@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/prod/core/owner.js

@@ -1,4 +1,4 @@
-import { REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
+import { REACTIVE_DISPOSED, CONFIG_CHILD_COMPANIONS, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
 
 import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
 
@@ -6,16 +6,16 @@ import { clearDeps, unobserved } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
 
-import { GlobalQueue, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
+import { GlobalQueue, wokenTransitions, schedule, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
 
 const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.Qe;
+    let t = e.Xe;
     while (t) {
-        const e = t.ie;
-        t.ie = e | REACTIVE_ZOMBIE;
+        const e = t.ue;
+        t.ue = e | REACTIVE_ZOMBIE;
         // migrate height-adjust entries too, not just recompute entries: every
         // `deleteFromHeap` call site picks the queue from the zombie flag, so a
         // node left physically linked in `dirtyQueue` after being zombified gets
@@ -26,7 +26,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.We;
+        t = t.$e;
     }
 }
 
@@ -42,22 +42,34 @@ function dispose(e) {
 }
 
 function disposeChildren(e, t = false, n) {
-    const i = e.ie;
+    const i = e.ue;
     if (i & REACTIVE_DISPOSED) return;
     if (t) {
-        e.ie = i | REACTIVE_DISPOSED;
+        e.ue = i | REACTIVE_DISPOSED;
         // Companions are created detached and outlive their owner, but a verdict
         // must not: a disposed source can never settle, so an isPending companion
         // latched `true` here would hold a spinner forever (INV-9, the PR #2845
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t.o?.ye || t.o?.Ce) GlobalQueue.un(t);
+        if (t.o?.je || t.o?.xe) GlobalQueue.En(t);
+        // A firewall's leaves have no lifecycle of their own, so a companion on
+        // one of them outlives its source the same way (INV-9's rationale). The
+        // firewall knows which leaves carry companions (CONFIG_CHILD_COMPANIONS,
+        // #3038): snap them with it — the snap retires a shadow whose firewall is
+        // disposed (spec O5).
+                if (t.T & CONFIG_CHILD_COMPANIONS) t.o.bt.forEach(GlobalQueue.En);
+        // A pending reader parked in a transaction may be the only thing holding
+        // it (#3372): its death is a completion event the transaction must be
+        // re-judged for, and nothing else re-enters a parked transaction.
+                const n = t.Ge;
+        if (n && t.S & STATUS_PENDING && !wokenTransitions.includes(n)) wokenTransitions.push(n), 
+        schedule();
     }
-    if (t && e.oe && e.o !== null) e.o.Ie = null;
-    let o = n ? e.o?.Ke ?? null : e.Qe;
+    if (t && e.ce && e.o !== null) e.o.Re = null;
+    let o = n ? e.o?.lt ?? null : e.Xe;
     while (o) {
-        const e = o.We;
+        const e = o.$e;
         const t = o;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
@@ -80,34 +92,34 @@ function disposeChildren(e, t = false, n) {
         o = e;
     }
     if (n) {
-        if (e.o !== null) e.o.Ke = null;
+        if (e.o !== null) e.o.lt = null;
     } else {
-        e.Qe = null;
-        e.je = 0;
+        e.Xe = null;
+        e.ut = 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 (t && !n && !(i & REACTIVE_ZOMBIE) && e.Le !== null && !(e.Le.ie & REACTIVE_DISPOSED)) {
-        const t = e.It;
-        const n = e.We;
-        if (t !== null) t.We = n; else e.Le.Qe = n;
-        if (n !== null) n.It = t;
-        e.It = null;
+        if (t && !n && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.ue & REACTIVE_DISPOSED)) {
+        const t = e.Dt;
+        const n = e.$e;
+        if (t !== null) t.$e = n; else e._parent.Xe = n;
+        if (n !== null) n.Dt = t;
+        e.Dt = null;
     }
     runDisposal(e, n);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.Gt) {
-        const t = e.Gt;
-        e.Gt = undefined;
+        if (t && e.yt) {
+        const t = e.yt;
+        e.yt = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.o?.Ze : e.Ge;
+    let n = t ? e.o?.it : e.ke;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -118,14 +130,14 @@ function runDisposal(e, t) {
         n.call(n);
     }
     if (t) {
-        if (e.o !== null) e.o.Ze = null;
-    } else e.Ge = null;
+        if (e.o !== null) e.o.it = null;
+    } else e.ke = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.Le) n = n.Le;
-    if (n.id != null) return formatId(n.id, t ? n.je++ : n.je);
+    while (n.T & CONFIG_TRANSPARENT && n._parent) n = n._parent;
+    if (n.id != null) return formatId(n.id, t ? n.ut++ : n.ut);
     throw new Error("");
 }
 
@@ -206,7 +218,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Ge) context.Ge = e; else if (Array.isArray(context.Ge)) context.Ge.push(e); else context.Ge = [ context.Ge, e ];
+    if (!context.ke) context.ke = e; else if (Array.isArray(context.ke)) context.ke.push(e); else context.ke = [ context.ke, e ];
     return e;
 }
 
@@ -226,7 +238,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.ue & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -243,30 +255,34 @@ function disposeRootSelf(e = true) {
  */ function createOwner(e) {
     const t = context;
     const n = e?.transparent ?? false;
-    const i = {
+    // Prod and observe boilerplates (see core.ts computed()). The observe
+    // literal carries the `_name` slot the rendering layer fills with the
+    // component label (`owner._name = "<App>"`) — a slot, so labelling a root
+    // is a plain store rather than a shape fork between labelled and plain roots.
+        const i = {
         id: inheritId(e, n, t),
         T: n ? CONFIG_TRANSPARENT : 0,
-        Dt: true,
-        Pt: t?.Dt ? t.Pt : t,
-        Qe: null,
-        We: null,
-        It: null,
-        Ge: null,
+        xt: true,
+        Qt: t?.xt ? t.Qt : t,
+        Xe: null,
+        $e: null,
+        Dt: null,
+        ke: null,
         C: t?.C ?? globalQueue,
-        we: t?.we || defaultContext,
-        je: 0,
+        ze: t?.ze || defaultContext,
+        ut: 0,
         o: null,
-        Le: t,
+        _parent: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.Qe;
+        const e = t.Xe;
         if (e === null) {
-            t.Qe = i;
+            t.Xe = i;
         } else {
-            i.We = e;
-            e.It = i;
-            t.Qe = i;
+            i.$e = e;
+            e.Dt = i;
+            t.Xe = i;
         }
     }
     return i;