sibujs 1.5.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;
@@ -518,6 +703,27 @@ function optimisticList(initialValue) {
   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++;
@@ -533,12 +739,13 @@ function optimisticList(initialValue) {
   }
   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;
@@ -546,8 +753,10 @@ function optimisticList(initialValue) {
         }
         return [...current, result];
       });
+      idToItem.delete(id);
       end(myVersion);
     } catch {
+      idToItem.delete(id);
       end(myVersion, () => setItems(prev));
     }
   }
@@ -564,12 +773,13 @@ function optimisticList(initialValue) {
   }
   async function updateItem(predicate, patch, asyncAction) {
     const prev = items();
-    const patchedRefs = [];
+    const patchedIds = [];
     setItems(
       prev.map((item) => {
         if (predicate(item)) {
           const patched = { ...item, ...patch };
-          patchedRefs.push(patched);
+          const id = tagItem(patched);
+          patchedIds.push(id);
           return patched;
         }
         return item;
@@ -578,9 +788,19 @@ function optimisticList(initialValue) {
     const myVersion = begin();
     try {
       const result = await asyncAction();
-      setItems((current) => current.map((item) => patchedRefs.includes(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 {
+      for (const id of patchedIds) idToItem.delete(id);
       end(myVersion, () => setItems(prev));
     }
   }
@@ -589,10 +809,7 @@ function optimisticList(initialValue) {
     pending,
     add,
     remove,
-    update: updateItem,
-    addOptimistic: add,
-    removeOptimistic: remove,
-    updateOptimistic: updateItem
+    update: updateItem
   };
 }
 
@@ -600,6 +817,7 @@ function optimisticList(initialValue) {
 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;
@@ -610,8 +828,14 @@ 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;
@@ -624,11 +848,16 @@ function derived(getter, options) {
     if (trackingSuspended) {
       if (cs._d) {
         evaluating = true;
+        let threw = true;
         try {
-          cs._d = false;
-          cs._v = getter();
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
         } finally {
           evaluating = false;
+          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -637,13 +866,17 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
+      let threw = true;
       try {
-        track(() => {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
           cs._d = false;
-          cs._v = getter();
+          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 });
@@ -675,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()) {
@@ -695,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();
@@ -708,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 = JSON.parse(JSON.stringify(config.state));
+  const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
   const listeners = /* @__PURE__ */ new Set();
   const middlewares = config.middleware || [];

package/dist/patterns.d.cts

@@ -71,19 +71,24 @@ interface PersistOptions<T = unknown> {
      *  - use XOR with a static key — trivially reversible
      *  - roll your own cipher — nearly always broken
      *
+     * **Sync only:** because `persisted()` exposes synchronous getters and
+     * setters, both `encrypt` and `decrypt` must be SYNCHRONOUS. Async
+     * crypto (e.g. `crypto.subtle.encrypt`) is NOT supported here — derive
+     * keys ahead of time and use a sync wrapper, or pre/post-process the
+     * value yourself before/after `setValue`.
+     *
      * @example
      * ```ts
+     * // Pre-derived key + sync wrapper
      * persisted("token", "", {
-     *   encrypt: async (v) => aesGcmEncrypt(v, await getKey()),
-     *   decrypt: async (v) => aesGcmDecrypt(v, await getKey()),
+     *   encrypt: (v) => syncAesGcmEncrypt(v, derivedKey),
+     *   decrypt: (v) => syncAesGcmDecrypt(v, derivedKey),
      * });
      * ```
-     *
-     * Note that because localStorage is synchronous, any real AES-GCM
-     * flow needs pre-derived keys and is inherently best-effort.
      */
     encrypt?: (value: string) => string;
-    /** Decrypt the stored value before deserialization. Required if `encrypt` is set. */
+    /** Decrypt the stored value before deserialization. Required if `encrypt` is set.
+     *  Must be synchronous — see `encrypt` docs. */
     decrypt?: (value: string) => string;
 }
 declare function persisted<T>(key: string, initial: T, options?: PersistOptions<T>): [() => T, (next: T | ((prev: T) => T)) => void];
@@ -141,12 +146,6 @@ declare function optimisticList<T>(initialValue: T[]): {
     add: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
     remove: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
     update: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
-    /** @deprecated Use `add` instead */
-    addOptimistic: (item: T, asyncAction: () => Promise<T>) => Promise<void>;
-    /** @deprecated Use `remove` instead */
-    removeOptimistic: (predicate: (item: T) => boolean, asyncAction: () => Promise<void>) => Promise<void>;
-    /** @deprecated Use `update` instead */
-    updateOptimistic: (predicate: (item: T) => boolean, patch: Partial<T>, asyncAction: () => Promise<T>) => Promise<void>;
 };
 
 interface TimeTravelReturn<T> {