sibujs 4.4.0 → 4.6.0

package/dist/patterns.cjs

@@ -147,6 +147,25 @@ function reportError(error, context) {
   });
 }
 
+// src/core/rendering/dispose.ts
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
+
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
@@ -294,8 +313,18 @@ function untracked(fn) {
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
+  let savedDepth = 0;
+  let savedSuspendSub = null;
+  if (trackingSuspended) {
+    savedDepth = suspendDepth;
+    savedSuspendSub = suspendSavedSub;
+    suspendDepth = 0;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
   currentSubscriber = subscriber;
   const sub = subscriber;
+  if (sub._cap === void 0) sub._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub._epoch = epoch;
   sub._structDirty = false;
@@ -308,6 +337,11 @@ function retrack(effectFn, subscriber) {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    if (savedDepth !== 0) {
+      suspendDepth = savedDepth;
+      suspendSavedSub = savedSuspendSub;
+      trackingSuspended = true;
+    }
     let node = sub.depsHead ?? null;
     while (node !== null) {
       const next = node.subNext;
@@ -327,11 +361,25 @@ function track(effectFn, subscriber) {
   if (!subscriber) return reactiveBinding(effectFn);
   cleanup(subscriber);
   const prev = currentSubscriber;
+  let savedDepth = 0;
+  let savedSuspendSub = null;
+  if (trackingSuspended) {
+    savedDepth = suspendDepth;
+    savedSuspendSub = suspendSavedSub;
+    suspendDepth = 0;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
   currentSubscriber = subscriber;
   try {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    if (savedDepth !== 0) {
+      suspendDepth = savedDepth;
+      suspendSavedSub = savedSuspendSub;
+      trackingSuspended = true;
+    }
     const sub2 = subscriber;
     for (let n = sub2.depsHead ?? null; n !== null; n = n.subNext) {
       const sig = n.sig;
@@ -468,7 +516,12 @@ function drainQueue() {
       quarantined.add(sub);
       continue;
     }
-    safeInvoke(sub);
+    const pushed = beginDisposerCapture(sub._cap ?? null);
+    try {
+      safeInvoke(sub);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -502,8 +555,9 @@ function propagateDirty(sub) {
         if (s._c) {
           const nSig = s._sig;
           if (nSig) {
-            if (!nSig._d) {
+            if (!nSig._d || nSig._f === true) {
               nSig._d = true;
+              nSig._f = false;
               stack.push(nSig);
             }
           } else {
@@ -603,7 +657,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.4.0" : "dev";
+var _runtimeVersion = true ? "4.6.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -797,12 +851,24 @@ function stripUnsafeKeys(obj) {
 function machine(config) {
   const [state2, setState] = signal(config.initial);
   const [context, setContext] = signal(config.context || {});
-  const initialDef = config.states[config.initial];
-  if (initialDef?.entry) {
-    initialDef.entry(context());
+  let currentState = config.initial;
+  let currentContext = context();
+  const queue = [];
+  let processing = false;
+  function drain() {
+    processing = true;
+    try {
+      while (queue.length > 0) {
+        step(queue.shift());
+      }
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
+    }
   }
-  function send(event) {
-    const currentState = state2();
+  function step(event) {
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return;
     const transition = stateDef.on[event];
@@ -817,28 +883,51 @@ function machine(config) {
       guard = transition.guard;
       action = transition.action;
     }
-    const ctx = context();
+    const ctx = currentContext;
     if (guard && !guard(ctx)) return;
     if (stateDef.exit) {
       stateDef.exit(ctx);
     }
+    let nextContext = ctx;
     if (action) {
       const rawPatch = action(ctx);
-      const next = { ...ctx, ...stripUnsafeKeys(rawPatch) };
-      setContext(next);
+      nextContext = { ...ctx, ...stripUnsafeKeys(rawPatch) };
     }
-    setState(target);
+    currentState = target;
+    currentContext = nextContext;
+    batch(() => {
+      if (action) setContext(nextContext);
+      setState(target);
+    });
     const targetDef = config.states[target];
     if (targetDef?.entry) {
-      targetDef.entry(context());
+      targetDef.entry(currentContext);
     }
   }
+  function send(event) {
+    queue.push(event);
+    if (processing) return;
+    drain();
+  }
+  const initialDef = config.states[config.initial];
+  if (initialDef?.entry) {
+    processing = true;
+    try {
+      initialDef.entry(currentContext);
+    } catch (err) {
+      queue.length = 0;
+      throw err;
+    } finally {
+      processing = false;
+    }
+    if (queue.length > 0) drain();
+  }
   function matches(s) {
     return state2() === s;
   }
   function can(event) {
-    const currentState = state2();
-    const stateDef = config.states[currentState];
+    const currentState2 = state2();
+    const stateDef = config.states[currentState2];
     if (!stateDef?.on) return false;
     const transition = stateDef.on[event];
     if (!transition) return false;
@@ -1390,10 +1479,14 @@ function derived(getter, options) {
   const cs = {};
   cs._d = false;
   cs._init = false;
+  cs._f = false;
   cs._g = getter;
   cs.__v = 0;
+  let evaluating = false;
+  let disposed = false;
+  let pendingError;
   const markDirty = () => {
-    if (cs._d) return;
+    if (cs._d || disposed) return;
     cs._d = true;
   };
   markDirty._c = 1;
@@ -1416,33 +1509,53 @@ function derived(getter, options) {
     }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  let evaluating = false;
   const validate = () => {
-    if (!cs._d) return;
+    if (!cs._d || disposed || pendingError !== void 0) return;
     const oldValue = cs._v;
     evaluating = true;
     try {
       retrack2(recompute, markDirty);
       if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } catch (err) {
+      pendingError = { error: err };
+      cs.__v++;
+      if (disposed) cs._d = true;
+      else cs._f = true;
     } finally {
       evaluating = false;
+      if (disposed) cleanup2(markDirty);
     }
-    if (hook && !Object.is(oldValue, cs._v)) {
+    if (hook && !disposed && !Object.is(oldValue, cs._v)) {
       hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
     }
   };
   cs._validate = validate;
+  const throwPending = () => {
+    const { error } = pendingError;
+    pendingError = void 0;
+    if (disposed) cs._d = false;
+    throw error;
+  };
   function computedGetter() {
     if (evaluating) {
       throw new Error(
         `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
       );
     }
-    if (isTrackingSuspended2()) {
-      if (cs._d) validate();
+    if (isTrackingSuspended2() || disposed) {
+      if (cs._d) {
+        validate();
+        if (pendingError !== void 0) throwPending();
+      }
       return cs._v;
     }
-    if (cs._d) validate();
+    if (cs._d) {
+      validate();
+      if (pendingError !== void 0) {
+        recordDependency2(cs);
+        throwPending();
+      }
+    }
     recordDependency2(cs);
     return cs._v;
   }
@@ -1451,12 +1564,28 @@ function derived(getter, options) {
     cs.__name = debugName;
   }
   computedGetter.__signal = cs;
+  computedGetter.dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    cs._d = pendingError !== void 0;
+    cleanup2(markDirty);
+    const h = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (h) {
+      try {
+        h.emit("computed:destroy", { signal: cs, getter: computedGetter });
+      } catch {
+      }
+    }
+  };
   if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
   return computedGetter;
 }
 
 // src/patterns/timeTravel.ts
 function timeline(initial, maxHistory = 100) {
+  if (!Number.isSafeInteger(maxHistory) || maxHistory < 1) {
+    throw new RangeError(`[timeline] maxHistory must be a positive safe integer, got ${maxHistory}`);
+  }
   const [history, setHistory] = signal([initial]);
   const [index, setIndex] = signal(0);
   const value = derived(() => history()[index()]);
@@ -1503,7 +1632,126 @@ function timeline(initial, maxHistory = 100) {
       setIndex(targetIndex);
     }
   }
-  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo };
+  function dispose() {
+    value.dispose();
+    canUndo.dispose();
+    canRedo.dispose();
+  }
+  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo, dispose };
+}
+
+// src/utils/adoption.ts
+var nativeThen = Promise.prototype.then;
+function probeNative(target, onRejected, onOpen) {
+  let decided = false;
+  const decide = (rejected) => {
+    if (decided) return;
+    decided = true;
+    (rejected ? onRejected : onOpen)();
+  };
+  try {
+    Reflect.apply(nativeThen, target, [void 0, () => decide(true)]);
+  } catch {
+    queueMicrotask(() => decide(true));
+    return;
+  }
+  queueMicrotask(() => decide(false));
+}
+function adopt(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return {
+      promise: Promise.reject(error),
+      failedEarly: true,
+      probe: (onRejected) => queueMicrotask(onRejected)
+    };
+  }
+  if (typeof then !== "function") return null;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let state2 = "invoking";
+  let nativeTarget;
+  const waiters = [];
+  const transition = (next) => {
+    state2 = next;
+    if (next === "invoking") return;
+    for (const waiter of waiters.splice(0)) waiter();
+  };
+  const fulfil = (result) => {
+    resolvePromise(result);
+    transition("fulfilled");
+  };
+  const fail = (error) => {
+    rejectPromise(error);
+    transition("rejected");
+  };
+  const follow = (result) => {
+    if (result === promise) {
+      fail(new TypeError("adopt: a thenable resolved to its own adoption"));
+      return;
+    }
+    if (result === null || typeof result !== "object" && typeof result !== "function") {
+      fulfil(result);
+      return;
+    }
+    let nextThen;
+    try {
+      nextThen = result.then;
+    } catch (error) {
+      fail(error);
+      return;
+    }
+    if (typeof nextThen !== "function") {
+      fulfil(result);
+      return;
+    }
+    invokeLater(result, nextThen);
+  };
+  const invokeLater = (target, targetThen) => {
+    if (targetThen === nativeThen) {
+      nativeTarget = target;
+      transition("native");
+    } else {
+      transition("invoking");
+    }
+    queueMicrotask(() => {
+      let done = false;
+      const onResolve = (result) => {
+        if (done) return;
+        done = true;
+        follow(result);
+      };
+      const onReject = (error) => {
+        if (done) return;
+        done = true;
+        fail(error);
+      };
+      try {
+        Reflect.apply(targetThen, target, [onResolve, onReject]);
+      } catch (error) {
+        onReject(error);
+      }
+      if (!done && state2 === "invoking") transition("pending");
+    });
+  };
+  invokeLater(value, then);
+  const probe = (onRejected, onOpen) => {
+    const decide = () => {
+      if (state2 === "native") probeNative(nativeTarget, onRejected, onOpen);
+      else (state2 === "rejected" ? onRejected : onOpen)();
+    };
+    if (state2 === "native") probeNative(nativeTarget, onRejected, onOpen);
+    else if (state2 === "invoking") waiters.push(decide);
+    else queueMicrotask(state2 === "rejected" ? onRejected : onOpen);
+  };
+  return { promise, failedEarly: false, probe };
 }
 
 // src/patterns/globalStore.ts
@@ -1540,8 +1788,51 @@ function deepClone(value) {
 function globalStore(config) {
   const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
-  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Map();
   const middlewares = config.middleware || [];
+  function notifyListeners(state2) {
+    if (subscriptions.size === 0) return;
+    for (const subscription of Array.from(subscriptions.values())) {
+      if (!subscription.active) continue;
+      try {
+        subscription.callback(state2);
+      } catch (err) {
+        reportError(err, { phase: "event", name: "globalStore(subscribe)" });
+      }
+    }
+  }
+  const operations = [];
+  let running = false;
+  function perform(operation, rethrowOwn = true) {
+    operations.push(operation);
+    if (running) return;
+    running = true;
+    let callerError;
+    let callerFailed = false;
+    try {
+      let first = true;
+      let cursor = 0;
+      while (cursor < operations.length) {
+        const next = operations[cursor];
+        operations[cursor++] = void 0;
+        try {
+          next();
+        } catch (err) {
+          if (first && rethrowOwn) {
+            callerFailed = true;
+            callerError = err;
+          } else {
+            reportError(err, { phase: "event", name: "globalStore(dispatch)" });
+          }
+        }
+        first = false;
+      }
+    } finally {
+      operations.length = 0;
+      running = false;
+    }
+    if (callerFailed) throw callerError;
+  }
   function dispatch(action, payload) {
     const actionFn = config.actions[action];
     if (!actionFn) throw new Error(`Unknown action: ${String(action)}`);
@@ -1550,38 +1841,96 @@ function globalStore(config) {
       const rawPatch = actionFn(current, payload);
       const patch = stripUnsafeKeys(rawPatch);
       setState({ ...current, ...patch });
-      const newState = getState();
-      for (const listener of listeners) {
-        listener(newState);
-      }
+      notifyListeners(getState());
     };
-    if (middlewares.length === 0) {
-      execute();
-      return;
-    }
-    let index = 0;
-    const next = () => {
-      if (index < middlewares.length) {
-        const mw = middlewares[index++];
-        mw(getState(), String(action), payload, next);
-      } else {
+    perform(() => {
+      if (middlewares.length === 0) {
         execute();
+        return;
       }
-    };
-    next();
+      const runFrom = (index) => {
+        if (index >= middlewares.length) {
+          execute();
+          return;
+        }
+        let called = false;
+        let failed = false;
+        let synchronous = true;
+        const next = () => {
+          if (failed && !called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+            called = true;
+            return;
+          }
+          if (called) {
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called more than once for "${String(action)}"; ignored.`
+              );
+            return;
+          }
+          called = true;
+          if (synchronous) {
+            runFrom(index + 1);
+            return;
+          }
+          const proceed = () => perform(() => runFrom(index + 1), false);
+          if (!adoption) {
+            proceed();
+            return;
+          }
+          adoption.probe(() => {
+            failed = true;
+            if (DEV)
+              devWarn(
+                `globalStore: middleware ${index} next() called after it failed for "${String(action)}"; ignored.`
+              );
+          }, proceed);
+        };
+        let adoption = null;
+        try {
+          adoption = adopt(middlewares[index](getState(), String(action), payload, next));
+        } catch (err) {
+          failed = true;
+          throw err;
+        } finally {
+          synchronous = false;
+        }
+        if (adoption) {
+          if (adoption.failedEarly) failed = true;
+          adoption.promise.then(void 0, (err) => {
+            failed = true;
+            reportError(err, { phase: "async", name: "globalStore(middleware)" });
+          });
+        }
+      };
+      runFrom(0);
+    });
   }
   function select(selector) {
     return () => selector(getState());
   }
   function subscribe(callback) {
-    listeners.add(callback);
-    return () => listeners.delete(callback);
+    let subscription = subscriptions.get(callback);
+    if (!subscription) {
+      subscription = { callback, active: true };
+      subscriptions.set(callback, subscription);
+    }
+    const own = subscription;
+    return () => {
+      if (subscriptions.get(callback) !== own) return;
+      own.active = false;
+      subscriptions.delete(callback);
+    };
   }
   function reset() {
-    setState({ ...initialState });
-    for (const listener of listeners) {
-      listener(getState());
-    }
+    perform(() => {
+      setState({ ...initialState });
+      notifyListeners(getState());
+    });
   }
   return { getState, select, dispatch, subscribe, reset };
 }
@@ -1705,7 +2054,7 @@ function validateProps(props, schema) {
     const errors = [];
     for (const [key, def] of Object.entries(schema)) {
       const propDef = typeof def === "function" ? { type: def } : def;
-      if (result[key] == null && propDef.default !== void 0) {
+      if (result[key] === void 0 && propDef.default !== void 0) {
         result[key] = typeof propDef.default === "function" ? propDef.default() : propDef.default;
       }
       if (propDef.required && result[key] == null) {
@@ -1731,7 +2080,7 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   for (const [key, def] of Object.entries(schema)) {
     if (typeof def === "function") continue;
     const fallback = def.default;
-    if (result[key] == null && fallback !== void 0) {
+    if (result[key] === void 0 && fallback !== void 0) {
       result[key] = typeof fallback === "function" ? fallback() : fallback;
     }
   }

package/dist/patterns.d.cts

@@ -1,4 +1,4 @@
-export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, b as assertType, c as compose, d as createGuard, e as createSlots, f as defineComponent, g as defineSlottedComponent, h as defineStrictComponent, v as validateProps, i as validators, w as withBoundary, j as withDefaults, k as withProps, l as withWrapper } from './contracts-DBdg9J_a.cjs';
+export { C as ComponentProps, P as PropDef, a as PropSchema, R as RenderProp, V as Validator, W as WithDefaultsProps, b as assertType, c as compose, d as createGuard, e as createSlots, f as defineComponent, g as defineSlottedComponent, h as defineStrictComponent, v as validateProps, i as validators, w as withBoundary, j as withDefaults, k as withProps, l as withWrapper } from './contracts-DRIuclVT.cjs';
 
 interface MachineConfig<S extends string, E extends string, C extends object = Record<string, unknown>> {
     initial: S;
@@ -36,10 +36,10 @@ declare function machine<S extends string, E extends string, C extends object =
  * @param key Storage key
  * @param initial Default value when no persisted value exists
  * @param options Storage options
- * @returns The same `[getter, setter]` tuple as `signal()`. For localStorage
- *   (cross-tab sync on), the setter additionally carries a non-enumerable
- *   `dispose()` method — call `setter.dispose()` on unmount to remove the
- *   `storage` event listener; otherwise it lives for the page's lifetime.
+ * @returns The same `[getter, setter]` tuple as `signal()`. The setter also
+ *   carries a non-enumerable `dispose()` method — call `setter.dispose()` on
+ *   unmount to stop persisting and remove the cross-tab `storage` listener;
+ *   otherwise both live for the page's lifetime.
  *
  * @example
  * ```ts
@@ -94,15 +94,21 @@ interface PersistOptions<T = unknown> {
      *  Must be synchronous — see `encrypt` docs. */
     decrypt?: (value: string) => string;
 }
+/** Setter returned by {@link persisted}: writes like a `signal()` setter, released with `dispose()`. */
+type PersistedSetter<T> = ((next: T | ((prev: T) => T)) => void) & {
+    /** Stop persisting changes and remove the cross-tab `storage` listener. */
+    dispose(): void;
+};
 /**
  * A signal mirrored into persistent storage, rehydrated on creation.
  *
  * @param key Storage key.
  * @param initial Value used when storage holds nothing (or holds junk).
  * @param options Storage backend, serializer and version/migration settings.
- * @returns A `[accessor, setter]` pair with the same shape as `signal`.
+ * @returns A `[accessor, setter]` pair with the same shape as `signal`; the
+ *   setter carries `dispose()`.
  */
-declare function persisted<T>(key: string, initial: T, options?: PersistOptions<T>): [() => T, (next: T | ((prev: T) => T)) => void];
+declare function persisted<T>(key: string, initial: T, options?: PersistOptions<T>): [() => T, PersistedSetter<T>];
 
 /**
  * optimistic provides optimistic UI updates that can be reverted on failure.
@@ -202,13 +208,30 @@ interface TimeTravelReturn<T> {
     index: () => number;
     reset: () => void;
     jumpTo: (index: number) => void;
+    /**
+     * Dispose the internal `value`, `canUndo` and `canRedo` deriveds and remove
+     * them from DevTools. Afterwards they return their last values. Idempotent.
+     */
+    dispose: () => void;
 }
 /**
  * timeline wraps a state value with undo/redo history.
+ *
+ * @param maxHistory How many entries (including the current one) to keep. Must
+ *   be a positive safe integer — `0`, negative, fractional, `NaN` or infinite
+ *   capacities throw a `RangeError`, since they would evict the current value
+ *   and break the index invariant.
  */
 declare function timeline<T>(initial: T, maxHistory?: number): TimeTravelReturn<T>;
 
-type Middleware<S> = (state: S, action: string, payload: unknown, next: () => void) => void;
+/**
+ * Store middleware. Call `next()` once to continue the chain — synchronously or
+ * later (after an `await`, from a timer). A middleware may be `async`: a
+ * rejection is reported through the runtime error handler, and a middleware
+ * that fails (throws, or rejects) before calling `next()` never continues —
+ * a later `next()` from it is ignored.
+ */
+type Middleware<S> = (state: S, action: string, payload: unknown, next: () => void) => void | PromiseLike<void>;
 type Selector<S, R> = (state: S) => R;
 /**
  * Action-map constraint.
@@ -242,4 +265,4 @@ declare function globalStore<S extends object, A extends StoreActionMap<S>>(conf
     middleware?: Middleware<S>[];
 }): GlobalStore<S, A>;
 
-export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type PersistOptions, type Selector, type StoreActionMap, type TimeTravelReturn, globalStore, machine, optimistic, optimisticList, persisted, timeline };
+export { type GlobalStore, type MachineConfig, type MachineReturn, type Middleware, type PersistOptions, type PersistedSetter, type Selector, type StoreActionMap, type TimeTravelReturn, globalStore, machine, optimistic, optimisticList, persisted, timeline };