sibujs 1.4.0 → 2.0.0

package/dist/patterns.cjs

@@ -50,12 +50,12 @@ function isDev() {
 var _isDev = isDev();
 function devAssert(condition, message) {
   if (_isDev && !condition) {
-    throw new Error(`[Sibu] ${message}`);
+    throw new Error(`[SibuJS] ${message}`);
   }
 }
 function devWarn(message) {
   if (_isDev) {
-    console.warn(`[Sibu] ${message}`);
+    console.warn(`[SibuJS] ${message}`);
   }
 }
 
@@ -65,11 +65,11 @@ var subscriberStack = new Array(32);
 var stackCapacity = 32;
 var stackTop = -1;
 var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
 var SUBS = "__s";
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
 function safeInvoke(sub) {
   try {
     sub();
@@ -78,6 +78,15 @@ function safeInvoke(sub) {
   }
 }
 var trackingSuspended = false;
+function retrack(effectFn, subscriber) {
+  const prev = currentSubscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
 function track(effectFn, subscriber) {
   if (!subscriber) subscriber = effectFn;
   cleanup(subscriber);
@@ -116,7 +125,6 @@ function recordDependency(signal2) {
   let subs = signal2[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal2, subs);
     signal2[SUBS] = subs;
   }
   subs.add(currentSubscriber);
@@ -126,42 +134,83 @@ function recordDependency(signal2) {
     signal2.__f = void 0;
   }
 }
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+var maxDrainIterations = 1e5;
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      if (i >= maxDrainIterations) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
+      safeInvoke(pendingQueue[i]);
+      i++;
+    }
+  } finally {
+    notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
+  }
+}
 function propagateDirty(sub) {
   sub();
-  let sig = sub._sig;
-  while (sig) {
+  const rootSig = sub._sig;
+  if (!rootSig) return;
+  const stack = propagateStack;
+  const baseLen = stack.length;
+  stack.push(rootSig);
+  while (stack.length > baseLen) {
+    const sig = stack.pop();
     const first = sig.__f;
     if (first) {
       if (first._c) {
         const nSig = first._sig;
-        nSig._d = true;
-        sig = nSig;
-        continue;
-      }
-      if (!pendingSet.has(first)) {
+        if (!nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        }
+      } else if (!pendingSet.has(first)) {
         pendingSet.add(first);
         pendingQueue.push(first);
       }
-      break;
+      continue;
     }
     const subs = sig[SUBS];
-    if (!subs) break;
-    let nextSig;
+    if (!subs) continue;
     for (const s of subs) {
       if (s._c) {
-        s();
         const nSig = s._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s);
+        if (nSig && !nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        } else if (!nSig) {
+          s();
         }
       } else if (!pendingSet.has(s)) {
         pendingSet.add(s);
         pendingQueue.push(s);
       }
     }
-    sig = nextSig;
   }
 }
 function notifySubscribers(signal2) {
@@ -185,13 +234,23 @@ function notifySubscribers(signal2) {
       }
       let i = 0;
       while (i < pendingQueue.length) {
+        if (i >= maxDrainIterations) {
+          if (typeof console !== "undefined") {
+            console.error(
+              `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+            );
+          }
+          break;
+        }
         safeInvoke(pendingQueue[i]);
         i++;
       }
     } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
       notifyDepth--;
+      if (notifyDepth === 0) {
+        pendingQueue.length = 0;
+        pendingSet.clear();
+      }
     }
     return;
   }
@@ -211,30 +270,48 @@ function notifySubscribers(signal2) {
   notifyDepth++;
   try {
     let directCount = 0;
+    let hasComputedSub = false;
     for (const sub of subs) {
+      if (sub._c) hasComputedSub = true;
       pendingQueue[directCount++] = sub;
     }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (pendingQueue[i2]._c) {
-        propagateDirty(pendingQueue[i2]);
+    if (!hasComputedSub) {
+      for (let i2 = 0; i2 < directCount; i2++) {
+        safeInvoke(pendingQueue[i2]);
       }
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (!pendingQueue[i2]._c) {
-        if (!pendingSet.has(pendingQueue[i2])) {
-          safeInvoke(pendingQueue[i2]);
+    } else {
+      for (let i2 = 0; i2 < directCount; i2++) {
+        if (pendingQueue[i2]._c) {
+          propagateDirty(pendingQueue[i2]);
+        }
+      }
+      for (let i2 = 0; i2 < directCount; i2++) {
+        const sub = pendingQueue[i2];
+        if (!sub._c && !pendingSet.has(sub)) {
+          pendingSet.add(sub);
+          safeInvoke(sub);
         }
       }
     }
     let i = directCount;
     while (i < pendingQueue.length) {
+      if (i - directCount >= maxDrainIterations) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
       safeInvoke(pendingQueue[i]);
       i++;
     }
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function cleanup(subscriber) {
@@ -245,7 +322,9 @@ function cleanup(subscriber) {
     if (subs) {
       subs.delete(subscriber);
       if (singleDep.__f === subscriber) {
-        singleDep.__f = void 0;
+        singleDep.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && singleDep.__f === void 0) {
+        singleDep.__f = subs.values().next().value;
       }
     }
     sub._dep = void 0;
@@ -258,7 +337,9 @@ function cleanup(subscriber) {
     if (subs) {
       subs.delete(subscriber);
       if (signal2.__f === subscriber) {
-        signal2.__f = void 0;
+        signal2.__f = subs.size === 1 ? subs.values().next().value : void 0;
+      } else if (subs.size === 1 && signal2.__f === void 0) {
+        signal2.__f = subs.values().next().value;
       }
     }
   }
@@ -268,11 +349,32 @@ function cleanup(subscriber) {
 // src/reactivity/batch.ts
 var batchDepth = 0;
 var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
 function enqueueBatchedSignal(signal2) {
   if (batchDepth === 0) return false;
   pendingSignals.add(signal2);
   return true;
 }
+function flushBatch() {
+  try {
+    for (const signal2 of pendingSignals) {
+      queueSignalNotification(signal2);
+    }
+  } finally {
+    pendingSignals.clear();
+  }
+  drainNotificationQueue();
+}
 
 // src/core/signals/signal.ts
 var _g = globalThis;
@@ -375,9 +477,28 @@ function machine(config) {
 }
 
 // src/core/ssr-context.ts
-var ssrMode = false;
+var als = null;
+try {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const req = Function("return typeof require==='function'?require:null")();
+    if (req) {
+      const mod = req("node:async_hooks");
+      als = new mod.AsyncLocalStorage();
+    }
+  }
+} catch {
+  als = null;
+}
+var fallbackStore = { ssr: false, suspenseIdCounter: 0 };
+function getSSRStore() {
+  if (als) {
+    const s = als.getStore();
+    if (s) return s;
+  }
+  return fallbackStore;
+}
 function isSSR() {
-  return ssrMode;
+  return getSSRStore().ssr;
 }
 
 // src/core/signals/effect.ts
@@ -387,26 +508,86 @@ function effect(effectFn, options) {
   if (isSSR()) return () => {
   };
   const onError = options?.onError;
+  let userCleanups = [];
+  const onCleanup = (fn) => {
+    userCleanups.push(fn);
+  };
+  const runUserCleanups = () => {
+    if (userCleanups.length === 0) return;
+    const list = userCleanups;
+    userCleanups = [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      try {
+        list[i]();
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS effect] onCleanup threw:", err);
+        }
+      }
+    }
+  };
+  const invokeBody = () => effectFn(onCleanup);
   const wrappedFn = onError ? () => {
     try {
-      effectFn();
+      invokeBody();
     } catch (err) {
       onError(err);
     }
-  } : effectFn;
+  } : invokeBody;
   let cleanupHandle = () => {
   };
+  let running = false;
   const subscriber = () => {
-    cleanupHandle();
-    cleanupHandle = track(wrappedFn, subscriber);
+    if (running) {
+      if (_g2.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+        console.warn(
+          "[SibuJS] effect re-entered itself while running \u2014 the triggering update will be ignored. Wrap mutual writes in `batch()` or split the effect to avoid this."
+        );
+      }
+      return;
+    }
+    running = true;
+    try {
+      runUserCleanups();
+      cleanupHandle();
+      cleanupHandle = track(wrappedFn, subscriber);
+    } finally {
+      running = false;
+    }
   };
-  cleanupHandle = track(wrappedFn, subscriber);
+  running = true;
+  try {
+    cleanupHandle = track(wrappedFn, subscriber);
+  } finally {
+    running = false;
+  }
   const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });
+  let disposed = false;
   return () => {
+    if (disposed) return;
+    disposed = true;
     const h = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) h.emit("effect:destroy", { effectFn });
-    cleanupHandle();
+    if (h) {
+      try {
+        h.emit("effect:destroy", { effectFn });
+      } catch {
+      }
+    }
+    try {
+      runUserCleanups();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+      }
+    }
+    try {
+      cleanupHandle();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] dispose threw:", err);
+      }
+    }
   };
 }
 
@@ -414,7 +595,11 @@ function effect(effectFn, options) {
 function persisted(key, initial, options = {}) {
   const storage = options.session ? sessionStorage : localStorage;
   const serialize = options.serialize || JSON.stringify;
-  const deserialize = options.deserialize || JSON.parse;
+  const safeReviver = (k, v) => {
+    if (k === "__proto__" || k === "constructor" || k === "prototype") return void 0;
+    return v;
+  };
+  const deserialize = options.deserialize || ((raw) => JSON.parse(raw, safeReviver));
   const encrypt = options.encrypt;
   const decrypt = options.decrypt;
   const syncTabs = options.session ? false : options.syncTabs ?? true;
@@ -430,7 +615,7 @@ function persisted(key, initial, options = {}) {
   }
   const [value, setValue] = signal(restored);
   let applyingFromStorage = false;
-  effect(() => {
+  const stopPersistEffect = effect(() => {
     const current = value();
     if (applyingFromStorage) return;
     try {
@@ -470,6 +655,7 @@ function persisted(key, initial, options = {}) {
     window.addEventListener("storage", storageListener);
   }
   const dispose = () => {
+    stopPersistEffect();
     if (storageListener && typeof window !== "undefined") {
       window.removeEventListener("storage", storageListener);
       storageListener = null;
@@ -487,68 +673,151 @@ function persisted(key, initial, options = {}) {
 // src/patterns/optimistic.ts
 function optimistic(initialValue) {
   const [value, setValue] = signal(initialValue);
-  const [_pending, setPending] = signal(false);
-  async function addOptimistic(optimisticValue, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  async function update(optimisticValue, asyncAction) {
+    const myVersion = ++version;
     const previousValue = value();
     setValue(optimisticValue);
+    inflightCount++;
     setPending(true);
     try {
       const result = await asyncAction();
-      setValue(result);
+      if (version === myVersion) {
+        setValue(result);
+      }
     } catch {
-      setValue(previousValue);
+      if (version === myVersion) {
+        setValue(previousValue);
+      }
     } finally {
-      setPending(false);
+      inflightCount--;
+      if (inflightCount === 0) setPending(false);
     }
   }
-  return [value, addOptimistic];
+  return { value, pending, update };
 }
 function optimisticList(initialValue) {
   const [items, setItems] = signal([...initialValue]);
-  async function addOptimistic(item, asyncAction) {
+  const [pending, setPending] = signal(false);
+  let inflightCount = 0;
+  let version = 0;
+  let tempIdCounter = 0;
+  const itemIds = /* @__PURE__ */ new WeakMap();
+  const idToItem = /* @__PURE__ */ new Map();
+  function tagItem(item) {
+    const id = ++tempIdCounter;
+    if (item !== null && typeof item === "object") {
+      itemIds.set(item, id);
+    }
+    idToItem.set(id, item);
+    return id;
+  }
+  function findIndexById(list, id) {
+    for (let i = 0; i < list.length; i++) {
+      const it = list[i];
+      if (it !== null && typeof it === "object" && itemIds.get(it) === id) {
+        return i;
+      }
+      if (Object.is(it, idToItem.get(id))) return i;
+    }
+    return -1;
+  }
+  function begin() {
+    const v = ++version;
+    inflightCount++;
+    setPending(true);
+    return v;
+  }
+  function end(myVersion, revertFn) {
+    if (revertFn && version === myVersion) {
+      revertFn();
+    }
+    inflightCount--;
+    if (inflightCount === 0) setPending(false);
+  }
+  async function add(item, asyncAction) {
     const prev = items();
+    const id = tagItem(item);
     setItems([...prev, item]);
+    const myVersion = begin();
     try {
       const result = await asyncAction();
       setItems((current) => {
-        const idx = current.lastIndexOf(item);
+        const idx = findIndexById(current, id);
         if (idx >= 0) {
           const next = [...current];
           next[idx] = result;
           return next;
         }
-        return [...current.filter((i) => i !== item), result];
+        return [...current, result];
       });
+      idToItem.delete(id);
+      end(myVersion);
     } catch {
-      setItems(prev);
+      idToItem.delete(id);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function removeOptimistic(predicate, asyncAction) {
+  async function remove(predicate, asyncAction) {
     const prev = items();
     setItems(prev.filter((item) => !predicate(item)));
+    const myVersion = begin();
     try {
       await asyncAction();
+      end(myVersion);
     } catch {
-      setItems(prev);
+      end(myVersion, () => setItems(prev));
     }
   }
-  async function updateOptimistic(predicate, update, asyncAction) {
+  async function updateItem(predicate, patch, asyncAction) {
     const prev = items();
-    setItems(prev.map((item) => predicate(item) ? { ...item, ...update } : item));
+    const patchedIds = [];
+    setItems(
+      prev.map((item) => {
+        if (predicate(item)) {
+          const patched = { ...item, ...patch };
+          const id = tagItem(patched);
+          patchedIds.push(id);
+          return patched;
+        }
+        return item;
+      })
+    );
+    const myVersion = begin();
     try {
       const result = await asyncAction();
-      setItems((current) => current.map((item) => predicate(item) ? result : item));
+      setItems(
+        (current) => current.map((item) => {
+          if (item !== null && typeof item === "object") {
+            const existingId = itemIds.get(item);
+            if (existingId !== void 0 && patchedIds.includes(existingId)) return result;
+          }
+          return item;
+        })
+      );
+      for (const id of patchedIds) idToItem.delete(id);
+      end(myVersion);
     } catch {
-      setItems(prev);
+      for (const id of patchedIds) idToItem.delete(id);
+      end(myVersion, () => setItems(prev));
     }
   }
-  return { items, addOptimistic, removeOptimistic, updateOptimistic };
+  return {
+    items,
+    pending,
+    add,
+    remove,
+    update: updateItem
+  };
 }
 
 // src/core/signals/derived.ts
 function derived(getter, options) {
   devAssert(typeof getter === "function", "derived: argument must be a getter function.");
   const debugName = options?.name;
+  const equals = options?.equals;
   const cs = {};
   cs._d = false;
   cs._g = getter;
@@ -559,25 +828,56 @@ function derived(getter, options) {
   markDirty._c = 1;
   markDirty._sig = cs;
   track(() => {
-    cs._d = false;
-    cs._v = getter();
+    let threw = true;
+    try {
+      cs._v = getter();
+      cs._d = false;
+      threw = false;
+    } finally {
+      if (threw) cs._d = true;
+    }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  let evaluating = false;
   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 (trackingSuspended) {
       if (cs._d) {
-        cs._d = false;
-        cs._v = getter();
+        evaluating = true;
+        let threw = true;
+        try {
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
+        } finally {
+          evaluating = false;
+          if (threw) cs._d = true;
+        }
       }
       return cs._v;
     }
     recordDependency(cs);
     if (cs._d) {
       const oldValue = cs._v;
-      track(() => {
-        cs._d = false;
-        cs._v = getter();
-      }, markDirty);
+      evaluating = true;
+      let threw = true;
+      try {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
+          cs._d = false;
+          threw = false;
+        }, markDirty);
+      } finally {
+        evaluating = false;
+        if (threw) cs._d = true;
+      }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
       }
@@ -608,14 +908,16 @@ function timeline(initial, maxHistory = 100) {
     const idx = index();
     const newHistory = hist.slice(0, idx + 1);
     newHistory.push(newValue);
-    if (newHistory.length > maxHistory) {
-      newHistory.shift();
-      setHistory(newHistory);
-      setIndex(newHistory.length - 1);
-    } else {
-      setHistory(newHistory);
-      setIndex(idx + 1);
-    }
+    batch(() => {
+      if (newHistory.length > maxHistory) {
+        newHistory.shift();
+        setHistory(newHistory);
+        setIndex(newHistory.length - 1);
+      } else {
+        setHistory(newHistory);
+        setIndex(idx + 1);
+      }
+    });
   }
   function undo() {
     if (canUndo()) {
@@ -628,8 +930,10 @@ function timeline(initial, maxHistory = 100) {
     }
   }
   function reset() {
-    setHistory([initial]);
-    setIndex(0);
+    batch(() => {
+      setHistory([initial]);
+      setIndex(0);
+    });
   }
   function jumpTo(targetIndex) {
     const hist = history();
@@ -641,8 +945,37 @@ function timeline(initial, maxHistory = 100) {
 }
 
 // src/patterns/globalStore.ts
+function deepClone(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const clone = (v) => {
+    if (v === null || typeof v !== "object") return v;
+    if (seen.has(v)) throw new Error("deepClone: circular reference");
+    seen.add(v);
+    if (v instanceof Date) return new Date(v.getTime());
+    if (v instanceof Map) {
+      const out2 = /* @__PURE__ */ new Map();
+      for (const [k, val] of v) out2.set(clone(k), clone(val));
+      return out2;
+    }
+    if (v instanceof Set) {
+      const out2 = /* @__PURE__ */ new Set();
+      for (const val of v) out2.add(clone(val));
+      return out2;
+    }
+    if (Array.isArray(v)) return v.map(clone);
+    const out = {};
+    for (const k of Object.keys(v)) {
+      out[k] = clone(v[k]);
+    }
+    return out;
+  };
+  return clone(value);
+}
 function globalStore(config) {
-  const initialState = { ...config.state };
+  const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
   const listeners = /* @__PURE__ */ new Set();
   const middlewares = config.middleware || [];