@ahoo-wang/fetcher-eventbus 2.8.6 → 2.8.8

package/dist/abstractTypedEventBus.d.ts

@@ -0,0 +1,16 @@
+import { TypedEventBus } from './typedEventBus';
+import { EventHandler, EventType } from './types';
+export declare abstract class AbstractTypedEventBus<EVENT> implements TypedEventBus<EVENT> {
+    protected eventHandlers: EventHandler<EVENT>[];
+    abstract type: EventType;
+    /**
+     * Gets a copy of all registered event handlers, sorted by order
+     */
+    get handlers(): EventHandler<EVENT>[];
+    destroy(): void;
+    protected handleEvent(handler: EventHandler<EVENT>, event: EVENT): Promise<void>;
+    abstract emit(event: EVENT): Promise<void>;
+    abstract off(name: string): boolean;
+    abstract on(handler: EventHandler<EVENT>): boolean;
+}
+//# sourceMappingURL=abstractTypedEventBus.d.ts.map

package/dist/abstractTypedEventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractTypedEventBus.d.ts","sourceRoot":"","sources":["../src/abstractTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD,8BAAsB,qBAAqB,CAAC,KAAK,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAChF,SAAS,CAAC,aAAa,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAM;IACpD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;OAEG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAEpC;IAED,OAAO;cAIS,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtF,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1C,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAEnC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CACnD"}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export * from './eventBus';
+export * from './abstractTypedEventBus';
 export * from './parallelTypedEventBus';
 export * from './serialTypedEventBus';
 export * from './typedEventBus';
 export * from './broadcastTypedEventBus';
 export * from './types';
+export * from './nameGenerator';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,YAAY,CAAC;AAC3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC"}

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { toSorted as o } from "@ahoo-wang/fetcher";
-class l {
+import { toSorted as a } from "@ahoo-wang/fetcher";
+class c {
   /**
    * Creates a generic event bus
    *
@@ -51,14 +51,9 @@ class l {
     this.buses.clear();
   }
 }
-class d {
-  /**
-   * Creates a parallel typed event bus
-   *
-   * @param type - The event type identifier for this bus
-   */
-  constructor(e) {
-    this.type = e, this.eventHandlers = [];
+class i {
+  constructor() {
+    this.eventHandlers = [];
   }
   /**
    * Gets a copy of all registered event handlers, sorted by order
@@ -66,6 +61,26 @@ class d {
   get handlers() {
     return [...this.eventHandlers];
   }
+  destroy() {
+    this.eventHandlers = [];
+  }
+  async handleEvent(e, t) {
+    try {
+      e.handle(t);
+    } catch (s) {
+      console.warn(`Event handler error for ${e.name}:`, s);
+    }
+  }
+}
+class u extends i {
+  /**
+   * Creates a parallel typed event bus
+   *
+   * @param type - The event type identifier for this bus
+   */
+  constructor(e) {
+    super(), this.type = e;
+  }
   /**
    * Emits an event to all registered handlers in parallel
    *
@@ -75,17 +90,11 @@ class d {
    * @param event - The event to emit
    */
   async emit(e) {
-    const t = [], s = this.eventHandlers.map(async (r) => {
-      try {
-        await r.handle(e);
-      } catch (a) {
-        console.warn(`Event handler error for ${r.name}:`, a);
-      } finally {
-        r.once && t.push(r);
-      }
+    const t = [], s = this.eventHandlers.map(async (n) => {
+      await this.handleEvent(n, e), n.once && t.push(n);
     });
     await Promise.all(s), t.length > 0 && (this.eventHandlers = this.eventHandlers.filter(
-      (r) => !t.includes(r)
+      (n) => !t.includes(n)
     ));
   }
   /**
@@ -110,24 +119,15 @@ class d {
     const t = this.eventHandlers;
     return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = [...t, e], !0);
   }
-  destroy() {
-    this.eventHandlers = [];
-  }
 }
-class h {
+class d extends i {
   /**
    * Creates an in-memory typed event bus
    *
    * @param type - The event type identifier for this bus
    */
   constructor(e) {
-    this.type = e, this.sortedHandlers = [];
-  }
-  /**
-   * Gets a copy of all registered event handlers, sorted by order
-   */
-  get handlers() {
-    return [...this.sortedHandlers];
+    super(), this.type = e;
   }
   /**
    * Emits an event to all registered handlers serially
@@ -139,16 +139,10 @@ class h {
    */
   async emit(e) {
     const t = [];
-    for (const s of this.sortedHandlers)
-      try {
-        await s.handle(e);
-      } catch (r) {
-        console.warn(`Event handler error for ${s.name}:`, r);
-      } finally {
-        s.once && t.push(s);
-      }
-    t.length > 0 && (this.sortedHandlers = o(
-      this.sortedHandlers.filter((s) => !t.includes(s))
+    for (const s of this.eventHandlers)
+      await this.handleEvent(s, e), s.once && t.push(s);
+    t.length > 0 && (this.eventHandlers = a(
+      this.eventHandlers.filter((s) => !t.includes(s))
     ));
   }
   /**
@@ -158,8 +152,8 @@ class h {
    * @returns true if a handler was removed, false otherwise
    */
   off(e) {
-    const t = this.sortedHandlers;
-    return t.some((s) => s.name === e) ? (this.sortedHandlers = o(t, (s) => s.name !== e), !0) : !1;
+    const t = this.eventHandlers;
+    return t.some((s) => s.name === e) ? (this.eventHandlers = a(t, (s) => s.name !== e), !0) : !1;
   }
   /**
    * Adds an event handler if not already present
@@ -170,14 +164,11 @@ class h {
    * @returns true if the handler was added, false if a handler with the same name already exists
    */
   on(e) {
-    const t = this.sortedHandlers;
-    return t.some((s) => s.name === e.name) ? !1 : (this.sortedHandlers = o([...t, e]), !0);
-  }
-  destroy() {
-    this.sortedHandlers = [];
+    const t = this.eventHandlers;
+    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = a([...t, e]), !0);
   }
 }
-class c {
+class f {
   /**
    * Creates a broadcast typed event bus
    *
@@ -187,11 +178,11 @@ class c {
   constructor(e, t) {
     this.delegate = e, this.type = e.type;
     const s = t ?? `_broadcast_:${this.type}`;
-    this.broadcastChannel = new BroadcastChannel(s), this.broadcastChannel.onmessage = async (r) => {
+    this.broadcastChannel = new BroadcastChannel(s), this.broadcastChannel.onmessage = async (n) => {
       try {
-        await this.delegate.emit(r.data);
-      } catch (a) {
-        console.warn(`Broadcast event handler error for ${this.type}:`, a);
+        await this.delegate.emit(n.data);
+      } catch (o) {
+        console.warn(`Broadcast event handler error for ${this.type}:`, o);
       }
     };
   }
@@ -234,10 +225,27 @@ class c {
     this.broadcastChannel.close();
   }
 }
+class l {
+  constructor() {
+    this.namingCounter = 0;
+  }
+  /**
+   * Generates a unique name by appending an incrementing counter to the prefix
+   * @param prefix - The prefix for the generated name
+   * @returns The generated unique name
+   */
+  generate(e) {
+    return this.namingCounter++, `${e}_${this.namingCounter}`;
+  }
+}
+const m = new l();
 export {
-  c as BroadcastTypedEventBus,
-  l as EventBus,
-  d as ParallelTypedEventBus,
-  h as SerialTypedEventBus
+  i as AbstractTypedEventBus,
+  f as BroadcastTypedEventBus,
+  l as DefaultNameGenerator,
+  c as EventBus,
+  u as ParallelTypedEventBus,
+  d as SerialTypedEventBus,
+  m as nameGenerator
 };
 //# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../src/eventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/broadcastTypedEventBus.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { TypedEventBus } from './typedEventBus';\n\n/**\n * Supplier function for creating TypedEventBus instances by event type\n */\nexport type TypeEventBusSupplier = (type: EventType) => TypedEventBus<unknown>;\n\n/**\n * Generic event bus that manages multiple event types using lazy-loaded TypedEventBus instances\n *\n * @template Events - A record mapping event types to their event data types\n *\n * @example\n * ```typescript\n * const supplier = (type: EventType) => new SerialTypedEventBus(type);\n * const bus = new EventBus<{ 'user-login': string; 'order-update': number }>(supplier);\n * bus.on('user-login', { name: 'logger', order: 1, handle: (event) => console.log(event) });\n * await bus.emit('user-login', 'john-doe');\n * ```\n */\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  private readonly buses: Map<EventType, TypedEventBus<unknown>> = new Map();\n\n  /**\n   * Creates a generic event bus\n   *\n   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types\n   */\n  constructor(private readonly typeEventBusSupplier: TypeEventBusSupplier) {\n  }\n\n  /**\n   * Adds an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to listen for\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on<Key extends EventType>(\n    type: Key,\n    handler: EventHandler<Events[Key]>,\n  ): boolean {\n    let bus = this.buses.get(type);\n    if (!bus) {\n      bus = this.typeEventBusSupplier(type);\n      this.buses.set(type, bus);\n    }\n    return bus?.on(handler) ?? false;\n  }\n\n  /**\n   * Removes an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type\n   * @param name - The name of the event handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off<Key extends EventType>(\n    type: Key,\n    name: string,\n  ): boolean {\n    return this.buses.get(type)?.off(name) ?? false;\n  }\n\n  /**\n   * Emits an event for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to emit\n   * @param event - The event data\n   * @returns Promise if the underlying bus is async, void otherwise\n   */\n  emit<Key extends EventType>(\n    type: Key,\n    event: Events[Key],\n  ): void | Promise<void> {\n    return this.buses.get(type)?.emit(event);\n  }\n\n  /**\n   * Cleans up all managed event buses\n   */\n  destroy(): void {\n    for (const bus of this.buses.values()) {\n      bus.destroy();\n    }\n    this.buses.clear();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Parallel implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers in parallel.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new ParallelTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // Both handlers execute in parallel\n * ```\n */\nexport class ParallelTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  private eventHandlers: EventHandler<EVENT>[] = [];\n\n  /**\n   * Creates a parallel typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n  }\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.eventHandlers];\n  }\n\n  /**\n   * Emits an event to all registered handlers in parallel\n   *\n   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.\n   * Errors in individual handlers are logged but do not affect other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    const promises = this.eventHandlers.map(async handler => {\n      try {\n        await handler.handle(event);\n      } catch (e) {\n        console.warn(`Event handler error for ${handler.name}:`, e);\n      } finally {\n        if (handler.once) {\n          onceHandlers.push(handler);\n        }\n      }\n    });\n    await Promise.all(promises);\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = this.eventHandlers.filter(\n        item => !onceHandlers.includes(item),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = original.filter(item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = [...original, handler];\n    return true;\n  }\n\n  destroy() {\n    this.eventHandlers = [];\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\nimport { toSorted } from '@ahoo-wang/fetcher';\n\n/**\n * Serial implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers serially in order of priority.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new SerialTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // handler1 executes first, then handler2\n * ```\n */\nexport class SerialTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  private sortedHandlers: EventHandler<EVENT>[] = [];\n\n  /**\n   * Creates an in-memory typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n  }\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.sortedHandlers];\n  }\n\n  /**\n   * Emits an event to all registered handlers serially\n   *\n   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.\n   * Errors in individual handlers are logged but do not stop other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    for (const handler of this.sortedHandlers) {\n      try {\n        await handler.handle(event);\n      } catch (e) {\n        console.warn(`Event handler error for ${handler.name}:`, e);\n      } finally {\n        if (handler.once) {\n          onceHandlers.push(handler);\n        }\n      }\n    }\n    if (onceHandlers.length > 0) {\n      this.sortedHandlers = toSorted(\n        this.sortedHandlers.filter(item => !onceHandlers.includes(item)),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.sortedHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.sortedHandlers = toSorted(original, item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.sortedHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.sortedHandlers = toSorted([...original, handler]);\n    return true;\n  }\n\n  destroy() {\n    this.sortedHandlers = [];\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Broadcast implementation of TypedEventBus using BroadcastChannel API\n *\n * Enables cross-tab/window event broadcasting within the same origin. Events are first emitted\n * locally via the delegate, then broadcasted to other tabs/windows. Incoming broadcasts from\n * other tabs are handled by the delegate as well.\n *\n * Note: BroadcastChannel is only supported in modern browsers and requires same-origin policy.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const delegate = new SerialTypedEventBus<string>('user-events');\n * const bus = new BroadcastTypedEventBus(delegate);\n * bus.on({ name: 'user-login', order: 1, handle: (event) => console.log('User logged in:', event) });\n * await bus.emit('john-doe'); // Emits locally and broadcasts to other tabs\n * ```\n *\n * @example Custom channel name\n * ```typescript\n * const bus = new BroadcastTypedEventBus(delegate, 'my-custom-channel');\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly broadcastChannel: BroadcastChannel;\n\n  /**\n   * Creates a broadcast typed event bus\n   *\n   * @param delegate - The underlying TypedEventBus for local event handling\n   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`\n   */\n  constructor(\n    private readonly delegate: TypedEventBus<EVENT>,\n    channel?: string,\n  ) {\n    this.type = delegate.type;\n    const channelName = channel ?? `_broadcast_:${this.type}`;\n    this.broadcastChannel = new BroadcastChannel(channelName);\n    this.broadcastChannel.onmessage = async event => {\n      try {\n        await this.delegate.emit(event.data);\n      } catch (e) {\n        console.warn(`Broadcast event handler error for ${this.type}:`, e);\n      }\n    };\n  }\n\n  /**\n   * Gets a copy of all registered event handlers from the delegate\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other tabs/windows\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.broadcastChannel.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by name from the delegate\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Adds an event handler to the delegate\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    return this.delegate.on(handler);\n  }\n\n  /**\n   * Cleans up resources by closing the BroadcastChannel\n   */\n  destroy() {\n    this.broadcastChannel.close();\n  }\n}\n"],"names":["EventBus","typeEventBusSupplier","type","handler","bus","name","event","ParallelTypedEventBus","onceHandlers","promises","e","item","original","SerialTypedEventBus","toSorted","BroadcastTypedEventBus","delegate","channel","channelName"],"mappings":"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"}
+{"version":3,"file":"index.es.js","sources":["../src/eventBus.ts","../src/abstractTypedEventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/broadcastTypedEventBus.ts","../src/nameGenerator.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { TypedEventBus } from './typedEventBus';\n\n/**\n * Supplier function for creating TypedEventBus instances by event type\n */\nexport type TypeEventBusSupplier = (type: EventType) => TypedEventBus<unknown>;\n\n/**\n * Generic event bus that manages multiple event types using lazy-loaded TypedEventBus instances\n *\n * @template Events - A record mapping event types to their event data types\n *\n * @example\n * ```typescript\n * const supplier = (type: EventType) => new SerialTypedEventBus(type);\n * const bus = new EventBus<{ 'user-login': string; 'order-update': number }>(supplier);\n * bus.on('user-login', { name: 'logger', order: 1, handle: (event) => console.log(event) });\n * await bus.emit('user-login', 'john-doe');\n * ```\n */\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  private readonly buses: Map<EventType, TypedEventBus<unknown>> = new Map();\n\n  /**\n   * Creates a generic event bus\n   *\n   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types\n   */\n  constructor(private readonly typeEventBusSupplier: TypeEventBusSupplier) {\n  }\n\n  /**\n   * Adds an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to listen for\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on<Key extends EventType>(\n    type: Key,\n    handler: EventHandler<Events[Key]>,\n  ): boolean {\n    let bus = this.buses.get(type);\n    if (!bus) {\n      bus = this.typeEventBusSupplier(type);\n      this.buses.set(type, bus);\n    }\n    return bus?.on(handler) ?? false;\n  }\n\n  /**\n   * Removes an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type\n   * @param name - The name of the event handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off<Key extends EventType>(\n    type: Key,\n    name: string,\n  ): boolean {\n    return this.buses.get(type)?.off(name) ?? false;\n  }\n\n  /**\n   * Emits an event for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to emit\n   * @param event - The event data\n   * @returns Promise if the underlying bus is async, void otherwise\n   */\n  emit<Key extends EventType>(\n    type: Key,\n    event: Events[Key],\n  ): void | Promise<void> {\n    return this.buses.get(type)?.emit(event);\n  }\n\n  /**\n   * Cleans up all managed event buses\n   */\n  destroy(): void {\n    for (const bus of this.buses.values()) {\n      bus.destroy();\n    }\n    this.buses.clear();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\nexport abstract class AbstractTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  protected eventHandlers: EventHandler<EVENT>[] = [];\n  abstract type: EventType;\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.eventHandlers];\n  }\n\n  destroy() {\n    this.eventHandlers = [];\n  }\n\n  protected async handleEvent(handler: EventHandler<EVENT>, event: EVENT): Promise<void> {\n    try {\n      handler.handle(event);\n    } catch (e) {\n      console.warn(`Event handler error for ${handler.name}:`, e);\n    }\n  }\n\n  abstract emit(event: EVENT): Promise<void>;\n\n  abstract off(name: string): boolean;\n\n  abstract on(handler: EventHandler<EVENT>): boolean;\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { AbstractTypedEventBus } from './abstractTypedEventBus';\n\n/**\n * Parallel implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers in parallel.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new ParallelTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // Both handlers execute in parallel\n * ```\n */\nexport class ParallelTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {\n\n  /**\n   * Creates a parallel typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n    super();\n  }\n\n  /**\n   * Emits an event to all registered handlers in parallel\n   *\n   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.\n   * Errors in individual handlers are logged but do not affect other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    const promises = this.eventHandlers.map(async handler => {\n      await this.handleEvent(handler, event);\n      if (handler.once) {\n        onceHandlers.push(handler);\n      }\n    });\n    await Promise.all(promises);\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = this.eventHandlers.filter(\n        item => !onceHandlers.includes(item),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = original.filter(item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = [...original, handler];\n    return true;\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { toSorted } from '@ahoo-wang/fetcher';\nimport { AbstractTypedEventBus } from './abstractTypedEventBus';\n\n/**\n * Serial implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers serially in order of priority.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new SerialTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // handler1 executes first, then handler2\n * ```\n */\nexport class SerialTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {\n\n  /**\n   * Creates an in-memory typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n    super();\n  }\n\n  /**\n   * Emits an event to all registered handlers serially\n   *\n   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.\n   * Errors in individual handlers are logged but do not stop other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    for (const handler of this.eventHandlers) {\n      await this.handleEvent(handler, event);\n      if (handler.once) {\n        onceHandlers.push(handler);\n      }\n    }\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = toSorted(\n        this.eventHandlers.filter(item => !onceHandlers.includes(item)),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = toSorted(original, item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = toSorted([...original, handler]);\n    return true;\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Broadcast implementation of TypedEventBus using BroadcastChannel API\n *\n * Enables cross-tab/window event broadcasting within the same origin. Events are first emitted\n * locally via the delegate, then broadcasted to other tabs/windows. Incoming broadcasts from\n * other tabs are handled by the delegate as well.\n *\n * Note: BroadcastChannel is only supported in modern browsers and requires same-origin policy.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const delegate = new SerialTypedEventBus<string>('user-events');\n * const bus = new BroadcastTypedEventBus(delegate);\n * bus.on({ name: 'user-login', order: 1, handle: (event) => console.log('User logged in:', event) });\n * await bus.emit('john-doe'); // Emits locally and broadcasts to other tabs\n * ```\n *\n * @example Custom channel name\n * ```typescript\n * const bus = new BroadcastTypedEventBus(delegate, 'my-custom-channel');\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly broadcastChannel: BroadcastChannel;\n\n  /**\n   * Creates a broadcast typed event bus\n   *\n   * @param delegate - The underlying TypedEventBus for local event handling\n   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`\n   */\n  constructor(\n    private readonly delegate: TypedEventBus<EVENT>,\n    channel?: string,\n  ) {\n    this.type = delegate.type;\n    const channelName = channel ?? `_broadcast_:${this.type}`;\n    this.broadcastChannel = new BroadcastChannel(channelName);\n    this.broadcastChannel.onmessage = async event => {\n      try {\n        await this.delegate.emit(event.data);\n      } catch (e) {\n        console.warn(`Broadcast event handler error for ${this.type}:`, e);\n      }\n    };\n  }\n\n  /**\n   * Gets a copy of all registered event handlers from the delegate\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other tabs/windows\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.broadcastChannel.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by name from the delegate\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Adds an event handler to the delegate\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    return this.delegate.on(handler);\n  }\n\n  /**\n   * Cleans up resources by closing the BroadcastChannel\n   */\n  destroy() {\n    this.broadcastChannel.close();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Interface for generating unique names with a prefix\n */\nexport interface NameGenerator {\n  generate(prefix: string): string;\n}\n\n/**\n * Default implementation of NameGenerator that generates names with incrementing counters\n */\nexport class DefaultNameGenerator implements NameGenerator {\n  private namingCounter: number = 0;\n\n  /**\n   * Generates a unique name by appending an incrementing counter to the prefix\n   * @param prefix - The prefix for the generated name\n   * @returns The generated unique name\n   */\n  generate(prefix: string): string {\n    this.namingCounter++;\n    return `${prefix}_${this.namingCounter}`;\n  }\n}\n\n/**\n * Default instance of NameGenerator\n */\nexport const nameGenerator = new DefaultNameGenerator();\n"],"names":["EventBus","typeEventBusSupplier","type","handler","bus","name","event","AbstractTypedEventBus","e","ParallelTypedEventBus","onceHandlers","promises","item","original","SerialTypedEventBus","toSorted","BroadcastTypedEventBus","delegate","channel","channelName","DefaultNameGenerator","prefix","nameGenerator"],"mappings":"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"}

package/dist/index.umd.js

@@ -1,2 +1,2 @@
-(function(n,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","@ahoo-wang/fetcher"],a):(n=typeof globalThis<"u"?globalThis:n||self,a(n.FetcherEventBus={},n.Fetcher))})(this,(function(n,a){"use strict";class l{constructor(e){this.typeEventBusSupplier=e,this.buses=new Map}on(e,t){let s=this.buses.get(e);return s||(s=this.typeEventBusSupplier(e),this.buses.set(e,s)),s?.on(t)??!1}off(e,t){return this.buses.get(e)?.off(t)??!1}emit(e,t){return this.buses.get(e)?.emit(t)}destroy(){for(const e of this.buses.values())e.destroy();this.buses.clear()}}class d{constructor(e){this.type=e,this.eventHandlers=[]}get handlers(){return[...this.eventHandlers]}async emit(e){const t=[],s=this.eventHandlers.map(async r=>{try{await r.handle(e)}catch(i){console.warn(`Event handler error for ${r.name}:`,i)}finally{r.once&&t.push(r)}});await Promise.all(s),t.length>0&&(this.eventHandlers=this.eventHandlers.filter(r=>!t.includes(r)))}off(e){const t=this.eventHandlers;return t.some(s=>s.name===e)?(this.eventHandlers=t.filter(s=>s.name!==e),!0):!1}on(e){const t=this.eventHandlers;return t.some(s=>s.name===e.name)?!1:(this.eventHandlers=[...t,e],!0)}destroy(){this.eventHandlers=[]}}class h{constructor(e){this.type=e,this.sortedHandlers=[]}get handlers(){return[...this.sortedHandlers]}async emit(e){const t=[];for(const s of this.sortedHandlers)try{await s.handle(e)}catch(r){console.warn(`Event handler error for ${s.name}:`,r)}finally{s.once&&t.push(s)}t.length>0&&(this.sortedHandlers=a.toSorted(this.sortedHandlers.filter(s=>!t.includes(s))))}off(e){const t=this.sortedHandlers;return t.some(s=>s.name===e)?(this.sortedHandlers=a.toSorted(t,s=>s.name!==e),!0):!1}on(e){const t=this.sortedHandlers;return t.some(s=>s.name===e.name)?!1:(this.sortedHandlers=a.toSorted([...t,e]),!0)}destroy(){this.sortedHandlers=[]}}class u{constructor(e,t){this.delegate=e,this.type=e.type;const s=t??`_broadcast_:${this.type}`;this.broadcastChannel=new BroadcastChannel(s),this.broadcastChannel.onmessage=async r=>{try{await this.delegate.emit(r.data)}catch(i){console.warn(`Broadcast event handler error for ${this.type}:`,i)}}}get handlers(){return this.delegate.handlers}async emit(e){await this.delegate.emit(e),this.broadcastChannel.postMessage(e)}off(e){return this.delegate.off(e)}on(e){return this.delegate.on(e)}destroy(){this.broadcastChannel.close()}}n.BroadcastTypedEventBus=u,n.EventBus=l,n.ParallelTypedEventBus=d,n.SerialTypedEventBus=h,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));
+(function(n,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","@ahoo-wang/fetcher"],a):(n=typeof globalThis<"u"?globalThis:n||self,a(n.FetcherEventBus={},n.Fetcher))})(this,(function(n,a){"use strict";class u{constructor(e){this.typeEventBusSupplier=e,this.buses=new Map}on(e,t){let s=this.buses.get(e);return s||(s=this.typeEventBusSupplier(e),this.buses.set(e,s)),s?.on(t)??!1}off(e,t){return this.buses.get(e)?.off(t)??!1}emit(e,t){return this.buses.get(e)?.emit(t)}destroy(){for(const e of this.buses.values())e.destroy();this.buses.clear()}}class o{constructor(){this.eventHandlers=[]}get handlers(){return[...this.eventHandlers]}destroy(){this.eventHandlers=[]}async handleEvent(e,t){try{e.handle(t)}catch(s){console.warn(`Event handler error for ${e.name}:`,s)}}}class h extends o{constructor(e){super(),this.type=e}async emit(e){const t=[],s=this.eventHandlers.map(async r=>{await this.handleEvent(r,e),r.once&&t.push(r)});await Promise.all(s),t.length>0&&(this.eventHandlers=this.eventHandlers.filter(r=>!t.includes(r)))}off(e){const t=this.eventHandlers;return t.some(s=>s.name===e)?(this.eventHandlers=t.filter(s=>s.name!==e),!0):!1}on(e){const t=this.eventHandlers;return t.some(s=>s.name===e.name)?!1:(this.eventHandlers=[...t,e],!0)}}class d extends o{constructor(e){super(),this.type=e}async emit(e){const t=[];for(const s of this.eventHandlers)await this.handleEvent(s,e),s.once&&t.push(s);t.length>0&&(this.eventHandlers=a.toSorted(this.eventHandlers.filter(s=>!t.includes(s))))}off(e){const t=this.eventHandlers;return t.some(s=>s.name===e)?(this.eventHandlers=a.toSorted(t,s=>s.name!==e),!0):!1}on(e){const t=this.eventHandlers;return t.some(s=>s.name===e.name)?!1:(this.eventHandlers=a.toSorted([...t,e]),!0)}}class c{constructor(e,t){this.delegate=e,this.type=e.type;const s=t??`_broadcast_:${this.type}`;this.broadcastChannel=new BroadcastChannel(s),this.broadcastChannel.onmessage=async r=>{try{await this.delegate.emit(r.data)}catch(v){console.warn(`Broadcast event handler error for ${this.type}:`,v)}}}get handlers(){return this.delegate.handlers}async emit(e){await this.delegate.emit(e),this.broadcastChannel.postMessage(e)}off(e){return this.delegate.off(e)}on(e){return this.delegate.on(e)}destroy(){this.broadcastChannel.close()}}class l{constructor(){this.namingCounter=0}generate(e){return this.namingCounter++,`${e}_${this.namingCounter}`}}const f=new l;n.AbstractTypedEventBus=o,n.BroadcastTypedEventBus=c,n.DefaultNameGenerator=l,n.EventBus=u,n.ParallelTypedEventBus=h,n.SerialTypedEventBus=d,n.nameGenerator=f,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));
 //# sourceMappingURL=index.umd.js.map

package/dist/index.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.js","sources":["../src/eventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/broadcastTypedEventBus.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { TypedEventBus } from './typedEventBus';\n\n/**\n * Supplier function for creating TypedEventBus instances by event type\n */\nexport type TypeEventBusSupplier = (type: EventType) => TypedEventBus<unknown>;\n\n/**\n * Generic event bus that manages multiple event types using lazy-loaded TypedEventBus instances\n *\n * @template Events - A record mapping event types to their event data types\n *\n * @example\n * ```typescript\n * const supplier = (type: EventType) => new SerialTypedEventBus(type);\n * const bus = new EventBus<{ 'user-login': string; 'order-update': number }>(supplier);\n * bus.on('user-login', { name: 'logger', order: 1, handle: (event) => console.log(event) });\n * await bus.emit('user-login', 'john-doe');\n * ```\n */\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  private readonly buses: Map<EventType, TypedEventBus<unknown>> = new Map();\n\n  /**\n   * Creates a generic event bus\n   *\n   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types\n   */\n  constructor(private readonly typeEventBusSupplier: TypeEventBusSupplier) {\n  }\n\n  /**\n   * Adds an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to listen for\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on<Key extends EventType>(\n    type: Key,\n    handler: EventHandler<Events[Key]>,\n  ): boolean {\n    let bus = this.buses.get(type);\n    if (!bus) {\n      bus = this.typeEventBusSupplier(type);\n      this.buses.set(type, bus);\n    }\n    return bus?.on(handler) ?? false;\n  }\n\n  /**\n   * Removes an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type\n   * @param name - The name of the event handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off<Key extends EventType>(\n    type: Key,\n    name: string,\n  ): boolean {\n    return this.buses.get(type)?.off(name) ?? false;\n  }\n\n  /**\n   * Emits an event for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to emit\n   * @param event - The event data\n   * @returns Promise if the underlying bus is async, void otherwise\n   */\n  emit<Key extends EventType>(\n    type: Key,\n    event: Events[Key],\n  ): void | Promise<void> {\n    return this.buses.get(type)?.emit(event);\n  }\n\n  /**\n   * Cleans up all managed event buses\n   */\n  destroy(): void {\n    for (const bus of this.buses.values()) {\n      bus.destroy();\n    }\n    this.buses.clear();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Parallel implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers in parallel.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new ParallelTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // Both handlers execute in parallel\n * ```\n */\nexport class ParallelTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  private eventHandlers: EventHandler<EVENT>[] = [];\n\n  /**\n   * Creates a parallel typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n  }\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.eventHandlers];\n  }\n\n  /**\n   * Emits an event to all registered handlers in parallel\n   *\n   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.\n   * Errors in individual handlers are logged but do not affect other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    const promises = this.eventHandlers.map(async handler => {\n      try {\n        await handler.handle(event);\n      } catch (e) {\n        console.warn(`Event handler error for ${handler.name}:`, e);\n      } finally {\n        if (handler.once) {\n          onceHandlers.push(handler);\n        }\n      }\n    });\n    await Promise.all(promises);\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = this.eventHandlers.filter(\n        item => !onceHandlers.includes(item),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = original.filter(item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = [...original, handler];\n    return true;\n  }\n\n  destroy() {\n    this.eventHandlers = [];\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\nimport { toSorted } from '@ahoo-wang/fetcher';\n\n/**\n * Serial implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers serially in order of priority.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new SerialTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // handler1 executes first, then handler2\n * ```\n */\nexport class SerialTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  private sortedHandlers: EventHandler<EVENT>[] = [];\n\n  /**\n   * Creates an in-memory typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n  }\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.sortedHandlers];\n  }\n\n  /**\n   * Emits an event to all registered handlers serially\n   *\n   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.\n   * Errors in individual handlers are logged but do not stop other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    for (const handler of this.sortedHandlers) {\n      try {\n        await handler.handle(event);\n      } catch (e) {\n        console.warn(`Event handler error for ${handler.name}:`, e);\n      } finally {\n        if (handler.once) {\n          onceHandlers.push(handler);\n        }\n      }\n    }\n    if (onceHandlers.length > 0) {\n      this.sortedHandlers = toSorted(\n        this.sortedHandlers.filter(item => !onceHandlers.includes(item)),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.sortedHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.sortedHandlers = toSorted(original, item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.sortedHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.sortedHandlers = toSorted([...original, handler]);\n    return true;\n  }\n\n  destroy() {\n    this.sortedHandlers = [];\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Broadcast implementation of TypedEventBus using BroadcastChannel API\n *\n * Enables cross-tab/window event broadcasting within the same origin. Events are first emitted\n * locally via the delegate, then broadcasted to other tabs/windows. Incoming broadcasts from\n * other tabs are handled by the delegate as well.\n *\n * Note: BroadcastChannel is only supported in modern browsers and requires same-origin policy.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const delegate = new SerialTypedEventBus<string>('user-events');\n * const bus = new BroadcastTypedEventBus(delegate);\n * bus.on({ name: 'user-login', order: 1, handle: (event) => console.log('User logged in:', event) });\n * await bus.emit('john-doe'); // Emits locally and broadcasts to other tabs\n * ```\n *\n * @example Custom channel name\n * ```typescript\n * const bus = new BroadcastTypedEventBus(delegate, 'my-custom-channel');\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly broadcastChannel: BroadcastChannel;\n\n  /**\n   * Creates a broadcast typed event bus\n   *\n   * @param delegate - The underlying TypedEventBus for local event handling\n   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`\n   */\n  constructor(\n    private readonly delegate: TypedEventBus<EVENT>,\n    channel?: string,\n  ) {\n    this.type = delegate.type;\n    const channelName = channel ?? `_broadcast_:${this.type}`;\n    this.broadcastChannel = new BroadcastChannel(channelName);\n    this.broadcastChannel.onmessage = async event => {\n      try {\n        await this.delegate.emit(event.data);\n      } catch (e) {\n        console.warn(`Broadcast event handler error for ${this.type}:`, e);\n      }\n    };\n  }\n\n  /**\n   * Gets a copy of all registered event handlers from the delegate\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other tabs/windows\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.broadcastChannel.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by name from the delegate\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Adds an event handler to the delegate\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    return this.delegate.on(handler);\n  }\n\n  /**\n   * Cleans up resources by closing the BroadcastChannel\n   */\n  destroy() {\n    this.broadcastChannel.close();\n  }\n}\n"],"names":["EventBus","typeEventBusSupplier","type","handler","bus","name","event","ParallelTypedEventBus","onceHandlers","promises","e","item","original","SerialTypedEventBus","toSorted","BroadcastTypedEventBus","delegate","channel","channelName"],"mappings":"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"}
+{"version":3,"file":"index.umd.js","sources":["../src/eventBus.ts","../src/abstractTypedEventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/broadcastTypedEventBus.ts","../src/nameGenerator.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { TypedEventBus } from './typedEventBus';\n\n/**\n * Supplier function for creating TypedEventBus instances by event type\n */\nexport type TypeEventBusSupplier = (type: EventType) => TypedEventBus<unknown>;\n\n/**\n * Generic event bus that manages multiple event types using lazy-loaded TypedEventBus instances\n *\n * @template Events - A record mapping event types to their event data types\n *\n * @example\n * ```typescript\n * const supplier = (type: EventType) => new SerialTypedEventBus(type);\n * const bus = new EventBus<{ 'user-login': string; 'order-update': number }>(supplier);\n * bus.on('user-login', { name: 'logger', order: 1, handle: (event) => console.log(event) });\n * await bus.emit('user-login', 'john-doe');\n * ```\n */\nexport class EventBus<Events extends Record<EventType, unknown>> {\n  private readonly buses: Map<EventType, TypedEventBus<unknown>> = new Map();\n\n  /**\n   * Creates a generic event bus\n   *\n   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types\n   */\n  constructor(private readonly typeEventBusSupplier: TypeEventBusSupplier) {\n  }\n\n  /**\n   * Adds an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to listen for\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on<Key extends EventType>(\n    type: Key,\n    handler: EventHandler<Events[Key]>,\n  ): boolean {\n    let bus = this.buses.get(type);\n    if (!bus) {\n      bus = this.typeEventBusSupplier(type);\n      this.buses.set(type, bus);\n    }\n    return bus?.on(handler) ?? false;\n  }\n\n  /**\n   * Removes an event handler for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type\n   * @param name - The name of the event handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off<Key extends EventType>(\n    type: Key,\n    name: string,\n  ): boolean {\n    return this.buses.get(type)?.off(name) ?? false;\n  }\n\n  /**\n   * Emits an event for a specific event type\n   *\n   * @template Key - The event type\n   * @param type - The event type to emit\n   * @param event - The event data\n   * @returns Promise if the underlying bus is async, void otherwise\n   */\n  emit<Key extends EventType>(\n    type: Key,\n    event: Events[Key],\n  ): void | Promise<void> {\n    return this.buses.get(type)?.emit(event);\n  }\n\n  /**\n   * Cleans up all managed event buses\n   */\n  destroy(): void {\n    for (const bus of this.buses.values()) {\n      bus.destroy();\n    }\n    this.buses.clear();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\nexport abstract class AbstractTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  protected eventHandlers: EventHandler<EVENT>[] = [];\n  abstract type: EventType;\n\n  /**\n   * Gets a copy of all registered event handlers, sorted by order\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return [...this.eventHandlers];\n  }\n\n  destroy() {\n    this.eventHandlers = [];\n  }\n\n  protected async handleEvent(handler: EventHandler<EVENT>, event: EVENT): Promise<void> {\n    try {\n      handler.handle(event);\n    } catch (e) {\n      console.warn(`Event handler error for ${handler.name}:`, e);\n    }\n  }\n\n  abstract emit(event: EVENT): Promise<void>;\n\n  abstract off(name: string): boolean;\n\n  abstract on(handler: EventHandler<EVENT>): boolean;\n}","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { AbstractTypedEventBus } from './abstractTypedEventBus';\n\n/**\n * Parallel implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers in parallel.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new ParallelTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // Both handlers execute in parallel\n * ```\n */\nexport class ParallelTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {\n\n  /**\n   * Creates a parallel typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n    super();\n  }\n\n  /**\n   * Emits an event to all registered handlers in parallel\n   *\n   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.\n   * Errors in individual handlers are logged but do not affect other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    const promises = this.eventHandlers.map(async handler => {\n      await this.handleEvent(handler, event);\n      if (handler.once) {\n        onceHandlers.push(handler);\n      }\n    });\n    await Promise.all(promises);\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = this.eventHandlers.filter(\n        item => !onceHandlers.includes(item),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = original.filter(item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = [...original, handler];\n    return true;\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventHandler, EventType } from './types';\nimport { toSorted } from '@ahoo-wang/fetcher';\nimport { AbstractTypedEventBus } from './abstractTypedEventBus';\n\n/**\n * Serial implementation of TypedEventBus\n *\n * Provides an in-memory event bus that executes event handlers serially in order of priority.\n * Supports ordering and once-only execution of handlers.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const bus = new SerialTypedEventBus<string>('test');\n * bus.on({ name: 'handler1', order: 1, handle: (event) => console.log(event) });\n * bus.on({ name: 'handler2', order: 2, handle: (event) => console.log('second', event) });\n * await bus.emit('hello'); // handler1 executes first, then handler2\n * ```\n */\nexport class SerialTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {\n\n  /**\n   * Creates an in-memory typed event bus\n   *\n   * @param type - The event type identifier for this bus\n   */\n  constructor(public readonly type: EventType) {\n    super();\n  }\n\n  /**\n   * Emits an event to all registered handlers serially\n   *\n   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.\n   * Errors in individual handlers are logged but do not stop other handlers.\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    const onceHandlers: EventHandler<EVENT>[] = [];\n    for (const handler of this.eventHandlers) {\n      await this.handleEvent(handler, event);\n      if (handler.once) {\n        onceHandlers.push(handler);\n      }\n    }\n    if (onceHandlers.length > 0) {\n      this.eventHandlers = toSorted(\n        this.eventHandlers.filter(item => !onceHandlers.includes(item)),\n      );\n    }\n  }\n\n  /**\n   * Removes an event handler by name\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    const original = this.eventHandlers;\n    if (!original.some(item => item.name === name)) {\n      return false;\n    }\n    this.eventHandlers = toSorted(original, item => item.name !== name);\n    return true;\n  }\n\n  /**\n   * Adds an event handler if not already present\n   *\n   * Handlers are sorted by their order property after addition.\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    const original = this.eventHandlers;\n    if (original.some(item => item.name === handler.name)) {\n      return false;\n    }\n    this.eventHandlers = toSorted([...original, handler]);\n    return true;\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TypedEventBus } from './typedEventBus';\nimport { EventHandler, EventType } from './types';\n\n/**\n * Broadcast implementation of TypedEventBus using BroadcastChannel API\n *\n * Enables cross-tab/window event broadcasting within the same origin. Events are first emitted\n * locally via the delegate, then broadcasted to other tabs/windows. Incoming broadcasts from\n * other tabs are handled by the delegate as well.\n *\n * Note: BroadcastChannel is only supported in modern browsers and requires same-origin policy.\n *\n * @template EVENT - The type of events this bus handles\n *\n * @example\n * ```typescript\n * const delegate = new SerialTypedEventBus<string>('user-events');\n * const bus = new BroadcastTypedEventBus(delegate);\n * bus.on({ name: 'user-login', order: 1, handle: (event) => console.log('User logged in:', event) });\n * await bus.emit('john-doe'); // Emits locally and broadcasts to other tabs\n * ```\n *\n * @example Custom channel name\n * ```typescript\n * const bus = new BroadcastTypedEventBus(delegate, 'my-custom-channel');\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly broadcastChannel: BroadcastChannel;\n\n  /**\n   * Creates a broadcast typed event bus\n   *\n   * @param delegate - The underlying TypedEventBus for local event handling\n   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`\n   */\n  constructor(\n    private readonly delegate: TypedEventBus<EVENT>,\n    channel?: string,\n  ) {\n    this.type = delegate.type;\n    const channelName = channel ?? `_broadcast_:${this.type}`;\n    this.broadcastChannel = new BroadcastChannel(channelName);\n    this.broadcastChannel.onmessage = async event => {\n      try {\n        await this.delegate.emit(event.data);\n      } catch (e) {\n        console.warn(`Broadcast event handler error for ${this.type}:`, e);\n      }\n    };\n  }\n\n  /**\n   * Gets a copy of all registered event handlers from the delegate\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other tabs/windows\n   *\n   * @param event - The event to emit\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.broadcastChannel.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by name from the delegate\n   *\n   * @param name - The name of the handler to remove\n   * @returns true if a handler was removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Adds an event handler to the delegate\n   *\n   * @param handler - The event handler to add\n   * @returns true if the handler was added, false if a handler with the same name already exists\n   */\n  on(handler: EventHandler<EVENT>): boolean {\n    return this.delegate.on(handler);\n  }\n\n  /**\n   * Cleans up resources by closing the BroadcastChannel\n   */\n  destroy() {\n    this.broadcastChannel.close();\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Interface for generating unique names with a prefix\n */\nexport interface NameGenerator {\n  generate(prefix: string): string;\n}\n\n/**\n * Default implementation of NameGenerator that generates names with incrementing counters\n */\nexport class DefaultNameGenerator implements NameGenerator {\n  private namingCounter: number = 0;\n\n  /**\n   * Generates a unique name by appending an incrementing counter to the prefix\n   * @param prefix - The prefix for the generated name\n   * @returns The generated unique name\n   */\n  generate(prefix: string): string {\n    this.namingCounter++;\n    return `${prefix}_${this.namingCounter}`;\n  }\n}\n\n/**\n * Default instance of NameGenerator\n */\nexport const nameGenerator = new DefaultNameGenerator();\n"],"names":["EventBus","typeEventBusSupplier","type","handler","bus","name","event","AbstractTypedEventBus","e","ParallelTypedEventBus","onceHandlers","promises","item","original","SerialTypedEventBus","toSorted","BroadcastTypedEventBus","delegate","channel","channelName","DefaultNameGenerator","prefix","nameGenerator"],"mappings":"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"}

package/dist/nameGenerator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Interface for generating unique names with a prefix
+ */
+export interface NameGenerator {
+    generate(prefix: string): string;
+}
+/**
+ * Default implementation of NameGenerator that generates names with incrementing counters
+ */
+export declare class DefaultNameGenerator implements NameGenerator {
+    private namingCounter;
+    /**
+     * Generates a unique name by appending an incrementing counter to the prefix
+     * @param prefix - The prefix for the generated name
+     * @returns The generated unique name
+     */
+    generate(prefix: string): string;
+}
+/**
+ * Default instance of NameGenerator
+ */
+export declare const nameGenerator: DefaultNameGenerator;
+//# sourceMappingURL=nameGenerator.d.ts.map

package/dist/nameGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nameGenerator.d.ts","sourceRoot":"","sources":["../src/nameGenerator.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,aAAa;IACxD,OAAO,CAAC,aAAa,CAAa;IAElC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAIjC;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,sBAA6B,CAAC"}

package/dist/parallelTypedEventBus.d.ts

@@ -1,5 +1,5 @@
-import { TypedEventBus } from './typedEventBus';
 import { EventHandler, EventType } from './types';
+import { AbstractTypedEventBus } from './abstractTypedEventBus';
 /**
  * Parallel implementation of TypedEventBus
  *
@@ -16,19 +16,14 @@ import { EventHandler, EventType } from './types';
  * await bus.emit('hello'); // Both handlers execute in parallel
  * ```
  */
-export declare class ParallelTypedEventBus<EVENT> implements TypedEventBus<EVENT> {
+export declare class ParallelTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {
     readonly type: EventType;
-    private eventHandlers;
     /**
      * Creates a parallel typed event bus
      *
      * @param type - The event type identifier for this bus
      */
     constructor(type: EventType);
-    /**
-     * Gets a copy of all registered event handlers, sorted by order
-     */
-    get handlers(): EventHandler<EVENT>[];
     /**
      * Emits an event to all registered handlers in parallel
      *
@@ -54,6 +49,5 @@ export declare class ParallelTypedEventBus<EVENT> implements TypedEventBus<EVENT
      * @returns true if the handler was added, false if a handler with the same name already exists
      */
     on(handler: EventHandler<EVENT>): boolean;
-    destroy(): void;
 }
 //# sourceMappingURL=parallelTypedEventBus.d.ts.map

package/dist/parallelTypedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelTypedEventBus.d.ts","sourceRoot":"","sources":["../src/parallelTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAqB,CAAC,KAAK,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;aAQ3C,IAAI,EAAE,SAAS;IAP3C,OAAO,CAAC,aAAa,CAA6B;IAElD;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAG3C;;OAEG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAEpC;IAED;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;IASzC,OAAO;CAGR"}
+{"version":3,"file":"parallelTypedEventBus.d.ts","sourceRoot":"","sources":["../src/parallelTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAqB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAOhD,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}

package/dist/serialTypedEventBus.d.ts

@@ -1,5 +1,5 @@
-import { TypedEventBus } from './typedEventBus';
 import { EventHandler, EventType } from './types';
+import { AbstractTypedEventBus } from './abstractTypedEventBus';
 /**
  * Serial implementation of TypedEventBus
  *
@@ -16,19 +16,14 @@ import { EventHandler, EventType } from './types';
  * await bus.emit('hello'); // handler1 executes first, then handler2
  * ```
  */
-export declare class SerialTypedEventBus<EVENT> implements TypedEventBus<EVENT> {
+export declare class SerialTypedEventBus<EVENT> extends AbstractTypedEventBus<EVENT> {
     readonly type: EventType;
-    private sortedHandlers;
     /**
      * Creates an in-memory typed event bus
      *
      * @param type - The event type identifier for this bus
      */
     constructor(type: EventType);
-    /**
-     * Gets a copy of all registered event handlers, sorted by order
-     */
-    get handlers(): EventHandler<EVENT>[];
     /**
      * Emits an event to all registered handlers serially
      *
@@ -54,6 +49,5 @@ export declare class SerialTypedEventBus<EVENT> implements TypedEventBus<EVENT>
      * @returns true if the handler was added, false if a handler with the same name already exists
      */
     on(handler: EventHandler<EVENT>): boolean;
-    destroy(): void;
 }
 //# sourceMappingURL=serialTypedEventBus.d.ts.map

package/dist/serialTypedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialTypedEventBus.d.ts","sourceRoot":"","sources":["../src/serialTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGlD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB,CAAC,KAAK,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;aAQzC,IAAI,EAAE,SAAS;IAP3C,OAAO,CAAC,cAAc,CAA6B;IAEnD;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAG3C;;OAEG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAEpC;IAED;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;IASzC,OAAO;CAGR"}
+{"version":3,"file":"serialTypedEventBus.d.ts","sourceRoot":"","sources":["../src/serialTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAO9C,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahoo-wang/fetcher-eventbus",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "A TypeScript event bus library with serial, parallel, and broadcast implementations",
   "keywords": [
     "eventbus",