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

package/dist/prod/core/owner.js

@@ -12,7 +12,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.me;
+    let n = e.ke;
     while (n) {
         const e = n.se;
         n.se = e | REACTIVE_ZOMBIE;
@@ -26,17 +26,17 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.ve;
+        n = n.Fe;
     }
 }
 
 function dispose(e) {
-    let n = e.Xe;
+    let n = e.et;
     while (n !== null) {
         n = unlinkSubs(n);
     }
-    e.Xe = null;
-    e.qe = null;
+    e.et = null;
+    e.We = null;
     disposeChildren(e, true);
 }
 
@@ -51,41 +51,41 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.be || n.ge) GlobalQueue.un(n);
+        if (n.he || n.Ge) GlobalQueue.un(n);
     }
-    if (n && e.ke) e.Te = null;
-    let l = t ? e.Le : e.me;
+    if (n && e.ae) e.Te = null;
+    let l = t ? e.Qe : e.ke;
     while (l) {
-        const e = l.ve;
-        if (l.Xe) {
+        const e = l.Fe;
+        if (l.et) {
             const e = l;
             deleteFromHeap(e, queueFor(e));
-            let n = e.Xe;
+            let n = e.et;
             do {
                 n = unlinkSubs(n);
             } while (n !== null);
-            e.Xe = null;
-            e.qe = null;
+            e.et = null;
+            e.We = null;
         }
         disposeChildren(l, true);
         l = e;
     }
     if (t) {
-        e.Le = null;
+        e.Qe = null;
     } else {
-        e.me = null;
-        e.Qe = 0;
+        e.ke = null;
+        e.qe = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.Ge !== null && !(e.Ge.se & REACTIVE_DISPOSED)) {
-        const n = e.st;
-        const t = e.ve;
-        if (n !== null) n.ve = t; else e.Ge.me = t;
-        if (t !== null) t.st = n;
-        e.st = null;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.ve !== null && !(e.ve.se & REACTIVE_DISPOSED)) {
+        const n = e.rt;
+        const t = e.Fe;
+        if (n !== null) n.Fe = t; else e.ve.ke = t;
+        if (t !== null) t.rt = n;
+        e.rt = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
@@ -98,7 +98,7 @@ function disposeChildren(e, n = false, t) {
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.ye : e.xe;
+    let t = n ? e.ye : e.Le;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -108,13 +108,13 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.ye = null : e.xe = null;
+    n ? e.ye = null : e.Le = null;
 }
 
 function childId(e, n) {
     let t = e;
-    while (t.T & CONFIG_TRANSPARENT && t.Ge) t = t.Ge;
-    if (t.id != null) return formatId(t.id, n ? t.Qe++ : t.Qe);
+    while (t.T & CONFIG_TRANSPARENT && t.ve) t = t.ve;
+    if (t.id != null) return formatId(t.id, n ? t.qe++ : t.qe);
     throw new Error("");
 }
 
@@ -195,7 +195,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.xe) context.xe = e; else if (Array.isArray(context.xe)) context.xe.push(e); else context.xe = [ context.xe, e ];
+    if (!context.Le) context.Le = e; else if (Array.isArray(context.Le)) context.Le.push(e); else context.Le = [ context.Le, e ];
     return e;
 }
 
@@ -235,28 +235,28 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, t, n),
         T: t ? CONFIG_TRANSPARENT : 0,
-        ft: true,
-        Nt: n?.ft ? n.Nt : n,
-        me: null,
-        ve: null,
-        st: null,
-        xe: null,
+        Nt: true,
+        Tt: n?.Nt ? n.Tt : n,
+        ke: null,
+        Fe: null,
+        rt: null,
+        Le: null,
         C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
-        Qe: 0,
+        qe: 0,
         ye: null,
-        Le: null,
-        Ge: n,
+        Qe: null,
+        ve: n,
         dispose: disposeRootSelf
     };
     if (n) {
-        const e = n.me;
+        const e = n.ke;
         if (e === null) {
-            n.me = i;
+            n.ke = i;
         } else {
-            i.ve = e;
-            e.st = i;
-            n.me = i;
+            i.Fe = e;
+            e.rt = i;
+            n.ke = i;
         }
     }
     return i;

package/dist/prod/core/scheduler.js

@@ -56,7 +56,7 @@ function registerTransientStoreNode(e) {
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Ze.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.je.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -66,14 +66,14 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Ne !== NOT_PENDING) continue;
-        if (e.Ee !== undefined && e.Ee !== NOT_PENDING) continue;
+        if (e._e !== NOT_PENDING) continue;
+        if (e.Ae !== undefined && e.Ae !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
                 if (e.t) continue;
         transientStoreNodes.delete(e);
-        e.it?.();
+        e.ut?.();
     }
 }
 
@@ -100,15 +100,15 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        ce: clock,
+        Se: clock,
         Qt: [],
-        yt: new Map,
-        Ze: [],
+        Ee: new Map,
+        je: [],
         A: [],
         cn: new Set,
         ie: [],
-        gt: {
-            bt: [ [], [] ],
+        yt: {
+            gt: [ [], [] ],
             vt: []
         },
         fn: false,
@@ -119,13 +119,13 @@ function setProjectionWriteActive(e) {
 function mergeTransitionState(e, t) {
     t.fn = e;
     e.ie.push(...t.ie);
-    for (const i of activeLanes) if (i.Ue === t) i.Ue = e;
-    if (t.Ze.length) {
+    for (const i of activeLanes) if (i.Ie === t) i.Ie = e;
+    if (t.je.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — duplicating every entry.
-        e.Ze.push(...t.Ze);
-        t.Ze.length = 0;
+        e.je.push(...t.je);
+        t.je.length = 0;
     }
     if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -135,9 +135,9 @@ function mergeTransitionState(e, t) {
         t.A.length = 0;
     }
     for (const i of t.cn) e.cn.add(i);
-    for (const [i, n] of t.yt) {
-        let t = e.yt.get(i);
-        if (!t) e.yt.set(i, t = new Set);
+    for (const [i, n] of t.Ee) {
+        let t = e.Ee.get(i);
+        if (!t) e.Ee.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
     for (const i of t.ln) e.ln.add(i);
@@ -150,7 +150,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.kt && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.bt && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -180,29 +180,29 @@ function notifyHalted() {
 }
 
 class Queue {
-    Ge=null;
-    bt=[ [], [] ];
+    ve=null;
+    gt=[ [], [] ];
     vt=[];
     created=clock;
     addChild(e) {
         this.vt.push(e);
-        e.Ge = this;
+        e.ve = this;
     }
     removeChild(e) {
         const t = this.vt.indexOf(e);
         if (t >= 0) {
             this.vt.splice(t, 1);
-            e.Ge = null;
+            e.ve = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.Ge) return this.Ge.notify(e, t, i, n);
+        if (this.ve) return this.ve.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.bt[e - 1].length) {
-            const t = this.bt[e - 1];
-            this.bt[e - 1] = [];
+        if (this.gt[e - 1].length) {
+            const t = this.gt[e - 1];
+            this.gt[e - 1] = [];
             runQueue(t, e);
         }
         for (let t = 0; t < this.vt.length; t++) this.vt[t].run?.(e);
@@ -214,21 +214,21 @@ class Queue {
                 const i = findLane(currentOptimisticLane);
                 i.rn[e - 1].push(t);
             } else {
-                this.bt[e - 1].push(t);
+                this.gt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.bt[0].push(...this.bt[0]);
-        e.bt[1].push(...this.bt[1]);
-        this.bt = [ [], [] ];
+        e.gt[0].push(...this.gt[0]);
+        e.gt[1].push(...this.gt[1]);
+        this.gt = [ [], [] ];
         for (let t = 0; t < this.vt.length; t++) {
             let i = this.vt[t];
             let n = e.vt[t];
             if (!n) {
                 n = {
-                    bt: [ [], [] ],
+                    gt: [ [], [] ],
                     vt: []
                 };
                 e.vt[t] = n;
@@ -237,8 +237,8 @@ class Queue {
         }
     }
     restoreQueues(e) {
-        this.bt[0].push(...e.bt[0]);
-        this.bt[1].push(...e.bt[1]);
+        this.gt[0].push(...e.gt[0]);
+        this.gt[1].push(...e.gt[1]);
         for (let t = 0; t < e.vt.length; t++) {
             const i = e.vt[t];
             let n = this.vt[t];
@@ -248,14 +248,14 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    kt=false;
+    bt=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
     static pe;
     static Ce;
-    static Je;
-    static Dt=null;
+    static Xe;
+    static kt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
@@ -269,24 +269,24 @@ class GlobalQueue extends Queue {
     static h=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static Tt=null;
     static It=null;
+    static dt=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
     // null or sit behind state only the verdict layer can create (`!` is safe
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static Ie=null;
-    static ae=null;
-    static he=null;
+    static De=null;
+    static ce=null;
+    static Oe=null;
     static un=null;
     static St=null;
-    static dt=null;
-    static Rt=null;
-    static ze=null;
+    static At=null;
+    static Pt=null;
+    static $e=null;
     static k=null;
-    static Lt=null;
+    static Dt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -294,21 +294,21 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static Pt=null;
+    static ht=null;
     static En=null;
-    static Tn=null;
     static dn=null;
+    static Tn=null;
     static In=null;
-    static Ct=null;
-    static At=null;
     static Ot=null;
-    static We=null;
+    static Ct=null;
+    static Rt=null;
+    static Ze=null;
+    static ze=null;
     static Ke=null;
-    static Me=null;
     static Nn=null;
     flush() {
-        if (this.kt) return;
-        this.kt = true;
+        if (this.bt) return;
+        this.bt = true;
         try {
             if (false) ;
             runHeap(dirtyQueue, GlobalQueue.pe);
@@ -329,7 +329,7 @@ class GlobalQueue extends Queue {
                         GlobalQueue.In(EFFECT_RENDER);
                         GlobalQueue.In(EFFECT_USER);
                     }
-                    this.stashQueues(e.gt);
+                    this.stashQueues(e.yt);
                     clock++;
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
@@ -343,7 +343,7 @@ class GlobalQueue extends Queue {
                 const t = activeTransition;
                 const i = this.m;
                 i !== t && i.Qt.push(...t.Qt);
-                this.restoreQueues(t.gt);
+                this.restoreQueues(t.yt);
                 transitions.delete(t);
                 activeTransition = null;
                 reassignPendingTransition(i.Qt);
@@ -354,7 +354,7 @@ class GlobalQueue extends Queue {
                     // there and must survive to the next flush.
                     const e = createBatch();
                     e.Qt = i.Qt;
-                    e.Ze = i.Ze;
+                    e.je = i.je;
                     e.A = i.A;
                     e.cn = i.cn;
                     currentBatch = this.m = e;
@@ -383,7 +383,7 @@ class GlobalQueue extends Queue {
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.kt = false;
+            this.bt = false;
         }
     }
     notify(e, t, i, n) {
@@ -398,8 +398,8 @@ class GlobalQueue extends Queue {
                                 if (t?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.yt.get(i);
-                    if (!n) activeTransition.yt.set(i, n = new Set);
+                    let n = activeTransition.Ee.get(i);
+                    if (!n) activeTransition.Ee.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) schedule();
@@ -412,7 +412,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.ce === clock) return;
+        if (!e && activeTransition && activeTransition.Se === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -422,7 +422,7 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.ce = clock;
+        activeTransition.Se = clock;
         const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -434,20 +434,20 @@ class GlobalQueue extends Queue {
             // nodes, see propagateAffectsMark, #2893.
             for (let e = 0; e < t.Qt.length; e++) {
                 const i = t.Qt[e];
-                i.Ue = activeTransition;
+                i.Ie = activeTransition;
                 activeTransition.Qt.push(i);
             }
-            for (let e = 0; e < t.Ze.length; e++) {
-                const i = t.Ze[e];
-                i.Ue = activeTransition;
-                activeTransition.Ze.push(i);
+            for (let e = 0; e < t.je.length; e++) {
+                const i = t.je[e];
+                i.Ie = activeTransition;
+                activeTransition.je.push(i);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.cn) activeTransition.cn.add(e);
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.Ue) e.Ue = activeTransition;
+            if (!e.Ie) e.Ie = activeTransition;
         }
     }
 }
@@ -468,8 +468,8 @@ function armReaskClear() {
 function insertSubs(e, t = false) {
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
-    const i = e.je || currentOptimisticLane;
-    const n = e.Ve !== undefined;
+    const i = e.Me || currentOptimisticLane;
+    const n = e.xe !== undefined;
     const s = reaskArmed;
     for (let r = e.o; r !== null; r = r.ue) {
         // A value-change notification is a new question for the subscriber: any
@@ -485,7 +485,7 @@ function insertSubs(e, t = false) {
         } else if (t) {
             r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        r.le.je = undefined;
+                        r.le.Me = undefined;
         }
         enqueueSub(r.le);
     }
@@ -493,24 +493,24 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.ke) {
-        if (e.Ne !== NOT_PENDING) {
-            e.Pe = e.Ne;
-            e.Ne = NOT_PENDING;
+    if (!t.ae) {
+        if (e._e !== NOT_PENDING) {
+            e.Ue = e._e;
+            e._e = NOT_PENDING;
         }
-        if (e.be || e.ge) GlobalQueue.un(e);
+        if (e.he || e.Ge) GlobalQueue.un(e);
         return;
     }
-    if (e.Ne !== NOT_PENDING) {
-        e.Pe = e.Ne;
-        e.Ne = NOT_PENDING;
+    if (e._e !== NOT_PENDING) {
+        e.Ue = e._e;
+        e._e = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Ae && e.Ae !== EFFECT_TRACKED) e.$e = true;
+                if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
     }
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.Le !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
-    if (e.be || e.ge) GlobalQueue.un(e);
+    if (t.Qe !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
+    if (e.he || e.Ge) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
@@ -535,7 +535,7 @@ function finalizePureQueue(e = null, t = false) {
                 const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Ze.length) GlobalQueue.En(t.Ze);
+                if (t.je.length) GlobalQueue.En(t.je);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible.
                 if (e && e.ln.size) {
@@ -559,10 +559,10 @@ function finalizePureQueue(e = null, t = false) {
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.Dt(t.cn, e);
+                if (t.cn.size) GlobalQueue.kt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.dn(e);
+                if (activeLanes.size) GlobalQueue.Tn(e);
     }
 }
 
@@ -591,7 +591,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].Ue = activeTransition;
+        e[t].Ie = activeTransition;
     }
 }
 
@@ -619,7 +619,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.kt) {
+    if (globalQueue.bt) {
         return;
     }
     if (halted) return;
@@ -637,10 +637,10 @@ function runQueue(e, t) {
 function reporterBlocksSource(e, t) {
     if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.oe?.has(t)) return true;
-    for (let i = e.Xe; i; i = i.et) {
-        let e = i.tt;
+    for (let i = e.et; i; i = i.tt) {
+        let e = i.nt;
         while (e) {
-            if (e === t || e.nt === t) return true;
+            if (e === t || e.it === t) return true;
             e = e.nn;
         }
     }
@@ -651,7 +651,7 @@ function transitionComplete(e) {
     if (e.fn) return true;
     if (e.ie.length) return false;
     let t = true;
-    for (const [i, n] of e.yt) {
+    for (const [i, n] of e.Ee) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -660,7 +660,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.yt.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
+        if (!s) e.Ee.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
             t = false;
             break;
         }
@@ -668,7 +668,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine. Absent hook = "no optimistic
     // blockage", which is exact: only _optimisticWrite (engine) pushes to
     // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.Ze.length && GlobalQueue.Tn(e)) t = false;
+        if (t && e.je.length && GlobalQueue.dn(e)) t = false;
     t && (e.fn = true);
     return t;
 }