@ipld/car 4.1.5 → 5.0.0

package/cjs/lib/indexer.js

@@ -1,41 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var decoder = require('./decoder.js');
-
-class CarIndexer {
-  constructor(version, roots, iterator) {
-    this._version = version;
-    this._roots = roots;
-    this._iterator = iterator;
-  }
-  get version() {
-    return this._version;
-  }
-  async getRoots() {
-    return this._roots;
-  }
-  [Symbol.asyncIterator]() {
-    return this._iterator;
-  }
-  static async fromBytes(bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError('fromBytes() requires a Uint8Array');
-    }
-    return decodeIndexerComplete(decoder.bytesReader(bytes));
-  }
-  static async fromIterable(asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === 'function')) {
-      throw new TypeError('fromIterable() requires an async iterable');
-    }
-    return decodeIndexerComplete(decoder.asyncIterableReader(asyncIterable));
-  }
-}
-async function decodeIndexerComplete(reader) {
-  const decoder$1 = decoder.createDecoder(reader);
-  const {version, roots} = await decoder$1.header();
-  return new CarIndexer(version, roots, decoder$1.blocksIndex());
-}
-
-exports.CarIndexer = CarIndexer;

package/cjs/lib/iterator-channel.js

@@ -1,77 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function noop() {
-}
-function create() {
-  const chunkQueue = [];
-  let drainer = null;
-  let drainerResolver = noop;
-  let ended = false;
-  let outWait = null;
-  let outWaitResolver = noop;
-  const makeDrainer = () => {
-    if (!drainer) {
-      drainer = new Promise(resolve => {
-        drainerResolver = () => {
-          drainer = null;
-          drainerResolver = noop;
-          resolve();
-        };
-      });
-    }
-    return drainer;
-  };
-  const writer = {
-    write(chunk) {
-      chunkQueue.push(chunk);
-      const drainer = makeDrainer();
-      outWaitResolver();
-      return drainer;
-    },
-    async end() {
-      ended = true;
-      const drainer = makeDrainer();
-      outWaitResolver();
-      await drainer;
-    }
-  };
-  const iterator = {
-    async next() {
-      const chunk = chunkQueue.shift();
-      if (chunk) {
-        if (chunkQueue.length === 0) {
-          drainerResolver();
-        }
-        return {
-          done: false,
-          value: chunk
-        };
-      }
-      if (ended) {
-        drainerResolver();
-        return {
-          done: true,
-          value: undefined
-        };
-      }
-      if (!outWait) {
-        outWait = new Promise(resolve => {
-          outWaitResolver = () => {
-            outWait = null;
-            outWaitResolver = noop;
-            return resolve(iterator.next());
-          };
-        });
-      }
-      return outWait;
-    }
-  };
-  return {
-    writer,
-    iterator
-  };
-}
-
-exports.create = create;

package/cjs/lib/iterator.js

@@ -1,97 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var decoder = require('./decoder.js');
-
-class CarIteratorBase {
-  constructor(version, roots, iterable) {
-    this._version = version;
-    this._roots = roots;
-    this._iterable = iterable;
-    this._decoded = false;
-  }
-  get version() {
-    return this._version;
-  }
-  async getRoots() {
-    return this._roots;
-  }
-}
-class CarBlockIterator extends CarIteratorBase {
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error('Cannot decode more than once');
-    }
-    if (!this._iterable) {
-      throw new Error('Block iterable not found');
-    }
-    this._decoded = true;
-    return this._iterable[Symbol.asyncIterator]();
-  }
-  static async fromBytes(bytes) {
-    const {version, roots, iterator} = await fromBytes(bytes);
-    return new CarBlockIterator(version, roots, iterator);
-  }
-  static async fromIterable(asyncIterable) {
-    const {version, roots, iterator} = await fromIterable(asyncIterable);
-    return new CarBlockIterator(version, roots, iterator);
-  }
-}
-class CarCIDIterator extends CarIteratorBase {
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error('Cannot decode more than once');
-    }
-    if (!this._iterable) {
-      throw new Error('Block iterable not found');
-    }
-    this._decoded = true;
-    const iterable = this._iterable[Symbol.asyncIterator]();
-    return {
-      async next() {
-        const next = await iterable.next();
-        if (next.done) {
-          return next;
-        }
-        return {
-          done: false,
-          value: next.value.cid
-        };
-      }
-    };
-  }
-  static async fromBytes(bytes) {
-    const {version, roots, iterator} = await fromBytes(bytes);
-    return new CarCIDIterator(version, roots, iterator);
-  }
-  static async fromIterable(asyncIterable) {
-    const {version, roots, iterator} = await fromIterable(asyncIterable);
-    return new CarCIDIterator(version, roots, iterator);
-  }
-}
-async function fromBytes(bytes) {
-  if (!(bytes instanceof Uint8Array)) {
-    throw new TypeError('fromBytes() requires a Uint8Array');
-  }
-  return decodeIterator(decoder.bytesReader(bytes));
-}
-async function fromIterable(asyncIterable) {
-  if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === 'function')) {
-    throw new TypeError('fromIterable() requires an async iterable');
-  }
-  return decodeIterator(decoder.asyncIterableReader(asyncIterable));
-}
-async function decodeIterator(reader) {
-  const decoder$1 = decoder.createDecoder(reader);
-  const {version, roots} = await decoder$1.header();
-  return {
-    version,
-    roots,
-    iterator: decoder$1.blocks()
-  };
-}
-
-exports.CarBlockIterator = CarBlockIterator;
-exports.CarCIDIterator = CarCIDIterator;
-exports.CarIteratorBase = CarIteratorBase;

package/cjs/lib/reader-browser.js

@@ -1,62 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var decoder = require('./decoder.js');
-
-class CarReader {
-  constructor(header, blocks) {
-    this._header = header;
-    this._blocks = blocks;
-    this._keys = blocks.map(b => b.cid.toString());
-  }
-  get version() {
-    return this._header.version;
-  }
-  async getRoots() {
-    return this._header.roots;
-  }
-  async has(key) {
-    return this._keys.indexOf(key.toString()) > -1;
-  }
-  async get(key) {
-    const index = this._keys.indexOf(key.toString());
-    return index > -1 ? this._blocks[index] : undefined;
-  }
-  async *blocks() {
-    for (const block of this._blocks) {
-      yield block;
-    }
-  }
-  async *cids() {
-    for (const block of this._blocks) {
-      yield block.cid;
-    }
-  }
-  static async fromBytes(bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError('fromBytes() requires a Uint8Array');
-    }
-    return decodeReaderComplete(decoder.bytesReader(bytes));
-  }
-  static async fromIterable(asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === 'function')) {
-      throw new TypeError('fromIterable() requires an async iterable');
-    }
-    return decodeReaderComplete(decoder.asyncIterableReader(asyncIterable));
-  }
-}
-async function decodeReaderComplete(reader) {
-  const decoder$1 = decoder.createDecoder(reader);
-  const header = await decoder$1.header();
-  const blocks = [];
-  for await (const block of decoder$1.blocks()) {
-    blocks.push(block);
-  }
-  return new CarReader(header, blocks);
-}
-const __browser = true;
-
-exports.CarReader = CarReader;
-exports.__browser = __browser;
-exports.decodeReaderComplete = decodeReaderComplete;

package/cjs/lib/reader.js

@@ -1,38 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('fs');
-var util = require('util');
-var readerBrowser = require('./reader-browser.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-const fsread = util.promisify(fs__default["default"].read);
-class CarReader extends readerBrowser.CarReader {
-  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') {
-      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
-    };
-  }
-}
-const __browser = false;
-
-exports.CarReader = CarReader;
-exports.__browser = __browser;

package/cjs/lib/writer-browser.js

@@ -1,118 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var cid = require('multiformats/cid');
-var encoder = require('./encoder.js');
-var iteratorChannel = require('./iterator-channel.js');
-var decoder = require('./decoder.js');
-
-class CarWriter {
-  constructor(roots, encoder) {
-    this._encoder = encoder;
-    this._mutex = encoder.setRoots(roots);
-    this._ended = false;
-  }
-  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$1 = cid.CID.asCID(block.cid);
-    if (!cid$1) {
-      throw new TypeError('Can only write {cid, bytes} objects');
-    }
-    this._mutex = this._mutex.then(() => this._encoder.writeBlock({
-      cid: cid$1,
-      bytes: block.bytes
-    }));
-    return this._mutex;
-  }
-  async close() {
-    if (this._ended) {
-      throw new Error('Already closed');
-    }
-    await this._mutex;
-    this._ended = true;
-    return this._encoder.close();
-  }
-  static create(roots) {
-    roots = toRoots(roots);
-    const {encoder, iterator} = encodeWriter();
-    const writer = new CarWriter(roots, encoder);
-    const out = new CarWriterOut(iterator);
-    return {
-      writer,
-      out
-    };
-  }
-  static createAppender() {
-    const {encoder, iterator} = encodeWriter();
-    encoder.setRoots = () => Promise.resolve();
-    const writer = new CarWriter([], encoder);
-    const out = new CarWriterOut(iterator);
-    return {
-      writer,
-      out
-    };
-  }
-  static async updateRootsInBytes(bytes, roots) {
-    const reader = decoder.bytesReader(bytes);
-    await decoder.readHeader(reader);
-    const newHeader = encoder.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 CarWriterOut {
-  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() {
-  const iw = iteratorChannel.create();
-  const {writer, iterator} = iw;
-  const encoder$1 = encoder.createEncoder(writer);
-  return {
-    encoder: encoder$1,
-    iterator
-  };
-}
-function toRoots(roots) {
-  if (roots === undefined) {
-    return [];
-  }
-  if (!Array.isArray(roots)) {
-    const cid$1 = cid.CID.asCID(roots);
-    if (!cid$1) {
-      throw new TypeError('roots must be a single CID or an array of CIDs');
-    }
-    return [cid$1];
-  }
-  const _roots = [];
-  for (const root of roots) {
-    const _root = cid.CID.asCID(root);
-    if (!_root) {
-      throw new TypeError('roots must be a single CID or an array of CIDs');
-    }
-    _roots.push(_root);
-  }
-  return _roots;
-}
-const __browser = true;
-
-exports.CarWriter = CarWriter;
-exports.CarWriterOut = CarWriterOut;
-exports.__browser = __browser;

package/cjs/lib/writer.js

@@ -1,51 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('fs');
-var util = require('util');
-var writerBrowser = require('./writer-browser.js');
-var decoder = require('./decoder.js');
-var encoder = require('./encoder.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-const fsread = util.promisify(fs__default["default"].read);
-const fswrite = util.promisify(fs__default["default"].write);
-class CarWriter extends writerBrowser.CarWriter {
-  static async updateRootsInFile(fd, roots) {
-    const chunkSize = 256;
-    let bytes;
-    let offset = 0;
-    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') {
-      readChunk = async () => (await fd.read(bytes, 0, chunkSize, offset)).bytesRead;
-    } else {
-      throw new TypeError('Bad fd');
-    }
-    const fdReader = decoder.chunkReader(async () => {
-      bytes = new Uint8Array(chunkSize);
-      const read = await readChunk();
-      offset += read;
-      return read < chunkSize ? bytes.subarray(0, read) : bytes;
-    });
-    await decoder.readHeader(fdReader);
-    const newHeader = encoder.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') {
-      await fd.write(newHeader, 0, newHeader.length, 0);
-    }
-  }
-}
-const __browser = false;
-
-exports.CarWriter = CarWriter;
-exports.__browser = __browser;