sibujs 4.14.0 → 4.15.0

package/dist/widgets.cjs

@@ -215,13 +215,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]);
 }
@@ -397,6 +410,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;
@@ -504,6 +712,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();
     }
   };
 }
@@ -532,20 +754,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;
@@ -655,6 +891,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)) {
@@ -802,7 +1042,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;
@@ -838,6 +1078,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -865,6 +1107,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) {
@@ -1037,7 +1295,7 @@ var isBatching = API2.isBatching;
 // src/core/signals/signal.ts
 var _g = globalThis;
 function signal(initial, options) {
-  const state2 = {
+  const state3 = {
     value: initial,
     __v: 0,
     __sc: 0,
@@ -1050,57 +1308,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];
 }

package/dist/widgets.js

@@ -9,28 +9,28 @@ import {
   snapshotAttributes,
   tabs,
   tooltip
-} from "./chunk-TLS4NVIB.js";
+} from "./chunk-7JO7DPSS.js";
 import {
   claimWidgetKey,
   isWidgetKeyEvent,
   widgetKeyOwner
 } from "./chunk-N5TBYXHW.js";
-import "./chunk-RVR5NPFL.js";
+import "./chunk-2VKTFA7C.js";
 import {
   createId,
   domBinding
-} from "./chunk-CCKUNHVU.js";
-import "./chunk-N7A6FKWW.js";
+} from "./chunk-DAEXQJQA.js";
+import "./chunk-D44TAGCT.js";
 import "./chunk-B3HOT4TK.js";
 import "./chunk-UYTYNCMZ.js";
 import {
   batch,
   signal
-} from "./chunk-4FJSAUKB.js";
+} from "./chunk-IUBV5WO5.js";
 import {
   untracked
-} from "./chunk-MIRKTVH4.js";
-import "./chunk-S37PZD6I.js";
+} from "./chunk-GFM5WWPU.js";
+import "./chunk-BF3WBJJQ.js";
 import "./chunk-NT3ZYB5S.js";
 import "./chunk-R5U7XKVJ.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sibujs",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "A function-based frontend framework with fine-grained reactivity and no virtual DOM. Tag factories return live DOM nodes you can hold and mutate, signals update only what changed, and nothing needs a compiler — it runs from a script tag or a bundler.",
   "keywords": [
     "frontend",

package/dist/chunk-7ZHH77QA.js

@@ -1,9 +0,0 @@
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g = globalThis;
-  return g[key] ?? (g[key] = create());
-}
-
-export {
-  globalSingleton
-};