@kuindji/reactive 1.0.24 → 1.2.0

package/dist/react/useListenToEvent.d.ts

@@ -1,4 +1,4 @@
-import type { BaseEvent, ListenerOptions } from "../event";
-import type { ErrorListenerSignature } from "../lib/types";
+import type { BaseEvent, ListenerOptions } from "../event.js";
+import type { ErrorListenerSignature } from "../lib/types.js";
 export type { BaseEvent, ErrorListenerSignature, ListenerOptions };
 export declare function useListenToEvent<TEvent extends BaseEvent, TListenerSignature extends TEvent["__type"]["signature"], TErrorListenerSignature extends TEvent["__type"]["errorListenerSignature"]>(event: TEvent, listener: TListenerSignature, options?: ListenerOptions, errorListener?: TErrorListenerSignature): void;

package/dist/react/useListenToEvent.js

@@ -1,16 +1,18 @@
 import { useCallback, useEffect, useRef } from "react";
+import { useReconciledListener } from "./useReconciledListener.js";
 export function useListenToEvent(event, listener, options, errorListener) {
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
     const genericHandler = useCallback((...args) => {
         return listenerRef.current(...args);
     }, []);
-    useEffect(() => {
-        event.addListener(genericHandler, options);
-        return () => {
-            event.removeListener(genericHandler);
-        };
-    }, [event, genericHandler]);
+    useReconciledListener({
+        keyDeps: [event],
+        options,
+        subscribe: (opts) => event.addListener(genericHandler, opts !== null && opts !== void 0 ? opts : undefined),
+        unsubscribe: (ctx) => event.removeListener(genericHandler, ctx),
+        update: (ctx, opts) => event.updateListenerOptions(genericHandler, ctx, opts !== null && opts !== void 0 ? opts : undefined),
+    });
     useEffect(() => {
         if (errorListener) {
             event.addErrorListener(errorListener);

package/dist/react/useListenToEventBus.d.ts

@@ -1,5 +1,5 @@
-import type { ListenerOptions } from "../event";
-import type { BaseEventBus } from "../eventBus";
-import type { ErrorListenerSignature, KeyOf } from "../lib/types";
+import type { ListenerOptions } from "../event.js";
+import type { BaseEventBus } from "../eventBus.js";
+import type { ErrorListenerSignature, KeyOf } from "../lib/types.js";
 export type { BaseEventBus, ErrorListenerSignature, ListenerOptions };
 export declare function useListenToEventBus<TEventBus extends BaseEventBus, TKey extends KeyOf<TEventBus["__type"]["eventSignatures"]>, TListener extends TEventBus["__type"]["eventSignatures"][TKey]>(eventBus: TEventBus, eventName: TKey, listener: TListener, options?: ListenerOptions, errorListener?: ErrorListenerSignature<any[]>): void;

package/dist/react/useListenToEventBus.js

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef } from "react";
+import { useReconciledListener } from "./useReconciledListener.js";
 export function useListenToEventBus(eventBus, eventName, listener, options, errorListener) {
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
@@ -6,13 +7,14 @@ export function useListenToEventBus(eventBus, eventName, listener, options, erro
         var _a;
         return (_a = listenerRef.current) === null || _a === void 0 ? void 0 : _a.call(listenerRef, ...args);
     }, []);
-    // Main listener - cleanup pattern handles eventBus/eventName changes
-    useEffect(() => {
-        eventBus.addListener(eventName, genericHandler, options);
-        return () => {
-            eventBus.removeListener(eventName, genericHandler);
-        };
-    }, [eventBus, eventName, genericHandler]);
+    // Main listener - reconciled across eventBus/eventName/option changes
+    useReconciledListener({
+        keyDeps: [eventBus, eventName],
+        options,
+        subscribe: (opts) => eventBus.addListener(eventName, genericHandler, opts !== null && opts !== void 0 ? opts : undefined),
+        unsubscribe: (ctx) => eventBus.removeListener(eventName, genericHandler, ctx),
+        update: (ctx, opts) => eventBus.updateListenerOptions(eventName, genericHandler, ctx, opts !== null && opts !== void 0 ? opts : undefined),
+    });
     // Error listener - cleanup pattern
     useEffect(() => {
         if (errorListener) {

package/dist/react/useListenToStoreChanges.d.ts

@@ -1,5 +1,5 @@
-import type { ListenerOptions } from "../event";
-import { KeyOf } from "../lib/types";
-import type { BaseStore } from "../store";
+import type { ListenerOptions } from "../event.js";
+import { KeyOf } from "../lib/types.js";
+import type { BaseStore } from "../store.js";
 export type { BaseStore, ListenerOptions };
 export declare function useListenToStoreChanges<TStore extends BaseStore, TKey extends KeyOf<TStore["__type"]["propTypes"]>, TListener extends TStore["__type"]["changeEvents"][TKey]>(store: TStore, key: TKey, listener: TListener, options?: ListenerOptions): void;

package/dist/react/useListenToStoreChanges.js

@@ -1,14 +1,16 @@
-import { useCallback, useEffect, useRef } from "react";
+import { useCallback, useRef } from "react";
+import { useReconciledListener } from "./useReconciledListener.js";
 export function useListenToStoreChanges(store, key, listener, options) {
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
     const genericHandler = useCallback((value, previousValue) => {
         return listenerRef.current(value, previousValue);
     }, []);
-    useEffect(() => {
-        store.onChange(key, genericHandler, options);
-        return () => {
-            store.removeOnChange(key, genericHandler);
-        };
-    }, [store, key, genericHandler]);
+    useReconciledListener({
+        keyDeps: [store, key],
+        options,
+        subscribe: (opts) => store.onChange(key, genericHandler, opts !== null && opts !== void 0 ? opts : undefined),
+        unsubscribe: (ctx) => store.removeOnChange(key, genericHandler, ctx),
+        update: (ctx, opts) => store.updateOnChangeOptions(key, genericHandler, ctx, opts !== null && opts !== void 0 ? opts : undefined),
+    });
 }

package/dist/react/useReconciledListener.d.ts

@@ -0,0 +1,33 @@
+import type { ListenerOptions } from "../event.js";
+type ListenerOps = {
+    /**
+     * Identity dependencies. When any element changes (reference equality) the
+     * listener is fully resubscribed: the old registration is removed using the
+     * previous closure (previous target + previous context) and a fresh one is
+     * added. `context` is appended automatically because it is part of listener
+     * identity. The array length must stay constant across renders.
+     */
+    keyDeps: ReadonlyArray<unknown>;
+    options?: ListenerOptions | null;
+    /** Add the listener to the current target with the given options. */
+    subscribe: (options?: ListenerOptions | null) => void;
+    /** Remove the listener from the current target using the given context. */
+    unsubscribe: (context: object | null) => void;
+    /** Update soft options on the live listener in place (counters preserved). */
+    update: (context: object | null, options?: ListenerOptions | null) => void;
+};
+/**
+ * Reconciles a single reactive listener across renders without relying on the
+ * identity of the options object.
+ *
+ * Two effects cooperate:
+ *  - an identity effect keyed by `[...keyDeps, context]` performs the classic
+ *    add-on-mount / remove-on-cleanup cycle, so target/context changes (and
+ *    React StrictMode remounts) resubscribe correctly using the OLD context on
+ *    cleanup;
+ *  - a reconciliation effect runs every render and, when only soft options
+ *    changed, updates the live listener in place instead of resubscribing, so
+ *    per-listener counters are preserved.
+ */
+export declare function useReconciledListener({ keyDeps, options, subscribe, unsubscribe, update, }: ListenerOps): void;
+export {};

package/dist/react/useReconciledListener.js

@@ -0,0 +1,44 @@
+import { useEffect, useRef } from "react";
+import { areListenerOptionsEqual } from "./listenerOptionsEqual.js";
+/**
+ * Reconciles a single reactive listener across renders without relying on the
+ * identity of the options object.
+ *
+ * Two effects cooperate:
+ *  - an identity effect keyed by `[...keyDeps, context]` performs the classic
+ *    add-on-mount / remove-on-cleanup cycle, so target/context changes (and
+ *    React StrictMode remounts) resubscribe correctly using the OLD context on
+ *    cleanup;
+ *  - a reconciliation effect runs every render and, when only soft options
+ *    changed, updates the live listener in place instead of resubscribing, so
+ *    per-listener counters are preserved.
+ */
+export function useReconciledListener({ keyDeps, options, subscribe, unsubscribe, update, }) {
+    var _a;
+    const context = (_a = options === null || options === void 0 ? void 0 : options.context) !== null && _a !== void 0 ? _a : null;
+    const committedRef = useRef(undefined);
+    const registeredRef = useRef(false);
+    // Identity effect: (re)subscribe on target/context change.
+    useEffect(() => {
+        subscribe(options);
+        committedRef.current = options;
+        registeredRef.current = true;
+        return () => {
+            unsubscribe(context);
+            registeredRef.current = false;
+        };
+    }, [...keyDeps, context]);
+    // Reconciliation effect: in-place soft-option updates every render.
+    useEffect(() => {
+        if (!registeredRef.current) {
+            return;
+        }
+        if (committedRef.current === options) {
+            return;
+        }
+        if (!areListenerOptionsEqual(committedRef.current, options)) {
+            update(context, options);
+        }
+        committedRef.current = options;
+    });
+}

package/dist/react/useStore.d.ts

@@ -1,5 +1,5 @@
-import { createStore } from "../store";
-import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store";
+import { createStore } from "../store.js";
+import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store.js";
 export type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper, };
 export declare function useStore<PropMap extends BasePropMap, Store extends StoreDefinitionHelper<PropMap> = StoreDefinitionHelper<PropMap>, Config extends {
     onChange?: Partial<Store["changeEvents"]>;

package/dist/react/useStore.js

@@ -1,26 +1,78 @@
-import { useMemo } from "react";
-import { createStore } from "../store";
+import { useEffect, useMemo, useRef } from "react";
+import { createStore } from "../store.js";
 export function useStore(initialData = {}, config) {
-    const store = useMemo(() => {
-        const store = createStore(initialData);
-        if (config === null || config === void 0 ? void 0 : config.onChange) {
-            for (const key in config.onChange) {
-                store.onChange(key, config.onChange[key]);
-            }
+    // initialData is seed-only (captured once); later changes are ignored.
+    const store = useMemo(() => createStore(initialData), []);
+    // Track only the handlers we added (per category + key) and compare by
+    // reference, so consumer listeners added outside the hook are never
+    // touched and inline-equal config maps do not duplicate or churn
+    // subscriptions.
+    const appliedRef = useRef({
+        onChange: {},
+        pipes: {},
+        control: {},
+    });
+    const add = (category, key, fn) => {
+        if (category === "onChange") {
+            store.onChange(key, fn);
         }
-        if (config === null || config === void 0 ? void 0 : config.pipes) {
-            for (const key in config.pipes) {
-                // @ts-expect-error - TS widens for-in key to string; types are correct
-                store.pipe(key, config.pipes[key]);
-            }
+        else if (category === "pipes") {
+            store.pipe(key, fn);
         }
-        if (config === null || config === void 0 ? void 0 : config.control) {
-            for (const key in config.control) {
-                // @ts-expect-error - TS widens for-in key to string; types are correct
-                store.control(key, config.control[key]);
-            }
+        else {
+            store.control(key, fn);
+        }
+    };
+    const remove = (category, key, fn) => {
+        if (category === "onChange") {
+            store.removeOnChange(key, fn);
         }
-        return store;
+        else if (category === "pipes") {
+            store.removePipe(key, fn);
+        }
+        else {
+            store.removeControl(key, fn);
+        }
+    };
+    // Reconcile config handlers every render (no cleanup here, so equal config
+    // never causes remove/add churn).
+    useEffect(() => {
+        const categories = {
+            onChange: config === null || config === void 0 ? void 0 : config.onChange,
+            pipes: config === null || config === void 0 ? void 0 : config.pipes,
+            control: config === null || config === void 0 ? void 0 : config.control,
+        };
+        Object.keys(categories).forEach((category) => {
+            var _a;
+            const next = (_a = categories[category]) !== null && _a !== void 0 ? _a : {};
+            const prev = appliedRef.current[category];
+            // Remove stale/changed handlers before adding (matters for pipes).
+            for (const key in prev) {
+                if (next[key] !== prev[key]) {
+                    remove(category, key, prev[key]);
+                }
+            }
+            for (const key in next) {
+                if (next[key] !== prev[key]) {
+                    add(category, key, next[key]);
+                }
+            }
+            appliedRef.current[category] = Object.assign({}, next);
+        });
+    });
+    // Unmount cleanup: detach everything we applied (also makes StrictMode
+    // remount re-subscribe cleanly via the reconcile effect above).
+    useEffect(() => {
+        return () => {
+            const applied = appliedRef.current;
+            Object.keys(applied).forEach((category) => {
+                const map = applied[category];
+                for (const key in map) {
+                    remove(category, key, map[key]);
+                }
+                applied[category] = {};
+            });
+        };
     }, []);
     return store;
 }

package/dist/react/useStoreSelector.d.ts

@@ -0,0 +1,35 @@
+import type { KeyOf } from "../lib/types.js";
+import type { BaseStore } from "../store.js";
+export type EqualityFn<T> = (a: T, b: T) => boolean;
+/**
+ * Subscribes to a derived slice of a store with custom equality. Selector
+ * re-execution is gated on the raw input (dep values, or a shallow compare of
+ * the full state), so a selector that builds a fresh object each call returns a
+ * stable cached reference while its input is unchanged — safe even without an
+ * equality fn (an un-gated fresh reference on every getSnapshot call would loop
+ * forever). The optional equality fn additionally bails React re-renders when a
+ * recompute produces an equal-but-fresh result.
+ *
+ * Two forms:
+ *   useStoreSelector(store, (s) => `${s.first} ${s.last}`, shallowEqual?)
+ *   useStoreSelector(store, ["first", "last"], (first, last) => …, eqFn?)
+ *
+ * The deps-keyed form recomputes only when the change batch touches its keys.
+ *
+ * Prefer the deps-keyed form for narrow reads. The selector form (no deps)
+ * subscribes to every store change and rebuilds the whole state via getData()
+ * on each one, re-running the selector even for unrelated writes (the equality
+ * fn still bails React re-renders, but the recompute itself is not filtered).
+ * The deps-keyed form both filters the subscription to its keys and avoids
+ * materializing the full state, so reach for it when selecting a few slices of
+ * a large or frequently-written store.
+ *
+ * Concurrent-safe: the selection is memoized in a render-phase `useMemo` (an
+ * abandoned concurrent render discards it rather than leaking it into the
+ * committed tree) and the committed value is recorded in an effect, not during
+ * render. This mirrors React's own `useSyncExternalStoreWithSelector`.
+ */
+export declare function useStoreSelector<TStore extends BaseStore, R>(store: TStore, selector: (state: TStore["__type"]["propTypes"]) => R, equalityFn?: EqualityFn<R>): R;
+export declare function useStoreSelector<TStore extends BaseStore, const D extends readonly KeyOf<TStore["__type"]["propTypes"]>[], R>(store: TStore, deps: D, selector: (...values: {
+    [I in keyof D]: TStore["__type"]["propTypes"][D[I]];
+}) => R, equalityFn?: EqualityFn<R>): R;

package/dist/react/useStoreSelector.js

@@ -0,0 +1,144 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useSyncExternalStore, } from "react";
+import { ChangeEventName } from "../store.js";
+// Shallow per-entry equality for two state objects (enumerable own keys
+// compared with Object.is). Used to gate selector re-execution in the
+// no-deps form, whose input is rebuilt fresh by getData() on every call.
+function shallowEqualObject(a, b) {
+    if (a === b) {
+        return true;
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)
+            || !Object.is(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function useStoreSelector(store, arg2, arg3, arg4) {
+    var _a;
+    const deps = Array.isArray(arg2) ? arg2 : null;
+    const selector = (deps ? arg3 : arg2);
+    const equalityFn = (_a = (deps ? arg4 : arg3)) !== null && _a !== void 0 ? _a : Object.is;
+    // Committed selection cache. Written ONLY in an effect (commit phase) so an
+    // abandoned concurrent render cannot leak its selection into the committed
+    // tree (which a render-phase write to this cache would).
+    const instRef = useRef(null);
+    if (instRef.current === null) {
+        instRef.current = { hasValue: false, value: null };
+    }
+    const inst = instRef.current;
+    // Latest deps for the subscribe filter. Updated in a layout effect (commit
+    // phase), not during render, and read only inside the change listener (which
+    // fires after commit), so the subscription always filters on committed deps.
+    const depsRef = useRef(deps);
+    useLayoutEffect(() => {
+        depsRef.current = deps;
+    });
+    // The memoized selection getter. Built during render, but the useMemo result
+    // is part of the fiber's memoized state: an abandoned concurrent render
+    // discards it, so no closure leaks. Rebuilt only when the store, selector,
+    // equality, or deps identity changes. The committed `inst.value` is read
+    // (never written) here, so a re-render with an equal result bails out to the
+    // committed reference.
+    const getSelection = useMemo(() => {
+        let hasMemo = false;
+        let memoizedInput = [];
+        let memoized;
+        // Read the raw selector input (dep values, or the full state). On a
+        // destroyed store, read via getData() (which returns {} without
+        // asserting) instead of store.get() (which throws): getSnapshot can
+        // run for a still-mounted component after the store is destroyed
+        // (e.g. a provider torn down first), and must not throw out of
+        // render. Returns the input as an arg array so it can be both
+        // shallow-compared and spread into the selector.
+        const readInput = () => {
+            if (deps) {
+                if (store.isDestroyed()) {
+                    const snapshot = store.getData();
+                    return deps.map((d) => snapshot[d]);
+                }
+                return deps.map((d) => store.get(d));
+            }
+            return [store.getData()];
+        };
+        // Compare two raw inputs. The deps form holds dep values, compared
+        // by identity (the store replaces values on change, so identity
+        // tracks change). The selector form holds a single full-state
+        // object rebuilt fresh by getData() on every call, so it must be
+        // shallow-compared by entries rather than reference.
+        const inputsEqual = (a, b) => {
+            if (deps) {
+                if (a.length !== b.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.length; i++) {
+                    if (!Object.is(a[i], b[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return shallowEqualObject(a[0], b[0]);
+        };
+        return () => {
+            const input = readInput();
+            if (!hasMemo) {
+                hasMemo = true;
+                memoizedInput = input;
+                const next = selector(...input);
+                if (inst.hasValue && equalityFn(inst.value, next)) {
+                    memoized = inst.value;
+                    return inst.value;
+                }
+                memoized = next;
+                return next;
+            }
+            // Gate selector re-execution on the raw input. getSnapshot must
+            // return a cached reference that only changes when the store
+            // changes; re-running a fresh-object selector on every call (and
+            // relying solely on equalityFn) would return a new reference
+            // each call under the default Object.is and loop forever. When
+            // the input is unchanged we return the cached selection without
+            // re-running the selector — mirroring React's own
+            // useSyncExternalStoreWithSelector, which gates on snapshot
+            // identity (here the store's reads are not stable references, so
+            // we shallow-compare the input instead).
+            if (inputsEqual(memoizedInput, input)) {
+                return memoized;
+            }
+            memoizedInput = input;
+            const next = selector(...input);
+            if (equalityFn(memoized, next)) {
+                return memoized;
+            }
+            memoized = next;
+            return next;
+        };
+    }, [store, selector, equalityFn, deps, inst]);
+    const subscribe = useCallback((onStoreChange) => {
+        const listener = (names) => {
+            const currentDeps = depsRef.current;
+            if (currentDeps
+                && !names.some((n) => currentDeps.indexOf(n) !== -1)) {
+                return;
+            }
+            onStoreChange();
+        };
+        store.control(ChangeEventName, listener);
+        return () => {
+            store.removeControl(ChangeEventName, listener);
+        };
+    }, [store]);
+    const value = useSyncExternalStore(subscribe, getSelection, getSelection);
+    useEffect(() => {
+        inst.hasValue = true;
+        inst.value = value;
+    }, [value, inst]);
+    return value;
+}

package/dist/react/useStoreState.d.ts

@@ -1,3 +1,3 @@
-import { KeyOf } from "../lib/types";
-import { BaseStore } from "../store";
+import { KeyOf } from "../lib/types.js";
+import { BaseStore } from "../store.js";
 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

@@ -1,30 +1,35 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useSyncExternalStore } from "react";
 export function useStoreState(store, key) {
-    const [value, setValue] = useState(store.get(key));
-    const storeRef = useRef(store);
-    const keyRef = useRef(key);
-    const onChange = useCallback((value) => {
-        setValue(value);
-    }, []);
+    const subscribe = useCallback((onStoreChange) => {
+        const listener = () => {
+            onStoreChange();
+        };
+        store.onChange(key, listener);
+        return () => {
+            store.removeOnChange(key, listener);
+        };
+    }, [store, key]);
+    const getSnapshot = useCallback(
+    // getSnapshot can run for a still-mounted component after the store is
+    // destroyed (e.g. a provider torn down first), and must not throw out of
+    // render. On a destroyed store read via getData() (returns {} without
+    // asserting) instead of get() (which throws). Mirrors useStoreSelector.
+    () => (store.isDestroyed()
+        ? store.getData()[key]
+        : store.get(key)), [store, key]);
+    const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
     const setter = useCallback((value) => {
         if (typeof value === "function") {
-            storeRef.current.set(keyRef.current, value(storeRef.current.get(keyRef.current)));
+            // The cast is required by tsc (the typeof-narrowed `value` is
+            // `Setter | (ValueType & Function)`, not all callable), even
+            // though no-unnecessary-type-assertion disagrees on this TS
+            // version.
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+            store.set(key, value(store.get(key)));
         }
         else {
-            storeRef.current.set(keyRef.current, value);
+            store.set(key, value);
         }
-    }, []);
-    useEffect(() => {
-        return () => {
-            storeRef.current.removeOnChange(keyRef.current, onChange);
-        };
-    }, []);
-    useEffect(() => {
-        storeRef.current.removeOnChange(keyRef.current, onChange);
-        storeRef.current = store;
-        keyRef.current = key;
-        storeRef.current.onChange(keyRef.current, onChange);
-        setValue(store.get(key));
     }, [store, key]);
     return [value, setter];
 }

package/dist/react.d.ts

@@ -1,13 +1,16 @@
-export * from "./react/ErrorBoundary";
-export * from "./react/useAction";
-export * from "./react/useActionBus";
-export * from "./react/useActionMap";
-export * from "./react/useEvent";
-export * from "./react/useEventBus";
-export * from "./react/useListenToAction";
-export * from "./react/useListenToActionBus";
-export * from "./react/useListenToEvent";
-export * from "./react/useListenToEventBus";
-export * from "./react/useListenToStoreChanges";
-export * from "./react/useStore";
-export * from "./react/useStoreState";
+export * from "./react/ErrorBoundary.js";
+export * from "./react/useAction.js";
+export * from "./react/useActionBus.js";
+export * from "./react/useActionBusStatus.js";
+export * from "./react/useAsyncAction.js";
+export * from "./react/useActionMap.js";
+export * from "./react/useEvent.js";
+export * from "./react/useEventBus.js";
+export * from "./react/useListenToAction.js";
+export * from "./react/useListenToActionBus.js";
+export * from "./react/useListenToEvent.js";
+export * from "./react/useListenToEventBus.js";
+export * from "./react/useListenToStoreChanges.js";
+export * from "./react/useStore.js";
+export * from "./react/useStoreSelector.js";
+export * from "./react/useStoreState.js";

package/dist/react.js

@@ -1,13 +1,16 @@
-export * from "./react/ErrorBoundary";
-export * from "./react/useAction";
-export * from "./react/useActionBus";
-export * from "./react/useActionMap";
-export * from "./react/useEvent";
-export * from "./react/useEventBus";
-export * from "./react/useListenToAction";
-export * from "./react/useListenToActionBus";
-export * from "./react/useListenToEvent";
-export * from "./react/useListenToEventBus";
-export * from "./react/useListenToStoreChanges";
-export * from "./react/useStore";
-export * from "./react/useStoreState";
+export * from "./react/ErrorBoundary.js";
+export * from "./react/useAction.js";
+export * from "./react/useActionBus.js";
+export * from "./react/useActionBusStatus.js";
+export * from "./react/useAsyncAction.js";
+export * from "./react/useActionMap.js";
+export * from "./react/useEvent.js";
+export * from "./react/useEventBus.js";
+export * from "./react/useListenToAction.js";
+export * from "./react/useListenToActionBus.js";
+export * from "./react/useListenToEvent.js";
+export * from "./react/useListenToEventBus.js";
+export * from "./react/useListenToStoreChanges.js";
+export * from "./react/useStore.js";
+export * from "./react/useStoreSelector.js";
+export * from "./react/useStoreState.js";