@pixotope/event-bus 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,20 @@
+
+> @pixotope/event-bus@0.2.0 build /home/circleci/project/packages/event-bus
+> tsup src/index.ts --format cjs,esm --dts --sourcemap
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.0
+CLI Target: es2020
+CJS Build start
+ESM Build start
+CJS dist/index.cjs     2.39 KB
+CJS dist/index.cjs.map 3.90 KB
+CJS ⚡️ Build success in 393ms
+ESM dist/index.js     1.39 KB
+ESM dist/index.js.map 3.81 KB
+ESM ⚡️ Build success in 394ms
+DTS Build start
+DTS ⚡️ Build success in 1702ms
+DTS dist/index.d.cts 1.53 KB
+DTS dist/index.d.ts  1.53 KB

package/.turbo/turbo-check-types.log

@@ -0,0 +1,4 @@
+
+> @pixotope/event-bus@0.2.0 check-types /home/circleci/project/packages/event-bus
+> tsc --noEmit
+

package/.turbo/turbo-test.log

@@ -0,0 +1,14 @@
+
+> @pixotope/event-bus@0.2.0 test /home/circleci/project/packages/event-bus
+> vitest
+
+
+ RUN  v3.2.4 /home/circleci/project/packages/event-bus
+
+ ✓ src/EventBus.test.ts (8 tests) 7ms
+
+ Test Files  1 passed (1)
+      Tests  8 passed (8)
+   Start at  17:44:39
+   Duration  4.21s (transform 500ms, setup 0ms, collect 286ms, tests 7ms, environment 0ms, prepare 1.11s)
+

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @pixotope/event-bus
+
+## 0.2.0
+
+### Minor Changes
+
+- baa9a61: - added new `event-bus` package
+  - in `packages/query` update to pass more info to `queryFn`

package/dist/index.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EventBus: () => EventBus,
+  createEventBus: () => createEventBus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/EventBus.ts
+var EventBus = class {
+  constructor(all) {
+    __publicField(this, "all", /* @__PURE__ */ new Map());
+    this.all = all || /* @__PURE__ */ new Map();
+  }
+  on(type, handler) {
+    const handlers = this.all.get(type);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      this.all.set(type, [handler]);
+    }
+    return () => this.off(type, handler);
+  }
+  off(type, handler) {
+    const handlers = this.all.get(type);
+    if (handlers) {
+      if (handler) {
+        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+      } else {
+        this.all.set(type, []);
+      }
+    }
+  }
+  emit(type, ...args) {
+    const evt = args[0];
+    let handlers = this.all.get(type);
+    if (handlers) {
+      handlers.forEach(
+        (h) => h(evt)
+      );
+    }
+    handlers = this.all.get("*");
+    if (handlers) {
+      handlers.forEach(
+        (h) => h(type, evt)
+      );
+    }
+  }
+};
+function createEventBus(defaults) {
+  return new EventBus(
+    new Map(
+      Object.entries(defaults || {})
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventBus,
+  createEventBus
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/EventBus.ts"],"sourcesContent":["export * from \"./EventBus\";\n","export type EventType = string | symbol;\n\nexport type EmitArgs<\n  Events extends Record<EventType, unknown>,\n  Key extends keyof Events,\n> = undefined extends Events[Key] ? [evt?: Events[Key]] : [evt: Events[Key]];\n\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n  type: keyof T,\n  event: T[keyof T]\n) => void;\n\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<\n  WildcardHandler<T>\n>;\n\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | \"*\",\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\ntype GenericEventHandler<Events extends Record<EventType, unknown>> =\n  | Handler<Events[keyof Events]>\n  | WildcardHandler<Events>;\n\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  public readonly all: EventHandlerMap<Events> = new Map();\n\n  public constructor(all?: EventHandlerMap<Events>) {\n    this.all = all || new Map();\n  }\n\n  public on<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler: GenericEventHandler<Events>\n  ) {\n    const handlers: Array<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      handlers.push(handler);\n    } else {\n      this.all.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n    }\n\n    return () => this.off(type, handler);\n  }\n\n  public off<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler?: GenericEventHandler<Events>\n  ) {\n    const handlers: Array<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      if (handler) {\n        handlers.splice(handlers.indexOf(handler) >>> 0, 1);\n      } else {\n        this.all.set(type, []);\n      }\n    }\n  }\n\n  public emit<Key extends keyof Events | \"*\">(\n    type: Key,\n    ...args: EmitArgs<Events, Key>\n  ) {\n    const evt = args[0] as Events[Key];\n    let handlers = this.all.get(type);\n    if (handlers) {\n      (handlers as EventHandlerList<Events[keyof Events]>).forEach((h) =>\n        h(evt!)\n      );\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as WildCardEventHandlerList<Events>).forEach((h) =>\n        h(type, evt!)\n      );\n    }\n  }\n}\n\nexport function createEventBus<Events extends Record<EventType, unknown>>(\n  defaults?: Record<keyof Events | \"*\", GenericEventHandler<Events>[]>\n) {\n  return new EventBus<Events>(\n    new Map(\n      Object.entries(defaults || {}) as [\n        keyof Events | \"*\",\n        (\n          | EventHandlerList<Events[keyof Events]>\n          | WildCardEventHandlerList<Events>\n        ),\n      ][]\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC2BO,IAAM,WAAN,MAA0D;AAAA,EAGxD,YAAY,KAA+B;AAFlD,wBAAgB,OAA+B,oBAAI,IAAI;AAGrD,SAAK,MAAM,OAAO,oBAAI,IAAI;AAAA,EAC5B;AAAA,EAEO,GACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,eAAS,KAAK,OAAO;AAAA,IACvB,OAAO;AACL,WAAK,IAAI,IAAI,MAAM,CAAC,OAAO,CAA2C;AAAA,IACxE;AAEA,WAAO,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACrC;AAAA,EAEO,IACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,UAAI,SAAS;AACX,iBAAS,OAAO,SAAS,QAAQ,OAAO,MAAM,GAAG,CAAC;AAAA,MACpD,OAAO;AACL,aAAK,IAAI,IAAI,MAAM,CAAC,CAAC;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAAA,EAEO,KACL,SACG,MACH;AACA,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,WAAW,KAAK,IAAI,IAAI,IAAI;AAChC,QAAI,UAAU;AACZ,MAAC,SAAoD;AAAA,QAAQ,CAAC,MAC5D,EAAE,GAAI;AAAA,MACR;AAAA,IACF;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA8C;AAAA,QAAQ,CAAC,MACtD,EAAE,MAAM,GAAI;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,eACd,UACA;AACA,SAAO,IAAI;AAAA,IACT,IAAI;AAAA,MACF,OAAO,QAAQ,YAAY,CAAC,CAAC;AAAA,IAO/B;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,18 @@
+type EventType = string | symbol;
+type EmitArgs<Events extends Record<EventType, unknown>, Key extends keyof Events> = undefined extends Events[Key] ? [evt?: Events[Key]] : [evt: Events[Key]];
+type Handler<T = unknown> = (event: T) => void;
+type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+type EventHandlerList<T = unknown> = Array<Handler<T>>;
+type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | "*", EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+type GenericEventHandler<Events extends Record<EventType, unknown>> = Handler<Events[keyof Events]> | WildcardHandler<Events>;
+declare class EventBus<Events extends Record<EventType, unknown>> {
+    readonly all: EventHandlerMap<Events>;
+    constructor(all?: EventHandlerMap<Events>);
+    on<Key extends keyof Events | "*">(type: Key, handler: GenericEventHandler<Events>): () => void;
+    off<Key extends keyof Events | "*">(type: Key, handler?: GenericEventHandler<Events>): void;
+    emit<Key extends keyof Events | "*">(type: Key, ...args: EmitArgs<Events, Key>): void;
+}
+declare function createEventBus<Events extends Record<EventType, unknown>>(defaults?: Record<keyof Events | "*", GenericEventHandler<Events>[]>): EventBus<Events>;
+
+export { type EmitArgs, EventBus, type EventHandlerList, type EventHandlerMap, type EventType, type Handler, type WildCardEventHandlerList, type WildcardHandler, createEventBus };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+type EventType = string | symbol;
+type EmitArgs<Events extends Record<EventType, unknown>, Key extends keyof Events> = undefined extends Events[Key] ? [evt?: Events[Key]] : [evt: Events[Key]];
+type Handler<T = unknown> = (event: T) => void;
+type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+type EventHandlerList<T = unknown> = Array<Handler<T>>;
+type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | "*", EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+type GenericEventHandler<Events extends Record<EventType, unknown>> = Handler<Events[keyof Events]> | WildcardHandler<Events>;
+declare class EventBus<Events extends Record<EventType, unknown>> {
+    readonly all: EventHandlerMap<Events>;
+    constructor(all?: EventHandlerMap<Events>);
+    on<Key extends keyof Events | "*">(type: Key, handler: GenericEventHandler<Events>): () => void;
+    off<Key extends keyof Events | "*">(type: Key, handler?: GenericEventHandler<Events>): void;
+    emit<Key extends keyof Events | "*">(type: Key, ...args: EmitArgs<Events, Key>): void;
+}
+declare function createEventBus<Events extends Record<EventType, unknown>>(defaults?: Record<keyof Events | "*", GenericEventHandler<Events>[]>): EventBus<Events>;
+
+export { type EmitArgs, EventBus, type EventHandlerList, type EventHandlerMap, type EventType, type Handler, type WildCardEventHandlerList, type WildcardHandler, createEventBus };

package/dist/index.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/EventBus.ts
+var EventBus = class {
+  constructor(all) {
+    __publicField(this, "all", /* @__PURE__ */ new Map());
+    this.all = all || /* @__PURE__ */ new Map();
+  }
+  on(type, handler) {
+    const handlers = this.all.get(type);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      this.all.set(type, [handler]);
+    }
+    return () => this.off(type, handler);
+  }
+  off(type, handler) {
+    const handlers = this.all.get(type);
+    if (handlers) {
+      if (handler) {
+        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+      } else {
+        this.all.set(type, []);
+      }
+    }
+  }
+  emit(type, ...args) {
+    const evt = args[0];
+    let handlers = this.all.get(type);
+    if (handlers) {
+      handlers.forEach(
+        (h) => h(evt)
+      );
+    }
+    handlers = this.all.get("*");
+    if (handlers) {
+      handlers.forEach(
+        (h) => h(type, evt)
+      );
+    }
+  }
+};
+function createEventBus(defaults) {
+  return new EventBus(
+    new Map(
+      Object.entries(defaults || {})
+    )
+  );
+}
+export {
+  EventBus,
+  createEventBus
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/EventBus.ts"],"sourcesContent":["export type EventType = string | symbol;\n\nexport type EmitArgs<\n  Events extends Record<EventType, unknown>,\n  Key extends keyof Events,\n> = undefined extends Events[Key] ? [evt?: Events[Key]] : [evt: Events[Key]];\n\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n  type: keyof T,\n  event: T[keyof T]\n) => void;\n\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<\n  WildcardHandler<T>\n>;\n\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | \"*\",\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\ntype GenericEventHandler<Events extends Record<EventType, unknown>> =\n  | Handler<Events[keyof Events]>\n  | WildcardHandler<Events>;\n\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  public readonly all: EventHandlerMap<Events> = new Map();\n\n  public constructor(all?: EventHandlerMap<Events>) {\n    this.all = all || new Map();\n  }\n\n  public on<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler: GenericEventHandler<Events>\n  ) {\n    const handlers: Array<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      handlers.push(handler);\n    } else {\n      this.all.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n    }\n\n    return () => this.off(type, handler);\n  }\n\n  public off<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler?: GenericEventHandler<Events>\n  ) {\n    const handlers: Array<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      if (handler) {\n        handlers.splice(handlers.indexOf(handler) >>> 0, 1);\n      } else {\n        this.all.set(type, []);\n      }\n    }\n  }\n\n  public emit<Key extends keyof Events | \"*\">(\n    type: Key,\n    ...args: EmitArgs<Events, Key>\n  ) {\n    const evt = args[0] as Events[Key];\n    let handlers = this.all.get(type);\n    if (handlers) {\n      (handlers as EventHandlerList<Events[keyof Events]>).forEach((h) =>\n        h(evt!)\n      );\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as WildCardEventHandlerList<Events>).forEach((h) =>\n        h(type, evt!)\n      );\n    }\n  }\n}\n\nexport function createEventBus<Events extends Record<EventType, unknown>>(\n  defaults?: Record<keyof Events | \"*\", GenericEventHandler<Events>[]>\n) {\n  return new EventBus<Events>(\n    new Map(\n      Object.entries(defaults || {}) as [\n        keyof Events | \"*\",\n        (\n          | EventHandlerList<Events[keyof Events]>\n          | WildCardEventHandlerList<Events>\n        ),\n      ][]\n    )\n  );\n}\n"],"mappings":";;;;;AA2BO,IAAM,WAAN,MAA0D;AAAA,EAGxD,YAAY,KAA+B;AAFlD,wBAAgB,OAA+B,oBAAI,IAAI;AAGrD,SAAK,MAAM,OAAO,oBAAI,IAAI;AAAA,EAC5B;AAAA,EAEO,GACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,eAAS,KAAK,OAAO;AAAA,IACvB,OAAO;AACL,WAAK,IAAI,IAAI,MAAM,CAAC,OAAO,CAA2C;AAAA,IACxE;AAEA,WAAO,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACrC;AAAA,EAEO,IACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,UAAI,SAAS;AACX,iBAAS,OAAO,SAAS,QAAQ,OAAO,MAAM,GAAG,CAAC;AAAA,MACpD,OAAO;AACL,aAAK,IAAI,IAAI,MAAM,CAAC,CAAC;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAAA,EAEO,KACL,SACG,MACH;AACA,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,WAAW,KAAK,IAAI,IAAI,IAAI;AAChC,QAAI,UAAU;AACZ,MAAC,SAAoD;AAAA,QAAQ,CAAC,MAC5D,EAAE,GAAI;AAAA,MACR;AAAA,IACF;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA8C;AAAA,QAAQ,CAAC,MACtD,EAAE,MAAM,GAAI;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,eACd,UACA;AACA,SAAO,IAAI;AAAA,IACT,IAAI;AAAA,MACF,OAAO,QAAQ,YAAY,CAAC,CAAC;AAAA,IAO/B;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pixotope/event-bus",
+  "version": "0.2.0",
+  "description": "Typed in-memory event bus for Pixotope Foundation",
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.7.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --sourcemap",
+    "check-types": "tsc --noEmit",
+    "test": "vitest"
+  }
+}

package/src/EventBus.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from "vitest";
+import { EventBus, createEventBus } from "./EventBus";
+
+describe("EventBus", () => {
+  it("should create an event bus", () => {
+    const bus = new EventBus();
+    expect(bus).toBeDefined();
+  });
+
+  it("should be able to emit an event", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on("test", handler);
+    bus.emit("test");
+    expect(handler).toHaveBeenCalled();
+  });
+
+  it("should be able to off an event", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on("test", handler);
+    bus.off("test", handler);
+    bus.emit("test");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("should be able to off all events", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on("test", handler);
+    bus.off("test");
+    bus.emit("test");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("should be able to off a specific event", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on("test", handler);
+    bus.off("test", handler);
+    bus.emit("test");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("should be able to emit an event with a wildcard handler", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on("*", handler);
+    bus.emit("test");
+    expect(handler).toHaveBeenCalled();
+  });
+
+  it("should return off function when on is called", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    const off = bus.on("test", handler);
+    off();
+    bus.emit("test");
+    expect(handler).not.toHaveBeenCalled();
+  });
+});
+
+describe("createEventBus", () => {
+  it("should create an event bus with a specific type", () => {
+    const bus = createEventBus();
+    expect(bus).toBeDefined();
+  });
+});

package/src/EventBus.ts

@@ -0,0 +1,100 @@
+export type EventType = string | symbol;
+
+export type EmitArgs<
+  Events extends Record<EventType, unknown>,
+  Key extends keyof Events,
+> = undefined extends Events[Key] ? [evt?: Events[Key]] : [evt: Events[Key]];
+
+export type Handler<T = unknown> = (event: T) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (
+  type: keyof T,
+  event: T[keyof T]
+) => void;
+
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<
+  WildcardHandler<T>
+>;
+
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+  keyof Events | "*",
+  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
+>;
+
+type GenericEventHandler<Events extends Record<EventType, unknown>> =
+  | Handler<Events[keyof Events]>
+  | WildcardHandler<Events>;
+
+export class EventBus<Events extends Record<EventType, unknown>> {
+  public readonly all: EventHandlerMap<Events> = new Map();
+
+  public constructor(all?: EventHandlerMap<Events>) {
+    this.all = all || new Map();
+  }
+
+  public on<Key extends keyof Events | "*">(
+    type: Key,
+    handler: GenericEventHandler<Events>
+  ) {
+    const handlers: Array<GenericEventHandler<Events>> | undefined =
+      this.all.get(type);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      this.all.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
+    }
+
+    return () => this.off(type, handler);
+  }
+
+  public off<Key extends keyof Events | "*">(
+    type: Key,
+    handler?: GenericEventHandler<Events>
+  ) {
+    const handlers: Array<GenericEventHandler<Events>> | undefined =
+      this.all.get(type);
+    if (handlers) {
+      if (handler) {
+        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+      } else {
+        this.all.set(type, []);
+      }
+    }
+  }
+
+  public emit<Key extends keyof Events | "*">(
+    type: Key,
+    ...args: EmitArgs<Events, Key>
+  ) {
+    const evt = args[0] as Events[Key];
+    let handlers = this.all.get(type);
+    if (handlers) {
+      (handlers as EventHandlerList<Events[keyof Events]>).forEach((h) =>
+        h(evt!)
+      );
+    }
+
+    handlers = this.all.get("*");
+    if (handlers) {
+      (handlers as WildCardEventHandlerList<Events>).forEach((h) =>
+        h(type, evt!)
+      );
+    }
+  }
+}
+
+export function createEventBus<Events extends Record<EventType, unknown>>(
+  defaults?: Record<keyof Events | "*", GenericEventHandler<Events>[]>
+) {
+  return new EventBus<Events>(
+    new Map(
+      Object.entries(defaults || {}) as [
+        keyof Events | "*",
+        (
+          | EventHandlerList<Events[keyof Events]>
+          | WildCardEventHandlerList<Events>
+        ),
+      ][]
+    )
+  );
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./EventBus";

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "rootDir": "./src",
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020"],
+    "types": [],
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "useDefineForClassFields": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noEmit": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": false,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.mts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["src/**/*.{test,spec}.ts"],
+  },
+});