@autonomys/auto-dag-data 0.8.2

package/dist/metadata/onchain/protobuf/OnchainMetadata.d.ts

@@ -0,0 +1,69 @@
+import { type Codec, type DecodeOptions } from 'protons-runtime';
+import type { Uint8ArrayList } from 'uint8arraylist';
+export interface IPLDNodeData {
+    type: MetadataType;
+    linkDepth: number;
+    size?: number;
+    name?: string;
+    data?: Uint8Array;
+    uploadOptions?: FileUploadOptions;
+}
+export declare namespace IPLDNodeData {
+    const codec: () => Codec<IPLDNodeData>;
+    const encode: (obj: Partial<IPLDNodeData>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<IPLDNodeData>) => IPLDNodeData;
+}
+export declare enum MetadataType {
+    File = "File",
+    FileInlink = "FileInlink",
+    FileChunk = "FileChunk",
+    Folder = "Folder",
+    FolderInlink = "FolderInlink",
+    Metadata = "Metadata",
+    MetadataInlink = "MetadataInlink",
+    MetadataChunk = "MetadataChunk"
+}
+export declare namespace MetadataType {
+    const codec: () => Codec<MetadataType>;
+}
+export interface FileUploadOptions {
+    compression?: CompressionOptions;
+    encryption?: EncryptionOptions;
+}
+export declare namespace FileUploadOptions {
+    const codec: () => Codec<FileUploadOptions>;
+    const encode: (obj: Partial<FileUploadOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<FileUploadOptions>) => FileUploadOptions;
+}
+export interface CompressionOptions {
+    algorithm: CompressionAlgorithm;
+    level?: number;
+    chunkSize?: number;
+}
+export declare namespace CompressionOptions {
+    const codec: () => Codec<CompressionOptions>;
+    const encode: (obj: Partial<CompressionOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<CompressionOptions>) => CompressionOptions;
+}
+export interface EncryptionOptions {
+    algorithm: EncryptionAlgorithm;
+    chunkSize?: number;
+}
+export declare namespace EncryptionOptions {
+    const codec: () => Codec<EncryptionOptions>;
+    const encode: (obj: Partial<EncryptionOptions>) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<EncryptionOptions>) => EncryptionOptions;
+}
+export declare enum CompressionAlgorithm {
+    ZLIB = "ZLIB"
+}
+export declare namespace CompressionAlgorithm {
+    const codec: () => Codec<CompressionAlgorithm>;
+}
+export declare enum EncryptionAlgorithm {
+    AES_256_GCM = "AES_256_GCM"
+}
+export declare namespace EncryptionAlgorithm {
+    const codec: () => Codec<EncryptionAlgorithm>;
+}
+//# sourceMappingURL=OnchainMetadata.d.ts.map

package/dist/metadata/onchain/protobuf/OnchainMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnchainMetadata.d.ts","sourceRoot":"","sources":["../../../../src/metadata/onchain/protobuf/OnchainMetadata.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,KAAK,EAAiB,KAAK,aAAa,EAAuC,MAAM,iBAAiB,CAAA;AACpH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,aAAa,CAAC,EAAE,iBAAiB,CAAA;CAClC;AAED,yBAAiB,YAAY,CAAC;IAGrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CA0F1C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,YAAY,CAAC,KAAG,UAEnD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,YAAY,CAAC,KAAG,YAE7F,CAAA;CACF;AAED,oBAAY,YAAY;IACtB,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;CAChC;AAaD,yBAAiB,YAAY,CAAC;IACrB,MAAM,KAAK,QAAO,KAAK,CAAC,YAAY,CAE1C,CAAA;CACF;AACD,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B;AAED,yBAAiB,iBAAiB,CAAC;IAG1B,MAAM,KAAK,QAAO,KAAK,CAAC,iBAAiB,CAqD/C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,iBAAiB,CAAC,KAAG,UAExD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,iBAAiB,CAAC,KAAG,iBAElG,CAAA;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,oBAAoB,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,yBAAiB,kBAAkB,CAAC;IAG3B,MAAM,KAAK,QAAO,KAAK,CAAC,kBAAkB,CA4DhD,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,kBAAkB,CAAC,KAAG,UAEzD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,kBAAkB,CAAC,KAAG,kBAEnG,CAAA;CACF;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,mBAAmB,CAAA;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,yBAAiB,iBAAiB,CAAC;IAG1B,MAAM,KAAK,QAAO,KAAK,CAAC,iBAAiB,CAmD/C,CAAA;IAEM,MAAM,MAAM,QAAS,OAAO,CAAC,iBAAiB,CAAC,KAAG,UAExD,CAAA;IAEM,MAAM,MAAM,QAAS,UAAU,GAAG,cAAc,SAAS,aAAa,CAAC,iBAAiB,CAAC,KAAG,iBAElG,CAAA;CACF;AAED,oBAAY,oBAAoB;IAC9B,IAAI,SAAS;CACd;AAMD,yBAAiB,oBAAoB,CAAC;IAC7B,MAAM,KAAK,QAAO,KAAK,CAAC,oBAAoB,CAElD,CAAA;CACF;AACD,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;CAC5B;AAMD,yBAAiB,mBAAmB,CAAC;IAC5B,MAAM,KAAK,QAAO,KAAK,CAAC,mBAAmB,CAEjD,CAAA;CACF"}

package/dist/metadata/onchain/protobuf/OnchainMetadata.js

@@ -0,0 +1,322 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import { decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime';
+export var IPLDNodeData;
+(function (IPLDNodeData) {
+    let _codec;
+    IPLDNodeData.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.type != null && __MetadataTypeValues[obj.type] !== 0) {
+                    w.uint32(8);
+                    MetadataType.codec().encode(obj.type, w);
+                }
+                if ((obj.linkDepth != null && obj.linkDepth !== 0)) {
+                    w.uint32(16);
+                    w.int32(obj.linkDepth);
+                }
+                if (obj.size != null) {
+                    w.uint32(24);
+                    w.int32(obj.size);
+                }
+                if (obj.name != null) {
+                    w.uint32(34);
+                    w.string(obj.name);
+                }
+                if (obj.data != null) {
+                    w.uint32(42);
+                    w.bytes(obj.data);
+                }
+                if (obj.uploadOptions != null) {
+                    w.uint32(50);
+                    FileUploadOptions.codec().encode(obj.uploadOptions, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                var _a;
+                const obj = {
+                    type: MetadataType.File,
+                    linkDepth: 0
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.type = MetadataType.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.linkDepth = reader.int32();
+                            break;
+                        }
+                        case 3: {
+                            obj.size = reader.int32();
+                            break;
+                        }
+                        case 4: {
+                            obj.name = reader.string();
+                            break;
+                        }
+                        case 5: {
+                            obj.data = reader.bytes();
+                            break;
+                        }
+                        case 6: {
+                            obj.uploadOptions = FileUploadOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_a = opts.limits) === null || _a === void 0 ? void 0 : _a.uploadOptions
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    IPLDNodeData.encode = (obj) => {
+        return encodeMessage(obj, IPLDNodeData.codec());
+    };
+    IPLDNodeData.decode = (buf, opts) => {
+        return decodeMessage(buf, IPLDNodeData.codec(), opts);
+    };
+})(IPLDNodeData || (IPLDNodeData = {}));
+export var MetadataType;
+(function (MetadataType) {
+    MetadataType["File"] = "File";
+    MetadataType["FileInlink"] = "FileInlink";
+    MetadataType["FileChunk"] = "FileChunk";
+    MetadataType["Folder"] = "Folder";
+    MetadataType["FolderInlink"] = "FolderInlink";
+    MetadataType["Metadata"] = "Metadata";
+    MetadataType["MetadataInlink"] = "MetadataInlink";
+    MetadataType["MetadataChunk"] = "MetadataChunk";
+})(MetadataType || (MetadataType = {}));
+var __MetadataTypeValues;
+(function (__MetadataTypeValues) {
+    __MetadataTypeValues[__MetadataTypeValues["File"] = 0] = "File";
+    __MetadataTypeValues[__MetadataTypeValues["FileInlink"] = 1] = "FileInlink";
+    __MetadataTypeValues[__MetadataTypeValues["FileChunk"] = 2] = "FileChunk";
+    __MetadataTypeValues[__MetadataTypeValues["Folder"] = 3] = "Folder";
+    __MetadataTypeValues[__MetadataTypeValues["FolderInlink"] = 4] = "FolderInlink";
+    __MetadataTypeValues[__MetadataTypeValues["Metadata"] = 5] = "Metadata";
+    __MetadataTypeValues[__MetadataTypeValues["MetadataInlink"] = 6] = "MetadataInlink";
+    __MetadataTypeValues[__MetadataTypeValues["MetadataChunk"] = 7] = "MetadataChunk";
+})(__MetadataTypeValues || (__MetadataTypeValues = {}));
+(function (MetadataType) {
+    MetadataType.codec = () => {
+        return enumeration(__MetadataTypeValues);
+    };
+})(MetadataType || (MetadataType = {}));
+export var FileUploadOptions;
+(function (FileUploadOptions) {
+    let _codec;
+    FileUploadOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.compression != null) {
+                    w.uint32(10);
+                    CompressionOptions.codec().encode(obj.compression, w);
+                }
+                if (obj.encryption != null) {
+                    w.uint32(18);
+                    EncryptionOptions.codec().encode(obj.encryption, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                var _a, _b;
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.compression = CompressionOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_a = opts.limits) === null || _a === void 0 ? void 0 : _a.compression
+                            });
+                            break;
+                        }
+                        case 2: {
+                            obj.encryption = EncryptionOptions.codec().decode(reader, reader.uint32(), {
+                                limits: (_b = opts.limits) === null || _b === void 0 ? void 0 : _b.encryption
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    FileUploadOptions.encode = (obj) => {
+        return encodeMessage(obj, FileUploadOptions.codec());
+    };
+    FileUploadOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, FileUploadOptions.codec(), opts);
+    };
+})(FileUploadOptions || (FileUploadOptions = {}));
+export var CompressionOptions;
+(function (CompressionOptions) {
+    let _codec;
+    CompressionOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.algorithm != null && __CompressionAlgorithmValues[obj.algorithm] !== 0) {
+                    w.uint32(8);
+                    CompressionAlgorithm.codec().encode(obj.algorithm, w);
+                }
+                if (obj.level != null) {
+                    w.uint32(16);
+                    w.int32(obj.level);
+                }
+                if (obj.chunkSize != null) {
+                    w.uint32(24);
+                    w.int32(obj.chunkSize);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    algorithm: CompressionAlgorithm.ZLIB
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.algorithm = CompressionAlgorithm.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.level = reader.int32();
+                            break;
+                        }
+                        case 3: {
+                            obj.chunkSize = reader.int32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    CompressionOptions.encode = (obj) => {
+        return encodeMessage(obj, CompressionOptions.codec());
+    };
+    CompressionOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, CompressionOptions.codec(), opts);
+    };
+})(CompressionOptions || (CompressionOptions = {}));
+export var EncryptionOptions;
+(function (EncryptionOptions) {
+    let _codec;
+    EncryptionOptions.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.algorithm != null && __EncryptionAlgorithmValues[obj.algorithm] !== 0) {
+                    w.uint32(8);
+                    EncryptionAlgorithm.codec().encode(obj.algorithm, w);
+                }
+                if (obj.chunkSize != null) {
+                    w.uint32(16);
+                    w.int32(obj.chunkSize);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    algorithm: EncryptionAlgorithm.AES_256_GCM
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.algorithm = EncryptionAlgorithm.codec().decode(reader);
+                            break;
+                        }
+                        case 2: {
+                            obj.chunkSize = reader.int32();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    EncryptionOptions.encode = (obj) => {
+        return encodeMessage(obj, EncryptionOptions.codec());
+    };
+    EncryptionOptions.decode = (buf, opts) => {
+        return decodeMessage(buf, EncryptionOptions.codec(), opts);
+    };
+})(EncryptionOptions || (EncryptionOptions = {}));
+export var CompressionAlgorithm;
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm["ZLIB"] = "ZLIB";
+})(CompressionAlgorithm || (CompressionAlgorithm = {}));
+var __CompressionAlgorithmValues;
+(function (__CompressionAlgorithmValues) {
+    __CompressionAlgorithmValues[__CompressionAlgorithmValues["ZLIB"] = 0] = "ZLIB";
+})(__CompressionAlgorithmValues || (__CompressionAlgorithmValues = {}));
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm.codec = () => {
+        return enumeration(__CompressionAlgorithmValues);
+    };
+})(CompressionAlgorithm || (CompressionAlgorithm = {}));
+export var EncryptionAlgorithm;
+(function (EncryptionAlgorithm) {
+    EncryptionAlgorithm["AES_256_GCM"] = "AES_256_GCM";
+})(EncryptionAlgorithm || (EncryptionAlgorithm = {}));
+var __EncryptionAlgorithmValues;
+(function (__EncryptionAlgorithmValues) {
+    __EncryptionAlgorithmValues[__EncryptionAlgorithmValues["AES_256_GCM"] = 0] = "AES_256_GCM";
+})(__EncryptionAlgorithmValues || (__EncryptionAlgorithmValues = {}));
+(function (EncryptionAlgorithm) {
+    EncryptionAlgorithm.codec = () => {
+        return enumeration(__EncryptionAlgorithmValues);
+    };
+})(EncryptionAlgorithm || (EncryptionAlgorithm = {}));

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

@@ -0,0 +1,4 @@
+import { IPLDNodeData } from './index.js';
+export declare const encodeIPLDNodeData: (metadata: IPLDNodeData) => Uint8Array;
+export declare const decodeIPLDNodeData: (data: Uint8Array) => IPLDNodeData;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/metadata/onchain/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC,eAAO,MAAM,kBAAkB,aAAc,YAAY,KAAG,UAE3D,CAAA;AAED,eAAO,MAAM,kBAAkB,SAAU,UAAU,KAAG,YAOrD,CAAA"}

package/dist/metadata/onchain/utils.js

@@ -0,0 +1,12 @@
+import { decodeNode } from '../../ipld/index.js';
+import { IPLDNodeData } from './index.js';
+export const encodeIPLDNodeData = (metadata) => {
+    return IPLDNodeData.encode(metadata);
+};
+export const decodeIPLDNodeData = (data) => {
+    const decoded = decodeNode(data);
+    if (!decoded.Data) {
+        throw new Error('Invalid data');
+    }
+    return IPLDNodeData.decode(decoded.Data);
+};

package/dist/src/cid/index.d.ts

@@ -0,0 +1,9 @@
+import { PBNode } from '@ipld/dag-pb';
+import { CID } from 'multiformats/cid';
+export declare const BLAKE3_CODE = 31;
+export declare const cidOfNode: (node: PBNode) => CID<unknown, 85, 31, 1>;
+export declare const cidToString: (cid: CID) => string;
+export declare const stringToCid: (str: string) => CID<unknown, number, number, import("multiformats/cid").Version>;
+export declare const cidFromBlakeHash: (hash: Buffer) => CID<unknown, 85, 31, 1>;
+export declare const blake3HashFromCid: (cid: CID) => Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/cid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAKtC,eAAO,MAAM,WAAW,KAAO,CAAA;AAE/B,eAAO,MAAM,SAAS,SAAU,MAAM,4BAErC,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,GAAG,WAEnC,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,MAAM,qEAEtC,CAAA;AAED,eAAO,MAAM,gBAAgB,SAAU,MAAM,4BAE5C,CAAA;AAED,eAAO,MAAM,iBAAiB,QAAS,GAAG,eAAyB,CAAA"}

package/dist/src/cid/index.js

@@ -0,0 +1,20 @@
+import { encode } from '@ipld/dag-pb';
+import { hash } from 'blake3';
+import { CID } from 'multiformats/cid';
+import * as base32 from 'multiformats/bases/base32';
+import * as raw from 'multiformats/codecs/raw';
+import { create } from 'multiformats/hashes/digest';
+export const BLAKE3_CODE = 0x1f;
+export const cidOfNode = (node) => {
+    return cidFromBlakeHash(hash(encode(node)));
+};
+export const cidToString = (cid) => {
+    return cid.toString(base32.base32);
+};
+export const stringToCid = (str) => {
+    return CID.parse(str, base32.base32);
+};
+export const cidFromBlakeHash = (hash) => {
+    return CID.create(1, raw.code, create(BLAKE3_CODE, hash));
+};
+export const blake3HashFromCid = (cid) => cid.multihash.digest;

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cid/index.js';
+export * from './ipld/index.js';
+export * from './metadata/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export * from './cid/index.js';
+export * from './ipld/index.js';
+export * from './metadata/index.js';

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

@@ -0,0 +1,11 @@
+import { PBNode } from '@ipld/dag-pb';
+import { CID } from 'multiformats/cid';
+export interface Builders {
+    inlink: (links: CID[], size: number, linkDepth: number, chunkSize: number) => PBNode;
+    chunk: (data: Buffer) => PBNode;
+    root: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number) => PBNode;
+    single: (data: Buffer, filename?: string) => PBNode;
+}
+export declare const metadataBuilders: Builders;
+export declare const fileBuilders: Builders;
+//# sourceMappingURL=builders.d.ts.map

package/dist/src/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,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAYtC,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,KACjB,MAAM,CAAA;IACX,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CACpD;AACD,eAAO,MAAM,gBAAgB,EAAE,QAK9B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,QAK1B,CAAA"}

package/dist/src/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/src/ipld/chunker.d.ts

@@ -0,0 +1,22 @@
+import { PBNode } from '@ipld/dag-pb';
+import { CID } from 'multiformats';
+import { OffchainMetadata } from '../metadata/index.js';
+export declare const DEFAULT_MAX_CHUNK_SIZE: number;
+export declare const DEFAULT_MAX_LINK_PER_NODE: number;
+export interface IPLDDag {
+    headCID: CID;
+    nodes: Map<CID, PBNode>;
+}
+export declare const createFileIPLDDag: (file: AsyncIterable<Buffer>, filename?: string, { chunkSize, maxLinkPerNode }?: {
+    chunkSize: number;
+    maxLinkPerNode: number;
+}) => Promise<IPLDDag>;
+export declare const createMetadataIPLDDag: (metadata: OffchainMetadata, limits?: {
+    chunkSize: number;
+    maxLinkPerNode: number;
+}) => Promise<IPLDDag>;
+export declare const createFolderIPLDDag: (children: CID[], name: string, size: number, { maxLinkPerNode }?: {
+    maxLinkPerNode: number;
+}) => IPLDDag;
+export declare const ensureNodeMaxSize: (node: PBNode, maxSize?: number) => PBNode;
+//# sourceMappingURL=chunker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../../src/ipld/chunker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAgB,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKrE,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAC/C,eAAO,MAAM,yBAAyB,QAA8B,CAAA;AAEpE,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,GAAG,CAAA;IACZ,KAAK,EAAE,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;CACxB;AAED,eAAO,MAAM,iBAAiB,SACtB,aAAa,CAAC,MAAM,CAAC,aAChB,MAAM,kCACc;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAI3E,OAAO,CAAC,OAAO,CAEjB,CAAA;AAED,eAAO,MAAM,qBAAqB,aACtB,gBAAgB,WAClB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,KAIpD,OAAO,CAAC,OAAO,CAWjB,CAAA;AA6DD,eAAO,MAAM,mBAAmB,aACpB,GAAG,EAAE,QACT,MAAM,QACN,MAAM,uBACQ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,KAC7C,OAyBF,CAAA;AAED,eAAO,MAAM,iBAAiB,SACtB,MAAM,YACH,MAAM,KACd,MAOF,CAAA"}