sibujs 3.2.2 → 3.3.1

package/dist/motion.cjs

@@ -288,7 +288,13 @@ async function sequence(steps) {
 
 // src/core/dev.ts
 function isDev() {
-  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
+    // The bare `__SIBU_DEV__` is a bundler define that only exists in
+    // production builds; under the test runner it is always undefined, so
+    // this branch is unreachable here.
+    /* v8 ignore next 2 */
+    typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+  );
 }
 var _isDev = isDev();
 function devWarn(message) {
@@ -297,8 +303,9 @@ function devWarn(message) {
   }
 }
 
-// src/reactivity/track.ts
+// src/reactivity/track-core.ts
 var _isDev2 = isDev();
+var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
   return {
@@ -326,6 +333,16 @@ function allocNode(sig, sub, epoch) {
   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;
@@ -335,6 +352,22 @@ function linkSignal(sig, 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;
@@ -343,7 +376,18 @@ function linkSub(sub, 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();
@@ -355,6 +399,112 @@ function safeInvoke(sub) {
     if (_isDev2) 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;
+  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) 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(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
@@ -372,9 +522,31 @@ function recordDependency(signal2) {
   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 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) {
@@ -416,6 +588,20 @@ function drainQueue() {
     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;
@@ -448,6 +634,22 @@ function propagateDirty(sub) {
     }
   }
 }
+function queueSignalNotification(signal2) {
+  const sig = signal2;
+  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(signal2) {
   const sig = signal2;
   const head = sig.subsHead;
@@ -493,19 +695,139 @@ function notifySubscribers(signal2) {
     }
   }
 }
+function getSubscriberCount(signal2) {
+  return signal2.__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(signal2, visit) {
+  let node = signal2.subsHead ?? null;
+  while (node) {
+    const s = node.sub;
+    if (s) visit(s);
+    node = node.sigNext;
+  }
+}
+
+// src/reactivity/track.ts
+var _isDev3 = 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 (_isDev3 && !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/reactivity/batch.ts
 var batchDepth = 0;
 var pendingSignals = /* @__PURE__ */ new Set();
-function enqueueBatchedSignal(signal2) {
+function batchImpl(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignalImpl(signal2) {
   if (batchDepth === 0) return false;
   pendingSignals.add(signal2);
   return true;
 }
+function isBatchingImpl() {
+  return batchDepth > 0;
+}
+function flushBatch() {
+  try {
+    for (const signal2 of pendingSignals) {
+      queueSignalNotification2(signal2);
+    }
+  } finally {
+    pendingSignals.clear();
+  }
+  drainNotificationQueue2();
+}
+var BATCH_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.batch.v1");
+function resolveBatchApi() {
+  const g = globalThis;
+  const existing = g[BATCH_REGISTRY_KEY];
+  if (existing) return existing;
+  const local = {
+    batch: batchImpl,
+    enqueueBatchedSignal: enqueueBatchedSignalImpl,
+    isBatching: isBatchingImpl
+  };
+  g[BATCH_REGISTRY_KEY] = local;
+  return local;
+}
+var API2 = resolveBatchApi();
+var batch = API2.batch;
+var enqueueBatchedSignal = API2.enqueueBatchedSignal;
+var isBatching = API2.isBatching;
 
 // src/core/signals/signal.ts
 var _g = globalThis;
-var _isDev3 = isDev();
+var _isDev4 = isDev();
 function signal(initial, options) {
   const state = {
     value: initial,
@@ -516,11 +838,11 @@ function signal(initial, options) {
     __activeNode: null,
     __name: void 0
   };
-  const debugName = _isDev3 ? options?.name : void 0;
+  const debugName = _isDev4 ? options?.name : void 0;
   const equalsFn = options?.equals;
   if (debugName) state.__name = debugName;
   function get() {
-    recordDependency(state);
+    recordDependency2(state);
     return state.value;
   }
   get.__signal = state;
@@ -533,15 +855,15 @@ function signal(initial, options) {
       if (equalsFn(prev, newValue)) return;
       state.value = newValue;
       state.__v++;
-      if (_isDev3) {
+      if (_isDev4) {
         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);
+        notifySubscribers2(state);
       }
     };
-  } else if (_isDev3) {
+  } else if (_isDev4) {
     set = (next) => {
       const prev = state.value;
       const newValue = typeof next === "function" ? next(prev) : next;
@@ -551,7 +873,7 @@ function signal(initial, options) {
       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);
+        notifySubscribers2(state);
       }
     };
   } else {
@@ -562,11 +884,11 @@ function signal(initial, options) {
       state.value = newValue;
       state.__v++;
       if (!enqueueBatchedSignal(state)) {
-        notifySubscribers(state);
+        notifySubscribers2(state);
       }
     };
   }
-  if (_isDev3) {
+  if (_isDev4) {
     const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
     if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
   }
@@ -589,7 +911,7 @@ function TransitionGroup(options) {
     }
     setElements((prev) => prev.filter((e) => e !== el));
   }
-  function track(newElements) {
+  function track3(newElements) {
     const oldPositions = /* @__PURE__ */ new Map();
     for (const el of elements()) {
       if (typeof el.getBoundingClientRect === "function") {
@@ -631,7 +953,7 @@ function TransitionGroup(options) {
       }
     }
   }
-  return { add, remove, track };
+  return { add, remove, track: track3 };
 }
 
 // src/ui/viewTransition.ts

package/dist/motion.js

@@ -19,10 +19,10 @@ import {
   stagger,
   transition,
   viewTransition
-} from "./chunk-FOI23UJL.js";
-import "./chunk-C427DVQF.js";
-import "./chunk-Z2FWAE4B.js";
-import "./chunk-LMLD24FC.js";
+} from "./chunk-WL7BIR6O.js";
+import "./chunk-WZG2SZOT.js";
+import "./chunk-TEFZT5PJ.js";
+import "./chunk-COY6PUD2.js";
 export {
   TransitionGroup,
   animate,