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

package/dist/prod/core/effect.js

@@ -14,7 +14,7 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
     const r = !!R?.user;
     const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
     recompute(f, true);
-    !R?.defer && (f.Ae === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Ae, runEffect.bind(null, f)) : runEffect(f));
+    !R?.defer && (f.Pe === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Pe, runEffect.bind(null, f)) : runEffect(f));
 }
 
 function notifyEffectStatus(t, E) {
@@ -23,7 +23,7 @@ function notifyEffectStatus(t, E) {
     const R = E !== undefined ? E : this._;
     if (e & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Ae === EFFECT_USER) {
+        if (this.Pe === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -34,8 +34,8 @@ function notifyEffectStatus(t, E) {
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
-                this.$e = true;
-                this.C.enqueue(this.Ae, this.Be ??= runEffect.bind(null, this));
+                this.Be = true;
+                this.C.enqueue(this.Pe, this.Je ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -43,13 +43,13 @@ function notifyEffectStatus(t, E) {
             haltReactivity(unwrapStatusError(R));
             throw R;
         }
-    } else if (this.Ae === EFFECT_RENDER) {
+    } else if (this.Pe === EFFECT_RENDER) {
         this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
     }
 }
 
 function runEffect(t) {
-    if (!t.$e || t.se & REACTIVE_DISPOSED) return;
+    if (!t.Be || t.se & REACTIVE_DISPOSED) return;
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -60,14 +60,14 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.Ae === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.Pe === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t.rt = t.Pe;
-        t.$e = false;
+        t.ct = t.Ue;
+        t.Be = false;
         try {
-            t._t ? t._t(E, () => {
-                const E = t.ft;
-                t.ft = undefined;
+            t.ft ? t.ft(E, () => {
+                const E = t.Et;
+                t.Et = undefined;
                 E?.();
             }) : console.error(E);
         } catch (E) {
@@ -78,14 +78,14 @@ function runEffect(t) {
         }
         return;
     }
-    const E = t.ft;
-    t.ft = undefined;
+    const E = t.Et;
+    t.Et = undefined;
     try {
         E?.();
-        const e = t.ct(t.Pe, t.rt);
+        const e = t._t(t.Ue, t.ct);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.ft = e;
+                t.Et = e;
     } catch (E) {
         t._ = new StatusError(t, E);
         t.S |= STATUS_ERROR;
@@ -94,12 +94,12 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t.rt = t.Pe;
-        t.$e = false;
+        t.ct = t.Ue;
+        t.Be = false;
     }
 }
 
-GlobalQueue.Je = runEffect;
+GlobalQueue.Xe = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -107,26 +107,26 @@ GlobalQueue.Je = runEffect;
  * Uses stale reads.
  */ function trackedEffect(t, E) {
     const run = () => {
-        if (!e.$e || e.se & REACTIVE_DISPOSED) return;
+        if (!e.Be || e.se & REACTIVE_DISPOSED) return;
         try {
-            e.$e = false;
+            e.Be = false;
             recompute(e);
         } finally {}
     };
     const e = computed(() => {
-        const E = e.ft;
-        e.ft = undefined;
+        const E = e.Et;
+        e.Et = undefined;
         E?.();
         const R = staleValues(t);
-        e.ft = R;
+        e.Et = R;
     }, {
         ...E,
         lazy: true
     });
-    e.ft = undefined;
+    e.Et = undefined;
     e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    e.$e = true;
-    e.Ae = EFFECT_TRACKED;
+    e.Be = true;
+    e.Pe = EFFECT_TRACKED;
     e.i = (t, E) => {
         const R = t !== undefined ? t : e.S;
         if (R & STATUS_ERROR) {
@@ -138,7 +138,7 @@ GlobalQueue.Je = runEffect;
             }
         }
     };
-    e.ht = run;
+    e.Ft = run;
     e.C.enqueue(EFFECT_USER, run);
 }
 

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ke, () => {
+    const r = externalSourceConfig.factory(e.ae, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ke = e => {
+    e.ae = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Tt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.It = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.It = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.dt = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -8,15 +8,15 @@ import "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(l) {
-    const n = l.tt;
-    const e = l.et;
+    const n = l.nt;
+    const e = l.tt;
     const u = l.ue;
     const s = l.ll;
-    if (u !== null) u.ll = s; else n.ot = s;
+    if (u !== null) u.ll = s; else n.st = s;
     if (s !== null) s.ue = u; else {
         n.o = u;
         if (u === null) {
-            n.it?.();
+            n.ut?.();
             // 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
@@ -24,31 +24,31 @@ function unlinkSubs(l) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const l = n;
-            l.ke && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
+            l.ae && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
         }
     }
     return e;
 }
 
 function trimStaleDeps(l) {
-    const n = l.qe;
-    let e = n !== null ? n.et : l.Xe;
+    const n = l.We;
+    let e = n !== null ? n.tt : l.et;
     if (e !== null) {
         do {
             e = unlinkSubs(e);
         } while (e !== null);
-        if (n !== null) n.et = null; else l.Xe = null;
+        if (n !== null) n.tt = null; else l.et = null;
     }
 }
 
 function unobserved(l) {
     deleteFromHeap(l, queueFor(l));
-    let n = l.Xe;
+    let n = l.et;
     while (n !== null) {
         n = unlinkSubs(n);
     }
-    l.Xe = null;
-    l.qe = null;
+    l.et = null;
+    l.We = null;
     disposeChildren(l, true);
 }
 
@@ -59,20 +59,20 @@ function link(l, n, e = false) {
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const u = n.qe;
-    if (u !== null && u.tt === l) {
-        u.De &&= e;
+    const u = n.We;
+    if (u !== null && u.nt === l) {
+        u.ge &&= e;
         return;
     }
     let s = null;
     const t = n.se & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = u !== null ? u.et : n.Xe;
-        if (s !== null && s.tt === l) {
-            s.nl = n.We;
-            n.qe = s;
+        s = u !== null ? u.tt : n.et;
+        if (s !== null && s.nt === l) {
+            s.nl = n.Ye;
+            n.We = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.De = e;
+                        s.ge = e;
             return;
         }
     }
@@ -81,23 +81,23 @@ function link(l, n, e = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const i = l.ot;
-    if (i !== null && i.le === n && (!t || i.nl === n.We)) {
+        const i = l.st;
+    if (i !== null && i.le === n && (!t || i.nl === n.Ye)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (t) i.De &&= e; else i.De = e;
+        if (t) i.ge &&= e; else i.ge = e;
         return;
     }
-    const o = n.qe = l.ot = {
-        tt: l,
+    const o = n.We = l.st = {
+        nt: l,
         le: n,
-        et: s,
+        tt: s,
         ll: i,
         ue: null,
-        nl: n.We,
-        De: e
+        nl: n.Ye,
+        ge: e
     };
-    if (u !== null) u.et = o; else n.Xe = o;
+    if (u !== null) u.tt = o; else n.et = o;
     if (i !== null) i.ue = o; else l.o = o;
 }
 

package/dist/prod/core/heap.js

@@ -11,29 +11,29 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.Ae === EFFECT_TRACKED) {
+    if (e.Pe === EFFECT_TRACKED) {
         const E = e;
-        if (!E.$e) {
-            E.$e = true;
-            E.C.enqueue(EFFECT_USER, E.ht);
+        if (!E.Be) {
+            E.Be = true;
+            E.C.enqueue(EFFECT_USER, E.Ft);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.Fe > e.He) E.Fe = e.He;
+    if (E.He > e.Ve) E.He = e.Ve;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Ge?.Et ? e.Ge.Nt?.He : e.Ge?.He) ?? -1;
-    if (t >= e.He) e.He = t + 1;
-    const n = e.He;
+    const t = (e.ve?.Nt ? e.ve.Tt?.Ve : e.ve?.Ve) ?? -1;
+    if (t >= e.Ve) e.Ve = t + 1;
+    const n = e.Ve;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.lt;
-        E.ut = e;
-        e.lt = E;
-        I.lt = e;
+        const E = I.ot;
+        E.lt = e;
+        e.ot = E;
+        I.ot = e;
     }
     if (n > E.EE) E.EE = n;
 }
@@ -66,23 +66,23 @@ function deleteFromHeap(e, E) {
     const t = e.se;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.se = t & -25;
-    const n = e.He;
-    if (e.lt === e) E.eE[n] = undefined; else {
-        const t = e.ut;
+    const n = e.Ve;
+    if (e.ot === e) E.eE[n] = undefined; else {
+        const t = e.lt;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.lt.ut = t;
-        o.lt = e.lt;
+        if (e === I) E.eE[n] = t; else e.ot.lt = t;
+        o.ot = e.ot;
     }
-    e.lt = e;
-    e.ut = undefined;
+    e.ot = e;
+    e.lt = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.ut) {
+        for (let t = e.eE[E]; t !== undefined; t = t.lt) {
             if (t.se & REACTIVE_IN_HEAP) markNode(t);
         }
     }
@@ -106,11 +106,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Fe = 0; e.Fe <= e.EE; e.Fe++) {
-        let t = e.eE[e.Fe];
+    for (e.He = 0; e.He <= e.EE; e.He++) {
+        let t = e.eE[e.He];
         while (t !== undefined) {
             if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Fe];
+            t = e.eE[e.He];
         }
     }
     e.EE = 0;
@@ -118,14 +118,14 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.He;
-    for (let E = e.Xe; E; E = E.et) {
-        const e = E.tt;
-        const n = e.nt || e;
-        if (n.ke && n.He >= t) t = n.He + 1;
+    let t = e.Ve;
+    for (let E = e.et; E; E = E.tt) {
+        const e = E.nt;
+        const n = e.it || e;
+        if (n.ae && n.Ve >= t) t = n.Ve + 1;
     }
-    if (e.He !== t) {
-        e.He = t;
+    if (e.Ve !== t) {
+        e.Ve = t;
         for (let E = e.o; E !== null; E = E.ue) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`

package/dist/prod/core/lanes.js

@@ -19,13 +19,13 @@ const activeLanes = new Set;
     // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
     // The child lane should not merge with the parent lane.
         const i = n.nn;
-    const r = i?.je ? findLane(i.je) : null;
+    const r = i?.Me ? findLane(i.Me) : null;
     e = {
         en: n,
-        de: new Set,
+        Ne: new Set,
         rn: [ [], [] ],
         tn: null,
-        Ue: activeTransition,
+        Ie: activeTransition,
         an: r
     };
     signalLanes.set(n, e);
@@ -36,8 +36,8 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.be, e);
-    adoptCompanionLane(n.ge, e);
+        adoptCompanionLane(n.he, e);
+    adoptCompanionLane(n.Ge, e);
     return e;
 }
 
@@ -68,8 +68,8 @@ function adoptCompanionLane(n, e) {
     // Move (not copy) the merged lane's work: after the merge all routing goes
     // through findLane() to the root, so anything left behind here is dead —
     // and anything *added* here later is a routing bug (INV-5).
-        for (const i of e.de) n.de.add(i);
-    e.de.clear();
+        for (const i of e.Ne) n.Ne.add(i);
+    e.Ne.clear();
     n.rn[0].push(...e.rn[0]);
     n.rn[1].push(...e.rn[1]);
     e.rn[0].length = 0;
@@ -80,11 +80,11 @@ function adoptCompanionLane(n, e) {
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.je;
+    const e = n.Me;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    n.je = undefined;
+    n.Me = undefined;
     return undefined;
 }
 
@@ -99,13 +99,13 @@ function resolveTransition(n) {
         if (e.fn !== true) return e;
         n.sn = null;
     }
-    return resolveLane(n)?.Ue ?? n.Ue;
+    return resolveLane(n)?.Ie ?? n.Ie;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
-    return !!(n.Ee !== undefined && n.Ee !== NOT_PENDING);
+    return !!(n.Ae !== undefined && n.Ae !== NOT_PENDING);
 }
 
 /**
@@ -113,13 +113,13 @@ function resolveTransition(n) {
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
     const i = findLane(e);
-    const r = n.je;
+    const r = n.Me;
     if (r) {
         // If the subscriber's lane was merged into another lane, it's stale —
         // replace it with the new source lane instead of following the merge chain
         // (which would incorrectly merge the new lane into the old group)
         if (r.tn) {
-            n.je = e;
+            n.Me = e;
             return;
         }
         const t = findLane(r);
@@ -128,13 +128,13 @@ function resolveTransition(n) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
                 if (i.an && findLane(i.an) === t) {
-                    n.je = e;
+                    n.Me = e;
                 } else if (t.an && findLane(t.an) === i) ; else mergeLanes(i, t);
             }
             return;
         }
     }
-    n.je = e;
+    n.Me = e;
 }
 
 export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };