@kuindji/reactive 1.0.24 → 1.1.0

package/dist/event.js

@@ -1,7 +1,8 @@
-import asyncCall from "./lib/asyncCall";
-import listenerSorter from "./lib/listenerSorter";
-import tagsIntersect from "./lib/tagsIntersect";
-import { TriggerReturnType } from "./lib/types";
+import asyncCall from "./lib/asyncCall.js";
+import isPromiseLike from "./lib/isPromiseLike.js";
+import listenerSorter from "./lib/listenerSorter.js";
+import tagsIntersect from "./lib/tagsIntersect.js";
+import { TriggerReturnType } from "./lib/types.js";
 export function createEvent(eventOptions = {}) {
     let listeners = [];
     const errorListeners = [];
@@ -14,10 +15,12 @@ export function createEvent(eventOptions = {}) {
     let currentTagsFilter = null;
     const options = Object.assign({ async: null, limit: null, autoTrigger: null, filter: null, filterContext: null, maxListeners: 0 }, eventOptions);
     const addListener = (handler, listenerOptions = {}) => {
+        var _a;
         if (!handler) {
             return;
         }
-        if (listeners.find((l) => l.handler === handler && l.context === listenerOptions.context)) {
+        const listenerContext = (_a = listenerOptions.context) !== null && _a !== void 0 ? _a : null;
+        if (listeners.find((l) => l.handler === handler && l.context === listenerContext)) {
             return;
         }
         if (options.maxListeners && listeners.length >= options.maxListeners) {
@@ -54,8 +57,12 @@ export function createEvent(eventOptions = {}) {
                 }
                 return false;
             };
-            _trigger(lastTrigger);
-            options.filter = prevFilter;
+            try {
+                _trigger(lastTrigger);
+            }
+            finally {
+                options.filter = prevFilter;
+            }
         }
     };
     const removeListener = (handler, context, tag) => {
@@ -80,6 +87,49 @@ export function createEvent(eventOptions = {}) {
         listeners.splice(inx, 1);
         return true;
     };
+    const updateListenerOptions = (handler, context = null, nextOptions = {}) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const listenerContext = context !== null && context !== void 0 ? context : null;
+        const listener = listeners.find((l) => l.handler === handler && l.context === listenerContext);
+        if (!listener) {
+            return false;
+        }
+        const prevAlwaysFirst = listener.alwaysFirst;
+        const prevAlwaysLast = listener.alwaysLast;
+        // Soft fields, applying the same defaults as addListener so that a
+        // removed field resets to its default rather than lingering.
+        listener.limit = (_a = nextOptions.limit) !== null && _a !== void 0 ? _a : 0;
+        listener.start = (_b = nextOptions.start) !== null && _b !== void 0 ? _b : 1;
+        listener.tags = (_c = nextOptions.tags) !== null && _c !== void 0 ? _c : [];
+        listener.extraData = (_d = nextOptions.extraData) !== null && _d !== void 0 ? _d : null;
+        listener.alwaysFirst = (_e = nextOptions.alwaysFirst) !== null && _e !== void 0 ? _e : false;
+        listener.alwaysLast = (_f = nextOptions.alwaysLast) !== null && _f !== void 0 ? _f : false;
+        let nextAsync = (_g = nextOptions.async) !== null && _g !== void 0 ? _g : null;
+        if (nextAsync === true) {
+            nextAsync = 1;
+        }
+        listener.async = nextAsync;
+        // Re-sort if ordering hints changed. Unlike addListener we do NOT
+        // rewrite each listener's index here: the existing indices hold the
+        // original insertion order, and preserving them lets sorting restore
+        // that order when alwaysFirst/alwaysLast is cleared.
+        if (listener.alwaysFirst !== prevAlwaysFirst
+            || listener.alwaysLast !== prevAlwaysLast) {
+            if (listener.alwaysFirst === true || listener.alwaysLast === true) {
+                sortListeners = true;
+            }
+            if (sortListeners) {
+                listeners.sort((l1, l2) => listenerSorter(l1, l2));
+            }
+        }
+        // The core auto-remove check is a strict `called === limit`, so a
+        // listener whose `called` already exceeds the new limit would never
+        // auto-remove. Remove it immediately in that case.
+        if (listener.limit !== 0 && listener.called >= listener.limit) {
+            removeListener(listener.handler, listener.context);
+        }
+        return true;
+    };
     const hasListener = (handler, context, tag) => {
         if (handler) {
             return (listeners.findIndex((l) => {
@@ -137,7 +187,7 @@ export function createEvent(eventOptions = {}) {
         queued = false;
         if (queue.length > 0) {
             for (let i = 0, l = queue.length; i < l; i++) {
-                _trigger(queue[i][0], queue[i][1]);
+                _trigger(queue[i][0], queue[i][1], queue[i][2]);
             }
             queue = [];
         }
@@ -156,7 +206,6 @@ export function createEvent(eventOptions = {}) {
         triggered = 0;
         lastTrigger = null;
         sortListeners = false;
-        cachedPromise = null;
     };
     const _listenerCall = (listener, args, resolve = null) => {
         let isAsync = listener.async;
@@ -173,26 +222,29 @@ export function createEvent(eventOptions = {}) {
             const result = isAsync !== false
                 ? asyncCall(listener.handler, listener.context, args, isAsync)
                 : listener.handler.bind(listener.context)(...args);
-            if (resolve !== null) {
-                if (result instanceof Promise) {
-                    void result.then(resolve).catch((error) => {
-                        for (const errorListener of errorListeners) {
-                            errorListener.handler({
-                                error: error instanceof Error
-                                    ? error
-                                    : new Error(error),
-                                args: args,
-                                type: "event",
-                            });
-                        }
-                        if (errorListeners.length === 0) {
-                            throw error;
-                        }
-                    });
-                }
-                else {
-                    resolve(result);
+            if (isPromiseLike(result)) {
+                const handledResult = Promise.resolve(result).catch((error) => {
+                    for (const errorListener of errorListeners) {
+                        errorListener.handler({
+                            error: error instanceof Error
+                                ? error
+                                : new Error(error),
+                            args: args,
+                            type: "event",
+                        });
+                    }
+                    if (errorListeners.length === 0) {
+                        throw error;
+                    }
+                    return undefined;
+                });
+                if (resolve !== null) {
+                    void handledResult.then(resolve);
                 }
+                return handledResult;
+            }
+            if (resolve !== null) {
+                resolve(result);
             }
             return result;
         }
@@ -236,8 +288,13 @@ export function createEvent(eventOptions = {}) {
         return _listenerCall(listener, args);
     };
     const _trigger = (args, returnType = null, tags) => {
+        var _a, _b;
         if (queued) {
-            queue.push([args, returnType]);
+            queue.push([
+                args,
+                returnType,
+                (_b = (_a = (tags || currentTagsFilter)) === null || _a === void 0 ? void 0 : _a.slice()) !== null && _b !== void 0 ? _b : null,
+            ]);
             return;
         }
         if (suspended) {
@@ -303,9 +360,7 @@ export function createEvent(eventOptions = {}) {
             if (isConsequent && results.length > 0) {
                 const prev = results[results.length - 1];
                 if (hasPromises) {
-                    const prevPromise = prev instanceof Promise
-                        ? prev
-                        : Promise.resolve(prev);
+                    const prevPromise = Promise.resolve(prev);
                     listenerResult = prevPromise.then(((listener, args, returnType) => (value) => {
                         return _listenerCallWPrev(listener, args, value, returnType);
                     })(listener, args, returnType));
@@ -342,7 +397,7 @@ export function createEvent(eventOptions = {}) {
                     }
                     case TriggerReturnType.FIRST_NON_EMPTY: {
                         if (!hasPromises
-                            && !(listenerResult instanceof Promise)
+                            && !isPromiseLike(listenerResult)
                             && listenerResult !== null
                             && listenerResult !== undefined) {
                             return listenerResult;
@@ -351,7 +406,7 @@ export function createEvent(eventOptions = {}) {
                     }
                 }
             }
-            if (!hasPromises && listenerResult instanceof Promise) {
+            if (!hasPromises && isPromiseLike(listenerResult)) {
                 hasPromises = true;
             }
             results.push(listenerResult);
@@ -405,33 +460,31 @@ export function createEvent(eventOptions = {}) {
         _trigger(args);
     };
     const withTags = (tags, callback) => {
+        const prevTagsFilter = currentTagsFilter;
         currentTagsFilter = tags;
         try {
             return callback();
         }
         finally {
-            currentTagsFilter = null;
+            currentTagsFilter = prevTagsFilter;
         }
     };
-    let cachedPromise = null;
     const promise = (options) => {
-        return cachedPromise = cachedPromise
-            || new Promise((resolve) => {
-                options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
-                const l = ((...args) => {
-                    resolve(args);
-                    cachedPromise = null;
-                });
-                addListener(l, options);
+        return new Promise((resolve) => {
+            options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
+            const l = ((...args) => {
+                resolve(args);
             });
+            addListener(l, options);
+        });
     };
     const first = (...args) => {
         return _trigger(args, TriggerReturnType.FIRST);
     };
     const resolveFirst = (...args) => {
         const response = _trigger(args, TriggerReturnType.FIRST);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -440,8 +493,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveAll = (...args) => {
         const response = _trigger(args, TriggerReturnType.ALL);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -450,8 +503,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveLast = (...args) => {
         const response = _trigger(args, TriggerReturnType.LAST);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -460,8 +513,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveMerge = (...args) => {
         const response = _trigger(args, TriggerReturnType.MERGE);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -470,8 +523,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveConcat = (...args) => {
         const response = _trigger(args, TriggerReturnType.CONCAT);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -480,8 +533,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveFirstNonEmpty = (...args) => {
         const response = _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -496,8 +549,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolvePipe = (...args) => {
         const response = _trigger(args, TriggerReturnType.PIPE);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -513,6 +566,7 @@ export function createEvent(eventOptions = {}) {
         /** @alias addListener */
         subscribe: addListener,
         removeListener,
+        updateListenerOptions,
         /** @alias removeListener */
         un: removeListener,
         /** @alias removeListener */

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"]>;

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,6 +73,7 @@ function proxyReturnTypeToTriggerReturnType(proxyType) {
 }
 export function createEventBus(eventBusOptions) {
     const events = new Map();
+    let currentEventBusOptions = eventBusOptions;
     let currentTagsFilter = null;
     let interceptor = null;
     const proxyListeners = [];
@@ -135,10 +138,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;
     };
@@ -168,7 +192,7 @@ 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);
             }
         });
@@ -192,23 +216,28 @@ 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 (name === "*") {
             return;
@@ -220,6 +249,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 +319,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,17 +383,18 @@ 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 = () => {
         if (eventSources.length > 0) {
-            eventSources.forEach((evs) => {
+            eventSources.slice().forEach((evs) => {
                 removeEventSource(evs.eventSource);
             });
         }
@@ -417,9 +453,28 @@ export function createEventBus(eventBusOptions) {
         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 +517,7 @@ export function createEventBus(eventBusOptions) {
         remove: un,
         /** @alias removeListener */
         unsubscribe: un,
+        updateListenerOptions,
         trigger,
         /** @alias trigger */
         emit: trigger,
@@ -469,6 +525,7 @@ export function createEventBus(eventBusOptions) {
         dispatch: trigger,
         get,
         add,
+        setOptions,
         first,
         resolveFirst,
         all,

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/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>;