@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/observe/reveal.js

@@ -43,11 +43,11 @@ const slotMinReady = t => isController(t) ? t.Qt() : ready(t);
     if (isController(t)) {
         t.$ = s;
         t.ee = r;
-        t.Bt();
+        t.Jt();
         // Released and ready — every slot of its own has shown — it graduates,
         // as a boundary does when it shows content. Released at the frontier
         // but not ready, it stays the parent's frontier.
-                if (!s && t.Jt && t._parent === e) t._parent = null;
+                if (!s && t.Xt && t._parent === e) t._parent = null;
         return;
     }
     if (t.$ !== s || t.ee !== r) {
@@ -58,98 +58,98 @@ const slotMinReady = t => isController(t) ? t.Qt() : ready(t);
 }
 
 class RevealController {
-    Xt;
     Yt;
-    Zt=[];
+    Zt;
+    ts=[];
     /** The controller gating this one, until it releases this one. */
     _parent=null;
     /** The state a parent forces on this whole group. */
     $=false;
     ee=false;
-    Jt=true;
-    ts=true;
-    es=false;
+    Xt=true;
+    es=true;
+    ss=false;
     constructor(t, e) {
-        this.Xt = t;
-        this.Yt = e;
+        this.Yt = t;
+        this.Zt = e;
     }
     /** A slot that has left this controller's ownership: a boundary that has
      * shown content, a nested group that is ready. Shown is shown — it counts
-     * as ready whatever happens to it later (a re-arm gates nobody else). */    ss(t) {
+     * as ready whatever happens to it later (a re-arm gates nobody else). */    rs(t) {
         return (isController(t) ? t._parent : t.v) !== this;
     }
     /** The slots this controller still owns, in registration order — the
-     * ones the order's state is forced on. */    rs(t) {
-        for (let e = 0; e < this.Zt.length; e++) {
-            const s = this.Zt[e];
-            if (!this.ss(s) && t(s) === false) return false;
+     * ones the order's state is forced on. */    ns(t) {
+        for (let e = 0; e < this.ts.length; e++) {
+            const s = this.ts[e];
+            if (!this.rs(s) && t(s) === false) return false;
         }
         return true;
     }
     /** Readiness is judged over every slot, done ones as ready. */    Lt() {
-        for (let t = 0; t < this.Zt.length; t++) {
-            const e = this.Zt[t];
-            if (!this.ss(e) && !slotReady(e)) return false;
+        for (let t = 0; t < this.ts.length; t++) {
+            const e = this.ts[t];
+            if (!this.rs(e) && !slotReady(e)) return false;
         }
         return true;
     }
     /** Something visible to show under its own order — what an enclosing
      * `together` waits for: `together` — every slot minimally ready;
      * `sequential` — the first slot; `natural` — any. */    Qt() {
-        const t = untrack(this.Xt);
-        const e = this.Zt;
+        const t = untrack(this.Yt);
+        const e = this.ts;
         if (e.length === 0) return true;
-        if (t === "sequential") return this.ss(e[0]) || slotMinReady(e[0]);
+        if (t === "sequential") return this.rs(e[0]) || slotMinReady(e[0]);
         for (let s = 0; s < e.length; s++) {
-            const r = this.ss(e[s]) || slotMinReady(e[s]);
+            const r = this.rs(e[s]) || slotMinReady(e[s]);
             if (t === "natural" ? r : !r) return t === "natural";
         }
         return t !== "natural";
     }
     te(t) {
-        if (this.Zt.includes(t)) return;
-        this.Zt.push(t);
+        if (this.ts.includes(t)) return;
+        this.ts.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
         // evaluation releases what the order allows.
-                const e = untrack(this.Xt) === "sequential" && !!untrack(this.Yt);
+                const e = untrack(this.Yt) === "sequential" && !!untrack(this.Zt);
         if (isController(t)) {
             t._parent = this;
             t.$ = true;
             t.ee = e;
-            t.Bt();
+            t.Jt();
         } else {
             t.v = this;
             t.$ = true;
             t.ee = e;
         }
-        untrack(() => this.Bt());
+        untrack(() => this.Jt());
     }
     oe(t) {
-        const e = this.Zt.indexOf(t);
-        if (e >= 0) this.Zt.splice(e, 1);
-        untrack(() => this.Bt());
+        const e = this.ts.indexOf(t);
+        if (e >= 0) this.ts.splice(e, 1);
+        untrack(() => this.Jt());
     }
     /** Apply the order to the owned slots — or, gated by a parent, its state
-     * to all of them. */    Bt() {
-        if (this.es) return;
-        this.es = true;
-        const t = this.Jt;
-        const e = this.ts;
+     * to all of them. */    Jt() {
+        if (this.ss) return;
+        this.ss = true;
+        const t = this.Xt;
+        const e = this.es;
         try {
-            const t = untrack(this.Xt);
-            const e = t === "sequential" && !!untrack(this.Yt);
+            const t = untrack(this.Yt);
+            const e = t === "sequential" && !!untrack(this.Zt);
             if (this.$) {
-                this.rs(t => setSlotState(t, this, true, this.ee));
+                this.ns(t => setSlotState(t, this, true, this.ee));
             } else if (t === "natural") {
-                this.rs(t => {
+                this.ns(t => {
                     if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
                 });
             } else if (t === "together") {
-                const t = this.rs(slotMinReady);
-                this.rs(e => setSlotState(e, this, !t, false));
+                const t = this.ns(slotMinReady);
+                this.ns(e => setSlotState(e, this, !t, false));
             } else {
                 let t = false;
-                this.rs(s => {
+                this.ns(s => {
                     if (t) return setSlotState(s, this, true, e);
                     if (slotReady(s)) return setSlotState(s, this, false, false);
                     t = true;
@@ -159,11 +159,11 @@ class RevealController {
                 });
             }
         } finally {
-            this.Jt = this.Lt();
-            this.ts = this.Qt();
-            this.es = false;
+            this.Xt = this.Lt();
+            this.es = this.Qt();
+            this.ss = false;
         }
-        if (this._parent !== null && (t !== this.Jt || e !== this.ts)) this._parent.Bt();
+        if (this._parent !== null && (t !== this.Xt || e !== this.es)) this._parent.Jt();
     }
 }
 
@@ -188,9 +188,9 @@ class RevealController {
     return runWithOwner(s, () => {
         const e = t();
         const s = computed(() => {
-            i.Xt();
             i.Yt();
-            i.Bt();
+            i.Zt();
+            i.Jt();
         });
         if (true) s._name = "reveal order";
         if (r) {
@@ -206,7 +206,7 @@ class RevealController {
 setRevealHooks({
     te: (t, e) => t.te(e),
     oe: (t, e) => t.oe(e),
-    P: t => t.Bt()
+    P: t => t.Jt()
 });
 
 export { createRevealOrder };

package/dist/observe/signals.js

@@ -335,7 +335,7 @@ function createMemo(e, t) {
  *   joined it (L2, born held — A29) and delivers at that commit: the
  *   committed view, never a foreign hold's unrevealed frame. */ function watch(e, t, r, n = 0, o, c = flushTransaction) {
     if (n & CONFIG_AUTHORITATIVE) {
-        GlobalQueue.rn = truthRead;
+        GlobalQueue.un = truthRead;
         GlobalQueue.tn = truthConfirmed;
     }
     // `config` is on the node for its first pass too (the pass runs inside
@@ -367,7 +367,7 @@ function createMemo(e, t) {
         o?.(u);
         queueMicrotask(() => t(u));
     }, {
-        St: n
+        ct: n
     }).l |= CONFIG_REDERIVE;
 }
 
@@ -467,7 +467,7 @@ function createMemo(e, t) {
                 // guessed node's own re-ask is not answered by it (#3895): park
                 // on that flight, or reject with its error.
                                 const e = read(t);
-                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.F;
+                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.U;
                 return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
@@ -545,7 +545,7 @@ function createMemo(e, t) {
                 // The flip, inside the pass of the flush carrying it: the flush
                 // joins the action's transaction, and what it staged is held and
                 // revealed with the action.
-                if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
+                if (e && c !== null && globalQueue.Y && resolveTx(c).tt !== 0) joinFuture(c);
             });
             if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -663,7 +663,7 @@ function createMemo(e, t) {
         // still holding the optimistic value — reads do not pull (#3411). Fall
         // to the next pass while the heap has work; `run` swapped the queue,
         // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue.jt >= dirtyQueue.lt) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.yt >= dirtyQueue.Et) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply

package/dist/observe/store/affects.js

@@ -40,7 +40,7 @@ function scopeOf(e, o) {
     if (n === undefined) scopes.set(e, n = {
         oo: new Set,
         no: [],
-        Vt: o
+        gt: o
     });
     return n;
 }
@@ -94,7 +94,7 @@ function scopeOf(e, o) {
  * backings (§7b): a view's backing is another store's proxy — marks cover
  * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === n || s.Vt !== undefined && s.Vt !== o) continue;
+        if (t === n || s.gt !== undefined && s.gt !== o) continue;
         for (let o = e.v; ;) {
             if (s.oo.has(o)) return t;
             const e = o?.[$TARGET];