signalium 3.0.3 → 4.0.0

package/dist/cjs/production/{contexts-CMvA-Ae9.js → contexts-waczQzHZ.js}

@@ -1,5 +1,5 @@
 "use strict";
-const config = require("./config-B0MtLBgx.js");
+const config = require("./config-BHvmcsLQ.js");
 let CURRENT_CONSUMER;
 const setCurrentConsumer = (consumer) => {
   CURRENT_CONSUMER = consumer;
@@ -1205,32 +1205,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;
 }
@@ -1242,9 +1253,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;
 }
@@ -1283,7 +1295,7 @@ const FALSE = hashStr(
   3
   /* HashType.FALSE */
 );
-const ARRAY = hashStr(
+const ARRAY_SEED = hashStr(
   "array",
   7
   /* HashType.ARRAY */
@@ -1395,6 +1407,95 @@ function hashReactiveFn(fn, args) {
   h = h << 13 | h >>> 19;
   return imul(h, 5) + 3864292196 >>> 0;
 }
+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, config.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(config.getRenderLeaseTtl() * SUSPENDED_LEASE_HOLD_TTLS, config.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 = {
@@ -1454,6 +1555,9 @@ class ReactiveSignal {
       this.flags &= -33;
     }
   }
+  get _isLeased() {
+    return (this.flags & 128) !== 0;
+  }
   get _isLazy() {
     return (this.flags & 64) !== 0;
   }
@@ -1468,6 +1572,7 @@ class ReactiveSignal {
     return this._listeners ?? (this._listeners = {
       updatedAt: 0,
       current: /* @__PURE__ */ new Map(),
+      pausedReaders: 0,
       cachedBoundAdd: this.addListener.bind(this)
     });
   }
@@ -1475,7 +1580,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) {
@@ -1488,23 +1594,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();
         }
       }
     };
@@ -1512,15 +1634,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;
       }
-      this.flags |= 16;
+      addLease(this);
+    } else if ((flags & 128) !== 0 || watch && (flags & 256) === 0) {
+      if (watch && (flags & 256) === 0) {
+        watchSignal(this);
+        this.flags |= 256;
+      }
+      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;
@@ -1660,31 +1866,41 @@ const getScopeOwner = (obj) => {
   }
   return scope;
 };
+exports.ARRAY_SEED = ARRAY_SEED;
 exports.ReactivePromise = ReactivePromise;
 exports.SignalScope = SignalScope;
 exports.callback = callback;
+exports.checkSignal = checkSignal;
 exports.clearGlobalContexts = clearGlobalContexts;
 exports.context = context;
 exports.createReactiveDefinition = createReactiveDefinition;
 exports.createReactiveSignal = createReactiveSignal;
 exports.createRelay = createRelay;
 exports.createTask = createTask;
+exports.finalizeHash = finalizeHash;
 exports.generatorResultToPromiseWithConsumer = generatorResultToPromiseWithConsumer;
 exports.getContext = getContext;
 exports.getCurrentConsumer = getCurrentConsumer;
 exports.getCurrentScope = getCurrentScope;
 exports.getGlobalScope = getGlobalScope;
+exports.getObjectHash = getObjectHash;
+exports.getRenderLeaseCount = getRenderLeaseCount;
 exports.getScopeOwner = getScopeOwner;
 exports.getSignal = getSignal;
+exports.hashObjectKeys = hashObjectKeys;
 exports.hashValue = hashValue;
+exports.holdLeaseUntilSettled = holdLeaseUntilSettled;
+exports.holdSuspendedLease = holdSuspendedLease;
 exports.isPromise = isPromise;
 exports.isReactivePromise = isReactivePromise;
 exports.isSignal = isSignal;
 exports.isThennable = isThennable;
+exports.mixHash = mixHash;
 exports.notifier = notifier;
 exports.registerCustomHash = registerCustomHash;
+exports.releaseAbandonedAttempt = releaseAbandonedAttempt;
+exports.releaseRenderLeases = releaseRenderLeases;
 exports.runSignal = runSignal;
-exports.schedulePull = schedulePull;
 exports.scheduleTracer = scheduleTracer;
 exports.setCurrentConsumer = setCurrentConsumer;
 exports.setGlobalContexts = setGlobalContexts;
@@ -1696,4 +1912,4 @@ exports.signal = signal;
 exports.unwatchSignal = unwatchSignal;
 exports.watchSignal = watchSignal;
 exports.withContexts = withContexts;
-//# sourceMappingURL=contexts-CMvA-Ae9.js.map
+//# sourceMappingURL=contexts-waczQzHZ.js.map