@serenityjs/emitter 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# Emitter
+

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+type Listener<T extends Array<unknown>, R = unknown> = (...arguments_: T) => R;
+type ForceArray<T> = T extends Array<unknown> ? T : never;
+declare class Emitter<T> {
+    private _maxListeners;
+    private readonly _beforeHooks;
+    private readonly _afterHooks;
+    private readonly _listeners;
+    constructor(_maxListeners?: number);
+    get maxListeners(): number;
+    set maxListeners(value: number);
+    emit<K extends keyof T>(event: K, ...arguments_: ForceArray<T[K]>): boolean;
+    private _addListener;
+    private _addOnceListener;
+    private _removeListener;
+    private _removeAllListeners;
+    on<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    before<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>, boolean>): this;
+    after<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    once<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    onceBefore<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>, boolean>): this;
+    onceAfter<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    remove<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    removeBefore<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>, boolean>): this;
+    removeAfter<K extends keyof T>(event: K, listener: Listener<ForceArray<T[K]>>): this;
+    removeAll<K extends keyof T>(event?: K): this;
+    removeAllBefore<K extends keyof T>(event?: K): this;
+    removeAllAfter<K extends keyof T>(event?: K): this;
+}
+
+export { Emitter, type ForceArray, type Listener, Emitter as default };

package/dist/index.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Emitter: () => Emitter,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var Emitter = class {
+  constructor(_maxListeners = 10) {
+    this._maxListeners = _maxListeners;
+  }
+  _beforeHooks = /* @__PURE__ */ new Map();
+  _afterHooks = /* @__PURE__ */ new Map();
+  _listeners = /* @__PURE__ */ new Map();
+  get maxListeners() {
+    return this._maxListeners;
+  }
+  set maxListeners(value) {
+    this._maxListeners = value;
+  }
+  // Returns true if all listeners were called. Returns false if a before hook returned false.
+  emit(event, ...arguments_) {
+    const beforeHooks = this._beforeHooks.get(event) ?? [];
+    const listeners = this._listeners.get(event) ?? [];
+    const afterHooks = this._afterHooks.get(event) ?? [];
+    for (const hook of beforeHooks) {
+      const result = hook(...arguments_);
+      if (result === false)
+        return false;
+    }
+    for (const listener of listeners) {
+      listener(...arguments_);
+    }
+    for (const hook of afterHooks) {
+      hook(...arguments_);
+    }
+    return true;
+  }
+  // Register utility to reduce duplication in code.
+  _addListener(map, event, listener) {
+    const listeners = map.get(event) ?? [];
+    if (listeners.length >= this._maxListeners) {
+      console.trace(
+        `warning: possible EventEmitter memory leak detected. ${listeners.length} listeners added. Use #setMaxListeners() to increase limit`
+      );
+    }
+    map.set(event, [...listeners, listener]);
+    return this;
+  }
+  _addOnceListener(map, event, listener) {
+    const wrapper = (...arguments_) => {
+      this._removeListener(map, event, wrapper);
+      return listener(...arguments_);
+    };
+    return this._addListener(map, event, wrapper);
+  }
+  _removeListener(map, event, listener) {
+    const listeners = map.get(event);
+    const index = listeners?.indexOf(listener);
+    if (index !== void 0 && index !== -1) {
+      listeners?.splice(index, 1);
+    }
+    return this;
+  }
+  _removeAllListeners(map, event) {
+    if (event) {
+      map.delete(event);
+    } else {
+      map.clear();
+    }
+    return this;
+  }
+  on(event, listener) {
+    return this._addListener(this._listeners, event, listener);
+  }
+  before(event, listener) {
+    return this._addListener(this._beforeHooks, event, listener);
+  }
+  after(event, listener) {
+    return this._addListener(this._afterHooks, event, listener);
+  }
+  once(event, listener) {
+    return this._addOnceListener(this._listeners, event, listener);
+  }
+  onceBefore(event, listener) {
+    return this._addOnceListener(this._beforeHooks, event, listener);
+  }
+  onceAfter(event, listener) {
+    return this._addOnceListener(this._afterHooks, event, listener);
+  }
+  remove(event, listener) {
+    return this._removeListener(this._listeners, event, listener);
+  }
+  removeBefore(event, listener) {
+    return this._removeListener(this._beforeHooks, event, listener);
+  }
+  removeAfter(event, listener) {
+    return this._removeListener(this._afterHooks, event, listener);
+  }
+  removeAll(event) {
+    return this._removeAllListeners(this._listeners, event);
+  }
+  removeAllBefore(event) {
+    return this._removeAllListeners(this._beforeHooks, event);
+  }
+  removeAllAfter(event) {
+    return this._removeAllListeners(this._afterHooks, event);
+  }
+};
+var src_default = Emitter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Emitter
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@serenityjs/emitter",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": "https://github.com/SerenityJS/serenity",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "watch": "tsup --watch",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "test": "jest"
+  },
+  "jest": {
+    "preset": "@serenityjs/jest-presets/jest/node"
+  },
+  "devDependencies": {
+    "@serenityjs/eslint-config": "*",
+    "@serenityjs/jest-presets": "*",
+    "@serenityjs/typescript-config": "*",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "jest": "^29.7.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.2"
+  }
+}