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

package/dist/observe/core/owner.js

@@ -1,32 +1,34 @@
-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";
 
+import "./dev.js";
+
 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.Tt;
-    while (t) {
-        const e = t.it;
-        t.it = e | REACTIVE_ZOMBIE;
+    let n = e.Ot;
+    while (n) {
+        const e = n.ft;
+        n.ft = 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
         // unlinked from the wrong queue on dispose, corrupting the bucket and
         // livelocking the next `runHeap` that reaches it (#2759)
                 if (e & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) {
-            deleteFromHeap(t, e & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-            if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
+            deleteFromHeap(n, e & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+            if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
-        markDisposal(t);
-        t = t.dt;
+        markDisposal(n);
+        n = n.At;
     }
 }
 
@@ -37,28 +39,40 @@ 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.T &= ~CONFIG_AUTO_DISPOSE;
+    e.C &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
-function disposeChildren(e, t = false, n) {
-    const i = e.it;
+function disposeChildren(e, n = false, t) {
+    const i = e.ft;
     if (i & REACTIVE_DISPOSED) return;
-    if (t) {
-        e.it = i | REACTIVE_DISPOSED;
+    if (n) {
+        e.ft = 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?.be || t.o?.pe) GlobalQueue.Dn(t);
+                const n = e;
+        if (n.o?.he || n.o?.Ge) GlobalQueue.Qn(n);
+        // 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 (n.C & CONFIG_CHILD_COMPANIONS) n.o.Jt.forEach(GlobalQueue.Qn);
+        // 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 t = n.Te;
+        if (t && n.S & STATUS_PENDING && !wokenTransitions.includes(t)) wokenTransitions.push(t), 
+        schedule();
     }
-    if (t && e.ot && e.o !== null) e.o.Se = null;
-    let o = n ? e.o?.Rt ?? null : e.Tt;
+    if (n && e.ht && e.o !== null) e.o.ce = null;
+    let o = t ? e.o?.Pt ?? null : e.Ot;
     while (o) {
-        const e = o.dt;
-        const t = o;
+        const e = o.At;
+        const n = o;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
         // last committed value instead of reawakening in a torn-down tree.
@@ -66,7 +80,7 @@ function disposeChildren(e, t = false, n) {
         // 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.
-                t.T &= ~CONFIG_AUTO_DISPOSE;
+                n.C &= ~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 —
@@ -74,58 +88,58 @@ function disposeChildren(e, t = false, n) {
         // comes back to life (post-unmount runs, leaked cleanups, #2983).
         // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
         // Owners, whose _flags is undefined), so no gate here.
-                deleteFromHeap(t, queueFor(t));
-        clearDeps(t);
+                deleteFromHeap(n, queueFor(n));
+        clearDeps(n);
         disposeChildren(o, true);
         o = e;
     }
-    if (n) {
-        if (e.o !== null) e.o.Rt = null;
+    if (t) {
+        if (e.o !== null) e.o.Pt = null;
     } else {
-        e.Tt = null;
-        e.Gt = 0;
+        e.Ot = null;
+        e.Ft = 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.Nt !== null && !(e.Nt.it & REACTIVE_DISPOSED)) {
-        const t = e.wt;
-        const n = e.dt;
-        if (t !== null) t.dt = n; else e.Nt.Tt = n;
-        if (n !== null) n.wt = t;
-        e.wt = null;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.ft & REACTIVE_DISPOSED)) {
+        const n = e.Yt;
+        const t = e.At;
+        if (n !== null) n.At = t; else e._parent.Ot = t;
+        if (t !== null) t.Yt = n;
+        e.Yt = null;
     }
-    runDisposal(e, n);
+    runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.Xt) {
-        const t = e.Xt;
-        e.Xt = undefined;
-        t();
+        if (n && e.an) {
+        const n = e.an;
+        e.an = undefined;
+        n();
     }
 }
 
-function runDisposal(e, t) {
-    let n = t ? e.o?.Ct : e.he;
-    if (!n) return;
-    if (Array.isArray(n)) {
-        for (let e = 0; e < n.length; e++) {
-            const t = n[e];
-            t.call(t);
+function runDisposal(e, n) {
+    let t = n ? e.o?.Dt : e.Ue;
+    if (!t) return;
+    if (Array.isArray(t)) {
+        for (let e = 0; e < t.length; e++) {
+            const n = t[e];
+            n.call(n);
         }
     } else {
-        n.call(n);
+        t.call(t);
     }
-    if (t) {
-        if (e.o !== null) e.o.Ct = null;
-    } else e.he = null;
+    if (n) {
+        if (e.o !== null) e.o.Dt = null;
+    } else e.Ue = null;
 }
 
-function childId(e, t) {
-    let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.Nt) n = n.Nt;
-    if (n.id != null) return formatId(n.id, t ? n.Gt++ : n.Gt);
+function childId(e, n) {
+    let t = e;
+    while (t.C & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.Ft++ : t.Ft);
     throw new Error("");
 }
 
@@ -142,8 +156,8 @@ function childId(e, t) {
  * The id a freshly-created node inherits: an explicit `options.id` wins;
  * transparent nodes share their parent's id; otherwise the parent's next
  * child id is consumed (or `undefined` outside an id-carrying tree).
- */ function inheritId(e, t, n) {
-    return e?.id ?? (t ? n?.id : n?.id != null ? getNextChildId(n) : undefined);
+ */ function inheritId(e, n, t) {
+    return e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined);
 }
 
 /**
@@ -155,9 +169,9 @@ function childId(e, t) {
     return childId(e, false);
 }
 
-function formatId(e, t) {
-    const n = t.toString(36), i = n.length - 1;
-    return e + (i ? String.fromCharCode(64 + i) : "") + n;
+function formatId(e, n) {
+    const t = n.toString(36), i = t.length - 1;
+    return e + (i ? String.fromCharCode(64 + i) : "") + t;
 }
 
 /**
@@ -206,7 +220,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.he) context.he = e; else if (Array.isArray(context.he)) context.he.push(e); else context.he = [ context.he, e ];
+    if (!context.Ue) context.Ue = e; else if (Array.isArray(context.Ue)) context.Ue.push(e); else context.Ue = [ context.Ue, e ];
     return e;
 }
 
@@ -226,7 +240,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.it & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.ft & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -241,37 +255,37 @@ function disposeRootSelf(e = true) {
  *
  * @internal
  */ function createOwner(e) {
-    const t = context;
-    const n = e?.transparent ?? false;
+    const n = context;
+    const t = e?.transparent ?? false;
     // 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,
-        $t: true,
-        ln: t?.$t ? t.ln : t,
-        Tt: null,
-        dt: null,
-        wt: null,
-        he: null,
-        C: t?.C ?? globalQueue,
-        ft: t?.ft || defaultContext,
-        Gt: 0,
+        id: inheritId(e, t, n),
+        C: t ? CONFIG_TRANSPARENT : 0,
+        cn: true,
+        fn: n?.cn ? n.fn : n,
+        Ot: null,
+        At: null,
+        Yt: null,
+        Ue: null,
+        T: n?.T ?? globalQueue,
+        wt: n?.wt || defaultContext,
+        Ft: 0,
         o: null,
-        Nt: t,
+        _parent: n,
         dispose: disposeRootSelf,
         _name: undefined
     };
-    if (t) {
-        const e = t.Tt;
+    if (n) {
+        const e = n.Ot;
         if (e === null) {
-            t.Tt = i;
+            n.Ot = i;
         } else {
-            i.dt = e;
-            e.wt = i;
-            t.Tt = i;
+            i.At = e;
+            e.Yt = i;
+            n.Ot = i;
         }
     }
     return i;
@@ -300,9 +314,9 @@ function disposeRootSelf(e = true) {
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */ function createRoot(e, t) {
-    const n = createOwner(t);
-    return runWithOwner(n, () => e(() => n.dispose()));
+ */ function createRoot(e, n) {
+    const t = createOwner(n);
+    return runWithOwner(t, () => e(() => t.dispose()));
 }
 
 export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, markDisposal, peekNextChildId };