@gjsify/events 0.0.4 → 0.1.1

package/README.md

@@ -1,9 +1,34 @@
 # @gjsify/events
 
-Node.js events module for Gjs
+GJS implementation of the Node.js `events` module. Provides EventEmitter, once, on, and listenerCount.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/events
+# or
+yarn add @gjsify/events
+```
+
+## Usage
+
+```typescript
+import { EventEmitter } from '@gjsify/events';
+
+const emitter = new EventEmitter();
+emitter.on('data', (msg) => console.log(msg));
+emitter.emit('data', 'hello');
+```
 
 ## Inspirations and credits
+
 - https://github.com/EventEmitter2/EventEmitter2
 - https://github.com/browserify/events
 - https://github.com/geut/brode/blob/main/packages/browser-node-core/src/events.js
-- https://github.com/denoland/deno_std/blob/main/node/_events.mjs
+- https://github.com/denoland/deno_std/blob/main/node/_events.mjs
+
+## License
+
+MIT

package/cjs-compat.cjs

@@ -0,0 +1,6 @@
+// CJS compatibility wrapper for npm packages that require('events')
+// In Node.js CJS, require('events') returns the EventEmitter class directly.
+// When esbuild bundles ESM @gjsify/events for CJS consumers, it returns a
+// namespace object instead. This wrapper extracts the default export.
+const mod = require('./lib/esm/index.js');
+module.exports = mod.default || mod;

package/lib/esm/event-emitter.js

@@ -0,0 +1,591 @@
+const kCapture = /* @__PURE__ */ Symbol("kCapture");
+const kRejection = /* @__PURE__ */ Symbol.for("nodejs.rejection");
+function onceWrapper() {
+  const { target, type, listener } = this;
+  if (this.wrapperFn) target.removeListener(type, this.wrapperFn);
+  const result = listener.apply(target, arguments);
+  return result;
+}
+function _onceWrap(target, type, listener) {
+  const state = { target, type, listener, wrapperFn: void 0 };
+  const wrapped = onceWrapper.bind(state);
+  state.wrapperFn = wrapped;
+  wrapped.listener = listener;
+  return wrapped;
+}
+function arrayClone(arr) {
+  switch (arr.length) {
+    case 0:
+      return [];
+    case 1:
+      return [arr[0]];
+    case 2:
+      return [arr[0], arr[1]];
+    case 3:
+      return [arr[0], arr[1], arr[2]];
+    default:
+      return arr.slice();
+  }
+}
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+function validateNumber(value, name) {
+  if (typeof value !== "number" || value !== value) {
+    throw new TypeError(`The "${name}" argument must be of type number. Received type ${typeof value}`);
+  }
+}
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++) {
+    list[index] = list[index + 1];
+  }
+  list.pop();
+}
+class EventEmitter {
+  static defaultMaxListeners = 10;
+  static errorMonitor = /* @__PURE__ */ Symbol("events.errorMonitor");
+  static captureRejectionSymbol = kRejection;
+  static _captureRejections = false;
+  static get captureRejections() {
+    return EventEmitter._captureRejections;
+  }
+  static set captureRejections(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError('The "captureRejections" argument must be of type boolean.');
+    }
+    EventEmitter._captureRejections = value;
+  }
+  _events;
+  _eventsCount;
+  _maxListeners;
+  [kCapture];
+  constructor(opts) {
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+    this._maxListeners = void 0;
+    this[kCapture] = opts?.captureRejections ?? EventEmitter._captureRejections;
+  }
+  setMaxListeners(n) {
+    validateNumber(n, "n");
+    if (n < 0) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n);
+    }
+    this._maxListeners = n;
+    return this;
+  }
+  getMaxListeners() {
+    return this._maxListeners ?? EventEmitter.defaultMaxListeners;
+  }
+  emit(type, ...args) {
+    const events = this._events;
+    let doError = type === "error";
+    if (events !== void 0) {
+      if (doError && events[EventEmitter.errorMonitor] !== void 0) {
+        this.emit(EventEmitter.errorMonitor, ...args);
+      }
+      doError = doError && events.error === void 0;
+    } else if (!doError) {
+      return false;
+    }
+    if (doError) {
+      let er;
+      if (args.length > 0) {
+        er = args[0];
+      } else {
+        er = new Error("Unhandled error.");
+      }
+      if (er instanceof Error) {
+        throw er;
+      }
+      const err = new Error("Unhandled error. (" + er + ")");
+      err.context = er;
+      throw err;
+    }
+    const handler = events[type];
+    if (handler === void 0) {
+      return false;
+    }
+    if (typeof handler === "function") {
+      const result = handler.apply(this, args);
+      if (result !== void 0 && result !== null && this[kCapture]) {
+        this._addCatch(result, type, args);
+      }
+    } else {
+      const listeners = arrayClone(handler);
+      const len = listeners.length;
+      for (let i = 0; i < len; ++i) {
+        const result = listeners[i].apply(this, args);
+        if (result !== void 0 && result !== null && this[kCapture]) {
+          this._addCatch(result, type, args);
+        }
+      }
+    }
+    return true;
+  }
+  _addCatch(result, type, args) {
+    if (typeof result?.then === "function") {
+      result.then(void 0, (err) => {
+        const handler = this[kRejection];
+        if (typeof handler === "function") {
+          handler.call(this, err, type, ...args);
+        } else {
+          const prev = this[kCapture];
+          try {
+            this[kCapture] = false;
+            this.emit("error", err);
+          } finally {
+            this[kCapture] = prev;
+          }
+        }
+      });
+    }
+  }
+  addListener(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  on(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  prependListener(type, listener) {
+    return this._addListener(type, listener, true);
+  }
+  _addListener(type, listener, prepend) {
+    checkListener(listener);
+    let events = this._events;
+    if (events === void 0) {
+      events = this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    } else if (events.newListener !== void 0) {
+      this.emit("newListener", type, listener.listener ?? listener);
+      events = this._events;
+    }
+    let existing = events[type];
+    if (existing === void 0) {
+      events[type] = listener;
+      ++this._eventsCount;
+    } else if (typeof existing === "function") {
+      events[type] = prepend ? [listener, existing] : [existing, listener];
+    } else {
+      if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+    }
+    const m = this.getMaxListeners();
+    if (m > 0) {
+      const count = typeof events[type] === "function" ? 1 : events[type].length;
+      if (count > m && !events[type].warned) {
+        if (typeof events[type] !== "function") {
+          events[type].warned = true;
+        }
+        const w = new Error(
+          `Possible EventEmitter memory leak detected. ${count} ${String(type)} listeners added to [${this.constructor.name}]. Use emitter.setMaxListeners() to increase limit`
+        );
+        w.name = "MaxListenersExceededWarning";
+        console.warn(w.message);
+      }
+    }
+    return this;
+  }
+  once(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  }
+  prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, _onceWrap(this, type, listener));
+    return this;
+  }
+  removeListener(type, listener) {
+    checkListener(listener);
+    const events = this._events;
+    if (events === void 0) {
+      return this;
+    }
+    const list = events[type];
+    if (list === void 0) {
+      return this;
+    }
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+      } else {
+        delete events[type];
+        if (events.removeListener) {
+          this.emit("removeListener", type, list.listener ?? listener);
+        }
+      }
+    } else if (typeof list !== "function") {
+      let position = -1;
+      for (let i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || list[i].listener === listener) {
+          position = i;
+          break;
+        }
+      }
+      if (position < 0) {
+        return this;
+      }
+      if (position === 0) {
+        list.shift();
+      } else {
+        spliceOne(list, position);
+      }
+      if (list.length === 1) {
+        events[type] = list[0];
+      }
+      if (events.removeListener !== void 0) {
+        this.emit("removeListener", type, listener.listener ?? listener);
+      }
+    }
+    return this;
+  }
+  off(type, listener) {
+    return this.removeListener(type, listener);
+  }
+  removeAllListeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return this;
+    }
+    if (events.removeListener === void 0) {
+      if (arguments.length === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events[type] !== void 0) {
+        if (--this._eventsCount === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+        } else {
+          delete events[type];
+        }
+      }
+      return this;
+    }
+    if (arguments.length === 0) {
+      const keys = Object.keys(events);
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (key === "removeListener") continue;
+        this.removeAllListeners(key);
+      }
+      this.removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return this;
+    }
+    const listeners = events[type];
+    if (typeof listeners === "function") {
+      this.removeListener(type, listeners);
+    } else if (listeners !== void 0) {
+      for (let i = listeners.length - 1; i >= 0; i--) {
+        this.removeListener(type, listeners[i]);
+      }
+    }
+    return this;
+  }
+  listeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return [];
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return [];
+    }
+    if (typeof evlistener === "function") {
+      return [evlistener.listener ?? evlistener];
+    }
+    return unwrapListeners(evlistener);
+  }
+  rawListeners(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return [];
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return [];
+    }
+    if (typeof evlistener === "function") {
+      return [evlistener];
+    }
+    return arrayClone(evlistener);
+  }
+  listenerCount(type) {
+    const events = this._events;
+    if (events === void 0) {
+      return 0;
+    }
+    const evlistener = events[type];
+    if (evlistener === void 0) {
+      return 0;
+    }
+    if (typeof evlistener === "function") {
+      return 1;
+    }
+    return evlistener.length;
+  }
+  eventNames() {
+    return (this._eventsCount ?? 0) > 0 ? Reflect.ownKeys(this._events) : [];
+  }
+  // -- Static methods --
+  /**
+   * Returns a promise that resolves when the emitter emits the given event,
+   * or rejects if the emitter emits 'error' while waiting.
+   */
+  static once(emitter, name, options) {
+    return new Promise((resolve, reject) => {
+      const signal = options?.signal;
+      if (signal?.aborted) {
+        reject(createAbortError(signal));
+        return;
+      }
+      if (typeof emitter.addEventListener === "function") {
+        const eventTarget = emitter;
+        const handler = (...args) => {
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler2);
+          }
+          resolve(args);
+        };
+        const errorHandler2 = (err) => {
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler2);
+          }
+          eventTarget.removeEventListener("error", errorHandler2);
+          reject(err);
+        };
+        const abortHandler2 = () => {
+          eventTarget.removeEventListener(name, handler);
+          eventTarget.removeEventListener("error", errorHandler2);
+          reject(createAbortError(signal));
+        };
+        eventTarget.addEventListener(name, handler, { once: true });
+        if (name !== "error") {
+          eventTarget.addEventListener("error", errorHandler2, { once: true });
+        }
+        if (signal) {
+          signal.addEventListener("abort", abortHandler2, { once: true });
+        }
+        return;
+      }
+      const ee = emitter;
+      const eventHandler = (...args) => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        if (errorHandler !== void 0) {
+          ee.removeListener("error", errorHandler);
+        }
+        resolve(args);
+      };
+      let errorHandler;
+      if (name !== "error") {
+        errorHandler = (err) => {
+          ee.removeListener(name, eventHandler);
+          if (signal) {
+            signal.removeEventListener("abort", abortHandler);
+          }
+          reject(err);
+        };
+        ee.once("error", errorHandler);
+      }
+      ee.once(name, eventHandler);
+      const abortHandler = () => {
+        ee.removeListener(name, eventHandler);
+        if (errorHandler) {
+          ee.removeListener("error", errorHandler);
+        }
+        reject(createAbortError(signal));
+      };
+      if (signal) {
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    });
+  }
+  /**
+   * Returns an async iterator that yields event arguments each time the emitter emits.
+   */
+  static on(emitter, event, options) {
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      throw createAbortError(signal);
+    }
+    const highWaterMark = options?.highWaterMark ?? Number.MAX_SAFE_INTEGER;
+    const lowWaterMark = options?.lowWaterMark ?? 1;
+    validateNumber(highWaterMark, "highWaterMark");
+    validateNumber(lowWaterMark, "lowWaterMark");
+    const unconsumedEvents = [];
+    const unconsumedPromises = [];
+    let error = null;
+    let finished = false;
+    let paused = false;
+    const eventHandler = (...args) => {
+      if (unconsumedPromises.length > 0) {
+        const { resolve } = unconsumedPromises.shift();
+        resolve({ value: args, done: false });
+      } else {
+        unconsumedEvents.push(args);
+        if (unconsumedEvents.length >= highWaterMark && !paused) {
+          paused = true;
+          if (typeof emitter.pause === "function") {
+            emitter.pause();
+          }
+        }
+      }
+    };
+    const errorHandler = (err) => {
+      error = err;
+      if (unconsumedPromises.length > 0) {
+        const { reject } = unconsumedPromises.shift();
+        reject(err);
+      }
+      iterator.return();
+    };
+    const abortHandler = () => {
+      errorHandler(createAbortError(signal));
+    };
+    emitter.on(event, eventHandler);
+    if (event !== "error") {
+      emitter.on("error", errorHandler);
+    }
+    if (signal) {
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const cleanup = () => {
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener("error", errorHandler);
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      finished = true;
+      for (const { resolve } of unconsumedPromises) {
+        resolve({ value: void 0, done: true });
+      }
+      unconsumedPromises.length = 0;
+      unconsumedEvents.length = 0;
+    };
+    const iterator = {
+      next() {
+        if (unconsumedEvents.length > 0) {
+          const value = unconsumedEvents.shift();
+          if (paused && unconsumedEvents.length < lowWaterMark) {
+            paused = false;
+            if (typeof emitter.resume === "function") {
+              emitter.resume();
+            }
+          }
+          return Promise.resolve({ value, done: false });
+        }
+        if (error) {
+          const p = Promise.reject(error);
+          error = null;
+          return p;
+        }
+        if (finished) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          unconsumedPromises.push({ resolve, reject });
+        });
+      },
+      return() {
+        cleanup();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      throw(err) {
+        if (!finished) {
+          error = err;
+          cleanup();
+        }
+        return Promise.reject(err);
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+    return iterator;
+  }
+  /**
+   * Returns the number of listeners listening to the event name.
+   * @deprecated Use emitter.listenerCount() instead.
+   */
+  static listenerCount(emitter, type) {
+    return emitter.listenerCount(type);
+  }
+  /**
+   * Returns a copy of the array of listeners for the event named eventName.
+   */
+  static getEventListeners(emitter, name) {
+    if (typeof emitter.listeners === "function") {
+      return emitter.listeners(name);
+    }
+    return [];
+  }
+  /**
+   * Set max listeners on one or more emitters.
+   */
+  static setMaxListeners(n, ...emitters) {
+    validateNumber(n, "n");
+    if (n < 0) {
+      throw new RangeError('The value of "n" is out of range.');
+    }
+    if (emitters.length === 0) {
+      EventEmitter.defaultMaxListeners = n;
+    } else {
+      for (const emitter of emitters) {
+        if (typeof emitter.setMaxListeners === "function") {
+          emitter.setMaxListeners(n);
+        }
+      }
+    }
+  }
+  /**
+   * Returns the currently set max listeners on the emitter.
+   */
+  static getMaxListeners(emitter) {
+    if (typeof emitter.getMaxListeners === "function") {
+      return emitter.getMaxListeners();
+    }
+    return EventEmitter.defaultMaxListeners;
+  }
+  /**
+   * Listens once to an abort event on the provided signal and returns a disposable.
+   */
+  static addAbortListener(signal, listener) {
+    if (signal.aborted) {
+      Promise.resolve().then(() => listener());
+    }
+    const handler = () => listener();
+    signal.addEventListener("abort", handler, { once: true });
+    return {
+      [Symbol.dispose]() {
+        signal.removeEventListener("abort", handler);
+      }
+    };
+  }
+}
+EventEmitter.EventEmitter = EventEmitter;
+function unwrapListeners(arr) {
+  const ret = new Array(arr.length);
+  for (let i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener ?? arr[i];
+  }
+  return ret;
+}
+function createAbortError(signal) {
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  err.code = "ABORT_ERR";
+  if (signal?.reason) {
+    err.cause = signal.reason;
+  }
+  return err;
+}
+export {
+  EventEmitter
+};

package/lib/esm/index.js

@@ -1,6 +1,26 @@
-export * from "@gjsify/deno_std/node/events";
-import events from "@gjsify/deno_std/node/events";
-var src_default = events;
+import { EventEmitter } from "./event-emitter.js";
+const captureRejectionSymbol = EventEmitter.captureRejectionSymbol;
+const errorMonitor = EventEmitter.errorMonitor;
+const defaultMaxListeners = EventEmitter.defaultMaxListeners;
+const setMaxListeners = EventEmitter.setMaxListeners;
+const getMaxListeners = EventEmitter.getMaxListeners;
+const once = EventEmitter.once;
+const on = EventEmitter.on;
+const getEventListeners = EventEmitter.getEventListeners;
+const listenerCount = EventEmitter.listenerCount;
+const addAbortListener = EventEmitter.addAbortListener;
+var index_default = EventEmitter;
 export {
-  src_default as default
+  EventEmitter,
+  addAbortListener,
+  captureRejectionSymbol,
+  index_default as default,
+  defaultMaxListeners,
+  errorMonitor,
+  getEventListeners,
+  getMaxListeners,
+  listenerCount,
+  on,
+  once,
+  setMaxListeners
 };