@ahoo-wang/fetcher-eventbus 2.8.8 → 2.9.1

package/dist/broadcastTypedEventBus.d.ts

@@ -1,66 +1,160 @@
 import { TypedEventBus } from './typedEventBus';
 import { EventHandler, EventType } from './types';
+import { CrossTabMessenger } from './messengers';
 /**
- * Broadcast implementation of TypedEventBus using BroadcastChannel API
+ * Configuration options for BroadcastTypedEventBus
  *
- * Enables cross-tab/window event broadcasting within the same origin. Events are first emitted
- * locally via the delegate, then broadcasted to other tabs/windows. Incoming broadcasts from
- * other tabs are handled by the delegate as well.
+ * @template EVENT - The event type this bus will handle
+ */
+export interface BroadcastTypedEventBusOptions<EVENT> {
+    /**
+     * The underlying event bus that handles local event processing and storage.
+     * This bus manages event handlers and local event emission.
+     */
+    delegate: TypedEventBus<EVENT>;
+    /**
+     * Optional messenger for cross-tab/window communication.
+     * If not provided, a default BroadcastChannel-based messenger will be created
+     * using the pattern `_broadcast_:{type}`. Must be a valid CrossTabMessenger
+     * implementation when provided.
+     */
+    messenger?: CrossTabMessenger;
+}
+/**
+ * Broadcast event bus that enables cross-tab/window communication
+ *
+ * This class extends a local TypedEventBus with cross-context broadcasting capabilities.
+ * When events are emitted, they are first processed locally by the delegate bus, then
+ * broadcasted to other browser contexts (tabs, windows, etc.) through the provided messenger.
  *
- * Note: BroadcastChannel is only supported in modern browsers and requires same-origin policy.
+ * Incoming broadcast messages from other contexts are automatically forwarded to the
+ * local delegate bus for processing by registered event handlers.
  *
- * @template EVENT - The type of events this bus handles
+ * @template EVENT - The event type this bus handles (must be serializable for cross-context transport)
  *
- * @example
+ * @example Basic usage with default messenger
  * ```typescript
+ * import { SerialTypedEventBus } from './serialTypedEventBus';
+ * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';
+ *
+ * // Create local event bus
  * const delegate = new SerialTypedEventBus<string>('user-events');
- * const bus = new BroadcastTypedEventBus(delegate);
- * bus.on({ name: 'user-login', order: 1, handle: (event) => console.log('User logged in:', event) });
- * await bus.emit('john-doe'); // Emits locally and broadcasts to other tabs
+ *
+ * // Create broadcast event bus with default messenger
+ * const bus = new BroadcastTypedEventBus({
+ *   delegate
+ *   // messenger will be auto-created as '_broadcast_:user-events'
+ * });
+ *
+ * // Register event handler
+ * bus.on({
+ *   name: 'user-login',
+ *   order: 1,
+ *   handle: (username: string) => console.log(`User ${username} logged in`)
+ * });
+ *
+ * // Emit event (will be processed locally and broadcasted to other tabs)
+ * await bus.emit('john-doe');
  * ```
  *
- * @example Custom channel name
+ * @example Using custom messenger
  * ```typescript
- * const bus = new BroadcastTypedEventBus(delegate, 'my-custom-channel');
+ * import { SerialTypedEventBus } from './serialTypedEventBus';
+ * import { createCrossTabMessenger } from './messengers';
+ * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';
+ *
+ * // Create local event bus
+ * const delegate = new SerialTypedEventBus<string>('user-events');
+ *
+ * // Create custom cross-tab messenger
+ * const messenger = createCrossTabMessenger('my-custom-channel');
+ *
+ * // Create broadcast event bus
+ * const bus = new BroadcastTypedEventBus({
+ *   delegate,
+ *   messenger
+ * });
+ *
+ * // Register event handler and emit events...
+ * ```
+ *
+ * @example Using custom messenger implementation
+ * ```typescript
+ * class CustomMessenger implements CrossTabMessenger {
+ *   // ... implementation
+ * }
+ *
+ * const customMessenger = new CustomMessenger();
+ * const bus = new BroadcastTypedEventBus({
+ *   delegate: new SerialTypedEventBus('events'),
+ *   messenger: customMessenger
+ * });
  * ```
  */
 export declare class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {
-    private readonly delegate;
     readonly type: EventType;
-    private readonly broadcastChannel;
+    private readonly delegate;
+    private messenger;
     /**
-     * Creates a broadcast typed event bus
+     * Creates a new broadcast event bus with cross-context communication
      *
-     * @param delegate - The underlying TypedEventBus for local event handling
-     * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`
+     * @param options - Configuration object containing delegate bus and optional messenger
+     * @throws {Error} If messenger creation fails when no messenger is provided
      */
-    constructor(delegate: TypedEventBus<EVENT>, channel?: string);
+    constructor(options: BroadcastTypedEventBusOptions<EVENT>);
     /**
-     * Gets a copy of all registered event handlers from the delegate
+     * Returns a copy of all currently registered event handlers
+     *
+     * This getter delegates to the underlying event bus and returns the current
+     * list of handlers that will process incoming events.
+     *
+     * @returns Array of event handlers registered with this bus
      */
     get handlers(): EventHandler<EVENT>[];
     /**
-     * Emits an event locally and broadcasts it to other tabs/windows
+     * Emits an event locally and broadcasts it to other browser contexts
+     *
+     * This method first processes the event through the local delegate bus,
+     * allowing all registered local handlers to process it. Then, if successful,
+     * the event is broadcasted to other tabs/windows through the messenger.
      *
-     * @param event - The event to emit
+     * Note: If broadcasting fails (e.g., due to messenger errors), the local
+     * emission is still completed and a warning is logged to console.
+     *
+     * @param event - The event data to emit and broadcast
+     * @returns Promise that resolves when local processing is complete
+     * @throws Propagates any errors from local event processing
      */
     emit(event: EVENT): Promise<void>;
     /**
-     * Removes an event handler by name from the delegate
+     * Removes an event handler by its registered name
+     *
+     * This method delegates to the underlying event bus to remove the specified
+     * handler. The handler will no longer receive events emitted to this bus.
      *
-     * @param name - The name of the handler to remove
-     * @returns true if a handler was removed, false otherwise
+     * @param name - The unique name of the handler to remove
+     * @returns true if a handler with the given name was found and removed, false otherwise
      */
     off(name: string): boolean;
     /**
-     * Adds an event handler to the delegate
+     * Registers a new event handler with this bus
      *
-     * @param handler - The event handler to add
-     * @returns true if the handler was added, false if a handler with the same name already exists
+     * The handler will receive all events emitted to this bus, both locally
+     * generated and received from other browser contexts via broadcasting.
+     *
+     * @param handler - The event handler configuration to register
+     * @returns true if the handler was successfully added, false if a handler with the same name already exists
      */
     on(handler: EventHandler<EVENT>): boolean;
     /**
-     * Cleans up resources by closing the BroadcastChannel
+     * Cleans up resources and stops cross-context communication
+     *
+     * This method closes the messenger connection, preventing further
+     * cross-tab communication. Local event handling continues to work
+     * through the delegate bus. After calling destroy(), the bus should
+     * not be used for broadcasting operations.
+     *
+     * Note: This does not remove event handlers or affect local event processing.
      */
     destroy(): void;
 }

package/dist/broadcastTypedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"broadcastTypedEventBus.d.ts","sourceRoot":"","sources":["../src/broadcastTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,sBAAsB,CAAC,KAAK,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAWtE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,SAAgB,IAAI,EAAE,SAAS,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IAEpD;;;;;OAKG;gBAEgB,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,EAC/C,OAAO,CAAC,EAAE,MAAM;IAclB;;OAEG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAEpC;IAED;;;;OAIG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;;OAKG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;IAIzC;;OAEG;IACH,OAAO;CAGR"}
+{"version":3,"file":"broadcastTypedEventBus.d.ts","sourceRoot":"","sources":["../src/broadcastTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAA2B,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE1E;;;;GAIG;AACH,MAAM,WAAW,6BAA6B,CAAC,KAAK;IAClD;;;OAGG;IACH,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAE/B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,qBAAa,sBAAsB,CAAC,KAAK,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IACxE,SAAgB,IAAI,EAAE,SAAS,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,SAAS,CAAoB;IAErC;;;;;OAKG;gBACS,OAAO,EAAE,6BAA6B,CAAC,KAAK,CAAC;IAczD;;;;;;;OAOG;IACH,IAAI,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAEpC;IAED;;;;;;;;;;;;;OAaG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvC;;;;;;;;OAQG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;;;;;OAQG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;IAIzC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export * from './typedEventBus';
 export * from './broadcastTypedEventBus';
 export * from './types';
 export * from './nameGenerator';
+export * from './messengers';
 //# 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,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,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;AAChC,cAAc,cAAc,CAAC"}

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { toSorted as a } from "@ahoo-wang/fetcher";
-class c {
+import { toSorted as r } from "@ahoo-wang/fetcher";
+class y {
   /**
    * Creates a generic event bus
    *
@@ -72,7 +72,7 @@ class i {
     }
   }
 }
-class u extends i {
+class w extends i {
   /**
    * Creates a parallel typed event bus
    *
@@ -90,11 +90,11 @@ class u extends i {
    * @param event - The event to emit
    */
   async emit(e) {
-    const t = [], s = this.eventHandlers.map(async (n) => {
-      await this.handleEvent(n, e), n.once && t.push(n);
+    const t = [], s = this.eventHandlers.map(async (a) => {
+      await this.handleEvent(a, e), a.once && t.push(a);
     });
     await Promise.all(s), t.length > 0 && (this.eventHandlers = this.eventHandlers.filter(
-      (n) => !t.includes(n)
+      (a) => !t.includes(a)
     ));
   }
   /**
@@ -120,7 +120,7 @@ class u extends i {
     return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = [...t, e], !0);
   }
 }
-class d extends i {
+class E extends i {
   /**
    * Creates an in-memory typed event bus
    *
@@ -141,7 +141,7 @@ class d extends i {
     const t = [];
     for (const s of this.eventHandlers)
       await this.handleEvent(s, e), s.once && t.push(s);
-    t.length > 0 && (this.eventHandlers = a(
+    t.length > 0 && (this.eventHandlers = r(
       this.eventHandlers.filter((s) => !t.includes(s))
     ));
   }
@@ -153,7 +153,7 @@ class d extends i {
    */
   off(e) {
     const t = this.eventHandlers;
-    return t.some((s) => s.name === e) ? (this.eventHandlers = a(t, (s) => s.name !== e), !0) : !1;
+    return t.some((s) => s.name === e) ? (this.eventHandlers = r(t, (s) => s.name !== e), !0) : !1;
   }
   /**
    * Adds an event handler if not already present
@@ -165,67 +165,192 @@ class d extends i {
    */
   on(e) {
     const t = this.eventHandlers;
-    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = a([...t, e]), !0);
+    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = r([...t, e]), !0);
   }
 }
-class f {
-  /**
-   * Creates a broadcast typed event bus
-   *
-   * @param delegate - The underlying TypedEventBus for local event handling
-   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`
-   */
-  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 (n) => {
-      try {
-        await this.delegate.emit(n.data);
-      } catch (o) {
-        console.warn(`Broadcast event handler error for ${this.type}:`, o);
-      }
+class h {
+  constructor(e) {
+    this.broadcastChannel = new BroadcastChannel(e);
+  }
+  postMessage(e) {
+    this.broadcastChannel.postMessage(e);
+  }
+  /**
+   * Set the message handler for incoming messages
+   *
+   * @param handler - Function to handle incoming messages, or undefined to remove handler
+   */
+  set onmessage(e) {
+    this.broadcastChannel.onmessage = (t) => {
+      e(t.data);
     };
   }
   /**
-   * Gets a copy of all registered event handlers from the delegate
+   * Close the messenger and clean up resources
+   *
+   * After calling close(), the messenger cannot be used again.
+   */
+  close() {
+    this.broadcastChannel.close();
+  }
+}
+const c = 1e3, u = 6e4;
+class d {
+  constructor(e) {
+    this.storageEventHandler = (t) => {
+      if (!(t.storageArea !== this.storage || !t.key?.startsWith(this.messageKeyPrefix) || !t.newValue))
+        try {
+          const s = JSON.parse(t.newValue);
+          this.messageHandler?.(s.data);
+        } catch (s) {
+          console.warn("Failed to parse storage message:", s);
+        }
+    }, this.channelName = e.channelName, this.storage = e.storage ?? localStorage, this.messageKeyPrefix = `_storage_msg_${this.channelName}`, this.ttl = e.ttl ?? c, this.cleanupInterval = e.cleanupInterval ?? u, this.cleanupTimer = window.setInterval(
+      () => this.cleanup(),
+      this.cleanupInterval
+    ), window.addEventListener("storage", this.storageEventHandler);
+  }
+  generateMessageKey() {
+    return `${this.messageKeyPrefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  /**
+   * Send a message to other tabs/windows via localStorage
+   */
+  postMessage(e) {
+    const t = this.generateMessageKey(), s = {
+      data: e,
+      timestamp: Date.now()
+    };
+    this.storage.setItem(t, JSON.stringify(s)), setTimeout(() => this.storage.removeItem(t), this.ttl);
+  }
+  /**
+   * Set the message handler for incoming messages
+   */
+  set onmessage(e) {
+    this.messageHandler = e;
+  }
+  /**
+   * Clean up expired messages from storage
+   */
+  cleanup() {
+    const e = Date.now(), t = [];
+    for (let s = 0; s < this.storage.length; s++) {
+      const a = this.storage.key(s);
+      if (a?.startsWith(this.messageKeyPrefix))
+        try {
+          const o = this.storage.getItem(a);
+          if (o) {
+            const l = JSON.parse(o);
+            e > l.timestamp + this.ttl && t.push(a);
+          }
+        } catch {
+          t.push(a);
+        }
+    }
+    t.forEach((s) => this.storage.removeItem(s));
+  }
+  /**
+   * Close the messenger and clean up resources
+   */
+  close() {
+    this.cleanupTimer && clearInterval(this.cleanupTimer), window.removeEventListener("storage", this.storageEventHandler);
+  }
+}
+function g() {
+  return typeof BroadcastChannel < "u" && typeof BroadcastChannel.prototype?.postMessage == "function";
+}
+function f() {
+  return typeof StorageEvent < "u" && typeof window < "u" && typeof window.addEventListener == "function" && (typeof localStorage < "u" || typeof sessionStorage < "u");
+}
+function m(n) {
+  if (g())
+    return new h(n);
+  if (f())
+    return new d({ channelName: n });
+}
+class H {
+  /**
+   * Creates a new broadcast event bus with cross-context communication
+   *
+   * @param options - Configuration object containing delegate bus and optional messenger
+   * @throws {Error} If messenger creation fails when no messenger is provided
+   */
+  constructor(e) {
+    this.delegate = e.delegate, this.type = this.delegate.type;
+    const t = e.messenger ?? m(`_broadcast_:${this.type}`);
+    if (!t)
+      throw new Error("Messenger setup failed");
+    this.messenger = t, this.messenger.onmessage = async (s) => {
+      await this.delegate.emit(s);
+    };
+  }
+  /**
+   * Returns a copy of all currently registered event handlers
+   *
+   * This getter delegates to the underlying event bus and returns the current
+   * list of handlers that will process incoming events.
+   *
+   * @returns Array of event handlers registered with this bus
    */
   get handlers() {
     return this.delegate.handlers;
   }
   /**
-   * Emits an event locally and broadcasts it to other tabs/windows
+   * Emits an event locally and broadcasts it to other browser contexts
    *
-   * @param event - The event to emit
+   * This method first processes the event through the local delegate bus,
+   * allowing all registered local handlers to process it. Then, if successful,
+   * the event is broadcasted to other tabs/windows through the messenger.
+   *
+   * Note: If broadcasting fails (e.g., due to messenger errors), the local
+   * emission is still completed and a warning is logged to console.
+   *
+   * @param event - The event data to emit and broadcast
+   * @returns Promise that resolves when local processing is complete
+   * @throws Propagates any errors from local event processing
    */
   async emit(e) {
-    await this.delegate.emit(e), this.broadcastChannel.postMessage(e);
+    await this.delegate.emit(e), this.messenger.postMessage(e);
   }
   /**
-   * Removes an event handler by name from the delegate
+   * Removes an event handler by its registered name
    *
-   * @param name - The name of the handler to remove
-   * @returns true if a handler was removed, false otherwise
+   * This method delegates to the underlying event bus to remove the specified
+   * handler. The handler will no longer receive events emitted to this bus.
+   *
+   * @param name - The unique name of the handler to remove
+   * @returns true if a handler with the given name was found and removed, false otherwise
    */
   off(e) {
     return this.delegate.off(e);
   }
   /**
-   * Adds an event handler to the delegate
+   * Registers a new event handler with this bus
    *
-   * @param handler - The event handler to add
-   * @returns true if the handler was added, false if a handler with the same name already exists
+   * The handler will receive all events emitted to this bus, both locally
+   * generated and received from other browser contexts via broadcasting.
+   *
+   * @param handler - The event handler configuration to register
+   * @returns true if the handler was successfully added, false if a handler with the same name already exists
    */
   on(e) {
     return this.delegate.on(e);
   }
   /**
-   * Cleans up resources by closing the BroadcastChannel
+   * Cleans up resources and stops cross-context communication
+   *
+   * This method closes the messenger connection, preventing further
+   * cross-tab communication. Local event handling continues to work
+   * through the delegate bus. After calling destroy(), the bus should
+   * not be used for broadcasting operations.
+   *
+   * Note: This does not remove event handlers or affect local event processing.
    */
   destroy() {
-    this.broadcastChannel.close();
+    this.messenger.close();
   }
 }
-class l {
+class p {
   constructor() {
     this.namingCounter = 0;
   }
@@ -238,14 +363,19 @@ class l {
     return this.namingCounter++, `${e}_${this.namingCounter}`;
   }
 }
-const m = new l();
+const b = new p();
 export {
   i as AbstractTypedEventBus,
-  f as BroadcastTypedEventBus,
-  l as DefaultNameGenerator,
-  c as EventBus,
-  u as ParallelTypedEventBus,
-  d as SerialTypedEventBus,
-  m as nameGenerator
+  h as BroadcastChannelMessenger,
+  H as BroadcastTypedEventBus,
+  p as DefaultNameGenerator,
+  y as EventBus,
+  w as ParallelTypedEventBus,
+  E as SerialTypedEventBus,
+  d as StorageMessenger,
+  m as createCrossTabMessenger,
+  g as isBroadcastChannelSupported,
+  f as isStorageEventSupported,
+  b 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/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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"}
+{"version":3,"file":"index.es.js","sources":["../src/eventBus.ts","../src/abstractTypedEventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/messengers/broadcastChannelMessenger.ts","../src/messengers/storageMessenger.ts","../src/messengers/crossTabMessenger.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 { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';\n\nexport class BroadcastChannelMessenger implements CrossTabMessenger {\n  private readonly broadcastChannel: BroadcastChannel;\n\n  constructor(channelName: string) {\n    this.broadcastChannel = new BroadcastChannel(channelName);\n  }\n\n  postMessage(message: any): void {\n    this.broadcastChannel.postMessage(message);\n  }\n\n  /**\n   * Set the message handler for incoming messages\n   *\n   * @param handler - Function to handle incoming messages, or undefined to remove handler\n   */\n  set onmessage(handler: CrossTabMessageHandler) {\n    this.broadcastChannel.onmessage = (event: MessageEvent) => {\n      handler(event.data);\n    };\n  }\n\n  /**\n   * Close the messenger and clean up resources\n   *\n   * After calling close(), the messenger cannot be used again.\n   */\n  close(): void {\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\nimport { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';\n\nexport interface StorageMessengerOptions {\n  channelName: string;\n  /** Storage instance to use. Defaults to localStorage */\n  storage?: Storage;\n  ttl?: number;\n  cleanupInterval?: number;\n}\n\nexport interface StorageMessage {\n  data: any;\n  timestamp: number;\n}\n\nconst DEFAULT_TTL = 1000;\nconst DEFAULT_CLEANUP_INTERVAL = 60000;\n\nexport class StorageMessenger implements CrossTabMessenger {\n  private readonly channelName: string;\n  private readonly storage: Storage;\n  private messageHandler?: CrossTabMessageHandler;\n  private readonly messageKeyPrefix: string;\n  private readonly ttl: number;\n  private readonly cleanupInterval: number;\n  private cleanupTimer?: number;\n  private readonly storageEventHandler = (event: StorageEvent) => {\n    if (\n      event.storageArea !== this.storage ||\n      !event.key?.startsWith(this.messageKeyPrefix) ||\n      !event.newValue\n    ) {\n      return;\n    }\n    try {\n      const storageMessage = JSON.parse(event.newValue) as StorageMessage;\n      this.messageHandler?.(storageMessage.data);\n    } catch (error) {\n      console.warn('Failed to parse storage message:', error);\n    }\n  };\n\n  constructor(options: StorageMessengerOptions) {\n    this.channelName = options.channelName;\n    this.storage = options.storage ?? localStorage;\n    this.messageKeyPrefix = `_storage_msg_${this.channelName}`;\n    this.ttl = options.ttl ?? DEFAULT_TTL;\n    this.cleanupInterval = options.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL;\n    this.cleanupTimer = window.setInterval(\n      () => this.cleanup(),\n      this.cleanupInterval,\n    );\n    window.addEventListener('storage', this.storageEventHandler);\n  }\n\n  private generateMessageKey(): string {\n    return `${this.messageKeyPrefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;\n  }\n\n  /**\n   * Send a message to other tabs/windows via localStorage\n   */\n  postMessage(message: any): void {\n    const key = this.generateMessageKey();\n    const storageMessage: StorageMessage = {\n      data: message,\n      timestamp: Date.now(),\n    };\n    this.storage.setItem(key, JSON.stringify(storageMessage));\n    // Delay removal to ensure all listeners have processed the event\n    setTimeout(() => this.storage.removeItem(key), this.ttl);\n  }\n\n  /**\n   * Set the message handler for incoming messages\n   */\n  set onmessage(handler: CrossTabMessageHandler) {\n    this.messageHandler = handler;\n  }\n\n  /**\n   * Clean up expired messages from storage\n   */\n  private cleanup(): void {\n    const now = Date.now();\n    const keysToRemove: string[] = [];\n    for (let i = 0; i < this.storage.length; i++) {\n      const key = this.storage.key(i);\n      if (key?.startsWith(this.messageKeyPrefix)) {\n        try {\n          const value = this.storage.getItem(key);\n          if (value) {\n            const message: StorageMessage = JSON.parse(value);\n            if (now > message.timestamp + this.ttl) {\n              keysToRemove.push(key);\n            }\n          }\n        } catch {\n          // Invalid data, remove it\n          keysToRemove.push(key);\n        }\n      }\n    }\n    keysToRemove.forEach(key => this.storage.removeItem(key));\n  }\n\n  /**\n   * Close the messenger and clean up resources\n   */\n  close(): void {\n    if (this.cleanupTimer) {\n      clearInterval(this.cleanupTimer);\n    }\n    window.removeEventListener('storage', this.storageEventHandler);\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 { BroadcastChannelMessenger } from './broadcastChannelMessenger';\nimport { StorageMessenger } from './storageMessenger';\n\nexport type CrossTabMessageHandler = (message: any) => void;\n\n/**\n * Interface for cross-tab communication messengers\n *\n * Provides a unified API for different cross-tab communication mechanisms\n * like BroadcastChannel, StorageEvent, SharedWorker, etc.\n */\nexport interface CrossTabMessenger {\n  /**\n   * Send a message to other tabs/windows\n   *\n   * @param message - The data to send\n   */\n  postMessage(message: any): void;\n\n  /**\n   * Set the message handler for incoming messages\n   *\n   * @param handler - Function to handle incoming messages\n   */\n  set onmessage(handler: CrossTabMessageHandler);\n\n  /**\n   * Close the messenger and clean up resources\n   */\n  close(): void;\n}\n\nexport function isBroadcastChannelSupported(): boolean {\n  return (\n    typeof BroadcastChannel !== 'undefined' &&\n    typeof BroadcastChannel.prototype?.postMessage === 'function'\n  );\n}\n\nexport function isStorageEventSupported(): boolean {\n  return (\n    typeof StorageEvent !== 'undefined' &&\n    typeof window !== 'undefined' &&\n    typeof window.addEventListener === 'function' &&\n    (typeof localStorage !== 'undefined' ||\n      typeof sessionStorage !== 'undefined')\n  );\n}\n\nexport function createCrossTabMessenger(\n  channelName: string,\n): CrossTabMessenger | undefined {\n  if (isBroadcastChannelSupported()) {\n    return new BroadcastChannelMessenger(channelName);\n  }\n\n  if (isStorageEventSupported()) {\n    return new StorageMessenger({ channelName });\n  }\n\n  return undefined;\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 { createCrossTabMessenger, CrossTabMessenger } from './messengers';\n\n/**\n * Configuration options for BroadcastTypedEventBus\n *\n * @template EVENT - The event type this bus will handle\n */\nexport interface BroadcastTypedEventBusOptions<EVENT> {\n  /**\n   * The underlying event bus that handles local event processing and storage.\n   * This bus manages event handlers and local event emission.\n   */\n  delegate: TypedEventBus<EVENT>;\n\n  /**\n   * Optional messenger for cross-tab/window communication.\n   * If not provided, a default BroadcastChannel-based messenger will be created\n   * using the pattern `_broadcast_:{type}`. Must be a valid CrossTabMessenger\n   * implementation when provided.\n   */\n  messenger?: CrossTabMessenger;\n}\n\n/**\n * Broadcast event bus that enables cross-tab/window communication\n *\n * This class extends a local TypedEventBus with cross-context broadcasting capabilities.\n * When events are emitted, they are first processed locally by the delegate bus, then\n * broadcasted to other browser contexts (tabs, windows, etc.) through the provided messenger.\n *\n * Incoming broadcast messages from other contexts are automatically forwarded to the\n * local delegate bus for processing by registered event handlers.\n *\n * @template EVENT - The event type this bus handles (must be serializable for cross-context transport)\n *\n * @example Basic usage with default messenger\n * ```typescript\n * import { SerialTypedEventBus } from './serialTypedEventBus';\n * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';\n *\n * // Create local event bus\n * const delegate = new SerialTypedEventBus<string>('user-events');\n *\n * // Create broadcast event bus with default messenger\n * const bus = new BroadcastTypedEventBus({\n *   delegate\n *   // messenger will be auto-created as '_broadcast_:user-events'\n * });\n *\n * // Register event handler\n * bus.on({\n *   name: 'user-login',\n *   order: 1,\n *   handle: (username: string) => console.log(`User ${username} logged in`)\n * });\n *\n * // Emit event (will be processed locally and broadcasted to other tabs)\n * await bus.emit('john-doe');\n * ```\n *\n * @example Using custom messenger\n * ```typescript\n * import { SerialTypedEventBus } from './serialTypedEventBus';\n * import { createCrossTabMessenger } from './messengers';\n * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';\n *\n * // Create local event bus\n * const delegate = new SerialTypedEventBus<string>('user-events');\n *\n * // Create custom cross-tab messenger\n * const messenger = createCrossTabMessenger('my-custom-channel');\n *\n * // Create broadcast event bus\n * const bus = new BroadcastTypedEventBus({\n *   delegate,\n *   messenger\n * });\n *\n * // Register event handler and emit events...\n * ```\n *\n * @example Using custom messenger implementation\n * ```typescript\n * class CustomMessenger implements CrossTabMessenger {\n *   // ... implementation\n * }\n *\n * const customMessenger = new CustomMessenger();\n * const bus = new BroadcastTypedEventBus({\n *   delegate: new SerialTypedEventBus('events'),\n *   messenger: customMessenger\n * });\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly delegate: TypedEventBus<EVENT>;\n  private messenger: CrossTabMessenger;\n\n  /**\n   * Creates a new broadcast event bus with cross-context communication\n   *\n   * @param options - Configuration object containing delegate bus and optional messenger\n   * @throws {Error} If messenger creation fails when no messenger is provided\n   */\n  constructor(options: BroadcastTypedEventBusOptions<EVENT>) {\n    this.delegate = options.delegate;\n    this.type = this.delegate.type;\n    const messenger =\n      options.messenger ?? createCrossTabMessenger(`_broadcast_:${this.type}`);\n    if (!messenger) {\n      throw new Error('Messenger setup failed');\n    }\n    this.messenger = messenger;\n    this.messenger.onmessage = async (event: EVENT) => {\n      await this.delegate.emit(event);\n    };\n  }\n\n  /**\n   * Returns a copy of all currently registered event handlers\n   *\n   * This getter delegates to the underlying event bus and returns the current\n   * list of handlers that will process incoming events.\n   *\n   * @returns Array of event handlers registered with this bus\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other browser contexts\n   *\n   * This method first processes the event through the local delegate bus,\n   * allowing all registered local handlers to process it. Then, if successful,\n   * the event is broadcasted to other tabs/windows through the messenger.\n   *\n   * Note: If broadcasting fails (e.g., due to messenger errors), the local\n   * emission is still completed and a warning is logged to console.\n   *\n   * @param event - The event data to emit and broadcast\n   * @returns Promise that resolves when local processing is complete\n   * @throws Propagates any errors from local event processing\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.messenger.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by its registered name\n   *\n   * This method delegates to the underlying event bus to remove the specified\n   * handler. The handler will no longer receive events emitted to this bus.\n   *\n   * @param name - The unique name of the handler to remove\n   * @returns true if a handler with the given name was found and removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Registers a new event handler with this bus\n   *\n   * The handler will receive all events emitted to this bus, both locally\n   * generated and received from other browser contexts via broadcasting.\n   *\n   * @param handler - The event handler configuration to register\n   * @returns true if the handler was successfully 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 and stops cross-context communication\n   *\n   * This method closes the messenger connection, preventing further\n   * cross-tab communication. Local event handling continues to work\n   * through the delegate bus. After calling destroy(), the bus should\n   * not be used for broadcasting operations.\n   *\n   * Note: This does not remove event handlers or affect local event processing.\n   */\n  destroy(): void {\n    this.messenger.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","BroadcastChannelMessenger","channelName","message","DEFAULT_TTL","DEFAULT_CLEANUP_INTERVAL","StorageMessenger","options","storageMessage","error","key","now","keysToRemove","i","value","isBroadcastChannelSupported","isStorageEventSupported","createCrossTabMessenger","BroadcastTypedEventBus","messenger","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 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"})}));
+(function(n,o){typeof exports=="object"&&typeof module<"u"?o(exports,require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","@ahoo-wang/fetcher"],o):(n=typeof globalThis<"u"?globalThis:n||self,o(n.FetcherEventBus={},n.Fetcher))})(this,(function(n,o){"use strict";class m{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 i{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 p extends i{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 v extends i{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=o.toSorted(this.eventHandlers.filter(s=>!t.includes(s))))}off(e){const t=this.eventHandlers;return t.some(s=>s.name===e)?(this.eventHandlers=o.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=o.toSorted([...t,e]),!0)}}class l{constructor(e){this.broadcastChannel=new BroadcastChannel(e)}postMessage(e){this.broadcastChannel.postMessage(e)}set onmessage(e){this.broadcastChannel.onmessage=t=>{e(t.data)}}close(){this.broadcastChannel.close()}}const y=1e3,w=6e4;class h{constructor(e){this.storageEventHandler=t=>{if(!(t.storageArea!==this.storage||!t.key?.startsWith(this.messageKeyPrefix)||!t.newValue))try{const s=JSON.parse(t.newValue);this.messageHandler?.(s.data)}catch(s){console.warn("Failed to parse storage message:",s)}},this.channelName=e.channelName,this.storage=e.storage??localStorage,this.messageKeyPrefix=`_storage_msg_${this.channelName}`,this.ttl=e.ttl??y,this.cleanupInterval=e.cleanupInterval??w,this.cleanupTimer=window.setInterval(()=>this.cleanup(),this.cleanupInterval),window.addEventListener("storage",this.storageEventHandler)}generateMessageKey(){return`${this.messageKeyPrefix}_${Date.now()}_${Math.random().toString(36).slice(2,11)}`}postMessage(e){const t=this.generateMessageKey(),s={data:e,timestamp:Date.now()};this.storage.setItem(t,JSON.stringify(s)),setTimeout(()=>this.storage.removeItem(t),this.ttl)}set onmessage(e){this.messageHandler=e}cleanup(){const e=Date.now(),t=[];for(let s=0;s<this.storage.length;s++){const r=this.storage.key(s);if(r?.startsWith(this.messageKeyPrefix))try{const f=this.storage.getItem(r);if(f){const H=JSON.parse(f);e>H.timestamp+this.ttl&&t.push(r)}}catch{t.push(r)}}t.forEach(s=>this.storage.removeItem(s))}close(){this.cleanupTimer&&clearInterval(this.cleanupTimer),window.removeEventListener("storage",this.storageEventHandler)}}function c(){return typeof BroadcastChannel<"u"&&typeof BroadcastChannel.prototype?.postMessage=="function"}function d(){return typeof StorageEvent<"u"&&typeof window<"u"&&typeof window.addEventListener=="function"&&(typeof localStorage<"u"||typeof sessionStorage<"u")}function u(a){if(c())return new l(a);if(d())return new h({channelName:a})}class E{constructor(e){this.delegate=e.delegate,this.type=this.delegate.type;const t=e.messenger??u(`_broadcast_:${this.type}`);if(!t)throw new Error("Messenger setup failed");this.messenger=t,this.messenger.onmessage=async s=>{await this.delegate.emit(s)}}get handlers(){return this.delegate.handlers}async emit(e){await this.delegate.emit(e),this.messenger.postMessage(e)}off(e){return this.delegate.off(e)}on(e){return this.delegate.on(e)}destroy(){this.messenger.close()}}class g{constructor(){this.namingCounter=0}generate(e){return this.namingCounter++,`${e}_${this.namingCounter}`}}const S=new g;n.AbstractTypedEventBus=i,n.BroadcastChannelMessenger=l,n.BroadcastTypedEventBus=E,n.DefaultNameGenerator=g,n.EventBus=m,n.ParallelTypedEventBus=p,n.SerialTypedEventBus=v,n.StorageMessenger=h,n.createCrossTabMessenger=u,n.isBroadcastChannelSupported=c,n.isStorageEventSupported=d,n.nameGenerator=S,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/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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"}
+{"version":3,"file":"index.umd.js","sources":["../src/eventBus.ts","../src/abstractTypedEventBus.ts","../src/parallelTypedEventBus.ts","../src/serialTypedEventBus.ts","../src/messengers/broadcastChannelMessenger.ts","../src/messengers/storageMessenger.ts","../src/messengers/crossTabMessenger.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 { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';\n\nexport class BroadcastChannelMessenger implements CrossTabMessenger {\n  private readonly broadcastChannel: BroadcastChannel;\n\n  constructor(channelName: string) {\n    this.broadcastChannel = new BroadcastChannel(channelName);\n  }\n\n  postMessage(message: any): void {\n    this.broadcastChannel.postMessage(message);\n  }\n\n  /**\n   * Set the message handler for incoming messages\n   *\n   * @param handler - Function to handle incoming messages, or undefined to remove handler\n   */\n  set onmessage(handler: CrossTabMessageHandler) {\n    this.broadcastChannel.onmessage = (event: MessageEvent) => {\n      handler(event.data);\n    };\n  }\n\n  /**\n   * Close the messenger and clean up resources\n   *\n   * After calling close(), the messenger cannot be used again.\n   */\n  close(): void {\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\nimport { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';\n\nexport interface StorageMessengerOptions {\n  channelName: string;\n  /** Storage instance to use. Defaults to localStorage */\n  storage?: Storage;\n  ttl?: number;\n  cleanupInterval?: number;\n}\n\nexport interface StorageMessage {\n  data: any;\n  timestamp: number;\n}\n\nconst DEFAULT_TTL = 1000;\nconst DEFAULT_CLEANUP_INTERVAL = 60000;\n\nexport class StorageMessenger implements CrossTabMessenger {\n  private readonly channelName: string;\n  private readonly storage: Storage;\n  private messageHandler?: CrossTabMessageHandler;\n  private readonly messageKeyPrefix: string;\n  private readonly ttl: number;\n  private readonly cleanupInterval: number;\n  private cleanupTimer?: number;\n  private readonly storageEventHandler = (event: StorageEvent) => {\n    if (\n      event.storageArea !== this.storage ||\n      !event.key?.startsWith(this.messageKeyPrefix) ||\n      !event.newValue\n    ) {\n      return;\n    }\n    try {\n      const storageMessage = JSON.parse(event.newValue) as StorageMessage;\n      this.messageHandler?.(storageMessage.data);\n    } catch (error) {\n      console.warn('Failed to parse storage message:', error);\n    }\n  };\n\n  constructor(options: StorageMessengerOptions) {\n    this.channelName = options.channelName;\n    this.storage = options.storage ?? localStorage;\n    this.messageKeyPrefix = `_storage_msg_${this.channelName}`;\n    this.ttl = options.ttl ?? DEFAULT_TTL;\n    this.cleanupInterval = options.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL;\n    this.cleanupTimer = window.setInterval(\n      () => this.cleanup(),\n      this.cleanupInterval,\n    );\n    window.addEventListener('storage', this.storageEventHandler);\n  }\n\n  private generateMessageKey(): string {\n    return `${this.messageKeyPrefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;\n  }\n\n  /**\n   * Send a message to other tabs/windows via localStorage\n   */\n  postMessage(message: any): void {\n    const key = this.generateMessageKey();\n    const storageMessage: StorageMessage = {\n      data: message,\n      timestamp: Date.now(),\n    };\n    this.storage.setItem(key, JSON.stringify(storageMessage));\n    // Delay removal to ensure all listeners have processed the event\n    setTimeout(() => this.storage.removeItem(key), this.ttl);\n  }\n\n  /**\n   * Set the message handler for incoming messages\n   */\n  set onmessage(handler: CrossTabMessageHandler) {\n    this.messageHandler = handler;\n  }\n\n  /**\n   * Clean up expired messages from storage\n   */\n  private cleanup(): void {\n    const now = Date.now();\n    const keysToRemove: string[] = [];\n    for (let i = 0; i < this.storage.length; i++) {\n      const key = this.storage.key(i);\n      if (key?.startsWith(this.messageKeyPrefix)) {\n        try {\n          const value = this.storage.getItem(key);\n          if (value) {\n            const message: StorageMessage = JSON.parse(value);\n            if (now > message.timestamp + this.ttl) {\n              keysToRemove.push(key);\n            }\n          }\n        } catch {\n          // Invalid data, remove it\n          keysToRemove.push(key);\n        }\n      }\n    }\n    keysToRemove.forEach(key => this.storage.removeItem(key));\n  }\n\n  /**\n   * Close the messenger and clean up resources\n   */\n  close(): void {\n    if (this.cleanupTimer) {\n      clearInterval(this.cleanupTimer);\n    }\n    window.removeEventListener('storage', this.storageEventHandler);\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 { BroadcastChannelMessenger } from './broadcastChannelMessenger';\nimport { StorageMessenger } from './storageMessenger';\n\nexport type CrossTabMessageHandler = (message: any) => void;\n\n/**\n * Interface for cross-tab communication messengers\n *\n * Provides a unified API for different cross-tab communication mechanisms\n * like BroadcastChannel, StorageEvent, SharedWorker, etc.\n */\nexport interface CrossTabMessenger {\n  /**\n   * Send a message to other tabs/windows\n   *\n   * @param message - The data to send\n   */\n  postMessage(message: any): void;\n\n  /**\n   * Set the message handler for incoming messages\n   *\n   * @param handler - Function to handle incoming messages\n   */\n  set onmessage(handler: CrossTabMessageHandler);\n\n  /**\n   * Close the messenger and clean up resources\n   */\n  close(): void;\n}\n\nexport function isBroadcastChannelSupported(): boolean {\n  return (\n    typeof BroadcastChannel !== 'undefined' &&\n    typeof BroadcastChannel.prototype?.postMessage === 'function'\n  );\n}\n\nexport function isStorageEventSupported(): boolean {\n  return (\n    typeof StorageEvent !== 'undefined' &&\n    typeof window !== 'undefined' &&\n    typeof window.addEventListener === 'function' &&\n    (typeof localStorage !== 'undefined' ||\n      typeof sessionStorage !== 'undefined')\n  );\n}\n\nexport function createCrossTabMessenger(\n  channelName: string,\n): CrossTabMessenger | undefined {\n  if (isBroadcastChannelSupported()) {\n    return new BroadcastChannelMessenger(channelName);\n  }\n\n  if (isStorageEventSupported()) {\n    return new StorageMessenger({ channelName });\n  }\n\n  return undefined;\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 { createCrossTabMessenger, CrossTabMessenger } from './messengers';\n\n/**\n * Configuration options for BroadcastTypedEventBus\n *\n * @template EVENT - The event type this bus will handle\n */\nexport interface BroadcastTypedEventBusOptions<EVENT> {\n  /**\n   * The underlying event bus that handles local event processing and storage.\n   * This bus manages event handlers and local event emission.\n   */\n  delegate: TypedEventBus<EVENT>;\n\n  /**\n   * Optional messenger for cross-tab/window communication.\n   * If not provided, a default BroadcastChannel-based messenger will be created\n   * using the pattern `_broadcast_:{type}`. Must be a valid CrossTabMessenger\n   * implementation when provided.\n   */\n  messenger?: CrossTabMessenger;\n}\n\n/**\n * Broadcast event bus that enables cross-tab/window communication\n *\n * This class extends a local TypedEventBus with cross-context broadcasting capabilities.\n * When events are emitted, they are first processed locally by the delegate bus, then\n * broadcasted to other browser contexts (tabs, windows, etc.) through the provided messenger.\n *\n * Incoming broadcast messages from other contexts are automatically forwarded to the\n * local delegate bus for processing by registered event handlers.\n *\n * @template EVENT - The event type this bus handles (must be serializable for cross-context transport)\n *\n * @example Basic usage with default messenger\n * ```typescript\n * import { SerialTypedEventBus } from './serialTypedEventBus';\n * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';\n *\n * // Create local event bus\n * const delegate = new SerialTypedEventBus<string>('user-events');\n *\n * // Create broadcast event bus with default messenger\n * const bus = new BroadcastTypedEventBus({\n *   delegate\n *   // messenger will be auto-created as '_broadcast_:user-events'\n * });\n *\n * // Register event handler\n * bus.on({\n *   name: 'user-login',\n *   order: 1,\n *   handle: (username: string) => console.log(`User ${username} logged in`)\n * });\n *\n * // Emit event (will be processed locally and broadcasted to other tabs)\n * await bus.emit('john-doe');\n * ```\n *\n * @example Using custom messenger\n * ```typescript\n * import { SerialTypedEventBus } from './serialTypedEventBus';\n * import { createCrossTabMessenger } from './messengers';\n * import { BroadcastTypedEventBus } from './broadcastTypedEventBus';\n *\n * // Create local event bus\n * const delegate = new SerialTypedEventBus<string>('user-events');\n *\n * // Create custom cross-tab messenger\n * const messenger = createCrossTabMessenger('my-custom-channel');\n *\n * // Create broadcast event bus\n * const bus = new BroadcastTypedEventBus({\n *   delegate,\n *   messenger\n * });\n *\n * // Register event handler and emit events...\n * ```\n *\n * @example Using custom messenger implementation\n * ```typescript\n * class CustomMessenger implements CrossTabMessenger {\n *   // ... implementation\n * }\n *\n * const customMessenger = new CustomMessenger();\n * const bus = new BroadcastTypedEventBus({\n *   delegate: new SerialTypedEventBus('events'),\n *   messenger: customMessenger\n * });\n * ```\n */\nexport class BroadcastTypedEventBus<EVENT> implements TypedEventBus<EVENT> {\n  public readonly type: EventType;\n  private readonly delegate: TypedEventBus<EVENT>;\n  private messenger: CrossTabMessenger;\n\n  /**\n   * Creates a new broadcast event bus with cross-context communication\n   *\n   * @param options - Configuration object containing delegate bus and optional messenger\n   * @throws {Error} If messenger creation fails when no messenger is provided\n   */\n  constructor(options: BroadcastTypedEventBusOptions<EVENT>) {\n    this.delegate = options.delegate;\n    this.type = this.delegate.type;\n    const messenger =\n      options.messenger ?? createCrossTabMessenger(`_broadcast_:${this.type}`);\n    if (!messenger) {\n      throw new Error('Messenger setup failed');\n    }\n    this.messenger = messenger;\n    this.messenger.onmessage = async (event: EVENT) => {\n      await this.delegate.emit(event);\n    };\n  }\n\n  /**\n   * Returns a copy of all currently registered event handlers\n   *\n   * This getter delegates to the underlying event bus and returns the current\n   * list of handlers that will process incoming events.\n   *\n   * @returns Array of event handlers registered with this bus\n   */\n  get handlers(): EventHandler<EVENT>[] {\n    return this.delegate.handlers;\n  }\n\n  /**\n   * Emits an event locally and broadcasts it to other browser contexts\n   *\n   * This method first processes the event through the local delegate bus,\n   * allowing all registered local handlers to process it. Then, if successful,\n   * the event is broadcasted to other tabs/windows through the messenger.\n   *\n   * Note: If broadcasting fails (e.g., due to messenger errors), the local\n   * emission is still completed and a warning is logged to console.\n   *\n   * @param event - The event data to emit and broadcast\n   * @returns Promise that resolves when local processing is complete\n   * @throws Propagates any errors from local event processing\n   */\n  async emit(event: EVENT): Promise<void> {\n    await this.delegate.emit(event);\n    this.messenger.postMessage(event);\n  }\n\n  /**\n   * Removes an event handler by its registered name\n   *\n   * This method delegates to the underlying event bus to remove the specified\n   * handler. The handler will no longer receive events emitted to this bus.\n   *\n   * @param name - The unique name of the handler to remove\n   * @returns true if a handler with the given name was found and removed, false otherwise\n   */\n  off(name: string): boolean {\n    return this.delegate.off(name);\n  }\n\n  /**\n   * Registers a new event handler with this bus\n   *\n   * The handler will receive all events emitted to this bus, both locally\n   * generated and received from other browser contexts via broadcasting.\n   *\n   * @param handler - The event handler configuration to register\n   * @returns true if the handler was successfully 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 and stops cross-context communication\n   *\n   * This method closes the messenger connection, preventing further\n   * cross-tab communication. Local event handling continues to work\n   * through the delegate bus. After calling destroy(), the bus should\n   * not be used for broadcasting operations.\n   *\n   * Note: This does not remove event handlers or affect local event processing.\n   */\n  destroy(): void {\n    this.messenger.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","BroadcastChannelMessenger","channelName","message","DEFAULT_TTL","DEFAULT_CLEANUP_INTERVAL","StorageMessenger","options","storageMessage","error","key","now","keysToRemove","i","value","isBroadcastChannelSupported","isStorageEventSupported","createCrossTabMessenger","BroadcastTypedEventBus","messenger","DefaultNameGenerator","prefix","nameGenerator"],"mappings":"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"}

package/dist/messengers/broadcastChannelMessenger.d.ts

@@ -0,0 +1,19 @@
+import { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';
+export declare class BroadcastChannelMessenger implements CrossTabMessenger {
+    private readonly broadcastChannel;
+    constructor(channelName: string);
+    postMessage(message: any): void;
+    /**
+     * Set the message handler for incoming messages
+     *
+     * @param handler - Function to handle incoming messages, or undefined to remove handler
+     */
+    set onmessage(handler: CrossTabMessageHandler);
+    /**
+     * Close the messenger and clean up resources
+     *
+     * After calling close(), the messenger cannot be used again.
+     */
+    close(): void;
+}
+//# sourceMappingURL=broadcastChannelMessenger.d.ts.map

package/dist/messengers/broadcastChannelMessenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcastChannelMessenger.d.ts","sourceRoot":"","sources":["../../src/messengers/broadcastChannelMessenger.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEhF,qBAAa,yBAA0B,YAAW,iBAAiB;IACjE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;gBAExC,WAAW,EAAE,MAAM;IAI/B,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAI/B;;;;OAIG;IACH,IAAI,SAAS,CAAC,OAAO,EAAE,sBAAsB,EAI5C;IAED;;;;OAIG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/messengers/crossTabMessenger.d.ts

@@ -0,0 +1,29 @@
+export type CrossTabMessageHandler = (message: any) => void;
+/**
+ * Interface for cross-tab communication messengers
+ *
+ * Provides a unified API for different cross-tab communication mechanisms
+ * like BroadcastChannel, StorageEvent, SharedWorker, etc.
+ */
+export interface CrossTabMessenger {
+    /**
+     * Send a message to other tabs/windows
+     *
+     * @param message - The data to send
+     */
+    postMessage(message: any): void;
+    /**
+     * Set the message handler for incoming messages
+     *
+     * @param handler - Function to handle incoming messages
+     */
+    set onmessage(handler: CrossTabMessageHandler);
+    /**
+     * Close the messenger and clean up resources
+     */
+    close(): void;
+}
+export declare function isBroadcastChannelSupported(): boolean;
+export declare function isStorageEventSupported(): boolean;
+export declare function createCrossTabMessenger(channelName: string): CrossTabMessenger | undefined;
+//# sourceMappingURL=crossTabMessenger.d.ts.map

package/dist/messengers/crossTabMessenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossTabMessenger.d.ts","sourceRoot":"","sources":["../../src/messengers/crossTabMessenger.ts"],"names":[],"mappings":"AAgBA,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAEhC;;;;OAIG;IACH,IAAI,SAAS,CAAC,OAAO,EAAE,sBAAsB,EAAE;IAE/C;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,2BAA2B,IAAI,OAAO,CAKrD;AAED,wBAAgB,uBAAuB,IAAI,OAAO,CAQjD;AAED,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,GAClB,iBAAiB,GAAG,SAAS,CAU/B"}

package/dist/messengers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './crossTabMessenger';
+export * from './broadcastChannelMessenger';
+export * from './storageMessenger';
+//# sourceMappingURL=index.d.ts.map

package/dist/messengers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messengers/index.ts"],"names":[],"mappings":"AAaA,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC"}

package/dist/messengers/storageMessenger.d.ts

@@ -0,0 +1,41 @@
+import { CrossTabMessenger, CrossTabMessageHandler } from './crossTabMessenger';
+export interface StorageMessengerOptions {
+    channelName: string;
+    /** Storage instance to use. Defaults to localStorage */
+    storage?: Storage;
+    ttl?: number;
+    cleanupInterval?: number;
+}
+export interface StorageMessage {
+    data: any;
+    timestamp: number;
+}
+export declare class StorageMessenger implements CrossTabMessenger {
+    private readonly channelName;
+    private readonly storage;
+    private messageHandler?;
+    private readonly messageKeyPrefix;
+    private readonly ttl;
+    private readonly cleanupInterval;
+    private cleanupTimer?;
+    private readonly storageEventHandler;
+    constructor(options: StorageMessengerOptions);
+    private generateMessageKey;
+    /**
+     * Send a message to other tabs/windows via localStorage
+     */
+    postMessage(message: any): void;
+    /**
+     * Set the message handler for incoming messages
+     */
+    set onmessage(handler: CrossTabMessageHandler);
+    /**
+     * Clean up expired messages from storage
+     */
+    private cleanup;
+    /**
+     * Close the messenger and clean up resources
+     */
+    close(): void;
+}
+//# sourceMappingURL=storageMessenger.d.ts.map

package/dist/messengers/storageMessenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageMessenger.d.ts","sourceRoot":"","sources":["../../src/messengers/storageMessenger.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEhF,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,GAAG,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,cAAc,CAAC,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAclC;gBAEU,OAAO,EAAE,uBAAuB;IAa5C,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAW/B;;OAEG;IACH,IAAI,SAAS,CAAC,OAAO,EAAE,sBAAsB,EAE5C;IAED;;OAEG;IACH,OAAO,CAAC,OAAO;IAuBf;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}

package/package.json

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