@fireproof/vendor 0.0.0-smoke → 0.0.2-dev-test

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

@@ -1,194 +0,0 @@
-import { asyncIterableReader, bytesReader, createDecoder } from './decoder.js'
-
-/**
- * @typedef {import('multiformats').CID} CID
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').CarReader} CarReaderIface
- * @typedef {import('./coding').BytesReader} BytesReader
- * @typedef {import('./coding').CarHeader} CarHeader
- * @typedef {import('./coding').CarV2Header} CarV2Header
- */
-
-/**
- * Provides blockstore-like access to a CAR.
- *
- * Implements the `RootsReader` interface:
- * {@link CarReader.getRoots `getRoots()`}. And the `BlockReader` interface:
- * {@link CarReader.get `get()`}, {@link CarReader.has `has()`},
- * {@link CarReader.blocks `blocks()`} (defined as a `BlockIterator`) and
- * {@link CarReader.cids `cids()`} (defined as a `CIDIterator`).
- *
- * Load this class with either `import { CarReader } from '@ipld/car/reader'`
- * (`const { CarReader } = require('@ipld/car/reader')`). Or
- * `import { CarReader } from '@ipld/car'` (`const { CarReader } = require('@ipld/car')`).
- * The former will likely result in smaller bundle sizes where this is
- * important.
- *
- * @name CarReader
- * @class
- * @implements {CarReaderIface}
- * @property {number} version The version number of the CAR referenced by this
- * reader (should be `1` or `2`).
- */
-export class CarReader {
-  /**
-   * @constructs CarReader
-   * @param {CarHeader|CarV2Header} header
-   * @param {Block[]} blocks
-   */
-  constructor (header, blocks) {
-    this._header = header
-    this._blocks = blocks
-    this._keys = blocks.map((b) => b.cid.toString())
-  }
-
-  /**
-   * @property
-   * @memberof CarReader
-   * @instance
-   */
-  get version () {
-    return this._header.version
-  }
-
-  /**
-   * Get the list of roots defined by the CAR referenced by this reader. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots () {
-    return this._header.roots
-  }
-
-  /**
-   * Check whether a given `CID` exists within the CAR referenced by this
-   * reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<boolean>}
-   */
-  async has (key) {
-    return this._keys.indexOf(key.toString()) > -1
-  }
-
-  /**
-   * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
-   * referenced by this reader matching the provided `CID`. In the case where
-   * the provided `CID` doesn't exist within the CAR, `undefined` will be
-   * returned.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<Block | undefined>}
-   */
-  async get (key) {
-    const index = this._keys.indexOf(key.toString())
-    return index > -1 ? this._blocks[index] : undefined
-  }
-
-  /**
-   * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
-   * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
-   * the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<Block>}
-   */
-  async * blocks () {
-    for (const block of this._blocks) {
-      yield block
-    }
-  }
-
-  /**
-   * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
-   * the `CID`s contained within the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<CID>}
-   */
-  async * cids () {
-    for (const block of this._blocks) {
-      yield block.cid
-    }
-  }
-
-  /**
-   * Instantiate a {@link CarReader} from a `Uint8Array` blob. This performs a
-   * decode fully in memory and maintains the decoded state in memory for full
-   * access to the data via the `CarReader` API.
-   *
-   * @async
-   * @static
-   * @memberof CarReader
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarReader>}
-   */
-  static async fromBytes (bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError('fromBytes() requires a Uint8Array')
-    }
-    return decodeReaderComplete(bytesReader(bytes))
-  }
-
-  /**
-   * Instantiate a {@link CarReader} 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).
-   * This performs a decode fully in memory and maintains the decoded state in
-   * memory for full access to the data via the `CarReader` API.
-   *
-   * Care should be taken for large archives; this API may not be appropriate
-   * where memory is a concern or the archive is potentially larger than the
-   * amount of memory that the runtime can handle.
-   *
-   * @async
-   * @static
-   * @memberof CarReader
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarReader>}
-   */
-  static async fromIterable (asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === 'function')) {
-      throw new TypeError('fromIterable() requires an async iterable')
-    }
-    return decodeReaderComplete(asyncIterableReader(asyncIterable))
-  }
-}
-
-/**
- * @private
- * @param {BytesReader} reader
- * @returns {Promise<CarReader>}
- */
-export async function decodeReaderComplete (reader) {
-  const decoder = createDecoder(reader)
-  const header = await decoder.header()
-  const blocks = []
-  for await (const block of decoder.blocks()) {
-    blocks.push(block)
-  }
-
-  return new CarReader(header, blocks)
-}
-
-export const __browser = true

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

@@ -1,56 +0,0 @@
-import fs from 'fs'
-import { promisify } from 'util'
-import { CarReader as BrowserCarReader } from './reader-browser.js'
-
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./api').CarReader} CarReaderIface
- */
-
-const fsread = promisify(fs.read)
-
-/**
- * @class
- * @implements {CarReaderIface}
- */
-export class CarReader extends BrowserCarReader {
-  /**
-   * Reads a block directly from a file descriptor for an open CAR file. This
-   * function is **only available in Node.js** and not a browser environment.
-   *
-   * This function can be used in connection with {@link CarIndexer} which emits
-   * the `BlockIndex` objects that are required by this function.
-   *
-   * The user is responsible for opening and closing the file used in this call.
-   *
-   * @async
-   * @static
-   * @memberof CarReader
-   * @param {fs.promises.FileHandle | number} fd - A file descriptor from the
-   * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
-   * from `fs.promises.open()`.
-   * @param {BlockIndex} blockIndex - An index pointing to the location of the
-   * Block required. This `BlockIndex` should take the form:
-   * `{cid:CID, blockLength:number, blockOffset:number}`.
-   * @returns {Promise<Block>} A `{ cid:CID, bytes:Uint8Array }` pair.
-   */
-  static async readRaw (fd, blockIndex) {
-    const { cid, blockLength, blockOffset } = blockIndex
-    const bytes = new Uint8Array(blockLength)
-    let read
-    if (typeof fd === 'number') {
-      read = (await fsread(fd, bytes, 0, blockLength, blockOffset)).bytesRead
-    } else if (typeof fd === 'object' && typeof fd.read === 'function') { // FileDescriptor
-      read = (await fd.read(bytes, 0, blockLength, blockOffset)).bytesRead
-    } else {
-      throw new TypeError('Bad fd')
-    }
-    if (read !== blockLength) {
-      throw new Error(`Failed to read entire block (${read} instead of ${blockLength})`)
-    }
-    return { cid, bytes }
-  }
-}
-
-export const __browser = false

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

@@ -1,250 +0,0 @@
-import { CID } from 'multiformats/cid'
-import { bytesReader, readHeader } from './decoder.js'
-import { createEncoder, createHeader } from './encoder.js'
-import { create as iteratorChannel } from './iterator-channel.js'
-
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockWriter} BlockWriter
- * @typedef {import('./api').WriterChannel} WriterChannel
- * @typedef {import('./coding').CarEncoder} CarEncoder
- * @typedef {import('./coding').IteratorChannel<Uint8Array>} IteratorChannel
- */
-
-/**
- * Provides a writer interface for the creation of CAR files.
- *
- * Creation of a `CarWriter` involves the instatiation of an input / output pair
- * in the form of a `WriterChannel`, which is a
- * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair. These two
- * components form what can be thought of as a stream-like interface. The
- * `writer` component (an instantiated `CarWriter`), has methods to
- * {@link CarWriter.put `put()`} new blocks and {@link CarWriter.put `close()`}
- * the writing operation (finalising the CAR archive). The `out` component is
- * an `AsyncIterable` that yields the bytes of the archive. This can be
- * redirected to a file or other sink. In Node.js, you can use the
- * [`Readable.from()`](https://nodejs.org/api/stream.html#stream_stream_readable_from_iterable_options)
- * API to convert this to a standard Node.js stream, or it can be directly fed
- * to a
- * [`stream.pipeline()`](https://nodejs.org/api/stream.html#stream_stream_pipeline_source_transforms_destination_callback).
- *
- * The channel will provide a form of backpressure. The `Promise` from a
- * `write()` won't resolve until the resulting data is drained from the `out`
- * iterable.
- *
- * It is also possible to ignore the `Promise` from `write()` calls and allow
- * the generated data to queue in memory. This should be avoided for large CAR
- * archives of course due to the memory costs and potential for memory overflow.
- *
- * Load this class with either
- * `import { CarWriter } from '@ipld/car/writer'`
- * (`const { CarWriter } = require('@ipld/car/writer')`). Or
- * `import { CarWriter } from '@ipld/car'`
- * (`const { CarWriter } = require('@ipld/car')`). The former will likely
- * result in smaller bundle sizes where this is important.
- *
- * @name CarWriter
- * @class
- * @implements {BlockWriter}
- */
-export class CarWriter {
-  /**
-   * @param {CID[]} roots
-   * @param {CarEncoder} encoder
-   */
-  constructor (roots, encoder) {
-    this._encoder = encoder
-    /** @type {Promise<void>} */
-    this._mutex = encoder.setRoots(roots)
-    this._ended = false
-  }
-
-  /**
-   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-   * @returns {Promise<void>} The returned promise will only resolve once the
-   * bytes this block generates are written to the `out` iterable.
-   */
-  async put (block) {
-    if (!(block.bytes instanceof Uint8Array) || !block.cid) {
-      throw new TypeError('Can only write {cid, bytes} objects')
-    }
-    if (this._ended) {
-      throw new Error('Already closed')
-    }
-    const cid = CID.asCID(block.cid)
-    if (!cid) {
-      throw new TypeError('Can only write {cid, bytes} objects')
-    }
-    this._mutex = this._mutex.then(() => this._encoder.writeBlock({ cid, bytes: block.bytes }))
-    return this._mutex
-  }
-
-  /**
-   * Finalise the CAR archive and signal that the `out` iterable should end once
-   * any remaining bytes are written.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @returns {Promise<void>}
-   */
-  async close () {
-    if (this._ended) {
-      throw new Error('Already closed')
-    }
-    await this._mutex
-    this._ended = true
-    return this._encoder.close()
-  }
-
-  /**
-   * Returns the version number of the CAR file being written
-   *
-   * @returns {number}
-   */
-  version () {
-    return this._encoder.version()
-  }
-
-  /**
-   * Create a new CAR writer "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {CID[] | CID | void} roots
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static create (roots) {
-    roots = toRoots(roots)
-    const { encoder, iterator } = encodeWriter()
-    const writer = new CarWriter(roots, encoder)
-    const out = new CarWriterOut(iterator)
-    return { writer, out }
-  }
-
-  /**
-   * Create a new CAR appender "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   * This appender does not consider roots and does not produce a CAR header.
-   * It is designed to append blocks to an _existing_ CAR archive. It is
-   * expected that `out` will be concatenated onto the end of an existing
-   * archive that already has a properly formatted header.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static createAppender () {
-    const { encoder, iterator } = encodeWriter()
-    encoder.setRoots = () => Promise.resolve()
-    const writer = new CarWriter([], encoder)
-    const out = new CarWriterOut(iterator)
-    return { writer, out }
-  }
-
-  /**
-   * Update the list of roots in the header of an existing CAR as represented
-   * in a Uint8Array.
-   *
-   * This operation is an _overwrite_, the total length of the CAR will not be
-   * modified. A rejection will occur if the new header will not be the same
-   * length as the existing header, in which case the CAR will not be modified.
-   * It is the responsibility of the user to ensure that the roots being
-   * replaced encode as the same length as the new roots.
-   *
-   * The byte array passed in an argument will be modified and also returned
-   * upon successful modification.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {Uint8Array} bytes
-   * @param {CID[]} roots - A new list of roots to replace the existing list in
-   * the CAR header. The new header must take up the same number of bytes as the
-   * existing header, so the roots should collectively be the same byte length
-   * as the existing roots.
-   * @returns {Promise<Uint8Array>}
-   */
-  static async updateRootsInBytes (bytes, roots) {
-    const reader = bytesReader(bytes)
-    await readHeader(reader)
-    const newHeader = createHeader(roots)
-    if (Number(reader.pos) !== newHeader.length) {
-      throw new Error(`updateRoots() can only overwrite a header of the same length (old header is ${reader.pos} bytes, new header is ${newHeader.length} bytes)`)
-    }
-    bytes.set(newHeader, 0)
-    return bytes
-  }
-}
-
-/**
- * @class
- * @implements {AsyncIterable<Uint8Array>}
- */
-export class CarWriterOut {
-  /**
-   * @param {AsyncIterator<Uint8Array>} iterator
-   */
-  constructor (iterator) {
-    this._iterator = iterator
-  }
-
-  [Symbol.asyncIterator] () {
-    if (this._iterating) {
-      throw new Error('Multiple iterator not supported')
-    }
-    this._iterating = true
-    return this._iterator
-  }
-}
-
-function encodeWriter () {
-  /** @type {IteratorChannel} */
-  const iw = iteratorChannel()
-  const { writer, iterator } = iw
-  const encoder = createEncoder(writer)
-  return { encoder, iterator }
-}
-
-/**
- * @private
- * @param {CID[] | CID | void} roots
- * @returns {CID[]}
- */
-function toRoots (roots) {
-  if (roots === undefined) {
-    return []
-  }
-
-  if (!Array.isArray(roots)) {
-    const cid = CID.asCID(roots)
-    if (!cid) {
-      throw new TypeError('roots must be a single CID or an array of CIDs')
-    }
-    return [cid]
-  }
-
-  const _roots = []
-  for (const root of roots) {
-    const _root = CID.asCID(root)
-    if (!_root) {
-      throw new TypeError('roots must be a single CID or an array of CIDs')
-    }
-    _roots.push(_root)
-  }
-  return _roots
-}
-
-export const __browser = true

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

@@ -1,84 +0,0 @@
-import fs from 'fs'
-import { promisify } from 'util'
-import { readHeader, chunkReader } from './decoder.js'
-import { createHeader } from './encoder.js'
-import { CarWriter as BrowserCarWriter } from './writer-browser.js'
-
-const fsread = promisify(fs.read)
-const fswrite = promisify(fs.write)
-
-/**
- * @typedef {import('multiformats/cid').CID} CID
- * @typedef {import('./api').BlockWriter} BlockWriter
- */
-
-/**
- * @class
- * @implements {BlockWriter}
- */
-export class CarWriter extends BrowserCarWriter {
-  /**
-   * Update the list of roots in the header of an existing CAR file. The first
-   * argument must be a file descriptor for CAR file that is open in read and
-   * write mode (not append), e.g. `fs.open` or `fs.promises.open` with `'r+'`
-   * mode.
-   *
-   * This operation is an _overwrite_, the total length of the CAR will not be
-   * modified. A rejection will occur if the new header will not be the same
-   * length as the existing header, in which case the CAR will not be modified.
-   * It is the responsibility of the user to ensure that the roots being
-   * replaced encode as the same length as the new roots.
-   *
-   * This function is **only available in Node.js** and not a browser
-   * environment.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {fs.promises.FileHandle | number} fd - A file descriptor from the
-   * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
-   * from `fs.promises.open()`.
-   * @param {CID[]} roots - A new list of roots to replace the existing list in
-   * the CAR header. The new header must take up the same number of bytes as the
-   * existing header, so the roots should collectively be the same byte length
-   * as the existing roots.
-   * @returns {Promise<void>}
-   */
-  static async updateRootsInFile (fd, roots) {
-    const chunkSize = 256
-    /** @type {Uint8Array} */
-    let bytes
-    let offset = 0
-
-    /** @type {() => Promise<number>} */
-    let readChunk
-    if (typeof fd === 'number') {
-      readChunk = async () => (await fsread(fd, bytes, 0, chunkSize, offset)).bytesRead
-    } else if (typeof fd === 'object' && typeof fd.read === 'function') { // FileDescriptor
-      readChunk = async () => (await fd.read(bytes, 0, chunkSize, offset)).bytesRead
-    } else {
-      throw new TypeError('Bad fd')
-    }
-    const fdReader = chunkReader(async () => {
-      bytes = new Uint8Array(chunkSize) // need a new chunk each time, can't reuse old
-      const read = await readChunk()
-      offset += read
-      /* eslint no-warning-comments: 0 */
-      // TODO: test header > 256 bytes
-      return read < chunkSize ? bytes.subarray(0, read) : bytes
-    })
-
-    await readHeader(fdReader)
-    const newHeader = createHeader(roots)
-    if (fdReader.pos !== newHeader.length) {
-      throw new Error(`updateRoots() can only overwrite a header of the same length (old header is ${fdReader.pos} bytes, new header is ${newHeader.length} bytes)`)
-    }
-    if (typeof fd === 'number') {
-      await fswrite(fd, newHeader, 0, newHeader.length, 0)
-    } else if (typeof fd === 'object' && typeof fd.read === 'function') { // FileDescriptor
-      await fd.write(newHeader, 0, newHeader.length, 0)
-    }
-  }
-}
-
-export const __browser = false

package/src/@ipld/dag-cbor/dag-cbor/LICENSE

@@ -1,4 +0,0 @@
-This project is dual licensed under MIT and Apache-2.0.
-
-MIT: https://www.opensource.org/licenses/mit
-Apache-2.0: https://www.apache.org/licenses/license-2.0

package/src/@ipld/dag-cbor/dag-cbor/README.md

@@ -1,80 +0,0 @@
-# @ipld/dag-cbor <!-- omit in toc -->
-
-[![codecov](https://img.shields.io/codecov/c/github/ipld/js-dag-cbor.svg?style=flat-square)](https://codecov.io/gh/ipld/js-dag-cbor)
-[![CI](https://img.shields.io/github/workflow/status/ipld/js-dag-cbor/test%20&%20maybe%20release/master?style=flat-square)](https://github.com/ipld/js-dag-cbor/actions/workflows/js-test-and-release.yml)
-
-> JS implementation of DAG-CBOR
-
-## Table of contents <!-- omit in toc -->
-
-- [Install](#install)
-- [Spec](#spec)
-- [License](#license)
-- [Contribute](#contribute)
-
-## Install
-
-```console
-$ npm i @ipld/dag-cbor
-```
-
-This is the *new* interface meant for use by itself or with `multiformats` and
-`@ipld/block`. It is not used by `js-ipld-format` which is currently
-used in IPFS. That library is [here](https://github.com/ipld/js-ipld-dag-cbor).
-
-Usage:
-
-```javascript
-import { encode, decode } from '@ipld/dag-cbor'
-import { CID } from 'multiformats'
-
-const obj = {
-  x: 1,
-  /* CID instances are encoded as links */
-  y: [2, 3, CID.parse('QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4')],
-  z: {
-    a: CID.parse('QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4'),
-    b: null,
-    c: 'string'
-  }
-}
-
-let data = encode(obj)
-let decoded = decode(data)
-decoded.y[0] // 2
-CID.asCID(decoded.z.a) // cid instance
-
-// encode/decode options are exported for use with cborg's encodedLength and decodeFirst
-import { encodeOptions, decodeOptions } from '@ipld/dag-cbor'
-import { encodedLength } from 'cborg/length'
-import { decodeFirst } from 'cborg'
-
-// dag-cbor encoded length of obj in bytes
-const byteLength = encodedLength(obj, encodeOptions)
-byteLength // 104
-
-// concatenate two dag-cbor encoded obj
-const concatenatedData = new Uint8Array(data.length * 2)
-concatenatedData.set(data)
-concatenatedData.set(data, data.length)
-
-// returns dag-cbor decoded obj at the beginning of the buffer as well as the remaining bytes
-const [first, remainder] = decodeFirst(concatenatedData, decodeOptions)
-assert.deepStrictEqual(first, obj)
-assert.deepStrictEqual(remainder, data)
-```
-
-## Spec
-
-The [`dag-cbor` specification is in the IPLD specs repo](https://github.com/ipld/specs/blob/master/block-layer/codecs/dag-cbor.md).
-
-## License
-
-Licensed under either of
-
-- Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
-- MIT ([LICENSE-MIT](LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
-
-## Contribute
-
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.