web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/it-length-prefixed-stream/dist/src/errors.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * The reported length of the next data message was not a positive integer
+ */
+class InvalidMessageLengthError extends Error {
+  name = 'InvalidMessageLengthError';
+  code = 'ERR_INVALID_MSG_LENGTH';
+}
+/**
+ * The reported length of the next data message was larger than the configured
+ * max allowable value
+ */
+class InvalidDataLengthError extends Error {
+  name = 'InvalidDataLengthError';
+  code = 'ERR_MSG_DATA_TOO_LONG';
+}
+/**
+ * The varint used to specify the length of the next data message contained more
+ * bytes than the configured max allowable value
+ */
+class InvalidDataLengthLengthError extends Error {
+  name = 'InvalidDataLengthLengthError';
+  code = 'ERR_MSG_LENGTH_TOO_LONG';
+}
+
+exports.InvalidDataLengthError = InvalidDataLengthError;
+exports.InvalidDataLengthLengthError = InvalidDataLengthLengthError;
+exports.InvalidMessageLengthError = InvalidMessageLengthError;

package/dist/cjs/node_modules/it-length-prefixed-stream/dist/src/index.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var index = require('../../../it-byte-stream/dist/src/index.js');
+var index$1 = require('../../../uint8-varint/dist/src/index.js');
+var index$2 = require('../../../uint8arraylist/dist/src/index.js');
+var errors = require('./errors.js');
+
+/**
+ * @packageDocumentation
+ *
+ * This module makes it easy to send and receive length-prefixed byte arrays over streams.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { lpStream } from 'it-length-prefixed-stream'
+ *
+ * const stream = lpStream(duplex)
+ *
+ * // read the next length-prefixed chunk
+ * const bytes = await stream.read()
+ *
+ * // write a length-prefixed chunk
+ * await stream.write(Uint8Array.from([0, 1, 2, 3, 4]))
+ *
+ * // write several chunks, all individually length-prefixed
+ * await stream.writeV([
+ *   Uint8Array.from([0, 1, 2, 3, 4]),
+ *   Uint8Array.from([5, 6, 7, 8, 9])
+ * ])
+ * ```
+ */
+function lpStream(duplex) {
+  let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const bytes = index.byteStream(duplex, opts);
+  if (opts.maxDataLength != null && opts.maxLengthLength == null) {
+    // if max data length is set but max length length is not, calculate the
+    // max length length needed to encode max data length
+    opts.maxLengthLength = index$1.encodingLength(opts.maxDataLength);
+  }
+  const decodeLength = opts?.lengthDecoder ?? index$1.decode;
+  const encodeLength = opts?.lengthEncoder ?? index$1.encode;
+  const W = {
+    read: async options => {
+      let dataLength = -1;
+      const lengthBuffer = new index$2.Uint8ArrayList();
+      while (true) {
+        // read one byte at a time until we can decode a varint
+        lengthBuffer.append(await bytes.read({
+          ...options,
+          bytes: 1
+        }));
+        try {
+          dataLength = decodeLength(lengthBuffer);
+        } catch (err) {
+          if (err instanceof RangeError) {
+            continue;
+          }
+          throw err;
+        }
+        if (dataLength < 0) {
+          throw new errors.InvalidMessageLengthError('Invalid message length');
+        }
+        if (opts?.maxLengthLength != null && lengthBuffer.byteLength > opts.maxLengthLength) {
+          throw new errors.InvalidDataLengthLengthError('message length length too long');
+        }
+        if (dataLength > -1) {
+          break;
+        }
+      }
+      if (opts?.maxDataLength != null && dataLength > opts.maxDataLength) {
+        throw new errors.InvalidDataLengthError('message length too long');
+      }
+      return bytes.read({
+        ...options,
+        bytes: dataLength
+      });
+    },
+    write: async (data, options) => {
+      // encode, write
+      await bytes.write(new index$2.Uint8ArrayList(encodeLength(data.byteLength), data), options);
+    },
+    writeV: async (data, options) => {
+      const list = new index$2.Uint8ArrayList(...data.flatMap(buf => [encodeLength(buf.byteLength), buf]));
+      // encode, write
+      await bytes.write(list, options);
+    },
+    unwrap: () => {
+      return bytes.unwrap();
+    }
+  };
+  return W;
+}
+
+exports.lpStream = lpStream;

package/dist/cjs/node_modules/it-merge/dist/src/index.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../it-queueless-pushable/dist/src/index.js');
+
+/**
+ * @packageDocumentation
+ *
+ * Merge several (async)iterables into one, yield values as they arrive.
+ *
+ * Nb. sources are iterated over in parallel so the order of emitted items is not guaranteed.
+ *
+ * @example
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values1 = [0, 1, 2, 3, 4]
+ * const values2 = [5, 6, 7, 8, 9]
+ *
+ * const arr = all(merge(values1, values2))
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, async iterator, generator, etc
+ * const values1 = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ * const values2 = async function * () {
+ *   yield * [5, 6, 7, 8, 9]
+ * }
+ *
+ * const arr = await all(merge(values1(), values2()))
+ *
+ * console.info(arr) // 0, 1, 5, 6, 2, 3, 4, 7, 8, 9  <- nb. order is not guaranteed
+ * ```
+ */
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+async function addAllToPushable(sources, output, signal) {
+  try {
+    await Promise.all(sources.map(async source => {
+      for await (const item of source) {
+        await output.push(item, {
+          signal
+        });
+        signal.throwIfAborted();
+      }
+    }));
+    await output.end(undefined, {
+      signal
+    });
+  } catch (err) {
+    await output.end(err, {
+      signal
+    }).catch(() => {});
+  }
+}
+async function* mergeSources(sources) {
+  const controller = new AbortController();
+  const output = index.queuelessPushable();
+  addAllToPushable(sources, output, controller.signal).catch(() => {});
+  try {
+    yield* output;
+  } finally {
+    controller.abort();
+  }
+}
+function* mergeSyncSources(syncSources) {
+  for (const source of syncSources) {
+    yield* source;
+  }
+}
+function merge() {
+  const syncSources = [];
+  for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
+    sources[_key] = arguments[_key];
+  }
+  for (const source of sources) {
+    if (!isAsyncIterable(source)) {
+      syncSources.push(source);
+    }
+  }
+  if (syncSources.length === sources.length) {
+    // all sources are synchronous
+    return mergeSyncSources(syncSources);
+  }
+  return mergeSources(sources);
+}
+
+exports.default = merge;

package/dist/cjs/node_modules/it-pair/dist/src/duplex.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var index = require('./index.js');
+
+/**
+ * Two duplex streams that are attached to each other
+ */
+function duplexPair() {
+  const a = index.pair();
+  const b = index.pair();
+  return [{
+    source: a.source,
+    sink: b.sink
+  }, {
+    source: b.source,
+    sink: a.sink
+  }];
+}
+
+exports.duplexPair = duplexPair;

package/dist/cjs/node_modules/it-pair/dist/src/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var index = require('../../../p-defer/index.js');
+
+/**
+ * A pair of streams where one drains from the other
+ */
+function pair() {
+  const deferred = index.default();
+  let piped = false;
+  return {
+    sink: async source => {
+      if (piped) {
+        throw new Error('already piped');
+      }
+      piped = true;
+      deferred.resolve(source);
+    },
+    source: async function* () {
+      const source = await deferred.promise;
+      yield* source;
+    }()
+  };
+}
+
+exports.pair = pair;

package/dist/cjs/node_modules/it-parallel/dist/src/index.js

@@ -0,0 +1,209 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../p-defer/index.js');
+
+/**
+ * @packageDocumentation
+ *
+ * Takes an (async) iterable that emits promise-returning functions, invokes them in parallel up to the concurrency limit and emits the results as they become available, optionally in the same order as the input
+ *
+ * @example
+ *
+ * ```javascript
+ * import parallel from 'it-parallel'
+ * import all from 'it-all'
+ * import delay from 'delay'
+ *
+ * // This can also be an iterator, async iterator, generator, etc
+ * const input = [
+ *   async () => {
+ *     console.info('start 1')
+ *     await delay(500)
+ *
+ *     console.info('end 1')
+ *     return 1
+ *   },
+ *   async () => {
+ *     console.info('start 2')
+ *     await delay(200)
+ *
+ *     console.info('end 2')
+ *     return 2
+ *   },
+ *   async () => {
+ *     console.info('start 3')
+ *     await delay(100)
+ *
+ *     console.info('end 3')
+ *     return 3
+ *   }
+ * ]
+ *
+ * const result = await all(parallel(input, {
+ *   concurrency: 2
+ * }))
+ *
+ * // output:
+ * // start 1
+ * // start 2
+ * // end 2
+ * // start 3
+ * // end 3
+ * // end 1
+ *
+ * console.info(result) // [2, 3, 1]
+ * ```
+ *
+ * If order is important, pass `ordered: true` as an option:
+ *
+ * ```javascript
+ * const result = await all(parallel(input, {
+ *   concurrency: 2,
+ *   ordered: true
+ * }))
+ *
+ * // output:
+ * // start 1
+ * // start 2
+ * // end 2
+ * // start 3
+ * // end 3
+ * // end 1
+ *
+ * console.info(result) // [1, 2, 3]
+ * ```
+ */
+const CustomEvent = globalThis.CustomEvent ?? Event;
+/**
+ * Takes an (async) iterator that emits promise-returning functions,
+ * invokes them in parallel and emits the results as they become available but
+ * in the same order as the input
+ */
+function parallel(source) {
+  try {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return async function* () {
+      let concurrency = options.concurrency ?? Infinity;
+      if (concurrency < 1) {
+        concurrency = Infinity;
+      }
+      const ordered = options.ordered ?? false;
+      const emitter = new EventTarget();
+      const ops = [];
+      let slotAvailable = index.default();
+      let resultAvailable = index.default();
+      let sourceFinished = false;
+      let sourceErr;
+      let opErred = false;
+      emitter.addEventListener('task-complete', () => {
+        resultAvailable.resolve();
+      });
+      void Promise.resolve().then(async () => {
+        try {
+          for await (const task of source) {
+            if (ops.length === concurrency) {
+              slotAvailable = index.default();
+              await slotAvailable.promise;
+            }
+            if (opErred) {
+              break;
+            }
+            const op = {
+              done: false
+            };
+            ops.push(op);
+            task().then(result => {
+              op.done = true;
+              op.ok = true;
+              op.value = result;
+              emitter.dispatchEvent(new CustomEvent('task-complete'));
+            }, err => {
+              op.done = true;
+              op.err = err;
+              emitter.dispatchEvent(new CustomEvent('task-complete'));
+            });
+          }
+          sourceFinished = true;
+          emitter.dispatchEvent(new CustomEvent('task-complete'));
+        } catch (err) {
+          sourceErr = err;
+          emitter.dispatchEvent(new CustomEvent('task-complete'));
+        }
+      });
+      function valuesAvailable() {
+        if (ordered) {
+          return ops[0]?.done;
+        }
+        return Boolean(ops.find(op => op.done));
+      }
+      function* yieldOrderedValues() {
+        while (ops.length > 0 && ops[0].done) {
+          const op = ops[0];
+          ops.shift();
+          if (op.ok) {
+            yield op.value;
+          } else {
+            // allow the source to exit
+            opErred = true;
+            slotAvailable.resolve();
+            throw op.err;
+          }
+          slotAvailable.resolve();
+        }
+      }
+      function* yieldUnOrderedValues() {
+        // more values can become available while we wait for `yield`
+        // to return control to this function
+        while (valuesAvailable()) {
+          for (let i = 0; i < ops.length; i++) {
+            if (ops[i].done) {
+              const op = ops[i];
+              ops.splice(i, 1);
+              i--;
+              if (op.ok) {
+                yield op.value;
+              } else {
+                opErred = true;
+                slotAvailable.resolve();
+                throw op.err;
+              }
+              slotAvailable.resolve();
+            }
+          }
+        }
+      }
+      while (true) {
+        if (!valuesAvailable()) {
+          resultAvailable = index.default();
+          await resultAvailable.promise;
+        }
+        if (sourceErr != null) {
+          // the source threw an error, propagate it
+          throw sourceErr;
+        }
+        if (ordered) {
+          yield* yieldOrderedValues();
+        } else {
+          yield* yieldUnOrderedValues();
+        }
+        if (sourceErr != null) {
+          // if the source yields an array that is `yield *`, it can throw while the
+          // onward consumer is processing the array contents - make sure we
+          // propagate the error
+          // eslint-disable-next-line @typescript-eslint/only-throw-error
+          throw sourceErr;
+        }
+        if (sourceFinished && ops.length === 0) {
+          // not waiting for any results and no more tasks so we are done
+          break;
+        }
+      }
+    }();
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+exports.default = parallel;

package/dist/cjs/node_modules/it-peekable/dist/src/index.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @packageDocumentation
+ *
+ * Lets you look at the contents of an async iterator and decide what to do
+ *
+ * @example
+ *
+ * ```javascript
+ * import peekable from 'it-peekable'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values = [0, 1, 2, 3, 4]
+ *
+ * const it = peekable(value)
+ *
+ * const first = it.peek()
+ *
+ * console.info(first) // 0
+ *
+ * it.push(first)
+ *
+ * console.info([...it])
+ * // [ 0, 1, 2, 3, 4 ]
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * import peekable from 'it-peekable'
+ *
+ * const values = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const it = peekable(values())
+ *
+ * const first = await it.peek()
+ *
+ * console.info(first) // 0
+ *
+ * it.push(first)
+ *
+ * console.info(await all(it))
+ * // [ 0, 1, 2, 3, 4 ]
+ * ```
+ */
+function peekable(iterable) {
+  // @ts-expect-error can't use Symbol.asyncIterator to index iterable since it might be Iterable
+  const [iterator, symbol] = iterable[Symbol.asyncIterator] != null
+  // @ts-expect-error can't use Symbol.asyncIterator to index iterable since it might be Iterable
+  ? [iterable[Symbol.asyncIterator](), Symbol.asyncIterator]
+  // @ts-expect-error can't use Symbol.iterator to index iterable since it might be AsyncIterable
+  : [iterable[Symbol.iterator](), Symbol.iterator];
+  const queue = [];
+  // @ts-expect-error can't use symbol to index peekable
+  return {
+    peek: () => {
+      return iterator.next();
+    },
+    push: value => {
+      queue.push(value);
+    },
+    next: () => {
+      if (queue.length > 0) {
+        return {
+          done: false,
+          value: queue.shift()
+        };
+      }
+      return iterator.next();
+    },
+    [symbol]() {
+      return this;
+    }
+  };
+}
+
+exports.default = peekable;

package/dist/cjs/node_modules/it-pipe/dist/src/index.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var index = require('../../../it-pushable/dist/src/index.js');
+var index$1 = require('../../../it-merge/dist/src/index.js');
+
+function pipe(first) {
+  if (first == null) {
+    throw new Error('Empty pipeline');
+  }
+  // Duplex at start: wrap in function and return duplex source
+  if (isDuplex(first)) {
+    const duplex = first;
+    first = () => duplex.source;
+    // Iterable at start: wrap in function
+  } else if (isIterable(first) || isAsyncIterable(first)) {
+    const source = first;
+    first = () => source;
+  }
+  for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    rest[_key - 1] = arguments[_key];
+  }
+  const fns = [first, ...rest];
+  if (fns.length > 1) {
+    // Duplex at end: use duplex sink
+    if (isDuplex(fns[fns.length - 1])) {
+      fns[fns.length - 1] = fns[fns.length - 1].sink;
+    }
+  }
+  if (fns.length > 2) {
+    // Duplex in the middle, consume source with duplex sink and return duplex source
+    for (let i = 1; i < fns.length - 1; i++) {
+      if (isDuplex(fns[i])) {
+        fns[i] = duplexPipelineFn(fns[i]);
+      }
+    }
+  }
+  return rawPipe(...fns);
+}
+const rawPipe = function () {
+  let res;
+  for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    fns[_key2] = arguments[_key2];
+  }
+  while (fns.length > 0) {
+    res = fns.shift()(res);
+  }
+  return res;
+};
+const isAsyncIterable = obj => {
+  return obj?.[Symbol.asyncIterator] != null;
+};
+const isIterable = obj => {
+  return obj?.[Symbol.iterator] != null;
+};
+const isDuplex = obj => {
+  if (obj == null) {
+    return false;
+  }
+  return obj.sink != null && obj.source != null;
+};
+const duplexPipelineFn = duplex => {
+  return source => {
+    const p = duplex.sink(source);
+    if (p?.then != null) {
+      const stream = index.pushable({
+        objectMode: true
+      });
+      p.then(() => {
+        stream.end();
+      }, err => {
+        stream.end(err);
+      });
+      let sourceWrap;
+      const source = duplex.source;
+      if (isAsyncIterable(source)) {
+        sourceWrap = async function* () {
+          yield* source;
+          stream.end();
+        };
+      } else if (isIterable(source)) {
+        sourceWrap = function* () {
+          yield* source;
+          stream.end();
+        };
+      } else {
+        throw new Error('Unknown duplex source type - must be Iterable or AsyncIterable');
+      }
+      return index$1.default(stream, sourceWrap());
+    }
+    return duplex.source;
+  };
+};
+
+exports.pipe = pipe;
+exports.rawPipe = rawPipe;