sibujs 4.14.0 → 4.15.0

package/dist/browser.cjs

@@ -175,13 +175,26 @@ function reportError(error, context) {
   });
 }
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g = globalThis;
+  return g[key] ?? (g[key] = create());
+}
+
 // src/core/rendering/dispose.ts
+var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.disposers.v1"), () => ({
+  disposers: /* @__PURE__ */ new WeakMap(),
+  captures: [],
+  bindings: { count: 0 }
+}));
+var elementDisposers = state2.disposers;
+var bindings = state2.bindings;
 function resolveCapture(capture) {
   let frame = capture;
   while (frame?.closed) frame = frame.forwardTo;
   return frame ?? null;
 }
-var registrationCaptures = [];
+var registrationCaptures = state2.captures;
 function currentDisposerCapture() {
   return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
 }
@@ -357,6 +370,201 @@ function bindOwnerScope(fn) {
   return (...args) => runWithOwnerScope(scope, () => fn(...args));
 }
 var currentStructOwner = null;
+var frozenOwners = 0;
+var ACTIVE = 0;
+var PAUSED = 1;
+var ENDED = 2;
+var NOOP = () => {
+};
+var skippedWhileHeld = /* @__PURE__ */ new Set();
+var waiters = /* @__PURE__ */ new Set();
+var heldRoots = /* @__PURE__ */ new Set();
+function ownerState(tok) {
+  let state3 = ACTIVE;
+  for (let t = tok; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return ENDED;
+    if (o._frozen === true) state3 = PAUSED;
+    t = o._owner ?? null;
+  }
+  return state3;
+}
+var endWatchers = /* @__PURE__ */ new Set();
+var stateWatchers = /* @__PURE__ */ new Set();
+var stateCheckQueued = false;
+function queueStateCheck() {
+  if (stateCheckQueued || stateWatchers.size === 0) return;
+  stateCheckQueued = true;
+  queueMicrotask(() => {
+    stateCheckQueued = false;
+    for (const watcher of [...stateWatchers]) {
+      if (!stateWatchers.has(watcher)) continue;
+      const state3 = watcher.check.state();
+      if (state3 === ENDED) stateWatchers.delete(watcher);
+      if (state3 === ENDED || state3 === watcher.last) continue;
+      watcher.last = state3;
+      try {
+        watcher.listener(state3);
+      } catch (err) {
+        reportError(err, { phase: "effect" });
+      }
+    }
+  });
+}
+var ALWAYS_ACTIVE = Object.assign(() => false, {
+  state: () => ACTIVE,
+  wait: (onActive) => {
+    onActive();
+    return NOOP;
+  },
+  onEnd: () => NOOP,
+  run: (fn) => fn(),
+  onChange: () => NOOP,
+  within: () => false
+});
+function captureFrozen() {
+  const tok = currentStructOwner;
+  if (tok === null) return ALWAYS_ACTIVE;
+  const state3 = () => ownerState(tok);
+  const check = Object.assign(() => state3() !== ACTIVE, {
+    state: state3,
+    wait: (onActive, onEnd) => {
+      const now = state3();
+      if (now !== PAUSED) {
+        (now === ACTIVE ? onActive : onEnd)();
+        return NOOP;
+      }
+      const waiter = { check, onActive, onEnd };
+      waiters.add(waiter);
+      return () => {
+        waiters.delete(waiter);
+      };
+    },
+    onEnd: (onEnd) => {
+      if (state3() === ENDED) {
+        onEnd();
+        return NOOP;
+      }
+      const watcher = { check, onActive: NOOP, onEnd };
+      endWatchers.add(watcher);
+      return () => {
+        endWatchers.delete(watcher);
+      };
+    },
+    run: (fn) => {
+      const prev = currentStructOwner;
+      currentStructOwner = tok.sub === null ? null : tok;
+      try {
+        return fn();
+      } finally {
+        currentStructOwner = prev;
+      }
+    },
+    onChange: (listener) => {
+      const last = state3();
+      if (last === ENDED) return NOOP;
+      const watcher = { check, last, listener };
+      stateWatchers.add(watcher);
+      return () => {
+        stateWatchers.delete(watcher);
+      };
+    },
+    within: (owner) => {
+      const target = owner.run(() => currentStructOwner);
+      if (target === null) return false;
+      for (let t = tok; t !== null; ) {
+        if (t === target) return true;
+        const o = t.sub;
+        if (o === null) return false;
+        t = o._owner ?? null;
+      }
+      return false;
+    }
+  });
+  return check;
+}
+function holdSubtree(root) {
+  heldRoots.add(root);
+  return () => {
+    if (heldRoots.delete(root)) settleHeld();
+  };
+}
+function isHeld(sub) {
+  if (frozenOwners !== 0 && hasFrozenOwner(sub)) return true;
+  if (heldRoots.size !== 0) {
+    const node = sub._errorNode;
+    if (node != null) {
+      for (const root of heldRoots) if (root.contains(node)) return true;
+    }
+  }
+  return false;
+}
+function notifyEnded() {
+  for (const watcher of stateWatchers) if (watcher.check.state() === ENDED) stateWatchers.delete(watcher);
+  let ended = null;
+  for (const watcher of endWatchers) {
+    if (watcher.check.state() !== ENDED) continue;
+    endWatchers.delete(watcher);
+    (ended ?? (ended = [])).push(watcher);
+  }
+  if (ended === null) return;
+  for (const watcher of ended) {
+    try {
+      watcher.onEnd();
+    } catch (err) {
+      reportError(err, { phase: "cleanup" });
+    }
+  }
+}
+function dropReleasedSkipped() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true || sub.depsHead == null) skippedWhileHeld.delete(sub);
+  }
+}
+function settleHeld() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true) skippedWhileHeld.delete(sub);
+    else if (!isHeld(sub)) {
+      skippedWhileHeld.delete(sub);
+      if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+  }
+  if (frozenOwners === 0 && heldRoots.size === 0) skippedWhileHeld.clear();
+  let ready = null;
+  for (const waiter of waiters) {
+    if (waiter.check.state() === PAUSED) continue;
+    waiters.delete(waiter);
+    (ready ?? (ready = [])).push(waiter);
+  }
+  if (ready !== null) {
+    const settle = ready;
+    queueMicrotask(() => {
+      for (const waiter of settle) {
+        const state3 = waiter.check.state();
+        if (state3 === PAUSED) waiters.add(waiter);
+        else
+          try {
+            (state3 === ACTIVE ? waiter.onActive : waiter.onEnd)();
+          } catch (err) {
+            reportError(err, { phase: "effect" });
+          }
+      }
+    });
+  }
+  if (pendingQueue.length > 0) drainNotificationQueue();
+}
+function hasFrozenOwner(sub) {
+  for (let t = sub._owner ?? null; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return false;
+    if (o._frozen === true) return true;
+    t = o._owner ?? null;
+  }
+  return false;
+}
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -464,6 +672,20 @@ function structuralBinding(commit, ownerNode) {
       } finally {
         currentStructOwner = prev;
       }
+    },
+    freeze: () => {
+      const s = sub;
+      if (s._disposed || s._frozen) return;
+      s._frozen = true;
+      frozenOwners++;
+      queueStateCheck();
+    },
+    thaw: () => {
+      if (!sub._frozen) return;
+      sub._frozen = false;
+      frozenOwners--;
+      queueStateCheck();
+      settleHeld();
     }
   };
 }
@@ -492,20 +714,34 @@ function createBinding(commit, ownerNode, structural) {
   subscriber._errorNode = ownerNode;
   subscriber._tok = null;
   subscriber._owner = null;
+  subscriber._frozen = false;
   if (structural) subscriber._tok = { sub: subscriber };
   try {
     run();
   } catch (err) {
     subscriber._disposed = true;
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+    }
     cleanup(subscriber);
     throw err;
   }
   subscriber._dispose = () => {
     subscriber._disposed = true;
+    const wasFrozen = subscriber._frozen === true;
+    if (wasFrozen) {
+      subscriber._frozen = false;
+      frozenOwners--;
+    }
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+      if (skippedWhileHeld.size !== 0) dropReleasedSkipped();
+      if (wasFrozen || waiters.size !== 0) settleHeld();
+    }
     cleanup(subscriber);
   };
   return subscriber;
@@ -615,6 +851,10 @@ function runPendingOwners(sub) {
   }
 }
 function runQueued(sub) {
+  if ((frozenOwners !== 0 || heldRoots.size !== 0) && isHeld(sub)) {
+    skippedWhileHeld.add(sub);
+    return;
+  }
   if (quarantined.size > 0 && quarantined.has(sub)) return;
   if (sub._hasComputedDep === true && !depsChanged(sub)) return;
   if (tickRepeat(sub)) {
@@ -762,7 +1002,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.14.0" : "dev";
+var _runtimeVersion = true ? "4.15.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -798,6 +1038,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -825,6 +1067,22 @@ var getOwnerScope2 = API.getOwnerScope ?? getOwnerScope;
 var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
 var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
 var structuralBinding2 = API.structuralBinding ?? ((commit, ownerNode) => ({ stop: API.reactiveBinding(commit, ownerNode), run: (fn) => fn() }));
+var captureFrozen2 = API.captureFrozen ?? (() => Object.assign(() => false, {
+  state: () => 0,
+  wait: (onActive) => {
+    onActive();
+    return () => {
+    };
+  },
+  onEnd: () => () => {
+  },
+  run: (fn) => fn(),
+  onChange: () => () => {
+  },
+  within: () => false
+}));
+var holdSubtree2 = API.holdSubtree ?? (() => () => {
+});
 
 // src/reactivity/batch.ts
 var batchDepth = 0;
@@ -887,7 +1145,7 @@ function emitDevtools(hook, event, payload) {
 // src/core/signals/signal.ts
 var _g = globalThis;
 function signal(initial, options) {
-  const state2 = {
+  const state3 = {
     value: initial,
     __v: 0,
     __sc: 0,
@@ -900,57 +1158,57 @@ function signal(initial, options) {
   };
   const debugName = DEV ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state2.__name = debugName;
+  if (debugName) state3.__name = debugName;
   function get() {
-    recordDependency2(state2);
-    return state2.value;
+    recordDependency2(state3);
+    return state3.value;
   }
-  get.__signal = state2;
+  get.__signal = state3;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state2.value;
+      const prev = state3.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state2.value = newValue;
-      state2.__v++;
+      state3.value = newValue;
+      state3.__v++;
       if (DEV) {
         const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+        if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state2)) {
-        notifySubscribers2(state2);
+      if (!enqueueBatchedSignal(state3)) {
+        notifySubscribers2(state3);
       }
     };
   } else if (DEV) {
     set = (next) => {
-      const prev = state2.value;
+      const prev = state3.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state2.value = newValue;
-      state2.__v++;
+      state3.value = newValue;
+      state3.__v++;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state2)) {
-        notifySubscribers2(state2);
+      if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state3)) {
+        notifySubscribers2(state3);
       }
     };
   } else {
     set = (next) => {
-      const prev = state2.value;
+      const prev = state3.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state2.value = newValue;
-      state2.__v++;
-      if (!enqueueBatchedSignal(state2)) {
-        notifySubscribers2(state2);
+      state3.value = newValue;
+      state3.__v++;
+      if (!enqueueBatchedSignal(state3)) {
+        notifySubscribers2(state3);
       }
     };
   }
   if (DEV) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) emitDevtools(hook, "signal:create", { signal: state2, name: debugName, getter: get, initial });
+    if (hook) emitDevtools(hook, "signal:create", { signal: state3, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -1383,13 +1641,13 @@ function idle(timeout = 6e4) {
 
 // src/browser/permissions.ts
 function permissions(name) {
-  const [state2, setState] = signal("prompt");
+  const [state3, setState] = signal("prompt");
   let permissionStatus = null;
   let onChange = null;
   let disposed = false;
   if (typeof navigator === "undefined" || !navigator.permissions) {
     setState("unsupported");
-    return { state: state2, dispose: () => {
+    return { state: state3, dispose: () => {
     } };
   }
   navigator.permissions.query({ name }).then((status) => {
@@ -1412,7 +1670,7 @@ function permissions(name) {
       onChange = null;
     }
   }
-  return { state: state2, dispose };
+  return { state: state3, dispose };
 }
 
 // src/browser/clipboard.ts
@@ -1608,12 +1866,6 @@ function dropZone(element, options) {
   return { isOver, dispose };
 }
 
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g = globalThis;
-  return g[key] ?? (g[key] = create());
-}
-
 // src/utils/singletonResource.ts
 function singletonResource(io) {
   let original = null;
@@ -1763,9 +2015,9 @@ function colorScheme() {
 // src/browser/format.ts
 var I18N_STATE = /* @__PURE__ */ Symbol.for("sibujs.i18n.v1");
 function activeI18nLocale() {
-  const state2 = globalThis[I18N_STATE];
-  if (!state2) return void 0;
-  return state2.getLocale ? state2.getLocale() : state2.locale?.[0]();
+  const state3 = globalThis[I18N_STATE];
+  if (!state3) return void 0;
+  return state3.getLocale ? state3.getLocale() : state3.locale?.[0]();
 }
 function formatNumber(value, options) {
   const { locale, ...formatOptions } = options ?? {};
@@ -1947,9 +2199,9 @@ function notifyUrlWrite() {
   for (const sync of Array.from(_url.instances)) sync();
 }
 var SCROLL_ENTRY_KEY = "__sibuScrollKey";
-function withoutEntryIdentity(state2) {
-  if (state2 === null || typeof state2 !== "object" || !Object.hasOwn(state2, SCROLL_ENTRY_KEY)) return state2;
-  const { [SCROLL_ENTRY_KEY]: _identity, ...rest } = state2;
+function withoutEntryIdentity(state3) {
+  if (state3 === null || typeof state3 !== "object" || !Object.hasOwn(state3, SCROLL_ENTRY_KEY)) return state3;
+  const { [SCROLL_ENTRY_KEY]: _identity, ...rest } = state3;
   return rest;
 }
 function urlState() {
@@ -1987,9 +2239,9 @@ function urlState() {
   window.addEventListener("hashchange", syncFromLocation);
   _url.instances.add(syncFromLocation);
   function writeHistory(newUrl, opts) {
-    const state2 = "state" in opts ? opts.state : window.history.state;
-    if (opts.replace) window.history.replaceState(state2, "", newUrl);
-    else window.history.pushState("state" in opts ? state2 : withoutEntryIdentity(state2), "", newUrl);
+    const state3 = "state" in opts ? opts.state : window.history.state;
+    if (opts.replace) window.history.replaceState(state3, "", newUrl);
+    else window.history.pushState("state" in opts ? state3 : withoutEntryIdentity(state3), "", newUrl);
   }
   function setParams(next, opts = {}) {
     const p = next instanceof URLSearchParams ? next : new URLSearchParams(next);

package/dist/browser.js

@@ -36,16 +36,15 @@ import {
   visibility,
   wakeLock,
   windowSize
-} from "./chunk-A454RAEK.js";
-import "./chunk-52XFPGSN.js";
+} from "./chunk-KIDETDMU.js";
+import "./chunk-HTPOIAAL.js";
 import "./chunk-62BDYGAG.js";
-import "./chunk-7ZHH77QA.js";
-import "./chunk-AE32RGWX.js";
+import "./chunk-LGUXYHTZ.js";
 import "./chunk-B3HOT4TK.js";
 import "./chunk-UYTYNCMZ.js";
-import "./chunk-4FJSAUKB.js";
-import "./chunk-MIRKTVH4.js";
-import "./chunk-S37PZD6I.js";
+import "./chunk-IUBV5WO5.js";
+import "./chunk-GFM5WWPU.js";
+import "./chunk-BF3WBJJQ.js";
 import "./chunk-NT3ZYB5S.js";
 import "./chunk-R5U7XKVJ.js";
 export {