Class UnixFS
Index
Constructors
constructor
- new
UnixFS(options?): UnixFS Parameters
options: UnixFSOptions = ...
Returns UnixFS
Properties
Private Optional _mode
_mode?: number
Private _original
_original
block
block
Optional data
Optional fanout
fanout?: bigint
Optional hash
hash
Optional mtime
type
type: string
Accessors
mode
- get mode(): undefined | number
Returns undefined | number
- set mode(mode): void
Parameters
mode: undefined | number
Returns void
Methods
add
file
is
marshal
- marshal(): Uint8Array
encode to protobuf Uint8Array
-Returns Uint8Array
remove
Static unmarshal
- unmarshal(marshaled): UnixFS
Decode from protobuf https://github.com/ipfs/specs/blob/master/UNIXFS.md
-Parameters
marshaled: Uint8Array
Returns UnixFS
Generated using TypeDoc
Class UnixFS
Index
Constructors
constructor
- new
UnixFS(options?): UnixFS Parameters
- options: UnixFSOptions = ...
Returns UnixFS
Properties
Private Optional _mode
_mode?: number
Private _original
_original
block
block
Optional data
Optional fanout
fanout?: bigint
Optional hash
hash
Optional mtime
type
type: string
Accessors
mode
- get mode(): undefined | number
Returns undefined | number
- set mode(mode): void
Parameters
- mode: undefined | number
Returns void
Methods
add
file
is
marshal
- marshal(): Uint8Array
encode to protobuf Uint8Array
+Returns Uint8Array
remove
Static unmarshal
- unmarshal(marshaled): UnixFS
Decode from protobuf https://github.com/ipfs/specs/blob/master/UNIXFS.md
+Parameters
- marshaled: Uint8Array
Returns UnixFS
Generated using TypeDoc
Function exporter
- exporter(path, blockstore, options?): Promise<UnixFSEntry>
Uses the given blockstore instance to fetch an IPFS node by a CID or path.
+exporter | UnixFS Function exporter
- exporter(path, blockstore, options?): Promise<UnixFSEntry>
Uses the given blockstore instance to fetch an IPFS node by a CID or path.
Returns a Promise which resolves to a UnixFSEntry.
-Parameters
path: string | CID<unknown, number, number, Version>
blockstore: ReadableStorage
options: ExporterOptions = {}
Returns Promise<UnixFSEntry>
Example
import { exporter } from 'ipfs-unixfs-exporter'
import { CID } from 'multiformats/cid'
const cid = CID.parse('QmFoo')
const entry = await exporter(cid, blockstore, {
signal: AbortSignal.timeout(50000)
})
if (entry.type === 'file') {
for await (const chunk of entry.content()) {
// chunk is a Uint8Array
}
} +Parameters
- path: string | CID<unknown, number, number, Version>
- blockstore: ReadableStorage
- options: ExporterOptions = {}
Returns Promise<UnixFSEntry>
Example
-import { exporter } from 'ipfs-unixfs-exporter'
import { CID } from 'multiformats/cid'
const cid = CID.parse('QmFoo')
const entry = await exporter(cid, blockstore, {
signal: AbortSignal.timeout(50000)
})
if (entry.type === 'file') {
for await (const chunk of entry.content()) {
// chunk is a Uint8Array
}
}
\ No newline at end of file +Generated using TypeDoc
Generated using TypeDoc
Function recursive
- recursive(path, blockstore, options?): AsyncGenerator<UnixFSEntry, void, any>
Returns an async iterator that yields all entries beneath a given CID or IPFS +
recursive | UnixFS Function recursive
- recursive(path, blockstore, options?): AsyncGenerator<UnixFSEntry, void, any>
Returns an async iterator that yields all entries beneath a given CID or IPFS path, as well as the containing directory.
-Parameters
path: string | CID<unknown, number, number, Version>
blockstore: ReadableStorage
options: ExporterOptions = {}
Returns AsyncGenerator<UnixFSEntry, void, any>
Example
import { recursive } from 'ipfs-unixfs-exporter'
const entries = []
for await (const child of recursive('Qmfoo/foo/bar', blockstore)) {
entries.push(entry)
}
// entries contains all children of the `Qmfoo/foo/bar` directory and it's children +Parameters
- path: string | CID<unknown, number, number, Version>
- blockstore: ReadableStorage
- options: ExporterOptions = {}
Returns AsyncGenerator<UnixFSEntry, void, any>
Example
-import { recursive } from 'ipfs-unixfs-exporter'
const entries = []
for await (const child of recursive('Qmfoo/foo/bar', blockstore)) {
entries.push(entry)
}
// entries contains all children of the `Qmfoo/foo/bar` directory and it's children
\ No newline at end of file +Generated using TypeDoc
Generated using TypeDoc
Function walkPath
- walk
Path(path, blockstore, options?): AsyncGenerator<UnixFSEntry, void, any> Returns an async iterator that yields entries for all segments in a path
-Parameters
path: string | CID<unknown, number, number, Version>
blockstore: ReadableStorage
options: ExporterOptions = {}
Returns AsyncGenerator<UnixFSEntry, void, any>
Example
import { walkPath } from 'ipfs-unixfs-exporter'
const entries = []
for await (const entry of walkPath('Qmfoo/foo/bar/baz.txt', blockstore)) {
entries.push(entry)
}
// entries contains 4x `entry` objects +walkPath | UnixFS Function walkPath
- walk
Path(path, blockstore, options?): AsyncGenerator<UnixFSEntry, void, any> Returns an async iterator that yields entries for all segments in a path
+Parameters
- path: string | CID<unknown, number, number, Version>
- blockstore: ReadableStorage
- options: ExporterOptions = {}
Returns AsyncGenerator<UnixFSEntry, void, any>
Example
-import { walkPath } from 'ipfs-unixfs-exporter'
const entries = []
for await (const entry of walkPath('Qmfoo/foo/bar/baz.txt', blockstore)) {
entries.push(entry)
}
// entries contains 4x `entry` objects
\ No newline at end of file +Generated using TypeDoc
Generated using TypeDoc
Function fixedSize
- fixed
Size(options?): Chunker Parameters
options: FixedSizeOptions = {}
Returns Chunker
Generated using TypeDoc
Function fixedSize
- fixed
Size(options?): Chunker Parameters
- options: FixedSizeOptions = {}
Returns Chunker
Generated using TypeDoc
Function rabin
- rabin(options?): Chunker
Parameters
options: RabinOptions = {}
Returns Chunker
Generated using TypeDoc
Function rabin
- rabin(options?): Chunker
Parameters
- options: RabinOptions = {}
Returns Chunker
Generated using TypeDoc
Function importByteStream
- import
Byte Stream(bufs, blockstore, options?): Promise<ImportResult> importByteStreamaccepts a single stream of Uint8Arrays and +importByteStream | UnixFS Function importByteStream
- import
Byte Stream(bufs, blockstore, options?): Promise<ImportResult>
-importByteStreamaccepts a single stream of Uint8Arrays and returns a promise of a singleImportResult.Parameters
bufs: ByteStream
blockstore: WritableStorage
options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
import { importByteStream } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = [
Uint8Array.from([0, 1, 2, 3, 4]),
Uint8Array.from([5, 6, 7, 8, 9])
]
const entry = await importByteStream(input, blockstore) +Parameters
- bufs: ByteStream
- blockstore: WritableStorage
- options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
-import { importByteStream } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = [
Uint8Array.from([0, 1, 2, 3, 4]),
Uint8Array.from([5, 6, 7, 8, 9])
]
const entry = await importByteStream(input, blockstore)
\ No newline at end of file +Generated using TypeDoc
- import
Generated using TypeDoc
Function importBytes
- import
Bytes(buf, blockstore, options?): Promise<ImportResult> importBytesaccepts a single Uint8Array and returns a promise +importBytes | UnixFS Function importBytes
- import
Bytes(buf, blockstore, options?): Promise<ImportResult>
-importBytesaccepts a single Uint8Array and returns a promise of a singleImportResult.Parameters
buf: ImportContent
blockstore: WritableStorage
options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
import { importBytes } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = Uint8Array.from([0, 1, 2, 3, 4])
const entry = await importBytes(input, blockstore) +Parameters
- buf: ImportContent
- blockstore: WritableStorage
- options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
-import { importBytes } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = Uint8Array.from([0, 1, 2, 3, 4])
const entry = await importBytes(input, blockstore)
\ No newline at end of file +Generated using TypeDoc
- import
Generated using TypeDoc
Function importDirectory
- import
Directory(content, blockstore, options?): Promise<ImportResult> importDiris similar toimporterexcept it accepts a single +importDirectory | UnixFS Function importDirectory
- import
Directory(content, blockstore, options?): Promise<ImportResult>
-importDiris similar toimporterexcept it accepts a singleDirectoryCandidateand returns a promise of a singleImportResultinstead of a stream of results.Parameters
content: DirectoryCandidate
blockstore: WritableStorage
options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
import { importDirectory } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input: DirectoryCandidate = {
path: './foo.txt'
}
const entry = await importDirectory(input, blockstore) +Parameters
- content: DirectoryCandidate
- blockstore: WritableStorage
- options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
-import { importDirectory } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input: DirectoryCandidate = {
path: './foo.txt'
}
const entry = await importDirectory(input, blockstore)
\ No newline at end of file +Generated using TypeDoc
- import
Generated using TypeDoc
Function importFile
- import
File(content, blockstore, options?): Promise<ImportResult> importFileis similar toimporterexcept it accepts a single +importFile | UnixFS Function importFile
- import
File(content, blockstore, options?): Promise<ImportResult>
-importFileis similar toimporterexcept it accepts a singleFileCandidateand returns a promise of a singleImportResultinstead of a stream of results.Parameters
content: FileCandidate<ImportContent>
blockstore: WritableStorage
options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
import { importFile } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input: FileCandidate = {
path: './foo.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}
const entry = await importFile(input, blockstore) +Parameters
- content: FileCandidate<ImportContent>
- blockstore: WritableStorage
- options: ImporterOptions = {}
Returns Promise<ImportResult>
Example
-import { importFile } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input: FileCandidate = {
path: './foo.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}
const entry = await importFile(input, blockstore)
\ No newline at end of file +Generated using TypeDoc
- import
Generated using TypeDoc
Function importer
- importer(source, blockstore, options?): AsyncGenerator<ImportResult, void, unknown>
The importer creates UnixFS DAGs and stores the blocks that make +
importer | UnixFS Function importer
- importer(source, blockstore, options?): AsyncGenerator<ImportResult, void, unknown>
The importer creates UnixFS DAGs and stores the blocks that make them up in the passed blockstore.
-Parameters
source: ImportCandidateStream
blockstore: WritableStorage
options: ImporterOptions = {}
Returns AsyncGenerator<ImportResult, void, unknown>
Example
import { importer } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = [{
path: './foo.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}, {
path: './bar.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}]
for await (const entry of importer(input, blockstore)) {
console.info(entry)
// { cid: CID(), ... }
} +Parameters
- source: ImportCandidateStream
- blockstore: WritableStorage
- options: ImporterOptions = {}
Returns AsyncGenerator<ImportResult, void, unknown>
Example
-import { importer } from 'ipfs-unixfs-importer'
import { MemoryBlockstore } from 'blockstore-core'
// store blocks in memory, other blockstores are available
const blockstore = new MemoryBlockstore()
const input = [{
path: './foo.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}, {
path: './bar.txt',
content: Uint8Array.from([0, 1, 2, 3, 4])
}]
for await (const entry of importer(input, blockstore)) {
console.info(entry)
// { cid: CID(), ... }
}
\ No newline at end of file +Generated using TypeDoc
Generated using TypeDoc
Function balanced
- balanced(options?): FileLayout
Parameters
Optionaloptions: BalancedOptions
Returns FileLayout
Generated using TypeDoc
Function balanced
- balanced(options?): FileLayout
Parameters
Optionaloptions: BalancedOptions
Returns FileLayout
Generated using TypeDoc
Function flat
- flat(): FileLayout
Returns FileLayout
Generated using TypeDoc
Function flat
- flat(): FileLayout
Returns FileLayout
Generated using TypeDoc
Function trickle
- trickle(options?): FileLayout
Parameters
Optionaloptions: TrickleOptions
Returns FileLayout
Generated using TypeDoc
Function trickle
- trickle(options?): FileLayout
Parameters
Optionaloptions: TrickleOptions
Returns FileLayout
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
UnixFS
+
UnixFS
Please be aware that all interactions related to this repo are subject to the IPFS Code of Conduct.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface UnixFSOptions
interface UnixFSOptions {
    blockSizes?: bigint[];
    data?: Uint8Array;
    fanout?: bigint;
    hashType?: bigint;
    mode?: number;
    mtime?: Mtime;
    type?: string;
}
    blockSizes?: bigint[];
    data?: Uint8Array;
    fanout?: bigint;
    hashType?: bigint;
    mode?: number;
    mtime?: Mtime;
    type?: string;
}
Properties
Optional block
block
Optional data
Optional fanout
fanout?: bigint
Optional hash
hash
Optional mode
mode?: number
Optional mtime
Optional type
type?: string
Generated using TypeDoc
Interface UnixFSOptions
interface UnixFSOptions {
    blockSizes?: bigint[];
    data?: Uint8Array;
    fanout?: bigint;
    hashType?: bigint;
    mode?: number;
    mtime?: Mtime;
    type?: string;
}
    blockSizes?: bigint[];
    data?: Uint8Array;
    fanout?: bigint;
    hashType?: bigint;
    mode?: number;
    mtime?: Mtime;
    type?: string;
}
Properties
Optional block
block
Optional data
Optional fanout
fanout?: bigint
Optional hash
hash
Optional mode
mode?: number
Optional mtime
Optional type
type?: string
Generated using TypeDoc
Interface ExportProgress
interface ExportProgress {
    bytesRead: bigint;
    fileSize: bigint;
    totalBytes: bigint;
}
    bytesRead: bigint;
    fileSize: bigint;
    totalBytes: bigint;
}
Index
Properties
Properties
bytes
bytes
How many bytes of the file have been read
-file
file
The size of the file being read - n.b. this may be +
Interface ExportProgress
interface ExportProgress {
    bytesRead: bigint;
    fileSize: bigint;
    totalBytes: bigint;
}
    bytesRead: bigint;
    fileSize: bigint;
    totalBytes: bigint;
}
Index
Properties
Properties
bytes
bytes
How many bytes of the file have been read
+file
file
The size of the file being read - n.b. this may be
larger than total if offset/length has been
specified
total
total
How many bytes of the file will be read - n.b. this may be +
total
total
How many bytes of the file will be read - n.b. this may be
smaller than fileSize if offset/length have been
specified
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface Exportable<T>
interface Exportable<T> {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    path: string;
    size: bigint;
    type: "object" | "file" | "directory" | "raw" | "identity";
    content(options?): AsyncGenerator<T, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    path: string;
    size: bigint;
    type: "object" | "file" | "directory" | "raw" | "identity";
    content(options?): AsyncGenerator<T, void, unknown>;
}
Type Parameters
Hierarchy (view full)
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "object" | "file" | "directory" | "raw" | "identity"
A disambiguator to allow TypeScript to work out the type of the entry.
+Interface Exportable<T>
interface Exportable<T> {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    path: string;
    size: bigint;
    type: "object" | "file" | "directory" | "raw" | "identity";
    content(options?): AsyncGenerator<T, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    path: string;
    size: bigint;
    type: "object" | "file" | "directory" | "raw" | "identity";
    content(options?): AsyncGenerator<T, void, unknown>;
}
Type Parameters
Hierarchy (view full)
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "object" | "file" | "directory" | "raw" | "identity"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
Methods
content
- content(options?): AsyncGenerator<T, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<T, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
Methods
content
- content(options?): AsyncGenerator<T, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<T, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Interface ExporterOptions
interface ExporterOptions {
    blockReadConcurrency?: number;
    length?: number;
    offset?: number;
    onProgress?: ((evt) => void);
    signal?: AbortSignal;
}
    blockReadConcurrency?: number;
    length?: number;
    offset?: number;
    onProgress?: ((evt) => void);
    signal?: AbortSignal;
}
Hierarchy
- ProgressOptions<ExporterProgressEvents>
- ExporterOptions
Index
Properties
Properties
Optional block
block
When a DAG layer is encountered, all child nodes are loaded in parallel but +
Interface ExporterOptions
interface ExporterOptions {
    blockReadConcurrency?: number;
    length?: number;
    offset?: number;
    onProgress?: ((evt) => void);
    signal?: AbortSignal;
}
    blockReadConcurrency?: number;
    length?: number;
    offset?: number;
    onProgress?: ((evt) => void);
    signal?: AbortSignal;
}
Hierarchy
- ProgressOptions<ExporterProgressEvents>
- ExporterOptions
Index
Properties
Properties
Optional block
block
When a DAG layer is encountered, all child nodes are loaded in parallel but
processed as they arrive. This allows us to load sibling nodes in advance
of yielding their bytes. Pass a value here to control the number of blocks
loaded in parallel. If a strict depth-first traversal is required, this
value should be set to 1, otherwise the traversal order will tend to
resemble a breadth-first fan-out and yield a have stable ordering.
(default: undefined)
Optional length
length?: number
An optional length to read.
+Optional length
length?: number
An optional length to read.
If the CID resolves to a file this will be the number of bytes read from the file, otherwise if it's a directory it will be the number of directory entries read from the directory listing. (default: undefined)
-Optional offset
offset?: number
An optional offset to start reading at.
+Optional offset
offset?: number
An optional offset to start reading at.
If the CID resolves to a file this will be a byte offset within that file, otherwise if it's a directory it will be a directory entry offset within the directory listing. (default: undefined)
-Optional on
on
Type declaration
- (evt): void
Parameters
Returns void
Optional signal
This signal can be used to abort any long-lived operations such as fetching +
Optional on
on
Type declaration
- (evt): void
Parameters
Returns void
Optional signal
This signal can be used to abort any long-lived operations such as fetching blocks from the network. (default: undefined)
-Generated using TypeDoc
Generated using TypeDoc
Interface IdentityNode
Entries with a identity codec CID return identity entries.
Interface IdentityNode
Entries with a identity codec CID return identity entries.
These are entries where the data payload is stored in the CID itself, otherwise they are identical to RawNodes.
-interface IdentityNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "identity";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "identity";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- IdentityNode
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-node
path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "identity"
A disambiguator to allow TypeScript to work out the type of the entry.
+interface IdentityNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "identity";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "identity";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- IdentityNode
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+node
path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "identity"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface ObjectNode
Entries with a dag-cbor or dag-json codec CID return JavaScript object entries
interface ObjectNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "object";
    content(options?): AsyncGenerator<any, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "object";
    content(options?): AsyncGenerator<any, void, unknown>;
}
Hierarchy (view full)
- Exportable<any>
- ObjectNode
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-node
path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "object"
A disambiguator to allow TypeScript to work out the type of the entry.
+Interface ObjectNode
Entries with a dag-cbor or dag-json codec CID return JavaScript object entries
interface ObjectNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "object";
    content(options?): AsyncGenerator<any, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "object";
    content(options?): AsyncGenerator<any, void, unknown>;
}
Hierarchy (view full)
- Exportable<any>
- ObjectNode
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+node
path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "object"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
Methods
content
- content(options?): AsyncGenerator<any, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<any, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
Methods
content
- content(options?): AsyncGenerator<any, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<any, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Interface RawNode
Entries with a raw codec CID return raw entries.
Interface RawNode
Entries with a raw codec CID return raw entries.
entry.content() returns an async iterator that yields a buffer containing the node content:
for await (const chunk of entry.content()) {
// chunk is a Buffer
}
Unless you an options object containing offset and length keys as an argument to entry.content(), chunk will be equal to entry.node.
interface RawNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "raw";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "raw";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- RawNode
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-node
path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "raw"
A disambiguator to allow TypeScript to work out the type of the entry.
+interface RawNode {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "raw";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: Uint8Array;
    path: string;
    size: bigint;
    type: "raw";
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- RawNode
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+node
path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "raw"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Interface Resolve
interface Resolve ((cid, name, path, toResolve, depth, blockstore, options) => Promise<ResolveResult>)
- Resolve(cid, name, path, toResolve, depth, blockstore, options): Promise<ResolveResult>
Parameters
cid: CID<unknown, number, number, Version>
name: string
path: string
toResolve: string[]
depth: number
blockstore: ReadableStorage
options: ExporterOptions
Returns Promise<ResolveResult>
Generated using TypeDoc
Interface Resolve
interface Resolve ((cid, name, path, toResolve, depth, blockstore, options) => Promise<ResolveResult>)
- Resolve(cid, name, path, toResolve, depth, blockstore, options): Promise<ResolveResult>
Parameters
- cid: CID<unknown, number, number, Version>
- name: string
- path: string
- toResolve: string[]
- depth: number
- blockstore: ReadableStorage
- options: ExporterOptions
Returns Promise<ResolveResult>
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface Resolver
interface Resolver ((cid, name, path, toResolve, resolve, depth, blockstore, options) => Promise<ResolveResult>)
- Resolver(cid, name, path, toResolve, resolve, depth, blockstore, options): Promise<ResolveResult>
Parameters
cid: CID<unknown, number, number, Version>
name: string
path: string
toResolve: string[]
resolve: Resolve
depth: number
blockstore: ReadableStorage
options: ExporterOptions
Returns Promise<ResolveResult>
Generated using TypeDoc
Interface Resolver
interface Resolver ((cid, name, path, toResolve, resolve, depth, blockstore, options) => Promise<ResolveResult>)
- Resolver(cid, name, path, toResolve, resolve, depth, blockstore, options): Promise<ResolveResult>
Parameters
- cid: CID<unknown, number, number, Version>
- name: string
- path: string
- toResolve: string[]
- resolve: Resolve
- depth: number
- blockstore: ReadableStorage
- options: ExporterOptions
Returns Promise<ResolveResult>
Generated using TypeDoc
Interface ShardTraversalContext
interface ShardTraversalContext {
    hamtDepth: number;
    lastBucket: Bucket<boolean>;
    rootBucket: Bucket<boolean>;
}
    hamtDepth: number;
    lastBucket: Bucket<boolean>;
    rootBucket: Bucket<boolean>;
}
Index
Properties
Properties
hamt
hamt
last
root
Generated using TypeDoc
Interface ShardTraversalContext
interface ShardTraversalContext {
    hamtDepth: number;
    lastBucket: Bucket<boolean>;
    rootBucket: Bucket<boolean>;
}
    hamtDepth: number;
    lastBucket: Bucket<boolean>;
    rootBucket: Bucket<boolean>;
}
Index
Properties
Properties
hamt
hamt
last
root
Generated using TypeDoc
Interface UnixFSDirectory
If the entry is a directory, entry.content() returns further entry objects:
Interface UnixFSDirectory
If the entry is a directory, entry.content() returns further entry objects:
if (entry.type === 'directory') {
for await (const entry of dir.content()) {
console.info(entry.name)
}
}
interface UnixFSDirectory {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "directory";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<UnixFSEntry, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "directory";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<UnixFSEntry, void, unknown>;
}
Hierarchy (view full)
- Exportable<UnixFSEntry>
- UnixFSDirectory
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-node
path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "directory"
A disambiguator to allow TypeScript to work out the type of the entry.
+interface UnixFSDirectory {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "directory";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<UnixFSEntry, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "directory";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<UnixFSEntry, void, unknown>;
}
Hierarchy (view full)
- Exportable<UnixFSEntry>
- UnixFSDirectory
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+node
path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "directory"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
unixfs
Methods
content
- content(options?): AsyncGenerator<UnixFSEntry, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<UnixFSEntry, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
unixfs
Methods
content
- content(options?): AsyncGenerator<UnixFSEntry, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<UnixFSEntry, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Interface UnixFSFile
If the entry is a file, entry.content() returns an async iterator that yields one or more Uint8Arrays containing the file content:
Interface UnixFSFile
If the entry is a file, entry.content() returns an async iterator that yields one or more Uint8Arrays containing the file content:
if (entry.type === 'file') {
for await (const chunk of entry.content()) {
// chunk is a Buffer
}
}
interface UnixFSFile {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "file";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "file";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- UnixFSFile
Properties
cid
The CID of the entry
-depth
depth: number
How far down the DAG the entry is
-name
name: string
The name of the entry
-node
path
path: string
The path of the entry within the DAG in which it was encountered
-size
size: bigint
The size of the entry
-type
type: "file"
A disambiguator to allow TypeScript to work out the type of the entry.
+interface UnixFSFile {
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "file";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
    cid: CID<unknown, number, number, Version>;
    depth: number;
    name: string;
    node: PBNode;
    path: string;
    size: bigint;
    type: "file";
    unixfs: UnixFS;
    content(options?): AsyncGenerator<Uint8Array, void, unknown>;
}
Hierarchy (view full)
- Exportable<Uint8Array>
- UnixFSFile
Properties
cid
The CID of the entry
+depth
depth: number
How far down the DAG the entry is
+name
name: string
The name of the entry
+node
path
path: string
The path of the entry within the DAG in which it was encountered
+size
size: bigint
The size of the entry
+type
type: "file"
A disambiguator to allow TypeScript to work out the type of the entry.
Example
if (entry.type === 'file') {
// access UnixFSFile properties safely
}
if (entry.type === 'directory') {
// access UnixFSDirectory properties safely
}
unixfs
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
+entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:
unixfs
Methods
content
- content(options?): AsyncGenerator<Uint8Array, void, unknown>
Parameters
Optionaloptions: ExporterOptions
Returns AsyncGenerator<Uint8Array, void, unknown>
Example: File content
When
entryis a file or arawnode,offsetand/orlengtharguments can be passed toentry.content()to return slices of data:const length = 5
const data = new Uint8Array(length)
let offset = 0
for await (const chunk of entry.content({
offset: 0,
length
})) {
data.set(chunk, offset)
offset += chunk.length
}
// `data` contains the first 5 bytes of the file
return dataExample: Directory content
If
entryis a directory, passingoffsetand/orlengthtoentry.content()will limit the number of files returned from the directory.
-const entries = []
for await (const entry of dir.content({
offset: 0,
length: 5
})) {
entries.push(entry)
}
// `entries` contains the first 5 files/directories in the directory
Generated using TypeDoc
Generated using TypeDoc
Interface UnixfsV1Resolver
interface UnixfsV1Resolver ((cid, node, unixfs, path, resolve, depth, blockstore) => ((options) => UnixfsV1Content))
- Unixfs
V1 Resolver(cid, node, unixfs, path, resolve, depth, blockstore): ((options) => UnixfsV1Content) Parameters
Returns ((options) => UnixfsV1Content)
- (options): UnixfsV1Content
Parameters
options: ExporterOptions
Returns UnixfsV1Content
Generated using TypeDoc
Interface UnixfsV1Resolver
interface UnixfsV1Resolver ((cid, node, unixfs, path, resolve, depth, blockstore) => ((options) => UnixfsV1Content))
- Unixfs
V1 Resolver(cid, node, unixfs, path, resolve, depth, blockstore): ((options) => UnixfsV1Content) Parameters
Returns ((options) => UnixfsV1Content)
- (options): UnixfsV1Content
Parameters
- options: ExporterOptions
Returns UnixfsV1Content
Generated using TypeDoc
Interface Chunker
- Chunker(source): AsyncIterable<Uint8Array>
Parameters
source: AsyncIterable<Uint8Array>
Returns AsyncIterable<Uint8Array>
Generated using TypeDoc
Interface Chunker
- Chunker(source): AsyncIterable<Uint8Array>
Parameters
- source: AsyncIterable<Uint8Array>
Returns AsyncIterable<Uint8Array>
Generated using TypeDoc
Interface BufferImporter
interface BufferImporter ((file, blockstore) => AsyncIterable<(() => Promise<BufferImporterResult>)>)
- Buffer
Importer(file, blockstore): AsyncIterable<(() => Promise<BufferImporterResult>)> Parameters
file: File
blockstore: WritableStorage
Returns AsyncIterable<(() => Promise<BufferImporterResult>)>
Generated using TypeDoc
Interface BufferImporter
interface BufferImporter ((file, blockstore) => AsyncIterable<(() => Promise<BufferImporterResult>)>)
- Buffer
Importer(file, blockstore): AsyncIterable<(() => Promise<BufferImporterResult>)> Parameters
- file: File
- blockstore: WritableStorage
Returns AsyncIterable<(() => Promise<BufferImporterResult>)>
Generated using TypeDoc
Interface BufferImporterResult
interface BufferImporterResult {
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- BufferImporterResult
Properties
block
cid
Optional path
path?: string
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface BufferImporterResult
interface BufferImporterResult {
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- BufferImporterResult
Properties
block
cid
Optional path
path?: string
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface Directory
interface Directory {
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
Index
Properties
Properties
Optional mode
mode?: number
Optional mtime
Optional original
original
Optional path
path?: string
Generated using TypeDoc
Interface Directory
interface Directory {
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
Index
Properties
Properties
Optional mode
mode?: number
Optional mtime
Optional original
original
Optional path
path?: string
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface File
interface File {
    content: AsyncIterable<Uint8Array>;
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
    content: AsyncIterable<Uint8Array>;
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
Index
Properties
Properties
content
Optional mode
mode?: number
Optional mtime
Optional original
original
Optional path
path?: string
Generated using TypeDoc
Interface File
interface File {
    content: AsyncIterable<Uint8Array>;
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
    content: AsyncIterable<Uint8Array>;
    mode?: number;
    mtime?: Mtime;
    originalPath?: string;
    path?: string;
}
Index
Properties
Properties
content
Optional mode
mode?: number
Optional mtime
Optional original
original
Optional path
path?: string
Generated using TypeDoc
Interface FileCandidate<T>
interface FileCandidate<T> {
    content: T;
    mode?: number;
    mtime?: Mtime;
    path?: string;
}
    content: T;
    mode?: number;
    mtime?: Mtime;
    path?: string;
}
Type Parameters
T extends ImportContent = ImportContent
Properties
content
Optional mode
mode?: number
Optional mtime
Optional path
path?: string
Generated using TypeDoc
Interface FileCandidate<T>
interface FileCandidate<T> {
    content: T;
    mode?: number;
    mtime?: Mtime;
    path?: string;
}
    content: T;
    mode?: number;
    mtime?: Mtime;
    path?: string;
}
Type Parameters
- T extends ImportContent = ImportContent
Properties
content
Optional mode
mode?: number
Optional mtime
Optional path
path?: string
Generated using TypeDoc
Interface HamtHashFn
- Hamt
Hash Fn(value): Promise<Uint8Array> Parameters
value: Uint8Array
Returns Promise<Uint8Array>
Generated using TypeDoc
Interface HamtHashFn
- Hamt
Hash Fn(value): Promise<Uint8Array> Parameters
- value: Uint8Array
Returns Promise<Uint8Array>
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Interface ImporterOptions
Options to control the importer's behaviour
-interface ImporterOptions {
    blockWriteConcurrency?: number;
    bufferImporter?: BufferImporter;
    chunkValidator?: ChunkValidator;
    chunker?: Chunker;
    cidVersion?: Version;
    dagBuilder?: DAGBuilder;
    fileImportConcurrency?: number;
    layout?: FileLayout;
    leafType?: "file" | "raw";
    onProgress?: ((evt) => void);
    rawLeaves?: boolean;
    reduceSingleLeafToSelf?: boolean;
    shardFanoutBits?: number;
    shardSplitThresholdBytes?: number;
    treeBuilder?: TreeBuilder;
    wrapWithDirectory?: boolean;
}
    blockWriteConcurrency?: number;
    bufferImporter?: BufferImporter;
    chunkValidator?: ChunkValidator;
    chunker?: Chunker;
    cidVersion?: Version;
    dagBuilder?: DAGBuilder;
    fileImportConcurrency?: number;
    layout?: FileLayout;
    leafType?: "file" | "raw";
    onProgress?: ((evt) => void);
    rawLeaves?: boolean;
    reduceSingleLeafToSelf?: boolean;
    shardFanoutBits?: number;
    shardSplitThresholdBytes?: number;
    treeBuilder?: TreeBuilder;
    wrapWithDirectory?: boolean;
}
Hierarchy
- ProgressOptions<ImporterProgressEvents>
- ImporterOptions
Properties
Optional block
block
How many blocks to hash and write to the block store concurrently. For small +
Interface ImporterOptions
Options to control the importer's behaviour
+interface ImporterOptions {
    blockWriteConcurrency?: number;
    bufferImporter?: BufferImporter;
    chunkValidator?: ChunkValidator;
    chunker?: Chunker;
    cidVersion?: Version;
    dagBuilder?: DAGBuilder;
    fileImportConcurrency?: number;
    layout?: FileLayout;
    leafType?: "file" | "raw";
    onProgress?: ((evt) => void);
    rawLeaves?: boolean;
    reduceSingleLeafToSelf?: boolean;
    shardFanoutBits?: number;
    shardSplitThresholdBytes?: number;
    treeBuilder?: TreeBuilder;
    wrapWithDirectory?: boolean;
}
    blockWriteConcurrency?: number;
    bufferImporter?: BufferImporter;
    chunkValidator?: ChunkValidator;
    chunker?: Chunker;
    cidVersion?: Version;
    dagBuilder?: DAGBuilder;
    fileImportConcurrency?: number;
    layout?: FileLayout;
    leafType?: "file" | "raw";
    onProgress?: ((evt) => void);
    rawLeaves?: boolean;
    reduceSingleLeafToSelf?: boolean;
    shardFanoutBits?: number;
    shardSplitThresholdBytes?: number;
    treeBuilder?: TreeBuilder;
    wrapWithDirectory?: boolean;
}
Hierarchy
- ProgressOptions<ImporterProgressEvents>
- ImporterOptions
Properties
Optional block
block
How many blocks to hash and write to the block store concurrently. For small numbers of large files this should be high (e.g. 50). Default: 50
-Optional buffer
This option can be used to override the importer internals.
+Optional buffer
This option can be used to override the importer internals.
This function should read Buffers from source and persist them using blockstore.put
or similar
entry is the { path, content } entry, where entry.content is an async
@@ -26,15 +26,15 @@
the properties { cid, unixfs, size } where cid is a [CID], unixfs is a [UnixFS] entry and size is a Number that represents the serialized size of the [IPLD] node that holds the buffer data.
Values will be pulled from this generator in parallel - the amount of
parallelisation is controlled by the blockWriteConcurrency option (default: 10)
Optional chunk
This option can be used to override the importer internals.
+Optional chunk
This option can be used to override the importer internals.
This function takes input from the content field of imported entries.
It should transform them into Buffers, throwing an error if it cannot.
It should yield Buffer objects constructed from the source or throw an
Error
Optional chunker
The chunking strategy. See ./src/chunker/index.ts +
Optional chunker
The chunking strategy. See ./src/chunker/index.ts for available chunkers. Default: fixedSize
-Optional cid
the CID version to use when storing the data. Default: 1
-Optional dag
This option can be used to override the importer internals.
+Optional cid
the CID version to use when storing the data. Default: 1
+Optional dag
This option can be used to override the importer internals.
This function should read { path, content } entries from source and turn them
into DAGs
It should yield a function that returns a Promise that resolves to
@@ -42,32 +42,32 @@
is a UnixFS entry and node is a DAGNode.
Values will be pulled from this generator in parallel - the amount of parallelisation
is controlled by the fileImportConcurrency option (default: 50)
Optional file
file
How many files to import concurrently. For large numbers of small files this +
Optional file
file
How many files to import concurrently. For large numbers of small files this should be high (e.g. 50). Default: 10
-Optional layout
How the DAG that represents files are created. See +
Optional layout
How the DAG that represents files are created. See ./src/layout/index.ts for available layouts. Default: balanced
-Optional leaf
leaf
What type of UnixFS node leaves should be - can be 'file' or 'raw'
+
Optional leaf
leaf
What type of UnixFS node leaves should be - can be 'file' or 'raw'
(ignored when rawLeaves is true).
This option exists to simulate kubo's trickle dag which uses a combination
of 'raw' UnixFS leaves and reduceSingleLeafToSelf: false.
For modern code the rawLeaves: true option should be used instead so leaves
are plain Uint8Arrays without a UnixFS/Protobuf wrapper.
Optional on
on
Type declaration
- (evt): void
Parameters
Returns void
Optional raw
raw
When a file would span multiple DAGNodes, if this is true the leaf nodes +
Optional on
on
Type declaration
- (evt): void
Parameters
Returns void
Optional raw
raw
When a file would span multiple DAGNodes, if this is true the leaf nodes
will not be wrapped in UnixFS protobufs and will instead contain the
raw file bytes. Default: true
Optional reduce
reduce
If the file being imported is small enough to fit into one DAGNodes, store +
Optional reduce
reduce
If the file being imported is small enough to fit into one DAGNodes, store the file data in the root node along with the UnixFS metadata instead of in a leaf node which would then require additional I/O to load. Default: true
-Optional shard
shard
The number of bits of a hash digest used at each level of sharding to +
Optional shard
shard
The number of bits of a hash digest used at each level of sharding to the child index. 2**shardFanoutBits will dictate the maximum number of children for any shard in the HAMT. Default: 8
-Optional shard
shard
If the serialized node is larger than this it might be converted to a HAMT +
Optional shard
shard
If the serialized node is larger than this it might be converted to a HAMT sharded directory. Default: 256KiB
-Optional tree
This option can be used to override the importer internals.
+Optional tree
This option can be used to override the importer internals.
This function should read { cid, path, unixfs, node } entries from source and
place them in a directory structure
It should yield an object with the properties { cid, path, unixfs, size } where
cid is a CID, path is a string, unixfs is a UnixFS entry and size is a Number.
Optional wrap
wrap
If true, all imported files and folders will be contained in a directory that +
Optional wrap
wrap
If true, all imported files and folders will be contained in a directory that will correspond to the CID of the final entry yielded. Default: false
-Generated using TypeDoc
Generated using TypeDoc
Interface MultipleBlockImportResult
interface MultipleBlockImportResult {
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- MultipleBlockImportResult
Index
Properties
Properties
cid
Optional original
original
Optional path
path?: string
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface MultipleBlockImportResult
interface MultipleBlockImportResult {
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- MultipleBlockImportResult
Index
Properties
Properties
cid
Optional original
original
Optional path
path?: string
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface SingleBlockImportResult
interface SingleBlockImportResult {
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    single: true;
    size: bigint;
    unixfs?: UnixFS;
}
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    single: true;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- SingleBlockImportResult
Properties
block
cid
Optional original
original
Optional path
path?: string
single
single: true
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface SingleBlockImportResult
interface SingleBlockImportResult {
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    single: true;
    size: bigint;
    unixfs?: UnixFS;
}
    block: Uint8Array;
    cid: CID<unknown, number, number, Version>;
    originalPath?: string;
    path?: string;
    single: true;
    size: bigint;
    unixfs?: UnixFS;
}
Hierarchy (view full)
- ImportResult
- SingleBlockImportResult
Properties
block
cid
Optional original
original
Optional path
path?: string
single
single: true
size
size: bigint
Optional unixfs
Generated using TypeDoc
Interface TreeBuilder
- Tree
Builder(source, blockstore): AsyncIterable<ImportResult> Parameters
source: AsyncIterable<InProgressImportResult>
blockstore: WritableStorage
Returns AsyncIterable<ImportResult>
Generated using TypeDoc
Interface TreeBuilder
- Tree
Builder(source, blockstore): AsyncIterable<ImportResult> Parameters
- source: AsyncIterable<InProgressImportResult>
- blockstore: WritableStorage
Returns AsyncIterable<ImportResult>
Generated using TypeDoc
Interface FileLayout
- File
Layout(source, reducer): Promise<InProgressImportResult> Parameters
source: AsyncIterable<InProgressImportResult> | Iterable<InProgressImportResult>
reducer: Reducer
Returns Promise<InProgressImportResult>
Generated using TypeDoc
Interface FileLayout
- File
Layout(source, reducer): Promise<InProgressImportResult> Parameters
- source: AsyncIterable<InProgressImportResult> | Iterable<InProgressImportResult>
- reducer: Reducer
Returns Promise<InProgressImportResult>
Generated using TypeDoc
Interface Reducer
- Reducer(leaves): Promise<InProgressImportResult>
Parameters
leaves: InProgressImportResult[]
Returns Promise<InProgressImportResult>
Generated using TypeDoc
Interface Reducer
- Reducer(leaves): Promise<InProgressImportResult>
Parameters
- leaves: InProgressImportResult[]
Returns Promise<InProgressImportResult>
Generated using TypeDoc
Module ipfs-unixfs
This module contains the protobuf definition of the UnixFS data structure found at the root of all UnixFS DAGs.
+Module ipfs-unixfs
This module contains the protobuf definition of the UnixFS data structure found at the root of all UnixFS DAGs.
The UnixFS spec can be found in the ipfs/specs repository
Example: Create a file composed of several blocks
const data = new UnixFS({ type: 'file' })
data.addBlockSize(256) // add the size of each block
data.addBlockSize(256)
// ...
Example: Is this UnixFS entry a directory?
const file = new Data({ type: 'file' })
file.mtime // undefined
Object.prototype.hasOwnProperty.call(file, 'mtime') // false
const dir = new Data({ type: 'dir', mtime: new Date() })
dir.mtime // { secs: Number, nsecs: Number }
Index
Classes
UnixFS
-
Interfaces
Type Aliases
Generated using TypeDoc
Index
Classes
UnixFS
+
Interfaces
Type Aliases
Generated using TypeDoc
Module ipfs-unixfs-exporter
The UnixFS Exporter provides a means to read DAGs from a blockstore given a CID.
+Module ipfs-unixfs-exporter
The UnixFS Exporter provides a means to read DAGs from a blockstore given a CID.
Example
// import a file and export it again
import { importer } from 'ipfs-unixfs-importer'
import { exporter } from 'ipfs-unixfs-exporter'
import { MemoryBlockstore } from 'blockstore-core/memory'
// Should contain the blocks we are trying to export
const blockstore = new MemoryBlockstore()
const files = []
for await (const file of importer([{
path: '/foo/bar.txt',
content: new Uint8Array([0, 1, 2, 3])
}], blockstore)) {
files.push(file)
}
console.info(files[0].cid) // Qmbaz
const entry = await exporter(files[0].cid, blockstore)
console.info(entry.cid) // Qmqux
console.info(entry.path) // Qmbaz/foo/bar.txt
console.info(entry.name) // bar.txt
console.info(entry.unixfs.fileSize()) // 4
// stream content from unixfs node
const size = entry.unixfs.fileSize()
const bytes = new Uint8Array(size)
let offset = 0
for await (const buf of entry.content()) {
bytes.set(buf, offset)
offset += chunk.length
}
console.info(bytes) // 0, 1, 2, 3
Index
Interfaces
Type Aliases
Functions
Generated using TypeDoc
Index
Interfaces
Type Aliases
Functions
Generated using TypeDoc
Generated using TypeDoc
Module ipfs-unixfs-importer
ipfs-unixfs-importer
+
Module ipfs-unixfs-importer
ipfs-unixfs-importer
-JavaScript implementation of the UnixFs importer used by IPFS
About
Example
Let's create a little directory to import:
+About
+ +Example
Let's create a little directory to import:
> cd /tmp
> mkdir foo
> echo 'hello' > foo/bar
> echo 'world' > foo/quux
And write the importing logic:
@@ -32,7 +47,7 @@Please be aware that all interactions related to this repo are subject to the IPFS Code of Conduct.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
Index
Modules
Generated using TypeDoc
Index
Modules
Generated using TypeDoc
Module index
Example
Let's create a little directory to import:
+Module index
Example
Let's create a little directory to import:
> cd /tmp
> mkdir foo
> echo 'hello' > foo/bar
> echo 'world' > foo/quux
And write the importing logic:
@@ -7,28 +7,28 @@When run, metadata about DAGNodes in the created tree is printed until the root:
{
cid: CID, // see https://github.com/multiformats/js-cid
path: 'tmp/foo/bar',
unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
}
{
cid: CID, // see https://github.com/multiformats/js-cid
path: 'tmp/foo/quxx',
unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
}
{
cid: CID, // see https://github.com/multiformats/js-cid
path: 'tmp/foo',
unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
}
{
cid: CID, // see https://github.com/multiformats/js-cid
path: 'tmp',
unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
}
Index
Interfaces
Type Aliases
Functions
Generated using TypeDoc
Index
Interfaces
Type Aliases
Functions
Generated using TypeDoc
Module layout
Layout functions allow customising the shape of final DAGs
+Module layout
Layout functions allow customising the shape of final DAGs
https://dag.ipfs.tech can be used to explore different conigurations.
-Index
Interfaces
Functions
Generated using TypeDoc
Index
Interfaces
Functions
Generated using TypeDoc
Generated using TypeDoc
Generated using TypeDoc
Type alias ExporterProgressEvents
Exporter
Progress events emitted by the exporter
-Generated using TypeDoc
Type alias ExporterProgressEvents
Exporter
Progress events emitted by the exporter
+Generated using TypeDoc
Type alias ReadableStorage
A subset of the Blockstore interface that just contains the get +
Type alias ReadableStorage
A subset of the Blockstore interface that just contains the get method.
-Generated using TypeDoc
Generated using TypeDoc
Type alias UnixFSEntry
A UnixFSEntry is a representation of the types of node that can be +
Type alias UnixFSEntry
A UnixFSEntry is a representation of the types of node that can be encountered in a DAG.
-Generated using TypeDoc
Generated using TypeDoc
Type alias UnixfsV1Content
Generated using TypeDoc
Type alias UnixfsV1Content
Generated using TypeDoc
Type alias UnixfsV1DirectoryContent
Generated using TypeDoc
Type alias UnixfsV1DirectoryContent
Generated using TypeDoc
Type alias UnixfsV1FileContent
Generated using TypeDoc
Type alias UnixfsV1FileContent
Generated using TypeDoc
Type alias ByteStream
Generated using TypeDoc
Type alias ByteStream
Generated using TypeDoc
Type alias ImportCandidate
Generated using TypeDoc
Type alias ImportCandidate
Generated using TypeDoc
Type alias ImportCandidateStream
Import
Generated using TypeDoc
Type alias ImportCandidateStream
Import
Generated using TypeDoc
Type alias ImportContent
Generated using TypeDoc
Type alias ImportContent
Generated using TypeDoc
Type alias ImporterProgressEvents
Importer
Generated using TypeDoc
Type alias ImporterProgressEvents
Importer
Generated using TypeDoc
Type alias InProgressImportResult
Generated using TypeDoc
Type alias InProgressImportResult
Generated using TypeDoc
Type alias WritableStorage
Generated using TypeDoc
Type alias WritableStorage
Generated using TypeDoc
Returns
-0nfor directories ordata.length + sum(blockSizes)for everything else