sibujs 1.5.0 → 2.0.0

package/dist/{chunk-VAPYJN4X.js → chunk-3LR7GLWQ.js}

@@ -1,12 +1,13 @@
 import {
   derived
-} from "./chunk-XHK6BDAJ.js";
+} from "./chunk-54EDRCEF.js";
 import {
   effect
-} from "./chunk-VQNQZCWJ.js";
+} from "./chunk-HB24TBAF.js";
 import {
+  batch,
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/patterns/machine.ts
 function machine(config) {
@@ -74,7 +75,11 @@ function machine(config) {
 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;
@@ -178,6 +183,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++;
@@ -193,12 +219,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;
@@ -206,8 +233,10 @@ function optimisticList(initialValue) {
         }
         return [...current, result];
       });
+      idToItem.delete(id);
       end(myVersion);
     } catch {
+      idToItem.delete(id);
       end(myVersion, () => setItems(prev));
     }
   }
@@ -224,12 +253,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;
@@ -238,9 +268,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));
     }
   }
@@ -249,10 +289,7 @@ function optimisticList(initialValue) {
     pending,
     add,
     remove,
-    update: updateItem,
-    addOptimistic: add,
-    removeOptimistic: remove,
-    updateOptimistic: updateItem
+    update: updateItem
   };
 }
 
@@ -271,14 +308,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()) {
@@ -291,8 +330,10 @@ function timeline(initial, maxHistory = 100) {
     }
   }
   function reset() {
-    setHistory([initial]);
-    setIndex(0);
+    batch(() => {
+      setHistory([initial]);
+      setIndex(0);
+    });
   }
   function jumpTo(targetIndex) {
     const hist = history();
@@ -304,8 +345,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/{chunk-RJ46C3CS.js → chunk-3NSGB5JN.js}

@@ -1,10 +1,10 @@
 import {
   effect
-} from "./chunk-VQNQZCWJ.js";
+} from "./chunk-HB24TBAF.js";
 import {
   batch,
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/browser/media.ts
 function media(query) {
@@ -399,7 +399,10 @@ function dropZone(element, options) {
         const raw = e.dataTransfer.getData("application/json");
         if (raw) {
           try {
-            transferData = JSON.parse(raw);
+            transferData = JSON.parse(
+              raw,
+              (k, v) => k === "__proto__" || k === "constructor" || k === "prototype" ? void 0 : v
+            );
           } catch {
             transferData = raw;
           }
@@ -779,13 +782,21 @@ function wakeLock() {
   }
   const onVisibility = () => {
     if (sentinel?.released && !document.hidden) {
-      void request();
+      request().catch((err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS wakeLock] re-acquire failed:", err);
+        }
+      });
     }
   };
   document.addEventListener("visibilitychange", onVisibility);
   function dispose() {
     document.removeEventListener("visibilitychange", onVisibility);
-    void release();
+    release().catch((err) => {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS wakeLock] release failed:", err);
+      }
+    });
   }
   return { active, request, release, dispose };
 }
@@ -981,11 +992,21 @@ function speech() {
     };
   }
   const synth = window.speechSynthesis;
-  const interval = setInterval(() => {
-    setSpeaking(synth.speaking);
-    setPaused(synth.paused);
-  }, 200);
+  let interval = null;
+  function startPolling() {
+    if (interval !== null) return;
+    interval = setInterval(() => {
+      setSpeaking(synth.speaking);
+      setPaused(synth.paused);
+      if (!synth.speaking && !synth.paused) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }, 200);
+  }
+  let disposed = false;
   function speak(text, options = {}) {
+    if (disposed) return;
     const u = new SpeechSynthesisUtterance(text);
     if (options.lang) u.lang = options.lang;
     if (options.rate != null) u.rate = options.rate;
@@ -996,19 +1017,41 @@ function speech() {
       const match = voices.find((v) => v.name === options.voice);
       if (match) u.voice = match;
     }
-    u.addEventListener("start", () => setSpeaking(true));
-    u.addEventListener("end", () => {
-      setSpeaking(false);
-      setPaused(false);
-    });
-    u.addEventListener("error", () => {
-      setSpeaking(false);
-      setPaused(false);
-    });
+    u.addEventListener(
+      "start",
+      () => {
+        if (!disposed) setSpeaking(true);
+      },
+      { once: true }
+    );
+    u.addEventListener(
+      "end",
+      () => {
+        if (disposed) return;
+        setSpeaking(false);
+        setPaused(false);
+      },
+      { once: true }
+    );
+    u.addEventListener(
+      "error",
+      () => {
+        if (disposed) return;
+        setSpeaking(false);
+        setPaused(false);
+      },
+      { once: true }
+    );
     synth.speak(u);
+    setSpeaking(true);
+    startPolling();
   }
   function dispose() {
-    clearInterval(interval);
+    disposed = true;
+    if (interval !== null) {
+      clearInterval(interval);
+      interval = null;
+    }
     synth.cancel();
   }
   return {
@@ -1237,13 +1280,21 @@ function imageLoader(src) {
     };
     img.src = url;
   }
+  let srcEffectTeardown = null;
   if (typeof src === "function") {
-    start(src());
+    srcEffectTeardown = effect(() => {
+      const url = src();
+      start(url);
+    });
   } else {
     start(src);
   }
   function dispose() {
     disposed = true;
+    if (srcEffectTeardown) {
+      srcEffectTeardown();
+      srcEffectTeardown = null;
+    }
     if (current) {
       current.onload = null;
       current.onerror = null;

package/dist/{chunk-XUEEGU5O.js → chunk-52YJLLRO.js}

@@ -1,6 +1,6 @@
 import {
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/ui/transition.ts
 function transition(element, options = {}) {
@@ -345,15 +345,24 @@ function springSignal(initial, options) {
   let velocity = 0;
   let target = initial;
   let rafId = null;
-  function tick() {
+  let lastTime = 0;
+  const REF_DT_MS = 1e3 / 60;
+  const MAX_STEP_RATIO = 4;
+  function tick(now) {
+    if (lastTime === 0) lastTime = now;
+    const rawDt = now - lastTime;
+    lastTime = now;
+    const dt = Number.isFinite(rawDt) && rawDt > 0 ? rawDt : REF_DT_MS;
+    const ratio = Math.min(MAX_STEP_RATIO, Math.max(0.1, dt / REF_DT_MS));
     const force = -stiffness * (current - target);
     const dampingForce = -damping * velocity;
-    velocity += force + dampingForce;
-    current += velocity;
+    velocity += (force + dampingForce) * ratio;
+    current += velocity * ratio;
     if (Math.abs(current - target) < precision && Math.abs(velocity) < precision) {
       current = target;
       velocity = 0;
       rafId = null;
+      lastTime = 0;
       setValue(current);
       return;
     }
@@ -369,10 +378,12 @@ function springSignal(initial, options) {
         cancelAnimationFrame(rafId);
         rafId = null;
       }
+      lastTime = 0;
       setValue(current);
       return;
     }
     if (rafId === null) {
+      lastTime = 0;
       rafId = requestAnimationFrame(tick);
     }
   }
@@ -381,6 +392,7 @@ function springSignal(initial, options) {
       cancelAnimationFrame(rafId);
       rafId = null;
     }
+    lastTime = 0;
   }
   return [value, set, dispose];
 }

package/dist/{chunk-XHK6BDAJ.js → chunk-54EDRCEF.js}

@@ -1,16 +1,18 @@
 import {
   recordDependency,
+  retrack,
   track,
   trackingSuspended
-} from "./chunk-K4G4ZQNR.js";
+} from "./chunk-VLPPXTYG.js";
 import {
   devAssert
-} from "./chunk-5X6PP2UK.js";
+} from "./chunk-LMLD24FC.js";
 
 // 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;
@@ -21,8 +23,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;
@@ -35,11 +43,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;
@@ -48,13 +61,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 });