@pixotope/event-bus 0.3.0 → 0.4.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pixotope/event-bus@0.3.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.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
+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 1794ms
-DTS dist/index.d.cts 1.29 KB
-DTS dist/index.d.ts  1.29 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.3.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.3.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 (9 tests) 177ms
+ ✓ src/EventBus.test.ts (8 tests) 99ms
 
  Test Files  1 passed (1)
-      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)
+      Tests  8 passed (8)
+   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,11 @@
 # @pixotope/event-bus
 
+## 0.4.0
+
+### Minor Changes
+
+- 1a24c42: stronger event-bus types
+
 ## 0.3.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);
 
@@ -42,42 +41,39 @@ var EventBus = class {
     }
     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.delete(handler);
-      } else {
-        this.all.set(type, /* @__PURE__ */ new Set());
-      }
-    }
+    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).map(([key, value]) => [key, new Set(value)])
-    )
-  );
-}
 // 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 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":[]}
+{"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

@@ -4,13 +4,35 @@ type Handler<T = unknown> = (event: T) => void;
 type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
 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;
+    /**
+     * 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 EventHandlerMap, type EventType, type Handler, type WildcardHandler, createEventBus };
+export { type EmitArgs, EventBus, type EventHandlerMap, type EventType, type GenericEventHandler, type Handler, type WildcardHandler };

package/dist/index.d.ts

@@ -4,13 +4,35 @@ type Handler<T = unknown> = (event: T) => void;
 type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
 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;
+    /**
+     * 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 EventHandlerMap, type EventType, type Handler, type WildcardHandler, createEventBus };
+export { type EmitArgs, EventBus, type EventHandlerMap, type EventType, type GenericEventHandler, type Handler, type WildcardHandler };

package/dist/index.js

@@ -17,41 +17,38 @@ var EventBus = class {
     }
     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.delete(handler);
-      } else {
-        this.all.set(type, /* @__PURE__ */ new Set());
-      }
-    }
+    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).map(([key, value]) => [key, new Set(value)])
-    )
-  );
-}
 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 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":[]}
+{"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.3.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,24 +24,6 @@ describe("EventBus", () => {
     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();
@@ -58,36 +40,81 @@ describe("EventBus", () => {
     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();
+  it("should be able to achieve once functionality", () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    const off = bus.on("test", () => {
+      handler();
+      off();
+    });
+    bus.emit("test");
+    bus.emit("test");
+    expect(handler).toHaveBeenCalledTimes(1);
   });
-  it("should create an event bus with a default handler", () => {
+
+  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 handler2 = vi.fn();
-    const catchAllHandler = vi.fn();
-    const bus = createEventBus<{
-      test: { payload: string };
-      test2: { payload: string };
-      "*": { payload: string };
-    }>({
-      test: [handler],
-      test2: [handler2],
-      "*": [catchAllHandler],
+
+    bus.on("test", handler);
+    bus.on("test", ({ payload }) => {
+      expect(payload).toBeTypeOf("string");
+      expect(payload).toBe("test");
     });
-    
-    expect(bus).toBeDefined();
+    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);
+  });
+
+  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" });
-    bus.emit("test2", { payload: "test" });
-    expect(handler2).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);
 
-    expect(catchAllHandler).toHaveBeenCalledTimes(2);
-    expect(catchAllHandler).toHaveBeenCalledWith("test", { payload: "test" });
-    expect(catchAllHandler).toHaveBeenCalledWith("test2", { payload: "test" });
+    const testTypedHandler = (_args: { payload: string }) => {};
+    expect(bus.off("randomChannel", testTypedHandler)).toBe(false);
   });
 });

package/src/EventBus.ts

@@ -16,23 +16,41 @@ export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
   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: Set<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.add(handler);
     } else {
@@ -42,21 +60,23 @@ export class EventBus<Events extends Record<EventType, unknown>> {
     return () => this.off(type, handler);
   }
 
-  public off<Key extends keyof Events | "*">(
-    type: Key,
-    handler?: GenericEventHandler<Events>
-  ) {
-    const handlers: Set<GenericEventHandler<Events>> | undefined =
-      this.all.get(type);
-    if (handlers) {
-      if (handler) {
-        handlers.delete(handler);
-      } else {
-        this.all.set(type, new Set());
-      }
-    }
+  /**
+   * 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;
   }
 
+  /**
+   * 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>
@@ -64,26 +84,19 @@ export class EventBus<Events extends Record<EventType, unknown>> {
     const evt = args[0] as Events[Key];
     let handlers = this.all.get(type);
     if (handlers) {
-      (handlers as Set<Handler<Events[Key]>>).forEach((h) =>
-        h(evt!)
-      );
+      (handlers as Set<Handler<Events[Key]>>).forEach((h) => h(evt!));
     }
 
     handlers = this.all.get("*");
     if (handlers) {
-      (handlers as Set<WildcardHandler<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>[]> = {} as Record<keyof Events, GenericEventHandler<Events>[]>
-) {
-  return new EventBus<Events>(
-    new Map(
-      Object.entries(defaults).map(([key, value]) => [key, new Set(value)])
-    )
-  );
+  /**
+   * Clear all event handlers
+   */
+  public dispose() {
+    this.all.clear();
+  }
 }