web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/@libp2p/utils/dist/src/queue/index.js

@@ -0,0 +1,281 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index$1 = require('../../../../../it-pushable/dist/src/index.js');
+var index = require('../../../../../race-event/dist/src/index.js');
+var debounce = require('../debounce.js');
+var errors = require('../errors.js');
+var job = require('./job.js');
+
+/**
+ * Heavily influence by `p-queue` with the following differences:
+ *
+ * 1. Items remain at the head of the queue while they are running so `queue.size` includes `queue.pending` items - this is so interested parties can join the results of a queue item while it is running
+ * 2. The options for a job are stored separately to the job in order for them to be modified while they are still in the queue
+ */
+class Queue extends _interface.TypedEventEmitter {
+  concurrency;
+  maxSize;
+  queue;
+  pending;
+  sort;
+  constructor() {
+    let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super();
+    this.concurrency = init.concurrency ?? Number.POSITIVE_INFINITY;
+    this.maxSize = init.maxSize ?? Number.POSITIVE_INFINITY;
+    this.pending = 0;
+    if (init.metricName != null) {
+      init.metrics?.registerMetricGroup(init.metricName, {
+        calculate: () => {
+          return {
+            size: this.queue.length,
+            running: this.pending,
+            queued: this.queue.length - this.pending
+          };
+        }
+      });
+    }
+    this.sort = init.sort;
+    this.queue = [];
+    this.emitEmpty = debounce.debounce(this.emitEmpty.bind(this), 1);
+    this.emitIdle = debounce.debounce(this.emitIdle.bind(this), 1);
+  }
+  emitEmpty() {
+    if (this.size !== 0) {
+      return;
+    }
+    this.safeDispatchEvent('empty');
+  }
+  emitIdle() {
+    if (this.running !== 0) {
+      return;
+    }
+    this.safeDispatchEvent('idle');
+  }
+  tryToStartAnother() {
+    if (this.size === 0) {
+      this.emitEmpty();
+      if (this.running === 0) {
+        this.emitIdle();
+      }
+      return false;
+    }
+    if (this.pending < this.concurrency) {
+      let job;
+      for (const j of this.queue) {
+        if (j.status === 'queued') {
+          job = j;
+          break;
+        }
+      }
+      if (job == null) {
+        return false;
+      }
+      this.safeDispatchEvent('active');
+      this.pending++;
+      void job.run().finally(() => {
+        // remove the job from the queue
+        for (let i = 0; i < this.queue.length; i++) {
+          if (this.queue[i] === job) {
+            this.queue.splice(i, 1);
+            break;
+          }
+        }
+        this.pending--;
+        this.tryToStartAnother();
+        this.safeDispatchEvent('next');
+      });
+      return true;
+    }
+    return false;
+  }
+  enqueue(job) {
+    this.queue.push(job);
+    if (this.sort != null) {
+      this.queue.sort(this.sort);
+    }
+  }
+  /**
+   * Adds a sync or async task to the queue. Always returns a promise.
+   */
+  async add(fn, options) {
+    options?.signal?.throwIfAborted();
+    if (this.size === this.maxSize) {
+      throw new errors.QueueFullError();
+    }
+    const job$1 = new job.Job(fn, options);
+    this.enqueue(job$1);
+    this.safeDispatchEvent('add');
+    this.tryToStartAnother();
+    return job$1.join(options).then(result => {
+      this.safeDispatchEvent('completed', {
+        detail: result
+      });
+      this.safeDispatchEvent('success', {
+        detail: {
+          job: job$1,
+          result
+        }
+      });
+      return result;
+    }).catch(err => {
+      if (job$1.status === 'queued') {
+        // job was aborted before it started - remove the job from the queue
+        for (let i = 0; i < this.queue.length; i++) {
+          if (this.queue[i] === job$1) {
+            this.queue.splice(i, 1);
+            break;
+          }
+        }
+      }
+      this.safeDispatchEvent('error', {
+        detail: err
+      });
+      this.safeDispatchEvent('failure', {
+        detail: {
+          job: job$1,
+          error: err
+        }
+      });
+      throw err;
+    });
+  }
+  /**
+   * Clear the queue
+   */
+  clear() {
+    this.queue.splice(0, this.queue.length);
+  }
+  /**
+   * Abort all jobs in the queue and clear it
+   */
+  abort() {
+    this.queue.forEach(job => {
+      job.abort(new _interface.AbortError());
+    });
+    this.clear();
+  }
+  /**
+   * Can be called multiple times. Useful if you for example add additional items at a later time.
+   *
+   * @returns A promise that settles when the queue becomes empty.
+   */
+  async onEmpty(options) {
+    // Instantly resolve if the queue is empty
+    if (this.size === 0) {
+      return;
+    }
+    await index.raceEvent(this, 'empty', options?.signal);
+  }
+  /**
+   * @returns A promise that settles when the queue size is less than the given
+   * limit: `queue.size < limit`.
+   *
+   * If you want to avoid having the queue grow beyond a certain size you can
+   * `await queue.onSizeLessThan()` before adding a new item.
+   *
+   * Note that this only limits the number of items waiting to start. There
+   * could still be up to `concurrency` jobs already running that this call does
+   * not include in its calculation.
+   */
+  async onSizeLessThan(limit, options) {
+    // Instantly resolve if the queue is empty.
+    if (this.size < limit) {
+      return;
+    }
+    await index.raceEvent(this, 'next', options?.signal, {
+      filter: () => this.size < limit
+    });
+  }
+  /**
+   * The difference with `.onEmpty` is that `.onIdle` guarantees that all work
+   * from the queue has finished. `.onEmpty` merely signals that the queue is
+   * empty, but it could mean that some promises haven't completed yet.
+   *
+   * @returns A promise that settles when the queue becomes empty, and all
+   * promises have completed; `queue.size === 0 && queue.pending === 0`.
+   */
+  async onIdle(options) {
+    // Instantly resolve if none pending and if nothing else is queued
+    if (this.pending === 0 && this.size === 0) {
+      return;
+    }
+    await index.raceEvent(this, 'idle', options?.signal);
+  }
+  /**
+   * Size of the queue including running items
+   */
+  get size() {
+    return this.queue.length;
+  }
+  /**
+   * The number of queued items waiting to run.
+   */
+  get queued() {
+    return this.queue.length - this.pending;
+  }
+  /**
+   * The number of items currently running.
+   */
+  get running() {
+    return this.pending;
+  }
+  /**
+   * Returns an async generator that makes it easy to iterate over the results
+   * of jobs added to the queue.
+   *
+   * The generator will end when the queue becomes idle, that is there are no
+   * jobs running and no jobs that have yet to run.
+   *
+   * If you need to keep the queue open indefinitely, consider using it-pushable
+   * instead.
+   */
+  async *toGenerator(options) {
+    options?.signal?.throwIfAborted();
+    const stream = index$1.pushable({
+      objectMode: true
+    });
+    const cleanup = err => {
+      if (err != null) {
+        this.abort();
+      } else {
+        this.clear();
+      }
+      stream.end(err);
+    };
+    const onQueueJobComplete = evt => {
+      if (evt.detail != null) {
+        stream.push(evt.detail);
+      }
+    };
+    const onQueueError = evt => {
+      cleanup(evt.detail);
+    };
+    const onQueueIdle = () => {
+      cleanup();
+    };
+    // clear the queue and throw if the query is aborted
+    const onSignalAbort = () => {
+      cleanup(new _interface.AbortError('Queue aborted'));
+    };
+    // add listeners
+    this.addEventListener('completed', onQueueJobComplete);
+    this.addEventListener('error', onQueueError);
+    this.addEventListener('idle', onQueueIdle);
+    options?.signal?.addEventListener('abort', onSignalAbort);
+    try {
+      yield* stream;
+    } finally {
+      // remove listeners
+      this.removeEventListener('completed', onQueueJobComplete);
+      this.removeEventListener('error', onQueueError);
+      this.removeEventListener('idle', onQueueIdle);
+      options?.signal?.removeEventListener('abort', onSignalAbort);
+      // empty the queue for when the user has broken out of a loop early
+      cleanup();
+    }
+  }
+}
+
+exports.Queue = Queue;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/queue/job.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index = require('../../../../../race-signal/dist/src/index.js');
+var recipient = require('./recipient.js');
+
+/**
+ * Returns a random string
+ */
+function randomId() {
+  return `${parseInt(String(Math.random() * 1e9), 10).toString()}${Date.now()}`;
+}
+class Job {
+  id;
+  fn;
+  options;
+  recipients;
+  status;
+  timeline;
+  controller;
+  constructor(fn, options) {
+    this.id = randomId();
+    this.status = 'queued';
+    this.fn = fn;
+    this.options = options;
+    this.recipients = [];
+    this.timeline = {
+      created: Date.now()
+    };
+    this.controller = new AbortController();
+    _interface.setMaxListeners(Infinity, this.controller.signal);
+    this.onAbort = this.onAbort.bind(this);
+  }
+  abort(err) {
+    this.controller.abort(err);
+  }
+  onAbort() {
+    const allAborted = this.recipients.reduce((acc, curr) => {
+      return acc && curr.signal?.aborted === true;
+    }, true);
+    // if all recipients have aborted the job, actually abort the job
+    if (allAborted) {
+      this.controller.abort(new _interface.AbortError());
+      this.cleanup();
+    }
+  }
+  async join() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const recipient$1 = new recipient.JobRecipient(options.signal);
+    this.recipients.push(recipient$1);
+    options.signal?.addEventListener('abort', this.onAbort);
+    return recipient$1.deferred.promise;
+  }
+  async run() {
+    this.status = 'running';
+    this.timeline.started = Date.now();
+    try {
+      this.controller.signal.throwIfAborted();
+      const result = await index.raceSignal(this.fn({
+        ...(this.options ?? {}),
+        signal: this.controller.signal
+      }), this.controller.signal);
+      this.recipients.forEach(recipient => {
+        recipient.deferred.resolve(result);
+      });
+      this.status = 'complete';
+    } catch (err) {
+      this.recipients.forEach(recipient => {
+        recipient.deferred.reject(err);
+      });
+      this.status = 'errored';
+    } finally {
+      this.timeline.finished = Date.now();
+      this.cleanup();
+    }
+  }
+  cleanup() {
+    this.recipients.forEach(recipient => {
+      recipient.cleanup();
+      recipient.signal?.removeEventListener('abort', this.onAbort);
+    });
+  }
+}
+
+exports.Job = Job;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/queue/recipient.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index = require('../../../../../p-defer/index.js');
+
+class JobRecipient {
+  deferred;
+  signal;
+  constructor(signal) {
+    this.signal = signal;
+    this.deferred = index.default();
+    this.onAbort = this.onAbort.bind(this);
+    this.signal?.addEventListener('abort', this.onAbort);
+  }
+  onAbort() {
+    this.deferred.reject(this.signal?.reason ?? new _interface.AbortError());
+  }
+  cleanup() {
+    this.signal?.removeEventListener('abort', this.onAbort);
+  }
+}
+
+exports.JobRecipient = JobRecipient;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/repeating-task.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index = require('../../../../any-signal/dist/src/index.js');
+
+function repeatingTask(fn, interval, options) {
+  let timeout;
+  let shutdownController;
+  function runTask() {
+    const opts = {
+      signal: shutdownController.signal
+    };
+    if (options?.timeout != null) {
+      const signal = index.anySignal([shutdownController.signal, AbortSignal.timeout(options.timeout)]);
+      _interface.setMaxListeners(Infinity, signal);
+      opts.signal = signal;
+    }
+    Promise.resolve().then(async () => {
+      await fn(opts);
+    }).catch(() => {}).finally(() => {
+      if (shutdownController.signal.aborted) {
+        // task has been cancelled, bail
+        return;
+      }
+      // reschedule
+      timeout = setTimeout(runTask, interval);
+    });
+  }
+  let started = false;
+  return {
+    setInterval: ms => {
+      if (interval === ms) {
+        // already running at this interval, nothing to do
+        return;
+      }
+      interval = ms;
+      // maybe reschedule
+      if (timeout != null) {
+        clearTimeout(timeout);
+        timeout = setTimeout(runTask, interval);
+      }
+    },
+    setTimeout: ms => {
+      options ??= {};
+      options.timeout = ms;
+    },
+    start: () => {
+      if (started) {
+        return;
+      }
+      started = true;
+      shutdownController = new AbortController();
+      _interface.setMaxListeners(Infinity, shutdownController.signal);
+      // run now
+      if (options?.runImmediately === true) {
+        queueMicrotask(() => {
+          runTask();
+        });
+      } else {
+        // run later
+        timeout = setTimeout(runTask, interval);
+      }
+    },
+    stop: () => {
+      clearTimeout(timeout);
+      shutdownController?.abort();
+      started = false;
+    }
+  };
+}
+
+exports.repeatingTask = repeatingTask;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/stream-to-ma-conn.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var index$1 = require('../../../../it-foreach/dist/src/index.js');
+var index = require('../../../../it-pipe/dist/src/index.js');
+
+/**
+ * Convert a duplex iterable into a MultiaddrConnection.
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+function streamToMaConnection(props) {
+  const {
+    stream,
+    remoteAddr,
+    logger,
+    onDataRead,
+    onDataWrite
+  } = props;
+  const log = logger.forComponent('libp2p:stream:converter');
+  let closedRead = false;
+  let closedWrite = false;
+  // piggyback on `stream.close` invocations to close multiaddr connection
+  const streamClose = stream.close.bind(stream);
+  stream.close = async options => {
+    await streamClose(options);
+    close(true);
+  };
+  // piggyback on `stream.abort` invocations to close multiaddr connection
+  const streamAbort = stream.abort.bind(stream);
+  stream.abort = err => {
+    streamAbort(err);
+    close(true);
+  };
+  // piggyback on `stream.sink` invocations to close multiaddr connection
+  const streamSink = stream.sink.bind(stream);
+  stream.sink = async source => {
+    try {
+      await streamSink(index.pipe(source, source => index$1.default(source, buf => onDataWrite?.(buf))));
+    } catch (err) {
+      // If aborted we can safely ignore
+      if (err.type !== 'aborted') {
+        // If the source errored the socket will already have been destroyed by
+        // toIterable.duplex(). If the socket errored it will already be
+        // destroyed. There's nothing to do here except log the error & return.
+        log.error('%s error in sink', remoteAddr, err);
+      }
+    } finally {
+      closedWrite = true;
+      close();
+    }
+  };
+  const maConn = {
+    log,
+    sink: stream.sink,
+    source: async function* () {
+      try {
+        for await (const buf of stream.source) {
+          onDataRead?.(buf);
+          yield buf;
+        }
+      } finally {
+        closedRead = true;
+        close();
+      }
+    }(),
+    remoteAddr,
+    timeline: {
+      open: Date.now(),
+      close: undefined
+    },
+    close: stream.close,
+    abort: stream.abort
+  };
+  function close(force) {
+    if (force === true) {
+      closedRead = true;
+      closedWrite = true;
+    }
+    if (closedRead && closedWrite && maConn.timeline.close == null) {
+      maConn.timeline.close = Date.now();
+    }
+  }
+  return maConn;
+}
+
+exports.streamToMaConnection = streamToMaConnection;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/constants.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var index = require('../../../../uint8-varint/dist/src/index.js');
+var message = require('./private-to-public/pb/message.js');
+
+/**
+ * STUN servers help clients discover their own public IPs.
+ *
+ * Using five or more servers causes warnings to be printed so
+ * ensure we limit it to max x4
+ *
+ * @see https://gist.github.com/mondain/b0ec1cf5f60ae726202e
+ */
+const DEFAULT_ICE_SERVERS = ['stun:stun.l.google.com:19302', 'stun:global.stun.twilio.com:3478', 'stun:stun.cloudflare.com:3478', 'stun:stun.services.mozilla.com:3478'];
+/**
+ * Characters that can be present in a ufrag
+ */
+const UFRAG_ALPHABET = Array.from('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890');
+/**
+ * Used to detect the version of the WebRTC Direct connection protocol in use
+ */
+const UFRAG_PREFIX = 'libp2p+webrtc+v1/';
+/**
+ * The multicodec code for certhash tuples
+ */
+const CODEC_CERTHASH = 0x01d2;
+/**
+ * How much can be buffered to the DataChannel at once
+ */
+const MAX_BUFFERED_AMOUNT = 2 * 1024 * 1024;
+/**
+ * How long time we wait for the 'bufferedamountlow' event to be emitted
+ */
+const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000;
+/**
+ * Max message size that can be sent to the DataChannel. In browsers this is
+ * 256KiB but go-libp2p and rust-libp2p only support 16KiB at the time of
+ * writing.
+ *
+ * @see https://blog.mozilla.org/webrtc/large-data-channel-messages/
+ * @see https://issues.webrtc.org/issues/40644524
+ */
+const MAX_MESSAGE_SIZE = 16 * 1024;
+/**
+ * max protobuf overhead:
+ *
+ * ```
+ * [message-length][flag-field-id+type][flag-field-length][flag-field][message-field-id+type][message-field-length][message-field]
+ * ```
+ */
+function calculateProtobufOverhead() {
+  let maxMessageSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : MAX_MESSAGE_SIZE;
+  // these have a fixed size
+  const messageLength = index.encodingLength(maxMessageSize - index.encodingLength(maxMessageSize));
+  const flagField = 1 + index.encodingLength(Object.keys(message.Message.Flag).length - 1); // id+type/value
+  const messageFieldIdType = 1; // id+type
+  const available = maxMessageSize - messageLength - flagField - messageFieldIdType;
+  // let message-length/message-data fill the rest of the message
+  const messageFieldLengthLength = index.encodingLength(available);
+  return messageLength + flagField + messageFieldIdType + messageFieldLengthLength;
+}
+/**
+ * The protobuf message overhead includes the maximum amount of all bytes in the
+ * protobuf that aren't message field bytes
+ */
+const PROTOBUF_OVERHEAD = calculateProtobufOverhead();
+/**
+ * When closing streams we send a FIN then wait for the remote to
+ * reply with a FIN_ACK. If that does not happen within this timeout
+ * we close the stream anyway.
+ */
+const FIN_ACK_TIMEOUT = 5_000;
+/**
+ * When sending data messages, if the channel is not in the "open" state, wait
+ * this long for the "open" event to fire.
+ */
+const OPEN_TIMEOUT = 5_000;
+/**
+ * When closing a stream, we wait for `bufferedAmount` to become 0 before
+ * closing the underlying RTCDataChannel - this controls how long we wait in ms
+ */
+const DATA_CHANNEL_DRAIN_TIMEOUT = 30_000;
+/**
+ * Set as the 'negotiated' muxer protocol name
+ */
+const MUXER_PROTOCOL = '/webrtc';
+/**
+ * The protocol used for the signalling stream protocol
+ */
+const SIGNALING_PROTOCOL = '/webrtc-signaling/0.0.1';
+/**
+ * Used to store generated certificates in the datastore
+ */
+const DEFAULT_CERTIFICATE_DATASTORE_KEY = '/libp2p/webrtc-direct/certificate';
+/**
+ * Used to store the certificate private key in the keychain
+ */
+const DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME = 'webrtc-direct-certificate-private-key';
+/**
+ * How long the certificate is valid for
+ */
+const DEFAULT_CERTIFICATE_LIFESPAN = 1_209_600_000;
+/**
+ * Renew the certificate this long before it expires
+ */
+const DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD = 86_400_000;
+
+exports.BUFFERED_AMOUNT_LOW_TIMEOUT = BUFFERED_AMOUNT_LOW_TIMEOUT;
+exports.CODEC_CERTHASH = CODEC_CERTHASH;
+exports.DATA_CHANNEL_DRAIN_TIMEOUT = DATA_CHANNEL_DRAIN_TIMEOUT;
+exports.DEFAULT_CERTIFICATE_DATASTORE_KEY = DEFAULT_CERTIFICATE_DATASTORE_KEY;
+exports.DEFAULT_CERTIFICATE_LIFESPAN = DEFAULT_CERTIFICATE_LIFESPAN;
+exports.DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME = DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME;
+exports.DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD = DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD;
+exports.DEFAULT_ICE_SERVERS = DEFAULT_ICE_SERVERS;
+exports.FIN_ACK_TIMEOUT = FIN_ACK_TIMEOUT;
+exports.MAX_BUFFERED_AMOUNT = MAX_BUFFERED_AMOUNT;
+exports.MAX_MESSAGE_SIZE = MAX_MESSAGE_SIZE;
+exports.MUXER_PROTOCOL = MUXER_PROTOCOL;
+exports.OPEN_TIMEOUT = OPEN_TIMEOUT;
+exports.PROTOBUF_OVERHEAD = PROTOBUF_OVERHEAD;
+exports.SIGNALING_PROTOCOL = SIGNALING_PROTOCOL;
+exports.UFRAG_ALPHABET = UFRAG_ALPHABET;
+exports.UFRAG_PREFIX = UFRAG_PREFIX;