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

package/dist/dev.js

@@ -1569,8 +1569,17 @@ function unlinkSubs(link) {
     if (nextSub === null) {
       dep._unobserved?.();
       // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+      // A pending node is exempt: its in-flight async work (or the
+      // transition holding it) is an observer — tearing down would orphan
+      // the work and re-execute it on the next read. The settle path runs
+      // this same last-one-out check when that observer releases (the
+      // untracked-read dispose in core.ts guards on pending identically).
       const c = dep;
-      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
+      c._fn &&
+        c._config & CONFIG_AUTO_DISPOSE &&
+        !(c._flags & REACTIVE_ZOMBIE) &&
+        !(c._statusFlags & STATUS_PENDING) &&
+        unobserved(c);
     }
   }
   return nextDep;
@@ -1847,6 +1856,16 @@ function handleAsync(el, result, setter) {
     flush();
     then?.();
   };
+  // A pending node's in-flight promise is an observer: `unlinkSubs` skips
+  // autodispose while STATUS_PENDING so subscriber churn can't orphan the
+  // work (a lazy async memo would otherwise tear down and re-execute — one
+  // fetch per suspended re-read). Settling is that observer's release, so
+  // it runs the same last-one-out check the other release sites run.
+  const settleAutodispose = () => {
+    if (el._config & CONFIG_AUTO_DISPOSE && !el._subs && !(el._statusFlags & STATUS_PENDING)) {
+      unobserved(el);
+    }
+  };
   if (thenable) {
     let resolved = false,
       rejected = false,
@@ -1857,13 +1876,19 @@ function handleAsync(el, result, setter) {
         if (isSync) {
           syncValue = v;
           resolved = true;
-        } else asyncWrite(v);
+        } else {
+          asyncWrite(v);
+          settleAutodispose();
+        }
       },
       e => {
         if (isSync) {
           syncError = e;
           rejected = true;
-        } else handleError(e);
+        } else {
+          handleError(e);
+          settleAutodispose();
+        }
       }
     );
     isSync = false;
@@ -2113,7 +2138,10 @@ function clearSnapshots() {
   if (snapshotSources) {
     for (const source of snapshotSources) {
       delete source._snapshotValue;
-      delete source[STORE_SNAPSHOT_PROPS];
+      // StoreNode targets share one pre-initialized hidden class (see
+      // createStoreProxy) — assign undefined instead of deleting, and only
+      // when present so signal-node sources don't grow the field.
+      if (source[STORE_SNAPSHOT_PROPS] !== undefined) source[STORE_SNAPSHOT_PROPS] = undefined;
     }
     snapshotSources = null;
   }
@@ -4738,23 +4766,18 @@ function applyStateFast(next, target, keyFn) {
   let tracked;
   if (nodes) {
     tracked = nodes[$TRACK];
-    const keys = tracked ? getAllKeys(previous, undefined, next) : nodeKeys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const key = keys[i];
-      const node = nodes[key];
-      const previousValue = unwrap(previous[key]);
-      let nextValue = unwrap(next[key]);
-      if (previousValue === nextValue) continue;
-      if (
-        !previousValue ||
-        !isWrappable(previousValue) ||
-        !isWrappable(nextValue) ||
-        Array.isArray(previousValue) !== Array.isArray(nextValue) ||
-        (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
-      ) {
-        tracked && setSignal(tracked, void 0);
-        node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else applyState(nextValue, wrap(previousValue, target), keyFn);
+    if (tracked || symbolKeyedRecords.has(nodes)) {
+      const keys = tracked ? getAllKeys(previous, undefined, next) : nodeKeys(nodes);
+      for (let i = 0, len = keys.length; i < len; i++) {
+        diffNodeKey(keys[i], nodes, previous, next, target, tracked, keyFn);
+      }
+    } 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 key in nodes) {
+        diffNodeKey(key, nodes, previous, next, target, tracked, keyFn);
+      }
     }
   }
   if (!tracked && target[STORE_DESC]) applyDescendants(previous, next, target, nodes, keyFn);
@@ -4767,6 +4790,24 @@ function applyStateFast(next, target, keyFn) {
     }
   }
 }
+// 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(key, nodes, previous, next, target, tracked, keyFn) {
+  const node = nodes[key];
+  const previousValue = unwrap(previous[key]);
+  let nextValue = unwrap(next[key]);
+  if (previousValue === nextValue) return;
+  if (
+    !previousValue ||
+    !isWrappable(previousValue) ||
+    !isWrappable(nextValue) ||
+    Array.isArray(previousValue) !== Array.isArray(nextValue) ||
+    (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
+  ) {
+    tracked && setSignal(tracked, void 0);
+    node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+  } else applyState(nextValue, wrap(previousValue, target), keyFn);
+}
 function applyStateSlow(next, target, keyFn) {
   const previous = target[STORE_VALUE];
   const override = target[STORE_OVERRIDE];
@@ -4904,17 +4945,26 @@ function applyStateSlow(next, target, keyFn) {
     }
   }
 }
+// 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
@@ -4922,13 +4972,20 @@ function applyStateSlow(next, target, keyFn) {
  *
  * 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(value, key) {
+function reconcile(value, key = "id") {
   return state => {
     if (state == null) throw new Error("Cannot reconcile null or undefined state");
+    if (key === null) {
+      applyState(value, state, NOKEY);
+      return;
+    }
     const keyFn = typeof key === "string" ? item => item[key] : key;
     const eq = keyFn(state);
     if (eq !== undefined && keyFn(value) !== eq)
@@ -5131,13 +5188,37 @@ const STORE_VALUE = "v",
   STORE_PARENT = "u",
   STORE_DESC = "d";
 const STORE_SELF_PENDING = Symbol("STORE_SELF_PENDING");
+// Every StoreNode field is initialized up front, in one fixed order, so all
+// targets share a single hidden class. The traps and reconcile read these
+// fields on their hottest paths; fields added lazily in varying orders made
+// those loads megamorphic across a large store graph (dictionary-mode probes
+// on every trap hit). Assignments elsewhere must never `delete` a field —
+// write `undefined` instead, or the shape degrades again.
+function initStoreFields(newTarget) {
+  newTarget[STORE_OVERRIDE] = undefined;
+  newTarget[STORE_OPTIMISTIC_OVERRIDE] = undefined;
+  newTarget[STORE_OPTIMISTIC_OWNERS] = undefined;
+  newTarget[STORE_NODE] = undefined;
+  newTarget[STORE_HAS] = undefined;
+  newTarget[STORE_CUSTOM_PROTO] = undefined;
+  newTarget[STORE_WRAP] = undefined;
+  newTarget[STORE_LOOKUP] = undefined;
+  newTarget[STORE_FIREWALL] = undefined;
+  newTarget[STORE_OPTIMISTIC] = undefined;
+  newTarget[STORE_SNAPSHOT_PROPS] = undefined;
+  newTarget[STORE_PARENT] = undefined;
+  newTarget[STORE_DESC] = undefined;
+  newTarget[$PROXY] = null;
+}
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
     newTarget = [];
-    newTarget.v = value;
+    newTarget[STORE_VALUE] = value;
+    initStoreFields(newTarget);
   } else {
-    newTarget = { v: value };
+    newTarget = { [STORE_VALUE]: value };
+    initStoreFields(newTarget);
     const unwrapped = value?.[$TARGET]?.[STORE_VALUE] ?? value;
     const proto = Object.getPrototypeOf(unwrapped);
     if (proto !== null && proto !== Object.prototype) {
@@ -5716,6 +5797,28 @@ const storeTraps = {
       trackSelf(target);
       return receiver;
     }
+    // Hot path: an existing node on a plain target — no firewall (so neither
+    // selfRead nor the uninitialized guard can apply), no override layers,
+    // no write scope, and a raw (non-proxy) source. This is the shape of
+    // every effect re-read of a settled store; it pays one node read and the
+    // wrap check, nothing else. Any exotic bit falls through to the full
+    // resolution below, and dev strictRead keeps its warning path.
+    if (
+      !strictRead &&
+      target[STORE_FIREWALL] === undefined &&
+      target[STORE_OVERRIDE] === undefined &&
+      target[STORE_OPTIMISTIC_OVERRIDE] === undefined &&
+      !writeOverride &&
+      (Writing === null || !Writing.has(receiver))
+    ) {
+      const nodes = target[STORE_NODE];
+      const node = nodes && nodes[property];
+      if (node !== undefined && target[STORE_VALUE][$TARGET] === undefined) {
+        let value = read(node);
+        if (value === $DELETED) value = undefined;
+        return isWrappable(value) ? wrap(value, target) : value;
+      }
+    }
     const selfRead = getObserver() === target[STORE_FIREWALL];
     const nodes = getNodes(target, STORE_NODE);
     const tracked = selfRead ? undefined : nodes[property];
@@ -6305,8 +6408,10 @@ function clearOptimisticOverride(target, completing) {
       }
     }
     if (!remaining) {
-      delete target[STORE_OPTIMISTIC_OVERRIDE];
-      delete target[STORE_OPTIMISTIC_OWNERS];
+      // Assignment, not delete: StoreNode targets share one pre-initialized
+      // hidden class (see createStoreProxy) and a delete would demote it.
+      target[STORE_OPTIMISTIC_OVERRIDE] = undefined;
+      target[STORE_OPTIMISTIC_OWNERS] = undefined;
     }
     // Notify $TRACK
     if (cleared && nodes?.[$TRACK]) {
@@ -6499,6 +6604,18 @@ function snapshotImpl(item, track, map, lookup) {
       if (pendingCheckActive) witnessAffectsMark(target);
     }
     override = mergedOverlay(target);
+    // A derived store's STORE_VALUE is the inner store's live proxy
+    // (store-in-store: createOptimisticStore/createProjection over a store).
+    // Without an overlay of its own, the fast path below would map to — and
+    // could return — that proxy verbatim. Recurse instead so the
+    // inner store's own target branch unwraps it (chains of any depth).
+    // With an overlay, a fresh `result` is always built, so the walk over the
+    // inner proxy already copies plain values.
+    if (!override && target[STORE_VALUE][$TARGET]) {
+      unwrapped = snapshotImpl(target[STORE_VALUE], track, map, lookup);
+      map.set(item, unwrapped);
+      return unwrapped;
+    }
     isArray = Array.isArray(target[STORE_VALUE]);
     map.set(
       item,
@@ -6912,19 +7029,7 @@ function updateKeyedMap() {
       this._items = newItems.slice(0);
       this._len = newLen;
     } else {
-      let start,
-        end,
-        newEnd,
-        item,
-        key,
-        newIndices,
-        newIndicesNext,
-        removed,
-        created,
-        temp = new Array(newLen),
-        tempNodes = new Array(newLen);
-      rows = this._rows ? new Array(newLen) : undefined;
-      indexes = this._indexes ? new Array(newLen) : undefined;
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, removed, created;
       // skip common prefix
       for (
         start = 0, end = Math.min(this._len, newLen);
@@ -6935,7 +7040,8 @@ function updateKeyedMap() {
       ) {
         if (this._rows) setSignal(this._rows[start], newItems[start]);
       }
-      // common suffix
+      // skip common suffix — counted only; retained entries land in one pass
+      // at commit instead of being staged and copied twice
       for (
         end = this._len - 1, newEnd = newLen - 1;
         end >= start &&
@@ -6943,13 +7049,21 @@ function updateKeyedMap() {
         (this._items[end] === newItems[newEnd] ||
           (this._rows && compare(this._key, this._items[end], newItems[newEnd])));
         end--, newEnd--
-      ) {
-        temp[newEnd] = this._mappings[end];
-        tempNodes[newEnd] = this._nodes[end];
-        rows && (rows[newEnd] = this._rows[end]);
-        indexes && (indexes[newEnd] = this._indexes[end]);
+      );
+      // no structural change (every position matched in place at equal
+      // length — the common post-reconcile shape): keep the same mapped
+      // array identity so downstream consumers don't re-run at all
+      if (start === newLen && this._len === newLen) {
+        this._items = newItems.slice(0);
+        return;
       }
-      // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
+      const dif = newLen - this._len;
+      const temp = new Array(newLen);
+      const tempNodes = new Array(newLen);
+      rows = this._rows ? new Array(newLen) : undefined;
+      indexes = this._indexes ? new Array(newLen) : undefined;
+      // 0) prepare a map of all indices in the changed window of newItems,
+      // scanning backwards so we encounter them in natural order
       newIndices = new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
@@ -6959,7 +7073,9 @@ function updateKeyedMap() {
         newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(key, j);
       }
-      // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
+      // 1) step through the old changed window and see if items can be found
+      // in the new set; if so, stage them at their new positions; if not,
+      // queue them for disposal at commit
       for (i = start; i <= end; i++) {
         item = this._items[i];
         key = this._key ? this._key(item) : item;
@@ -6975,8 +7091,8 @@ function updateKeyedMap() {
       }
       // 2) create new rows into the temp arrays; an abort disposes only these
       try {
-        for (j = start; j < newLen; j++) {
-          if (j in temp) continue;
+        for (j = start; j <= newEnd; j++) {
+          if (tempNodes[j] !== undefined) continue;
           (created ??= []).push((tempNodes[j] = createOwner()));
           temp[j] = runWithOwner(tempNodes[j], mapper);
         }
@@ -6984,24 +7100,39 @@ function updateKeyedMap() {
         if (created) for (i = 0; i < created.length; i++) created[i].dispose();
         throw err;
       }
-      // 3) commit: land positions, then dispose exited rows
-      for (j = start; j < newLen; j++) {
-        this._mappings[j] = temp[j];
-        this._nodes[j] = tempNodes[j];
+      // 3) commit: land the retained prefix and suffix plus the staged window
+      // into the fresh arrays, swap them in (new identity for downstream
+      // change propagation), then dispose exited rows
+      for (i = 0; i < start; i++) {
+        temp[i] = this._mappings[i];
+        tempNodes[i] = this._nodes[i];
+        rows && (rows[i] = this._rows[i]);
+        indexes && (indexes[i] = this._indexes[i]);
+      }
+      for (j = start; j <= newEnd; j++) {
+        if (rows) setSignal(rows[j], newItems[j]);
+        if (indexes) setSignal(indexes[j], j);
+      }
+      for (j = newEnd + 1; j < newLen; j++) {
+        temp[j] = this._mappings[j - dif];
+        tempNodes[j] = this._nodes[j - dif];
         if (rows) {
-          this._rows[j] = rows[j];
-          setSignal(this._rows[j], newItems[j]);
+          rows[j] = this._rows[j - dif];
+          setSignal(rows[j], newItems[j]);
         }
         if (indexes) {
-          this._indexes[j] = indexes[j];
-          setSignal(this._indexes[j], j);
+          indexes[j] = this._indexes[j - dif];
+          if (dif !== 0) setSignal(indexes[j], j);
         }
       }
-      if (removed) for (i = 0; i < removed.length; i++) removed[i].dispose();
-      // 4) in case the new set is shorter than the old, set the length of the mapped array
-      this._mappings = this._mappings.slice(0, (this._len = newLen));
-      // 5) save a copy of the mapped items for the next update
+      this._mappings = temp;
+      this._nodes = tempNodes;
+      rows && (this._rows = rows);
+      indexes && (this._indexes = indexes);
+      this._len = newLen;
+      // save a copy of the mapped items for the next update
       this._items = newItems.slice(0);
+      if (removed) for (i = 0; i < removed.length; i++) removed[i].dispose();
     }
   });
   return this._mappings;