@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/prod/core/effect.js

@@ -15,44 +15,47 @@ import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } from
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */ function effect(t, e, E, u) {
-    const f = !!u?.user;
-    const r = createEffectNode(t, e, E, f ? EFFECT_USER : EFFECT_RENDER, u);
-    recompute(r, true);
+    const r = !!u?.user;
+    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, u);
+    recompute(f, true);
     // A first pass that read a staged value was staged itself (recompute: born
     // staged); the flush's commit replays this effect. Its first run is not this
     // creation's (A29). A lane's node likewise: its run is the lane's, queued
     // by the pass and released at the reveal (lanes.ts).
-        !u?.defer && r.se === NOT_PENDING && !r.T?.Re?.v && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !u?.defer && f.ie === NOT_PENDING && !f.T?.Re?.P && (f.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(f.i, runEffect.bind(null, f)) : runEffect(f, f.i));
 }
 
-function notifyEffectStatus(t, e) {
-    // Use passed values if provided, otherwise read from node
-    const E = t !== undefined ? t : this.m;
-    const u = e !== undefined ? e : this.T?.F;
-    if (E & STATUS_ERROR) {
+function notifyEffectStatus() {
+    const t = this.m;
+    const e = this.T?.U;
+    if (t & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
             // and the runner dispatches on them, so a recovery before the effect
-            // phase takes the success arm instead. Blocked forwards (explicit
-            // `status` arg without node-state writes) don't queue: the status
-            // re-propagates unblocked at commit.
+            // phase takes the success arm instead. (Re-read: the boundary
+            // notify above can run a redraw.)
             if (this.m & STATUS_ERROR) {
                 this.Ae = true;
                 globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            // Dev locates the halt at the node that threw: the StatusError's
-            // source, upstream of this effect when a computed failed.
-            haltReactivity(unwrapStatusError(u));
-            throw u;
-        }
+        // Dev locates the halt at the node that threw: the StatusError's
+        // source, upstream of this effect when a computed failed.
+                escalate(this, unwrapStatusError(e), e, this);
     } else if (this.i === EFFECT_RENDER) {
-        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, E, u);
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, t, e);
+    }
+}
+
+/** An effect's error no boundary takes halts the system (boundary-or-halt):
+ * halted with `cause`, `thrown` rethrown; dev locates it at `subject`. */ function escalate(t, e, E = e, u = t) {
+    if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        haltReactivity(e);
+        throw E;
     }
 }
 
@@ -78,8 +81,8 @@ function runEffect(t, e) {
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
         if (t.m & STATUS_ERROR && t.i === EFFECT_USER) {
-        const e = unwrapStatusError(t.T?.F);
-        t.ge = t.Ie;
+        const e = unwrapStatusError(t.T?.U);
+        t.ke = t.le;
         t.Ae = false;
         try {
             t.qe ? t.qe(e, () => {
@@ -88,33 +91,27 @@ function runEffect(t, e) {
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(e);
-                throw e;
-            }
+            escalate(t, e);
         }
         return;
     }
     // Captured before the callback: its own throw errors the node below, but
     // the compute pass that produced `_value` was clean, so its tail still goes.
-        const E = t.T?.F == null;
+        const E = t.T?.U == null;
     const u = t.Je;
     t.Je = undefined;
     try {
         u?.();
-        const e = t.Ke(t.Ie, t.ge);
+        const e = t.Ke(t.le, t.ke);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.Je = e;
     } catch (e) {
-        ext(t).F = new StatusError(t, e);
+        ext(t).U = new StatusError(t, e);
         t.m |= STATUS_ERROR;
-        if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(e);
-            throw e;
-        }
+        escalate(t, e);
     } finally {
-        t.ge = t.Ie;
+        t.ke = t.le;
         t.Ae = false;
         // The run applied: this is the frame now, so the dependency tail the
         // compute pass left linked goes (A30, #3438 — `recompute` defers an
@@ -160,7 +157,7 @@ GlobalQueue.K = runEffect;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.
-        E.M = run;
+        E.Z = run;
     // The first run rides the heap like every wake (GlobalQueue._update), so a
     // tracked effect created inside a render-effect callback runs after that
     // pass's staged writes commit, not before.

package/dist/prod/core/graph.js

@@ -1,4 +1,4 @@
-import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
+import { NewSet, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
 
 import { deleteFromHeap } from "./heap.js";
 
@@ -107,7 +107,7 @@ function unobserved(e) {
  * stays alive and serves its cache, uniform with observed memos) while
  * reclamation still happens within one microtask — the enqueue site arms
  * schedule(), so a flush is guaranteed even when no other work is queued.
- */ const dormantNodes = new Set;
+ */ const dormantNodes = new NewSet;
 
 function sweepDormant() {
     if (dormantNodes.size === 0) return;
@@ -133,7 +133,7 @@ function link(e, n) {
     if (s) {
         o = l !== null ? l.G : n.C;
         if (o !== null && o.S === e) {
-            o.Te = n.Ne;
+            o.de = n.Ne;
             n._ = o;
             return;
         }
@@ -144,14 +144,14 @@ function link(e, n) {
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
         const r = e.ve;
-    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    if (r !== null && r.u === n && (!s || r.de === n.Ne)) return;
     const t = n._ = e.ve = {
         S: e,
         u: n,
         G: o,
         Xe: r,
         t: null,
-        Te: n.Ne
+        de: n.Ne
     };
     if (l !== null) l.G = t; else n.C = t;
     if (r !== null) r.t = t; else e.o = t;

package/dist/prod/core/heap.js

@@ -11,14 +11,14 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.Ge > e.Fe) dirtyQueue.Ge = e.Fe;
+    if (dirtyQueue.Fe > e.he) dirtyQueue.Fe = e.he;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Qe ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
-    if (E >= e.Fe) e.Fe = E + 1;
-    const n = e.Fe;
+    const E = (e._parent?.Qe ? e._parent.Ye?.he : e._parent?.he) ?? -1;
+    if (E >= e.he) e.he = E + 1;
+    const n = e.he;
     const I = t.$e[n];
     if (I === undefined) t.$e[n] = e; else {
         const t = I.We;
@@ -65,7 +65,7 @@ function deleteFromHeap(e, t) {
     const E = e.R;
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
-    const n = e.Fe;
+    const n = e.he;
     if (e.We === e) t.$e[n] = undefined; else {
         const E = e.be;
         const I = t.$e[n];
@@ -98,11 +98,11 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.p = false;
-    for (e.Ge = 0; e.Ge <= e.et; e.Ge++) {
-        let E = e.$e[e.Ge];
+    for (e.Fe = 0; e.Fe <= e.et; e.Fe++) {
+        let E = e.$e[e.Fe];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.$e[e.Ge];
+            E = e.$e[e.Fe];
         }
     }
     e.et = 0;
@@ -110,13 +110,13 @@ function runHeap(e, t) {
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.Fe;
+    let E = e.he;
     for (let t = e.C; t; t = t.G) {
         const e = t.S;
-        if (e.X && e.Fe >= E) E = e.Fe + 1;
+        if (e.X && e.he >= E) E = e.he + 1;
     }
-    if (e.Fe !== E) {
-        e.Fe = E;
+    if (e.he !== E) {
+        e.he = E;
         for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }