@pixotope/event-bus 0.2.0 → 0.4.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pixotope/event-bus@0.2.0 build /home/circleci/project/packages/event-bus
+> @pixotope/event-bus@0.4.0 build /home/circleci/project/packages/event-bus
 > tsup src/index.ts --format cjs,esm --dts --sourcemap
 
 CLI Building entry: src/index.ts
@@ -8,13 +8,13 @@
 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
+ESM dist/index.js     1.40 KB
+ESM dist/index.js.map 3.67 KB
+ESM ⚡️ Build success in 198ms
+CJS dist/index.cjs     2.36 KB
+CJS dist/index.cjs.map 3.76 KB
+CJS ⚡️ Build success in 199ms
 DTS Build start
-DTS ⚡️ Build success in 1702ms
-DTS dist/index.d.cts 1.53 KB
-DTS dist/index.d.ts  1.53 KB
+DTS ⚡️ Build success in 2192ms
+DTS dist/index.d.cts 1.94 KB
+DTS dist/index.d.ts  1.94 KB

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

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

package/.turbo/turbo-test.log

@@ -1,14 +1,14 @@
 
-> @pixotope/event-bus@0.2.0 test /home/circleci/project/packages/event-bus
+> @pixotope/event-bus@0.4.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
+ ✓ src/EventBus.test.ts (8 tests) 99ms
 
  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)
+   Start at  16:16:57
+   Duration  4.18s (transform 712ms, setup 0ms, collect 893ms, tests 99ms, environment 0ms, prepare 1.21s)
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pixotope/event-bus
 
+## 0.4.0
+
+### Minor Changes
+
+- 1a24c42: stronger event-bus types
+
+## 0.3.0
+
+### Minor Changes
+
+- dddca36: use set for event bus
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -22,8 +22,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  EventBus: () => EventBus,
-  createEventBus: () => createEventBus
+  EventBus: () => EventBus
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -36,48 +35,45 @@ var EventBus = class {
   on(type, handler) {
     const handlers = this.all.get(type);
     if (handlers) {
-      handlers.push(handler);
+      handlers.add(handler);
     } else {
-      this.all.set(type, [handler]);
+      this.all.set(type, /* @__PURE__ */ new Set([handler]));
     }
     return () => this.off(type, handler);
   }
+  /**
+   * Remove an event handler
+   * @param type - The event type
+   * @param handler - The event 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, []);
-      }
-    }
+    return this.all.get(type)?.delete(handler) ?? false;
   }
+  /**
+   * Emit an event
+   * @param type - The event type
+   * @param args - The event arguments
+   */
   emit(type, ...args) {
     const evt = args[0];
     let handlers = this.all.get(type);
     if (handlers) {
-      handlers.forEach(
-        (h) => h(evt)
-      );
+      handlers.forEach((h) => h(evt));
     }
     handlers = this.all.get("*");
     if (handlers) {
-      handlers.forEach(
-        (h) => h(type, evt)
-      );
+      handlers.forEach((h) => h(type, evt));
     }
   }
+  /**
+   * Clear all event handlers
+   */
+  dispose() {
+    this.all.clear();
+  }
 };
-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
+  EventBus
 });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +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":[]}
+{"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 EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | \"*\",\n  Set<GenericEventHandler<Events>>\n>;\n\nexport type GenericEventHandler<Events extends Record<EventType, unknown>> =\n  | Handler<Events[keyof Events]>\n  | WildcardHandler<Events>;\n\ntype IsLooseEvents<Events extends Record<EventType, unknown>> =\n  string extends keyof Events ? true : false;\n\nexport class EventBus<\n  Events extends Record<EventType, unknown> = Record<EventType, unknown>,\n> {\n  public readonly all: EventHandlerMap<Events> = new Map();\n\n  public constructor(all?: EventHandlerMap<Events>) {\n    this.all = all || new Map();\n  }\n\n  /**\n   * Add an event handler\n   * @param type - The event type\n   * @param handler - The event handler\n   * @returns A function to remove the event handler\n   */\n  public on(\n    type: keyof Events,\n    handler: Handler<Events[typeof type]>\n  ): () => void;\n  public on(type: \"*\", handler: WildcardHandler<Events>): () => void;\n  public on<T extends string>(\n    type: IsLooseEvents<Events> extends true ? T : never,\n    handler: IsLooseEvents<Events> extends true\n      ? (...args: any[]) => void\n      : never\n  ): () => void;\n  public on(type: keyof Events | \"*\", handler: GenericEventHandler<Events>) {\n    const handlers = this.all.get(type);\n    if (handlers) {\n      handlers.add(handler);\n    } else {\n      this.all.set(type, new Set([handler]));\n    }\n\n    return () => this.off(type, handler);\n  }\n\n  /**\n   * Remove an event handler\n   * @param type - The event type\n   * @param handler - The event handler\n   */\n  public off(\n    type: keyof Events | \"*\",\n    handler: (...args: any[]) => any\n  ): boolean {\n    return this.all.get(type)?.delete(handler) ?? false;\n  }\n\n  /**\n   * Emit an event\n   * @param type - The event type\n   * @param args - The event arguments\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 Set<Handler<Events[Key]>>).forEach((h) => h(evt!));\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as Set<WildcardHandler<Events>>).forEach((h) => h(type, evt!));\n    }\n  }\n\n  /**\n   * Clear all event handlers\n   */\n  public dispose() {\n    this.all.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACyBO,IAAM,WAAN,MAEL;AAAA,EAGO,YAAY,KAA+B;AAFlD,wBAAgB,OAA+B,oBAAI,IAAI;AAGrD,SAAK,MAAM,OAAO,oBAAI,IAAI;AAAA,EAC5B;AAAA,EAmBO,GAAG,MAA0B,SAAsC;AACxE,UAAM,WAAW,KAAK,IAAI,IAAI,IAAI;AAClC,QAAI,UAAU;AACZ,eAAS,IAAI,OAAO;AAAA,IACtB,OAAO;AACL,WAAK,IAAI,IAAI,MAAM,oBAAI,IAAI,CAAC,OAAO,CAAC,CAAC;AAAA,IACvC;AAEA,WAAO,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IACL,MACA,SACS;AACT,WAAO,KAAK,IAAI,IAAI,IAAI,GAAG,OAAO,OAAO,KAAK;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,KACL,SACG,MACH;AACA,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,WAAW,KAAK,IAAI,IAAI,IAAI;AAChC,QAAI,UAAU;AACZ,MAAC,SAAuC,QAAQ,CAAC,MAAM,EAAE,GAAI,CAAC;AAAA,IAChE;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA0C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAI,CAAC;AAAA,IACzE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKO,UAAU;AACf,SAAK,IAAI,MAAM;AAAA,EACjB;AACF;","names":[]}

package/dist/index.d.cts

@@ -2,17 +2,37 @@ 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 EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | "*", Set<GenericEventHandler<Events>>>;
 type GenericEventHandler<Events extends Record<EventType, unknown>> = Handler<Events[keyof Events]> | WildcardHandler<Events>;
-declare class EventBus<Events extends Record<EventType, unknown>> {
+type IsLooseEvents<Events extends Record<EventType, unknown>> = string extends keyof Events ? true : false;
+declare class EventBus<Events extends Record<EventType, unknown> = 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;
+    /**
+     * Add an event handler
+     * @param type - The event type
+     * @param handler - The event handler
+     * @returns A function to remove the event handler
+     */
+    on(type: keyof Events, handler: Handler<Events[typeof type]>): () => void;
+    on(type: "*", handler: WildcardHandler<Events>): () => void;
+    on<T extends string>(type: IsLooseEvents<Events> extends true ? T : never, handler: IsLooseEvents<Events> extends true ? (...args: any[]) => void : never): () => void;
+    /**
+     * Remove an event handler
+     * @param type - The event type
+     * @param handler - The event handler
+     */
+    off(type: keyof Events | "*", handler: (...args: any[]) => any): boolean;
+    /**
+     * Emit an event
+     * @param type - The event type
+     * @param args - The event arguments
+     */
+    emit<Key extends keyof Events>(type: Key, ...args: EmitArgs<Events, Key>): void;
+    /**
+     * Clear all event handlers
+     */
+    dispose(): 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 };
+export { type EmitArgs, EventBus, type EventHandlerMap, type EventType, type GenericEventHandler, type Handler, type WildcardHandler };

package/dist/index.d.ts

@@ -2,17 +2,37 @@ 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 EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | "*", Set<GenericEventHandler<Events>>>;
 type GenericEventHandler<Events extends Record<EventType, unknown>> = Handler<Events[keyof Events]> | WildcardHandler<Events>;
-declare class EventBus<Events extends Record<EventType, unknown>> {
+type IsLooseEvents<Events extends Record<EventType, unknown>> = string extends keyof Events ? true : false;
+declare class EventBus<Events extends Record<EventType, unknown> = 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;
+    /**
+     * Add an event handler
+     * @param type - The event type
+     * @param handler - The event handler
+     * @returns A function to remove the event handler
+     */
+    on(type: keyof Events, handler: Handler<Events[typeof type]>): () => void;
+    on(type: "*", handler: WildcardHandler<Events>): () => void;
+    on<T extends string>(type: IsLooseEvents<Events> extends true ? T : never, handler: IsLooseEvents<Events> extends true ? (...args: any[]) => void : never): () => void;
+    /**
+     * Remove an event handler
+     * @param type - The event type
+     * @param handler - The event handler
+     */
+    off(type: keyof Events | "*", handler: (...args: any[]) => any): boolean;
+    /**
+     * Emit an event
+     * @param type - The event type
+     * @param args - The event arguments
+     */
+    emit<Key extends keyof Events>(type: Key, ...args: EmitArgs<Events, Key>): void;
+    /**
+     * Clear all event handlers
+     */
+    dispose(): 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 };
+export { type EmitArgs, EventBus, type EventHandlerMap, type EventType, type GenericEventHandler, type Handler, type WildcardHandler };

package/dist/index.js

@@ -11,47 +11,44 @@ var EventBus = class {
   on(type, handler) {
     const handlers = this.all.get(type);
     if (handlers) {
-      handlers.push(handler);
+      handlers.add(handler);
     } else {
-      this.all.set(type, [handler]);
+      this.all.set(type, /* @__PURE__ */ new Set([handler]));
     }
     return () => this.off(type, handler);
   }
+  /**
+   * Remove an event handler
+   * @param type - The event type
+   * @param handler - The event 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, []);
-      }
-    }
+    return this.all.get(type)?.delete(handler) ?? false;
   }
+  /**
+   * Emit an event
+   * @param type - The event type
+   * @param args - The event arguments
+   */
   emit(type, ...args) {
     const evt = args[0];
     let handlers = this.all.get(type);
     if (handlers) {
-      handlers.forEach(
-        (h) => h(evt)
-      );
+      handlers.forEach((h) => h(evt));
     }
     handlers = this.all.get("*");
     if (handlers) {
-      handlers.forEach(
-        (h) => h(type, evt)
-      );
+      handlers.forEach((h) => h(type, evt));
     }
   }
+  /**
+   * Clear all event handlers
+   */
+  dispose() {
+    this.all.clear();
+  }
 };
-function createEventBus(defaults) {
-  return new EventBus(
-    new Map(
-      Object.entries(defaults || {})
-    )
-  );
-}
 export {
-  EventBus,
-  createEventBus
+  EventBus
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +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":[]}
+{"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 EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | \"*\",\n  Set<GenericEventHandler<Events>>\n>;\n\nexport type GenericEventHandler<Events extends Record<EventType, unknown>> =\n  | Handler<Events[keyof Events]>\n  | WildcardHandler<Events>;\n\ntype IsLooseEvents<Events extends Record<EventType, unknown>> =\n  string extends keyof Events ? true : false;\n\nexport class EventBus<\n  Events extends Record<EventType, unknown> = Record<EventType, unknown>,\n> {\n  public readonly all: EventHandlerMap<Events> = new Map();\n\n  public constructor(all?: EventHandlerMap<Events>) {\n    this.all = all || new Map();\n  }\n\n  /**\n   * Add an event handler\n   * @param type - The event type\n   * @param handler - The event handler\n   * @returns A function to remove the event handler\n   */\n  public on(\n    type: keyof Events,\n    handler: Handler<Events[typeof type]>\n  ): () => void;\n  public on(type: \"*\", handler: WildcardHandler<Events>): () => void;\n  public on<T extends string>(\n    type: IsLooseEvents<Events> extends true ? T : never,\n    handler: IsLooseEvents<Events> extends true\n      ? (...args: any[]) => void\n      : never\n  ): () => void;\n  public on(type: keyof Events | \"*\", handler: GenericEventHandler<Events>) {\n    const handlers = this.all.get(type);\n    if (handlers) {\n      handlers.add(handler);\n    } else {\n      this.all.set(type, new Set([handler]));\n    }\n\n    return () => this.off(type, handler);\n  }\n\n  /**\n   * Remove an event handler\n   * @param type - The event type\n   * @param handler - The event handler\n   */\n  public off(\n    type: keyof Events | \"*\",\n    handler: (...args: any[]) => any\n  ): boolean {\n    return this.all.get(type)?.delete(handler) ?? false;\n  }\n\n  /**\n   * Emit an event\n   * @param type - The event type\n   * @param args - The event arguments\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 Set<Handler<Events[Key]>>).forEach((h) => h(evt!));\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as Set<WildcardHandler<Events>>).forEach((h) => h(type, evt!));\n    }\n  }\n\n  /**\n   * Clear all event handlers\n   */\n  public dispose() {\n    this.all.clear();\n  }\n}\n"],"mappings":";;;;;AAyBO,IAAM,WAAN,MAEL;AAAA,EAGO,YAAY,KAA+B;AAFlD,wBAAgB,OAA+B,oBAAI,IAAI;AAGrD,SAAK,MAAM,OAAO,oBAAI,IAAI;AAAA,EAC5B;AAAA,EAmBO,GAAG,MAA0B,SAAsC;AACxE,UAAM,WAAW,KAAK,IAAI,IAAI,IAAI;AAClC,QAAI,UAAU;AACZ,eAAS,IAAI,OAAO;AAAA,IACtB,OAAO;AACL,WAAK,IAAI,IAAI,MAAM,oBAAI,IAAI,CAAC,OAAO,CAAC,CAAC;AAAA,IACvC;AAEA,WAAO,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IACL,MACA,SACS;AACT,WAAO,KAAK,IAAI,IAAI,IAAI,GAAG,OAAO,OAAO,KAAK;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,KACL,SACG,MACH;AACA,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,WAAW,KAAK,IAAI,IAAI,IAAI;AAChC,QAAI,UAAU;AACZ,MAAC,SAAuC,QAAQ,CAAC,MAAM,EAAE,GAAI,CAAC;AAAA,IAChE;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA0C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAI,CAAC;AAAA,IACzE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKO,UAAU;AACf,SAAK,IAAI,MAAM;AAAA,EACjB;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixotope/event-bus",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Typed in-memory event bus for Pixotope Foundation",
   "private": false,
   "type": "module",

package/src/EventBus.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
-import { EventBus, createEventBus } from "./EventBus";
+import { EventBus } from "./EventBus";
 
 describe("EventBus", () => {
   it("should create an event bus", () => {
@@ -11,8 +11,8 @@ describe("EventBus", () => {
     const bus = new EventBus();
     const handler = vi.fn();
     bus.on("test", handler);
-    bus.emit("test");
-    expect(handler).toHaveBeenCalled();
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledWith({ payload: "test" });
   });
 
   it("should be able to off an event", () => {
@@ -24,45 +24,97 @@ describe("EventBus", () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it("should be able to off all events", () => {
+  it("should be able to emit an event with a wildcard handler", () => {
     const bus = new EventBus();
     const handler = vi.fn();
-    bus.on("test", handler);
-    bus.off("test");
-    bus.emit("test");
-    expect(handler).not.toHaveBeenCalled();
+    bus.on("*", handler);
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledWith("test", { payload: "test" });
   });
 
-  it("should be able to off a specific event", () => {
+  it("should return off function when on is called", () => {
     const bus = new EventBus();
     const handler = vi.fn();
-    bus.on("test", handler);
-    bus.off("test", handler);
+    const off = bus.on("test", handler);
+    off();
     bus.emit("test");
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it("should be able to emit an event with a wildcard handler", () => {
+  it("should be able to achieve once functionality", () => {
     const bus = new EventBus();
     const handler = vi.fn();
-    bus.on("*", handler);
+    const off = bus.on("test", () => {
+      handler();
+      off();
+    });
     bus.emit("test");
-    expect(handler).toHaveBeenCalled();
+    bus.emit("test");
+    expect(handler).toHaveBeenCalledTimes(1);
   });
 
-  it("should return off function when on is called", () => {
-    const bus = new EventBus();
+  it("should work with correct event types", () => {
+    const bus = new EventBus<{
+      test: { payload: string };
+      test2: { payload: number };
+      test3: { payload: boolean };
+    }>();
     const handler = vi.fn();
-    const off = bus.on("test", handler);
-    off();
-    bus.emit("test");
-    expect(handler).not.toHaveBeenCalled();
+    const handler2 = vi.fn();
+
+    bus.on("test", handler);
+    bus.on("test", ({ payload }) => {
+      expect(payload).toBeTypeOf("string");
+      expect(payload).toBe("test");
+    });
+    bus.on("test2", ({ payload }) => {
+      expect(payload).toBeTypeOf("number");
+      expect(payload).toBe(1);
+    });
+    bus.on("test2", handler2);
+    bus.on("test3", ({ payload }) => {
+      expect(payload).toBeTypeOf("boolean");
+      expect(payload).toBe(true);
+    });
+
+    bus.emit("test", { payload: "test" });
+    bus.emit("test2", { payload: 1 });
+    bus.emit("test3", { payload: true });
+
+    expect(handler).toHaveBeenCalledWith({ payload: "test" });
+    expect(handler2).toHaveBeenCalledWith({ payload: 1 });
+
+    const off = bus.off("test", handler);
+    expect(off).toBe(true);
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledTimes(1);
   });
-});
 
-describe("createEventBus", () => {
-  it("should create an event bus with a specific type", () => {
-    const bus = createEventBus();
-    expect(bus).toBeDefined();
+  it("should be able to work without providing event types", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    const handler2 = vi.fn();
+
+    bus.on("test", ({ payload }: { payload: string }) => {
+      expect(payload).toBeTypeOf("string");
+      expect(payload).toBe("test");
+    });
+
+    bus.on("test", handler);
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledWith({ payload: "test" });
+    const off = bus.off("test", handler);
+    expect(off).toBe(true);
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    bus.on("test2", handler2);
+    bus.emit("test2", { payload: "test2" });
+    bus.emit("test2", { payload: "test2" });
+    expect(handler2).toHaveBeenCalledTimes(2);
+    expect(bus.off("test2", handler2)).toBe(true);
+
+    const testTypedHandler = (_args: { payload: string }) => {};
+    expect(bus.off("randomChannel", testTypedHandler)).toBe(false);
   });
 });

package/src/EventBus.ts

@@ -11,90 +11,92 @@ export type WildcardHandler<T = Record<string, unknown>> = (
   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>
+  Set<GenericEventHandler<Events>>
 >;
 
-type GenericEventHandler<Events extends Record<EventType, unknown>> =
+export type GenericEventHandler<Events extends Record<EventType, unknown>> =
   | Handler<Events[keyof Events]>
   | WildcardHandler<Events>;
 
-export class EventBus<Events extends Record<EventType, unknown>> {
+type IsLooseEvents<Events extends Record<EventType, unknown>> =
+  string extends keyof Events ? true : false;
+
+export class EventBus<
+  Events extends Record<EventType, unknown> = 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);
+  /**
+   * Add an event handler
+   * @param type - The event type
+   * @param handler - The event handler
+   * @returns A function to remove the event handler
+   */
+  public on(
+    type: keyof Events,
+    handler: Handler<Events[typeof type]>
+  ): () => void;
+  public on(type: "*", handler: WildcardHandler<Events>): () => void;
+  public on<T extends string>(
+    type: IsLooseEvents<Events> extends true ? T : never,
+    handler: IsLooseEvents<Events> extends true
+      ? (...args: any[]) => void
+      : never
+  ): () => void;
+  public on(type: keyof Events | "*", handler: GenericEventHandler<Events>) {
+    const handlers = this.all.get(type);
     if (handlers) {
-      handlers.push(handler);
+      handlers.add(handler);
     } else {
-      this.all.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
+      this.all.set(type, new Set([handler]));
     }
 
     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, []);
-      }
-    }
+  /**
+   * Remove an event handler
+   * @param type - The event type
+   * @param handler - The event handler
+   */
+  public off(
+    type: keyof Events | "*",
+    handler: (...args: any[]) => any
+  ): boolean {
+    return this.all.get(type)?.delete(handler) ?? false;
   }
 
-  public emit<Key extends keyof Events | "*">(
+  /**
+   * Emit an event
+   * @param type - The event type
+   * @param args - The event arguments
+   */
+  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 as Set<Handler<Events[Key]>>).forEach((h) => h(evt!));
     }
 
     handlers = this.all.get("*");
     if (handlers) {
-      (handlers as WildCardEventHandlerList<Events>).forEach((h) =>
-        h(type, evt!)
-      );
+      (handlers as Set<WildcardHandler<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>
-        ),
-      ][]
-    )
-  );
+  /**
+   * Clear all event handlers
+   */
+  public dispose() {
+    this.all.clear();
+  }
 }