sibujs 4.14.0 → 4.15.0

package/dist/performance.cjs

@@ -356,7 +356,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;
@@ -365,13 +370,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]);
 }
@@ -390,7 +395,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]);
 }
@@ -418,13 +423,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;
@@ -627,6 +632,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;
@@ -734,6 +934,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();
     }
   };
 }
@@ -762,20 +976,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;
@@ -885,6 +1113,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)) {
@@ -1032,7 +1264,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;
@@ -1068,6 +1300,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -1095,6 +1329,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) {
@@ -1332,7 +1582,7 @@ var isBatching = API2.isBatching;
 // src/core/signals/signal.ts
 var _g2 = globalThis;
 function signal(initial, options) {
-  const state2 = {
+  const state3 = {
     value: initial,
     __v: 0,
     __sc: 0,
@@ -1345,57 +1595,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 = _g2.__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 = _g2.__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 = _g2.__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];
 }
@@ -1729,8 +1979,8 @@ function normalizedStore(schema) {
     return ownGet(getState().entities, id);
   }
   function getAll() {
-    const state2 = getState();
-    return state2.ids.map((id) => state2.entities[id]);
+    const state3 = getState();
+    return state3.ids.map((id) => state3.entities[id]);
   }
   function update(id, partial) {
     const prev = getState();
@@ -1763,8 +2013,8 @@ function normalizedStore(schema) {
     });
   }
   function select(predicate) {
-    const state2 = getState();
-    return state2.ids.map((id) => state2.entities[id]).filter(predicate);
+    const state3 = getState();
+    return state3.ids.map((id) => state3.entities[id]).filter(predicate);
   }
   return { add, addMany, get, getAll, update, remove, select, getState };
 }

package/dist/performance.js

@@ -33,22 +33,22 @@ import {
   transitionState,
   uniqueId,
   yieldToMain
-} from "./chunk-UUIKJJIK.js";
+} from "./chunk-Y7JM7GY2.js";
 import {
   trustHTML
-} from "./chunk-BOYKGGVD.js";
-import "./chunk-CNPT6NKV.js";
-import "./chunk-LJMX4SQ7.js";
+} from "./chunk-DRWOD7RZ.js";
+import "./chunk-MINLMJUY.js";
+import "./chunk-BG4BP44S.js";
 import "./chunk-3HZOSMPX.js";
 import "./chunk-62BDYGAG.js";
+import "./chunk-DNCQDFJJ.js";
 import "./chunk-RVWJGWCL.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 {