sibujs 2.1.0 → 2.2.0

package/dist/ssr.js

@@ -22,8 +22,8 @@ import {
   wasm,
   worker,
   workerFn
-} from "./chunk-KGYT6UO6.js";
-import "./chunk-CWBVQML6.js";
+} from "./chunk-V65KTDZW.js";
+import "./chunk-VSNLICTS.js";
 import {
   collectStream,
   deserializeState,
@@ -43,14 +43,14 @@ import {
   suspenseSwapScript,
   trustHTML
 } from "./chunk-JYD2PWXH.js";
-import "./chunk-P2HSJDDN.js";
-import "./chunk-WIPZPFBQ.js";
+import "./chunk-STFTTMO2.js";
+import "./chunk-UKMXT5T6.js";
 import "./chunk-2UPRY23K.js";
 import "./chunk-UCS6AMJ7.js";
-import "./chunk-WZA53FXU.js";
+import "./chunk-5WD7BYTZ.js";
 import "./chunk-2RA7SHDA.js";
-import "./chunk-RDTDJCAB.js";
-import "./chunk-QO3WC6FS.js";
+import "./chunk-6QZO7MMG.js";
+import "./chunk-L4DAT4WU.js";
 import "./chunk-LMLD24FC.js";
 export {
   Head,

package/dist/testing.cjs

@@ -1549,69 +1549,88 @@ function testComponent(component, options = {}) {
 
 // src/reactivity/track.ts
 var _isDev3 = isDev();
-var STACK_INITIAL = 32;
-var STACK_SHRINK_THRESHOLD = 128;
-var subscriberStack = new Array(STACK_INITIAL);
-var stackCapacity = STACK_INITIAL;
-var stackTop = -1;
+var POOL_MAX = 4096;
+var nodePool = [];
+function freeNode(node) {
+  node.sig = null;
+  node.sub = null;
+  node.sigPrev = null;
+  node.sigNext = null;
+  node.subPrev = null;
+  node.subNext = null;
+  node.prevActive = null;
+  if (nodePool.length < POOL_MAX) nodePool.push(node);
+}
+function unlinkSignal(node) {
+  const sig = node.sig;
+  if (!sig) return;
+  const prev = node.sigPrev;
+  const next = node.sigNext;
+  if (prev) prev.sigNext = next;
+  else sig.subsHead = next;
+  if (next) next.sigPrev = prev;
+  else sig.subsTail = prev;
+  sig.__sc = (sig.__sc ?? 1) - 1;
+  if (sig.__activeNode === node) sig.__activeNode = node.prevActive;
+  if (sig.__sc === 0) {
+    sig.subsHead = null;
+    sig.subsTail = null;
+  }
+}
+function unlinkSub(node) {
+  const sub = node.sub;
+  if (!sub) return;
+  const prev = node.subPrev;
+  const next = node.subNext;
+  if (prev) prev.subNext = next;
+  else sub.depsHead = next;
+  if (next) next.subPrev = prev;
+  else sub.depsTail = prev;
+}
 var currentSubscriber = null;
-var SUBS = "__s";
-function syncFastPath(signal, subs) {
-  const size = subs.size;
-  if (size === 0) {
-    signal.__f = void 0;
-    delete signal[SUBS];
-  } else if (size === 1) {
-    signal.__f = subs.values().next().value;
-  } else {
-    signal.__f = void 0;
-  }
-}
-function track(effectFn, subscriber) {
-  if (!subscriber) subscriber = effectFn;
-  cleanup(subscriber);
-  ++stackTop;
-  if (stackTop >= stackCapacity) {
-    stackCapacity *= 2;
-    subscriberStack.length = stackCapacity;
-  }
-  subscriberStack[stackTop] = subscriber;
+var subscriberEpochCounter = 0;
+function retrack(effectFn, subscriber) {
+  const prev = currentSubscriber;
   currentSubscriber = subscriber;
+  const sub = subscriber;
+  const epoch = ++subscriberEpochCounter;
+  sub._epoch = epoch;
+  sub._structDirty = false;
+  for (let n = sub.depsHead ?? null; n !== null; n = n.subNext) {
+    const sig = n.sig;
+    n.prevActive = sig.__activeNode ?? null;
+    sig.__activeNode = n;
+  }
   try {
     effectFn();
   } finally {
-    stackTop--;
-    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
-    if (stackTop < 0 && stackCapacity > STACK_SHRINK_THRESHOLD) {
-      stackCapacity = Math.max(STACK_INITIAL, stackCapacity >>> 1);
-      subscriberStack.length = stackCapacity;
+    currentSubscriber = prev;
+    let node = sub.depsHead ?? null;
+    while (node !== null) {
+      const next = node.subNext;
+      const sig = node.sig;
+      sig.__activeNode = node.prevActive;
+      node.prevActive = null;
+      if (node.epoch !== epoch) {
+        unlinkSub(node);
+        unlinkSignal(node);
+        freeNode(node);
+      }
+      node = next;
     }
   }
-  return () => cleanup(subscriber);
 }
 function cleanup(subscriber) {
   const sub = subscriber;
-  const singleDep = sub._dep;
-  if (singleDep !== void 0) {
-    const sig = singleDep;
-    const subs = sig[SUBS];
-    if (subs?.delete(subscriber)) {
-      syncFastPath(sig, subs);
-    }
-    sub._dep = void 0;
-    sub._depEpoch = void 0;
-    return;
-  }
-  const deps = sub._deps;
-  if (!deps || deps.size === 0) return;
-  for (const signal of deps.keys()) {
-    const sig = signal;
-    const subs = sig[SUBS];
-    if (subs?.delete(subscriber)) {
-      syncFastPath(sig, subs);
-    }
+  let node = sub.depsHead ?? null;
+  sub.depsHead = null;
+  sub.depsTail = null;
+  while (node) {
+    const next = node.subNext;
+    unlinkSignal(node);
+    freeNode(node);
+    node = next;
   }
-  deps.clear();
 }
 
 // src/core/ssr-context.ts
@@ -1641,120 +1660,122 @@ function isSSR() {
 
 // src/core/signals/effect.ts
 var _g = globalThis;
+var MAX_RERUNS = 100;
+function flushUserCleanups(ctx) {
+  const list = ctx.userCleanups;
+  if (list.length === 0) return;
+  ctx.userCleanups = [];
+  for (let i = list.length - 1; i >= 0; i--) {
+    try {
+      list[i]();
+    } catch (err) {
+      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+    }
+  }
+}
+function drainReruns(ctx) {
+  let reruns = 1;
+  do {
+    ctx.rerunPending = false;
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+    retrack(ctx.bodyFn, ctx.subscriber);
+  } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
+  if (ctx.rerunPending) {
+    ctx.rerunPending = false;
+    if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+      console.error(
+        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      );
+    }
+  }
+}
+function disposeEffect(ctx) {
+  if (ctx.disposed) return;
+  ctx.disposed = true;
+  const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (h) {
+    try {
+      h.emit("effect:destroy", { effectFn: ctx.fn });
+    } catch {
+    }
+  }
+  try {
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+    }
+  }
+  try {
+    cleanup(ctx.subscriber);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.warn("[SibuJS effect] dispose threw:", err);
+    }
+  }
+}
 function effect(effectFn, options) {
   devAssert(typeof effectFn === "function", "effect: argument must be a function.");
   if (isSSR()) return () => {
   };
-  const onError = options?.onError;
-  let userCleanups = [];
-  const onCleanup = (fn) => {
-    userCleanups.push(fn);
+  const ctx = {
+    fn: effectFn,
+    onError: options?.onError,
+    userCleanups: [],
+    running: false,
+    rerunPending: false,
+    disposed: false,
+    onCleanup: null,
+    subscriber: null,
+    bodyFn: null
   };
-  const runUserCleanups = () => {
-    if (userCleanups.length === 0) return;
-    const list = userCleanups;
-    userCleanups = [];
-    for (let i = list.length - 1; i >= 0; i--) {
-      try {
-        list[i]();
-      } catch (err) {
-        if (typeof console !== "undefined") {
-          console.warn("[SibuJS effect] onCleanup threw:", err);
-        }
-      }
-    }
+  ctx.onCleanup = (fn) => {
+    ctx.userCleanups.push(fn);
   };
-  const invokeBody = () => effectFn(onCleanup);
-  const wrappedFn = onError ? () => {
+  const onErrorCaptured = ctx.onError;
+  ctx.bodyFn = onErrorCaptured ? () => {
     try {
-      invokeBody();
+      ctx.fn(ctx.onCleanup);
     } catch (err) {
-      onError(err);
+      onErrorCaptured(err);
     }
-  } : invokeBody;
-  let cleanupHandle = () => {
+  } : () => {
+    ctx.fn(ctx.onCleanup);
   };
-  let running = false;
-  let rerunPending = false;
-  const MAX_RERUNS = 100;
-  const subscriber = () => {
-    if (running) {
-      rerunPending = true;
+  const sub = (() => {
+    if (ctx.running) {
+      ctx.rerunPending = true;
       return;
     }
-    running = true;
+    ctx.running = true;
     try {
-      let reruns = 0;
-      do {
-        rerunPending = false;
-        runUserCleanups();
-        cleanupHandle();
-        cleanupHandle = track(wrappedFn, subscriber);
-        if (++reruns > MAX_RERUNS) {
-          if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-            console.error(
-              `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-            );
-          }
-          rerunPending = false;
-          break;
-        }
-      } while (rerunPending);
+      ctx.rerunPending = false;
+      if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+      retrack(ctx.bodyFn, sub);
+      if (ctx.rerunPending) drainReruns(ctx);
     } finally {
-      running = false;
-      rerunPending = false;
+      ctx.running = false;
+      ctx.rerunPending = false;
     }
-  };
-  running = true;
+  });
+  sub.depsHead = null;
+  sub.depsTail = null;
+  sub._epoch = 0;
+  sub._structDirty = false;
+  sub._runEpoch = 0;
+  sub._runs = 0;
+  ctx.subscriber = sub;
+  ctx.running = true;
   try {
-    let reruns = 0;
-    do {
-      rerunPending = false;
-      runUserCleanups();
-      cleanupHandle();
-      cleanupHandle = track(wrappedFn, subscriber);
-      if (++reruns > MAX_RERUNS) {
-        if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-          console.error(
-            `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times on initial run \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-          );
-        }
-        rerunPending = false;
-        break;
-      }
-    } while (rerunPending);
+    retrack(ctx.bodyFn, ctx.subscriber);
+    if (ctx.rerunPending) drainReruns(ctx);
   } finally {
-    running = false;
-    rerunPending = false;
+    ctx.running = false;
+    ctx.rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) {
-      try {
-        h.emit("effect:destroy", { effectFn });
-      } catch {
-      }
-    }
-    try {
-      runUserCleanups();
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
-      }
-    }
-    try {
-      cleanupHandle();
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS effect] dispose threw:", err);
-      }
-    }
-  };
+  return () => disposeEffect(ctx);
 }
 
 // src/testing/queries.ts

package/dist/testing.js

@@ -3,9 +3,9 @@ import {
 } from "./chunk-2UPRY23K.js";
 import {
   effect
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import "./chunk-2RA7SHDA.js";
-import "./chunk-QO3WC6FS.js";
+import "./chunk-L4DAT4WU.js";
 import "./chunk-LMLD24FC.js";
 
 // src/testing/a11y.ts