@eolthar/events 1.0.1 → 2.0.0

package/README.md

@@ -1,35 +1,89 @@
 # @eolthar/events
-A lightweight, high-performance event system for fast and scalable projects.
+A lightweight, high-performance event emitter for fast and scalable projects.
 
 ```
 npm i @eolthar/events
 ```
 
+## Benchmark
+| Category                          | @eolthar/events |     tseep | EventEmitter3 |    NanoEvents |      mitt |
+| :-------------------------------- | --------------: | --------: | ------------: | ------------: | --------: |
+| **1. Mass subscription and emit** |   **4 151 932** | 3 875 026 |     3 225 172 |     3 774 587 | 3 276 026 |
+| **2. Unsubscribe**                |       6 198 889 | 6 286 916 |     4 384 381 | **7 885 637** | 5 295 300 |
+| **3. on → emit → off**            |       2 348 937 | 2 727 954 |     2 509 048 | **3 543 034** | 2 744 207 |
+| **4. emit (0 arguments)**         |  **10 397 673** | 8 126 418 |     6 837 431 |     8 565 591 | 6 764 343 |
+| **5. emit (5 arguments)**         |   **9 915 638** | 8 080 340 |     6 901 530 |     7 531 209 | 6 454 089 |
+| **6. emit (10 arguments)**        |   **9 183 703** | 7 561 947 |     4 503 834 |     6 767 050 | 6 023 215 |
+
 ## Usage
 ```js
-const { createEmitter } = require("@eolthar/events");
+const { Emitter } = require("@eolthar/events");
 
-const emitter = createEmitter();
+const emitter = new Emitter();
 
-// Subscribe to an event
-const off = emitter.on("hello", (name) => {
+function handler(name) {
     console.log(`Hello, ${name}!`);
-});
+}
+
+// Subscribe to an event
+emitter.on("hello", handler);
 
 // Emit an event
 emitter.emit("hello", "Alice"); // Hello, Alice!
 
 // Unsubscribe from the event
-off();
+emitter.off("hello", handler);
 
 // Emitting again won't call the listener
 emitter.emit("hello", "Bob"); // nothing happens
 ```
 
 ## API
-### `createEmitter()`
+### `new Emitter()`
 Creates a new event emitter instance.
 
-#### Methods
-- **`on(event, listener)`** - Subscribes to a named event. Returns a function that can be called to unsubscribe.
-- **`emit(event, ...args)`** - Emits the specified event with any number of arguments. Calls all registered listeners in the order they were added.
+### `emitter.on(event, listener)`
+Subscribes a listener to a named event.
+
+```js
+emitter.on("data", (value) => console.log(value));
+```
+
+### `emitter.off(event, listener)`
+Removes a specific listener from an event.
+
+```js
+function handler(value) {
+    console.log(value);
+}
+
+emitter.on("data", handler);
+emitter.off("data", handler);
+```
+
+### `emitter.once(event, listener)`
+Subscribes a listener that is automatically removed after the first call. Returns the internal wrapper function, which can be passed to `off` to manually remove the listener before it fires.
+
+```js
+emitter.once("connect", () => console.log("connected!"));
+emitter.emit("connect"); // connected!
+emitter.emit("connect"); // nothing happens
+```
+
+### `emitter.emit(event, ...args)`
+Emits the specified event, calling all registered listeners in the order they were added.
+
+```js
+emitter.emit("data", 1, 2, 3);
+```
+
+### `emitter.clear(event?)`
+Removes all listeners for a specific event. If no event is provided, clears all events.
+
+```js
+emitter.clear("data"); // removes all listeners for "data"
+emitter.clear(); // removes everything
+```
+
+## License
+MIT

package/main.js

@@ -1,19 +1,115 @@
-const createEmitter = () => {
-    const e = {};
-    return {
-        on(event, listener) {
-            (e[event] || (e[event] = [])).push(listener);
-            return () => {
-                const a = e[event];
-                const i = a.indexOf(listener);
-                if (i !== -1) a.splice(i, 1);
-            };
-        },
-        emit(event, ...args) {
-            const a = e[event];
-            if (a) for (let i = 0, l = a.length; i < l; i++) a[i](...args);
+const forge = new Map();
+const sigs = new Map([
+    [0, ""],
+    [1, "a0"]
+]);
+
+function compile(pool, argc) {
+    const len = pool.length;
+    const stamp = len + "-" + argc;
+    const mold = forge.get(stamp);
+    if (mold !== undefined) return mold(pool);
+    let args = sigs.get(argc);
+    if (args === undefined) {
+        args = "a0";
+        for (let i = 1; i < argc; i++) args += ",a" + i;
+        sigs.set(argc, args);
+    }
+    let pins = "",
+        fire = "";
+    for (let i = 0; i < len; i++) {
+        pins += "var f" + i + "=c[" + i + "];";
+        fire += "f" + i + "(" + args + ");";
+    }
+    const nep = eval("(function(c){" + pins + "return function(" + args + "){" + fire + "}})");
+    forge.set(stamp, nep);
+    return nep(pool);
+}
+
+class Emitter {
+    constructor() {
+        this.events = new Map();
+    }
+
+    on(event, listener) {
+        let e = this.events.get(event);
+        if (!e) {
+            this.events.set(event, { exec: listener, arity: listener.length, pool: null });
+            return;
+        }
+        if (e.pool === null) {
+            e.pool = [e.exec, listener];
+        } else {
+            e.pool.push(listener);
+        }
+        if (listener.length > e.arity) e.arity = listener.length;
+        e.exec = compile(e.pool, e.arity);
+    }
+
+    off(event, listener) {
+        const e = this.events.get(event);
+        if (!e) return;
+        if (e.pool === null) {
+            if (e.exec === listener) this.events.delete(event);
+            return;
+        }
+        const pool = e.pool;
+        const idx = pool.indexOf(listener);
+        if (idx === -1) return;
+        const last = pool[pool.length - 1];
+        if (last !== listener) pool[idx] = last;
+        pool.pop();
+        if (pool.length === 1) {
+            const single = pool[0];
+            e.exec = single;
+            e.arity = single.length;
+            e.pool = null;
+        } else {
+            if (listener.length >= e.arity) {
+                let max = 0;
+                for (let i = 0; i < pool.length; i++) {
+                    if (pool[i].length > max) max = pool[i].length;
+                }
+                e.arity = max;
+            }
+            e.exec = compile(e.pool, e.arity);
+        }
+    }
+
+    clear(event) {
+        if (event === undefined) {
+            this.events.clear();
+        } else {
+            this.events.delete(event);
+        }
+    }
+
+    once(event, listener) {
+        const self = this;
+        let called = false;
+        const wrapper = function () {
+            if (called) return;
+            called = true;
+            self.off(event, wrapper);
+            listener.apply(undefined, arguments);
+        };
+        Object.defineProperty(wrapper, "length", { value: listener.length });
+        this.on(event, wrapper);
+        return wrapper;
+    }
+
+    emit(event, a, b, c, d, f) {
+        const e = this.events.get(event);
+        if (!e) return;
+        const l = e.arity;
+        if (l < 6) {
+            e.exec(a, b, c, d, f);
+        } else {
+            const r = new Array(l);
+            for (let i = 0; i < l; i++) r[i] = arguments[i + 1];
+            e.exec.apply(undefined, r);
         }
-    };
-};
+    }
+}
 
-module.exports = { createEmitter };
+module.exports = { Emitter };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@eolthar/events",
-    "description": "A lightweight, high-performance event system for fast and scalable projects.",
-    "version": "1.0.1",
+    "description": "A lightweight, high-performance event emitter for fast and scalable projects.",
+    "version": "2.0.0",
     "main": "main.js",
     "author": "Mlad (https://github.com/eolthar)",
     "repository": "https://github.com/eolthar/events",
@@ -10,8 +10,9 @@
         "events",
         "emitter",
         "eventemitter",
+        "emit",
         "pubsub",
-        "lightweight",
+        "fast",
         "performance"
     ]
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Mlad
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.