@kuindji/reactive 1.2.0 → 1.3.0

package/dist/action.js

@@ -145,12 +145,15 @@ export function createAction(action) {
                 ? error
                 : new Error(error);
             lastResponse = null;
-            // Handle the error if listeners existed at invoke start OR were
-            // registered while the invocation was in flight. The start-of-invoke
-            // snapshot is retained (rather than relying solely on the live check)
-            // so that destroy() tearing the listeners down mid-flight cannot flip
-            // a previously-handled failure into a rejection.
-            if (!handlesErrors && !hasErrorListeners()) {
+            // Re-throw unless the failure is handled. It is handled when a live
+            // error listener exists now, OR when the action was destroyed
+            // mid-flight after starting with listeners: destroy() tears the
+            // listeners down, and that teardown must not flip a previously-handled
+            // failure into a rejection. The start-of-invoke snapshot is scoped to
+            // the destroyed case on purpose — an ordinary removeErrorListener()
+            // while awaiting genuinely leaves the failure unhandled, so invoke()
+            // must reject rather than silently swallow it.
+            if (!hasErrorListeners() && !(destroyed && handlesErrors)) {
                 throw error;
             }
             const response = {

package/dist/react/listenerOptionsEqual.d.ts

@@ -14,6 +14,20 @@ export declare function areTagsEqual(a?: string[], b?: string[]): boolean;
  * compare by reference, and `tags` use order-insensitive set comparison.
  */
 export declare function areListenerOptionsEqual(a?: ListenerOptions | null, b?: ListenerOptions | null): boolean;
+/**
+ * Expand a listener's options into a fully-populated set of the soft fields
+ * that {@link ListenerOptions} reconciliation updates in place, filling every
+ * omitted field with its default.
+ *
+ * `event.updateListenerOptions` uses partial-merge semantics (only fields
+ * present in the passed object change), but the React reconciliation layer is
+ * declarative: the options object fully describes the desired listener state,
+ * so a field dropped between renders must reset to its default. Passing this
+ * normalized object makes partial-merge behave as a full reset for exactly the
+ * soft fields — without disturbing `signal` (identity-managed by the abort
+ * wiring) or `context` (identity, handled by resubscribe).
+ */
+export declare function fillListenerUpdateDefaults(options?: ListenerOptions | null): ListenerOptions;
 /**
  * Domain-specific comparator for {@link EventOptions}. Primitives compare after
  * default semantics; `filter`/`filterContext` compare by reference.

package/dist/react/listenerOptionsEqual.js

@@ -70,6 +70,32 @@ export function areListenerOptionsEqual(a, b) {
     }
     return true;
 }
+/**
+ * Expand a listener's options into a fully-populated set of the soft fields
+ * that {@link ListenerOptions} reconciliation updates in place, filling every
+ * omitted field with its default.
+ *
+ * `event.updateListenerOptions` uses partial-merge semantics (only fields
+ * present in the passed object change), but the React reconciliation layer is
+ * declarative: the options object fully describes the desired listener state,
+ * so a field dropped between renders must reset to its default. Passing this
+ * normalized object makes partial-merge behave as a full reset for exactly the
+ * soft fields — without disturbing `signal` (identity-managed by the abort
+ * wiring) or `context` (identity, handled by resubscribe).
+ */
+export function fillListenerUpdateDefaults(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const o = options !== null && options !== void 0 ? options : {};
+    return {
+        limit: (_a = o.limit) !== null && _a !== void 0 ? _a : 0,
+        start: (_b = o.start) !== null && _b !== void 0 ? _b : 1,
+        tags: (_c = o.tags) !== null && _c !== void 0 ? _c : [],
+        extraData: (_d = o.extraData) !== null && _d !== void 0 ? _d : null,
+        alwaysFirst: (_e = o.alwaysFirst) !== null && _e !== void 0 ? _e : false,
+        alwaysLast: (_f = o.alwaysLast) !== null && _f !== void 0 ? _f : false,
+        async: (_g = o.async) !== null && _g !== void 0 ? _g : null,
+    };
+}
 /**
  * Domain-specific comparator for {@link EventOptions}. Primitives compare after
  * default semantics; `filter`/`filterContext` compare by reference.

package/dist/react/useActionBusStatus.d.ts

@@ -1,7 +1,7 @@
 import type { ActionStatus } from "../action.js";
 import type { BaseActionBus } from "../actionBus.js";
 import type { KeyOf } from "../lib/types.js";
-import type { AsyncActionState } from "./useAsyncAction.js";
+import { type AsyncActionState } from "./useAsyncAction.js";
 export type { ActionStatus, AsyncActionState };
 /**
  * Subscribes to the status of a named action on an ActionBus and returns

package/dist/react/useActionBusStatus.js

@@ -1,4 +1,5 @@
 import { useCallback, useSyncExternalStore } from "react";
+import { toAsyncActionState } from "./useAsyncAction.js";
 /**
  * Subscribes to the status of a named action on an ActionBus and returns
  * `{ loading, error, response }` for driving `loading`/`disabled` UI. This is
@@ -18,9 +19,5 @@ export function useActionBusStatus(bus, name) {
     }, [bus, name]);
     const getSnapshot = useCallback(() => bus.getStatus(name), [bus, name]);
     const status = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-    return {
-        loading: status.pending,
-        error: status.error,
-        response: status.response,
-    };
+    return toAsyncActionState(status);
 }

package/dist/react/useAsyncAction.d.ts

@@ -6,6 +6,12 @@ export type AsyncActionState<Response = any> = {
     error: Error | null;
     response: Response | null;
 };
+/**
+ * Project an action's {@link ActionStatus} into the {@link AsyncActionState}
+ * shape consumed by the status hooks (`pending` -> `loading`). Shared so
+ * `useAsyncAction` and `useActionBusStatus` stay in lockstep.
+ */
+export declare function toAsyncActionState<Response>(status: ActionStatus<Response>): AsyncActionState<Response>;
 /**
  * Wraps a function in an action and exposes its in-flight status, so a
  * component can drive `loading`/`disabled` without a hand-rolled

package/dist/react/useAsyncAction.js

@@ -1,5 +1,17 @@
 import { useCallback, useLayoutEffect, useMemo, useRef, useSyncExternalStore, } from "react";
 import { createAction } from "../action.js";
+/**
+ * Project an action's {@link ActionStatus} into the {@link AsyncActionState}
+ * shape consumed by the status hooks (`pending` -> `loading`). Shared so
+ * `useAsyncAction` and `useActionBusStatus` stay in lockstep.
+ */
+export function toAsyncActionState(status) {
+    return {
+        loading: status.pending,
+        error: status.error,
+        response: status.response,
+    };
+}
 /**
  * Wraps a function in an action and exposes its in-flight status, so a
  * component can drive `loading`/`disabled` without a hand-rolled
@@ -44,10 +56,6 @@ export function useAsyncAction(fn) {
     const invoke = useCallback((...args) => action.invoke(...args), [action]);
     return [
         invoke,
-        {
-            loading: status.pending,
-            error: status.error,
-            response: status.response,
-        },
+        toAsyncActionState(status),
     ];
 }

package/dist/react/useReconciledListener.js

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from "react";
-import { areListenerOptionsEqual } from "./listenerOptionsEqual.js";
+import { areListenerOptionsEqual, fillListenerUpdateDefaults, } from "./listenerOptionsEqual.js";
 /**
  * Reconciles a single reactive listener across renders without relying on the
  * identity of the options object.
@@ -37,7 +37,16 @@ export function useReconciledListener({ keyDeps, options, subscribe, unsubscribe
             return;
         }
         if (!areListenerOptionsEqual(committedRef.current, options)) {
-            update(context, options);
+            // Normalize to a full soft-option set so a field dropped since the
+            // last render resets to its default: updateListenerOptions is
+            // partial-merge, but the React path is declarative (see
+            // fillListenerUpdateDefaults). Carry `signal` through only when
+            // present (matching the old whole-options pass), so its abort wiring
+            // is rebound/cleared exactly as before; `context` is passed
+            // separately and not read from the options object.
+            update(context, Object.assign(Object.assign({}, fillListenerUpdateDefaults(options)), ((options === null || options === void 0 ? void 0 : options.signal) !== undefined
+                ? { signal: options.signal }
+                : {})));
         }
         committedRef.current = options;
     });

package/dist/react/useStoreSelector.js

@@ -122,6 +122,15 @@ export function useStoreSelector(store, arg2, arg3, arg4) {
         };
     }, [store, selector, equalityFn, deps, inst]);
     const subscribe = useCallback((onStoreChange) => {
+        // subscribe can run (during commit) for an already-destroyed store
+        // — e.g. a provider torn down before this component mounts, or a
+        // `store` change re-running subscribe. control() reaches the
+        // destroyed control bus's addListener, which throws "EventBus is
+        // destroyed" out of render. Skip subscribing and hand back a no-op
+        // cleanup; getSelection already reads destroyed stores safely.
+        if (store.isDestroyed()) {
+            return () => { };
+        }
         const listener = (names) => {
             const currentDeps = depsRef.current;
             if (currentDeps

package/dist/react/useStoreState.js

@@ -1,6 +1,15 @@
 import { useCallback, useSyncExternalStore } from "react";
 export function useStoreState(store, key) {
     const subscribe = useCallback((onStoreChange) => {
+        // subscribe can run (during commit) for a store that was already
+        // destroyed — e.g. a provider torn down before this component
+        // mounts, or a `key`/`store` change re-running subscribe. onChange
+        // reaches the destroyed changes event's addListener, which throws
+        // "Event is destroyed" out of render. Skip subscribing and hand back
+        // a no-op cleanup; getSnapshot already reads destroyed stores safely.
+        if (store.isDestroyed()) {
+            return () => { };
+        }
         const listener = () => {
             onStoreChange();
         };

package/dist/store.js

@@ -80,13 +80,20 @@ export function createStore(initialData = {}) {
         }
         return true;
     };
-    const _set = (name, value, triggerChange = true) => {
+    const _set = (name, value, triggerChange = true, runBeforeChange = true) => {
         var _a, _b, _c, _d, _e;
         const prev = data.get(name);
         if (prev !== value) {
-            const beforeChangeResults = control.all(BeforeChangeEventName, name, value);
-            if (beforeChangeResults.some((result) => result === false)) {
-                return;
+            // A computed recompute skips the beforeChange veto (runBeforeChange
+            // false): the initial computed seed() bypasses beforeChange for the
+            // same reason, so allowing a veto here would leave the derived value
+            // stale and no longer equal to fn(deps) — internally inconsistent
+            // with the seeded value. beforeChange still gates ordinary sets.
+            if (runBeforeChange) {
+                const beforeChangeResults = control.all(BeforeChangeEventName, name, value);
+                if (beforeChangeResults.some((result) => result === false)) {
+                    return;
+                }
             }
             const pipeArgs = [value];
             let newValue;
@@ -199,6 +206,22 @@ export function createStore(initialData = {}) {
         return false;
     };
     function asyncSet(name, value) {
+        // Validate computed keys synchronously, mirroring set(). Deferring the
+        // check to the timer callback would turn a misuse into an uncaught
+        // exception escaping the timer (crashing Node / surfacing as an uncaught
+        // browser error) instead of a catchable throw at the call site.
+        if (typeof name === "string") {
+            if (computedKeys.has(name)) {
+                throw new Error(`Cannot set computed property "${name}"`);
+            }
+        }
+        else if (typeof name === "object" && name !== null) {
+            for (const k of Object.keys(name)) {
+                if (computedKeys.has(k)) {
+                    throw new Error(`Cannot set computed property "${k}"`);
+                }
+            }
+        }
         const timer = setTimeout(() => {
             pendingTimers.delete(timer);
             // The store may have been destroyed between scheduling and firing.
@@ -214,12 +237,14 @@ export function createStore(initialData = {}) {
         }, 0);
         pendingTimers.add(timer);
     }
-    // Replay a coalesced change log: one onChange per key, keeping the first
-    // entry's pre-cascade `prev` and the last entry's settled `value`, dropping
-    // keys whose net value is unchanged. Mirrors batch()'s replay (including its
-    // store-change error routing) so a computed touched several times during a
-    // cascade emits a single, internally-consistent onChange.
-    const replayCoalescedChanges = (log, hasCallbackError, callbackError) => {
+    // Coalesce a change log per key and replay it as one onChange each, keeping
+    // the first entry's pre-cascade `prev` and the last entry's settled `value`
+    // and dropping keys whose net value is unchanged. Store-change errors route
+    // to the error event; an unhandled one propagates unless the surrounding
+    // callback already failed (`hasCallbackError`), in which case it is swallowed
+    // so the original callback error is the one that ultimately surfaces. Shared
+    // by batch() and the single-set cascade wrapper so both coalesce identically.
+    const replayCoalescedLog = (log, hasCallbackError) => {
         var _a;
         const coalesced = new Map();
         for (const [propName, value, prev] of log) {
@@ -260,6 +285,11 @@ export function createStore(initialData = {}) {
                 throw error;
             }
         }
+    };
+    // Replay a coalesced cascade log and, if the driving callback failed, rethrow
+    // its error last (after every surviving onChange has fired).
+    const replayCoalescedChanges = (log, hasCallbackError, callbackError) => {
+        replayCoalescedLog(log, hasCallbackError);
         if (hasCallbackError) {
             throw callbackError;
         }
@@ -461,7 +491,7 @@ export function createStore(initialData = {}) {
     };
     let batching = false;
     const batch = (fn) => {
-        var _a, _b;
+        var _a;
         if (batching) {
             throw new Error("Nested batch() calls are not supported");
         }
@@ -498,48 +528,10 @@ export function createStore(initialData = {}) {
         // Coalesce the log per key before replaying: a key written multiple
         // times in the batch (e.g. a computed recomputing once per base-key
         // write) must fire onChange once with its final value, not once per
-        // intermediate value. Keep first-occurrence order, the pre-batch `prev`
-        // from the first entry, and the final `value` from the last entry; drop
-        // keys whose net value is unchanged from before the batch.
-        const coalesced = new Map();
-        for (const [propName, value, prev] of log) {
-            const existing = coalesced.get(propName);
-            if (existing) {
-                existing.value = value;
-            }
-            else {
-                coalesced.set(propName, { value, prev });
-            }
-        }
-        for (const [propName, { value, prev }] of coalesced) {
-            if (value === prev) {
-                continue;
-            }
-            const changeArgs = [
-                value,
-                prev,
-            ];
-            try {
-                changes.trigger(propName, ...changeArgs);
-            }
-            catch (error) {
-                control.trigger(ErrorEventName, {
-                    error: error instanceof Error
-                        ? error
-                        : new Error(String(error)),
-                    args: changeArgs,
-                    type: "store-change",
-                    name: propName,
-                });
-                if ((_a = control.get(ErrorEventName)) === null || _a === void 0 ? void 0 : _a.hasListener()) {
-                    continue;
-                }
-                if (hasCallbackError) {
-                    continue;
-                }
-                throw error;
-            }
-        }
+        // intermediate value. Drop keys whose net value is unchanged from before
+        // the batch. The callback error (if any) is deferred and rethrown at the
+        // end so the partial-write control change event below still fires.
+        replayCoalescedLog(log, hasCallbackError);
         // Dedupe so the control change event lists each key once, matching the
         // non-batch path (which dedupes via `dedupe([name, ...effectKeys])`).
         // A computed touched by several base-key writes would otherwise repeat.
@@ -556,7 +548,7 @@ export function createStore(initialData = {}) {
                     args: [dedupedChangedKeys],
                     type: "store-control",
                 });
-                if ((_b = control.get(ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
+                if ((_a = control.get(ErrorEventName)) === null || _a === void 0 ? void 0 : _a.hasListener()) {
                     if (hasCallbackError) {
                         throw callbackError;
                     }
@@ -670,7 +662,10 @@ export function createStore(initialData = {}) {
             }
             computingKeys.add(key);
             try {
-                _set(key, fn(...depValues));
+                // runBeforeChange=false: a computed key is derived and must
+                // always hold fn(deps); a beforeChange veto here would strand a
+                // stale value (see _set and the seed() rationale).
+                _set(key, fn(...depValues), true, false);
             }
             finally {
                 computingKeys.delete(key);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kuindji/reactive",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "author": "Ivan Kuindzhi",
     "type": "module",
     "repository": {