@sapphire/event-iterator/dist/cjs/index.cjs

Turns event emitter events into async iterators.

'use strict';

var __defProp = Object.defineProperty;
var __typeError = (msg) => {
  throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
var __privateWrapper = (obj, member, setter, getter) => ({
  set _(value) {
    __privateSet(obj, member, value);
  },
  get _() {
    return __privateGet(obj, member, getter);
  }
});

// src/index.ts
var _ended, _idle, _queue, _passed, _limit, _idleTimer, _push;
var _EventIterator = class _EventIterator {
  /**
   * @param emitter The event emitter to listen to.
   * @param event The event we're listening for to receives values from.
   * @param options Any extra options.
   */
  constructor(emitter, event, options = {}) {
    /**
     * The emitter to listen to.
     */
    __publicField(this, "emitter");
    /**
     * The event the event iterator is listening for to receive values from.
     */
    __publicField(this, "event");
    /**
     * The filter used to filter out values.
     */
    __publicField(this, "filter");
    /**
     * Whether or not the EventIterator has ended.
     */
    __privateAdd(this, _ended, false);
    /**
     * The amount of idle time in ms before moving on.
     */
    __privateAdd(this, _idle);
    /**
     * The queue of received values.
     */
    __privateAdd(this, _queue, []);
    /**
     * The amount of events that have passed the filter.
     */
    __privateAdd(this, _passed, 0);
    /**
     * The limit before ending the EventIterator.
     */
    __privateAdd(this, _limit);
    /**
     * The timer to track when this will idle out.
     */
    __privateAdd(this, _idleTimer, null);
    /**
     * The push handler with context bound to the instance.
     */
    __privateAdd(this, _push);
    this.emitter = emitter;
    this.event = event;
    __privateSet(this, _limit, options.limit ?? Infinity);
    __privateSet(this, _idle, options.idle);
    this.filter = options.filter ?? (() => true);
    if (__privateGet(this, _idle)) __privateSet(this, _idleTimer, setTimeout(this.end.bind(this), __privateGet(this, _idle)));
    __privateSet(this, _push, this.push.bind(this));
    const maxListeners = this.emitter.getMaxListeners();
    if (maxListeners !== 0) this.emitter.setMaxListeners(maxListeners + 1);
    this.emitter.on(this.event, __privateGet(this, _push));
  }
  /**
   * Whether or not the EventIterator has ended.
   */
  get ended() {
    return __privateGet(this, _ended);
  }
  /**
   * Ends the EventIterator.
   */
  end() {
    if (__privateGet(this, _ended)) return;
    __privateSet(this, _ended, true);
    __privateSet(this, _queue, []);
    this.emitter.off(this.event, __privateGet(this, _push));
    const maxListeners = this.emitter.getMaxListeners();
    if (maxListeners !== 0) this.emitter.setMaxListeners(maxListeners - 1);
  }
  /**
   * The next value that's received from the EventEmitter.
   */
  async next() {
    if (__privateGet(this, _queue).length) {
      const value = __privateGet(this, _queue).shift();
      if (!this.filter(value)) return this.next();
      if (++__privateWrapper(this, _passed)._ >= __privateGet(this, _limit)) this.end();
      if (__privateGet(this, _idleTimer)) __privateGet(this, _idleTimer).refresh();
      return { done: false, value };
    }
    if (__privateGet(this, _ended)) {
      if (__privateGet(this, _idleTimer)) clearTimeout(__privateGet(this, _idleTimer));
      return { done: true, value: void 0 };
    }
    return new Promise((resolve) => {
      let idleTimer = null;
      if (__privateGet(this, _idle)) {
        idleTimer = setTimeout(() => {
          this.end();
          resolve(this.next());
        }, __privateGet(this, _idle));
      }
      this.emitter.once(this.event, () => {
        if (idleTimer) clearTimeout(idleTimer);
        resolve(this.next());
      });
    });
  }
  /**
   * Handles what happens when you break or return from a loop.
   */
  return() {
    this.end();
    return Promise.resolve({ done: true, value: void 0 });
  }
  /**
   * Handles what happens when you encounter an error in a loop.
   */
  throw() {
    this.end();
    return Promise.resolve({ done: true, value: void 0 });
  }
  /**
   * The symbol allowing EventIterators to be used in for-await-of loops.
   */
  [Symbol.asyncIterator]() {
    return this;
  }
  /**
   * Pushes a value into the queue.
   */
  push(...value) {
    __privateGet(this, _queue).push(value);
  }
};
_ended = new WeakMap();
_idle = new WeakMap();
_queue = new WeakMap();
_passed = new WeakMap();
_limit = new WeakMap();
_idleTimer = new WeakMap();
_push = new WeakMap();
__name(_EventIterator, "EventIterator");
var EventIterator = _EventIterator;

exports.EventIterator = EventIterator;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map