@helia/unixfs 0.0.0 → 1.0.0

package/src/commands/utils/is-over-shard-threshold.ts

@@ -0,0 +1,78 @@
+import type { PBNode } from '@ipld/dag-pb'
+import type { Blockstore } from 'interface-blockstore'
+import { UnixFS } from 'ipfs-unixfs'
+import * as dagPb from '@ipld/dag-pb'
+import { CID_V0, CID_V1 } from './dir-sharded.js'
+
+/**
+ * Estimate node size only based on DAGLink name and CID byte lengths
+ * https://github.com/ipfs/go-unixfsnode/blob/37b47f1f917f1b2f54c207682f38886e49896ef9/data/builder/directory.go#L81-L96
+ *
+ * If the node is a hamt sharded directory the calculation is based on if it was a regular directory.
+ */
+export async function isOverShardThreshold (node: PBNode, blockstore: Blockstore, threshold: number): Promise<boolean> {
+  if (node.Data == null) {
+    throw new Error('DagPB node had no data')
+  }
+
+  const unixfs = UnixFS.unmarshal(node.Data)
+  let size: number
+
+  if (unixfs.type === 'directory') {
+    size = estimateNodeSize(node)
+  } else if (unixfs.type === 'hamt-sharded-directory') {
+    size = await estimateShardSize(node, 0, threshold, blockstore)
+  } else {
+    throw new Error('Can only estimate the size of directories or shards')
+  }
+
+  return size > threshold
+}
+
+function estimateNodeSize (node: PBNode): number {
+  let size = 0
+
+  // estimate size only based on DAGLink name and CID byte lengths
+  // https://github.com/ipfs/go-unixfsnode/blob/37b47f1f917f1b2f54c207682f38886e49896ef9/data/builder/directory.go#L81-L96
+  for (const link of node.Links) {
+    size += (link.Name ?? '').length
+    size += link.Hash.version === 1 ? CID_V1.bytes.byteLength : CID_V0.bytes.byteLength
+  }
+
+  return size
+}
+
+async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: Blockstore): Promise<number> {
+  if (current > max) {
+    return max
+  }
+
+  if (node.Data == null) {
+    return current
+  }
+
+  const unixfs = UnixFS.unmarshal(node.Data)
+
+  if (!unixfs.isDirectory()) {
+    return current
+  }
+
+  for (const link of node.Links) {
+    let name = link.Name ?? ''
+
+    // remove hamt hash prefix from name
+    name = name.substring(2)
+
+    current += name.length
+    current += link.Hash.bytes.byteLength
+
+    if (link.Hash.code === dagPb.code) {
+      const block = await blockstore.get(link.Hash)
+      const node = dagPb.decode(block)
+
+      current += await estimateShardSize(node, current, max, blockstore)
+    }
+  }
+
+  return current
+}

package/src/commands/utils/persist.ts

@@ -1,18 +1,23 @@
-import { CID, Version } from 'multiformats/cid'
-import * as dagPB from '@ipld/dag-pb'
+import { CID } from 'multiformats/cid'
+import * as dagPb from '@ipld/dag-pb'
 import { sha256 } from 'multiformats/hashes/sha2'
-import type { BlockCodec } from 'multiformats/codecs/interface'
-import type { AbortOptions } from '@libp2p/interfaces'
 import type { Blockstore } from 'interface-blockstore'
+import type { BlockCodec } from 'multiformats/codecs/interface'
+import type { Version as CIDVersion } from 'multiformats/cid'
 
-export interface PersistOptions extends AbortOptions {
+export interface PersistOptions {
   codec?: BlockCodec<any, any>
-  cidVersion?: Version
+  cidVersion: CIDVersion
+  signal?: AbortSignal
 }
 
-export const persist = async (buffer: Uint8Array, blockstore: Blockstore, options: PersistOptions = {}): Promise<CID> => {
+export const persist = async (buffer: Uint8Array, blockstore: Blockstore, options: PersistOptions): Promise<CID> => {
+  if (options.codec == null) {
+    options.codec = dagPb
+  }
+
   const multihash = await sha256.digest(buffer)
-  const cid = CID.create(options.cidVersion ?? 1, dagPB.code, multihash)
+  const cid = CID.create(options.cidVersion, options.codec.code, multihash)
 
   await blockstore.put(cid, buffer, {
     signal: options.signal

package/src/commands/utils/remove-link.ts

@@ -1,30 +1,36 @@
 
 import * as dagPB from '@ipld/dag-pb'
-import { CID } from 'multiformats/cid'
+import type { CID, Version } from 'multiformats/cid'
 import { logger } from '@libp2p/logger'
 import { UnixFS } from 'ipfs-unixfs'
 import {
   generatePath,
+  HamtPathSegment,
   updateHamtDirectory,
-  UpdateHamtResult
+  UpdateHamtDirectoryOptions
 } from './hamt-utils.js'
-import type { PBNode, PBLink } from '@ipld/dag-pb'
+import type { PBNode } from '@ipld/dag-pb'
 import type { Blockstore } from 'interface-blockstore'
-import { sha256 } from 'multiformats/hashes/sha2'
-import type { Bucket } from 'hamt-sharding'
 import type { Directory } from './cid-to-directory.js'
 import type { AbortOptions } from '@libp2p/interfaces'
-import { InvalidPBNodeError } from './errors.js'
-import { InvalidParametersError } from '@helia/interface/errors'
+import { InvalidParametersError, InvalidPBNodeError } from './errors.js'
+import { exporter } from 'ipfs-unixfs-exporter'
+import { persist } from './persist.js'
+import { isOverShardThreshold } from './is-over-shard-threshold.js'
 
 const log = logger('helia:unixfs:utils:remove-link')
 
+export interface RmLinkOptions extends AbortOptions {
+  shardSplitThresholdBytes: number
+  cidVersion: Version
+}
+
 export interface RemoveLinkResult {
   node: PBNode
   cid: CID
 }
 
-export async function removeLink (parent: Directory, name: string, blockstore: Blockstore, options: AbortOptions): Promise<RemoveLinkResult> {
+export async function removeLink (parent: Directory, name: string, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> {
   if (parent.node.Data == null) {
     throw new InvalidPBNodeError('Parent node had no data')
   }
@@ -32,12 +38,20 @@ export async function removeLink (parent: Directory, name: string, blockstore: B
   const meta = UnixFS.unmarshal(parent.node.Data)
 
   if (meta.type === 'hamt-sharded-directory') {
-    log(`Removing ${name} from sharded directory`)
+    log(`removing ${name} from sharded directory`)
+
+    const result = await removeFromShardedDirectory(parent, name, blockstore, options)
+
+    if (!(await isOverShardThreshold(result.node, blockstore, options.shardSplitThresholdBytes))) {
+      log('converting shard to flat directory %c', parent.cid)
 
-    return await removeFromShardedDirectory(parent, name, blockstore, options)
+      return await convertToFlatDirectory(result, blockstore, options)
+    }
+
+    return result
   }
 
-  log(`Removing link ${name} regular directory`)
+  log(`removing link ${name} regular directory`)
 
   return await removeFromDirectory(parent, name, blockstore, options)
 }
@@ -49,10 +63,10 @@ const removeFromDirectory = async (parent: Directory, name: string, blockstore:
   })
 
   const parentBlock = dagPB.encode(parent.node)
-  const hash = await sha256.digest(parentBlock)
-  const parentCid = CID.create(parent.cid.version, dagPB.code, hash)
-
-  await blockstore.put(parentCid, parentBlock, options)
+  const parentCid = await persist(parentBlock, blockstore, {
+    ...options,
+    cidVersion: parent.cid.version
+  })
 
   log(`Updated regular directory ${parentCid}`)
 
@@ -62,90 +76,177 @@ const removeFromDirectory = async (parent: Directory, name: string, blockstore:
   }
 }
 
-const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: AbortOptions): Promise<UpdateHamtResult> => {
-  const {
-    rootBucket, path
-  } = await generatePath(parent, name, blockstore, options)
+const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: UpdateHamtDirectoryOptions): Promise<{ cid: CID, node: PBNode }> => {
+  const path = await generatePath(parent, name, blockstore, options)
 
-  await rootBucket.del(name)
+  // remove file from root bucket
+  const rootBucket = path[path.length - 1].bucket
 
-  const {
-    node
-  } = await updateShard(parent, blockstore, path, name, options)
+  if (rootBucket == null) {
+    throw new Error('Could not generate HAMT path')
+  }
 
-  return await updateHamtDirectory(parent, blockstore, node.Links, rootBucket, options)
-}
+  await rootBucket.del(name)
 
-const updateShard = async (parent: Directory, blockstore: Blockstore, positions: Array<{ bucket: Bucket<any>, prefix: string, node?: PBNode }>, name: string, options: AbortOptions): Promise<{ node: PBNode, cid: CID, size: number }> => {
-  const last = positions.pop()
+  // update all nodes in the shard path
+  return await updateShard(path, name, blockstore, options)
+}
 
-  if (last == null) {
-    throw new InvalidParametersError('Could not find parent')
+/**
+ * The `path` param is a list of HAMT path segments starting with th
+ */
+const updateShard = async (path: HamtPathSegment[], name: string, blockstore: Blockstore, options: UpdateHamtDirectoryOptions): Promise<{ node: PBNode, cid: CID }> => {
+  const fileName = `${path[0].prefix}${name}`
+
+  // skip first path segment as it is the file to remove
+  for (let i = 1; i < path.length; i++) {
+    const lastPrefix = path[i - 1].prefix
+    const segment = path[i]
+
+    if (segment.node == null) {
+      throw new InvalidParametersError('Path segment had no associated PBNode')
+    }
+
+    const link = segment.node.Links
+      .find(link => (link.Name ?? '').substring(0, 2) === lastPrefix)
+
+    if (link == null) {
+      throw new InvalidParametersError(`No link found with prefix ${lastPrefix} for file ${name}`)
+    }
+
+    if (link.Name == null) {
+      throw new InvalidParametersError(`${lastPrefix} link had no name`)
+    }
+
+    if (link.Name === fileName) {
+      log(`removing existing link ${link.Name}`)
+
+      const links = segment.node.Links.filter((nodeLink) => {
+        return nodeLink.Name !== link.Name
+      })
+
+      if (segment.bucket == null) {
+        throw new Error('Segment bucket was missing')
+      }
+
+      await segment.bucket.del(name)
+
+      const result = await updateHamtDirectory({
+        Data: segment.node.Data,
+        Links: links
+      }, blockstore, segment.bucket, options)
+
+      segment.node = result.node
+      segment.cid = result.cid
+      segment.size = result.size
+    }
+
+    if (link.Name === lastPrefix) {
+      log(`updating subshard with prefix ${lastPrefix}`)
+
+      const lastSegment = path[i - 1]
+
+      if (lastSegment.node?.Links.length === 1) {
+        log(`removing subshard for ${lastPrefix}`)
+
+        // convert subshard back to normal file entry
+        const link = lastSegment.node.Links[0]
+        link.Name = `${lastPrefix}${(link.Name ?? '').substring(2)}`
+
+        // remove existing prefix
+        segment.node.Links = segment.node.Links.filter((link) => {
+          return link.Name !== lastPrefix
+        })
+
+        // add new child
+        segment.node.Links.push(link)
+      } else {
+        // replace subshard entry
+        log(`replacing subshard for ${lastPrefix}`)
+
+        // remove existing prefix
+        segment.node.Links = segment.node.Links.filter((link) => {
+          return link.Name !== lastPrefix
+        })
+
+        if (lastSegment.cid == null) {
+          throw new Error('Did not persist previous segment')
+        }
+
+        // add new child
+        segment.node.Links.push({
+          Name: lastPrefix,
+          Hash: lastSegment.cid,
+          Tsize: lastSegment.size
+        })
+      }
+
+      if (segment.bucket == null) {
+        throw new Error('Segment bucket was missing')
+      }
+
+      const result = await updateHamtDirectory(segment.node, blockstore, segment.bucket, options)
+      segment.node = result.node
+      segment.cid = result.cid
+      segment.size = result.size
+    }
   }
 
-  const {
-    bucket,
-    prefix,
-    node
-  } = last
+  const rootSegment = path[path.length - 1]
 
-  if (node == null) {
-    throw new InvalidParametersError('Could not find parent')
+  if (rootSegment == null || rootSegment.cid == null || rootSegment.node == null) {
+    throw new InvalidParametersError('Failed to update shard')
   }
 
-  const link = node.Links
-    .find(link => (link.Name ?? '').substring(0, 2) === prefix)
-
-  if (link == null) {
-    throw new InvalidParametersError(`No link found with prefix ${prefix} for file ${name}`)
+  return {
+    cid: rootSegment.cid,
+    node: rootSegment.node
   }
+}
 
-  if (link.Name === `${prefix}${name}`) {
-    log(`Removing existing link ${link.Name}`)
-
-    const links = node.Links.filter((nodeLink) => {
-      return nodeLink.Name !== link.Name
-    })
-
-    await bucket.del(name)
-
-    parent.node = node
-
-    return await updateHamtDirectory(parent, blockstore, links, bucket, options)
+const convertToFlatDirectory = async (parent: Directory, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> => {
+  if (parent.node.Data == null) {
+    throw new InvalidParametersError('Invalid parent passed to convertToFlatDirectory')
   }
 
-  log(`Descending into sub-shard ${link.Name} for ${prefix}${name}`)
-
-  const result = await updateShard(parent, blockstore, positions, name, options)
+  const rootNode: PBNode = {
+    Links: []
+  }
+  const dir = await exporter(parent.cid, blockstore)
 
-  const child: Required<PBLink> = {
-    Hash: result.cid,
-    Tsize: result.size,
-    Name: prefix
+  if (dir.type !== 'directory') {
+    throw new Error('Unexpected node type')
   }
 
-  if (result.node.Links.length === 1) {
-    log(`Removing subshard for ${prefix}`)
+  for await (const entry of dir.content()) {
+    let tsize = 0
 
-    // convert shard back to normal dir
-    const link = result.node.Links[0]
+    if (entry.node instanceof Uint8Array) {
+      tsize = entry.node.byteLength
+    } else {
+      tsize = dagPB.encode(entry.node).length
+    }
 
-    child.Name = `${prefix}${(link.Name ?? '').substring(2)}`
-    child.Hash = link.Hash
-    child.Tsize = link.Tsize ?? 0
+    rootNode.Links.push({
+      Hash: entry.cid,
+      Name: entry.name,
+      Tsize: tsize
+    })
   }
 
-  log(`Updating shard ${prefix} with name ${child.Name}`)
-
-  return await updateShardParent(parent, child, prefix, blockstore, bucket, options)
-}
+  // copy mode/mtime over if set
+  const oldUnixfs = UnixFS.unmarshal(parent.node.Data)
+  rootNode.Data = new UnixFS({ type: 'directory', mode: oldUnixfs.mode, mtime: oldUnixfs.mtime }).marshal()
+  const block = dagPB.encode(dagPB.prepare(rootNode))
 
-const updateShardParent = async (parent: Directory, child: Required<PBLink>, oldName: string, blockstore: Blockstore, bucket: Bucket<any>, options: AbortOptions): Promise<UpdateHamtResult> => {
-  // Remove existing link if it exists
-  const parentLinks = parent.node.Links.filter((link) => {
-    return link.Name !== oldName
+  const cid = await persist(block, blockstore, {
+    codec: dagPB,
+    cidVersion: parent.cid.version,
+    signal: options.signal
   })
-  parentLinks.push(child)
 
-  return await updateHamtDirectory(parent, blockstore, parentLinks, bucket, options)
+  return {
+    cid,
+    node: rootNode
+  }
 }

package/src/commands/utils/resolve.ts

@@ -1,19 +1,19 @@
 import type { CID } from 'multiformats/cid'
-import { Blockstore, exporter } from 'ipfs-unixfs-exporter'
+import { exporter } from 'ipfs-unixfs-exporter'
 import type { AbortOptions } from '@libp2p/interfaces'
-import { InvalidParametersError } from '@helia/interface/errors'
 import { logger } from '@libp2p/logger'
-import { DoesNotExistError } from './errors.js'
+import { DoesNotExistError, InvalidParametersError } from './errors.js'
 import { addLink } from './add-link.js'
 import { cidToDirectory } from './cid-to-directory.js'
 import { cidToPBLink } from './cid-to-pblink.js'
+import type { Blockstore } from 'interface-blockstore'
 
 const log = logger('helia:unixfs:components:utils:add-link')
 
 export interface Segment {
   name: string
   cid: CID
-  size: number
+  size: bigint
 }
 
 export interface ResolveResult {
@@ -43,7 +43,7 @@ export async function resolve (cid: CID, path: string | undefined, blockstore: B
   const segments: Segment[] = [{
     name: '',
     cid,
-    size: 0
+    size: 0n
   }]
 
   for (let i = 0; i < parts.length; i++) {
@@ -88,11 +88,15 @@ export async function resolve (cid: CID, path: string | undefined, blockstore: B
   }
 }
 
+export interface UpdatePathCidsOptions extends AbortOptions {
+  shardSplitThresholdBytes: number
+}
+
 /**
  * Where we have descended into a DAG to update a child node, ascend up the DAG creating
  * new hashes and blocks for the changed content
  */
-export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blockstore, options: AbortOptions): Promise<CID> {
+export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blockstore, options: UpdatePathCidsOptions): Promise<CID> {
   if (result.segments == null || result.segments.length === 0) {
     return cid
   }
@@ -118,7 +122,8 @@ export async function updatePathCids (cid: CID, result: ResolveResult, blockstor
 
     const result = await addLink(directory, pblink, blockstore, {
       ...options,
-      allowOverwriting: true
+      allowOverwriting: true,
+      cidVersion: cid.version
     })
 
     cid = result.cid

package/src/index.ts

@@ -1,8 +1,6 @@
 import type { CID, Version } from 'multiformats/cid'
 import type { Blockstore } from 'interface-blockstore'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { ImportCandidate, ImportResult, UserImporterOptions } from 'ipfs-unixfs-importer'
-import { add, addStream } from './commands/add.js'
 import { cat } from './commands/cat.js'
 import { mkdir } from './commands/mkdir.js'
 import type { Mtime } from 'ipfs-unixfs'
@@ -27,10 +25,12 @@ export interface CatOptions extends AbortOptions {
 export interface ChmodOptions extends AbortOptions {
   recursive: boolean
   path?: string
+  shardSplitThresholdBytes: number
 }
 
 export interface CpOptions extends AbortOptions {
   force: boolean
+  shardSplitThresholdBytes: number
 }
 
 export interface LsOptions extends AbortOptions {
@@ -44,10 +44,11 @@ export interface MkdirOptions extends AbortOptions {
   force: boolean
   mode?: number
   mtime?: Mtime
+  shardSplitThresholdBytes: number
 }
 
 export interface RmOptions extends AbortOptions {
-
+  shardSplitThresholdBytes: number
 }
 
 export interface StatOptions extends AbortOptions {
@@ -73,22 +74,22 @@ export interface UnixFSStats {
   /**
    * The size of the file in bytes
    */
-  fileSize: number
+  fileSize: bigint
 
   /**
    * The size of the DAG that holds the file in bytes
    */
-  dagSize: number
+  dagSize: bigint
 
   /**
    * How much of the file is in the local block store
    */
-  localFileSize: number
+  localFileSize: bigint
 
   /**
    * How much of the DAG that holds the file is in the local blockstore
    */
-  localDagSize: number
+  localDagSize: bigint
 
   /**
    * How many blocks make up the DAG - nb. this will only be accurate
@@ -100,17 +101,22 @@ export interface UnixFSStats {
    * The type of file
    */
   type: 'file' | 'directory' | 'raw'
+
+  /**
+   * UnixFS metadata about this file or directory. Will not be present
+   * if the node is a `raw` type.
+   */
+  unixfs?: import('ipfs-unixfs').UnixFS
 }
 
 export interface TouchOptions extends AbortOptions {
   mtime?: Mtime
   path?: string
   recursive: boolean
+  shardSplitThresholdBytes: number
 }
 
 export interface UnixFS {
-  add: (source: Uint8Array | Iterator<Uint8Array> | AsyncIterator<Uint8Array> | ImportCandidate, options?: Partial<UserImporterOptions>) => Promise<CID>
-  addStream: (source: Iterable<ImportCandidate> | AsyncIterable<ImportCandidate>, options?: Partial<UserImporterOptions>) => AsyncGenerator<ImportResult>
   cat: (cid: CID, options?: Partial<CatOptions>) => AsyncIterable<Uint8Array>
   chmod: (source: CID, mode: number, options?: Partial<ChmodOptions>) => Promise<CID>
   cp: (source: CID, target: CID, name: string, options?: Partial<CpOptions>) => Promise<CID>
@@ -128,14 +134,6 @@ class DefaultUnixFS implements UnixFS {
     this.components = components
   }
 
-  async add (source: Uint8Array | Iterator<Uint8Array> | AsyncIterator<Uint8Array> | ImportCandidate, options: Partial<UserImporterOptions> = {}): Promise<CID> {
-    return await add(source, this.components.blockstore, options)
-  }
-
-  async * addStream (source: Iterable<ImportCandidate> | AsyncIterable<ImportCandidate>, options: Partial<UserImporterOptions> = {}): AsyncGenerator<ImportResult> {
-    yield * addStream(source, this.components.blockstore, options)
-  }
-
   async * cat (cid: CID, options: Partial<CatOptions> = {}): AsyncIterable<Uint8Array> {
     yield * cat(cid, this.components.blockstore, options)
   }

package/dist/src/commands/add.d.ts

@@ -1,6 +0,0 @@
-import type { Blockstore } from 'interface-blockstore';
-import { ImportCandidate, ImportResult, UserImporterOptions } from 'ipfs-unixfs-importer';
-import type { CID } from 'multiformats/cid';
-export declare function add(source: Uint8Array | Iterator<Uint8Array> | AsyncIterator<Uint8Array> | ImportCandidate, blockstore: Blockstore, options?: UserImporterOptions): Promise<CID>;
-export declare function addStream(source: Iterable<ImportCandidate> | AsyncIterable<ImportCandidate>, blockstore: Blockstore, options?: UserImporterOptions): AsyncGenerator<ImportResult>;
-//# sourceMappingURL=add.d.ts.map

package/dist/src/commands/add.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/commands/add.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,eAAe,EAAY,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAEnG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAW3C,wBAAsB,GAAG,CAAE,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GAAG,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,GAAG,CAAC,CAuB3L;AAED,wBAAwB,SAAS,CAAE,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,aAAa,CAAC,eAAe,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,mBAAwB,GAAG,cAAc,CAAC,YAAY,CAAC,CAM9L"}

package/dist/src/commands/add.js

@@ -1,38 +0,0 @@
-import { importer } from 'ipfs-unixfs-importer';
-import last from 'it-last';
-import { UnknownError } from './utils/errors.js';
-function isIterable(obj) {
-    return obj[Symbol.iterator] != null;
-}
-function isAsyncIterable(obj) {
-    return obj[Symbol.asyncIterator] != null;
-}
-export async function add(source, blockstore, options = {}) {
-    let importCandidate;
-    if (source instanceof Uint8Array || isIterable(source) || isAsyncIterable(source)) {
-        importCandidate = {
-            // @ts-expect-error FIXME: work out types
-            content: source
-        };
-    }
-    else {
-        importCandidate = source;
-    }
-    const result = await last(importer(importCandidate, blockstore, {
-        cidVersion: 1,
-        rawLeaves: true,
-        ...options
-    }));
-    if (result == null) {
-        throw new UnknownError('Could not import');
-    }
-    return result.cid;
-}
-export async function* addStream(source, blockstore, options = {}) {
-    yield* importer(source, blockstore, {
-        cidVersion: 1,
-        rawLeaves: true,
-        ...options
-    });
-}
-//# sourceMappingURL=add.js.map

package/dist/src/commands/add.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.js","sourceRoot":"","sources":["../../../src/commands/add.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,QAAQ,EAAqC,MAAM,sBAAsB,CAAA;AACnG,OAAO,IAAI,MAAM,SAAS,CAAA;AAE1B,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,SAAS,UAAU,CAAE,GAAQ;IAC3B,OAAO,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAA;AACrC,CAAC;AAED,SAAS,eAAe,CAAE,GAAQ;IAChC,OAAO,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,IAAI,CAAA;AAC1C,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,GAAG,CAAE,MAAuF,EAAE,UAAsB,EAAE,UAA+B,EAAE;IAC3K,IAAI,eAAgC,CAAA;IAEpC,IAAI,MAAM,YAAY,UAAU,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,eAAe,CAAC,MAAM,CAAC,EAAE;QACjF,eAAe,GAAG;YAChB,yCAAyC;YACzC,OAAO,EAAE,MAAM;SAChB,CAAA;KACF;SAAM;QACL,eAAe,GAAG,MAAM,CAAA;KACzB;IAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,UAAU,EAAE;QAC9D,UAAU,EAAE,CAAC;QACb,SAAS,EAAE,IAAI;QACf,GAAG,OAAO;KACX,CAAC,CAAC,CAAA;IAEH,IAAI,MAAM,IAAI,IAAI,EAAE;QAClB,MAAM,IAAI,YAAY,CAAC,kBAAkB,CAAC,CAAA;KAC3C;IAED,OAAO,MAAM,CAAC,GAAG,CAAA;AACnB,CAAC;AAED,MAAM,CAAC,KAAK,SAAU,CAAC,CAAC,SAAS,CAAE,MAAkE,EAAE,UAAsB,EAAE,UAA+B,EAAE;IAC9J,KAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE;QACnC,UAAU,EAAE,CAAC;QACb,SAAS,EAAE,IAAI;QACf,GAAG,OAAO;KACX,CAAC,CAAA;AACJ,CAAC"}