sibujs 2.1.0 → 3.0.0

package/dist/{chunk-RDTDJCAB.js → chunk-6QZO7MMG.js}

@@ -3,7 +3,7 @@ import {
   notifySubscribers,
   queueSignalNotification,
   recordDependency
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 import {
   isDev
 } from "./chunk-LMLD24FC.js";
@@ -45,32 +45,64 @@ function flushBatch() {
 var _g = globalThis;
 var _isDev = isDev();
 function signal(initial, options) {
-  const state = { value: initial };
+  const state = {
+    value: initial,
+    __v: 0,
+    __sc: 0,
+    subsHead: null,
+    subsTail: null,
+    __activeNode: null,
+    __name: void 0
+  };
   const debugName = _isDev ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) {
-    state.__name = debugName;
-  }
+  if (debugName) state.__name = debugName;
   function get() {
     recordDependency(state);
     return state.value;
   }
   get.__signal = state;
   if (debugName) get.__name = debugName;
-  function set(next) {
-    const newValue = typeof next === "function" ? next(state.value) : next;
-    if (equalsFn ? equalsFn(state.value, newValue) : Object.is(newValue, state.value)) return;
-    if (_isDev) {
-      const oldValue = state.value;
+  let set;
+  if (equalsFn) {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (equalsFn(prev, newValue)) return;
+      state.value = newValue;
+      state.__v++;
+      if (_isDev) {
+        const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+      }
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
+  } else if (_isDev) {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (Object.is(newValue, prev)) return;
       state.value = newValue;
+      state.__v++;
       const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
-    } else {
+      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
+  } else {
+    set = (next) => {
+      const prev = state.value;
+      const newValue = typeof next === "function" ? next(prev) : next;
+      if (Object.is(newValue, prev)) return;
       state.value = newValue;
-    }
-    if (!enqueueBatchedSignal(state)) {
-      notifySubscribers(state);
-    }
+      state.__v++;
+      if (!enqueueBatchedSignal(state)) {
+        notifySubscribers(state);
+      }
+    };
   }
   if (_isDev) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;

package/dist/{chunk-DRUZZAK4.js → chunk-DF3GTP4Q.js}

@@ -3,7 +3,7 @@ import {
   retrack,
   track,
   trackingSuspended
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 import {
   devAssert
 } from "./chunk-LMLD24FC.js";
@@ -16,6 +16,7 @@ function derived(getter, options) {
   const cs = {};
   cs._d = false;
   cs._g = getter;
+  cs.__v = 0;
   const markDirty = () => {
     if (cs._d) return;
     cs._d = true;
@@ -45,11 +46,14 @@ function derived(getter, options) {
         evaluating = true;
         let threw = true;
         try {
+          const prev = cs._v;
           retrack(() => {
-            cs._v = getter();
+            const next = getter();
+            cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
             cs._d = false;
             threw = false;
           }, markDirty);
+          if (!Object.is(prev, cs._v)) cs.__v++;
         } finally {
           evaluating = false;
           if (threw) cs._d = true;
@@ -69,6 +73,7 @@ function derived(getter, options) {
           cs._d = false;
           threw = false;
         }, markDirty);
+        if (!Object.is(oldValue, cs._v)) cs.__v++;
       } finally {
         evaluating = false;
         if (threw) cs._d = true;

package/dist/{chunk-AMK2TYNW.js → chunk-INBOWHQ3.js}

@@ -139,28 +139,28 @@ import {
   use,
   var_,
   video
-} from "./chunk-CWBVQML6.js";
+} from "./chunk-VSNLICTS.js";
 import {
   watch
-} from "./chunk-45YP72ZQ.js";
+} from "./chunk-NEWH4O5U.js";
 import {
   trustHTML
 } from "./chunk-JYD2PWXH.js";
 import {
   context
-} from "./chunk-OJ3P4ECI.js";
+} from "./chunk-YMOIAHWA.js";
 import {
   SVG_NS,
   bindChildNode,
   tagFactory
-} from "./chunk-P2HSJDDN.js";
+} from "./chunk-STFTTMO2.js";
 import {
   bindAttribute,
   bindDynamic
-} from "./chunk-WIPZPFBQ.js";
+} from "./chunk-UKMXT5T6.js";
 import {
   derived
-} from "./chunk-DRUZZAK4.js";
+} from "./chunk-DF3GTP4Q.js";
 import {
   checkLeaks,
   dispose,
@@ -174,7 +174,7 @@ import {
 import {
   effect,
   on
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import {
   disableSSR,
   enableSSR,
@@ -188,7 +188,7 @@ import {
   enqueueBatchedSignal,
   isBatching,
   signal
-} from "./chunk-RDTDJCAB.js";
+} from "./chunk-6QZO7MMG.js";
 import {
   notifySubscribers,
   recordDependency,
@@ -196,7 +196,7 @@ import {
   setMaxDrainIterations,
   track,
   untracked
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 import {
   __export,
   devAssert,
@@ -2845,7 +2845,10 @@ function getMemoizedFallback(fallbackFn, error, retry) {
   }
   return factory();
 }
-function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
+function ErrorBoundary(optionsOrChildren, maybeChildren) {
+  const children = typeof optionsOrChildren === "function" ? optionsOrChildren : maybeChildren;
+  const options = typeof optionsOrChildren === "function" ? {} : optionsOrChildren;
+  const { fallback, onError, resetKeys } = options;
   injectStyles2();
   const [error, setError] = signal(null);
   const retry = () => {
@@ -2920,7 +2923,7 @@ function ErrorBoundary({ nodes, fallback, onError, resetKeys }) {
         return tryRenderFallback(currentError);
       }
       try {
-        const result = nodes();
+        const result = children();
         if (result && typeof result.then === "function") {
           const asyncContainer = div({ class: "sibu-error-async" });
           asyncContainer.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));

package/dist/{chunk-O6EFQ3KT.js → chunk-KH4OE6WY.js}

@@ -1,22 +1,22 @@
 import {
   bindAttribute
-} from "./chunk-WIPZPFBQ.js";
+} from "./chunk-UKMXT5T6.js";
 import {
   derived
-} from "./chunk-DRUZZAK4.js";
+} from "./chunk-DF3GTP4Q.js";
 import {
   dispose,
   registerDisposer
 } from "./chunk-2UPRY23K.js";
 import {
   effect
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import {
   signal
-} from "./chunk-RDTDJCAB.js";
+} from "./chunk-6QZO7MMG.js";
 import {
   track
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 
 // src/ui/form.ts
 function required(message = "This field is required") {

package/dist/{chunk-V6C4FADE.js → chunk-KZA7ANXP.js}

@@ -1,13 +1,13 @@
 import {
   derived
-} from "./chunk-DRUZZAK4.js";
+} from "./chunk-DF3GTP4Q.js";
 import {
   effect
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import {
   batch,
   signal
-} from "./chunk-RDTDJCAB.js";
+} from "./chunk-6QZO7MMG.js";
 
 // src/patterns/machine.ts
 function machine(config) {

package/dist/chunk-L4DAT4WU.js

@@ -0,0 +1,400 @@
+import {
+  devWarn,
+  isDev
+} from "./chunk-LMLD24FC.js";
+
+// src/reactivity/track.ts
+var _isDev = 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;
+  node.sigPrev = null;
+  node.sigNext = null;
+  node.subPrev = null;
+  node.subNext = null;
+  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;
+  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 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;
+  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 suspendSavedSub = null;
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
+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 suspendTracking() {
+  if (suspendDepth === 0) {
+    suspendSavedSub = currentSubscriber;
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    currentSubscriber = suspendSavedSub;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
+}
+function untracked(fn) {
+  suspendTracking();
+  try {
+    return fn();
+  } finally {
+    resumeTracking();
+  }
+}
+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 {
+    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;
+    }
+  }
+}
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = 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 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;
+  sub.depsHead = null;
+  sub.depsTail = null;
+  while (node) {
+    const next = node.subNext;
+    unlinkSignal(node);
+    freeNode(node);
+    node = next;
+  }
+}
+var maxSubscriberRepeats = 50;
+var maxDrainIterations = 1e6;
+var drainEpoch = 0;
+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;
+  }
+}
+
+export {
+  trackingSuspended,
+  untracked,
+  retrack,
+  track,
+  recordDependency,
+  cleanup,
+  setMaxDrainIterations,
+  drainNotificationQueue,
+  queueSignalNotification,
+  notifySubscribers,
+  getSubscriberCount,
+  getSubscriberDeps,
+  forEachSubscriber
+};

package/dist/{chunk-WANSMF2L.js → chunk-L52H775O.js}

@@ -3,17 +3,17 @@ import {
 } from "./chunk-3JHCYHWN.js";
 import {
   tagFactory
-} from "./chunk-P2HSJDDN.js";
+} from "./chunk-STFTTMO2.js";
 import {
   derived
-} from "./chunk-DRUZZAK4.js";
+} from "./chunk-DF3GTP4Q.js";
 import {
   effect
-} from "./chunk-WZA53FXU.js";
+} from "./chunk-5WD7BYTZ.js";
 import {
   batch,
   signal
-} from "./chunk-RDTDJCAB.js";
+} from "./chunk-6QZO7MMG.js";
 
 // src/ecosystem/adapters/mobx.ts
 function mobXAdapter(options) {

package/dist/{chunk-45YP72ZQ.js → chunk-NEWH4O5U.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2RA7SHDA.js";
 import {
   track
-} from "./chunk-QO3WC6FS.js";
+} from "./chunk-L4DAT4WU.js";
 import {
   devAssert
 } from "./chunk-LMLD24FC.js";