@kuindji/reactive 1.0.21 → 1.0.23

package/README.md

@@ -117,29 +117,28 @@ type ApplicationData = {
         type: string;
         message: string;
     }[];
-}
-const event = createEvent(<() => Partial<ApplicationData>>);
+};
+const event = createEvent<() => Partial<ApplicationData>>();
 event.addListener(() => {
     return {
         user: {
             username: "john",
             role: "admin",
-            loggedIn: true
-        }
-    }
+            loggedIn: true,
+        },
+    };
 });
 event.addListener(() => {
     return {
         notifications: [
             {
                 type: "chat",
-                message: "You've got a new message!"
-            }
-        ]
-    }
+                message: "You've got a new message!",
+            },
+        ],
+    };
 });
 
-
 const applicationData = event.merge();
 ```
 

package/dist/action.d.ts

@@ -1,5 +1,5 @@
 import type { ApiType, BaseHandler, ErrorListenerSignature, ErrorResponse } from "./lib/types";
-export type ActionResponse<Response extends any = any, Args extends any[] = any[]> = {
+export type ActionResponse<Response = any, Args extends unknown[] = unknown[]> = {
     response: Response;
     error: null;
     args: Args;

package/dist/actionBus.js

@@ -7,9 +7,7 @@ function createActionBus(initialActions = {}, errorListener) {
     const actions = new Map();
     const errorEvent = (0, event_1.createEvent)();
     if (errorListener) {
-        errorEvent.addListener(({ error, args }) => {
-            errorEvent.emit({ error, args, type: "action" });
-        });
+        errorEvent.addListener(errorListener);
     }
     const add = (name, action) => {
         if (!actions.has(name)) {
@@ -28,6 +26,9 @@ function createActionBus(initialActions = {}, errorListener) {
     };
     const invoke = (name, ...args) => {
         const action = get(name);
+        if (!action) {
+            throw new Error(`Action ${name} not found`);
+        }
         return action.invoke(...args);
     };
     const on = (name, handler, options) => {

package/dist/event.d.ts

@@ -118,7 +118,7 @@ export declare function createEvent<ListenerSignature extends BaseHandler>(event
     readonly reset: () => void;
     readonly isSuspended: () => boolean;
     readonly isQueued: () => boolean;
-    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    readonly withTags: <R>(tags: string[], callback: () => R) => R;
     readonly promise: (options?: ListenerOptions) => Promise<Parameters<ListenerSignature>>;
     readonly first: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
     readonly resolveFirst: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;

package/dist/event.js

@@ -7,7 +7,7 @@ const tagsIntersect_1 = require("./lib/tagsIntersect");
 const types_1 = require("./lib/types");
 function createEvent(eventOptions = {}) {
     let listeners = [];
-    let errorListeners = [];
+    const errorListeners = [];
     let queue = [];
     let suspended = false;
     let queued = false;
@@ -116,7 +116,7 @@ function createEvent(eventOptions = {}) {
         }
     };
     const addErrorListener = (handler, context) => {
-        if (listeners.find((l) => l.handler === handler && l.context === context)) {
+        if (errorListeners.find((l) => l.handler === handler && l.context === context)) {
             return;
         }
         errorListeners.push({ handler, context });
@@ -152,10 +152,14 @@ function createEvent(eventOptions = {}) {
     const isQueued = () => queued;
     const reset = () => {
         listeners.length = 0;
+        errorListeners.length = 0;
         queue.length = 0;
         suspended = false;
         queued = false;
         triggered = 0;
+        lastTrigger = null;
+        sortListeners = false;
+        cachedPromise = null;
     };
     const _listenerCall = (listener, args, resolve = null) => {
         let isAsync = listener.async;
@@ -174,7 +178,20 @@ function createEvent(eventOptions = {}) {
                 : listener.handler.bind(listener.context)(...args);
             if (resolve !== null) {
                 if (result instanceof Promise) {
-                    result.then(resolve);
+                    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);
@@ -287,7 +304,7 @@ function createEvent(eventOptions = {}) {
                 continue;
             }
             if (isConsequent && results.length > 0) {
-                let prev = results[results.length - 1];
+                const prev = results[results.length - 1];
                 if (hasPromises) {
                     const prevPromise = prev instanceof Promise
                         ? prev
@@ -360,13 +377,13 @@ function createEvent(eventOptions = {}) {
             }
             case types_1.TriggerReturnType.CONCAT: {
                 return hasPromises
-                    ? Promise.all(results).then((results) => results.flat())
+                    ? Promise.all(results).then((r) => r.flat())
                     : results.flat();
             }
             case types_1.TriggerReturnType.MERGE: {
                 return hasPromises
-                    ? Promise.all(results).then((results) => Object.assign.apply(null, [{}, ...results]))
-                    : Object.assign.apply(null, [{}, ...results]);
+                    ? Promise.all(results).then((r) => Object.assign({}, ...r))
+                    : Object.assign({}, ...results);
             }
             case types_1.TriggerReturnType.LAST: {
                 return results.pop();
@@ -378,7 +395,9 @@ function createEvent(eventOptions = {}) {
                 return;
             }
             case types_1.TriggerReturnType.FIRST_NON_EMPTY: {
-                return Promise.all(results).then((results) => results.find((r) => r !== undefined && r !== null));
+                return hasPromises
+                    ? Promise.all(results).then((r) => r.find((item) => item !== undefined && item !== null))
+                    : results.find((item) => item !== undefined && item !== null);
             }
             case types_1.TriggerReturnType.PIPE: {
                 return results[results.length - 1];
@@ -390,16 +409,24 @@ function createEvent(eventOptions = {}) {
     };
     const withTags = (tags, callback) => {
         currentTagsFilter = tags;
-        const result = callback();
-        currentTagsFilter = null;
-        return result;
+        try {
+            return callback();
+        }
+        finally {
+            currentTagsFilter = null;
+        }
     };
+    let cachedPromise = null;
     const promise = (options) => {
-        return new Promise((resolve) => {
-            options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
-            const l = ((...args) => resolve(args));
-            addListener(l, 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);
+            });
     };
     const first = (...args) => {
         return _trigger(args, types_1.TriggerReturnType.FIRST);

package/dist/eventBus.d.ts

@@ -66,25 +66,25 @@ 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 first: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveFirst: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly all: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]>[]>;
-    readonly resolveAll: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>>[]>>;
-    readonly resolve: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>>[]>>;
-    readonly last: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveLast: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly merge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveMerge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly concat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => (ReturnType<EventsMap[K]> extends infer T ? T extends ReturnType<EventsMap[K]> ? T extends (infer U)[] ? U : T : never : never)[]>;
-    readonly resolveConcat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<(Awaited<ReturnType<EventsMap[K]>> extends infer T ? T extends Awaited<ReturnType<EventsMap[K]>> ? T extends (infer U)[] ? U : T : never : never)[]>>;
-    readonly firstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveFirstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly untilTrue: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
-    readonly untilFalse: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
-    readonly pipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolvePipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly raw: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => (ReturnType<EventsMap[K]> extends infer T ? T extends ReturnType<EventsMap[K]> ? T extends (infer U)[] ? U : T : never : never)[]>;
-    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    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"]>;
+    readonly resolveAll: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveAll"]>;
+    readonly resolve: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveAll"]>;
+    readonly last: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["last"]>;
+    readonly resolveLast: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveLast"]>;
+    readonly merge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["merge"]>;
+    readonly resolveMerge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveMerge"]>;
+    readonly concat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["concat"]>;
+    readonly resolveConcat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveConcat"]>;
+    readonly firstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["firstNonEmpty"]>;
+    readonly resolveFirstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveFirstNonEmpty"]>;
+    readonly untilTrue: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["untilTrue"]>;
+    readonly untilFalse: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["untilFalse"]>;
+    readonly pipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["pipe"]>;
+    readonly resolvePipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolvePipe"]>;
+    readonly raw: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["raw"]>;
+    readonly withTags: <R>(tags: string[], callback: () => R) => R;
     readonly intercept: (fn: InterceptorFunction) => void;
     readonly stopIntercepting: () => void;
     readonly isIntercepting: () => boolean;
@@ -94,14 +94,14 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly relay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
         eventSource: RelaySource;
         remoteEventName: MapKey;
-        localEventName?: any;
+        localEventName?: MapKey | null;
         proxyType?: ProxyType;
         localEventNamePrefix?: string | null;
     }) => void;
     readonly unrelay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
         eventSource: RelaySource;
         remoteEventName: MapKey;
-        localEventName?: any;
+        localEventName?: MapKey | null;
         proxyType?: ProxyType;
         localEventNamePrefix?: string | null;
     }) => void;

package/dist/eventBus.js

@@ -87,35 +87,46 @@ function createEventBus(eventBusOptions) {
             && listener.remoteEventName === remoteEventName
             && listener.localEventNamePrefix === localEventNamePrefix);
         if (!listener) {
-            listener = {
+            const createListenerFn = () => {
+                if (remoteEventName === "*") {
+                    return (eventName, args) => {
+                        let computedName;
+                        if (localEventName) {
+                            computedName = localEventName;
+                        }
+                        else if (localEventNamePrefix) {
+                            computedName = `${localEventNamePrefix}${String(eventName)}`;
+                        }
+                        else {
+                            computedName = eventName;
+                        }
+                        return _trigger(computedName, args, returnType, resolve);
+                    };
+                }
+                return (...args) => {
+                    let computedName;
+                    if (localEventName) {
+                        computedName = localEventName;
+                    }
+                    else if (localEventNamePrefix) {
+                        computedName = `${localEventNamePrefix}${String(remoteEventName)}`;
+                    }
+                    else {
+                        computedName = remoteEventName;
+                    }
+                    return _trigger(computedName, args, returnType, resolve);
+                };
+            };
+            const proxyListener = {
                 localEventName,
                 remoteEventName,
                 localEventNamePrefix,
                 returnType,
                 resolve,
-                listener: remoteEventName === "*"
-                    ? (eventName, args) => {
-                        const name = localEventName
-                            ? localEventName
-                            : localEventNamePrefix
-                                ? `${localEventNamePrefix}${eventName}`
-                                : eventName;
-                        return _trigger(name, 
-                        // @ts-expect-error
-                        args, returnType, resolve);
-                    }
-                    : (...args) => {
-                        const name = localEventName
-                            ? localEventName
-                            : localEventNamePrefix
-                                ? `${localEventNamePrefix}${remoteEventName}`
-                                : remoteEventName;
-                        return _trigger(name, 
-                        // @ts-expect-error
-                        args, returnType, resolve);
-                    },
+                listener: createListenerFn(),
             };
-            proxyListeners.push(listener);
+            listener = proxyListener;
+            proxyListeners.push(proxyListener);
         }
         return listener;
     };
@@ -146,7 +157,6 @@ function createEventBus(eventBusOptions) {
     const on = (name, handler, options) => {
         const e = _getOrAddEvent(name);
         eventSources.forEach((evs) => {
-            name;
             if (evs.eventSource.accepts === false
                 || (typeof evs.eventSource.accepts === "function"
                     && !evs.eventSource.accepts(name))) {
@@ -181,7 +191,7 @@ function createEventBus(eventBusOptions) {
         if (e) {
             e.removeListener(handler, context, tag);
         }
-        if (eventSources.length > 0) {
+        if (eventSources.length > 0 && e) {
             const isEmpty = !e.hasListener();
             eventSources.forEach((evs) => {
                 const inx = evs.subscribed.indexOf(name);
@@ -256,6 +266,7 @@ function createEventBus(eventBusOptions) {
                     break;
                 default:
                     e.trigger(...args);
+                    return undefined;
             }
             return result;
         };
@@ -289,78 +300,64 @@ function createEventBus(eventBusOptions) {
         return _trigger(name, args, null, false);
     };
     const first = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.FIRST, false);
     };
     const resolveFirst = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.FIRST, true);
     };
     const all = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.ALL, false);
     };
     const resolveAll = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.ALL, true);
     };
     const last = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.LAST, false);
     };
     const resolveLast = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.LAST, true);
     };
     const merge = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.MERGE, false);
     };
     const resolveMerge = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.MERGE, true);
     };
     const concat = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.CONCAT, false);
     };
     const resolveConcat = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.CONCAT, true);
     };
     const firstNonEmpty = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.FIRST_NON_EMPTY, false);
     };
     const resolveFirstNonEmpty = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.FIRST_NON_EMPTY, true);
     };
     const untilTrue = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.UNTIL_TRUE, false);
     };
     const untilFalse = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.UNTIL_FALSE, false);
     };
     const pipe = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.PIPE, false);
     };
     const resolvePipe = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.PIPE, true);
     };
     const raw = (name, ...args) => {
-        const e = _getOrAddEvent(name);
         return _trigger(name, args, types_1.TriggerReturnType.RAW, false);
     };
     const withTags = (tags, callback) => {
         currentTagsFilter = tags;
-        const result = callback();
-        currentTagsFilter = null;
-        return result;
+        try {
+            return callback();
+        }
+        finally {
+            currentTagsFilter = null;
+        }
     };
     const reset = () => {
         if (eventSources.length > 0) {
@@ -376,14 +373,14 @@ function createEventBus(eventBusOptions) {
         eventSources.length = 0;
     };
     const suspendAll = (withQueue = false) => {
-        for (const name in events) {
-            events.get(name).suspend(withQueue);
-        }
+        events.forEach((event) => {
+            event.suspend(withQueue);
+        });
     };
     const resumeAll = () => {
-        for (const name in events) {
-            events.get(name).resume();
-        }
+        events.forEach((event) => {
+            event.resume();
+        });
     };
     const relay = ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }) => {
         const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(proxyType || types_1.ProxyType.TRIGGER);
@@ -435,16 +432,16 @@ function createEventBus(eventBusOptions) {
             : evs.eventSource.name === eventSource.name);
         if (inx !== -1) {
             const evs = eventSources[inx];
-            evs.subscribed.forEach((name) => {
+            evs.subscribed.forEach((subscribedName) => {
                 const { returnType, resolve } = proxyReturnTypeToTriggerReturnType(evs.eventSource.proxyType || types_1.ProxyType.TRIGGER);
                 const listener = _getProxyListener({
                     localEventName: null,
-                    remoteEventName: name,
+                    remoteEventName: subscribedName,
                     returnType,
                     resolve,
                     localEventNamePrefix: null,
                 });
-                evs.eventSource.un(name, listener.listener, evs.eventSource);
+                evs.eventSource.un(subscribedName, listener.listener, evs.eventSource);
             });
             eventSources.splice(inx, 1);
         }

package/dist/lib/asyncCall.js

@@ -4,13 +4,12 @@ exports.default = asyncCall;
 function asyncCall(fn, context, args, timeout) {
     return new Promise((resolve, reject) => {
         const newArgs = [...(args || [])];
-        // const newArgs = [ ...(args || []) ];
         setTimeout(() => {
             try {
                 resolve(fn.apply(context, newArgs));
             }
             catch (err) {
-                reject(err);
+                reject(err instanceof Error ? err : new Error(String(err)));
             }
         }, timeout || 0);
     });

package/dist/react/ErrorBoundary.js

@@ -9,6 +9,9 @@ function ErrorBoundary({ children, listener }) {
     const boundaryErrorListener = (0, react_1.useContext)(exports.ErrorBoundaryContext);
     const thisRef = (0, react_1.useRef)(listener);
     const outerRef = (0, react_1.useRef)(boundaryErrorListener);
+    // Keep refs in sync with props
+    thisRef.current = listener;
+    outerRef.current = boundaryErrorListener;
     const thisErrorListener = (0, react_1.useCallback)((errorResponse) => {
         if (thisRef.current) {
             thisRef.current(errorResponse);

package/dist/react/useListenToActionBus.js

@@ -9,12 +9,9 @@ function useListenToActionBus(actionBus, actionName, listener, options, errorLis
         beforeActionListener = listener.beforeActionListener;
         listener = listener.listener;
     }
-    const actionBusRef = (0, react_1.useRef)(actionBus);
     const listenerRef = (0, react_1.useRef)(listener || null);
-    const errorListenerRef = (0, react_1.useRef)(null);
     const beforeActionListenerRef = (0, react_1.useRef)(null);
     listenerRef.current = listener || null;
-    errorListenerRef.current = errorListener || null;
     beforeActionListenerRef.current = beforeActionListener || null;
     const genericHandler = (0, react_1.useCallback)((arg) => {
         var _a;
@@ -24,27 +21,22 @@ function useListenToActionBus(actionBus, actionName, listener, options, errorLis
         var _a;
         return ((_a = beforeActionListenerRef.current) === null || _a === void 0 ? void 0 : _a.call(beforeActionListenerRef, ...args)) || undefined;
     }, []);
-    const genericErrorListener = (0, react_1.useCallback)((arg) => {
-        var _a;
-        return (_a = errorListenerRef.current) === null || _a === void 0 ? void 0 : _a.call(errorListenerRef, arg);
-    }, []);
+    // Main listener + beforeAction listener - tied to actionName
     (0, react_1.useEffect)(() => {
+        actionBus.addListener(actionName, genericHandler, options || undefined);
+        actionBus.get(actionName).addBeforeActionListener(genericBeforeActionHandler);
         return () => {
-            actionBusRef.current.removeListener(actionName, genericHandler);
-            actionBusRef.current.get(actionName)
-                .removeBeforeActionListener(genericBeforeActionHandler);
-            actionBusRef.current.removeErrorListener(genericErrorListener);
+            actionBus.removeListener(actionName, genericHandler);
+            actionBus.get(actionName).removeBeforeActionListener(genericBeforeActionHandler);
         };
-    }, []);
+    }, [actionBus, actionName, genericHandler, genericBeforeActionHandler]);
+    // Error listener - bus level
     (0, react_1.useEffect)(() => {
-        actionBusRef.current.removeListener(actionName, genericHandler);
-        actionBusRef.current.get(actionName)
-            .removeBeforeActionListener(genericBeforeActionHandler);
-        actionBusRef.current.removeErrorListener(genericErrorListener);
-        actionBusRef.current = actionBus;
-        actionBusRef.current.addListener(actionName, genericHandler, options || undefined);
-        actionBusRef.current.get(actionName)
-            .addBeforeActionListener(genericBeforeActionHandler);
-        actionBusRef.current.addErrorListener(genericErrorListener);
-    }, [actionBus]);
+        if (errorListener) {
+            actionBus.addErrorListener(errorListener);
+            return () => {
+                actionBus.removeErrorListener(errorListener);
+            };
+        }
+    }, [actionBus, errorListener]);
 }

package/dist/react/useListenToEvent.js

@@ -4,31 +4,22 @@ exports.useListenToEvent = useListenToEvent;
 const react_1 = require("react");
 function useListenToEvent(event, listener, options, errorListener) {
     const listenerRef = (0, react_1.useRef)(listener);
-    const eventRef = (0, react_1.useRef)(event);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
     listenerRef.current = listener;
     const genericHandler = (0, react_1.useCallback)((...args) => {
         return listenerRef.current(...args);
     }, []);
     (0, react_1.useEffect)(() => {
+        event.addListener(genericHandler, options);
         return () => {
-            eventRef.current.removeListener(genericHandler);
+            event.removeListener(genericHandler);
         };
-    }, []);
-    (0, react_1.useEffect)(() => {
-        eventRef.current.removeListener(genericHandler);
-        eventRef.current = event;
-        eventRef.current.addListener(genericHandler, options);
-    }, [event]);
+    }, [event, genericHandler]);
     (0, react_1.useEffect)(() => {
-        if (errorListenerRef.current !== errorListener) {
-            if (errorListenerRef.current) {
-                eventRef.current.removeErrorListener(errorListenerRef.current);
-            }
-            errorListenerRef.current = errorListener;
-            if (errorListener) {
-                eventRef.current.addErrorListener(errorListener);
-            }
+        if (errorListener) {
+            event.addErrorListener(errorListener);
+            return () => {
+                event.removeErrorListener(errorListener);
+            };
         }
-    }, [errorListener]);
+    }, [event, errorListener]);
 }

package/dist/react/useListenToEventBus.js

@@ -4,35 +4,25 @@ exports.useListenToEventBus = useListenToEventBus;
 const react_1 = require("react");
 function useListenToEventBus(eventBus, eventName, listener, options, errorListener) {
     const listenerRef = (0, react_1.useRef)(listener);
-    const eventBusRef = (0, react_1.useRef)(eventBus);
-    const errorListenerRef = (0, react_1.useRef)(errorListener);
     listenerRef.current = listener;
     const genericHandler = (0, react_1.useCallback)((...args) => {
         var _a;
         return (_a = listenerRef.current) === null || _a === void 0 ? void 0 : _a.call(listenerRef, ...args);
     }, []);
+    // Main listener - cleanup pattern handles eventBus/eventName changes
     (0, react_1.useEffect)(() => {
+        eventBus.addListener(eventName, genericHandler, options);
         return () => {
-            eventBusRef.current.removeListener(eventName, genericHandler);
-            if (errorListenerRef.current) {
-                eventBusRef.current.removeErrorListener(errorListenerRef.current);
-            }
+            eventBus.removeListener(eventName, genericHandler);
         };
-    }, []);
-    (0, react_1.useEffect)(() => {
-        eventBusRef.current.removeListener(eventName, genericHandler);
-        eventBusRef.current = eventBus;
-        eventBusRef.current.addListener(eventName, genericHandler, options);
-    }, [eventBus]);
+    }, [eventBus, eventName, genericHandler]);
+    // Error listener - cleanup pattern
     (0, react_1.useEffect)(() => {
-        if (errorListenerRef.current !== errorListener) {
-            if (errorListenerRef.current) {
-                eventBusRef.current.removeErrorListener(errorListenerRef.current);
-            }
-            errorListenerRef.current = errorListener;
-            if (errorListener) {
-                eventBusRef.current.addErrorListener(errorListener);
-            }
+        if (errorListener) {
+            eventBus.addErrorListener(errorListener);
+            return () => {
+                eventBus.removeErrorListener(errorListener);
+            };
         }
-    }, [errorListener]);
+    }, [eventBus, errorListener]);
 }

package/dist/react/useListenToStoreChanges.js

@@ -4,19 +4,14 @@ exports.useListenToStoreChanges = useListenToStoreChanges;
 const react_1 = require("react");
 function useListenToStoreChanges(store, key, listener, options) {
     const listenerRef = (0, react_1.useRef)(listener);
-    const storeRef = (0, react_1.useRef)(store);
     listenerRef.current = listener;
     const genericHandler = (0, react_1.useCallback)((value, previousValue) => {
         return listenerRef.current(value, previousValue);
     }, []);
     (0, react_1.useEffect)(() => {
+        store.onChange(key, genericHandler, options);
         return () => {
-            storeRef.current.removeOnChange(key, genericHandler);
+            store.removeOnChange(key, genericHandler);
         };
-    }, []);
-    (0, react_1.useEffect)(() => {
-        storeRef.current.removeOnChange(key, genericHandler);
-        storeRef.current = store;
-        storeRef.current.onChange(key, genericHandler, options);
-    }, [store]);
+    }, [store, key, genericHandler]);
 }

package/dist/react/useStore.js

@@ -13,15 +13,14 @@ function useStore(initialData = {}, config) {
         }
         if (config === null || config === void 0 ? void 0 : config.pipes) {
             for (const key in config.pipes) {
-                // @ts-expect-error
+                // @ts-expect-error - TS widens for-in key to string; types are correct
                 store.pipe(key, config.pipes[key]);
             }
         }
         if (config === null || config === void 0 ? void 0 : config.control) {
             for (const key in config.control) {
-                store.control(
-                // @ts-expect-error
-                key, config.control[key]);
+                // @ts-expect-error - TS widens for-in key to string; types are correct
+                store.control(key, config.control[key]);
             }
         }
         return store;

package/dist/react/useStoreState.d.ts

@@ -1,3 +1,3 @@
 import { KeyOf } from "../lib/types";
 import { BaseStore } from "../store";
-export declare function useStoreState<TStore extends BaseStore, TKey extends KeyOf<TStore["__type"]["propTypes"]>>(store: TStore, key: TKey): readonly [TStore["__type"]["propTypes"][TKey], (value: TStore["__type"]["propTypes"][TKey] | ((previousValue?: TStore["__type"]["propTypes"][TKey] | undefined) => TStore["__type"]["propTypes"][TKey])) => void];
+export declare function useStoreState<TStore extends BaseStore, TKey extends KeyOf<TStore["__type"]["propTypes"]>>(store: TStore, key: TKey): readonly [TStore["__type"]["propTypes"][TKey], (value: TStore["__type"]["propTypes"][TKey] | ((previousValue?: TStore["__type"]["propTypes"][TKey]) => TStore["__type"]["propTypes"][TKey])) => void];

package/dist/react/useStoreState.js

@@ -27,6 +27,7 @@ function useStoreState(store, key) {
         storeRef.current = store;
         keyRef.current = key;
         storeRef.current.onChange(keyRef.current, onChange);
+        setValue(store.get(key));
     }, [store, key]);
     return [value, setter];
 }

package/dist/store.js

@@ -69,6 +69,7 @@ function createStore(initialData = {}) {
                     name,
                 });
                 if ((_b = control.get(exports.ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
+                    effectKeys = [];
                     return true;
                 }
                 throw error;
@@ -94,6 +95,7 @@ function createStore(initialData = {}) {
                         name,
                     });
                     if ((_d = control.get(exports.ErrorEventName)) === null || _d === void 0 ? void 0 : _d.hasListener()) {
+                        effectKeys = [];
                         return true;
                     }
                     throw error;
@@ -116,6 +118,7 @@ function createStore(initialData = {}) {
                         name,
                     });
                     if ((_e = control.get(exports.ErrorEventName)) === null || _e === void 0 ? void 0 : _e.hasListener()) {
+                        effectKeys = [];
                         return true;
                     }
                     throw error;
@@ -171,7 +174,7 @@ function createStore(initialData = {}) {
                     type: "store-control",
                 });
                 if ((_b = control.get(exports.ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
-                    return true;
+                    return;
                 }
                 throw error;
             }
@@ -182,14 +185,16 @@ function createStore(initialData = {}) {
     }
     const get = (key) => {
         if (typeof key === "string") {
-            return data.get(key);
+            const value = data.get(key);
+            return value;
         }
         else if (Array.isArray(key)) {
             // return object with given keys
-            return key.reduce((acc, k) => {
-                acc[k] = data.get(k);
-                return acc;
-            }, {});
+            const result = {};
+            for (const k of key) {
+                result[k] = data.get(k);
+            }
+            return result;
         }
         else {
             throw new Error(`Invalid key: ${String(key)}`);
@@ -204,7 +209,12 @@ function createStore(initialData = {}) {
     const getData = () => {
         return Object.fromEntries(data.entries());
     };
+    let batching = false;
     const batch = (fn) => {
+        if (batching) {
+            throw new Error("Nested batch() calls are not supported");
+        }
+        batching = true;
         const allChangedKeys = [];
         const log = [];
         const controlInterceptor = function (name, [changedKeys]) {
@@ -220,9 +230,14 @@ function createStore(initialData = {}) {
         };
         changes.intercept(changeInterceptor);
         control.intercept(controlInterceptor);
-        fn();
-        control.stopIntercepting();
-        changes.stopIntercepting();
+        try {
+            fn();
+        }
+        finally {
+            control.stopIntercepting();
+            changes.stopIntercepting();
+            batching = false;
+        }
         for (const [propName, value, prev] of log) {
             const changeArgs = [
                 value,

package/package.json

@@ -1,34 +1,35 @@
 {
     "name": "@kuindji/reactive",
-    "version": "1.0.21",
+    "version": "1.0.23",
     "author": "Ivan Kuindzhi",
+    "type": "module",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/kuindji/reactive.git"
     },
     "main": "dist/index.js",
     "devDependencies": {
-        "@happy-dom/global-registrator": "^18.0.1",
+        "@happy-dom/global-registrator": "^20.0.11",
         "@testing-library/dom": "^10.4.1",
-        "@testing-library/jest-dom": "^6.6.4",
+        "@testing-library/jest-dom": "^6.9.1",
         "@testing-library/react": "^16.3.0",
-        "@types/bun": "^1.2.19",
-        "@types/react": "^19.1.9",
-        "@typescript-eslint/eslint-plugin": "^8.38.0",
-        "react": "^19.1.1",
-        "typescript": "^5",
-        "typescript-eslint": "^8.38.0"
+        "@types/bun": "^1.3.3",
+        "@types/react": "^19.2.7",
+        "@typescript-eslint/eslint-plugin": "^8.48.0",
+        "globals": "^16.5.0",
+        "react": "^19.2.0",
+        "react-dom": "^19.2.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.48.0"
     },
     "exports": {
         ".": {
-            "import": "./dist/index.js",
-            "require": "./dist/index.js",
-            "types": "./dist/index.d.ts"
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
         },
         "./react": {
-            "import": "./dist/react.js",
-            "require": "./dist/react.js",
-            "types": "./dist/react.d.ts"
+            "types": "./dist/react.d.ts",
+            "import": "./dist/react.js"
         }
     },
     "bugs": {
@@ -62,9 +63,10 @@
     "scripts": {
         "build": "tsc -p ./tsconfig-build.json",
         "lint": "bun eslint .",
-        "test": "bun test tests/**/*.spec.ts*"
+        "test": "bun test tests/**/*.spec.ts*",
+        "test:types": "tsc -p ./tests/types/tsconfig.json",
+        "test:all": "bun run test:types && bun run test"
     },
     "sideEffects": false,
-    "type": "commonjs",
     "types": "dist/index.d.ts"
 }