@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/prod/core/verdict.js

@@ -32,21 +32,21 @@ 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.be) {
+    if (!e.he) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.be = optimisticSignal(false, {
+        e.he = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.be.nn = e;
-        if (computePendingState(e)) setSignal(e.be, true);
+        e.he.nn = e;
+        if (computePendingState(e)) setSignal(e.he, true);
     }
-    return e.be;
+    return e.he;
 }
 
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.nt || e;
+    const t = e.it || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -79,17 +79,17 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.nt;
+    const n = e.it;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const i = e;
-    const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.qe : undefined;
+    const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.We : undefined;
     if (r !== null) {
-        for (let e = i.Xe ?? null; e !== null; e = e.et) {
-            if (!e.De && markWalk(e.tt, t)) return true;
+        for (let e = i.et ?? null; e !== null; e = e.tt) {
+            if (!e.Oe && markWalk(e.nt, t)) return true;
             if (e === r) break;
         }
     }
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t._e) return false;
+        for (const t of e.oe) if (!t.Re) return false;
         return true;
     }
-    return e._e;
+    return e.Re;
 }
 
 function newQuestionInFlight(e) {
@@ -119,37 +119,37 @@ function computePendingState(e) {
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
         if (markCovered(e)) return true;
-    const n = e.nt;
+    const n = e.it;
     if (e.nn) {
         const t = e.nn;
-        const n = t.nt || t;
+        const n = t.it || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Ne !== NOT_PENDING && !hasActiveOverride(e)) {
+    if (n && e.De !== NOT_PENDING && !hasActiveOverride(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.Re || !e.Re(e.Ne, unwrapOverride(e.Ee));
+    if (e.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.be || !e.be(e.De, unwrapOverride(e.Ae));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.be) updatePendingSignal(e);
-    if (e.ge) setSignal(e.ge, t);
+    if (e.he) updatePendingSignal(e);
+    if (e.pe) setSignal(e.pe, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.be) {
-        setSignal(e.be, computePendingState(e));
+    if (e.he) {
+        setSignal(e.he, computePendingState(e));
     }
-    if (e.ge) updatePendingSignal(e.ge);
+    if (e.pe) updatePendingSignal(e.pe);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.fe) {
-        if (t.be || t.ge) updatePendingSignal(t);
+        if (t.he || t.pe) updatePendingSignal(t);
     }
 }
 
@@ -167,7 +167,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.be || e.ge) n(e);
+        if (e.he || e.pe) 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.be;
-    if (t && (t.Ee === undefined || t.Ee === NOT_PENDING)) {
+    const t = e.he;
+    if (t && (t.Ae === undefined || t.Ae === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Pe !== n || t.Ne !== NOT_PENDING) {
-            t.Pe = n;
-            t.Ne = NOT_PENDING;
-            t.ce = clock;
+        if (t.Ue !== n || t.De !== NOT_PENDING) {
+            t.Ue = n;
+            t.De = NOT_PENDING;
+            t.Se = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.ge;
+    const n = e.pe;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Pe, e.Pe) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(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.ge) {
+    if (!e.pe) {
         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.ge = optimisticComputed(() => read(e));
-        e.ge.nn = e;
+                e.pe = optimisticComputed(() => read(e));
+        e.pe.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.ge;
+    return e.pe;
 }
 
 /** 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.Pe;
+    const i = e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.Ue;
     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.Ve >= e.He && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
@@ -244,10 +244,10 @@ function getLatestValueComputed(e) {
         setLatestReadActive(n);
     }
     if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.je) {
-        const e = findLane(t.je);
+    if (stale && currentOptimisticLane && t.Me) {
+        const e = findLane(t.Me);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.de.size > 0) {
+        if (e !== n && e.Ne.size > 0) {
             return i;
         }
     }
@@ -255,13 +255,13 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Ne !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ue && activeTransition !== t.Ue)) return t.Ne;
+        if (t.De !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ie && activeTransition !== t.Ie)) return t.De;
     return r;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
-    if (typeof e.ke === "function") prepareComputed(e, true);
+    if (typeof e.ae === "function") prepareComputed(e, true);
     const r = n.S;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
@@ -274,14 +274,14 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Ne !== NOT_PENDING && t === e.Ne) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e.De !== NOT_PENDING && t === e.De) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e._e);
-    const r = n && e._e !== i;
-    e._e = i;
+    const i = t && !(n && !e.Re);
+    const r = n && e.Re !== i;
+    e.Re = i;
     return r;
 }
 
@@ -335,21 +335,21 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Ie = syncCompanions;
+GlobalQueue._e = syncCompanions;
 
-GlobalQueue.ae = updatePendingSignal;
+GlobalQueue.ce = updatePendingSignal;
 
-GlobalQueue.he = updateChildCompanions;
+GlobalQueue.Ge = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.dt = latestRead;
+GlobalQueue.St = latestRead;
 
-GlobalQueue.St = pendingCheckRead;
+GlobalQueue.At = pendingCheckRead;
 
-GlobalQueue.Rt = recordFreshRead;
+GlobalQueue.Pt = recordFreshRead;
 
-GlobalQueue.ze = applyReask;
+GlobalQueue.$e = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 

package/dist/prod/map.js

@@ -27,17 +27,17 @@ function mapArray(t, s, i) {
         Mt: [],
         Kt: n,
         xt: [],
-        Ft: [],
-        Gt: e,
-        Ut: e || i?.keyed === false ? [] : undefined,
-        $t: r && i?.keyed !== false ? [] : undefined,
-        qt: i?.keyed === false,
-        zt: i?.fallback
+        Gt: [],
+        Ut: e,
+        $t: e || i?.keyed === false ? [] : undefined,
+        qt: r && i?.keyed !== false ? [] : undefined,
+        zt: i?.keyed === false,
+        Bt: i?.fallback
     };
     const o = computed(updateKeyedMap.bind(h));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.wt.Nt = o;
+        h.wt.Tt = o;
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -63,14 +63,14 @@ function updateKeyedMap() {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        h = this.Ut ? this.qt ? () => {
+        h = this.$t ? this.zt ? () => {
             r[e] = signal(t[e], pureOptions);
             return this.Kt(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
             return this.Kt(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.$t ? () => {
+        } : this.qt ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
             return this.Kt(s, accessor(n[e]));
@@ -82,26 +82,26 @@ function updateKeyedMap() {
                 if (s === 0) {
             if (this.jt !== 0) {
                 this.wt.dispose(false);
-                this.Ft = [];
+                this.Gt = [];
                 this.Mt = [];
                 this.xt = [];
                 this.jt = 0;
-                this.Ut && (this.Ut = []);
                 this.$t && (this.$t = []);
+                this.qt && (this.qt = []);
             }
-            if (this.zt && !this.xt[0]) {
+            if (this.Bt && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Ft[0]?.dispose();
-                this.xt[0] = runWithOwner(this.Ft[0] = createOwner(), this.zt);
+                this.Gt[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Gt[0] = createOwner(), this.Bt);
             }
         }
         // fast path for new create
          else if (this.jt === 0) {
             const o = new Array(s);
             const c = new Array(s);
-            r = this.Ut && new Array(s);
-            n = this.$t && new Array(s);
+            r = this.$t && new Array(s);
+            n = this.qt && new Array(s);
             try {
                 for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
             } catch (t) {
@@ -109,23 +109,23 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.Ft[0]) this.Ft[0].dispose();
+                        if (this.Gt[0]) this.Gt[0].dispose();
  // previous fallback
                         this.xt = o;
-            this.Ft = c;
-            r && (this.Ut = r);
-            n && (this.$t = n);
+            this.Gt = c;
+            r && (this.$t = r);
+            n && (this.qt = n);
             this.Mt = t.slice(0);
             this.jt = s;
         } else {
             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]);
+                        for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.$t && compare(this.Ut, this.Mt[o], t[o])); o++) {
+                if (this.$t) setSignal(this.$t[o], t[o]);
             }
             // 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--, 
+                        for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.$t && compare(this.Ut, this.Mt[c], t[a])); c--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -137,15 +137,15 @@ function updateKeyedMap() {
             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;
+            r = this.$t ? new Array(s) : undefined;
+            n = this.qt ? 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--) {
                 f = t[e];
-                u = this.Gt ? this.Gt(f) : f;
+                u = this.Ut ? this.Ut(f) : f;
                 i = p.get(u);
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
@@ -155,16 +155,16 @@ function updateKeyedMap() {
             // queue them for disposal at commit
                         for (i = o; i <= c; i++) {
                 f = this.Mt[i];
-                u = this.Gt ? this.Gt(f) : f;
+                u = this.Ut ? this.Ut(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
                     m[e] = this.xt[i];
-                    _[e] = this.Ft[i];
-                    r && (r[e] = this.Ut[i]);
-                    n && (n[e] = this.$t[i]);
+                    _[e] = this.Gt[i];
+                    r && (r[e] = this.$t[i]);
+                    n && (n[e] = this.qt[i]);
                     e = w[e];
                     p.set(u, e);
-                } else (l ??= []).push(this.Ft[i]);
+                } else (l ??= []).push(this.Gt[i]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -182,9 +182,9 @@ function updateKeyedMap() {
             // 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]);
+                _[i] = this.Gt[i];
+                r && (r[i] = this.$t[i]);
+                n && (n[i] = this.qt[i]);
             }
             for (e = o; e <= a; e++) {
                 if (r) setSignal(r[e], t[e]);
@@ -192,20 +192,20 @@ function updateKeyedMap() {
             }
             for (e = a + 1; e < s; e++) {
                 m[e] = this.xt[e - O];
-                _[e] = this.Ft[e - O];
+                _[e] = this.Gt[e - O];
                 if (r) {
-                    r[e] = this.Ut[e - O];
+                    r[e] = this.$t[e - O];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.$t[e - O];
+                    n[e] = this.qt[e - O];
                     if (O !== 0) setSignal(n[e], e);
                 }
             }
             this.xt = m;
-            this.Ft = _;
-            r && (this.Ut = r);
-            n && (this.$t = n);
+            this.Gt = _;
+            r && (this.$t = r);
+            n && (this.qt = n);
             this.jt = s;
             // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
@@ -234,19 +234,19 @@ function updateKeyedMap() {
     const r = {
         wt: createOwner(),
         jt: 0,
-        Bt: 0,
-        Ht: t,
+        Ht: 0,
+        Jt: t,
         Kt: e,
-        Ft: [],
+        Gt: [],
         xt: [],
-        Jt: i?.from,
-        zt: i?.fallback
+        Vt: i?.from,
+        Bt: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.wt.Nt = n;
+        r.wt.Tt = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -259,37 +259,37 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.Ht();
-    const s = this.Jt?.() || 0;
+    const t = this.Jt();
+    const s = this.Vt?.() || 0;
     runWithOwner(this.wt, () => {
         if (t === 0) {
             if (this.jt !== 0) {
                 this.wt.dispose(false);
-                this.Ft = [];
+                this.Gt = [];
                 this.xt = [];
                 this.jt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Bt = 0;
+                                this.Ht = 0;
             }
-            if (this.zt && !this.xt[0]) {
+            if (this.Bt && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Ft[0]?.dispose();
-                this.xt[0] = runWithOwner(this.Ft[0] = createOwner(), this.zt);
+                this.Gt[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Gt[0] = createOwner(), this.Bt);
             }
             return;
         }
         const i = s + t;
-        const e = this.Bt + this.jt;
+        const e = this.Ht + this.jt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(s, this.Bt);
+                const r = Math.max(s, this.Ht);
         const n = Math.min(i, e);
         const h = new Array(t);
         const o = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.Ft[t - this.Bt];
-            h[t - s] = this.xt[t - this.Bt];
+            o[t - s] = this.Gt[t - this.Ht];
+            h[t - s] = this.xt[t - this.Ht];
         }
         try {
             for (let t = s; t < i; t++) {
@@ -301,10 +301,10 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.jt === 0) this.Ft[0]?.dispose(); else for (let t = this.Bt; t < e; t++) if (t < s || t >= i) this.Ft[t - this.Bt].dispose();
+                if (this.jt === 0) this.Gt[0]?.dispose(); else for (let t = this.Ht; t < e; t++) if (t < s || t >= i) this.Gt[t - this.Ht].dispose();
         this.xt = h;
-        this.Ft = o;
-        this.Bt = s;
+        this.Gt = o;
+        this.Ht = s;
         this.jt = t;
     });
     return this.xt;

package/dist/prod/signals.js

@@ -277,7 +277,7 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const r = getOwner();
             const o = new MicrotaskQueue;
-            o.Ge = r.C;
+            o.ve = r.C;
  // notify() forwards up the normal chain
                         r.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and