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

package/dist/observe/store/edges.js

@@ -0,0 +1,39 @@
+import { CONFIG_SLOT_NODE } from "../core/constants.js";
+
+import { signalName } from "../core/identities.js";
+
+import { $TARGET } from "./types.js";
+
+/**
+ * Deferred hydration, dependency edges for stores. Only the frames client
+ * imports this module, so nothing here ships without it.
+ *
+ * A plain store root (`createStore` over an object) is named like a plain
+ * signal (core/identities.ts: `<owner id>~<n>`, on the same count), and the
+ * whole store goes by that one name: the server records it for any read of
+ * the store, at any depth, and a setter call on the store — on its root or
+ * on a proxy nested in it — is a write to it. Its readers mount at the
+ * setter's entry, before the draft runs, as a plain signal's do.
+ */
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */ function storeName(e) {
+    if (e === undefined) return undefined;
+    let n = e.l & CONFIG_SLOT_NODE ? e.O : e[$TARGET];
+    if (n === undefined) return undefined;
+    // Up to the root; a target on the way named as a root of its own is one
+    // object in two stores.
+        while (n.u !== null) {
+        if (n.fam !== null || n.ch || signalName(n) !== undefined) return undefined;
+        n = n.u;
+    }
+    if (n.fam !== null || n.ch) return undefined;
+    return signalName(n) || undefined;
+}
+
+export { storeName };

package/dist/observe/store/hooks.js

@@ -0,0 +1,13 @@
+let optHooks = null;
+
+function installOptHooks(o) {
+    optHooks = o;
+}
+
+let affectsHooks = null;
+
+function installAffectsHooks(o) {
+    affectsHooks = o;
+}
+
+export { affectsHooks, installAffectsHooks, installOptHooks, optHooks };

package/dist/observe/store/index.js

@@ -2,8 +2,6 @@ import { createStore as createStore$1, deep as deep$1, snapshot as snapshot$1 }
 
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store.js";
 
-import "./affects.js";
-
 export { createOptimisticStore } from "./optimistic.js";
 
 import { createStoreDerived } from "./projection.js";

package/dist/observe/store/optimistic.js

@@ -2,7 +2,7 @@ import { CONFIG_OVERRIDE, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/const
 
 import { computed, ext, untrack, read, isEqual } from "../core/core.js";
 
-import { pendingGuessOf, laneValueOf, optimisticWrite } from "../core/lanes.js";
+import { pendingGuessOf, optimisticWrite } from "../core/lanes.js";
 
 import { getOwner } from "../core/owner.js";
 
@@ -10,12 +10,16 @@ import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule }
 
 import { runProjectionComputed } from "./projection.js";
 
-import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, installOptHooks, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+
+import { installOptHooks } from "./hooks.js";
 
 import { $OWNER } from "./target.js";
 
 import { $TARGET, markRawIngest, $TRACK, isWrappable } from "./types.js";
 
+import { laneValueOf } from "../core/truth.js";
+
 /**
  * Store — optimistic stores on lanes (plan sec. 31, S4; INTERNALS §3/§7, RUL-3).
  *
@@ -79,7 +83,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.pe = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.Ie = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -157,9 +161,40 @@ function rowSame(e, n, t) {
     if (t === null || !isWrappable(e) || !isWrappable(n)) return false;
     const i = t(unwrapValue(e));
     const r = t(unwrapValue(n));
+    // Keyless rows are identified by position — reconcile's fallback when the
+    // key is missing. The caller already paired these by index, so two keyless
+    // rows are the same row and the landing confirms the arrangement instead of
+    // dissolving it. Dissolving held an external echo under the action, and a
+    // mainline `until` then timed out on a source that already contained it
+    // (#3898). Keyed rows still match only on the key.
+        if (i === undefined && r === undefined) return true;
     return i !== undefined && sameKey(i, r);
 }
 
+/** Whether reconcile would write anything into `a` from `b`: wrappable
+ * pairs descend, leaves compare as its writes do. A key mismatch is a
+ * replacement, which a content difference already says. Plain data — the
+ * server's echo of a guessed row is a new object with the same contents. */ function echoes(e, n) {
+    if (e === n) return true;
+    if (!isWrappable(e) || !isWrappable(n)) return false;
+    e = unwrapValue(e);
+    n = unwrapValue(n);
+    const t = Object.keys(e);
+    if (Array.isArray(e) !== Array.isArray(n) || t.length !== Object.keys(n).length) return false;
+    for (const i of t) if (!hasOwn.call(n, i) || !echoes(e[i], n[i])) return false;
+    return true;
+}
+
+// A cycle (a row that references itself) is not plain data: no match, so
+// the landing stays a correction.
+GlobalQueue.sn = (e, n) => {
+    try {
+        return echoes(e, n);
+    } catch {
+        return false;
+    }
+};
+
 function arrangementEqual(e, n, t) {
     if (Array.isArray(e) !== Array.isArray(n)) return false;
     if (Array.isArray(e)) {
@@ -233,10 +268,10 @@ function arrangementEqual(e, n, t) {
  * node is born for it as the lane's derivation), on `length` only when the
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
- * positionally — the guess stands as written (the documented residue). */ GlobalQueue.In = (e, n) => {
-    const t = e.yt;
-    if (t === undefined || e.bt !== $TRACK) return;
-    const i = e.m.Z;
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n) => {
+    const t = e.O;
+    if (t === undefined || e.Vt !== $TRACK) return;
+    const i = e.T.V;
     if (!(i instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(i.rows)) {
         i.base = n;
@@ -262,15 +297,15 @@ function arrangementEqual(e, n, t) {
             s.add(t);
         } else a.push(n);
     }
-    const l = i.removed;
+    const u = i.removed;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
         const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !s.has(i) && (l === null || !l.has(i))) a.push(t);
+        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
     }
     i.rows = a;
     i.base = a;
-    const u = txOf(e);
+    const l = txOf(e);
     const c = committed(t);
     const d = t.n;
     for (let e = 0; e < a.length; e++) {
@@ -279,17 +314,17 @@ function arrangementEqual(e, n, t) {
         // lane's only where the composed row is another row (by key — the same
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
-            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], u);
-        } else if (!sameRow(n.u & CONFIG_OVERRIDE ? n.m.Z : c[e], a[e], r)) laneSet(n, a[e], u);
+            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.V : c[e], a[e], r)) laneSet(n, a[e], l);
     }
     if (d !== null) {
         for (let e = a.length; ;e++) {
             const n = d[e];
             if (n === undefined) break;
-            laneSet(n, undefined, u);
+            laneSet(n, undefined, l);
         }
         const e = d.length;
-        if (e !== undefined && (e.u & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, u);
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
     }
 };
 
@@ -304,12 +339,12 @@ function sameRow(e, n, t) {
  * node that was not the lane's becomes its derivation (its committed value
  * untouched beneath; the lane's end commits the latest). */ function laneSet(e, n, t) {
     const i = ext(e);
-    if (!(e.u & CONFIG_OVERRIDE)) {
-        e.u |= CONFIG_OVERRIDE;
+    if (!(e.l & CONFIG_OVERRIDE)) {
+        e.l |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.Z === n) return;
-    i.Z = n;
-    if (e.t !== null) {
+    } else if (i.V === n) return;
+    i.V = n;
+    if (e.o !== null) {
         insertSubs(e);
         laneDirty(e, t);
     }
@@ -354,7 +389,7 @@ function sweepOverlaid() {
             // The container shows its backing again (a shown arrangement guess
             // that ended without a landing left its `LaneView` as the value).
                         const t = e.k;
-            if (t !== null && t.pe instanceof LaneView) t.pe = t.pe.base;
+            if (t !== null && t.Ie instanceof LaneView) t.Ie = t.Ie.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -371,11 +406,11 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.tn && r.tn(r.pe, o)) continue;
-        r.pe = o;
+        if (r.Ye && r.Ye(r.Ie, o)) continue;
+        r.Ie = o;
         // (The lane's end notified it this epoch when the shown value and the
         // covered one differed — its readers re-derive already.)
-                if (r.t !== null && r.Pt !== notifyEpoch) {
+                if (r.o !== null && r.Ot !== notifyEpoch) {
             insertSubs(r);
             t = true;
         }
@@ -384,9 +419,9 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.pe === o) continue;
-        i.pe = o;
-        if (i.t !== null && i.Pt !== notifyEpoch) {
+        if (i.Ie === o) continue;
+        i.Ie = o;
+        if (i.o !== null && i.Ot !== notifyEpoch) {
             insertSubs(i);
             t = true;
         }
@@ -394,9 +429,9 @@ function sweepOverlaid() {
     // The arrangement the readers saw (the shown guess) against the inner's
     // now: a structural reader re-derives when they differ.
         const o = e.k;
-    if (o !== null && o.t !== null && o.pe instanceof LaneView && o.Pt !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.Ie instanceof LaneView && o.Ot !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.pe.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.Ie.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }
@@ -405,12 +440,12 @@ function sweepOverlaid() {
 }
 
 function carriesLane(e) {
-    if (e.k !== null && e.k.u & CONFIG_OVERRIDE) return true;
-    if (e.dk !== null && e.dk.u & CONFIG_OVERRIDE) return true;
+    if (e.k !== null && e.k.l & CONFIG_OVERRIDE) return true;
+    if (e.dk !== null && e.dk.l & CONFIG_OVERRIDE) return true;
     const n = e.n;
-    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].u & CONFIG_OVERRIDE) return true;
+    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].l & CONFIG_OVERRIDE) return true;
     const t = e.h;
-    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].u & CONFIG_OVERRIDE) return true;
+    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].l & CONFIG_OVERRIDE) return true;
     return false;
 }
 
@@ -428,9 +463,9 @@ function overlaid(e) {
  * the backing answers. */ function optimisticHas(e, n) {
     if (!overlaid(e)) return undefined;
     const t = e.h?.[n];
-    if (t !== undefined && t.u & CONFIG_OVERRIDE) return !!shown(t);
+    if (t !== undefined && t.l & CONFIG_OVERRIDE) return !!shown(t);
     const i = e.n?.[n];
-    if (i !== undefined && i.u & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    if (i !== undefined && i.l & CONFIG_OVERRIDE) return shown(i) !== undefined;
     return undefined;
 }
 
@@ -441,7 +476,7 @@ function overlaid(e) {
     if (t === undefined) return undefined;
     if (!t) return null;
     const i = e.n?.[n];
-    const r = i !== undefined && i.u & CONFIG_OVERRIDE ? shown(i) : e.v[n];
+    const r = i !== undefined && i.l & CONFIG_OVERRIDE ? shown(i) : e.v[n];
     // An array's `length` is reported as the array has it (non-configurable).
         if (n === "length" && Array.isArray(e.v)) return {
         value: r,
@@ -474,7 +509,7 @@ i = false) {
         for (const e of Reflect.ownKeys(o)) {
             const r = o[e];
             let s;
-            if (r.u & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            if (r.l & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
             if (e === "length" && Array.isArray(n)) {
                 if (n.length !== s) ensure().length = s;
             } else if (!isEqual(n[e], s) || !hasOwn.call(n, e)) {
@@ -487,10 +522,10 @@ i = false) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
             let a;
-            if (o.u & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            if (o.l & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
             const f = !!a;
-            const l = r ?? n;
-            if (!f && e in l) delete ensure()[e];
+            const u = r ?? n;
+            if (!f && e in u) delete ensure()[e];
         }
     }
     return r ?? n;
@@ -499,7 +534,9 @@ i = false) {
 function createOptimisticStore(e, n, t) {
     const i = typeof e === "function";
     const r = i ? t : n;
-    const o = i ? n : e;
+    // Seedless derived form: the root starts as an empty record (see
+    // createProjectionInternal).
+        const o = i ? n || {} : e;
     const s = r?.key === undefined ? "id" : r.key;
     const a = {
         map: new WeakMap,
@@ -510,7 +547,7 @@ function createOptimisticStore(e, n, t) {
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
     const f = wrap(o, null, null, a);
-    nameStore(f, r?.name);
+    nameStore(f, r?.name, r?.loc);
     if (a.shallow) {
         f[$TARGET].s = true;
         markRawIngest(o);
@@ -521,15 +558,16 @@ function createOptimisticStore(e, n, t) {
         if (r?.seedLoadingValue) t = {
             loadingValue: undefined
         };
-        if (r?.name) t = {
+        if (r?.name || r?.loc) t = {
             ...t,
-            name: r.name
+            name: r.name,
+            loc: r.loc
         };
         const i = computed(() => {
             if (!a.node) a.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
-        i.u &= ~CONFIG_AUTO_DISPOSE;
+        i.l &= ~CONFIG_AUTO_DISPOSE;
         a.node = i;
     }
     return [ f, e => storeSetter(f, e) ];