sibujs 1.4.0 → 2.0.0

package/dist/chunk-3JHCYHWN.js

@@ -0,0 +1,125 @@
+// src/plugins/plugin.ts
+function createPluginRegistry() {
+  const installedPlugins = /* @__PURE__ */ new Set();
+  const hooks = { init: [], mount: [], unmount: [], error: [] };
+  const provided = /* @__PURE__ */ new Map();
+  const registry = {
+    installedPlugins,
+    hooks,
+    provided,
+    plugin(p, options) {
+      if (installedPlugins.has(p.name)) {
+        console.warn(`[Plugin] "${p.name}" is already installed.`);
+        return;
+      }
+      const ctx = {
+        onInit: (cb) => hooks.init.push(cb),
+        onMount: (cb) => hooks.mount.push(cb),
+        onUnmount: (cb) => hooks.unmount.push(cb),
+        onError: (cb) => hooks.error.push(cb),
+        provide: (key, value) => provided.set(key, value)
+      };
+      const initHooksBefore = hooks.init.length;
+      p.install(ctx, options);
+      installedPlugins.add(p.name);
+      const justAdded = hooks.init.slice(initHooksBefore);
+      for (const cb of justAdded) {
+        try {
+          cb();
+        } catch (e) {
+          console.error(`[Plugin] "${p.name}" init error:`, e);
+        }
+      }
+    },
+    inject(key, defaultValue) {
+      if (provided.has(key)) return provided.get(key);
+      if (defaultValue !== void 0) return defaultValue;
+      throw new Error(`[Plugin] No provider found for key "${key}"`);
+    },
+    triggerMount(element) {
+      const snapshot = hooks.mount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Mount hook error:", e);
+        }
+      }
+    },
+    triggerUnmount(element) {
+      const snapshot = hooks.unmount.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(element);
+        } catch (e) {
+          console.error("[Plugin] Unmount hook error:", e);
+        }
+      }
+    },
+    triggerError(error) {
+      const snapshot = hooks.error.slice();
+      for (const hook of snapshot) {
+        try {
+          hook(error);
+        } catch (e) {
+          console.error("[Plugin] Error hook error:", e);
+        }
+      }
+    },
+    reset() {
+      installedPlugins.clear();
+      hooks.init.length = 0;
+      hooks.mount.length = 0;
+      hooks.unmount.length = 0;
+      hooks.error.length = 0;
+      provided.clear();
+    }
+  };
+  return registry;
+}
+var defaultRegistry = createPluginRegistry();
+var defaultRegistryTouched = false;
+function createPlugin(name, install) {
+  return { name, install };
+}
+function plugin(plugin2, options) {
+  defaultRegistryTouched = true;
+  defaultRegistry.plugin(plugin2, options);
+}
+function inject(key, defaultValue) {
+  return defaultRegistry.inject(key, defaultValue);
+}
+function triggerPluginMount(element) {
+  defaultRegistry.triggerMount(element);
+}
+function triggerPluginUnmount(element) {
+  defaultRegistry.triggerUnmount(element);
+}
+function triggerPluginError(error) {
+  defaultRegistry.triggerError(error);
+}
+function resetPlugins() {
+  defaultRegistry.reset();
+  defaultRegistryTouched = false;
+}
+function setDefaultPluginRegistry(registry) {
+  if (defaultRegistryTouched && defaultRegistry.installedPlugins.size > 0) {
+    console.warn(
+      "[Plugin] Replacing default plugin registry while plugins are already installed on the singleton. This may indicate mixed singleton/registry usage."
+    );
+  }
+  defaultRegistry = registry;
+  defaultRegistryTouched = true;
+}
+
+export {
+  createPluginRegistry,
+  createPlugin,
+  plugin,
+  inject,
+  triggerPluginMount,
+  triggerPluginUnmount,
+  triggerPluginError,
+  resetPlugins,
+  setDefaultPluginRegistry
+};

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

@@ -1,12 +1,13 @@
 import {
   derived
-} from "./chunk-NEKUBFPT.js";
+} from "./chunk-54EDRCEF.js";
 import {
   effect
-} from "./chunk-CHF5OHIA.js";
+} from "./chunk-HB24TBAF.js";
 import {
+  batch,
   signal
-} from "./chunk-WZSPOOER.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;
@@ -90,7 +95,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 {
@@ -130,6 +135,7 @@ function persisted(key, initial, options = {}) {
     window.addEventListener("storage", storageListener);
   }
   const dispose = () => {
+    stopPersistEffect();
     if (storageListener && typeof window !== "undefined") {
       window.removeEventListener("storage", storageListener);
       storageListener = null;
@@ -147,62 +153,144 @@ 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/patterns/timeTravel.ts
@@ -220,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()) {
@@ -240,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();
@@ -253,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 = { ...config.state };
+  const initialState = deepClone(config.state);
   const [getState, setState] = signal({ ...initialState });
   const listeners = /* @__PURE__ */ new Set();
   const middlewares = config.middleware || [];

package/dist/{chunk-3AIRKM3B.js → chunk-3NSGB5JN.js}

@@ -1,10 +1,10 @@
 import {
   effect
-} from "./chunk-CHF5OHIA.js";
+} from "./chunk-HB24TBAF.js";
 import {
   batch,
   signal
-} from "./chunk-WZSPOOER.js";
+} from "./chunk-CC65Y57T.js";
 
 // src/browser/media.ts
 function media(query) {
@@ -72,6 +72,8 @@ function scroll(target) {
   const [y, setY] = signal(0);
   const [isScrolling, setIsScrolling] = signal(false);
   let scrollTimer = null;
+  let currentTarget = null;
+  let effectCleanup = null;
   if (typeof window === "undefined") {
     return { x, y, isScrolling, dispose: () => {
     } };
@@ -94,11 +96,26 @@ function scroll(target) {
       scrollTimer = null;
     }, 150);
   };
-  const scrollTarget = target ? target() : null;
-  const eventTarget = scrollTarget || window;
-  eventTarget.addEventListener("scroll", handler, { passive: true });
+  function attachListener(eventTarget) {
+    if (currentTarget === eventTarget) return;
+    if (currentTarget) currentTarget.removeEventListener("scroll", handler);
+    currentTarget = eventTarget;
+    currentTarget.addEventListener("scroll", handler, { passive: true });
+  }
+  if (target) {
+    effectCleanup = effect(() => {
+      const el = target();
+      attachListener(el || window);
+    });
+  } else {
+    attachListener(window);
+  }
   function dispose() {
-    eventTarget.removeEventListener("scroll", handler);
+    effectCleanup?.();
+    if (currentTarget) {
+      currentTarget.removeEventListener("scroll", handler);
+      currentTarget = null;
+    }
     if (scrollTimer !== null) {
       clearTimeout(scrollTimer);
       scrollTimer = null;
@@ -382,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;
           }
@@ -617,31 +637,44 @@ function urlState() {
       }
     };
   }
-  const [params, setParamsSignal] = signal(new URLSearchParams(window.location.search));
-  const [hash, setHashSignal] = signal(window.location.hash);
-  const syncFromLocation = () => {
-    setParamsSignal(new URLSearchParams(window.location.search));
-    setHashSignal(window.location.hash);
-  };
-  const onPopState = () => syncFromLocation();
-  window.addEventListener("popstate", onPopState);
+  let lastSearch = window.location.search;
+  let lastHash = window.location.hash;
+  const [params, setParamsSignal] = signal(new URLSearchParams(lastSearch));
+  const [hash, setHashSignal] = signal(lastHash);
+  function syncFromLocation() {
+    const currentSearch = window.location.search;
+    const currentHash = window.location.hash;
+    if (currentSearch !== lastSearch) {
+      lastSearch = currentSearch;
+      setParamsSignal(new URLSearchParams(currentSearch));
+    }
+    if (currentHash !== lastHash) {
+      lastHash = currentHash;
+      setHashSignal(currentHash);
+    }
+  }
+  window.addEventListener("popstate", syncFromLocation);
+  window.addEventListener("hashchange", syncFromLocation);
   function setParams(next, opts = {}) {
     const p = next instanceof URLSearchParams ? next : new URLSearchParams(next);
     const query = p.toString();
     const newUrl = `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`;
     if (opts.replace) window.history.replaceState(null, "", newUrl);
     else window.history.pushState(null, "", newUrl);
+    lastSearch = window.location.search;
     setParamsSignal(new URLSearchParams(p));
   }
   function setHash(next, opts = {}) {
-    const normalized = next.startsWith("#") ? next : next ? `#${next}` : "";
+    const normalized = next && next !== "#" ? next.startsWith("#") ? next : `#${next}` : "";
     const newUrl = `${window.location.pathname}${window.location.search}${normalized}`;
     if (opts.replace) window.history.replaceState(null, "", newUrl);
     else window.history.pushState(null, "", newUrl);
+    lastHash = normalized;
     setHashSignal(normalized);
   }
   function dispose() {
-    window.removeEventListener("popstate", onPopState);
+    window.removeEventListener("popstate", syncFromLocation);
+    window.removeEventListener("hashchange", syncFromLocation);
   }
   return { params, hash, setParams, setHash, dispose };
 }
@@ -749,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 };
 }
@@ -951,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;
@@ -966,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 {
@@ -1207,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;