sibujs 2.0.0 → 2.1.0

package/dist/ssr.cjs

@@ -682,11 +682,24 @@ function escapeAttr(str) {
 
 // src/reactivity/track.ts
 var _isDev3 = isDev();
-var subscriberStack = new Array(32);
-var stackCapacity = 32;
+var STACK_INITIAL = 32;
+var STACK_SHRINK_THRESHOLD = 128;
+var subscriberStack = new Array(STACK_INITIAL);
+var stackCapacity = STACK_INITIAL;
 var stackTop = -1;
 var currentSubscriber = null;
 var SUBS = "__s";
+function syncFastPath(signal2, subs) {
+  const size = subs.size;
+  if (size === 0) {
+    signal2.__f = void 0;
+    delete signal2[SUBS];
+  } else if (size === 1) {
+    signal2.__f = subs.values().next().value;
+  } else {
+    signal2.__f = void 0;
+  }
+}
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
@@ -713,36 +726,49 @@ function track(effectFn, subscriber) {
   } 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;
+    }
   }
   return () => cleanup(subscriber);
 }
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub2 = currentSubscriber;
-  if (sub2._dep === signal2) return;
+  const epoch = sub2._epoch;
+  if (sub2._dep === signal2) {
+    sub2._depEpoch = epoch;
+    return;
+  }
   const deps = sub2._deps;
   if (deps) {
-    if (deps.has(signal2)) return;
-    deps.add(signal2);
+    deps.set(signal2, epoch);
   } else if (sub2._dep !== void 0) {
-    const set = /* @__PURE__ */ new Set();
-    set.add(sub2._dep);
-    set.add(signal2);
-    sub2._deps = set;
+    const map2 = /* @__PURE__ */ new Map();
+    map2.set(sub2._dep, sub2._depEpoch);
+    map2.set(signal2, epoch);
+    sub2._deps = map2;
     sub2._dep = void 0;
+    sub2._depEpoch = void 0;
   } else {
     sub2._dep = signal2;
+    sub2._depEpoch = epoch;
   }
-  let subs = signal2[SUBS];
+  const sig = signal2;
+  let subs = sig[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signal2[SUBS] = subs;
+    sig[SUBS] = subs;
   }
+  const prevSize = subs.size;
   subs.add(currentSubscriber);
-  if (subs.size === 1) {
-    signal2.__f = currentSubscriber;
-  } else if (signal2.__f !== void 0) {
-    signal2.__f = void 0;
+  if (subs.size !== prevSize) {
+    if (subs.size === 1) {
+      sig.__f = currentSubscriber;
+    } else if (sig.__f !== void 0) {
+      sig.__f = void 0;
+    }
   }
 }
 function queueSignalNotification(signal2) {
@@ -757,24 +783,55 @@ function queueSignalNotification(signal2) {
     }
   }
 }
-var maxDrainIterations = 1e5;
+var maxSubscriberRepeats = 50;
+var maxDrainIterations = 1e6;
+var drainEpoch = 0;
+function tickRepeat(sub2) {
+  const s2 = sub2;
+  if (s2._runEpoch !== drainEpoch) {
+    s2._runEpoch = drainEpoch;
+    s2._runs = 1;
+    return false;
+  }
+  return ++s2._runs > maxSubscriberRepeats;
+}
+function cycleError(sub2) {
+  if (typeof console !== "undefined") {
+    const name = sub2.__name ?? "<unnamed>";
+    console.error(
+      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
+    );
+  }
+}
+function absoluteDrainError() {
+  if (typeof console !== "undefined") {
+    console.error(
+      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    );
+  }
+}
+function drainQueue() {
+  let i2 = 0;
+  while (i2 < pendingQueue.length) {
+    if (i2 >= maxDrainIterations) {
+      absoluteDrainError();
+      break;
+    }
+    const sub2 = pendingQueue[i2++];
+    if (tickRepeat(sub2)) {
+      cycleError(sub2);
+      break;
+    }
+    pendingSet.delete(sub2);
+    safeInvoke(sub2);
+  }
+}
 function drainNotificationQueue() {
   if (notifyDepth > 0) return;
   notifyDepth++;
+  drainEpoch++;
   try {
-    let i2 = 0;
-    while (i2 < pendingQueue.length) {
-      if (i2 >= maxDrainIterations) {
-        if (typeof console !== "undefined") {
-          console.error(
-            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
-          );
-        }
-        break;
-      }
-      safeInvoke(pendingQueue[i2]);
-      i2++;
-    }
+    drainQueue();
   } finally {
     notifyDepth--;
     if (notifyDepth === 0) {
@@ -837,25 +894,16 @@ function notifySubscribers(signal2) {
       return;
     }
     notifyDepth++;
+    drainEpoch++;
     try {
       if (first._c) {
         propagateDirty(first);
+      } else if (tickRepeat(first)) {
+        cycleError(first);
       } else {
         safeInvoke(first);
       }
-      let i2 = 0;
-      while (i2 < pendingQueue.length) {
-        if (i2 >= maxDrainIterations) {
-          if (typeof console !== "undefined") {
-            console.error(
-              `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
-            );
-          }
-          break;
-        }
-        safeInvoke(pendingQueue[i2]);
-        i2++;
-      }
+      drainQueue();
     } finally {
       notifyDepth--;
       if (notifyDepth === 0) {
@@ -879,44 +927,17 @@ function notifySubscribers(signal2) {
     return;
   }
   notifyDepth++;
+  drainEpoch++;
   try {
-    let directCount = 0;
-    let hasComputedSub = false;
     for (const sub2 of subs) {
-      if (sub2._c) hasComputedSub = true;
-      pendingQueue[directCount++] = sub2;
-    }
-    if (!hasComputedSub) {
-      for (let i3 = 0; i3 < directCount; i3++) {
-        safeInvoke(pendingQueue[i3]);
-      }
-    } else {
-      for (let i3 = 0; i3 < directCount; i3++) {
-        if (pendingQueue[i3]._c) {
-          propagateDirty(pendingQueue[i3]);
-        }
-      }
-      for (let i3 = 0; i3 < directCount; i3++) {
-        const sub2 = pendingQueue[i3];
-        if (!sub2._c && !pendingSet.has(sub2)) {
-          pendingSet.add(sub2);
-          safeInvoke(sub2);
-        }
-      }
-    }
-    let i2 = directCount;
-    while (i2 < pendingQueue.length) {
-      if (i2 - directCount >= maxDrainIterations) {
-        if (typeof console !== "undefined") {
-          console.error(
-            `[SibuJS] Notification queue exceeded ${maxDrainIterations} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
-          );
-        }
-        break;
+      if (sub2._c) {
+        propagateDirty(sub2);
+      } else if (!pendingSet.has(sub2)) {
+        pendingSet.add(sub2);
+        pendingQueue.push(sub2);
       }
-      safeInvoke(pendingQueue[i2]);
-      i2++;
     }
+    drainQueue();
   } finally {
     notifyDepth--;
     if (notifyDepth === 0) {
@@ -929,29 +950,22 @@ function cleanup(subscriber) {
   const sub2 = subscriber;
   const singleDep = sub2._dep;
   if (singleDep !== void 0) {
-    const subs = singleDep[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (singleDep.__f === subscriber) {
-        singleDep.__f = subs.size === 1 ? subs.values().next().value : void 0;
-      } else if (subs.size === 1 && singleDep.__f === void 0) {
-        singleDep.__f = subs.values().next().value;
-      }
+    const sig = singleDep;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
     sub2._dep = void 0;
+    sub2._depEpoch = void 0;
     return;
   }
   const deps = sub2._deps;
   if (!deps || deps.size === 0) return;
-  for (const signal2 of deps) {
-    const subs = signal2[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (signal2.__f === subscriber) {
-        signal2.__f = subs.size === 1 ? subs.values().next().value : void 0;
-      } else if (subs.size === 1 && signal2.__f === void 0) {
-        signal2.__f = subs.values().next().value;
-      }
+  for (const signal2 of deps.keys()) {
+    const sig = signal2;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
   }
   deps.clear();
@@ -993,29 +1007,57 @@ function effect(effectFn, options) {
   let cleanupHandle = () => {
   };
   let running = false;
+  let rerunPending = false;
+  const MAX_RERUNS = 100;
   const subscriber = () => {
     if (running) {
-      if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-        console.warn(
-          "[SibuJS] effect re-entered itself while running \u2014 the triggering update will be ignored. Wrap mutual writes in `batch()` or split the effect to avoid this."
-        );
-      }
+      rerunPending = true;
       return;
     }
     running = true;
     try {
-      runUserCleanups();
-      cleanupHandle();
-      cleanupHandle = track(wrappedFn, subscriber);
+      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);
     } finally {
       running = false;
+      rerunPending = false;
     }
   };
   running = true;
   try {
-    cleanupHandle = track(wrappedFn, subscriber);
+    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);
   } finally {
     running = false;
+    rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });

package/dist/ssr.js

@@ -22,8 +22,8 @@ import {
   wasm,
   worker,
   workerFn
-} from "./chunk-SAHNHTFC.js";
-import "./chunk-R73P76YZ.js";
+} from "./chunk-KGYT6UO6.js";
+import "./chunk-CWBVQML6.js";
 import {
   collectStream,
   deserializeState,
@@ -43,14 +43,14 @@ import {
   suspenseSwapScript,
   trustHTML
 } from "./chunk-JYD2PWXH.js";
-import "./chunk-KLRMB5ZS.js";
-import "./chunk-DFPFITST.js";
+import "./chunk-P2HSJDDN.js";
+import "./chunk-WIPZPFBQ.js";
 import "./chunk-2UPRY23K.js";
 import "./chunk-UCS6AMJ7.js";
-import "./chunk-HB24TBAF.js";
+import "./chunk-WZA53FXU.js";
 import "./chunk-2RA7SHDA.js";
-import "./chunk-CC65Y57T.js";
-import "./chunk-VLPPXTYG.js";
+import "./chunk-RDTDJCAB.js";
+import "./chunk-QO3WC6FS.js";
 import "./chunk-LMLD24FC.js";
 export {
   Head,

package/dist/testing.cjs

@@ -1549,11 +1549,24 @@ function testComponent(component, options = {}) {
 
 // src/reactivity/track.ts
 var _isDev3 = isDev();
-var subscriberStack = new Array(32);
-var stackCapacity = 32;
+var STACK_INITIAL = 32;
+var STACK_SHRINK_THRESHOLD = 128;
+var subscriberStack = new Array(STACK_INITIAL);
+var stackCapacity = STACK_INITIAL;
 var stackTop = -1;
 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);
@@ -1569,6 +1582,10 @@ function track(effectFn, subscriber) {
   } 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;
+    }
   }
   return () => cleanup(subscriber);
 }
@@ -1576,29 +1593,22 @@ function cleanup(subscriber) {
   const sub = subscriber;
   const singleDep = sub._dep;
   if (singleDep !== void 0) {
-    const subs = singleDep[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (singleDep.__f === subscriber) {
-        singleDep.__f = subs.size === 1 ? subs.values().next().value : void 0;
-      } else if (subs.size === 1 && singleDep.__f === void 0) {
-        singleDep.__f = subs.values().next().value;
-      }
+    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) {
-    const subs = signal[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (signal.__f === subscriber) {
-        signal.__f = subs.size === 1 ? subs.values().next().value : void 0;
-      } else if (subs.size === 1 && signal.__f === void 0) {
-        signal.__f = subs.values().next().value;
-      }
+  for (const signal of deps.keys()) {
+    const sig = signal;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
   }
   deps.clear();
@@ -1665,29 +1675,57 @@ function effect(effectFn, options) {
   let cleanupHandle = () => {
   };
   let running = false;
+  let rerunPending = false;
+  const MAX_RERUNS = 100;
   const subscriber = () => {
     if (running) {
-      if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-        console.warn(
-          "[SibuJS] effect re-entered itself while running \u2014 the triggering update will be ignored. Wrap mutual writes in `batch()` or split the effect to avoid this."
-        );
-      }
+      rerunPending = true;
       return;
     }
     running = true;
     try {
-      runUserCleanups();
-      cleanupHandle();
-      cleanupHandle = track(wrappedFn, subscriber);
+      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);
     } finally {
       running = false;
+      rerunPending = false;
     }
   };
   running = true;
   try {
-    cleanupHandle = track(wrappedFn, subscriber);
+    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);
   } finally {
     running = false;
+    rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });

package/dist/testing.js

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