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

package/dist/prod/store/reconcile.js

@@ -8,7 +8,7 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_NODE, storeLookup, STORE_LOOKUP, $PROXY, isWrappable, wrap, notifySelf, $TRACK, STORE_DESC, STORE_HAS, getKeys, $DELETED, symbolKeyedRecords, getStoreSymbols } from "./store.js";
+import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_NODE, storeLookup, STORE_LOOKUP, $PROXY, isWrappable, wrap, notifySelf, $TRACK, STORE_DESC, STORE_HAS, symbolKeyedRecords, getKeys, $DELETED, getStoreSymbols } from "./store.js";
 
 // Enumerate a node record's keys. Keeps the common string-key path on the
 // `Object.keys` fast path; only records currently holding a user symbol node
@@ -155,9 +155,9 @@ function applyArrayItem(e, t, r, n, a) {
         if (!isWrappable(c)) continue;
         const u = (l.get(c) ?? storeLookup.get(c))?.[$TARGET];
         if (!u?.[STORE_DESC]) continue;
-        const S = unwrap(t[f]);
-        if (c === S || !isWrappable(S) || Array.isArray(c) !== Array.isArray(S) || a(c) != null && a(c) !== a(S)) continue;
-        applyState(S, wrap(c, r), a);
+        const y = unwrap(t[f]);
+        if (c === y || !isWrappable(y) || Array.isArray(c) !== Array.isArray(y) || a(c) != null && a(c) !== a(y)) continue;
+        applyState(y, wrap(c, r), a);
     }
 }
 
@@ -191,7 +191,7 @@ function applyStateFast(e, t, r) {
         let i = false;
         const o = n.length;
         if (e.length && o && isWrappable(e[0]) && r(e[0]) != null) {
-            let l, s, p, f, c, u, S, y;
+            let l, s, p, f, c, u, y, S;
             for (p = 0, f = Math.min(o, e.length); p < f && keyedMatch(u = n[p], e[p], r); p++) {
                 isWrappable(u) && isWrappable(e[p]) && applyState(e[p], wrap(u, t), r);
             }
@@ -214,22 +214,22 @@ function applyStateFast(e, t, r) {
                 o !== e.length && a?.length && setSignal(a.length, e.length);
                 return;
             }
-            S = new Array(c + 1);
+            y = new Array(c + 1);
             for (s = c; s >= p; s--) {
                 u = e[s];
-                y = itemKey(u, r);
-                l = O.get(y);
-                S[s] = l === undefined ? -1 : l;
-                O.set(y, s);
+                S = itemKey(u, r);
+                l = O.get(S);
+                y[s] = l === undefined ? -1 : l;
+                O.set(S, s);
             }
             for (l = p; l <= f; l++) {
                 u = n[l];
-                y = itemKey(u, r);
-                s = O.get(y);
+                S = itemKey(u, r);
+                s = O.get(S);
                 if (s !== undefined && s !== -1) {
                     E[s] = u;
-                    s = S[s];
-                    O.set(y, s);
+                    s = y[s];
+                    O.set(S, s);
                 }
             }
             for (s = p; s < e.length; s++) {
@@ -260,17 +260,18 @@ function applyStateFast(e, t, r) {
     let o;
     if (i) {
         o = i[$TRACK];
-        const a = o ? getAllKeys(n, undefined, e) : nodeKeys(i);
-        for (let l = 0, s = a.length; l < s; l++) {
-            const s = a[l];
-            const p = i[s];
-            const f = unwrap(n[s]);
-            let c = unwrap(e[s]);
-            if (f === c) continue;
-            if (!f || !isWrappable(f) || !isWrappable(c) || Array.isArray(f) !== Array.isArray(c) || r(f) != null && r(f) !== r(c)) {
-                o && setSignal(o, void 0);
-                p && setSignal(p, isWrappable(c) ? wrap(c, t) : c);
-            } else applyState(c, wrap(f, t), r);
+        if (o || symbolKeyedRecords.has(i)) {
+            const a = o ? getAllKeys(n, undefined, e) : nodeKeys(i);
+            for (let l = 0, s = a.length; l < s; l++) {
+                diffNodeKey(a[l], i, n, e, t, o, r);
+            }
+        } else {
+            // Untracked, string-only node records (the overwhelmingly common case)
+            // iterate in place — nodeKeys() allocated a fresh key array per object
+            // per pass, which dominates allocation on large-graph reconciles.
+            for (const a in i) {
+                diffNodeKey(a, i, n, e, t, o, r);
+            }
         }
     }
     if (!o && t[STORE_DESC]) applyDescendants(n, e, t, i, r);
@@ -284,6 +285,19 @@ function applyStateFast(e, t, r) {
     }
 }
 
+// One node-key step of the fast object diff — shared by the array-iterating
+// (tracked / symbol-keyed) and for-in (plain) loops in applyStateFast.
+function diffNodeKey(e, t, r, n, a, i, o) {
+    const l = t[e];
+    const s = unwrap(r[e]);
+    let p = unwrap(n[e]);
+    if (s === p) return;
+    if (!s || !isWrappable(s) || !isWrappable(p) || Array.isArray(s) !== Array.isArray(p) || o(s) != null && o(s) !== o(p)) {
+        i && setSignal(i, void 0);
+        l && setSignal(l, isWrappable(p) ? wrap(p, a) : p);
+    } else applyState(p, wrap(s, a), o);
+}
+
 function applyStateSlow(e, t, r) {
     const n = t[STORE_VALUE];
     const a = t[STORE_OVERRIDE];
@@ -298,23 +312,23 @@ function applyStateSlow(e, t, r) {
         let l = false;
         const s = getOverrideValue(n, a, "length", i);
         if (e.length && s && isWrappable(e[0]) && r(e[0]) != null) {
-            let p, f, c, u, S, y, E, O;
-            for (c = 0, u = Math.min(s, e.length); c < u && keyedMatch(y = getOverrideValue(n, a, c, i), e[c], r); c++) {
-                isWrappable(y) && isWrappable(e[c]) && applyState(e[c], wrap(y, t), r);
+            let p, f, c, u, y, S, E, O;
+            for (c = 0, u = Math.min(s, e.length); c < u && keyedMatch(S = getOverrideValue(n, a, c, i), e[c], r); c++) {
+                isWrappable(S) && isWrappable(e[c]) && applyState(e[c], wrap(S, t), r);
             }
-            const R = new Array(e.length), d = new Map;
-            for (u = s - 1, S = e.length - 1; u >= c && S >= c && keyedMatch(y = getOverrideValue(n, a, u, i), e[S], r); u--, 
-            S--) {
-                R[S] = y;
+            const d = new Array(e.length), R = new Map;
+            for (u = s - 1, y = e.length - 1; u >= c && y >= c && keyedMatch(S = getOverrideValue(n, a, u, i), e[y], r); u--, 
+            y--) {
+                d[y] = S;
             }
-            if (c > S || c > u) {
-                for (f = c; f <= S; f++) {
+            if (c > y || c > u) {
+                for (f = c; f <= y; f++) {
                     l = true;
                     o?.[f] && setSignal(o[f], wrapValue(e[f], t));
                 }
                 for (;f < e.length; f++) {
                     l = true;
-                    applyArrayItem(e[f], R[f], t, o?.[f], r);
+                    applyArrayItem(e[f], d[f], t, o?.[f], r);
                 }
                 const n = e.length;
                 syncArrayNodeMembership(t, e);
@@ -322,27 +336,27 @@ function applyStateSlow(e, t, r) {
                 s !== n && o?.length && setSignal(o.length, n);
                 return;
             }
-            E = new Array(S + 1);
-            for (f = S; f >= c; f--) {
-                y = e[f];
-                O = itemKey(y, r);
-                p = d.get(O);
+            E = new Array(y + 1);
+            for (f = y; f >= c; f--) {
+                S = e[f];
+                O = itemKey(S, r);
+                p = R.get(O);
                 E[f] = p === undefined ? -1 : p;
-                d.set(O, f);
+                R.set(O, f);
             }
             for (p = c; p <= u; p++) {
-                y = getOverrideValue(n, a, p, i);
-                O = itemKey(y, r);
-                f = d.get(O);
+                S = getOverrideValue(n, a, p, i);
+                O = itemKey(S, r);
+                f = R.get(O);
                 if (f !== undefined && f !== -1) {
-                    R[f] = y;
+                    d[f] = S;
                     f = E[f];
-                    d.set(O, f);
+                    R.set(O, f);
                 }
             }
             for (f = c; f < e.length; f++) {
-                if (f in R) {
-                    applyArrayItem(e[f], R[f], t, o?.[f], r);
+                if (f in d) {
+                    applyArrayItem(e[f], d[f], t, o?.[f], r);
                 } else o?.[f] && setSignal(o[f], wrapValue(e[f], t));
             }
             if (c < e.length) l = true;
@@ -373,12 +387,12 @@ function applyStateSlow(e, t, r) {
             const f = s[p];
             const c = o[f];
             const u = unwrap(getOverrideValue(n, a, f, i));
-            let S = unwrap(e[f]);
-            if (u === S) continue;
-            if (!u || !isWrappable(u) || !isWrappable(S) || Array.isArray(u) !== Array.isArray(S) || r(u) != null && r(u) !== r(S)) {
+            let y = unwrap(e[f]);
+            if (u === y) continue;
+            if (!u || !isWrappable(u) || !isWrappable(y) || Array.isArray(u) !== Array.isArray(y) || r(u) != null && r(u) !== r(y)) {
                 l && setSignal(l, void 0);
-                c && setSignal(c, isWrappable(S) ? wrap(S, t) : S);
-            } else applyState(S, wrap(u, t), r);
+                c && setSignal(c, isWrappable(y) ? wrap(y, t) : y);
+            } else applyState(y, wrap(u, t), r);
         }
     }
     if (!l && t[STORE_DESC]) applyDescendants(n, e, t, o, r, a, i);
@@ -392,17 +406,27 @@ function applyStateSlow(e, t, r) {
     }
 }
 
+// No-key reconcile: every item reports "no key", which routes array diffs to
+// the positional branch and object descent to plain per-property merging.
+const NOKEY = () => null;
+
 /**
  * Returns a draft-mutating function that smart-merges `value` into a store,
- * preserving the identity of items whose `key` field matches between old and
- * new states. Useful when applying server payloads or full-replacement data
- * onto an existing store without losing fine-grained reactivity.
+ * preserving fine-grained reactivity: only changed leaves trigger updates.
+ *
+ * With a `key` (default `"id"`), array items whose key matches between old
+ * and new states keep their identity (updated in place, moves and removals
+ * update the corresponding signals) — the shape for keyed server payloads.
+ * Items without the key field fall back to positional matching.
  *
- * Items with the same key are updated in place (only changed properties
- * trigger updates). Items added or removed update the corresponding signals.
+ * With `key: null`, matching is purely positional: index N of the new array
+ * merges into index N of the old, and object properties merge recursively —
+ * the classic pattern for fixed-shape data that churns in place (dashboards,
+ * monitors), where no keyed diff pass is needed or wanted.
  *
  * @param value the next state to merge in
- * @param key property name (string) or extractor function for stable identity
+ * @param key property name (string) or extractor function for stable
+ * identity (default `"id"`); pass `null` for positional merging
  *
  * @example
  * ```ts
@@ -410,12 +434,19 @@ function applyStateSlow(e, t, r) {
  *
  * async function refresh() {
  *   const fresh = await api.getTodos();
- *   setTodos(reconcile(fresh, "id")); // diff-merge by `id`
+ *   setTodos(reconcile(fresh)); // diff-merge by `id`
  * }
+ *
+ * // fixed-shape polling data — positional merge
+ * setStats(reconcile(nextStats, null));
  * ```
- */ function reconcile(e, t) {
+ */ function reconcile(e, t = "id") {
     return r => {
         if (r == null) throw new Error("");
+        if (t === null) {
+            applyState(e, r, NOKEY);
+            return;
+        }
         const n = typeof t === "string" ? e => e[t] : t;
         const a = n(r);
         if (a !== undefined && n(e) !== a) throw new Error("");