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

package/dist/observe/core/heap.js

@@ -11,22 +11,22 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.ut > e.it) dirtyQueue.ut = e.it;
+    if (dirtyQueue.st > e.Et) dirtyQueue.st = e.Et;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Ht ? e._parent.gt?.it : e._parent?.it) ?? -1;
-    if (E >= e.it) e.it = E + 1;
-    const n = e.it;
-    const I = t.jt[n];
-    if (I === undefined) t.jt[n] = e; else {
+    const E = (e._parent?.Pt ? e._parent.Ht?.Et : e._parent?.Et) ?? -1;
+    if (E >= e.Et) e.Et = E + 1;
+    const n = e.Et;
+    const I = t.gt[n];
+    if (I === undefined) t.gt[n] = e; else {
         const t = I.Rt;
-        t.Ot = e;
+        t.At = e;
         e.Rt = t;
         I.Rt = e;
     }
-    if (n > t.Kt) t.Kt = n;
+    if (n > t.jt) t.jt = n;
 }
 
 function insertIntoHeap(e, t) {
@@ -49,7 +49,7 @@ function insertIntoHeap(e, t) {
         // parked in the heap for a synchronous mount (each row writing a ref
         // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
         // markNode's own guard skips an already-DIRTY node.
-                if (t.N) markNode(e);
+                if (t.p) markNode(e);
     }
     if (!(E & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
@@ -65,23 +65,23 @@ 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.it;
-    if (e.Rt === e) t.jt[n] = undefined; else {
-        const E = e.Ot;
-        const I = t.jt[n];
+    const n = e.Et;
+    if (e.Rt === e) t.gt[n] = undefined; else {
+        const E = e.At;
+        const I = t.gt[n];
         const i = E ?? I;
-        if (e === I) t.jt[n] = E; else e.Rt.Ot = E;
+        if (e === I) t.gt[n] = E; else e.Rt.At = E;
         i.Rt = e.Rt;
     }
     e.Rt = e;
-    e.Ot = undefined;
+    e.At = undefined;
 }
 
 function markHeap(e) {
-    if (e.N) return;
-    e.N = true;
-    for (let t = 0; t <= e.Kt; t++) {
-        for (let E = e.jt[t]; E !== undefined; E = E.Ot) {
+    if (e.p) return;
+    e.p = true;
+    for (let t = 0; t <= e.jt; t++) {
+        for (let E = e.gt[t]; E !== undefined; E = E.At) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
@@ -91,33 +91,33 @@ function markNode(e, t = REACTIVE_DIRTY) {
     const E = e.R;
     if ((E & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
     e.R = E & -4 | t;
-    for (let t = e.t; t !== null; t = t.o) {
-        markNode(t.l, REACTIVE_CHECK);
+    for (let t = e.o; t !== null; t = t.t) {
+        markNode(t.u, REACTIVE_CHECK);
     }
 }
 
 function runHeap(e, t) {
-    e.N = false;
-    for (e.ut = 0; e.ut <= e.Kt; e.ut++) {
-        let E = e.jt[e.ut];
+    e.p = false;
+    for (e.st = 0; e.st <= e.jt; e.st++) {
+        let E = e.gt[e.st];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.jt[e.ut];
+            E = e.gt[e.st];
         }
     }
-    e.Kt = 0;
+    e.jt = 0;
 }
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.it;
-    for (let t = e.G; t; t = t._) {
-        const e = t.I;
-        if (e.ee && e.it >= E) E = e.it + 1;
+    let E = e.Et;
+    for (let t = e.C; t; t = t.G) {
+        const e = t.S;
+        if (e.X && e.Et >= E) E = e.Et + 1;
     }
-    if (e.it !== E) {
-        e.it = E;
-        for (let E = e.t; E !== null; E = E.o) insertIntoHeapHeight(E.l, t);
+    if (e.Et !== E) {
+        e.Et = E;
+        for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }
 

package/dist/observe/core/identities.js

@@ -0,0 +1,62 @@
+import { CONFIG_TRANSPARENT } from "./constants.js";
+
+import "./dev.js";
+
+import { getOwner } from "./owner.js";
+
+// Deferred hydration, dependency edges: plain-signal identities.
+// While on (`setSignalIdentities`; the server-components client turns it on
+// before hydrating), a plain signal created under an id-bearing owner is
+// named `<owner id>~<n>`, n counting the plain signals (and plain store
+// roots: `createStore` over an object, store/edges.ts) created under that
+// owner in its current pass (transparent owners defer to the nearest
+// id-bearing one, as child ids do). The server names the same signal the
+// same way and restarts the count on every re-run, so an edge it shipped (a
+// slot fill read it) matches the client node; the write hook receives the
+// node and looks its name up (`signalName`). The count restarts when the owner's pass
+// generation (`_depGen`, bumped by every recompute) moves on. Only the
+// frames client imports this module, so nothing here ships without it.
+// Names live in a side table, not on the node: frames reads them across the
+// package boundary, where a mangled field would not survive.
+let counts = null;
+
+const names = new WeakMap;
+
+/** @internal The identity of a plain signal named while identities were on. */ function signalName(n) {
+    return n === undefined ? undefined : names.get(n);
+}
+
+function identify(n) {
+    let e = getOwner();
+    if (!e) return;
+    while (e.l & CONFIG_TRANSPARENT && e._parent) e = e._parent;
+    if (e.id == null) return;
+    const t = e.Ne;
+    let i = counts.get(e);
+    if (i === undefined || i[0] !== t) counts.set(e, i = [ t, 0 ]);
+    const s = e.id + "~" + i[1]++;
+    // A store root named twice (one object made into two stores, or a store
+    // handed to `createStore`) is one target under two server names: its
+    // writes cannot be attributed (an empty name).
+        names.set(n, names.has(n) ? "" : s);
+}
+
+/** @internal Name plain signals from now on (`on`), or stop. */ function setSignalIdentities(n) {
+    counts = n ? counts || new WeakMap : null;
+    signalHook = n ? identify : null;
+}
+
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */ let signalHook = null;
+
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */ function setReadWatch(n) {}
+
+export { setReadWatch, setSignalIdentities, signalHook, signalName };