sibujs 1.3.0 → 1.5.0

package/dist/chunk-K4G4ZQNR.js

@@ -0,0 +1,286 @@
+import {
+  devWarn,
+  isDev
+} from "./chunk-5X6PP2UK.js";
+
+// src/reactivity/track.ts
+var _isDev = isDev();
+var subscriberStack = new Array(32);
+var stackCapacity = 32;
+var stackTop = -1;
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+function safeInvoke(sub) {
+  try {
+    sub();
+  } catch (err) {
+    if (_isDev) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  ++stackTop;
+  if (stackTop >= stackCapacity) {
+    stackCapacity *= 2;
+    subscriberStack.length = stackCapacity;
+  }
+  subscriberStack[stackTop] = subscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+  }
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    ++stackTop;
+    if (stackTop >= stackCapacity) {
+      stackCapacity *= 2;
+      subscriberStack.length = stackCapacity;
+    }
+    subscriberStack[stackTop] = null;
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+    trackingSuspended = false;
+  }
+}
+function untracked(fn) {
+  suspendTracking();
+  try {
+    return fn();
+  } finally {
+    resumeTracking();
+  }
+}
+function recordDependency(signal) {
+  if (!currentSubscriber) return;
+  const sub = currentSubscriber;
+  if (sub._dep === signal) return;
+  const deps = sub._deps;
+  if (deps) {
+    if (deps.has(signal)) return;
+    deps.add(signal);
+  } else if (sub._dep !== void 0) {
+    const set = /* @__PURE__ */ new Set();
+    set.add(sub._dep);
+    set.add(signal);
+    sub._deps = set;
+    sub._dep = void 0;
+  } else {
+    sub._dep = signal;
+  }
+  let subs = signal[SUBS];
+  if (!subs) {
+    subs = /* @__PURE__ */ new Set();
+    signalSubscribers.set(signal, subs);
+    signal[SUBS] = subs;
+  }
+  subs.add(currentSubscriber);
+  if (subs.size === 1) {
+    signal.__f = currentSubscriber;
+  } else if (signal.__f !== void 0) {
+    signal.__f = void 0;
+  }
+}
+function queueSignalNotification(signal) {
+  const subs = signal[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+var MAX_DRAIN_ITERATIONS = 1e3;
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      if (i >= MAX_DRAIN_ITERATIONS) {
+        if (typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] Notification queue exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
+          );
+        }
+        break;
+      }
+      safeInvoke(pendingQueue[i]);
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+}
+function notifySubscribers(signal) {
+  const first = signal.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        safeInvoke(first);
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        safeInvoke(pendingQueue[i]);
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          safeInvoke(pendingQueue[i2]);
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      safeInvoke(pendingQueue[i]);
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+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 = void 0;
+      }
+    }
+    sub._dep = 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 = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+export {
+  trackingSuspended,
+  track,
+  untracked,
+  recordDependency,
+  queueSignalNotification,
+  drainNotificationQueue,
+  notifySubscribers
+};