@fireproof/vendor 1.0.3 → 1.1.0-dev

package/src/@ipld/car/src/header-validator.js

@@ -1,214 +0,0 @@
-/** Auto-generated with @ipld/schema@v4.2.0 at Thu Sep 14 2023 from IPLD Schema:
- *
- * # CarV1HeaderOrV2Pragma is a more relaxed form, and can parse {version:x} where
- * # roots are optional. This is typically useful for the {verison:2} CARv2
- * # pragma.
- *
- * type CarV1HeaderOrV2Pragma struct {
- * 	roots optional [&Any]
- * 	# roots is _not_ optional for CarV1 but we defer that check within code to
- * 	# gracefully handle the V2 case where it's just {version:X}
- * 	version Int
- * }
- *
- * # CarV1Header is the strict form of the header, and requires roots to be
- * # present. This is compatible with the CARv1 specification.
- *
- * # type CarV1Header struct {
- * # 	roots [&Any]
- * # 	version Int
- * # }
- *
- */
-
-const Kinds = {
-  Null: /** @returns {undefined|null} */ (/** @type {any} */ obj) => obj === null ? obj : undefined,
-  Int: /** @returns {undefined|number} */ (/** @type {any} */ obj) => Number.isInteger(obj) ? obj : undefined,
-  Float: /** @returns {undefined|number} */ (/** @type {any} */ obj) => typeof obj === 'number' && Number.isFinite(obj) ? obj : undefined,
-  String: /** @returns {undefined|string} */ (/** @type {any} */ obj) => typeof obj === 'string' ? obj : undefined,
-  Bool: /** @returns {undefined|boolean} */ (/** @type {any} */ obj) => typeof obj === 'boolean' ? obj : undefined,
-  Bytes: /** @returns {undefined|Uint8Array} */ (/** @type {any} */ obj) => obj instanceof Uint8Array ? obj : undefined,
-  Link: /** @returns {undefined|object} */ (/** @type {any} */ obj) => obj !== null && typeof obj === 'object' && obj.asCID === obj ? obj : undefined,
-  List: /** @returns {undefined|Array<any>} */ (/** @type {any} */ obj) => Array.isArray(obj) ? obj : undefined,
-  Map: /** @returns {undefined|object} */ (/** @type {any} */ obj) => obj !== null && typeof obj === 'object' && obj.asCID !== obj && !Array.isArray(obj) && !(obj instanceof Uint8Array) ? obj : undefined
-}
-/** @type {{ [k in string]: (obj:any)=>undefined|any}} */
-const Types = {
-  'CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)': Kinds.Link,
-  'CarV1HeaderOrV2Pragma > roots (anon)': /** @returns {undefined|any} */ (/** @type {any} */ obj) => {
-    if (Kinds.List(obj) === undefined) {
-      return undefined
-    }
-    for (let i = 0; i < obj.length; i++) {
-      let v = obj[i]
-      v = Types['CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)'](v)
-      if (v === undefined) {
-        return undefined
-      }
-      if (v !== obj[i]) {
-        const ret = obj.slice(0, i)
-        for (let j = i; j < obj.length; j++) {
-          let v = obj[j]
-          v = Types['CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)'](v)
-          if (v === undefined) {
-            return undefined
-          }
-          ret.push(v)
-        }
-        return ret
-      }
-    }
-    return obj
-  },
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: /** @returns {undefined|any} */ (/** @type {any} */ obj) => {
-    if (Kinds.Map(obj) === undefined) {
-      return undefined
-    }
-    const entries = Object.entries(obj)
-    /** @type {{[k in string]: any}} */
-    let ret = obj
-    let requiredCount = 1
-    for (let i = 0; i < entries.length; i++) {
-      const [key, value] = entries[i]
-      switch (key) {
-        case 'roots':
-          {
-            const v = Types['CarV1HeaderOrV2Pragma > roots (anon)'](obj[key])
-            if (v === undefined) {
-              return undefined
-            }
-            if (v !== value || ret !== obj) {
-              if (ret === obj) {
-                /** @type {{[k in string]: any}} */
-                ret = {}
-                for (let j = 0; j < i; j++) {
-                  ret[entries[j][0]] = entries[j][1]
-                }
-              }
-              ret.roots = v
-            }
-          }
-          break
-        case 'version':
-          {
-            requiredCount--
-            const v = Types.Int(obj[key])
-            if (v === undefined) {
-              return undefined
-            }
-            if (v !== value || ret !== obj) {
-              if (ret === obj) {
-                /** @type {{[k in string]: any}} */
-                ret = {}
-                for (let j = 0; j < i; j++) {
-                  ret[entries[j][0]] = entries[j][1]
-                }
-              }
-              ret.version = v
-            }
-          }
-          break
-        default:
-          return undefined
-      }
-    }
-
-    if (requiredCount > 0) {
-      return undefined
-    }
-    return ret
-  }
-}
-/** @type {{ [k in string]: (obj:any)=>undefined|any}} */
-const Reprs = {
-  'CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)': Kinds.Link,
-  'CarV1HeaderOrV2Pragma > roots (anon)': /** @returns {undefined|any} */ (/** @type {any} */ obj) => {
-    if (Kinds.List(obj) === undefined) {
-      return undefined
-    }
-    for (let i = 0; i < obj.length; i++) {
-      let v = obj[i]
-      v = Reprs['CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)'](v)
-      if (v === undefined) {
-        return undefined
-      }
-      if (v !== obj[i]) {
-        const ret = obj.slice(0, i)
-        for (let j = i; j < obj.length; j++) {
-          let v = obj[j]
-          v = Reprs['CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)'](v)
-          if (v === undefined) {
-            return undefined
-          }
-          ret.push(v)
-        }
-        return ret
-      }
-    }
-    return obj
-  },
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: /** @returns {undefined|any} */ (/** @type {any} */ obj) => {
-    if (Kinds.Map(obj) === undefined) {
-      return undefined
-    }
-    const entries = Object.entries(obj)
-    /** @type {{[k in string]: any}} */
-    let ret = obj
-    let requiredCount = 1
-    for (let i = 0; i < entries.length; i++) {
-      const [key, value] = entries[i]
-      switch (key) {
-        case 'roots':
-          {
-            const v = Reprs['CarV1HeaderOrV2Pragma > roots (anon)'](value)
-            if (v === undefined) {
-              return undefined
-            }
-            if (v !== value || ret !== obj) {
-              if (ret === obj) {
-                /** @type {{[k in string]: any}} */
-                ret = {}
-                for (let j = 0; j < i; j++) {
-                  ret[entries[j][0]] = entries[j][1]
-                }
-              }
-              ret.roots = v
-            }
-          }
-          break
-        case 'version':
-          {
-            requiredCount--
-            const v = Reprs.Int(value)
-            if (v === undefined) {
-              return undefined
-            }
-            if (v !== value || ret !== obj) {
-              if (ret === obj) {
-                /** @type {{[k in string]: any}} */
-                ret = {}
-                for (let j = 0; j < i; j++) {
-                  ret[entries[j][0]] = entries[j][1]
-                }
-              }
-              ret.version = v
-            }
-          }
-          break
-        default:
-          return undefined
-      }
-    }
-    if (requiredCount > 0) {
-      return undefined
-    }
-    return ret
-  }
-}
-
-export const CarV1HeaderOrV2Pragma = {
-  toTyped: Types.CarV1HeaderOrV2Pragma,
-  toRepresentation: Reprs.CarV1HeaderOrV2Pragma
-}

package/src/@ipld/car/src/header.ipldsch

@@ -1,18 +0,0 @@
-# CarV1HeaderOrV2Pragma is a more relaxed form, and can parse {version:x} where
-# roots are optional. This is typically useful for the {verison:2} CARv2
-# pragma.
-
-type CarV1HeaderOrV2Pragma struct {
-	roots optional [&Any]
-	# roots is _not_ optional for CarV1 but we defer that check within code to
-	# gracefully handle the V2 case where it's just {version:X}
-	version Int
-}
-
-# CarV1Header is the strict form of the header, and requires roots to be
-# present. This is compatible with the CARv1 specification.
-
-# type CarV1Header struct {
-# 	roots [&Any]
-# 	version Int
-# }

package/src/@ipld/car/src/index-browser.js

@@ -1,18 +0,0 @@
-import { CarBufferReader } from './buffer-reader.js'
-import * as CarBufferWriter from './buffer-writer.js'
-import { CarIndexedReader } from './indexed-reader-browser.js'
-import { CarIndexer } from './indexer.js'
-import { CarBlockIterator, CarCIDIterator } from './iterator.js'
-import { CarReader } from './reader-browser.js'
-import { CarWriter } from './writer-browser.js'
-
-export {
-  CarReader,
-  CarIndexer,
-  CarBlockIterator,
-  CarCIDIterator,
-  CarWriter,
-  CarIndexedReader,
-  CarBufferReader,
-  CarBufferWriter
-}

package/src/@ipld/car/src/index.js

@@ -1,21 +0,0 @@
-import { CarBufferReader } from './buffer-reader.js'
-import * as CarBufferWriter from './buffer-writer.js'
-import { CarIndexedReader } from './indexed-reader.js'
-import { CarIndexer } from './indexer.js'
-import { CarBlockIterator, CarCIDIterator } from './iterator.js'
-import { CarReader } from './reader.js'
-import { CarWriter } from './writer.js'
-
-// @see https://www.iana.org/assignments/media-types/application/vnd.ipld.car
-export const contentType = 'application/vnd.ipld.car'
-
-export {
-  CarReader,
-  CarBufferReader,
-  CarIndexer,
-  CarBlockIterator,
-  CarCIDIterator,
-  CarWriter,
-  CarIndexedReader,
-  CarBufferWriter
-}

package/src/@ipld/car/src/indexed-reader-browser.js

@@ -1,7 +0,0 @@
-export class CarIndexedReader {
-  static async fromFile () {
-    throw new Error('Unsupported in this environment')
-  }
-}
-
-export const __browser = true

package/src/@ipld/car/src/indexed-reader.js

@@ -1,211 +0,0 @@
-import fs from 'fs'
-import { Readable } from 'stream'
-import { CID } from 'multiformats/cid'
-import { CarIndexer } from './indexer.js'
-import { CarReader as NodeCarReader } from './reader.js'
-
-/**
- * @typedef {import('fs').promises.FileHandle} FileHandle
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./api').CarReader} CarReaderIface
- * @typedef {import('./reader-browser').CarReader} CarReader
- * @typedef {{ blockLength:number, blockOffset:number }} RawLocation
- */
-
-/**
- * A form of {@link CarReader} that pre-indexes a CAR archive from a file and
- * provides random access to blocks within the file using the index data. This
- * function is **only available in Node.js** and not a browser environment.
- *
- * For large CAR files, using this form of `CarReader` can be singificantly more
- * efficient in terms of memory. The index consists of a list of `CID`s and
- * their location within the archive (see {@link CarIndexer}). For large numbers
- * of blocks, this index can also occupy a significant amount of memory. In some
- * cases it may be necessary to expand the memory capacity of a Node.js instance
- * to allow this index to fit. (e.g. by running with
- * `NODE_OPTIONS="--max-old-space-size=16384"`).
- *
- * As an `CarIndexedReader` instance maintains an open file descriptor for its
- * CAR file, an additional {@link CarReader#close} method is attached. This
- * _must_ be called to have full clean-up of resources after use.
- *
- * Load this class with either
- * `import { CarIndexedReader } from '@ipld/car/indexed-reader'`
- * (`const { CarIndexedReader } = require('@ipld/car/indexed-reader')`). Or
- * `import { CarIndexedReader } from '@ipld/car'`
- * (`const { CarIndexedReader } = require('@ipld/car')`). The former will likely
- * result in smaller bundle sizes where this is important.
- *
- * @name CarIndexedReader
- * @class
- * @implements {CarReaderIface}
- * @extends {CarReader}
- * @property {number} version The version number of the CAR referenced by this
- * reader (should be `1`).
- */
-export class CarIndexedReader {
-  /**
-   * @param {number} version
-   * @param {string} path
-   * @param {CID[]} roots
-   * @param {Map<string, RawLocation>} index
-   * @param {string[]} order
-   */
-  constructor (version, path, roots, index, order) {
-    this._version = version
-    this._path = path
-    this._roots = roots
-    this._index = index
-    this._order = order
-    this._fd = null
-  }
-
-  get version () {
-    return this._version
-  }
-
-  /**
-   * See {@link CarReader#getRoots}
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots () {
-    return this._roots
-  }
-
-  /**
-   * See {@link CarReader#has}
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<boolean>}
-   */
-  async has (key) {
-    return this._index.has(key.toString())
-  }
-
-  /**
-   * See {@link CarReader#get}
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<Block | undefined>}
-   */
-  async get (key) {
-    const blockIndex = this._index.get(key.toString())
-    if (!blockIndex) {
-      return undefined
-    }
-    if (!this._fd) {
-      this._fd = await fs.promises.open(this._path, 'r')
-    }
-    const readIndex = {
-      cid: key,
-      length: 0,
-      offset: 0,
-      blockLength: blockIndex.blockLength,
-      blockOffset: blockIndex.blockOffset
-    }
-    return NodeCarReader.readRaw(this._fd, readIndex)
-  }
-
-  /**
-   * See {@link CarReader#blocks}
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<Block>}
-   */
-  async * blocks () {
-    for (const cidStr of this._order) {
-      const block = await this.get(CID.parse(cidStr))
-      /* c8 ignore next 3 */
-      if (!block) {
-        throw new Error('Unexpected internal error')
-      }
-      yield block
-    }
-  }
-
-  /**
-   * See {@link CarReader#cids}
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<CID>}
-   */
-  async * cids () {
-    for (const cidStr of this._order) {
-      yield CID.parse(cidStr)
-    }
-  }
-
-  /**
-   * Close the underlying file descriptor maintained by this `CarIndexedReader`.
-   * This must be called for proper resource clean-up to occur.
-   *
-   * @function
-   * @memberof CarIndexedReader
-   * @instance
-   * @async
-   * @returns {Promise<void>}
-   */
-  async close () {
-    if (this._fd) {
-      return this._fd.close()
-    }
-  }
-
-  /**
-   * Instantiate an {@link CarIndexedReader} from a file with the provided
-   * `path`. The CAR file is first indexed with a full path that collects `CID`s
-   * and block locations. This index is maintained in memory. Subsequent reads
-   * operate on a read-only file descriptor, fetching the block from its in-file
-   * location.
-   *
-   * For large archives, the initial indexing may take some time. The returned
-   * `Promise` will resolve only after this is complete.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexedReader
-   * @param {string} path
-   * @returns {Promise<CarIndexedReader>}
-   */
-  static async fromFile (path) {
-    if (typeof path !== 'string') {
-      throw new TypeError('fromFile() requires a file path string')
-    }
-
-    const iterable = await CarIndexer.fromIterable(Readable.from(fs.createReadStream(path)))
-    /** @type {Map<string, RawLocation>} */
-    const index = new Map()
-    /** @type {string[]} */
-    const order = []
-    for await (const { cid, blockLength, blockOffset } of iterable) {
-      const cidStr = cid.toString()
-      index.set(cidStr, { blockLength, blockOffset })
-      order.push(cidStr)
-    }
-    return new CarIndexedReader(iterable.version, path, await iterable.getRoots(), index, order)
-  }
-}
-
-export const __browser = false

package/src/@ipld/car/src/indexer.js

@@ -1,130 +0,0 @@
-import {
-  asyncIterableReader,
-  bytesReader,
-  createDecoder
-} from './decoder.js'
-
-/**
- * @typedef {import('multiformats').CID} CID
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').RootsReader} RootsReader
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./coding').BytesReader} BytesReader
- */
-
-/**
- * Provides an iterator over all of the `Block`s in a CAR, returning their CIDs
- * and byte-location information. Implements an `AsyncIterable<BlockIndex>`.
- * Where a `BlockIndex` is a
- * `{ cid:CID, length:number, offset:number, blockLength:number, blockOffset:number }`.
- *
- * As an implementer of `AsyncIterable`, this class can be used directly in a
- * `for await (const blockIndex of iterator) {}` loop. Where the `iterator` is
- * constructed using {@link CarIndexer.fromBytes} or
- * {@link CarIndexer.fromIterable}.
- *
- * An iteration can only be performce _once_ per instantiation.
- *
- * `CarIndexer` also implements the `RootsReader` interface and provides
- * the {@link CarIndexer.getRoots `getRoots()`} method.
- *
- * Load this class with either
- * `import { CarIndexer } from '@ipld/car/indexer'`
- * (`const { CarIndexer } = require('@ipld/car/indexer')`). Or
- * `import { CarIndexer } from '@ipld/car'`
- * (`const { CarIndexer } = require('@ipld/car')`). The former will likely
- * result in smaller bundle sizes where this is important.
- *
- * @name CarIndexer
- * @class
- * @implements {RootsReader}
- * @implements {AsyncIterable<BlockIndex>}
- * @property {number} version The version number of the CAR referenced by this
- * reader (should be `1`).
- */
-export class CarIndexer {
-  /**
-   * @param {number} version
-   * @param {CID[]} roots
-   * @param {AsyncGenerator<BlockIndex>} iterator
-   */
-  constructor (version, roots, iterator) {
-    this._version = version
-    this._roots = roots
-    this._iterator = iterator
-  }
-
-  get version () {
-    return this._version
-  }
-
-  /**
-   * Get the list of roots defined by the CAR referenced by this indexer. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarIndexer
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots () {
-    return this._roots
-  }
-
-  /**
-   * @returns {AsyncIterator<BlockIndex>}
-   */
-  [Symbol.asyncIterator] () {
-    return this._iterator
-  }
-
-  /**
-   * Instantiate a {@link CarIndexer} from a `Uint8Array` blob. Only the header
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromBytes (bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError('fromBytes() requires a Uint8Array')
-    }
-    return decodeIndexerComplete(bytesReader(bytes))
-  }
-
-  /**
-   * Instantiate a {@link CarIndexer} from a `AsyncIterable<Uint8Array>`,
-   * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromIterable (asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === 'function')) {
-      throw new TypeError('fromIterable() requires an async iterable')
-    }
-    return decodeIndexerComplete(asyncIterableReader(asyncIterable))
-  }
-}
-
-/**
- * @private
- * @param {BytesReader} reader
- * @returns {Promise<CarIndexer>}
- */
-async function decodeIndexerComplete (reader) {
-  const decoder = createDecoder(reader)
-  const { version, roots } = await decoder.header()
-
-  return new CarIndexer(version, roots, decoder.blocksIndex())
-}