sibujs 4.5.0 → 4.7.0

package/dist/{chunk-VZKNK2V7.js → chunk-XZR4PXRE.js}

@@ -4,25 +4,42 @@ import {
 } from "./chunk-H3SRKIYX.js";
 import {
   derived
-} from "./chunk-RBTPLM32.js";
+} from "./chunk-RUSSKG6G.js";
 import {
   effect
-} from "./chunk-RIXRAYIU.js";
+} from "./chunk-WEQ3DMVL.js";
 import {
   batch,
   signal
-} from "./chunk-XZZOBQAY.js";
+} from "./chunk-FQRUXCEE.js";
+import {
+  DEV,
+  devWarn,
+  reportError
+} from "./chunk-NYNYSPK7.js";
 
 // src/patterns/machine.ts
 function machine(config) {
   const [state, 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 = state();
+  function step(event) {
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return;
     const transition = stateDef.on[event];
@@ -37,28 +54,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 state() === s;
   }
   function can(event) {
-    const currentState = state();
-    const stateDef = config.states[currentState];
+    const currentState2 = state();
+    const stateDef = config.states[currentState2];
     if (!stateDef?.on) return false;
     const transition = stateDef.on[event];
     if (!transition) return false;
@@ -441,6 +481,9 @@ function optimisticList(initialValue) {
 
 // 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()]);
@@ -495,6 +538,120 @@ function timeline(initial, maxHistory = 100) {
   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 state = "invoking";
+  let nativeTarget;
+  const waiters = [];
+  const transition = (next) => {
+    state = 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 && state === "invoking") transition("pending");
+    });
+  };
+  invokeLater(value, then);
+  const probe = (onRejected, onOpen) => {
+    const decide = () => {
+      if (state === "native") probeNative(nativeTarget, onRejected, onOpen);
+      else (state === "rejected" ? onRejected : onOpen)();
+    };
+    if (state === "native") probeNative(nativeTarget, onRejected, onOpen);
+    else if (state === "invoking") waiters.push(decide);
+    else queueMicrotask(state === "rejected" ? onRejected : onOpen);
+  };
+  return { promise, failedEarly: false, probe };
+}
+
 // src/patterns/globalStore.ts
 function deepClone(value) {
   if (typeof structuredClone === "function") {
@@ -529,8 +686,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(state) {
+    if (subscriptions.size === 0) return;
+    for (const subscription of Array.from(subscriptions.values())) {
+      if (!subscription.active) continue;
+      try {
+        subscription.callback(state);
+      } 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)}`);
@@ -539,38 +739,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 };
 }