@solidjs/signals 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { trimStaleDeps } from "./graph.js";
+import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
@@ -22,79 +22,75 @@ import { globalQueue, GlobalQueue, clock, schedule, flush, queuePendingNode, ins
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(e, n) {
-    if (e.m?.has(n)) return false;
-    (e.m ??= new Set).add(n);
+    if (e.oe?.has(n)) return false;
+    (e.oe ??= new Set).add(n);
     return true;
 }
 
 function removePendingSource(e, n) {
-    if (!e.m?.delete(n)) return false;
-    if (e.m.size === 0) e.m = undefined;
+    if (!e.oe?.delete(n)) return false;
+    if (e.oe.size === 0) e.oe = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.m?.clear();
-    e.m = undefined;
+    e.oe?.clear();
+    e.oe = undefined;
 }
 
 function setPendingError(e, n, r) {
     if (!n) {
-        e.k = null;
+        e._ = null;
         return;
     }
     if (r instanceof NotReadyError && r.source === n) {
-        e.k = r;
+        e._ = r;
         return;
     }
-    const t = e.k;
+    const t = e._;
     if (!(t instanceof NotReadyError) || t.source !== n) {
-        e.k = new NotReadyError(n);
+        e._ = new NotReadyError(n);
     }
 }
 
 function forEachDependent(e, n) {
-    for (let r = e.p; r !== null; r = r.de) n(r.Ee, r);
+    for (let r = e.o; r !== null; r = r.ue) n(r.le, r);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let r = e.G ?? null; r !== null; r = r.Ne) {
-        for (let e = r.p; e !== null; e = e.de) n(e.Ee, e);
+        for (let r = e.u ?? null; r !== null; r = r.fe) {
+        for (let e = r.o; e !== null; e = e.ue) n(e.le, e);
     }
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
 // settles and when an `isPending` observer must re-evaluate after a real error):
 // shared scheduling helper in heap.ts (tracked effects bypass the heap).
-function settlePendingSource(e, n = e, 
-// Mark release runs inside queue finalization: companion writes must go
-// through the settlement snap (committed), because a setSignal here would
-// open a fresh transition-scoped override window that nothing reverts.
-r = false) {
-    let t = false;
-    const o = new Set;
-    // Companion updates no-op without the verdict layer (null hooks).
-        const u = r ? GlobalQueue.R : GlobalQueue.P;
-    const settle = e => {
-        if (o.has(e) || !removePendingSource(e, n)) return;
-        o.add(e);
-        e.Ie = clock;
-        const r = e.m?.values().next().value;
-        if (r) {
-            setPendingError(e, r);
-            u !== null && u(e);
+function settlePendingSource(e) {
+    let n = false;
+    const r = new Set;
+    // Companion updates no-op without the verdict layer (null hook).
+        const t = GlobalQueue.ae;
+    const settle = o => {
+        if (r.has(o) || !removePendingSource(o, e)) return;
+        r.add(o);
+        o.ce = clock;
+        const u = o.oe?.values().next().value;
+        if (u) {
+            setPendingError(o, u);
+            t !== null && t(o);
         } else {
-            e.i &= ~STATUS_PENDING;
-            setPendingError(e);
-            u !== null && u(e);
-            if (e.Re) {
-                enqueueSub(e);
-                t = true;
+            o.S &= ~STATUS_PENDING;
+            setPendingError(o);
+            t !== null && t(o);
+            if (o.Se) {
+                enqueueSub(o);
+                n = true;
             }
-            e.Re = false;
+            o.Se = false;
         }
-        forEachDependent(e, settle);
+        forEachDependent(o, settle);
     };
     forEachDependent(e, settle);
-    if (t) schedule();
+    if (n) schedule();
 }
 
 // Object-thenable detection (Promises/A+ shape).
@@ -112,34 +108,34 @@ function handleAsync(e, n, r) {
         });
     }
     if (!o && !t) {
-        e.Ae = null;
+        e.Te = null;
         return n;
     }
-    e.Ae = n;
+    e.Te = n;
     let u;
     const handleError = r => {
-        if (e.Ae !== n) return;
+        if (e.Te !== n) return;
         globalQueue.initTransition(resolveTransition(e));
         // NotReadyError from rejected promises should be treated as pending, not error
                 notifyStatus(e, r instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, r);
-        e.Ie = clock;
+        e.ce = clock;
     };
     const asyncWrite = (t, o) => {
-        if (e.Ae !== n) return;
+        if (e.Te !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
-                if (e.u & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+                if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         globalQueue.initTransition(resolveTransition(e));
-        const u = !!(e.i & STATUS_UNINITIALIZED);
+        const u = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const l = resolveLane(e);
-        if (l) l.Pe.delete(e);
+        if (l) l.de.delete(e);
         if (r) {
             r(t);
             if (u) clearStatus(e, true);
-        } else if (e.be !== undefined) {
+        } else if (e.Ee !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -149,8 +145,8 @@ function handleAsync(e, n, r) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.ge === NOT_PENDING) queuePendingNode(e);
-            e.ge = t;
+            if (e.Ne === NOT_PENDING) queuePendingNode(e);
+            e.Ne = t;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -158,22 +154,22 @@ function handleAsync(e, n, r) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue._e !== null && GlobalQueue._e(e, t);
+                        GlobalQueue.Ie !== null && GlobalQueue.Ie(e, t);
             if (!hasActiveOverride(e)) insertSubs(e);
-            e.Ie = clock;
+            e.ce = clock;
         } else if (l) {
             // Route through lane's effect queue for independent flushing
-            const n = e.De;
-            const r = e.Ue;
-            const o = e.Ge;
+            const n = e.Ae;
+            const r = e.Pe;
+            const o = e.Re;
             try {
                 if (!n && u || !o || !o(t, r)) {
-                    e.Ue = t;
-                    e.Ie = clock;
+                    e.Pe = t;
+                    e.ce = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue._e !== null && GlobalQueue._e(e, t);
+                                        GlobalQueue.Ie !== null && GlobalQueue.Ie(e, t);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -197,18 +193,34 @@ function handleAsync(e, n, r) {
         flush();
         o?.();
     };
+    // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+    // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+    // work (a lazy async memo would otherwise tear down and re-execute — one
+    // fetch per suspended re-read). Settling is that observer's release, so
+    // it runs the same last-one-out check the other release sites run.
+        const settleAutodispose = () => {
+        if (e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.S & STATUS_PENDING)) {
+            unobserved(e);
+        }
+    };
     if (o) {
         let r = false, t = false, o, l = true;
         n.then(e => {
             if (l) {
                 u = e;
                 r = true;
-            } else asyncWrite(e);
+            } else {
+                asyncWrite(e);
+                settleAutodispose();
+            }
         }, e => {
             if (l) {
                 o = e;
                 t = true;
-            } else handleError(e);
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
         });
         l = false;
         if (t) {
@@ -242,7 +254,7 @@ function handleAsync(e, n, r) {
                     i = r;
                     f = true;
                     if (r.done) o = true;
-                } else if (e.Ae !== n) {
+                } else if (e.Te !== n) {
                     return;
                 } else if (!r.done) {
                     t = true;
@@ -261,7 +273,7 @@ function handleAsync(e, n, r) {
                 if (c) {
                     s = r;
                     a = true;
-                } else if (e.Ae === n) {
+                } else if (e.Te === n) {
                     o = true;
                     handleError(r);
                 }
@@ -293,86 +305,74 @@ function handleAsync(e, n, r) {
 }
 
 function clearStatus(e, n = false) {
-    if (e.m) clearPendingSources(e);
-    if (e.Re) e.Re = false;
+    if (e.oe) clearPendingSources(e);
+    if (e.Se) e.Se = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.A = false;
-    e.i = n ? 0 : e.i & STATUS_UNINITIALIZED;
-    if (e.k) setPendingError(e);
+        e._e = false;
+    e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
+    if (e._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.ye || e.pe) GlobalQueue.P(e);
-    if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
-    if (e.C) e.C();
+        if (e.be || e.ge) GlobalQueue.ae(e);
+    if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
+    if (e.i) e.i();
 }
 
 function notifyStatus(e, n, r, t, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(r instanceof StatusError) && !(r instanceof NotReadyError)) r = new StatusError(e, r);
     const u = n === STATUS_PENDING && r instanceof NotReadyError ? r.source : undefined;
-    // Mark-sourced propagation must not capture subscribers into the marking
-    // action's transaction (#2893): they carry no held value needing a
-    // transition-scheduled commit, and stamping `_transition` on them would
-    // freeze unrelated writes that share a downstream memo until the action
-    // settles. Real async keeps queuing (its commits ride the transition).
-        const l = u?.l !== undefined;
-    // A real error is a settled verdict a mark must not erase (#2893): landing
-    // STATUS_PENDING here would clobber `_error` with the sentinel's
-    // NotReadyError, and unlike real async there is no arriving value whose
-    // recompute would surface the error again. Descent stops too — everything
-    // downstream holds the propagated error for the same reason.
-        if (l && e.i & STATUS_ERROR) return;
-    const i = u === e;
-    const s = n === STATUS_PENDING && e.be !== undefined && !i;
-    const f = s && hasActiveOverride(e);
+    const l = u === e;
+    const i = n === STATUS_PENDING && e.Ee !== undefined && !l;
+    const s = i && hasActiveOverride(e);
     if (!t) {
         if (n === STATUS_PENDING && u) {
             addPendingSource(e, u);
-            e.i = STATUS_PENDING | e.i & STATUS_UNINITIALIZED;
+            e.S = STATUS_PENDING | e.S & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
                         setPendingError(e, u, r);
         } else {
             clearPendingSources(e);
-            e.i = n | (n !== STATUS_ERROR ? e.i & STATUS_UNINITIALIZED : 0);
-            e.k = r;
+            e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
+            e._ = r;
         }
-        GlobalQueue.P !== null && GlobalQueue.P(e);
-        if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
+        GlobalQueue.ae !== null && GlobalQueue.ae(e);
+        if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
     }
     if (o && !t) {
         assignOrMergeLane(e, o);
     }
-    const a = t || f;
-    const c = t || s ? undefined : o;
-    if (e.C) {
+    const f = t || s;
+    const a = t || i ? undefined : o;
+    if (e.i) {
         if (t && n === STATUS_PENDING) {
             return;
         }
-        if (a) {
-            e.C(n, r);
+        if (f) {
+            e.i(n, r);
         } else {
-            e.C();
+            e.i();
         }
         return;
     }
     forEachDependent(e, (e, t) => {
-        e.Ie = clock;
-        if (n === STATUS_PENDING && u && !e.m?.has(u) || n !== STATUS_PENDING && (e.k !== r || e.m)) {
+        e.ce = clock;
+        if (n === STATUS_PENDING && u && !e.oe?.has(u) || n !== STATUS_PENDING && (e._ !== r || e.oe)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (t.Qe && n !== STATUS_PENDING && !(r instanceof NotReadyError)) {
+            if (t.De && n !== STATUS_PENDING && !(r instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!a && !l && !e.ve) queuePendingNode(e);
-            notifyStatus(e, n, r, a, c);
+            if (!f && !e.Ue) queuePendingNode(e);
+            notifyStatus(e, n, r, f, a);
         }
     });
 }