@autonomys/auto-dag-data 0.8.2

package/dist/ipld/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/ipld/builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAYnC,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACpF,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/B,IAAI,EAAE,CACJ,KAAK,EAAE,GAAG,EAAE,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,iBAAiB,CAAC,EAAE,iBAAiB,KAClC,MAAM,CAAA;IACX,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,KAAK,MAAM,CAAA;CAC3F;AACD,eAAO,MAAM,gBAAgB,EAAE,QAK9B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,QAK1B,CAAA"}

package/dist/ipld/builders.js

@@ -0,0 +1,13 @@
+import { createChunkedFileIpldNode, createChunkedMetadataIpldNode, createFileChunkIpldNode, createFileInlinkIpldNode, createMetadataChunkIpldNode, createMetadataInlinkIpldNode, createSingleFileIpldNode, createSingleMetadataIpldNode, } from './nodes.js';
+export const metadataBuilders = {
+    inlink: createMetadataInlinkIpldNode,
+    chunk: createMetadataChunkIpldNode,
+    root: createChunkedMetadataIpldNode,
+    single: createSingleMetadataIpldNode,
+};
+export const fileBuilders = {
+    inlink: createFileInlinkIpldNode,
+    chunk: createFileChunkIpldNode,
+    root: createChunkedFileIpldNode,
+    single: createSingleFileIpldNode,
+};

package/dist/ipld/chunker.d.ts

@@ -0,0 +1,30 @@
+import type { BaseBlockstore } from 'blockstore-core';
+import type { AwaitIterable } from 'interface-store';
+import { CID } from 'multiformats';
+import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js';
+import { Builders } from './builders.js';
+import { PBNode } from './utils.js';
+type ChunkerLimits = {
+    maxChunkSize: number;
+    maxLinkPerNode: number;
+};
+type ChunkerOptions = ChunkerLimits & FileUploadOptions;
+export declare const DEFAULT_MAX_CHUNK_SIZE: number;
+export declare const DEFAULT_MAX_LINK_PER_NODE: number;
+export declare const processFileToIPLDFormat: (blockstore: BaseBlockstore, file: AwaitIterable<Buffer>, totalSize: number, filename?: string, { maxChunkSize, maxLinkPerNode, encryption, compression, }?: Partial<ChunkerOptions>) => Promise<CID>;
+export declare const processMetadataToIPLDFormat: (blockstore: BaseBlockstore, metadata: OffchainMetadata, limits?: {
+    maxChunkSize: number;
+    maxLinkPerNode: number;
+}) => Promise<CID>;
+export declare const processBufferToIPLDFormatFromChunks: (blockstore: BaseBlockstore, chunks: AwaitIterable<CID>, filename: string | undefined, totalSize: number, builders: Builders, { maxChunkSize, maxLinkPerNode, encryption, compression, }?: Partial<ChunkerOptions>) => Promise<CID>;
+export declare const processFolderToIPLDFormat: (blockstore: BaseBlockstore, children: CID[], name: string, size: number, { maxLinkPerNode, maxChunkSize, compression, encryption, }?: Partial<ChunkerOptions>) => Promise<CID>;
+/**
+ * Process chunks to IPLD format, return the last chunk if it's not full
+ * @returns the last chunk if it's not full, otherwise an empty buffer
+ */
+export declare const processChunksToIPLDFormat: (blockstore: BaseBlockstore, chunks: AwaitIterable<Buffer>, builders: Builders, { maxChunkSize }: {
+    maxChunkSize?: number;
+}) => Promise<Buffer>;
+export declare const ensureNodeMaxSize: (node: PBNode, maxSize?: number) => PBNode;
+export {};
+//# sourceMappingURL=chunker.d.ts.map

package/dist/ipld/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/ipld/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAsB,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC9F,OAAO,EAAE,QAAQ,EAAkC,MAAM,eAAe,CAAA;AAExE,OAAO,EAA2B,MAAM,EAAE,MAAM,YAAY,CAAA;AAE5D,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,cAAc,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEvD,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAG/C,eAAO,MAAM,yBAAyB,QAAwD,CAAA;AAE9F,eAAO,MAAM,uBAAuB,eACtB,cAAc,QACpB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,aACN,MAAM,+DAMd,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAOb,CAAA;AAED,eAAO,MAAM,2BAA2B,eAC1B,cAAc,YAChB,gBAAgB,WAClB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAIvD,OAAO,CAAC,GAAG,CAab,CAAA;AAsCD,eAAO,MAAM,mCAAmC,eAClC,cAAc,UAClB,aAAa,CAAC,GAAG,CAAC,YAChB,MAAM,GAAG,SAAS,aACjB,MAAM,YACP,QAAQ,+DAMf,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CA4Cb,CAAA;AAED,eAAO,MAAM,yBAAyB,eACxB,cAAc,YAChB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,+DAMT,OAAO,CAAC,cAAc,CAAC,KAMzB,OAAO,CAAC,GAAG,CAwBb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,eACxB,cAAc,UAClB,aAAa,CAAC,MAAM,CAAC,YACnB,QAAQ,oBACyB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACnE,OAAO,CAAC,MAAM,CAchB,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACH,MAAM,KACd,MAOF,CAAA"}

package/dist/ipld/chunker.js

@@ -0,0 +1,219 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { cidOfNode } from '../cid/index.js';
+import { decodeIPLDNodeData } from '../metadata/index.js';
+import { fileBuilders, metadataBuilders } from './builders.js';
+import { createFolderInlinkIpldNode, createFolderIpldNode } from './nodes.js';
+import { chunkBuffer, encodeNode } from './utils.js';
+export const DEFAULT_MAX_CHUNK_SIZE = 64 * 1024;
+const ESTIMATED_LINK_SIZE_IN_BYTES = 64;
+export const DEFAULT_MAX_LINK_PER_NODE = DEFAULT_MAX_CHUNK_SIZE / ESTIMATED_LINK_SIZE_IN_BYTES;
+export const processFileToIPLDFormat = (blockstore, file, totalSize, filename, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
+}) => {
+    return processBufferToIPLDFormat(blockstore, file, filename, totalSize, fileBuilders, {
+        maxChunkSize,
+        maxLinkPerNode,
+        encryption,
+        compression,
+    });
+};
+export const processMetadataToIPLDFormat = (blockstore_1, metadata_1, ...args_1) => __awaiter(void 0, [blockstore_1, metadata_1, ...args_1], void 0, function* (blockstore, metadata, limits = {
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+}) {
+    const buffer = Buffer.from(JSON.stringify(metadata));
+    const name = `${metadata.name}.metadata.json`;
+    return processBufferToIPLDFormat(blockstore, (function () {
+        return __asyncGenerator(this, arguments, function* () {
+            yield yield __await(buffer);
+        });
+    })(), name, buffer.byteLength, metadataBuilders, limits);
+});
+const processBufferToIPLDFormat = (blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, buffer_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, buffer, filename, totalSize, builders, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
+}) {
+    var _a, e_1, _b, _c;
+    const bufferChunks = chunkBuffer(buffer, { maxChunkSize: maxChunkSize });
+    let CIDs = [];
+    try {
+        for (var _d = true, bufferChunks_1 = __asyncValues(bufferChunks), bufferChunks_1_1; bufferChunks_1_1 = yield bufferChunks_1.next(), _a = bufferChunks_1_1.done, !_a; _d = true) {
+            _c = bufferChunks_1_1.value;
+            _d = false;
+            const chunk = _c;
+            const node = builders.chunk(chunk);
+            const cid = cidOfNode(node);
+            yield blockstore.put(cid, encodeNode(node));
+            CIDs.push(cid);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = bufferChunks_1.return)) yield _b.call(bufferChunks_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return processBufferToIPLDFormatFromChunks(blockstore, CIDs, filename, totalSize, builders, {
+        maxLinkPerNode,
+        maxChunkSize,
+        encryption,
+        compression,
+    });
+});
+export const processBufferToIPLDFormatFromChunks = (blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1) => __awaiter(void 0, [blockstore_1, chunks_1, filename_1, totalSize_1, builders_1, ...args_1], void 0, function* (blockstore, chunks, filename, totalSize, builders, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, encryption = undefined, compression = undefined, } = {
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    encryption: undefined,
+    compression: undefined,
+}) {
+    var _a, chunks_2, chunks_2_1;
+    var _b, e_2, _c, _d;
+    let chunkCount = 0;
+    let CIDs = [];
+    try {
+        for (_a = true, chunks_2 = __asyncValues(chunks); chunks_2_1 = yield chunks_2.next(), _b = chunks_2_1.done, !_b; _a = true) {
+            _d = chunks_2_1.value;
+            _a = false;
+            const chunk = _d;
+            CIDs.push(chunk);
+            chunkCount++;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = chunks_2.return)) yield _c.call(chunks_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (CIDs.length === 1) {
+        const nodeBytes = yield blockstore.get(CIDs[0]);
+        yield blockstore.delete(CIDs[0]);
+        const data = decodeIPLDNodeData(nodeBytes);
+        const singleNode = builders.single(Buffer.from(data.data), filename, {
+            compression,
+            encryption,
+        });
+        yield blockstore.put(cidOfNode(singleNode), encodeNode(singleNode));
+        const headCID = cidOfNode(singleNode);
+        return headCID;
+    }
+    let depth = 1;
+    while (CIDs.length > maxLinkPerNode) {
+        const newCIDs = [];
+        for (let i = 0; i < CIDs.length; i += maxLinkPerNode) {
+            const chunk = CIDs.slice(i, i + maxLinkPerNode);
+            const node = builders.inlink(chunk, chunk.length, depth, maxChunkSize);
+            const cid = cidOfNode(node);
+            yield blockstore.put(cid, encodeNode(node));
+            newCIDs.push(cid);
+        }
+        depth++;
+        CIDs = newCIDs;
+    }
+    const head = builders.root(CIDs, totalSize, depth, filename, maxChunkSize, {
+        compression,
+        encryption,
+    });
+    const headCID = cidOfNode(head);
+    yield blockstore.put(headCID, encodeNode(head));
+    return headCID;
+});
+export const processFolderToIPLDFormat = (blockstore_1, children_1, name_1, size_1, ...args_1) => __awaiter(void 0, [blockstore_1, children_1, name_1, size_1, ...args_1], void 0, function* (blockstore, children, name, size, { maxLinkPerNode = DEFAULT_MAX_LINK_PER_NODE, maxChunkSize = DEFAULT_MAX_CHUNK_SIZE, compression = undefined, encryption = undefined, } = {
+    maxLinkPerNode: DEFAULT_MAX_LINK_PER_NODE,
+    maxChunkSize: DEFAULT_MAX_CHUNK_SIZE,
+    compression: undefined,
+    encryption: undefined,
+}) {
+    let cids = children;
+    let depth = 0;
+    while (cids.length > maxLinkPerNode) {
+        const newCIDs = [];
+        for (let i = 0; i < cids.length; i += maxLinkPerNode) {
+            const chunk = cids.slice(i, i + maxLinkPerNode);
+            const node = createFolderInlinkIpldNode(chunk, depth);
+            const cid = cidOfNode(node);
+            yield blockstore.put(cid, encodeNode(node));
+            newCIDs.push(cid);
+        }
+        cids = newCIDs;
+        depth++;
+    }
+    const node = createFolderIpldNode(cids, name, depth, size, maxChunkSize, {
+        compression,
+        encryption,
+    });
+    const cid = cidOfNode(node);
+    yield blockstore.put(cid, encodeNode(node));
+    return cid;
+});
+/**
+ * Process chunks to IPLD format, return the last chunk if it's not full
+ * @returns the last chunk if it's not full, otherwise an empty buffer
+ */
+export const processChunksToIPLDFormat = (blockstore_1, chunks_1, builders_1, _a) => __awaiter(void 0, [blockstore_1, chunks_1, builders_1, _a], void 0, function* (blockstore, chunks, builders, { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE }) {
+    var _b, e_3, _c, _d;
+    const bufferChunks = chunkBuffer(chunks, { maxChunkSize, ignoreLastChunk: false });
+    try {
+        for (var _e = true, bufferChunks_2 = __asyncValues(bufferChunks), bufferChunks_2_1; bufferChunks_2_1 = yield bufferChunks_2.next(), _b = bufferChunks_2_1.done, !_b; _e = true) {
+            _d = bufferChunks_2_1.value;
+            _e = false;
+            const chunk = _d;
+            if (chunk.byteLength < maxChunkSize) {
+                return chunk;
+            }
+            const node = builders.chunk(chunk);
+            const cid = cidOfNode(node);
+            yield blockstore.put(cid, encodeNode(node));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (!_e && !_b && (_c = bufferChunks_2.return)) yield _c.call(bufferChunks_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return Buffer.alloc(0);
+});
+export const ensureNodeMaxSize = (node, maxSize = DEFAULT_MAX_CHUNK_SIZE) => {
+    const nodeSize = encodeNode(node).byteLength;
+    if (nodeSize > maxSize) {
+        throw new Error(`Node is too large to fit in a single chunk: ${nodeSize} > ${maxSize}`);
+    }
+    return node;
+};

package/dist/ipld/index.d.ts

@@ -0,0 +1,5 @@
+export * from './builders.js';
+export * from './chunker.js';
+export * from './nodes.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ipld/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ipld/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/dist/ipld/index.js

@@ -0,0 +1,4 @@
+export * from './builders.js';
+export * from './chunker.js';
+export * from './nodes.js';
+export * from './utils.js';

package/dist/ipld/nodes.d.ts

@@ -0,0 +1,15 @@
+import { CID } from 'multiformats/cid';
+import { FileUploadOptions, OffchainMetadata } from '../metadata/index.js';
+import { PBNode } from './index.js';
+export declare const createFileChunkIpldNode: (data: Buffer) => PBNode;
+export declare const createChunkedFileIpldNode: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number, uploadOptions?: FileUploadOptions) => PBNode;
+export declare const createFileInlinkIpldNode: (links: CID[], size: number, linkDepth: number, maxNodeSize?: number) => PBNode;
+export declare const createSingleFileIpldNode: (data: Buffer, name?: string, uploadOptions?: FileUploadOptions) => PBNode;
+export declare const createMetadataInlinkIpldNode: (links: CID[], size: number, linkDepth: number, maxNodeSize?: number) => PBNode;
+export declare const createSingleMetadataIpldNode: (data: Buffer, name?: string) => PBNode;
+export declare const createMetadataChunkIpldNode: (data: Buffer) => PBNode;
+export declare const createChunkedMetadataIpldNode: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number) => PBNode;
+export declare const createFolderIpldNode: (links: CID[], name: string, linkDepth: number, size: number, maxNodeSize?: number, uploadOptions?: FileUploadOptions) => PBNode;
+export declare const createFolderInlinkIpldNode: (links: CID[], linkDepth: number, maxNodeSize?: number) => PBNode;
+export declare const createMetadataNode: (metadata: OffchainMetadata, maxNodeSize?: number) => PBNode;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/ipld/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/ipld/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG1E,OAAO,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAG/C,eAAO,MAAM,uBAAuB,SAAU,MAAM,KAAG,MASpD,CAAA;AAKH,eAAO,MAAM,yBAAyB,UAC7B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,kBACH,iBAAiB,KAChC,MAaA,CAAA;AAGH,eAAO,MAAM,wBAAwB,UAC5B,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,wBAAwB,SAC7B,MAAM,SACL,MAAM,kBACG,iBAAiB,KAChC,MAWA,CAAA;AAKH,eAAO,MAAM,4BAA4B,UAChC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,gBACJ,MAAM,KAClB,MAWA,CAAA;AAKH,eAAO,MAAM,4BAA4B,SAAU,MAAM,SAAS,MAAM,KAAG,MAUxE,CAAA;AAEH,eAAO,MAAM,2BAA2B,SAAU,MAAM,KAAG,MAQxD,CAAA;AAEH,eAAO,MAAM,6BAA6B,UACjC,GAAG,EAAE,QACN,MAAM,aACD,MAAM,SACV,MAAM,gBACA,MAAM,KAClB,MAYA,CAAA;AAKH,eAAO,MAAM,oBAAoB,UACxB,GAAG,EAAE,QACN,MAAM,aACD,MAAM,QACX,MAAM,gBACC,MAAM,kBACH,iBAAiB,KAChC,MAaA,CAAA;AAEH,eAAO,MAAM,0BAA0B,UAC9B,GAAG,EAAE,aACD,MAAM,gBACJ,MAAM,KAClB,MAUA,CAAA;AAGH,eAAO,MAAM,kBAAkB,aACnB,gBAAgB,gBACb,MAAM,KAClB,MAcF,CAAA"}

package/dist/ipld/nodes.js

@@ -0,0 +1,92 @@
+import { encodeIPLDNodeData, MetadataType } from '../metadata/onchain/index.js';
+import { DEFAULT_MAX_CHUNK_SIZE, ensureNodeMaxSize } from './chunker.js';
+import { createNode } from './index.js';
+/// Creates a file chunk ipld node
+export const createFileChunkIpldNode = (data) => createNode(encodeIPLDNodeData({
+    type: MetadataType.FileChunk,
+    size: data.length,
+    linkDepth: 0,
+    data,
+}), []);
+// Creates a file ipld node
+// links: the CIDs of the file's contents
+// @todo: add the file's metadata
+export const createChunkedFileIpldNode = (links, size, linkDepth, name, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE, uploadOptions) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.File,
+    name,
+    size,
+    linkDepth,
+    uploadOptions,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+// Creates a file ipld node
+// links: the CIDs of the file's contents
+export const createFileInlinkIpldNode = (links, size, linkDepth, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.FileInlink,
+    size,
+    linkDepth,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+// Creates a file ipld node
+// links: the CIDs of the file's contents
+// @todo: add the file's metadata
+export const createSingleFileIpldNode = (data, name, uploadOptions) => createNode(encodeIPLDNodeData({
+    type: MetadataType.File,
+    name,
+    size: data.length,
+    linkDepth: 0,
+    data,
+    uploadOptions,
+}), []);
+// Creates a file ipld node
+// links: the CIDs of the file's contents
+// @todo: add the file's metadata
+export const createMetadataInlinkIpldNode = (links, size, linkDepth, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.FileInlink,
+    size,
+    linkDepth,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+// Creates a file ipld node
+// links: the CIDs of the file's contents
+// @todo: add the file's metadata
+export const createSingleMetadataIpldNode = (data, name) => createNode(encodeIPLDNodeData({
+    type: MetadataType.Metadata,
+    name,
+    size: data.length,
+    linkDepth: 0,
+    data,
+}), []);
+export const createMetadataChunkIpldNode = (data) => createNode(encodeIPLDNodeData({
+    type: MetadataType.MetadataChunk,
+    size: data.length,
+    linkDepth: 0,
+    data,
+}));
+export const createChunkedMetadataIpldNode = (links, size, linkDepth, name, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.Metadata,
+    name,
+    size,
+    linkDepth,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+// Creates a folder ipld node
+// links: the CIDs of the folder's contents
+// @todo: add the folder's metadata
+export const createFolderIpldNode = (links, name, linkDepth, size, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE, uploadOptions) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.Folder,
+    name,
+    size,
+    linkDepth,
+    uploadOptions,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+export const createFolderInlinkIpldNode = (links, linkDepth, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+    type: MetadataType.FolderInlink,
+    linkDepth,
+}), links.map((cid) => ({ Hash: cid }))), maxNodeSize);
+/// Creates a metadata ipld node
+export const createMetadataNode = (metadata, maxNodeSize = DEFAULT_MAX_CHUNK_SIZE) => {
+    const data = Buffer.from(JSON.stringify(metadata));
+    return ensureNodeMaxSize(createNode(encodeIPLDNodeData({
+        type: MetadataType.Metadata,
+        name: metadata.name,
+        linkDepth: 0,
+        data,
+    })), maxNodeSize);
+};

package/dist/ipld/utils.d.ts

@@ -0,0 +1,8 @@
+import { createNode, decode, encode, PBNode } from '@ipld/dag-pb';
+import { AwaitIterable } from 'interface-store';
+export declare const chunkBuffer: (buffer: AwaitIterable<Buffer>, { maxChunkSize, ignoreLastChunk }: {
+    maxChunkSize: number;
+    ignoreLastChunk?: boolean;
+}) => AsyncIterable<Buffer>;
+export { createNode, decode as decodeNode, encode as encodeNode, PBNode };
+//# sourceMappingURL=utils.d.ts.map

package/dist/ipld/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/ipld/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,eAAO,MAAM,WAAW,WACd,aAAa,CAAC,MAAM,CAAC,qCACc;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,KAC7F,aAAa,CAAC,MAAM,CAYtB,CAAA;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,EAAE,CAAA"}

package/dist/ipld/utils.js

@@ -0,0 +1,50 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { createNode, decode, encode } from '@ipld/dag-pb';
+export const chunkBuffer = function (buffer_1, _a) {
+    return __asyncGenerator(this, arguments, function* (buffer, { maxChunkSize, ignoreLastChunk = false }) {
+        var _b, e_1, _c, _d;
+        let target = Buffer.alloc(0);
+        try {
+            for (var _e = true, buffer_2 = __asyncValues(buffer), buffer_2_1; buffer_2_1 = yield __await(buffer_2.next()), _b = buffer_2_1.done, !_b; _e = true) {
+                _d = buffer_2_1.value;
+                _e = false;
+                let chunk = _d;
+                target = Buffer.concat([target, chunk]);
+                while (target.length >= maxChunkSize) {
+                    yield yield __await(target.subarray(0, maxChunkSize));
+                    target = target.subarray(maxChunkSize);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_b && (_c = buffer_2.return)) yield __await(_c.call(buffer_2));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (target.length > 0 && !ignoreLastChunk) {
+            yield yield __await(target);
+        }
+    });
+};
+export { createNode, decode as decodeNode, encode as encodeNode };

package/dist/metadata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './offchain/index.js';
+export * from './onchain/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metadata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/metadata/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA"}

package/dist/metadata/index.js

@@ -0,0 +1,2 @@
+export * from './offchain/index.js';
+export * from './onchain/index.js';

package/dist/metadata/offchain/base.d.ts

@@ -0,0 +1,4 @@
+import { OffchainFileMetadata } from './file.js';
+import { OffchainFolderMetadata } from './folder.js';
+export type OffchainMetadata = OffchainFolderMetadata | OffchainFileMetadata;
+//# sourceMappingURL=base.d.ts.map

package/dist/metadata/offchain/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAEpD,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GAAG,oBAAoB,CAAA"}

package/dist/metadata/offchain/base.js

@@ -0,0 +1 @@
+export {};

package/dist/metadata/offchain/file.d.ts

@@ -0,0 +1,18 @@
+import { CID } from 'multiformats';
+import { FileUploadOptions } from '../../index.js';
+export type OffchainFileMetadata = {
+    type: 'file';
+    dataCid: string;
+    name?: string;
+    mimeType?: string;
+    totalSize: number;
+    totalChunks: number;
+    chunks: ChunkInfo[];
+    uploadOptions?: FileUploadOptions;
+};
+export interface ChunkInfo {
+    size: number;
+    cid: string;
+}
+export declare const fileMetadata: (headCID: CID, chunks: ChunkInfo[], totalSize: number, name?: string | null, mimeType?: string | null, uploadOptions?: FileUploadOptions) => OffchainFileMetadata;
+//# sourceMappingURL=file.d.ts.map

package/dist/metadata/offchain/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAClC,OAAO,EAAe,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,aAAa,CAAC,EAAE,iBAAiB,CAAA;CAClC,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,eAAO,MAAM,YAAY,YACd,GAAG,UACJ,SAAS,EAAE,aACR,MAAM,SACV,MAAM,GAAG,IAAI,aACT,MAAM,GAAG,IAAI,kBACT,iBAAiB,KAI/B,oBAWF,CAAA"}

package/dist/metadata/offchain/file.js

@@ -0,0 +1,16 @@
+import { cidToString } from '../../index.js';
+export const fileMetadata = (headCID, chunks, totalSize, name, mimeType, uploadOptions = {
+    compression: undefined,
+    encryption: undefined,
+}) => {
+    return {
+        type: 'file',
+        dataCid: cidToString(headCID),
+        name: name !== null && name !== void 0 ? name : undefined,
+        mimeType: mimeType !== null && mimeType !== void 0 ? mimeType : undefined,
+        totalSize,
+        totalChunks: chunks.length,
+        chunks,
+        uploadOptions,
+    };
+};

package/dist/metadata/offchain/folder.d.ts

@@ -0,0 +1,22 @@
+import { CID } from 'multiformats';
+import { PBNode } from '../../ipld/index.js';
+import { FileUploadOptions } from '../onchain/index.js';
+interface ChildrenMetadata {
+    type: 'folder' | 'file';
+    name?: string;
+    cid: string;
+    totalSize: number;
+}
+export type OffchainFolderMetadata = {
+    type: 'folder';
+    dataCid: string;
+    name?: string;
+    totalSize: number;
+    totalFiles: number;
+    children: ChildrenMetadata[];
+    uploadOptions: FileUploadOptions;
+};
+export declare const childrenMetadataFromNode: (node: PBNode) => ChildrenMetadata;
+export declare const folderMetadata: (cid: CID | string, children: ChildrenMetadata[], name?: string | null, uploadOptions?: FileUploadOptions) => OffchainFolderMetadata;
+export {};
+//# sourceMappingURL=folder.d.ts.map

package/dist/metadata/offchain/folder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/folder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,iBAAiB,EAA8B,MAAM,qBAAqB,CAAA;AAEnF,UAAU,gBAAgB;IACxB,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,wBAAwB,SAAU,MAAM,KAAG,gBAYvD,CAAA;AAED,eAAO,MAAM,cAAc,QACpB,GAAG,GAAG,MAAM,YACP,gBAAgB,EAAE,SACrB,MAAM,GAAG,IAAI,kBACL,iBAAiB,KAC/B,sBAYF,CAAA"}

package/dist/metadata/offchain/folder.js

@@ -0,0 +1,27 @@
+import { cidOfNode, cidToString } from '../../cid/index.js';
+import { IPLDNodeData, MetadataType } from '../onchain/index.js';
+export const childrenMetadataFromNode = (node) => {
+    var _a;
+    const ipldData = IPLDNodeData.decode(node.Data);
+    if (ipldData.type !== MetadataType.File && ipldData.type !== MetadataType.Folder) {
+        throw new Error('Invalid metadata type');
+    }
+    return {
+        type: ipldData.type === MetadataType.File ? 'file' : 'folder',
+        cid: cidToString(cidOfNode(node)),
+        totalSize: (_a = ipldData.size) !== null && _a !== void 0 ? _a : 0,
+        name: ipldData.name,
+    };
+};
+export const folderMetadata = (cid, children, name, uploadOptions = {}) => {
+    cid = typeof cid === 'string' ? cid : cidToString(cid);
+    return {
+        dataCid: cid,
+        totalSize: children.reduce((acc, child) => acc + child.totalSize, 0),
+        totalFiles: children.length,
+        children,
+        type: 'folder',
+        name: name !== null && name !== void 0 ? name : undefined,
+        uploadOptions,
+    };
+};

package/dist/metadata/offchain/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base.js';
+export * from './file.js';
+export * from './folder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metadata/offchain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metadata/offchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA"}

package/dist/metadata/offchain/index.js

@@ -0,0 +1,3 @@
+export * from './base.js';
+export * from './file.js';
+export * from './folder.js';

package/dist/metadata/onchain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './protobuf/OnchainMetadata.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metadata/onchain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metadata/onchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,YAAY,CAAA"}

package/dist/metadata/onchain/index.js

@@ -0,0 +1,2 @@
+export * from './protobuf/OnchainMetadata.js';
+export * from './utils.js';