sibujs 3.3.0 → 3.3.1

package/dist/testing.cjs

@@ -82,6 +82,11 @@ function devAssert(condition, message) {
     throw new Error(`[SibuJS] ${message}`);
   }
 }
+function devWarn(message) {
+  if (_isDev) {
+    console.warn(`[SibuJS] ${message}`);
+  }
+}
 
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
@@ -1559,10 +1564,36 @@ function testComponent(component, options = {}) {
   };
 }
 
-// src/reactivity/track.ts
+// src/reactivity/track-core.ts
 var _isDev3 = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
+function createNode() {
+  return {
+    sig: null,
+    sub: null,
+    epoch: 0,
+    sigPrev: null,
+    sigNext: null,
+    subPrev: null,
+    subNext: null,
+    prevActive: null
+  };
+}
+function allocNode(sig, sub, epoch) {
+  const n = nodePool.pop();
+  if (n) {
+    n.sig = sig;
+    n.sub = sub;
+    n.epoch = epoch;
+    return n;
+  }
+  const fresh = createNode();
+  fresh.sig = sig;
+  fresh.sub = sub;
+  fresh.epoch = epoch;
+  return fresh;
+}
 function freeNode(node) {
   node.sig = null;
   node.sub = null;
@@ -1573,6 +1604,15 @@ function freeNode(node) {
   node.prevActive = null;
   if (nodePool.length < POOL_MAX) nodePool.push(node);
 }
+function linkSignal(sig, node) {
+  const oldHead = sig.subsHead ?? null;
+  node.sigPrev = null;
+  node.sigNext = oldHead;
+  if (oldHead) oldHead.sigPrev = node;
+  else sig.subsTail = node;
+  sig.subsHead = node;
+  sig.__sc = (sig.__sc ?? 0) + 1;
+}
 function unlinkSignal(node) {
   const sig = node.sig;
   if (!sig) return;
@@ -1589,6 +1629,14 @@ function unlinkSignal(node) {
     sig.subsTail = null;
   }
 }
+function linkSub(sub, node) {
+  const oldTail = sub.depsTail ?? null;
+  node.subPrev = oldTail;
+  node.subNext = null;
+  if (oldTail) oldTail.subNext = node;
+  else sub.depsHead = node;
+  sub.depsTail = node;
+}
 function unlinkSub(node) {
   const sub = node.sub;
   if (!sub) return;
@@ -1600,6 +1648,47 @@ function unlinkSub(node) {
   else sub.depsTail = prev;
 }
 var currentSubscriber = null;
+var suspendSavedSub = null;
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
+function safeInvoke(sub) {
+  try {
+    sub();
+  } catch (err) {
+    if (_isDev3) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var suspendDepth = 0;
+var trackingSuspended = false;
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    suspendSavedSub = currentSubscriber;
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    currentSubscriber = suspendSavedSub;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
+}
+function isTrackingSuspended() {
+  return trackingSuspended;
+}
+function untracked(fn) {
+  suspendTracking();
+  try {
+    return fn();
+  } finally {
+    resumeTracking();
+  }
+}
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -1632,6 +1721,68 @@ function retrack(effectFn, subscriber) {
     }
   }
 }
+function track(effectFn, subscriber) {
+  if (!subscriber) return reactiveBinding(effectFn);
+  cleanup(subscriber);
+  const prev = currentSubscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    currentSubscriber = prev;
+    const sub2 = subscriber;
+    for (let n = sub2.depsHead ?? null; n !== null; n = n.subNext) {
+      const sig = n.sig;
+      sig.__activeNode = n.prevActive;
+      n.prevActive = null;
+    }
+  }
+  const sub = subscriber;
+  return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
+}
+function reactiveBinding(commit) {
+  const run = () => {
+    const s = subscriber;
+    if (s._disposed || s._reentrant) return;
+    s._reentrant = true;
+    try {
+      retrack(commit, subscriber);
+    } finally {
+      s._reentrant = false;
+    }
+  };
+  const subscriber = run;
+  subscriber.depsHead = null;
+  subscriber.depsTail = null;
+  subscriber._epoch = 0;
+  subscriber._structDirty = false;
+  subscriber._runEpoch = 0;
+  subscriber._runs = 0;
+  subscriber._reentrant = false;
+  subscriber._disposed = false;
+  run();
+  return subscriber._dispose ?? (subscriber._dispose = () => {
+    subscriber._disposed = true;
+    cleanup(subscriber);
+  });
+}
+function recordDependency(signal) {
+  if (!currentSubscriber) return;
+  const sub = currentSubscriber;
+  const sig = signal;
+  const epoch = sub._epoch ?? 0;
+  const active = sig.__activeNode ?? null;
+  if (active !== null && active.sub === sub) {
+    active.epoch = epoch;
+    return;
+  }
+  const node = allocNode(signal, sub, epoch);
+  node.prevActive = active;
+  sig.__activeNode = node;
+  linkSub(sub, node);
+  linkSignal(sig, node);
+  sub._structDirty = true;
+}
 function cleanup(subscriber) {
   const sub = subscriber;
   let node = sub.depsHead ?? null;
@@ -1644,6 +1795,246 @@ function cleanup(subscriber) {
     node = next;
   }
 }
+var maxSubscriberRepeats = 50;
+var maxDrainIterations = 1e6;
+var drainEpoch = 0;
+function setMaxSubscriberRepeats(n) {
+  const prev = maxSubscriberRepeats;
+  if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
+  return prev;
+}
+function setMaxDrainIterations(n) {
+  const prev = maxDrainIterations;
+  if (Number.isFinite(n) && n > 0) maxDrainIterations = Math.floor(n);
+  return prev;
+}
+function tickRepeat(sub) {
+  const s = sub;
+  if (s._runEpoch !== drainEpoch) {
+    s._runEpoch = drainEpoch;
+    s._runs = 1;
+    return false;
+  }
+  s._runs = (s._runs ?? 0) + 1;
+  return s._runs > maxSubscriberRepeats;
+}
+function cycleError(sub) {
+  if (typeof console !== "undefined") {
+    const name = sub.__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 i = 0;
+  while (i < pendingQueue.length) {
+    if (i >= maxDrainIterations) {
+      absoluteDrainError();
+      break;
+    }
+    const sub = pendingQueue[i++];
+    if (tickRepeat(sub)) {
+      cycleError(sub);
+      break;
+    }
+    pendingSet.delete(sub);
+    safeInvoke(sub);
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  drainEpoch++;
+  try {
+    drainQueue();
+  } finally {
+    notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  const rootSig = sub._sig;
+  if (!rootSig) return;
+  const stack = propagateStack;
+  const baseLen = stack.length;
+  stack.push(rootSig);
+  while (stack.length > baseLen) {
+    const sig = stack.pop();
+    let node = sig.subsHead ?? null;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          const nSig = s._sig;
+          if (nSig) {
+            if (!nSig._d) {
+              nSig._d = true;
+              stack.push(nSig);
+            }
+          } else {
+            s();
+          }
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
+        }
+      }
+      node = node.sigNext;
+    }
+  }
+}
+function queueSignalNotification(signal) {
+  const sig = signal;
+  let node = sig.subsHead ?? null;
+  while (node) {
+    const s = node.sub;
+    if (s) {
+      if (s._c) {
+        propagateDirty(s);
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    node = node.sigNext;
+  }
+}
+function notifySubscribers(signal) {
+  const sig = signal;
+  const head = sig.subsHead;
+  if (!head) return;
+  if (notifyDepth > 0) {
+    let node = head;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          propagateDirty(s);
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
+        }
+      }
+      node = node.sigNext;
+    }
+    return;
+  }
+  notifyDepth++;
+  drainEpoch++;
+  try {
+    let node = head;
+    while (node) {
+      const s = node.sub;
+      if (s) {
+        if (s._c) {
+          propagateDirty(s);
+        } else if (!pendingSet.has(s)) {
+          pendingSet.add(s);
+          pendingQueue.push(s);
+        }
+      }
+      node = node.sigNext;
+    }
+    drainQueue();
+  } finally {
+    notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
+  }
+}
+function getSubscriberCount(signal) {
+  return signal.__sc ?? 0;
+}
+function getSubscriberDeps(subscriber) {
+  const sub = subscriber;
+  const out = [];
+  let node = sub.depsHead ?? null;
+  while (node) {
+    if (node.sig) out.push(node.sig);
+    node = node.subNext;
+  }
+  return out;
+}
+function forEachSubscriber(signal, visit) {
+  let node = signal.subsHead ?? null;
+  while (node) {
+    const s = node.sub;
+    if (s) visit(s);
+    node = node.sigNext;
+  }
+}
+
+// src/reactivity/track.ts
+var _isDev4 = isDev();
+var _runtimeVersion = typeof __SIBU_VERSION__ !== "undefined" ? __SIBU_VERSION__ : "dev";
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function resolveReactiveApi() {
+  const g = globalThis;
+  const existing = g[REGISTRY_KEY];
+  if (existing) {
+    if (_isDev4 && !existing.__dupWarned) {
+      existing.__dupWarned = true;
+      devWarn(
+        `Multiple instances of the reactive runtime detected on this page (active: ${existing.version}, duplicate: ${_runtimeVersion}). Reactivity still works \u2014 all copies share the first one \u2014 but de-duplicate sibujs in your bundler (e.g. Vite optimizeDeps.exclude: ['sibujs'] or resolve.dedupe: ['sibujs']).`
+      );
+    }
+    return existing;
+  }
+  const local = {
+    suspendTracking,
+    resumeTracking,
+    isTrackingSuspended,
+    untracked,
+    retrack,
+    track,
+    reactiveBinding,
+    recordDependency,
+    cleanup,
+    setMaxSubscriberRepeats,
+    setMaxDrainIterations,
+    drainNotificationQueue,
+    queueSignalNotification,
+    notifySubscribers,
+    getSubscriberCount,
+    getSubscriberDeps,
+    forEachSubscriber,
+    version: _runtimeVersion
+  };
+  g[REGISTRY_KEY] = local;
+  return local;
+}
+var API = resolveReactiveApi();
+var suspendTracking2 = API.suspendTracking;
+var resumeTracking2 = API.resumeTracking;
+var isTrackingSuspended2 = API.isTrackingSuspended;
+var untracked2 = API.untracked;
+var retrack2 = API.retrack;
+var track2 = API.track;
+var reactiveBinding2 = API.reactiveBinding;
+var recordDependency2 = API.recordDependency;
+var cleanup2 = API.cleanup;
+var setMaxSubscriberRepeats2 = API.setMaxSubscriberRepeats;
+var setMaxDrainIterations2 = API.setMaxDrainIterations;
+var drainNotificationQueue2 = API.drainNotificationQueue;
+var queueSignalNotification2 = API.queueSignalNotification;
+var notifySubscribers2 = API.notifySubscribers;
+var getSubscriberCount2 = API.getSubscriberCount;
+var getSubscriberDeps2 = API.getSubscriberDeps;
+var forEachSubscriber2 = API.forEachSubscriber;
 
 // src/core/ssr-context.ts
 var als = null;
@@ -1694,7 +2085,7 @@ function drainReruns(ctx) {
   do {
     ctx.rerunPending = false;
     if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
-    retrack(ctx.bodyFn, ctx.subscriber);
+    retrack2(ctx.bodyFn, ctx.subscriber);
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
@@ -1723,7 +2114,7 @@ function disposeEffect(ctx) {
     }
   }
   try {
-    cleanup(ctx.subscriber);
+    cleanup2(ctx.subscriber);
   } catch (err) {
     if (typeof console !== "undefined") {
       console.warn("[SibuJS effect] dispose threw:", err);
@@ -1768,7 +2159,7 @@ function effect(effectFn, options) {
     try {
       ctx.rerunPending = false;
       if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
-      retrack(ctx.bodyFn, sub);
+      retrack2(ctx.bodyFn, sub);
       if (ctx.rerunPending) drainReruns(ctx);
     } finally {
       ctx.running = false;
@@ -1784,7 +2175,7 @@ function effect(effectFn, options) {
   ctx.subscriber = sub;
   ctx.running = true;
   try {
-    retrack(ctx.bodyFn, ctx.subscriber);
+    retrack2(ctx.bodyFn, ctx.subscriber);
     if (ctx.rerunPending) drainReruns(ctx);
   } finally {
     ctx.running = false;

package/dist/testing.js

@@ -3,9 +3,9 @@ import {
 } from "./chunk-5VGSK6D2.js";
 import {
   effect
-} from "./chunk-7JHWAGRQ.js";
+} from "./chunk-MHBCEJQO.js";
 import "./chunk-GOJMFRBL.js";
-import "./chunk-X3NHE2DK.js";
+import "./chunk-TEFZT5PJ.js";
 import "./chunk-COY6PUD2.js";
 
 // src/testing/a11y.ts