@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/observe/affects.js

@@ -6,7 +6,9 @@ import "./core/dev.js";
 
 import { enqueueSub } from "./core/heap.js";
 
-import { GlobalQueue, schedule, resolveTx, flushTransaction } from "./core/scheduler.js";
+import { schedule, resolveTx, flushTransaction, GlobalQueue } from "./core/scheduler.js";
+
+import { storeMarks, installStoreAffects, releaseMarkScope } from "./store/affects.js";
 
 import { $TARGET } from "./store/types.js";
 
@@ -38,12 +40,12 @@ let active = 0;
 /** The verdict readers downstream of `node` — through derivations, stopping
  * at effects — re-derive: the mark's one notification (a probe's answer
  * changed with no value notifying anyone). */ function repoll(e, t = new Set) {
-    for (let n = e.t; n !== null; n = n.l) {
-        const e = n.o;
+    for (let r = e.t; r !== null; r = r.o) {
+        const e = r.l;
         if (t.has(e)) continue;
         t.add(e);
-        if (e.u & CONFIG_VERDICT) enqueueSub(e);
-        if (!e.i) repoll(e, t);
+        if (e.i & CONFIG_VERDICT) enqueueSub(e);
+        if (!e.u) repoll(e, t);
     }
 }
 
@@ -53,13 +55,13 @@ let active = 0;
  * (a direct mark on one still reads pending). Mid-recompute, only the
  * validated prefix of the dependency list is this pass's. */ function marked(e, t) {
     if (e.m !== null && e.m.T !== 0) return true;
-    const n = e;
-    if (n.G & STATUS_ERROR || t.has(e)) return false;
+    const r = e;
+    if (r.S & STATUS_ERROR || t.has(e)) return false;
     t.add(e);
-    const r = n.R & REACTIVE_RECOMPUTING_DEPS ? n.S : undefined;
-    if (r !== null) for (let e = n._ ?? null; e !== null; e = e.p) {
+    const n = r.R & REACTIVE_RECOMPUTING_DEPS ? r.p : undefined;
+    if (n !== null) for (let e = r.G ?? null; e !== null; e = e._) {
         if (marked(e.I, t)) return true;
-        if (e === r) break;
+        if (e === n) break;
     }
     return false;
 }
@@ -67,13 +69,13 @@ let active = 0;
 /** Releases one scope's marks (a landed transaction's, the ambient list at
  * the seam): a node whose last mark drops re-derives its verdict readers. */ function release(e) {
     for (let t = 0; t < e.length; t++) {
-        const n = e[t];
+        const r = e[t];
         active--;
-        if (--n.m.T === 0) {
-            repoll(n);
+        if (--r.m.T === 0) {
+            repoll(r);
             // A store mark's carrier: its scope (and the marks the nodes born in
             // its window inherited) goes with it.
-                        GlobalQueue.N?.(n);
+                        releaseMarkScope(r);
         }
     }
     e.length = 0;
@@ -84,8 +86,8 @@ let active = 0;
     mark(e);
     const t = flushTransaction;
     if (t === null) ambient.push(e); else {
-        const n = resolveTx(t);
-        (n.T ??= []).push(e);
+        const r = resolveTx(t);
+        (r.T ??= []).push(e);
     }
     repoll(e);
 }
@@ -98,28 +100,29 @@ function mark(e) {
 function affects(e, t) {
     // A store (the store half, store/affects.ts): the slot's leaf, or the
     // record's carrier and every live node under it.
-    const n = e?.[$TARGET];
-    if (n !== undefined) {
-        const e = GlobalQueue.O(n, t);
+    const r = e?.[$TARGET];
+    if (r !== undefined) {
+        installStoreAffects();
+        const e = storeMarks(r, t);
         for (let t = 0; t < e.length; t++) register(e[t]);
         schedule();
         return;
     }
-    const r = e?.[$REFRESH];
-    if (!r) {
+    const n = e?.[$REFRESH];
+    if (!n) {
         return;
     }
-    register(r);
+    register(n);
     schedule();
 }
 
-GlobalQueue.C = e => active !== 0 && marked(e, new Set);
+GlobalQueue.N = e => active !== 0 && marked(e, new Set);
 
-GlobalQueue.h = mark;
+GlobalQueue.O = mark;
 
-GlobalQueue.A = release;
+GlobalQueue.k = release;
 
-GlobalQueue.D = e => {
+GlobalQueue.A = e => {
     if (ambient.length === 0) return;
     // The flush parked: the declaration's window is the frame's — the marks
     // are its transaction's ("nothing async below ⇒ no window").
@@ -134,17 +137,17 @@ GlobalQueue.D = e => {
     // the window is the flight's; the mark stays to the seam after the
     // landing. The rest release: verdict-only, nothing to show.
         let t = 0;
-    const n = [];
+    const r = [];
     for (let e = 0; e < ambient.length; e++) {
-        const r = ambient[e];
-        if (inFlight(r)) ambient[t++] = r; else n.push(r);
+        const n = ambient[e];
+        if (inFlight(n)) ambient[t++] = n; else r.push(n);
     }
     ambient.length = t;
-    if (n.length !== 0) release(n);
+    if (r.length !== 0) release(r);
 };
 
 function inFlight(e) {
-    return (e.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
+    return (e.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(e) === true;
 }
 
 export { affects };