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

package/dist/prod/core/verdict.js

@@ -32,15 +32,15 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.ge) {
+    if (!e.be) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.ge = optimisticSignal(false, {
+        e.be = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.ge.nn = e;
-        if (computePendingState(e)) setSignal(e.ge, true);
+        e.be.nn = e;
+        if (computePendingState(e)) setSignal(e.be, true);
     }
-    return e.ge;
+    return e.be;
 }
 
 function collectPendingSources(e) {
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.be) return false;
+        for (const t of e.oe) if (!t._e) return false;
         return true;
     }
-    return e.be;
+    return e._e;
 }
 
 function newQuestionInFlight(e) {
@@ -129,27 +129,27 @@ function computePendingState(e) {
         return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     if (e.Ne !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Pe || !e.Pe(e.Ne, unwrapOverride(e.Ee));
+        if (hasActiveOverride(e)) return !e.Re || !e.Re(e.Ne, unwrapOverride(e.Ee));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.ge) updatePendingSignal(e);
-    if (e.he) setSignal(e.he, t);
+    if (e.be) updatePendingSignal(e);
+    if (e.ge) setSignal(e.ge, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.ge) {
-        setSignal(e.ge, computePendingState(e));
+    if (e.be) {
+        setSignal(e.be, computePendingState(e));
     }
-    if (e.he) updatePendingSignal(e.he);
+    if (e.ge) updatePendingSignal(e.ge);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.fe) {
-        if (t.ge || t.he) updatePendingSignal(t);
+        if (t.be || t.ge) updatePendingSignal(t);
     }
 }
 
@@ -167,7 +167,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.ge || e.he) n(e);
+        if (e.be || e.ge) n(e);
         for (let t = e.o; t !== null; t = t.ue) visit(t.le);
         for (let t = e.u ?? null; t !== null; t = t.fe) {
             visit(t);
@@ -177,20 +177,20 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.ge;
+    const t = e.be;
     if (t && (t.Ee === undefined || t.Ee === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Re !== n || t.Ne !== NOT_PENDING) {
-            t.Re = n;
+        if (t.Pe !== n || t.Ne !== NOT_PENDING) {
+            t.Pe = n;
             t.Ne = NOT_PENDING;
             t.ce = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.he;
+    const n = e.ge;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Re, e.Re) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Pe, e.Pe) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -201,7 +201,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.he) {
+    if (!e.ge) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -209,21 +209,21 @@ function getLatestValueComputed(e) {
         const i = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.he = optimisticComputed(() => read(e));
-        e.he.nn = e;
+                e.ge = optimisticComputed(() => read(e));
+        e.ge.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.he;
+    return e.ge;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Re;
+    const i = e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Pe;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -232,7 +232,7 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.He >= e.Fe && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Fe >= e.He && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
@@ -279,9 +279,9 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.be);
-    const r = n && e.be !== i;
-    e.be = i;
+    const i = t && !(n && !e._e);
+    const r = n && e._e !== i;
+    e._e = i;
     return r;
 }
 
@@ -339,7 +339,7 @@ GlobalQueue.Ie = syncCompanions;
 
 GlobalQueue.ae = updatePendingSignal;
 
-GlobalQueue._e = updateChildCompanions;
+GlobalQueue.he = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 

package/dist/prod/map.js

@@ -118,22 +118,29 @@ function updateKeyedMap() {
             this.Mt = t.slice(0);
             this.jt = s;
         } else {
-            let o, c, a, f, u, p, w, l, d, O = new Array(s), m = new Array(s);
-            r = this.Ut ? new Array(s) : undefined;
-            n = this.$t ? new Array(s) : undefined;
+            let o, c, a, f, u, p, w, l, d;
             // skip common prefix
                         for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.Ut && compare(this.Gt, this.Mt[o], t[o])); o++) {
                 if (this.Ut) setSignal(this.Ut[o], t[o]);
             }
-            // common suffix
+            // skip common suffix — counted only; retained entries land in one pass
+            // at commit instead of being staged and copied twice
                         for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.Ut && compare(this.Gt, this.Mt[c], t[a])); c--, 
-            a--) {
-                O[a] = this.xt[c];
-                m[a] = this.Ft[c];
-                r && (r[a] = this.Ut[c]);
-                n && (n[a] = this.$t[c]);
+            a--) ;
+            // 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 (o === s && this.jt === s) {
+                this.Mt = t.slice(0);
+                return;
             }
-            // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
+            const O = s - this.jt;
+            const m = new Array(s);
+            const _ = new Array(s);
+            r = this.Ut ? new Array(s) : undefined;
+            n = this.$t ? new Array(s) : undefined;
+            // 0) prepare a map of all indices in the changed window of newItems,
+            // scanning backwards so we encounter them in natural order
                         p = new Map;
             w = new Array(a + 1);
             for (e = a; e >= o; e--) {
@@ -143,14 +150,16 @@ function updateKeyedMap() {
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
             }
-            // 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 = o; i <= c; i++) {
                 f = this.Mt[i];
                 u = this.Gt ? this.Gt(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    O[e] = this.xt[i];
-                    m[e] = this.Ft[i];
+                    m[e] = this.xt[i];
+                    _[e] = this.Ft[i];
                     r && (r[e] = this.Ut[i]);
                     n && (n[e] = this.$t[i]);
                     e = w[e];
@@ -159,33 +168,48 @@ function updateKeyedMap() {
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (e = o; e < s; e++) {
-                    if (e in O) continue;
-                    (d ??= []).push(m[e] = createOwner());
-                    O[e] = runWithOwner(m[e], h);
+                for (e = o; e <= a; e++) {
+                    if (_[e] !== undefined) continue;
+                    (d ??= []).push(_[e] = createOwner());
+                    m[e] = runWithOwner(_[e], h);
                 }
             } catch (t) {
                 if (d) for (i = 0; i < d.length; i++) d[i].dispose();
                 throw t;
             }
-            // 3) commit: land positions, then dispose exited rows
-                        for (e = o; e < s; e++) {
-                this.xt[e] = O[e];
-                this.Ft[e] = m[e];
+            // 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 < o; i++) {
+                m[i] = this.xt[i];
+                _[i] = this.Ft[i];
+                r && (r[i] = this.Ut[i]);
+                n && (n[i] = this.$t[i]);
+            }
+            for (e = o; e <= a; e++) {
+                if (r) setSignal(r[e], t[e]);
+                if (n) setSignal(n[e], e);
+            }
+            for (e = a + 1; e < s; e++) {
+                m[e] = this.xt[e - O];
+                _[e] = this.Ft[e - O];
                 if (r) {
-                    this.Ut[e] = r[e];
-                    setSignal(this.Ut[e], t[e]);
+                    r[e] = this.Ut[e - O];
+                    setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    this.$t[e] = n[e];
-                    setSignal(this.$t[e], e);
+                    n[e] = this.$t[e - O];
+                    if (O !== 0) setSignal(n[e], e);
                 }
             }
-            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
-            // 4) in case the new set is shorter than the old, set the length of the mapped array
-                        this.xt = this.xt.slice(0, this.jt = s);
-            // 5) save a copy of the mapped items for the next update
+            this.xt = m;
+            this.Ft = _;
+            r && (this.Ut = r);
+            n && (this.$t = n);
+            this.jt = s;
+            // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
+            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
         }
     });
     return this.xt;

package/dist/prod/store/optimistic.js

@@ -16,17 +16,17 @@ import { runProjectionComputed } from "./projection.js";
 
 import { storeSetter, $TARGET, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_OPTIMISTIC, STORE_FIREWALL } from "./store.js";
 
-function createOptimisticStore(e, t, r) {
+function createOptimisticStore(e, t, i) {
     // Register clear function with scheduler; store nodes marked
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
     GlobalQueue.Dt ||= clearOptimisticStores;
-    const i = typeof e === "function";
-    const o = i ? t : e;
-    const n = i ? e : undefined;
+    const r = typeof e === "function";
+    const o = r ? t : e;
+    const n = r ? e : undefined;
     // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, r);
+        const {store: c} = createOptimisticProjectionInternal(n, o, i);
     return [ c, e => storeSetter(c, e) ];
 }
 
@@ -35,8 +35,8 @@ function createOptimisticStore(e, t, r) {
 // scheduler's flush tail carries only a size-guarded hook call. The
 // completing transition scopes each clear to its own layer keys (#2899).
 function clearOptimisticStores(e, t) {
-    for (const r of e) {
-        const e = r[$TARGET];
+    for (const i of e) {
+        const e = i[$TARGET];
         if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
     e.clear();
@@ -54,9 +54,9 @@ function clearOptimisticStores(e, t) {
  * fresh authoritative data) consumes everything — the correction supersedes
  * every tentative layer.
  */ function clearOptimisticOverride(e, t) {
-    const r = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!r) return;
-    const i = e[STORE_NODE];
+    const i = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!i) return;
+    const r = e[STORE_NODE];
     const o = e[STORE_OPTIMISTIC_OWNERS];
     const n = t !== undefined;
     let c = false;
@@ -66,7 +66,7 @@ function clearOptimisticStores(e, t) {
         const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        for (const O of Reflect.ownKeys(r)) {
+        for (const O of Reflect.ownKeys(i)) {
             if (n) {
                 let e = o?.[O] ?? null;
                 // Resolve merge chains (entangled actions settle as one); path-compress
@@ -83,37 +83,39 @@ function clearOptimisticStores(e, t) {
                     }
                 }
             }
-            delete r[O];
+            delete i[O];
             if (o) delete o[O];
             c = true;
-            const T = i?.[O];
+            const T = r?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
                 T.je = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, O);
-                const r = t ? t[O] : e[STORE_VALUE][O];
-                const i = r === $DELETED ? undefined : r;
-                const o = isWrappable(i) ? wrap(i, e) : i;
+                const i = t ? t[O] : e[STORE_VALUE][O];
+                const r = i === $DELETED ? undefined : i;
+                const o = isWrappable(r) ? wrap(r, e) : r;
                 const n = visibleNodeValue(T);
                 T.Ee = NOT_PENDING;
                 T.sn = null;
                 T.Ne = NOT_PENDING;
-                T.Re = o;
-                if (!T.Pe || !T.Pe(n, o)) {
+                T.Pe = o;
+                if (!T.Re || !T.Re(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }
             }
         }
         if (!s) {
-            delete e[STORE_OPTIMISTIC_OVERRIDE];
-            delete e[STORE_OPTIMISTIC_OWNERS];
+            // Assignment, not delete: StoreNode targets share one pre-initialized
+            // hidden class (see createStoreProxy) and a delete would demote it.
+            e[STORE_OPTIMISTIC_OVERRIDE] = undefined;
+            e[STORE_OPTIMISTIC_OWNERS] = undefined;
         }
         // Notify $TRACK
-                if (c && i?.[$TRACK]) {
-            i[$TRACK].je = undefined;
+                if (c && r?.[$TRACK]) {
+            r[$TRACK].je = undefined;
             notifySelf(e);
         }
     } finally {
@@ -121,8 +123,8 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, r) {
-    let i;
+function createOptimisticProjectionInternal(e, t, i) {
+    let r;
     const o = new WeakMap;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
@@ -131,7 +133,7 @@ function createOptimisticProjectionInternal(e, t, r) {
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return i;
+                return r;
             },
             configurable: true
         });
@@ -165,19 +167,19 @@ function createOptimisticProjectionInternal(e, t, r) {
                 setProjectionWriteActive(t);
             }
         };
-        i = computed(() => {
+        r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(n, e, r?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(n, e, i?.key || "id", wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        i.T &= ~CONFIG_AUTO_DISPOSE;
+        r.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: n,
-        node: i
+        node: r
     };
 }