@ahoo-wang/fetcher-eventbus 3.13.15 → 3.15.1

package/dist/abstractTypedEventBus.d.ts.map

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

package/dist/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;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"}
+{"version":3,"file":"broadcastTypedEventBus.d.ts","sourceRoot":"","sources":["../src/broadcastTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD;;;;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/eventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eventBus.d.ts","sourceRoot":"","sources":["../src/eventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,aAAa,CAAC,OAAO,CAAC,CAAC;AAE/E;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ,CAAC,MAAM,SAAS,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;IAQjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAPjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqD;IAE3E;;;;OAIG;gBAC0B,oBAAoB,EAAE,oBAAoB;IAEvE;;;;;;;OAOG;IACH,EAAE,CAAC,GAAG,SAAS,SAAS,EACtB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACjC,OAAO;IASV;;;;;;;OAOG;IACH,GAAG,CAAC,GAAG,SAAS,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAI5D;;;;;;;OAOG;IACH,IAAI,CAAC,GAAG,SAAS,SAAS,EACxB,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,GACjB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvB;;OAEG;IACH,OAAO,IAAI,IAAI;CAMhB"}
+{"version":3,"file":"eventBus.d.ts","sourceRoot":"","sources":["../src/eventBus.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,aAAa,CAAC,OAAO,CAAC,CAAC;AAE/E;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ,CAAC,MAAM,SAAS,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;IAQjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAPjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqD;IAE3E;;;;OAIG;gBAC0B,oBAAoB,EAAE,oBAAoB;IAEvE;;;;;;;OAOG;IACH,EAAE,CAAC,GAAG,SAAS,SAAS,EACtB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACjC,OAAO;IASV;;;;;;;OAOG;IACH,GAAG,CAAC,GAAG,SAAS,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAI5D;;;;;;;OAOG;IACH,IAAI,CAAC,GAAG,SAAS,SAAS,EACxB,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,GACjB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvB;;OAEG;IACH,OAAO,IAAI,IAAI;CAMhB"}

package/dist/index.es.js

@@ -1,381 +1,178 @@
-import { toSorted as r } from "@ahoo-wang/fetcher";
-class y {
-  /**
-   * Creates a generic event bus
-   *
-   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types
-   */
-  constructor(e) {
-    this.typeEventBusSupplier = e, this.buses = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Adds an event handler for a specific event type
-   *
-   * @template Key - The event type
-   * @param type - The event type to listen for
-   * @param handler - The event handler to add
-   * @returns true if the handler was added, false if a handler with the same name already exists
-   */
-  on(e, t) {
-    let s = this.buses.get(e);
-    return s || (s = this.typeEventBusSupplier(e), this.buses.set(e, s)), s?.on(t) ?? !1;
-  }
-  /**
-   * Removes an event handler for a specific event type
-   *
-   * @template Key - The event type
-   * @param type - The event type
-   * @param name - The name of the event handler to remove
-   * @returns true if a handler was removed, false otherwise
-   */
-  off(e, t) {
-    return this.buses.get(e)?.off(t) ?? !1;
-  }
-  /**
-   * Emits an event for a specific event type
-   *
-   * @template Key - The event type
-   * @param type - The event type to emit
-   * @param event - The event data
-   * @returns Promise if the underlying bus is async, void otherwise
-   */
-  emit(e, t) {
-    return this.buses.get(e)?.emit(t);
-  }
-  /**
-   * Cleans up all managed event buses
-   */
-  destroy() {
-    for (const e of this.buses.values())
-      e.destroy();
-    this.buses.clear();
-  }
-}
-class i {
-  constructor() {
-    this.eventHandlers = [];
-  }
-  /**
-   * Gets a copy of all registered event handlers, sorted by order
-   */
-  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 w extends i {
-  /**
-   * Creates a parallel typed event bus
-   *
-   * @param type - The event type identifier for this bus
-   */
-  constructor(e) {
-    super(), this.type = e;
-  }
-  /**
-   * Emits an event to all registered handlers in parallel
-   *
-   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.
-   * Errors in individual handlers are logged but do not affect other handlers.
-   *
-   * @param event - The event to emit
-   */
-  async emit(e) {
-    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(
-      (a) => !t.includes(a)
-    ));
-  }
-  /**
-   * Removes an event handler by name
-   *
-   * @param name - The name of the handler to remove
-   * @returns true if a handler was removed, false otherwise
-   */
-  off(e) {
-    const t = this.eventHandlers;
-    return t.some((s) => s.name === e) ? (this.eventHandlers = t.filter((s) => s.name !== e), !0) : !1;
-  }
-  /**
-   * Adds an event handler if not already present
-   *
-   * Handlers are sorted by their order property after addition.
-   *
-   * @param handler - The event handler to add
-   * @returns true if the handler was added, false if a handler with the same name already exists
-   */
-  on(e) {
-    const t = this.eventHandlers;
-    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = [...t, e], !0);
-  }
-}
-class E extends i {
-  /**
-   * Creates an in-memory typed event bus
-   *
-   * @param type - The event type identifier for this bus
-   */
-  constructor(e) {
-    super(), this.type = e;
-  }
-  /**
-   * Emits an event to all registered handlers serially
-   *
-   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.
-   * Errors in individual handlers are logged but do not stop other handlers.
-   *
-   * @param event - The event to emit
-   */
-  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 = r(
-      this.eventHandlers.filter((s) => !t.includes(s))
-    ));
-  }
-  /**
-   * Removes an event handler by name
-   *
-   * @param name - The name of the handler to remove
-   * @returns true if a handler was removed, false otherwise
-   */
-  off(e) {
-    const t = this.eventHandlers;
-    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
-   *
-   * Handlers are sorted by their order property after addition.
-   *
-   * @param handler - The event handler to add
-   * @returns true if the handler was added, false if a handler with the same name already exists
-   */
-  on(e) {
-    const t = this.eventHandlers;
-    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = r([...t, e]), !0);
-  }
-}
-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);
-    };
-  }
-  /**
-   * 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 });
+import { toSorted as e } from "@ahoo-wang/fetcher";
+//#region src/eventBus.ts
+var t = class {
+	constructor(e) {
+		this.typeEventBusSupplier = e, this.buses = /* @__PURE__ */ new Map();
+	}
+	on(e, t) {
+		let n = this.buses.get(e);
+		return n || (n = this.typeEventBusSupplier(e), this.buses.set(e, n)), n?.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 (let e of this.buses.values()) e.destroy();
+		this.buses.clear();
+	}
+}, n = class {
+	constructor() {
+		this.eventHandlers = [];
+	}
+	get handlers() {
+		return [...this.eventHandlers];
+	}
+	destroy() {
+		this.eventHandlers = [];
+	}
+	async handleEvent(e, t) {
+		try {
+			e.handle(t);
+		} catch (t) {
+			console.warn(`Event handler error for ${e.name}:`, t);
+		}
+	}
+}, r = class extends n {
+	constructor(e) {
+		super(), this.type = e;
+	}
+	async emit(e) {
+		let t = [], n = this.eventHandlers.map(async (n) => {
+			await this.handleEvent(n, e), n.once && t.push(n);
+		});
+		await Promise.all(n), t.length > 0 && (this.eventHandlers = this.eventHandlers.filter((e) => !t.includes(e)));
+	}
+	off(e) {
+		let t = this.eventHandlers;
+		return t.some((t) => t.name === e) ? (this.eventHandlers = t.filter((t) => t.name !== e), !0) : !1;
+	}
+	on(e) {
+		let t = this.eventHandlers;
+		return t.some((t) => t.name === e.name) ? !1 : (this.eventHandlers = [...t, e], !0);
+	}
+}, i = class extends n {
+	constructor(e) {
+		super(), this.type = e;
+	}
+	async emit(t) {
+		let n = [];
+		for (let e of this.eventHandlers) await this.handleEvent(e, t), e.once && n.push(e);
+		n.length > 0 && (this.eventHandlers = e(this.eventHandlers.filter((e) => !n.includes(e))));
+	}
+	off(t) {
+		let n = this.eventHandlers;
+		return n.some((e) => e.name === t) ? (this.eventHandlers = e(n, (e) => e.name !== t), !0) : !1;
+	}
+	on(t) {
+		let n = this.eventHandlers;
+		return n.some((e) => e.name === t.name) ? !1 : (this.eventHandlers = e([...n, t]), !0);
+	}
+}, a = class {
+	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();
+	}
+}, o = 1e3, s = 6e4, c = class {
+	constructor(e) {
+		this.storageEventHandler = (e) => {
+			if (!(e.storageArea !== this.storage || !e.key?.startsWith(this.messageKeyPrefix) || !e.newValue)) try {
+				let t = JSON.parse(e.newValue);
+				this.messageHandler?.(t.data);
+			} catch (e) {
+				console.warn("Failed to parse storage message:", e);
+			}
+		}, this.channelName = e.channelName, this.storage = e.storage ?? localStorage, this.messageKeyPrefix = `_storage_msg_${this.channelName}`, this.ttl = e.ttl ?? o, this.cleanupInterval = e.cleanupInterval ?? s, 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) {
+		let t = this.generateMessageKey(), n = {
+			data: e,
+			timestamp: Date.now()
+		};
+		this.storage.setItem(t, JSON.stringify(n)), setTimeout(() => this.storage.removeItem(t), this.ttl);
+	}
+	set onmessage(e) {
+		this.messageHandler = e;
+	}
+	cleanup() {
+		let e = Date.now(), t = [];
+		for (let n = 0; n < this.storage.length; n++) {
+			let r = this.storage.key(n);
+			if (r?.startsWith(this.messageKeyPrefix)) try {
+				let n = this.storage.getItem(r);
+				n && e > JSON.parse(n).timestamp + this.ttl && t.push(r);
+			} catch {
+				t.push(r);
+			}
+		}
+		t.forEach((e) => this.storage.removeItem(e));
+	}
+	close() {
+		this.cleanupTimer && clearInterval(this.cleanupTimer), window.removeEventListener("storage", this.storageEventHandler);
+	}
+};
+//#endregion
+//#region src/messengers/crossTabMessenger.ts
+function l() {
+	return typeof BroadcastChannel < "u" && typeof BroadcastChannel.prototype?.postMessage == "function";
 }
-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 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.
-   *
-   * 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.messenger.postMessage(e);
-  }
-  /**
-   * 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 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);
-  }
-  /**
-   * Registers a new event handler with this bus
-   *
-   * 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 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.messenger.close();
-  }
+function u() {
+	return typeof StorageEvent < "u" && typeof window < "u" && typeof window.addEventListener == "function" && (typeof localStorage < "u" || typeof sessionStorage < "u");
 }
-class p {
-  constructor() {
-    this.namingCounter = 0;
-  }
-  /**
-   * Generates a unique name by appending an incrementing counter to the prefix
-   * @param prefix - The prefix for the generated name
-   * @returns The generated unique name
-   */
-  generate(e) {
-    return this.namingCounter++, `${e}_${this.namingCounter}`;
-  }
+function d(e) {
+	if (l()) return new a(e);
+	if (u()) return new c({ channelName: e });
 }
-const b = new p();
-export {
-  i as AbstractTypedEventBus,
-  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
+//#endregion
+//#region src/broadcastTypedEventBus.ts
+var f = class {
+	constructor(e) {
+		this.delegate = e.delegate, this.type = this.delegate.type;
+		let t = e.messenger ?? d(`_broadcast_:${this.type}`);
+		if (!t) throw Error("Messenger setup failed");
+		this.messenger = t, this.messenger.onmessage = async (e) => {
+			await this.delegate.emit(e);
+		};
+	}
+	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();
+	}
+}, p = class {
+	constructor() {
+		this.namingCounter = 0;
+	}
+	generate(e) {
+		return this.namingCounter++, `${e}_${this.namingCounter}`;
+	}
+}, m = new p();
+//#endregion
+export { n as AbstractTypedEventBus, a as BroadcastChannelMessenger, f as BroadcastTypedEventBus, p as DefaultNameGenerator, t as EventBus, r as ParallelTypedEventBus, i as SerialTypedEventBus, c as StorageMessenger, d as createCrossTabMessenger, l as isBroadcastChannelSupported, u as isStorageEventSupported, m as nameGenerator };
+
+//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../src/eventBus.ts","../src/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   * 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>(type: Key, name: string): 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>\n  implements TypedEventBus<EVENT>\n{\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(\n    handler: EventHandler<EVENT>,\n    event: EVENT,\n  ): 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","/*\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   * 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   * 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":";AAkCO,MAAMA,EAAoD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ/D,YAA6BC,GAA4C;AAA5C,SAAA,uBAAAA,GAP7B,KAAiB,4BAAoD,IAAA;AAAA,EAOK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU1E,GACEC,GACAC,GACS;AACT,QAAIC,IAAM,KAAK,MAAM,IAAIF,CAAI;AAC7B,WAAKE,MACHA,IAAM,KAAK,qBAAqBF,CAAI,GACpC,KAAK,MAAM,IAAIA,GAAME,CAAG,IAEnBA,GAAK,GAAGD,CAAO,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAA2BD,GAAWG,GAAuB;AAC3D,WAAO,KAAK,MAAM,IAAIH,CAAI,GAAG,IAAIG,CAAI,KAAK;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,KACEH,GACAI,GACsB;AACtB,WAAO,KAAK,MAAM,IAAIJ,CAAI,GAAG,KAAKI,CAAK;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AACd,eAAWF,KAAO,KAAK,MAAM,OAAA;AAC3B,MAAAA,EAAI,QAAA;AAEN,SAAK,MAAM,MAAA;AAAA,EACb;AACF;ACpFO,MAAeG,EAEtB;AAAA,EAFO,cAAA;AAGL,SAAU,gBAAuC,CAAA;AAAA,EAAC;AAAA;AAAA;AAAA;AAAA,EAMlD,IAAI,WAAkC;AACpC,WAAO,CAAC,GAAG,KAAK,aAAa;AAAA,EAC/B;AAAA,EAEA,UAAU;AACR,SAAK,gBAAgB,CAAA;AAAA,EACvB;AAAA,EAEA,MAAgB,YACdJ,GACAG,GACe;AACf,QAAI;AACF,MAAAH,EAAQ,OAAOG,CAAK;AAAA,IACtB,SAASE,GAAG;AACV,cAAQ,KAAK,2BAA2BL,EAAQ,IAAI,KAAKK,CAAC;AAAA,IAC5D;AAAA,EACF;AAOF;ACjBO,MAAMC,UAAqCF,EAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7E,YAA4BL,GAAiB;AAC3C,UAAA,GAD0B,KAAA,OAAAA;AAAA,EAE5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,KAAKI,GAA6B;AACtC,UAAMI,IAAsC,CAAA,GACtCC,IAAW,KAAK,cAAc,IAAI,OAAMR,MAAW;AACvD,YAAM,KAAK,YAAYA,GAASG,CAAK,GACjCH,EAAQ,QACVO,EAAa,KAAKP,CAAO;AAAA,IAE7B,CAAC;AACD,UAAM,QAAQ,IAAIQ,CAAQ,GACtBD,EAAa,SAAS,MACxB,KAAK,gBAAgB,KAAK,cAAc;AAAA,MACtC,CAAAE,MAAQ,CAACF,EAAa,SAASE,CAAI;AAAA,IAAA;AAAA,EAGzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAIP,GAAuB;AACzB,UAAMQ,IAAW,KAAK;AACtB,WAAKA,EAAS,KAAK,OAAQD,EAAK,SAASP,CAAI,KAG7C,KAAK,gBAAgBQ,EAAS,OAAO,CAAAD,MAAQA,EAAK,SAASP,CAAI,GACxD,MAHE;AAAA,EAIX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAGF,GAAuC;AACxC,UAAMU,IAAW,KAAK;AACtB,WAAIA,EAAS,KAAK,CAAAD,MAAQA,EAAK,SAAST,EAAQ,IAAI,IAC3C,MAET,KAAK,gBAAgB,CAAC,GAAGU,GAAUV,CAAO,GACnC;AAAA,EACT;AACF;AChEO,MAAMW,UAAmCP,EAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3E,YAA4BL,GAAiB;AAC3C,UAAA,GAD0B,KAAA,OAAAA;AAAA,EAE5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,KAAKI,GAA6B;AACtC,UAAMI,IAAsC,CAAA;AAC5C,eAAWP,KAAW,KAAK;AACzB,YAAM,KAAK,YAAYA,GAASG,CAAK,GACjCH,EAAQ,QACVO,EAAa,KAAKP,CAAO;AAG7B,IAAIO,EAAa,SAAS,MACxB,KAAK,gBAAgBK;AAAA,MACnB,KAAK,cAAc,OAAO,CAAAH,MAAQ,CAACF,EAAa,SAASE,CAAI,CAAC;AAAA,IAAA;AAAA,EAGpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAIP,GAAuB;AACzB,UAAMQ,IAAW,KAAK;AACtB,WAAKA,EAAS,KAAK,OAAQD,EAAK,SAASP,CAAI,KAG7C,KAAK,gBAAgBU,EAASF,GAAU,CAAAD,MAAQA,EAAK,SAASP,CAAI,GAC3D,MAHE;AAAA,EAIX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAGF,GAAuC;AACxC,UAAMU,IAAW,KAAK;AACtB,WAAIA,EAAS,KAAK,CAAAD,MAAQA,EAAK,SAAST,EAAQ,IAAI,IAC3C,MAET,KAAK,gBAAgBY,EAAS,CAAC,GAAGF,GAAUV,CAAO,CAAC,GAC7C;AAAA,EACT;AACF;AClFO,MAAMa,EAAuD;AAAA,EAGlE,YAAYC,GAAqB;AAC/B,SAAK,mBAAmB,IAAI,iBAAiBA,CAAW;AAAA,EAC1D;AAAA,EAEA,YAAYC,GAAoB;AAC9B,SAAK,iBAAiB,YAAYA,CAAO;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAI,UAAUf,GAAiC;AAC7C,SAAK,iBAAiB,YAAY,CAACG,MAAwB;AACzD,MAAAH,EAAQG,EAAM,IAAI;AAAA,IACpB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAc;AACZ,SAAK,iBAAiB,MAAA;AAAA,EACxB;AACF;ACjBA,MAAMa,IAAc,KACdC,IAA2B;AAE1B,MAAMC,EAA8C;AAAA,EAwBzD,YAAYC,GAAkC;AAhB9C,SAAiB,sBAAsB,CAAChB,MAAwB;AAC9D,UACE,EAAAA,EAAM,gBAAgB,KAAK,WAC3B,CAACA,EAAM,KAAK,WAAW,KAAK,gBAAgB,KAC5C,CAACA,EAAM;AAIT,YAAI;AACF,gBAAMiB,IAAiB,KAAK,MAAMjB,EAAM,QAAQ;AAChD,eAAK,iBAAiBiB,EAAe,IAAI;AAAA,QAC3C,SAASC,GAAO;AACd,kBAAQ,KAAK,oCAAoCA,CAAK;AAAA,QACxD;AAAA,IACF,GAGE,KAAK,cAAcF,EAAQ,aAC3B,KAAK,UAAUA,EAAQ,WAAW,cAClC,KAAK,mBAAmB,gBAAgB,KAAK,WAAW,IACxD,KAAK,MAAMA,EAAQ,OAAOH,GAC1B,KAAK,kBAAkBG,EAAQ,mBAAmBF,GAClD,KAAK,eAAe,OAAO;AAAA,MACzB,MAAM,KAAK,QAAA;AAAA,MACX,KAAK;AAAA,IAAA,GAEP,OAAO,iBAAiB,WAAW,KAAK,mBAAmB;AAAA,EAC7D;AAAA,EAEQ,qBAA6B;AACnC,WAAO,GAAG,KAAK,gBAAgB,IAAI,KAAK,KAAK,IAAI,KAAK,OAAA,EAAS,SAAS,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC;AAAA,EAC1F;AAAA;AAAA;AAAA;AAAA,EAKA,YAAYF,GAAoB;AAC9B,UAAMO,IAAM,KAAK,mBAAA,GACXF,IAAiC;AAAA,MACrC,MAAML;AAAA,MACN,WAAW,KAAK,IAAA;AAAA,IAAI;AAEtB,SAAK,QAAQ,QAAQO,GAAK,KAAK,UAAUF,CAAc,CAAC,GAExD,WAAW,MAAM,KAAK,QAAQ,WAAWE,CAAG,GAAG,KAAK,GAAG;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,UAAUtB,GAAiC;AAC7C,SAAK,iBAAiBA;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKQ,UAAgB;AACtB,UAAMuB,IAAM,KAAK,IAAA,GACXC,IAAyB,CAAA;AAC/B,aAASC,IAAI,GAAGA,IAAI,KAAK,QAAQ,QAAQA,KAAK;AAC5C,YAAMH,IAAM,KAAK,QAAQ,IAAIG,CAAC;AAC9B,UAAIH,GAAK,WAAW,KAAK,gBAAgB;AACvC,YAAI;AACF,gBAAMI,IAAQ,KAAK,QAAQ,QAAQJ,CAAG;AACtC,cAAII,GAAO;AACT,kBAAMX,IAA0B,KAAK,MAAMW,CAAK;AAChD,YAAIH,IAAMR,EAAQ,YAAY,KAAK,OACjCS,EAAa,KAAKF,CAAG;AAAA,UAEzB;AAAA,QACF,QAAQ;AAEN,UAAAE,EAAa,KAAKF,CAAG;AAAA,QACvB;AAAA,IAEJ;AACA,IAAAE,EAAa,QAAQ,CAAAF,MAAO,KAAK,QAAQ,WAAWA,CAAG,CAAC;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,IAAI,KAAK,gBACP,cAAc,KAAK,YAAY,GAEjC,OAAO,oBAAoB,WAAW,KAAK,mBAAmB;AAAA,EAChE;AACF;ACnFO,SAASK,IAAuC;AACrD,SACE,OAAO,mBAAqB,OAC5B,OAAO,iBAAiB,WAAW,eAAgB;AAEvD;AAEO,SAASC,IAAmC;AACjD,SACE,OAAO,eAAiB,OACxB,OAAO,SAAW,OAClB,OAAO,OAAO,oBAAqB,eAClC,OAAO,eAAiB,OACvB,OAAO,iBAAmB;AAEhC;AAEO,SAASC,EACdf,GAC+B;AAC/B,MAAIa;AACF,WAAO,IAAId,EAA0BC,CAAW;AAGlD,MAAIc;AACF,WAAO,IAAIV,EAAiB,EAAE,aAAAJ,GAAa;AAI/C;ACmCO,MAAMgB,EAA8D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWzE,YAAYX,GAA+C;AACzD,SAAK,WAAWA,EAAQ,UACxB,KAAK,OAAO,KAAK,SAAS;AAC1B,UAAMY,IACJZ,EAAQ,aAAaU,EAAwB,eAAe,KAAK,IAAI,EAAE;AACzE,QAAI,CAACE;AACH,YAAM,IAAI,MAAM,wBAAwB;AAE1C,SAAK,YAAYA,GACjB,KAAK,UAAU,YAAY,OAAO5B,MAAiB;AACjD,YAAM,KAAK,SAAS,KAAKA,CAAK;AAAA,IAChC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAI,WAAkC;AACpC,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,MAAM,KAAKA,GAA6B;AACtC,UAAM,KAAK,SAAS,KAAKA,CAAK,GAC9B,KAAK,UAAU,YAAYA,CAAK;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,IAAID,GAAuB;AACzB,WAAO,KAAK,SAAS,IAAIA,CAAI;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,GAAGF,GAAuC;AACxC,WAAO,KAAK,SAAS,GAAGA,CAAO;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,UAAgB;AACd,SAAK,UAAU,MAAA;AAAA,EACjB;AACF;ACrLO,MAAMgC,EAA8C;AAAA,EAApD,cAAA;AACL,SAAQ,gBAAwB;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhC,SAASC,GAAwB;AAC/B,gBAAK,iBACE,GAAGA,CAAM,IAAI,KAAK,aAAa;AAAA,EACxC;AACF;AAKO,MAAMC,IAAgB,IAAIF,EAAA;"}
+{"version":3,"file":"index.es.js","names":[],"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 type { EventHandler, EventType } from './types';\nimport type { 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   * 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>(type: Key, name: string): 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 type { TypedEventBus } from './typedEventBus';\nimport type { EventHandler, EventType } from './types';\n\nexport abstract class AbstractTypedEventBus<EVENT>\n  implements TypedEventBus<EVENT>\n{\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(\n    handler: EventHandler<EVENT>,\n    event: EVENT,\n  ): 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","/*\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 type { 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   * 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 type { 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   * 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 type { 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 type { 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 type { TypedEventBus } from './typedEventBus';\nimport type { EventHandler, EventType } from './types';\nimport type { CrossTabMessenger } from './messengers';\nimport { createCrossTabMessenger } 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"],"mappings":"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"}

package/dist/index.umd.js

@@ -1,2 +1,2 @@
-(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
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports,require(`@ahoo-wang/fetcher`)):typeof define==`function`&&define.amd?define([`exports`,`@ahoo-wang/fetcher`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.FetcherEventBus={},e.Fetcher))})(this,function(e,t){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var n=class{constructor(e){this.typeEventBusSupplier=e,this.buses=new Map}on(e,t){let n=this.buses.get(e);return n||(n=this.typeEventBusSupplier(e),this.buses.set(e,n)),n?.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(let e of this.buses.values())e.destroy();this.buses.clear()}},r=class{constructor(){this.eventHandlers=[]}get handlers(){return[...this.eventHandlers]}destroy(){this.eventHandlers=[]}async handleEvent(e,t){try{e.handle(t)}catch(t){console.warn(`Event handler error for ${e.name}:`,t)}}},i=class extends r{constructor(e){super(),this.type=e}async emit(e){let t=[],n=this.eventHandlers.map(async n=>{await this.handleEvent(n,e),n.once&&t.push(n)});await Promise.all(n),t.length>0&&(this.eventHandlers=this.eventHandlers.filter(e=>!t.includes(e)))}off(e){let t=this.eventHandlers;return t.some(t=>t.name===e)?(this.eventHandlers=t.filter(t=>t.name!==e),!0):!1}on(e){let t=this.eventHandlers;return t.some(t=>t.name===e.name)?!1:(this.eventHandlers=[...t,e],!0)}},a=class extends r{constructor(e){super(),this.type=e}async emit(e){let n=[];for(let t of this.eventHandlers)await this.handleEvent(t,e),t.once&&n.push(t);n.length>0&&(this.eventHandlers=(0,t.toSorted)(this.eventHandlers.filter(e=>!n.includes(e))))}off(e){let n=this.eventHandlers;return n.some(t=>t.name===e)?(this.eventHandlers=(0,t.toSorted)(n,t=>t.name!==e),!0):!1}on(e){let n=this.eventHandlers;return n.some(t=>t.name===e.name)?!1:(this.eventHandlers=(0,t.toSorted)([...n,e]),!0)}},o=class{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()}},s=1e3,c=6e4,l=class{constructor(e){this.storageEventHandler=e=>{if(!(e.storageArea!==this.storage||!e.key?.startsWith(this.messageKeyPrefix)||!e.newValue))try{let t=JSON.parse(e.newValue);this.messageHandler?.(t.data)}catch(e){console.warn(`Failed to parse storage message:`,e)}},this.channelName=e.channelName,this.storage=e.storage??localStorage,this.messageKeyPrefix=`_storage_msg_${this.channelName}`,this.ttl=e.ttl??s,this.cleanupInterval=e.cleanupInterval??c,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){let t=this.generateMessageKey(),n={data:e,timestamp:Date.now()};this.storage.setItem(t,JSON.stringify(n)),setTimeout(()=>this.storage.removeItem(t),this.ttl)}set onmessage(e){this.messageHandler=e}cleanup(){let e=Date.now(),t=[];for(let n=0;n<this.storage.length;n++){let r=this.storage.key(n);if(r?.startsWith(this.messageKeyPrefix))try{let n=this.storage.getItem(r);n&&e>JSON.parse(n).timestamp+this.ttl&&t.push(r)}catch{t.push(r)}}t.forEach(e=>this.storage.removeItem(e))}close(){this.cleanupTimer&&clearInterval(this.cleanupTimer),window.removeEventListener(`storage`,this.storageEventHandler)}};function u(){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 f(e){if(u())return new o(e);if(d())return new l({channelName:e})}var p=class{constructor(e){this.delegate=e.delegate,this.type=this.delegate.type;let t=e.messenger??f(`_broadcast_:${this.type}`);if(!t)throw Error(`Messenger setup failed`);this.messenger=t,this.messenger.onmessage=async e=>{await this.delegate.emit(e)}}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()}},m=class{constructor(){this.namingCounter=0}generate(e){return this.namingCounter++,`${e}_${this.namingCounter}`}},h=new m;e.AbstractTypedEventBus=r,e.BroadcastChannelMessenger=o,e.BroadcastTypedEventBus=p,e.DefaultNameGenerator=m,e.EventBus=n,e.ParallelTypedEventBus=i,e.SerialTypedEventBus=a,e.StorageMessenger=l,e.createCrossTabMessenger=f,e.isBroadcastChannelSupported=u,e.isStorageEventSupported=d,e.nameGenerator=h});
+//# 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/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   * 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>(type: Key, name: string): 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>\n  implements TypedEventBus<EVENT>\n{\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(\n    handler: EventHandler<EVENT>,\n    event: EVENT,\n  ): 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","/*\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   * 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   * 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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"}
+{"version":3,"file":"index.umd.js","names":[],"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 type { EventHandler, EventType } from './types';\nimport type { 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   * 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>(type: Key, name: string): 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 type { TypedEventBus } from './typedEventBus';\nimport type { EventHandler, EventType } from './types';\n\nexport abstract class AbstractTypedEventBus<EVENT>\n  implements TypedEventBus<EVENT>\n{\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(\n    handler: EventHandler<EVENT>,\n    event: EVENT,\n  ): 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","/*\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 type { 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   * 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 type { 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   * 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 type { 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 type { 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 type { TypedEventBus } from './typedEventBus';\nimport type { EventHandler, EventType } from './types';\nimport type { CrossTabMessenger } from './messengers';\nimport { createCrossTabMessenger } 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"],"mappings":"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"}

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

@@ -1 +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"}
+{"version":3,"file":"broadcastChannelMessenger.d.ts","sourceRoot":"","sources":["../../src/messengers/broadcastChannelMessenger.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAErF,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/storageMessenger.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"storageMessenger.d.ts","sourceRoot":"","sources":["../../src/messengers/storageMessenger.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAErF,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/dist/parallelTypedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallelTypedEventBus.d.ts","sourceRoot":"","sources":["../src/parallelTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAqB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAMhD,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}
+{"version":3,"file":"parallelTypedEventBus.d.ts","sourceRoot":"","sources":["../src/parallelTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAqB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAMhD,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}

package/dist/serialTypedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialTypedEventBus.d.ts","sourceRoot":"","sources":["../src/serialTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAM9C,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}
+{"version":3,"file":"serialTypedEventBus.d.ts","sourceRoot":"","sources":["../src/serialTypedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB,CAAC,KAAK,CAAE,SAAQ,qBAAqB,CAAC,KAAK,CAAC;aAM9C,IAAI,EAAE,SAAS;IAL3C;;;;OAIG;gBACyB,IAAI,EAAE,SAAS;IAI3C;;;;;;;OAOG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAevC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS1B;;;;;;;OAOG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO;CAQ1C"}

package/dist/typedEventBus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typedEventBus.d.ts","sourceRoot":"","sources":["../src/typedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,KAAK;IAClC;;OAEG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,QAAQ,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IAEhC;;;;;OAKG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC;IAE1C;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3B;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB"}
+{"version":3,"file":"typedEventBus.d.ts","sourceRoot":"","sources":["../src/typedEventBus.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,KAAK;IAClC;;OAEG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,QAAQ,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;IAEhC;;;;;OAKG;IACH,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC;IAE1C;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3B;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { NamedCapable, OrderedCapable } from '@ahoo-wang/fetcher';
+import { OrderedCapable, NamedCapable } from '@ahoo-wang/fetcher';
 export type EventType = string;
 export interface EventHandler<EVENT> extends NamedCapable, OrderedCapable {
     once?: boolean;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,KAAK,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEvE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B,MAAM,WAAW,YAAY,CAAC,KAAK,CAAE,SAAQ,YAAY,EAAE,cAAc;IACvE,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B,MAAM,WAAW,YAAY,CAAC,KAAK,CAAE,SAAQ,YAAY,EAAE,cAAc;IACvE,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahoo-wang/fetcher-eventbus",
-  "version": "3.13.15",
+  "version": "3.15.1",
   "description": "A TypeScript event bus library with serial, parallel, and broadcast implementations",
   "keywords": [
     "eventbus",
@@ -41,17 +41,17 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",
-    "@vitest/coverage-v8": "^4.0.0",
-    "@vitest/ui": "^4.0.0",
+    "@vitest/coverage-v8": "^4.1.4",
+    "@vitest/ui": "^4.1.4",
     "eslint": "^9.39.4",
     "globals": "^17.4.0",
     "prettier": "^3.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.58.0",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
     "unplugin-dts": "1.0.0-beta.6",
-    "vite": "^7.3.1",
-    "vite-bundle-analyzer": "^1.3.6",
-    "vitest": "^4.1.2"
+    "vite": "^8.0.8",
+    "vite-bundle-analyzer": "^1.3.7",
+    "vitest": "^4.1.4"
   },
   "scripts": {
     "build": "vite build",