signalium 3.0.2 → 4.0.0

package/dist/esm/development/{debug-BTLbgTPK.js → debug-C3HD8WcT.js}

@@ -1,4 +1,4 @@
-import { s as scheduleFlush$1, r as runBatch } from "./config-CPQL7hX-.js";
+import { a as scheduleFlush$1, r as runBatch, b as getRenderLeaseTtl, M as MAX_TIMEOUT } from "./config-CQLKpPRj.js";
 let UNKNOWN_SIGNAL_ID = 0;
 const UNKNOWN_SIGNAL_NAMES = /* @__PURE__ */ new Map();
 function getUnknownSignalFnName(fn) {
@@ -427,12 +427,12 @@ function watchSignal(signal2) {
   }
   activateSignal(signal2);
 }
-function unwatchSignal(signal2) {
+function unwatchSignal(signal2, options = {}) {
   const { watchCount } = signal2;
   const newWatchCount = Math.max(watchCount - 1, 0);
   signal2.watchCount = newWatchCount;
   if (newWatchCount === 0) {
-    scheduleDeactivate(signal2);
+    scheduleDeactivate(signal2, options);
   }
 }
 function activateSignal(signal2) {
@@ -442,22 +442,22 @@ function activateSignal(signal2) {
     checkSignal(signal2);
   }
 }
-function deactivateSignal(signal2) {
+function deactivateSignal(signal2, options = {}) {
   signal2._isActive = false;
   for (const dep of signal2.deps.keys()) {
     const newWatchCount = Math.max(dep.watchCount - 1, 0);
     dep.watchCount = newWatchCount;
     if (newWatchCount === 0) {
-      deactivateSignal(dep);
+      deactivateSignal(dep, options);
     }
   }
   if (isRelay(signal2)) {
-    signal2._value?.();
+    signal2._value?.(options);
   }
 }
 let PENDING_PULLS = /* @__PURE__ */ new Set();
 let PENDING_ASYNC_PULLS = [];
-let PENDING_DEACTIVE = /* @__PURE__ */ new Set();
+let PENDING_DEACTIVE = /* @__PURE__ */ new Map();
 let PENDING_LISTENERS = [];
 let PENDING_TRACERS = [];
 const microtask = () => Promise.resolve();
@@ -481,8 +481,9 @@ const scheduleAsyncPull = (signal2) => {
   PENDING_ASYNC_PULLS.push(signal2);
   scheduleFlush();
 };
-const scheduleDeactivate = (signal2) => {
-  PENDING_DEACTIVE.add(signal2);
+const scheduleDeactivate = (signal2, options = {}) => {
+  const existing = PENDING_DEACTIVE.get(signal2);
+  PENDING_DEACTIVE.set(signal2, existing === void 0 ? options : { isPausing: Boolean(existing.isPausing && options.isPausing) });
   scheduleFlush();
 };
 const cancelDeactivate = (signal2) => {
@@ -517,8 +518,8 @@ const flushWatchers = async () => {
   }
   currentFlush = null;
   runBatch(() => {
-    for (const signal2 of PENDING_DEACTIVE) {
-      deactivateSignal(signal2);
+    for (const [signal2, options] of PENDING_DEACTIVE) {
+      deactivateSignal(signal2, options);
     }
     PENDING_DEACTIVE.clear();
     for (const signal2 of PENDING_LISTENERS) {
@@ -1298,11 +1299,11 @@ function createRelay(activate, scope, opts) {
   const p = new ReactivePromiseImpl();
   let active = false;
   let currentSub;
-  const unsubscribe = () => {
+  const unsubscribe = (options) => {
     if (typeof currentSub === "function") {
       currentSub();
     } else if (currentSub !== void 0) {
-      currentSub.deactivate?.();
+      currentSub.deactivate?.(options);
     }
     const signal2 = p["_signal"];
     signal2.subs = /* @__PURE__ */ new Map();
@@ -1602,32 +1603,43 @@ function hashNumber(num, seed = 0) {
   h ^= h >>> 16;
   return h >>> 0;
 }
-function hashArray(arr, seen) {
-  let h = ARRAY;
+function mixHash(h, k) {
   const c1 = 3432918353;
   const c2 = 461845907;
-  for (const item of arr) {
-    let k = hashValue(item, seen);
-    k = imul(k, c1);
-    k = k << 15 | k >>> 17;
-    k = imul(k, c2);
-    h ^= k;
-    h = h << 13 | h >>> 19;
-    h = imul(h, 5) + 3864292196;
-  }
-  h ^= arr.length;
+  const n = 3864292196;
+  k = imul(k, c1);
+  k = k << 15 | k >>> 17;
+  k = imul(k, c2);
+  h ^= k;
+  h = h << 13 | h >>> 19;
+  return imul(h, 5) + n | 0;
+}
+function finalizeHash(h, length) {
+  const fmix1 = 2246822507;
+  const fmix2 = 3266489909;
+  h ^= length;
   h ^= h >>> 16;
-  h = imul(h, 2246822507);
+  h = imul(h, fmix1);
   h ^= h >>> 13;
-  h = imul(h, 3266489909);
+  h = imul(h, fmix2);
   h ^= h >>> 16;
   return h >>> 0;
 }
+function hashArray(arr, seen) {
+  let h = ARRAY_SEED;
+  for (const item of arr) {
+    h = mixHash(h, hashValue(item, seen));
+  }
+  return finalizeHash(h, arr.length);
+}
 function hashObject(obj, seen) {
+  return hashObjectKeys(obj, Object.keys(obj), seen);
+}
+function hashObjectKeys(obj, keys, seen) {
+  const keyMultiplier = 2654435769;
   let sum = OBJECT;
-  const keys = Object.keys(obj);
   for (const key of keys) {
-    sum += imul(hashValue(key, seen), 2654435769) ^ hashValue(obj[key], seen);
+    sum += imul(hashValue(key, seen), keyMultiplier) ^ hashValue(obj[key], seen);
   }
   return sum >>> 0;
 }
@@ -1639,9 +1651,10 @@ function hashSet(set, seen) {
   return sum >>> 0;
 }
 function hashMap(map, seen) {
+  const keyMultiplier = 2654435769;
   let sum = MAP;
   for (const [key, value] of map) {
-    sum += imul(hashValue(key, seen), 2654435769) ^ hashValue(value, seen);
+    sum += imul(hashValue(key, seen), keyMultiplier) ^ hashValue(value, seen);
   }
   return sum >>> 0;
 }
@@ -1680,7 +1693,7 @@ const FALSE = hashStr(
   3
   /* HashType.FALSE */
 );
-const ARRAY = hashStr(
+const ARRAY_SEED = hashStr(
   "array",
   7
   /* HashType.ARRAY */
@@ -1844,6 +1857,95 @@ function stringifyValue(value) {
       return getObjectId(value);
   }
 }
+let young = /* @__PURE__ */ new Set();
+let old = /* @__PURE__ */ new Set();
+let timer;
+const pinned = /* @__PURE__ */ new Map();
+const SUSPENDED_LEASE_HOLD_TTLS = 30;
+function armTimer() {
+  timer = setTimeout(sweepLeases, getRenderLeaseTtl());
+  timer.unref?.();
+}
+function sweepLeases() {
+  timer = void 0;
+  const expired = old;
+  for (const signal2 of expired) {
+    signal2._releaseLease();
+  }
+  expired.clear();
+  old = young;
+  young = expired;
+  if (old.size > 0) {
+    armTimer();
+  }
+}
+function addLease(signal2) {
+  if (!pinned.delete(signal2)) {
+    old.delete(signal2);
+  }
+  young.add(signal2);
+  if (timer === void 0) {
+    armTimer();
+  }
+}
+function removeLease(signal2) {
+  if (!young.delete(signal2) && !old.delete(signal2)) {
+    pinned.delete(signal2);
+  }
+}
+function pinLease(signal2) {
+  if (!signal2._isLeased) {
+    return void 0;
+  }
+  young.delete(signal2);
+  old.delete(signal2);
+  const token = {};
+  pinned.set(signal2, token);
+  return token;
+}
+function unpinLease(signal2, token) {
+  if (pinned.get(signal2) === token && signal2._isLeased) {
+    addLease(signal2);
+  }
+}
+function holdLeaseUntilSettled(signal2, thenable) {
+  const token = pinLease(signal2);
+  if (token === void 0) {
+    return;
+  }
+  const renew = () => unpinLease(signal2, token);
+  thenable.then(renew, renew);
+}
+function holdSuspendedLease(signal2) {
+  const token = pinLease(signal2);
+  if (token === void 0) {
+    return;
+  }
+  const hold = setTimeout(() => unpinLease(signal2, token), Math.min(getRenderLeaseTtl() * SUSPENDED_LEASE_HOLD_TTLS, MAX_TIMEOUT));
+  hold.unref?.();
+}
+function releaseAbandonedAttempt(signal2) {
+  const token = pinned.get(signal2);
+  if (token !== void 0) {
+    unpinLease(signal2, token);
+  }
+}
+function releaseRenderLeases() {
+  if (timer !== void 0) {
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  const leases = [...old, ...young, ...pinned.keys()];
+  old = /* @__PURE__ */ new Set();
+  young = /* @__PURE__ */ new Set();
+  pinned.clear();
+  for (const signal2 of leases) {
+    signal2._releaseLease();
+  }
+}
+function getRenderLeaseCount() {
+  return young.size + old.size + pinned.size;
+}
 let ID = 0;
 function createReactiveDefinition(id, desc, compute, equals, isRelay2, paramKey, tracer) {
   const def = {
@@ -1916,6 +2018,9 @@ class ReactiveSignal {
       this.flags &= -33;
     }
   }
+  get _isLeased() {
+    return (this.flags & 128) !== 0;
+  }
   get _isLazy() {
     return (this.flags & 64) !== 0;
   }
@@ -1930,6 +2035,7 @@ class ReactiveSignal {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
       current: /* @__PURE__ */ new Map(),
+      pausedReaders: 0,
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
@@ -1937,7 +2043,8 @@ class ReactiveSignal {
     return getSignal(this);
   }
   addListener(listener, opts) {
-    const { current } = this.listeners;
+    const meta = this.listeners;
+    const { current } = meta;
     if (!current.has(listener)) {
       let effective = listener;
       if (opts?.skipInitial) {
@@ -1950,23 +2057,39 @@ class ReactiveSignal {
           listener();
         };
       }
-      if (!this._isListener) {
-        watchSignal(this);
-        this.flags |= 16;
+      const flags = this.flags;
+      current.set(listener, effective);
+      const unpaused = meta.pausedReaders < current.size;
+      if ((flags & 16) === 0) {
+        this.flags = flags | 16;
+      } else if ((flags & 128) !== 0 && (unpaused || (flags & 256) === 0)) {
+        this.flags = flags & -129;
+        removeLease(this);
+      }
+      if (unpaused) {
+        this._takeListenerWatch();
+      } else {
+        this._pauseListenerWatch();
       }
       if (this.watchCount > 0) {
         schedulePull(this);
       }
-      current.set(listener, effective);
     }
     return () => {
       if (current.has(listener)) {
         current.delete(listener);
         if (current.size === 0) {
+          const flags = this.flags;
+          if ((flags & 128) !== 0)
+            return;
           cancelPull(this);
-          unwatchSignal(this);
-          this.flags &= -17;
-          this.listeners.updatedAt = 0;
+          this.flags = flags & -273;
+          if ((flags & 256) !== 0) {
+            unwatchSignal(this);
+          }
+          meta.updatedAt = 0;
+        } else if (meta.pausedReaders >= current.size) {
+          this._pauseListenerWatch();
         }
       }
     };
@@ -1974,15 +2097,99 @@ class ReactiveSignal {
   // This method is used in React hooks specifically. It returns a bound add method
   // that is cached to avoid creating a new one on each call, and it eagerly sets
   // the listener as watched so that relays that are accessed will be activated.
+  //
+  // The eager watch is a lease (see `lease.ts`): the commit's subscription claims it, and a
+  // discarded render's lease expires. Each render of a still-leased signal extends it.
   addListenerLazy(watch = true) {
-    if (!this._isListener) {
+    const flags = this.flags;
+    if ((flags & 16) === 0) {
       if (watch) {
         watchSignal(this);
+        this.flags |= 16 | 128 | 256;
+      } else {
+        this.flags |= 16 | 128;
+      }
+      addLease(this);
+    } else if ((flags & 128) !== 0 || watch && (flags & 256) === 0) {
+      if (watch && (flags & 256) === 0) {
+        watchSignal(this);
+        this.flags |= 256;
       }
-      this.flags |= 16;
+      this.flags |= 128;
+      addLease(this);
     }
     return this.listeners.cachedBoundAdd;
   }
+  /** Drops the listener watch; listeners stay subscribed. */
+  _pauseWatch() {
+    const flags = this.flags;
+    if ((flags & 256) !== 0) {
+      this.flags = flags & -257;
+      unwatchSignal(this, { isPausing: true });
+    }
+  }
+  /** Retakes the listener watch, pulling changes missed while unwatched. */
+  _resumeWatch() {
+    if ((this.flags & 16) !== 0 && this._takeListenerWatch()) {
+      schedulePull(this);
+    }
+  }
+  _takeListenerWatch() {
+    if ((this.flags & 256) !== 0) {
+      return false;
+    }
+    watchSignal(this);
+    this.flags |= 256;
+    return true;
+  }
+  /** `deferred` reconciles in a microtask, for a reader that unregisters before it unsubscribes. */
+  _addPausedReaders(delta, deferred = false) {
+    this.listeners.pausedReaders += delta;
+    if (deferred) {
+      queueMicrotask(() => this._reconcilePausedReaders());
+    } else {
+      this._reconcilePausedReaders();
+    }
+  }
+  _reconcilePausedReaders() {
+    const { current, pausedReaders } = this.listeners;
+    if (current.size === 0)
+      return;
+    if (pausedReaders < current.size) {
+      this._resumeWatch();
+    } else {
+      this._pauseListenerWatch();
+    }
+  }
+  /** Pauses for the listeners' sake; an unclaimed render lease's watch belongs to its render. */
+  _pauseListenerWatch() {
+    if ((this.flags & 128) === 0) {
+      this._pauseWatch();
+    }
+  }
+  /** Releases an unclaimed render lease; a no-op once claimed. */
+  _releaseLease() {
+    const flags = this.flags;
+    if ((flags & 128) === 0) {
+      return;
+    }
+    const meta = this._listeners;
+    if (meta !== null && meta.current.size > 0) {
+      this.flags = flags & -129;
+      if (meta.pausedReaders >= meta.current.size) {
+        this._pauseWatch();
+      }
+      return;
+    }
+    this.flags = flags & -401;
+    if (meta !== null) {
+      meta.updatedAt = 0;
+    }
+    cancelPull(this);
+    if ((flags & 256) !== 0) {
+      unwatchSignal(this);
+    }
+  }
 }
 const runListeners = (signal2) => {
   const { listeners } = signal2;
@@ -2123,26 +2330,36 @@ const getScopeOwner = (obj) => {
   return scope;
 };
 export {
-  settled as A,
-  context as B,
-  getContext as C,
-  withContexts as D,
-  setGlobalContexts as E,
-  clearGlobalContexts as F,
-  setScopeOwner as G,
-  setTracing as H,
-  createTracer as I,
-  createTracerFromId as J,
-  removeTracer as K,
-  Tracer as L,
-  SignalType as M,
-  getTracerProxy as N,
-  scheduleTracer as O,
+  getRenderLeaseCount as $,
+  ARRAY_SEED as A,
+  getSignal as B,
+  unwatchSignal as C,
+  registerCustomHash as D,
+  setReactivePromise as E,
+  notifier as F,
+  isSignal as G,
+  callback as H,
+  settled as I,
+  context as J,
+  getContext as K,
+  withContexts as L,
+  setGlobalContexts as M,
+  clearGlobalContexts as N,
+  setScopeOwner as O,
+  setTracing as P,
+  createTracer as Q,
   ReactivePromise as R,
   SignalScope as S,
-  TracerEventType as T,
+  createTracerFromId as T,
+  removeTracer as U,
   VisualizerNode as V,
+  TracerEventType as W,
+  Tracer as X,
+  SignalType as Y,
+  getTracerProxy as Z,
+  scheduleTracer as _,
   generatorResultToPromiseWithConsumer as a,
+  releaseRenderLeases as a0,
   getCurrentConsumer as b,
   createReactiveSignal as c,
   setRequestScopeGetter as d,
@@ -2154,19 +2371,19 @@ export {
   isReactivePromise as j,
   getGlobalScope as k,
   hashValue as l,
-  schedulePull as m,
-  isPromise as n,
-  isThennable as o,
-  signal as p,
-  getSignal as q,
-  runSignal as r,
+  getObjectHash as m,
+  hashObjectKeys as n,
+  mixHash as o,
+  finalizeHash as p,
+  checkSignal as q,
+  isPromise as r,
   setCurrentConsumer as s,
-  registerCustomHash as t,
-  unwatchSignal as u,
-  setReactivePromise as v,
-  watchSignal as w,
-  notifier as x,
-  isSignal as y,
-  callback as z
+  isThennable as t,
+  runSignal as u,
+  holdLeaseUntilSettled as v,
+  holdSuspendedLease as w,
+  releaseAbandonedAttempt as x,
+  signal as y,
+  watchSignal as z
 };
-//# sourceMappingURL=debug-BTLbgTPK.js.map
+//# sourceMappingURL=debug-C3HD8WcT.js.map