@pixotope/event-bus 0.2.0 → 0.3.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.3.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
+CJS dist/index.cjs     2.46 KB
+CJS dist/index.cjs.map 3.61 KB
+CJS ⚡️ Build success in 502ms
+ESM dist/index.js     1.46 KB
+ESM dist/index.js.map 3.51 KB
+ESM ⚡️ Build success in 503ms
 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 1794ms
+DTS dist/index.d.cts 1.29 KB
+DTS dist/index.d.ts  1.29 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.3.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.3.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 (9 tests) 177ms
 
  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)
+      Tests  9 passed (9)
+   Start at  13:10:04
+   Duration  3.91s (transform 871ms, setup 0ms, collect 794ms, tests 177ms, environment 0ms, prepare 1.00s)
 

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pixotope/event-bus
 
+## 0.3.0
+
+### Minor Changes
+
+- dddca36: use set for event bus
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -36,9 +36,9 @@ 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);
   }
@@ -46,9 +46,9 @@ var EventBus = class {
     const handlers = this.all.get(type);
     if (handlers) {
       if (handler) {
-        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        handlers.delete(handler);
       } else {
-        this.all.set(type, []);
+        this.all.set(type, /* @__PURE__ */ new Set());
       }
     }
   }
@@ -68,10 +68,10 @@ var EventBus = class {
     }
   }
 };
-function createEventBus(defaults) {
+function createEventBus(defaults = {}) {
   return new EventBus(
     new Map(
-      Object.entries(defaults || {})
+      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])
     )
   );
 }

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\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: Set<GenericEventHandler<Events>> | undefined =\n      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  public off<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler?: GenericEventHandler<Events>\n  ) {\n    const handlers: Set<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      if (handler) {\n        handlers.delete(handler);\n      } else {\n        this.all.set(type, new Set());\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 Set<Handler<Events[Key]>>).forEach((h) =>\n        h(evt!)\n      );\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as Set<WildcardHandler<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>[]> = {} as Record<keyof Events, GenericEventHandler<Events>[]>\n) {\n  return new EventBus<Events>(\n    new Map(\n      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsBO,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,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,EAEO,IACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,UAAI,SAAS;AACX,iBAAS,OAAO,OAAO;AAAA,MACzB,OAAO;AACL,aAAK,IAAI,IAAI,MAAM,oBAAI,IAAI,CAAC;AAAA,MAC9B;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,SAAuC;AAAA,QAAQ,CAAC,MAC/C,EAAE,GAAI;AAAA,MACR;AAAA,IACF;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA0C;AAAA,QAAQ,CAAC,MAClD,EAAE,MAAM,GAAI;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,eACd,WAAgE,CAAC,GACjE;AACA,SAAO,IAAI;AAAA,IACT,IAAI;AAAA,MACF,OAAO,QAAQ,QAAQ,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC;AAAA,IACtE;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.cts

@@ -2,17 +2,15 @@ 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>> {
     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;
+    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>;
+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 Handler, type WildcardHandler, createEventBus };

package/dist/index.d.ts

@@ -2,17 +2,15 @@ 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>> {
     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;
+    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>;
+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 Handler, type WildcardHandler, createEventBus };

package/dist/index.js

@@ -11,9 +11,9 @@ 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);
   }
@@ -21,9 +21,9 @@ var EventBus = class {
     const handlers = this.all.get(type);
     if (handlers) {
       if (handler) {
-        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        handlers.delete(handler);
       } else {
-        this.all.set(type, []);
+        this.all.set(type, /* @__PURE__ */ new Set());
       }
     }
   }
@@ -43,10 +43,10 @@ var EventBus = class {
     }
   }
 };
-function createEventBus(defaults) {
+function createEventBus(defaults = {}) {
   return new EventBus(
     new Map(
-      Object.entries(defaults || {})
+      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])
     )
   );
 }

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\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: Set<GenericEventHandler<Events>> | undefined =\n      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  public off<Key extends keyof Events | \"*\">(\n    type: Key,\n    handler?: GenericEventHandler<Events>\n  ) {\n    const handlers: Set<GenericEventHandler<Events>> | undefined =\n      this.all.get(type);\n    if (handlers) {\n      if (handler) {\n        handlers.delete(handler);\n      } else {\n        this.all.set(type, new Set());\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 Set<Handler<Events[Key]>>).forEach((h) =>\n        h(evt!)\n      );\n    }\n\n    handlers = this.all.get(\"*\");\n    if (handlers) {\n      (handlers as Set<WildcardHandler<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>[]> = {} as Record<keyof Events, GenericEventHandler<Events>[]>\n) {\n  return new EventBus<Events>(\n    new Map(\n      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])\n    )\n  );\n}\n"],"mappings":";;;;;AAsBO,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,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,EAEO,IACL,MACA,SACA;AACA,UAAM,WACJ,KAAK,IAAI,IAAI,IAAI;AACnB,QAAI,UAAU;AACZ,UAAI,SAAS;AACX,iBAAS,OAAO,OAAO;AAAA,MACzB,OAAO;AACL,aAAK,IAAI,IAAI,MAAM,oBAAI,IAAI,CAAC;AAAA,MAC9B;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,SAAuC;AAAA,QAAQ,CAAC,MAC/C,EAAE,GAAI;AAAA,MACR;AAAA,IACF;AAEA,eAAW,KAAK,IAAI,IAAI,GAAG;AAC3B,QAAI,UAAU;AACZ,MAAC,SAA0C;AAAA,QAAQ,CAAC,MAClD,EAAE,MAAM,GAAI;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACF;AAEO,SAAS,eACd,WAAgE,CAAC,GACjE;AACA,SAAO,IAAI;AAAA,IACT,IAAI;AAAA,MACF,OAAO,QAAQ,QAAQ,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC;AAAA,IACtE;AAAA,EACF;AACF;","names":[]}

package/package.json

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

package/src/EventBus.test.ts

@@ -46,8 +46,8 @@ describe("EventBus", () => {
     const bus = new EventBus();
     const handler = vi.fn();
     bus.on("*", handler);
-    bus.emit("test");
-    expect(handler).toHaveBeenCalled();
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledWith("test", { payload: "test" });
   });
 
   it("should return off function when on is called", () => {
@@ -65,4 +65,29 @@ describe("createEventBus", () => {
     const bus = createEventBus();
     expect(bus).toBeDefined();
   });
+  it("should create an event bus with a default handler", () => {
+    const handler = vi.fn();
+    const handler2 = vi.fn();
+    const catchAllHandler = vi.fn();
+    const bus = createEventBus<{
+      test: { payload: string };
+      test2: { payload: string };
+      "*": { payload: string };
+    }>({
+      test: [handler],
+      test2: [handler2],
+      "*": [catchAllHandler],
+    });
+    
+    expect(bus).toBeDefined();
+
+    bus.emit("test", { payload: "test" });
+    expect(handler).toHaveBeenCalledWith({ payload: "test" });
+    bus.emit("test2", { payload: "test" });
+    expect(handler2).toHaveBeenCalledWith({ payload: "test" });
+
+    expect(catchAllHandler).toHaveBeenCalledTimes(2);
+    expect(catchAllHandler).toHaveBeenCalledWith("test", { payload: "test" });
+    expect(catchAllHandler).toHaveBeenCalledWith("test2", { payload: "test" });
+  });
 });

package/src/EventBus.ts

@@ -11,14 +11,9 @@ 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>> =
@@ -36,12 +31,12 @@ export class EventBus<Events extends Record<EventType, unknown>> {
     type: Key,
     handler: GenericEventHandler<Events>
   ) {
-    const handlers: Array<GenericEventHandler<Events>> | undefined =
+    const handlers: Set<GenericEventHandler<Events>> | undefined =
       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);
@@ -51,32 +46,32 @@ export class EventBus<Events extends Record<EventType, unknown>> {
     type: Key,
     handler?: GenericEventHandler<Events>
   ) {
-    const handlers: Array<GenericEventHandler<Events>> | undefined =
+    const handlers: Set<GenericEventHandler<Events>> | undefined =
       this.all.get(type);
     if (handlers) {
       if (handler) {
-        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        handlers.delete(handler);
       } else {
-        this.all.set(type, []);
+        this.all.set(type, new Set());
       }
     }
   }
 
-  public emit<Key extends keyof Events | "*">(
+  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) =>
+      (handlers as Set<Handler<Events[Key]>>).forEach((h) =>
         h(evt!)
       );
     }
 
     handlers = this.all.get("*");
     if (handlers) {
-      (handlers as WildCardEventHandlerList<Events>).forEach((h) =>
+      (handlers as Set<WildcardHandler<Events>>).forEach((h) =>
         h(type, evt!)
       );
     }
@@ -84,17 +79,11 @@ export class EventBus<Events extends Record<EventType, unknown>> {
 }
 
 export function createEventBus<Events extends Record<EventType, unknown>>(
-  defaults?: Record<keyof Events | "*", GenericEventHandler<Events>[]>
+  defaults: Record<keyof Events, GenericEventHandler<Events>[]> = {} as Record<keyof Events, GenericEventHandler<Events>[]>
 ) {
   return new EventBus<Events>(
     new Map(
-      Object.entries(defaults || {}) as [
-        keyof Events | "*",
-        (
-          | EventHandlerList<Events[keyof Events]>
-          | WildCardEventHandlerList<Events>
-        ),
-      ][]
+      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])
     )
   );
 }