sibujs 4.14.0 → 4.15.0

package/dist/ui.cjs

@@ -187,6 +187,12 @@ function reportError(error, context) {
   });
 }
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g = globalThis;
+  return g[key] ?? (g[key] = create());
+}
+
 // src/core/dev.ts
 var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
   // safe default: off in browser, on in test/dev Node
@@ -217,7 +223,12 @@ function isHydrating() {
 }
 
 // src/core/rendering/dispose.ts
-var elementDisposers = /* @__PURE__ */ new WeakMap();
+var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.disposers.v1"), () => ({
+  disposers: /* @__PURE__ */ new WeakMap(),
+  captures: [],
+  bindings: { count: 0 }
+}));
+var elementDisposers = state2.disposers;
 var MAX_DRAIN_TEARDOWNS = 1e4;
 function reportDrainRunaway(label, executed, remaining) {
   if (typeof console === "undefined") return;
@@ -226,13 +237,13 @@ function reportDrainRunaway(label, executed, remaining) {
     { executed, remaining }
   );
 }
-var activeBindingCount = 0;
+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]);
 }
@@ -251,7 +262,7 @@ function registerDisposer(node, teardown) {
     elementDisposers.set(node, disposers);
   }
   disposers.push(teardown);
-  if (DEV) activeBindingCount++;
+  if (DEV) bindings.count++;
   const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
   if (capture) capture.entries.push([node, teardown]);
 }
@@ -304,7 +315,7 @@ function unregisterDisposer(node, teardown) {
   const index = disposers.indexOf(teardown);
   if (index === -1) return false;
   disposers.splice(index, 1);
-  if (DEV) activeBindingCount--;
+  if (DEV) bindings.count--;
   if (disposers.length === 0) elementDisposers.delete(node);
   return true;
 }
@@ -332,13 +343,13 @@ function disposeNodeOwn(node) {
     if (!pending || pending.length === 0) break;
     const snapshot = pending.slice();
     elementDisposers.delete(node);
-    if (DEV) activeBindingCount -= snapshot.length;
+    if (DEV) bindings.count -= snapshot.length;
     for (let i = 0; i < snapshot.length; i++) {
       if (executed >= MAX_DRAIN_TEARDOWNS) {
         const rest = snapshot.slice(i);
         const added = elementDisposers.get(node);
         elementDisposers.set(node, added ? rest.concat(added) : rest);
-        if (DEV) activeBindingCount += rest.length;
+        if (DEV) bindings.count += rest.length;
         reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
         runaway = true;
         break;
@@ -541,6 +552,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 state4 = ACTIVE;
+  for (let t = tok; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return ENDED;
+    if (o._frozen === true) state4 = PAUSED;
+    t = o._owner ?? null;
+  }
+  return state4;
+}
+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 state4 = watcher.check.state();
+      if (state4 === ENDED) stateWatchers.delete(watcher);
+      if (state4 === ENDED || state4 === watcher.last) continue;
+      watcher.last = state4;
+      try {
+        watcher.listener(state4);
+      } 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 state4 = () => ownerState(tok);
+  const check = Object.assign(() => state4() !== ACTIVE, {
+    state: state4,
+    wait: (onActive, onEnd) => {
+      const now = state4();
+      if (now !== PAUSED) {
+        (now === ACTIVE ? onActive : onEnd)();
+        return NOOP;
+      }
+      const waiter = { check, onActive, onEnd };
+      waiters.add(waiter);
+      return () => {
+        waiters.delete(waiter);
+      };
+    },
+    onEnd: (onEnd) => {
+      if (state4() === 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 = state4();
+      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 state4 = waiter.check.state();
+        if (state4 === PAUSED) waiters.add(waiter);
+        else
+          try {
+            (state4 === 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;
@@ -648,6 +854,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();
     }
   };
 }
@@ -676,20 +896,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;
@@ -799,6 +1033,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)) {
@@ -946,7 +1184,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;
@@ -982,6 +1220,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -1009,6 +1249,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/core/devtoolsHook.ts
 function emitDevtools(hook, event, payload) {
@@ -1181,7 +1437,7 @@ var isBatching = API2.isBatching;
 // src/core/signals/signal.ts
 var _g = globalThis;
 function signal(initial, options) {
-  const state3 = {
+  const state4 = {
     value: initial,
     __v: 0,
     __sc: 0,
@@ -1194,57 +1450,57 @@ function signal(initial, options) {
   };
   const debugName = DEV ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state3.__name = debugName;
+  if (debugName) state4.__name = debugName;
   function get() {
-    recordDependency2(state3);
-    return state3.value;
+    recordDependency2(state4);
+    return state4.value;
   }
-  get.__signal = state3;
+  get.__signal = state4;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state4.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state3.value = newValue;
-      state3.__v++;
+      state4.value = newValue;
+      state4.__v++;
       if (DEV) {
         const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
+        if (hook) emitDevtools(hook, "signal:update", { signal: state4, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      if (!enqueueBatchedSignal(state4)) {
+        notifySubscribers2(state4);
       }
     };
   } else if (DEV) {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state4.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state3.value = newValue;
-      state3.__v++;
+      state4.value = newValue;
+      state4.__v++;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      if (hook) emitDevtools(hook, "signal:update", { signal: state4, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state4)) {
+        notifySubscribers2(state4);
       }
     };
   } else {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state4.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state3.value = newValue;
-      state3.__v++;
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      state4.value = newValue;
+      state4.__v++;
+      if (!enqueueBatchedSignal(state4)) {
+        notifySubscribers2(state4);
       }
     };
   }
   if (DEV) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) emitDevtools(hook, "signal:create", { signal: state3, name: debugName, getter: get, initial });
+    if (hook) emitDevtools(hook, "signal:create", { signal: state4, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -1840,12 +2096,6 @@ function zipMask() {
   return { pattern: "99999" };
 }
 
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g = globalThis;
-  return g[key] ?? (g[key] = create());
-}
-
 // src/ui/a11y.ts
 function aria(element, attrs) {
   for (const [key, value] of Object.entries(attrs)) {
@@ -3331,14 +3581,14 @@ function noDocument() {
 }
 
 // src/utils/embedPolicy.ts
-var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({
+var state3 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({
   allowed: [],
   frames: /* @__PURE__ */ new WeakMap()
 }));
 var REQUEST_CACHE = "embed";
 function currentEmbedAllowlist() {
   const scoped = getRequestStore()?.caches?.get(REQUEST_CACHE)?.get("allowed");
-  return scoped ?? state2.allowed;
+  return scoped ?? state3.allowed;
 }
 function setEmbedPolicy(policy) {
   const allowed = [];
@@ -3366,7 +3616,7 @@ function setEmbedPolicy(policy) {
     }
     scoped.set("allowed", allowed);
   } else {
-    state2.allowed = allowed;
+    state3.allowed = allowed;
   }
 }
 function resolveEmbedSrc(value, allowed = currentEmbedAllowlist()) {
@@ -3438,7 +3688,7 @@ function narrowEmbedReferrerPolicy(value) {
   return EMBED_REFERRER_POLICIES.has(lower) ? lower : DEFAULT_EMBED_REFERRER_POLICY;
 }
 function recordEmbedFrame(frame, record) {
-  state2.frames.set(frame, record);
+  state3.frames.set(frame, record);
 }
 
 // src/ui/embed.ts

package/dist/ui.js

@@ -38,7 +38,7 @@ import {
   toast,
   withScopedStyle,
   zipMask
-} from "./chunk-JTFQ7IL4.js";
+} from "./chunk-KPAXG5IR.js";
 import {
   RenderProp,
   assertType,
@@ -66,35 +66,33 @@ import {
   recordEmbedFrame,
   resolveEmbedSrc,
   setEmbedPolicy
-} from "./chunk-LJMX4SQ7.js";
+} from "./chunk-BG4BP44S.js";
 import {
   createId
-} from "./chunk-CCKUNHVU.js";
+} from "./chunk-DAEXQJQA.js";
 import {
   noDocument
-} from "./chunk-HQIAL7F2.js";
+} from "./chunk-XPDZ2LDR.js";
 import "./chunk-RVWJGWCL.js";
-import "./chunk-N7A6FKWW.js";
-import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
+import "./chunk-D44TAGCT.js";
 import {
   effect
-} from "./chunk-AE32RGWX.js";
+} from "./chunk-LGUXYHTZ.js";
 import "./chunk-B3HOT4TK.js";
 import "./chunk-UYTYNCMZ.js";
 import "./chunk-5HZXGZ6T.js";
 import {
   batch,
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   reactiveBinding
-} from "./chunk-MIRKTVH4.js";
+} from "./chunk-GFM5WWPU.js";
 import {
+  globalSingleton,
   registerDisposer,
   unregisterDisposer
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 import {
   devWarnLazy
 } from "./chunk-NT3ZYB5S.js";