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

package/dist/prod/signals.js

@@ -1,6 +1,6 @@
 import { TimeoutError } from "./core/error.js";
 
-import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner, setMemo, signal, markRefresh, installAuthoritativeRead, read, untrack } from "./core/core.js";
+import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner, setMemo, signal, installAuthoritativeRead, markRefresh, read, untrack } from "./core/core.js";
 
 import { cleanup, createRoot, getOwner, dispose, getObserver } from "./core/owner.js";
 
@@ -188,6 +188,16 @@ function createMemo(e, t) {
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
  *
+ * @deprecated Do not use in new code. For a side effect that follows reactive
+ * state, use `createEffect(compute, effect)` — it separates tracking from the
+ * side effect, knows its dependencies before it runs, and participates in
+ * async and transitions. For one-time DOM work after render (measuring,
+ * attaching third-party widgets to a ref), use `onSettled`. Tracking from
+ * inside the effect phase — the only thing this primitive adds — is retained
+ * solely to ease 1.x migration: it runs beside user-effect callbacks after
+ * values commit, never holds a transition, and cannot observe a write staged
+ * earlier in the same flush by a signal it has not read yet.
+ *
  * WARNING: Because tracking and effects happen in the same scope, this primitive
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.
@@ -256,25 +266,22 @@ function createMemo(e, t) {
     // sources stayed live (firing the callback for replaced dependencies), each
     // accumulated arm delivered its own fire, and un-fired arms leaked as live
     // effect nodes until the owner disposed (#2861).
-        let o;
-    return i => {
-        if (o) {
-            dispose(o);
-            o = undefined;
+        let i;
+    return o => {
+        if (i) {
+            dispose(i);
+            i = undefined;
         }
         runWithOwner(r, () => {
-            effect(() => (i(), o = getOwner()), t => {
-                o = undefined;
+            effect(() => (o(), i = getOwner()), t => {
+                i = undefined;
                 n?.();
                 const r = (e.effect || e)?.();
                 if (false && r !== undefined && typeof r !== "function") ;
                 n = r;
                 dispose(t);
             }, e.error, {
-                ...false ? {
-                    ...t,
-                    name: t?.name ?? "effect"
-                } : t,
+                ...t,
                 user: true,
                 defer: true
             });
@@ -318,11 +325,11 @@ function createMemo(e, t) {
             // still runs in place (under the transaction's view when created inside
             // an action step), and status/boundary notifications keep their normal
             // route through the inherited queue.
-            const o = getOwner();
-            const i = new MicrotaskQueue;
-            i.ke = o.C;
+            const i = getOwner();
+            const o = new MicrotaskQueue;
+            o.qe = i.C;
  // notify() forwards up the normal chain
-                        o.C = i;
+                        i.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and
             // are only re-enqueued when a pending source *resolves* — a rejection just
             // marks them errored, so nothing would re-run and the promise would never
@@ -342,7 +349,7 @@ function createMemo(e, t) {
             // stale mainline value and resolves with old data.
             {
                 user: true,
-                dt: CONFIG_DIRECT_COMMIT
+                Pt: CONFIG_DIRECT_COMMIT
             });
         });
     });
@@ -410,7 +417,14 @@ function createMemo(e, t) {
     // own eager compute is untouched: created after a refresh it still settles
     // stale-while-revalidate (#2930) — its contract is "first settled value",
     // not "next quiescent state".
-        markRefresh(t);
+    
+    // An authoritative reader is woken through a late-bound hook when the truth
+    // lands EQUAL to a standing override (the A17-silent path). Every setter of
+    // that reader bit must install it — until() does, and this waiter is the
+    // other one (#3303: refresh of an optimistic in an app that never called
+    // until() dereferenced the null hook).
+        installAuthoritativeRead();
+    markRefresh(t);
     const n = new Promise((n, r) => {
         queueMicrotask(() => {
             // No createRoot: the microtask has no ambient owner, so the effect is
@@ -423,24 +437,24 @@ function createMemo(e, t) {
             // Typed as the effect node, not Owner: the capture runs inside the
             // effect's own compute, where the ambient owner IS the effect —
             // exactly what dispose() takes.
-            let o = null;
+            let i = null;
             const make = () => effect(() => {
-                if (o === null) {
-                    o = getOwner();
+                if (i === null) {
+                    i = getOwner();
                     const e = new MicrotaskQueue;
-                    e.ke = o.C;
-                    o.C = e;
+                    e.qe = i.C;
+                    i.C = e;
                 }
                 return read(t);
             }, t => {
                 n(typeof e === "function" ? t : e);
-                dispose(o);
+                dispose(i);
             }, e => {
                 r(e);
-                dispose(o);
+                dispose(i);
             }, {
                 user: true,
-                dt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
+                Pt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
             });
             make();
         });
@@ -515,9 +529,9 @@ function createMemo(e, t) {
     // write flips it truthy, that transition merges here and reveals at the
     // joint settle instead of painting the confirmation under live optimism.
         const n = activeTransition;
-    return new Promise((r, o) => {
-        const i = t?.signal;
-        if (i?.aborted) return o(i.reason);
+    return new Promise((r, i) => {
+        const o = t?.signal;
+        if (o?.aborted) return i(o.reason);
         createRoot(c => {
             // Same delivery contract as resolve() (#2930): effect applies ride a
             // microtask so the promise can settle while the transaction the caller
@@ -525,13 +539,13 @@ function createMemo(e, t) {
             // entire point of the hold.
             const s = getOwner();
             const u = new MicrotaskQueue;
-            u.ke = s.C;
+            u.qe = s.C;
             s.C = u;
             let f;
             let a;
             const settle = e => {
                 if (f !== undefined) clearTimeout(f);
-                if (a !== undefined) i.removeEventListener("abort", a);
+                if (a !== undefined) o.removeEventListener("abort", a);
                 e();
                 c();
             };
@@ -547,7 +561,7 @@ function createMemo(e, t) {
                 // Falsy is "not yet": keep the subscription live and wait for the
                 // next evaluation. Only a truthy settled value resolves.
                 if (e) settle(() => r(e));
-            }, e => settle(() => o(e)), 
+            }, e => settle(() => i(e)), 
             // AUTHORITATIVE_READ: overrides invisible to the predicate.
             // DIRECT_COMMIT: truth that stages into the held transaction (a
             // refresh the action issued) must flow through to the microtask
@@ -555,12 +569,12 @@ function createMemo(e, t) {
             // the hold itself is keeping uncommitted.
             {
                 user: true,
-                dt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                Pt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
             });
-            if (t?.timeout !== undefined) f = setTimeout(() => settle(() => o(new TimeoutError)), t.timeout);
-            if (i !== undefined) {
-                a = () => settle(() => o(i.reason));
-                i.addEventListener("abort", a, {
+            if (t?.timeout !== undefined) f = setTimeout(() => settle(() => i(new TimeoutError)), t.timeout);
+            if (o !== undefined) {
+                a = () => settle(() => i(o.reason));
+                o.addEventListener("abort", a, {
                     once: true
                 });
             }
@@ -677,7 +691,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
         // 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