@kuindji/reactive 1.0.24 → 1.2.0

package/dist/eventBus.d.ts

@@ -1,6 +1,6 @@
-import { createEvent } from "./event";
-import type { EventDefinitionHelper, EventOptions, ListenerOptions } from "./event";
-import { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey, ProxyType, TriggerReturnType } from "./lib/types";
+import { createEvent } from "./event.js";
+import type { EventDefinitionHelper, EventOptions, ListenerOptions } from "./event.js";
+import { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey, ProxyType, TriggerReturnType } from "./lib/types.js";
 type InterceptorFunction = (name: MapKey, args: any[], tags: string[] | null, returnType: TriggerReturnType | null) => boolean;
 type RelaySource = {
     on: (name: any, fn: (...args: any[]) => any, options?: ListenerOptions) => void;
@@ -59,6 +59,7 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly remove: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
     /** @alias removeListener */
     readonly unsubscribe: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly updateListenerOptions: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, nextOptions?: ListenerOptions) => boolean;
     readonly trigger: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
     /** @alias trigger */
     readonly emit: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
@@ -66,6 +67,7 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly dispatch: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
     readonly get: <K extends KeyOf<GetEventsMap<EventsMap>>>(name: K) => GetEventTypesMap<EventsMap>[K];
     readonly add: (name: MapKey, options?: EventOptions<BaseHandler>) => void;
+    readonly setOptions: (options?: EventBusOptions<BaseEventMap>) => void;
     readonly first: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["first"]>;
     readonly resolveFirst: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveFirst"]>;
     readonly all: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["all"]>;
@@ -89,6 +91,8 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly stopIntercepting: () => void;
     readonly isIntercepting: () => boolean;
     readonly reset: () => void;
+    readonly destroy: () => void;
+    readonly isDestroyed: () => boolean;
     readonly suspendAll: (withQueue?: boolean) => void;
     readonly resumeAll: () => void;
     readonly relay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {

package/dist/eventBus.js

@@ -1,5 +1,7 @@
-import { createEvent } from "./event";
-import { ProxyType, TriggerReturnType, } from "./lib/types";
+import { createEvent } from "./event.js";
+import isPromiseLike from "./lib/isPromiseLike.js";
+import { normalizeEventOptions } from "./lib/normalizeEventOptions.js";
+import { ProxyType, TriggerReturnType, } from "./lib/types.js";
 function proxyReturnTypeToTriggerReturnType(proxyType) {
     switch (proxyType) {
         case ProxyType.TRIGGER:
@@ -71,10 +73,15 @@ function proxyReturnTypeToTriggerReturnType(proxyType) {
 }
 export function createEventBus(eventBusOptions) {
     const events = new Map();
+    let currentEventBusOptions = eventBusOptions;
     let currentTagsFilter = null;
     let interceptor = null;
     const proxyListeners = [];
     const eventSources = [];
+    let destroyed = false;
+    // Registry of active relays so destroy() can unwind the external listeners
+    // they attach (reset()/destroy() otherwise leave them dangling).
+    const relays = [];
     const asterisk = createEvent();
     const errorEvent = createEvent();
     const _getProxyListener = ({ remoteEventName, localEventName, returnType, resolve, localEventNamePrefix, }) => {
@@ -128,6 +135,9 @@ export function createEventBus(eventBusOptions) {
         return listener;
     };
     const add = (name, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (!events.has(name)) {
             events.set(name, createEvent(options));
         }
@@ -135,10 +145,31 @@ export function createEventBus(eventBusOptions) {
     const _getOrAddEvent = (name) => {
         var _a;
         if (!events.has(name)) {
-            events.set(name, createEvent((_a = eventBusOptions === null || eventBusOptions === void 0 ? void 0 : eventBusOptions.eventOptions) === null || _a === void 0 ? void 0 : _a[name]));
+            events.set(name, createEvent((_a = currentEventBusOptions === null || currentEventBusOptions === void 0 ? void 0 : currentEventBusOptions.eventOptions) === null || _a === void 0 ? void 0 : _a[name]));
         }
         return events.get(name);
     };
+    // Parameter is intentionally map-independent (like `add`) so that the
+    // method type is identical across instantiations and a typed bus stays
+    // assignable to BaseEventBus (which the React listener hooks rely on).
+    const setOptions = (options) => {
+        currentEventBusOptions = options;
+        const eventOptions = options === null || options === void 0 ? void 0 : options.eventOptions;
+        if (!eventOptions) {
+            return;
+        }
+        // Apply present entries to already-created events. Removed entries are
+        // intentionally left as-is (the bus can change an event's options but
+        // does not un-set them).
+        Object.keys(eventOptions).forEach((name) => {
+            const e = events.get(name);
+            if (e) {
+                // Normalize so fields removed from a present entry reset to
+                // their defaults (event.setOptions merges, it does not reset).
+                e.setOptions(normalizeEventOptions(eventOptions[name]));
+            }
+        });
+    };
     const intercept = (fn) => {
         interceptor = fn;
     };
@@ -149,9 +180,15 @@ export function createEventBus(eventBusOptions) {
         return interceptor !== null;
     };
     const get = (name) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         return _getOrAddEvent(name);
     };
     const on = (name, handler, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const e = _getOrAddEvent(name);
         eventSources.forEach((evs) => {
             if (evs.eventSource.accepts === false
@@ -168,18 +205,19 @@ export function createEventBus(eventBusOptions) {
                     resolve,
                     localEventNamePrefix: null,
                 });
-                evs.eventSource.on(name, listener.listener, evs.eventSource, options);
+                evs.eventSource.on(name, listener.listener, evs.eventSource);
                 evs.subscribed.push(name);
             }
         });
         return e.addListener(handler, options);
     };
     const once = (name, handler, options) => {
-        options = options || {};
-        options.limit = 1;
-        return on(name, handler, options);
+        return on(name, handler, Object.assign(Object.assign({}, (options || {})), { limit: 1 }));
     };
     const promise = (name, options) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const e = _getOrAddEvent(name);
         return e.promise(options);
     };
@@ -192,24 +230,32 @@ export function createEventBus(eventBusOptions) {
             const isEmpty = !e.hasListener();
             eventSources.forEach((evs) => {
                 const inx = evs.subscribed.indexOf(name);
-                if (inx !== -1) {
+                if (inx !== -1 && isEmpty) {
                     evs.subscribed.splice(inx, 1);
-                    if (isEmpty) {
-                        const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(evs.eventSource.proxyType || ProxyType.TRIGGER);
-                        const listener = _getProxyListener({
-                            localEventName: null,
-                            remoteEventName: name,
-                            returnType,
-                            resolve,
-                            localEventNamePrefix: null,
-                        });
-                        evs.eventSource.un(name, listener.listener, evs.eventSource, tag);
-                    }
+                    const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(evs.eventSource.proxyType || ProxyType.TRIGGER);
+                    const listener = _getProxyListener({
+                        localEventName: null,
+                        remoteEventName: name,
+                        returnType,
+                        resolve,
+                        localEventNamePrefix: null,
+                    });
+                    evs.eventSource.un(name, listener.listener, evs.eventSource, tag);
                 }
             });
         }
     };
+    const updateListenerOptions = (name, handler, context, nextOptions) => {
+        const e = events.get(name);
+        if (!e) {
+            return false;
+        }
+        return e.updateListenerOptions(handler, context !== null && context !== void 0 ? context : null, nextOptions);
+    };
     const _trigger = (name, args, returnType, resolve) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (name === "*") {
             return;
         }
@@ -220,6 +266,20 @@ export function createEventBus(eventBusOptions) {
             }
         }
         const e = _getOrAddEvent(name);
+        const handleError = (error) => {
+            errorEvent.trigger({
+                name,
+                error: error instanceof Error
+                    ? error
+                    : new Error(String(error)),
+                args,
+                type: "event",
+            });
+            if (errorEvent.hasListener()) {
+                return undefined;
+            }
+            throw error;
+        };
         const runner = () => {
             let result;
             switch (returnType) {
@@ -276,21 +336,13 @@ export function createEventBus(eventBusOptions) {
                 result = runner();
             }
             asterisk.trigger(name, args, currentTagsFilter);
+            if (isPromiseLike(result)) {
+                return Promise.resolve(result).catch(handleError);
+            }
             return result;
         }
         catch (error) {
-            errorEvent.trigger({
-                name,
-                error: error instanceof Error
-                    ? error
-                    : new Error(String(error)),
-                args,
-                type: "event",
-            });
-            if (errorEvent.hasListener()) {
-                return undefined;
-            }
-            throw error;
+            return handleError(error);
         }
     };
     const trigger = (name, ...args) => {
@@ -348,27 +400,80 @@ export function createEventBus(eventBusOptions) {
         return _trigger(name, args, TriggerReturnType.RAW, false);
     };
     const withTags = (tags, callback) => {
+        const prevTagsFilter = currentTagsFilter;
         currentTagsFilter = tags;
         try {
             return callback();
         }
         finally {
-            currentTagsFilter = null;
+            currentTagsFilter = prevTagsFilter;
         }
     };
     const reset = () => {
+        // Detach relays BEFORE clearing proxyListeners: unrelay() resolves the
+        // external listener via _getProxyListener, which depends on the original
+        // entry still being present. Clearing proxyListeners first would lose the
+        // callback identity, leaving the external subscription dangling so a
+        // later destroy() could never remove it.
+        relays.slice().forEach((r) => {
+            unrelay({
+                eventSource: r.eventSource,
+                remoteEventName: r.remoteEventName,
+                localEventName: r.localEventName,
+                proxyType: r.proxyType,
+                localEventNamePrefix: r.localEventNamePrefix,
+            });
+        });
         if (eventSources.length > 0) {
-            eventSources.forEach((evs) => {
+            eventSources.slice().forEach((evs) => {
                 removeEventSource(evs.eventSource);
             });
         }
+        // Reset each owned event before dropping it: clearing the map alone
+        // leaves listener AbortSignal handlers attached to their signals, which
+        // retains the orphaned events (and their listeners) until the signal
+        // aborts. reset() detaches those handlers and clears the listeners.
+        events.forEach((event) => {
+            event.reset();
+        });
         events.clear();
         interceptor = null;
         currentTagsFilter = null;
         asterisk.reset();
         proxyListeners.length = 0;
         eventSources.length = 0;
+        relays.length = 0;
+    };
+    // One-call teardown: unwind external attachments (relays + event sources)
+    // that reset() leaves dangling, destroy every owned event, and mark the bus
+    // dead. Post-destroy trigger/addListener throw rather than silently no-op.
+    const destroy = () => {
+        relays.slice().forEach((r) => {
+            unrelay({
+                eventSource: r.eventSource,
+                remoteEventName: r.remoteEventName,
+                localEventName: r.localEventName,
+                proxyType: r.proxyType,
+                localEventNamePrefix: r.localEventNamePrefix,
+            });
+        });
+        eventSources.slice().forEach((evs) => {
+            removeEventSource(evs.eventSource);
+        });
+        events.forEach((event) => {
+            event.destroy();
+        });
+        events.clear();
+        asterisk.destroy();
+        errorEvent.destroy();
+        proxyListeners.length = 0;
+        eventSources.length = 0;
+        relays.length = 0;
+        interceptor = null;
+        currentTagsFilter = null;
+        destroyed = true;
     };
+    const isDestroyed = () => destroyed;
     const suspendAll = (withQueue = false) => {
         events.forEach((event) => {
             event.suspend(withQueue);
@@ -380,6 +485,12 @@ export function createEventBus(eventBusOptions) {
         });
     };
     const relay = ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }) => {
+        // Like the other registration methods, refuse on a dead bus: attaching
+        // the proxy listener here would leave a dangling subscription that
+        // throws "EventBus is destroyed" the next time the source fires.
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(proxyType || ProxyType.TRIGGER);
         const listener = _getProxyListener({
             localEventName: localEventName || null,
@@ -394,6 +505,18 @@ export function createEventBus(eventBusOptions) {
         else {
             eventSource.on(remoteEventName, listener.listener);
         }
+        relays.push({
+            eventSource,
+            remoteEventName,
+            localEventName: localEventName || null,
+            // Store the resolved proxyType (undefined resolves to TRIGGER) so the
+            // registry key matches how the proxy listener is actually resolved.
+            // Otherwise unrelay({ proxyType: TRIGGER }) for a relay({}) (undefined)
+            // detaches the listener but leaves a stale registry entry, which a
+            // later reset()/destroy() then unrelays a second time.
+            proxyType: proxyType || ProxyType.TRIGGER,
+            localEventNamePrefix: localEventNamePrefix || null,
+        });
     };
     const unrelay = ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }) => {
         const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(proxyType || ProxyType.TRIGGER);
@@ -412,14 +535,47 @@ export function createEventBus(eventBusOptions) {
                 eventSource.un(remoteEventName, listener.listener);
             }
         }
+        const inx = relays.findIndex((r) => r.eventSource === eventSource
+            && r.remoteEventName === remoteEventName
+            && r.localEventName === (localEventName || null)
+            // Compare on the resolved proxyType so an undefined relay matches an
+            // explicit TRIGGER unrelay (and vice versa), mirroring how the proxy
+            // listener itself resolves equivalent types.
+            && r.proxyType === (proxyType || ProxyType.TRIGGER)
+            && r.localEventNamePrefix === (localEventNamePrefix || null));
+        if (inx !== -1) {
+            relays.splice(inx, 1);
+        }
     };
     const addEventSource = (eventSource) => {
+        if (destroyed) {
+            throw new Error("EventBus is destroyed");
+        }
         if (eventSources.find((evs) => evs.eventSource.name === eventSource.name)) {
             return;
         }
-        eventSources.push({
+        const eventSourceData = {
             eventSource,
             subscribed: [],
+        };
+        eventSources.push(eventSourceData);
+        events.forEach((event, name) => {
+            if (!event.hasListener()
+                || eventSource.accepts === false
+                || (typeof eventSource.accepts === "function"
+                    && !eventSource.accepts(name))) {
+                return;
+            }
+            const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(eventSource.proxyType || ProxyType.TRIGGER);
+            const listener = _getProxyListener({
+                localEventName: null,
+                remoteEventName: name,
+                returnType,
+                resolve,
+                localEventNamePrefix: null,
+            });
+            eventSource.on(name, listener.listener, eventSource);
+            eventSourceData.subscribed.push(name);
         });
     };
     const removeEventSource = (eventSource) => {
@@ -462,6 +618,7 @@ export function createEventBus(eventBusOptions) {
         remove: un,
         /** @alias removeListener */
         unsubscribe: un,
+        updateListenerOptions,
         trigger,
         /** @alias trigger */
         emit: trigger,
@@ -469,6 +626,7 @@ export function createEventBus(eventBusOptions) {
         dispatch: trigger,
         get,
         add,
+        setOptions,
         first,
         resolveFirst,
         all,
@@ -492,6 +650,8 @@ export function createEventBus(eventBusOptions) {
         stopIntercepting,
         isIntercepting,
         reset,
+        destroy,
+        isDestroyed,
         suspendAll,
         resumeAll,
         relay,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export * from "./action";
-export * from "./actionBus";
-export * from "./actionMap";
-export * from "./event";
-export * from "./eventBus";
-export * from "./lib/types";
-export * from "./store";
+export * from "./action.js";
+export * from "./actionBus.js";
+export * from "./actionMap.js";
+export * from "./event.js";
+export * from "./eventBus.js";
+export * from "./lib/types.js";
+export * from "./store.js";

package/dist/index.js

@@ -1,7 +1,7 @@
-export * from "./action";
-export * from "./actionBus";
-export * from "./actionMap";
-export * from "./event";
-export * from "./eventBus";
-export * from "./lib/types";
-export * from "./store";
+export * from "./action.js";
+export * from "./actionBus.js";
+export * from "./actionMap.js";
+export * from "./event.js";
+export * from "./eventBus.js";
+export * from "./lib/types.js";
+export * from "./store.js";

package/dist/lib/actionMapInternal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Internal-only symbol used to expose an in-place setter for an action map's
+ * forwarded error listeners. Lives under src/lib (which is not re-exported by
+ * the package root in index.ts) so it does not become part of the public API
+ * surface. Imported by createActionMap (to attach the setter) and by
+ * useActionMap (to call it during reconciliation).
+ */
+export declare const ActionMapSetErrorListeners: unique symbol;

package/dist/lib/actionMapInternal.js

@@ -0,0 +1,8 @@
+/**
+ * Internal-only symbol used to expose an in-place setter for an action map's
+ * forwarded error listeners. Lives under src/lib (which is not re-exported by
+ * the package root in index.ts) so it does not become part of the public API
+ * surface. Imported by createActionMap (to attach the setter) and by
+ * useActionMap (to call it during reconciliation).
+ */
+export const ActionMapSetErrorListeners = Symbol("actionMapSetErrorListeners");

package/dist/lib/isPromiseLike.d.ts

@@ -0,0 +1 @@
+export default function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T>;

package/dist/lib/isPromiseLike.js

@@ -0,0 +1,5 @@
+export default function isPromiseLike(value) {
+    return ((typeof value === "object" || typeof value === "function")
+        && value !== null
+        && typeof value.then === "function");
+}

package/dist/lib/normalizeEventOptions.d.ts

@@ -0,0 +1,13 @@
+import type { EventOptions } from "../event.js";
+import type { BaseHandler } from "./types.js";
+/**
+ * Produces a complete {@link EventOptions} object with every field set to the
+ * provided value or its createEvent default. Used by the reconciliation paths
+ * (useEvent and eventBus.setOptions) so that applying options via the
+ * merge-based event.setOptions also resets fields that were removed across
+ * renders, instead of leaving stale values from a previous render.
+ *
+ * Internal-only: this module lives under src/lib (not re-exported by the
+ * package root) and is not part of the public API surface.
+ */
+export declare function normalizeEventOptions(options?: EventOptions<BaseHandler> | null): EventOptions<BaseHandler>;

package/dist/lib/normalizeEventOptions.js

@@ -0,0 +1,21 @@
+/**
+ * Produces a complete {@link EventOptions} object with every field set to the
+ * provided value or its createEvent default. Used by the reconciliation paths
+ * (useEvent and eventBus.setOptions) so that applying options via the
+ * merge-based event.setOptions also resets fields that were removed across
+ * renders, instead of leaving stale values from a previous render.
+ *
+ * Internal-only: this module lives under src/lib (not re-exported by the
+ * package root) and is not part of the public API surface.
+ */
+export function normalizeEventOptions(options) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        async: (_a = options === null || options === void 0 ? void 0 : options.async) !== null && _a !== void 0 ? _a : null,
+        limit: (_b = options === null || options === void 0 ? void 0 : options.limit) !== null && _b !== void 0 ? _b : null,
+        autoTrigger: (_c = options === null || options === void 0 ? void 0 : options.autoTrigger) !== null && _c !== void 0 ? _c : null,
+        filter: (_d = options === null || options === void 0 ? void 0 : options.filter) !== null && _d !== void 0 ? _d : null,
+        filterContext: (_e = options === null || options === void 0 ? void 0 : options.filterContext) !== null && _e !== void 0 ? _e : null,
+        maxListeners: (_f = options === null || options === void 0 ? void 0 : options.maxListeners) !== null && _f !== void 0 ? _f : 0,
+    };
+}

package/dist/lib/types.d.ts

@@ -44,6 +44,6 @@ export type ErrorResponse<Arguments extends any[] = any[]> = {
     error: Error;
     args: Arguments;
     name?: MapKey;
-    type: "action" | "event" | "store-change" | "store-pipe" | "store-control";
+    type: "action" | "action-status" | "event" | "store-change" | "store-pipe" | "store-control";
 };
 export type ErrorListenerSignature<Arguments extends any[] = any[]> = (errorResponse: ErrorResponse<Arguments>) => void;

package/dist/react/ErrorBoundary.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorListenerSignature, ErrorResponse } from "../lib/types";
+import type { ErrorListenerSignature, ErrorResponse } from "../lib/types.js";
 export type ErrorBoundaryProps = {
     children: React.ReactNode;
     listener?: ErrorListenerSignature<any>;

package/dist/react/listenerOptionsEqual.d.ts

@@ -0,0 +1,27 @@
+import type { EventOptions, ListenerOptions } from "../event.js";
+import type { BaseEventMap, EventBusOptions } from "../eventBus.js";
+import type { BaseHandler } from "../lib/types.js";
+/**
+ * Order-insensitive set comparison for listener tags.
+ * `undefined`, `[]` and missing all compare equal. Order and duplicates do
+ * not matter because the core only ever uses tags via membership and
+ * intersection checks.
+ */
+export declare function areTagsEqual(a?: string[], b?: string[]): boolean;
+/**
+ * Domain-specific comparator for {@link ListenerOptions}. Avoids generic deep
+ * equality: primitives compare after default semantics, `context`/`extraData`
+ * compare by reference, and `tags` use order-insensitive set comparison.
+ */
+export declare function areListenerOptionsEqual(a?: ListenerOptions | null, b?: ListenerOptions | null): boolean;
+/**
+ * Domain-specific comparator for {@link EventOptions}. Primitives compare after
+ * default semantics; `filter`/`filterContext` compare by reference.
+ */
+export declare function areEventOptionsEqual(a?: EventOptions<BaseHandler> | null, b?: EventOptions<BaseHandler> | null): boolean;
+/**
+ * Compares the per-event `eventOptions` maps of two {@link EventBusOptions}.
+ * Equal when every event name present in either map has semantically equal
+ * {@link EventOptions} (missing entries compare as default options).
+ */
+export declare function areEventBusOptionsEqual(a?: EventBusOptions<BaseEventMap> | null, b?: EventBusOptions<BaseEventMap> | null): boolean;