@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/prod/core/owner.js

@@ -16,11 +16,11 @@ import { schedule, dirtyQueue } from "./scheduler.js";
 // key off it, and the heap defers a zombie's recompute past the seam (no
 // second heap — the deferral list in scheduler.ts).
 function markDisposal(e) {
-    let n = e.ge;
+    let n = e.Ve;
     while (n) {
         n.R |= REACTIVE_ZOMBIE;
         markDisposal(n);
-        n = n.me;
+        n = n.ge;
     }
 }
 
@@ -31,7 +31,7 @@ function dispose(e) {
     // left queued would be recomputed and resurrected by the next flush (#2983)
     // — dep unlinking, child disposal) is exactly unobserved()'s body; only
     // this flag distinguishes death from dormancy.
-    e.u &= ~CONFIG_AUTO_DISPOSE;
+    e.i &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
@@ -43,20 +43,20 @@ function disposeChildren(e, n = false, t) {
     // cleanups never run and it stays subscribed, rerunning in a torn-down
     // tree (#3561). Death only (`self`): a re-pass leaves the frame reacting
     // until the commit.
-        if (n && !t && e.m !== null && (e.m.Me !== null || e.m.Be !== null)) disposeChildren(e, false, true);
+        if (n && !t && e.m !== null && (e.m.Qe !== null || e.m.ve !== null)) disposeChildren(e, false, true);
     if (n) {
         e.R = i | REACTIVE_DISPOSED;
     }
-    if (n && e.re) {
-        if (e.m !== null) e.m.De = null;
+    if (n && e.ee) {
+        if (e.m !== null) e.m.Te = null;
         // A death that can unblock the future (L2, `futureBlocked`): a held
         // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
         // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
         // Nothing else re-examines a dead node, so make sure a seam comes.
-                if (e.G & STATUS_PENDING && e.m?.ke != null || i & REACTIVE_FRAME_READ) schedule();
+                if (e.S & STATUS_PENDING && e.m?.He != null || i & REACTIVE_FRAME_READ) schedule();
     }
-    let l = t ? e.m.Me : e.ge;
-    if (t) e.m.Me = null; else e.ge = null;
+    let l = t ? e.m.Qe : e.Ve;
+    if (t) e.m.Qe = null; else e.Ve = null;
     while (l) {
         const e = l;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -66,7 +66,7 @@ function disposeChildren(e, n = false, t) {
         // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
         // Only unobserved()'s own node keeps its dormancy — it is never in
         // this loop; its children are rebuilt fresh on reawaken.
-                e.u &= ~CONFIG_AUTO_DISPOSE;
+                e.i &= ~CONFIG_AUTO_DISPOSE;
         // Heap removal must not be gated on `_deps`: a dependency-free
         // computation queued by refresh() has a null dep list but still sits in
         // the dirty heap, and left there the post-disposal flush recomputes it —
@@ -80,43 +80,43 @@ function disposeChildren(e, n = false, t) {
         // on the fresh head and survives. Pointing each drained child's prev at
         // itself routes its later splice onto the detached chain, never the head,
         // and keeps the dev owner-chain-head invariant honest for those children.
-                l.Je = l;
+                l.Ke = l;
         disposeChildren(l, true);
         // Read after, not before: a sibling this disposal made dormant spliced
         // itself out of the detached chain, and a cleanup may then have linked
         // it at the fresh head, which rewrote the `_nextSibling` a pre-read
         // would still be holding.
-                l = l.me;
+                l = l.ge;
     }
-    if (!t) e.Ye = 0;
+    if (!t) e.Be = 0;
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and for a zombie (it sits on the
     // parent's parked frame, drained whole by the commit). We leave
     // node._nextSibling intact so outer walks that already advanced past us
     // still reach later siblings.
         if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
-        const n = e.Je;
-        const t = e.me;
-        if (n !== null) n.me = t; else e._parent.ge = t;
-        if (t !== null) t.Je = n;
-        e.Je = null;
+        const n = e.Ke;
+        const t = e.ge;
+        if (n !== null) n.ge = t; else e._parent.Ve = t;
+        if (t !== null) t.Ke = n;
+        e.Ke = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.lt) {
-        const n = e.lt;
-        e.lt = undefined;
+        if (n && e.st) {
+        const n = e.st;
+        e.st = undefined;
         n();
     }
 }
 
 function linkChild(e, n) {
-    const t = e.ge;
-    n.Je = null;
-    n.me = t;
-    if (t !== null) t.Je = n;
-    e.ge = n;
+    const t = e.Ve;
+    n.Ke = null;
+    n.ge = t;
+    if (t !== null) t.Ke = n;
+    e.Ve = n;
 }
 
 function runDisposal(e, n) {
@@ -126,9 +126,9 @@ function runDisposal(e, n) {
     // walk ran every entry a second time. Detached, the re-entrant drain finds
     // nothing. The same shape latched a throwing cleanup: the list survived the
     // throw and every later drain re-ran and re-threw it.
-    const t = n ? e.m.Be : e.Pe;
+    const t = n ? e.m.ve : e.Re;
     if (!t) return;
-    if (n) e.m.Be = null; else e.Pe = null;
+    if (n) e.m.ve = null; else e.Re = null;
     if (Array.isArray(t)) {
         // Unwind order (#3572, restores 1.x #1562): later registrations run
         // before earlier ones. Children have already been disposed by the caller,
@@ -145,8 +145,8 @@ function runDisposal(e, n) {
 
 function childId(e, n) {
     let t = e;
-    while (t.u & CONFIG_TRANSPARENT && t._parent) t = t._parent;
-    if (t.id != null) return formatId(t.id, n ? t.Ye++ : t.Ye);
+    while (t.i & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.Be++ : t.Be);
     throw new Error("");
 }
 
@@ -226,7 +226,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Pe) context.Pe = e; else if (Array.isArray(context.Pe)) context.Pe.push(e); else context.Pe = [ context.Pe, e ];
+    if (!context.Re) context.Re = e; else if (Array.isArray(context.Re)) context.Re.push(e); else context.Re = [ context.Re, e ];
     return e;
 }
 
@@ -269,15 +269,15 @@ function disposeRootSelf(e = true) {
     // is a plain store rather than a shape fork between labelled and plain roots.
         const i = {
         id: inheritId(e, t, n),
-        u: t ? CONFIG_TRANSPARENT : 0,
-        Et: true,
-        ut: n?.Et ? n.ut : n,
+        i: t ? CONFIG_TRANSPARENT : 0,
+        $e: true,
+        et: n?.$e ? n.et : n,
+        Ve: null,
         ge: null,
-        me: null,
-        Je: null,
-        Pe: null,
-        U: n?.U || defaultContext,
-        Ye: 0,
+        Ke: null,
+        Re: null,
+        D: n?.D || defaultContext,
+        Be: 0,
         m: null,
         _parent: n,
         dispose: disposeRootSelf