implement node:events in javascript

bench/emitter/implementations.mjs

@@ -0,0 +1,31 @@
+import EventEmitter3 from "eventemitter3";
+import { group } from "mitata";
+import EventEmitterNative from "node:events";
+
+export const implementations = [
+  {
+    EventEmitter: EventEmitterNative,
+    name: process.isBun ? (EventEmitterNative.init ? "bun" : "C++") : "node:events",
+    monkey: true,
+  },
+  // { EventEmitter: EventEmitter3, name: "EventEmitter3" },
+].filter(Boolean);
+
+for (const impl of implementations) {
+  impl.EventEmitter?.setMaxListeners?.(Infinity);
+}
+
+export function groupForEmitter(name, cb) {
+  if (implementations.length === 1) {
+    return cb({
+      ...implementations[0],
+      name: `${name}: ${implementations[0].name}`,
+    });
+  } else {
+    return group(name, () => {
+      for (let impl of implementations) {
+        cb(impl);
+      }
+    });
+  }
+}

bench/emitter/microbench.mjs

@@ -0,0 +1,96 @@
+import { bench, run } from "mitata";
+import { groupForEmitter } from "./implementations.mjs";
+
+var id = 0;
+
+groupForEmitter("single emit", ({ EventEmitter, name }) => {
+  const emitter = new EventEmitter();
+
+  emitter.on("hello", event => {
+    event.preventDefault();
+  });
+
+  bench(name, () => {
+    emitter.emit("hello", {
+      preventDefault() {
+        id++;
+      },
+    });
+  });
+});
+
+groupForEmitter("on x 10_000 (handler)", ({ EventEmitter, name }) => {
+  const emitter = new EventEmitter();
+
+  bench(name, () => {
+    var cb = event => {
+      event.preventDefault();
+    };
+    emitter.on("hey", cb);
+    var called = false;
+    for (let i = 0; i < 10_000; i++)
+      emitter.emit("hey", {
+        preventDefault() {
+          id++;
+          called = true;
+        },
+      });
+
+    if (!called) throw new Error("not called");
+  });
+});
+
+// for (let { impl: EventEmitter, name, monkey } of []) {
+//   if (monkey) {
+//     var monkeyEmitter = Object.assign({}, EventEmitter.prototype);
+//     monkeyEmitter.on("hello", event => {
+//       event.preventDefault();
+//     });
+
+//     bench(`[monkey] ${className}.emit`, () => {
+//       var called = false;
+//       monkeyEmitter.emit("hello", {
+//         preventDefault() {
+//           id++;
+//           called = true;
+//         },
+//       });
+
+//       if (!called) {
+//         throw new Error("monkey failed");
+//       }
+//     });
+
+//     bench(`[monkey] ${className}.on x 10_000 (handler)`, () => {
+//       var cb = () => {
+//         event.preventDefault();
+//       };
+//       monkeyEmitter.on("hey", cb);
+//       for (let i = 0; i < 10_000; i++)
+//         monkey.emit("hey", {
+//           preventDefault() {
+//             id++;
+//           },
+//         });
+//       monkeyEmitter.off("hey", cb);
+//     });
+//   }
+// }
+
+// var target = new EventTarget();
+// target.addEventListener("hello", event => {});
+// bench("EventTarget.dispatch", () => {
+//   target.dispatchEvent(event);
+// });
+
+// var hey = new Event("hey");
+
+// bench("EventTarget.on x 10_000 (handler)", () => {
+//   var handler = event => {};
+//   target.addEventListener("hey", handler);
+
+//   for (let i = 0; i < 10_000; i++) target.dispatchEvent(hey);
+//   target.removeEventListener("hey", handler);
+// });
+
+await run();

bench/emitter/microbench_once.mjs

@@ -0,0 +1,40 @@
+import { bench, run } from "mitata";
+import { groupForEmitter } from "./implementations.mjs";
+
+var id = 0;
+
+groupForEmitter("test 1", ({ EventEmitter, name }) => {
+  const emitter = new EventEmitter();
+
+  emitter.on("hello", event => {
+    event.preventDefault();
+  });
+
+  bench(name, () => {
+    emitter.once("hello", event => {
+      event.preventDefault();
+    });
+    emitter.emit("hello", {
+      preventDefault() {
+        id++;
+      },
+    });
+  });
+});
+
+groupForEmitter("test 2", ({ EventEmitter, name }) => {
+  const emitter = new EventEmitter();
+
+  bench(name, () => {
+    emitter.once("hello", event => {
+      event.preventDefault();
+    });
+    emitter.emit("hello", {
+      preventDefault() {
+        id++;
+      },
+    });
+  });
+});
+
+await run();

bench/emitter/realworld_stream.mjs

@@ -0,0 +1,63 @@
+import { bench, run } from "mitata";
+import { groupForEmitter } from "./implementations.mjs";
+
+// Psuedo RNG is derived from https://stackoverflow.com/a/424445
+let rngState = 123456789;
+function nextInt() {
+  const m = 0x80000000; // 2**31;
+  const a = 1103515245;
+  const c = 12345;
+  rngState = (a * rngState + c) % m;
+  return rngState;
+}
+function nextRange(start, end) {
+  // returns in range [start, end): including start, excluding end
+  // can't modulu nextInt because of weak randomness in lower bits
+  const rangeSize = end - start;
+  const randomUnder1 = nextInt() / 0x7fffffff; // 2**31 - 1
+  return start + Math.floor(randomUnder1 * rangeSize);
+}
+
+const chunks = new Array(1024).fill(null).map((_, j) => {
+  const arr = new Uint8Array(1024);
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = nextRange(0, 256);
+  }
+  return arr;
+});
+
+groupForEmitter("stream simulation", ({ EventEmitter, name }) => {
+  bench(name, () => {
+    let id = 0;
+    const stream = new EventEmitter();
+
+    stream.on("start", res => {
+      if (res.status !== 200) throw new Error("not 200");
+    });
+
+    const recived = [];
+    stream.on("data", req => {
+      recived.push(req);
+    });
+
+    stream.on("end", ev => {
+      ev.preventDefault();
+    });
+
+    // simulate a stream
+    stream.emit("start", { status: 200 });
+    for (let chunk of chunks) {
+      stream.emit("data", chunk);
+    }
+    stream.emit("end", {
+      preventDefault() {
+        id++;
+      },
+    });
+
+    if (id !== 1) throw new Error("not implemented right");
+    if (recived.length !== 1024) throw new Error("not implemented right");
+  });
+});
+
+await run();

bench/package.json

@@ -1,11 +1,13 @@
 {
   "name": "bench",
   "dependencies": {
-    "mitata": "^0.1.6",
-    "esbuild": "^0.14.12",
-    "@swc/core": "^1.2.133",
     "@babel/core": "^7.16.10",
-    "@babel/preset-react": "^7.16.7"
+    "@babel/preset-react": "^7.16.7",
+    "@swc/core": "^1.2.133",
+    "benchmark": "^2.1.4",
+    "esbuild": "^0.14.12",
+    "eventemitter3": "^5.0.0",
+    "mitata": "^0.1.6"
   },
   "scripts": {
     "ffi": "cd ffi && bun run deps && bun run build && bun run bench",

docs/runtime/nodejs-apis.md

@@ -81,7 +81,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 - {% anchor id="node_events" %} [`node:events`](https://nodejs.org/api/events.html) {% /anchor %}
 - 🟡
-- Missing `EventEmitterAsyncResource`. `EventEmitter` is missing `{get}set}MaxListeners` `usingDomains` `init`.
+- Missing `EventEmitterAsyncResource` `events.on`.
 
 ---