@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.11

package/dist/prod/core/action.js

@@ -1,14 +1,25 @@
-import { globalQueue, activeTransition, currentTransition, schedule, flush } from "./scheduler.js";
+import { setOrigin, globalQueue, activeTransition, currentTransition, schedule, actionStepDepth, flush, enterActionStep, exitActionStep } from "./scheduler.js";
 
 import { isThenable } from "./async.js";
 
 import "./core.js";
 
-function restoreTransition(e, r) {
-    globalQueue.initTransition(e);
-    const t = r();
-    flush();
-    return t;
+/** Invocation order across all actions — the provenance every slice of an
+ * action runs under (scheduler `origin`): the flights and overrides its
+ * ambient windows issue are stamped with it, so a later action's override
+ * can tell this action's late answer from its own (#3331). */ let actionSeq = 0;
+
+function restoreTransition(e, t, n) {
+    const r = setOrigin(e);
+    globalQueue.initTransition(t);
+    const i = n();
+    // A nested action resuming synchronously (its body yielded a non-thenable)
+    // runs this inside the OUTER action's slice: draining here would park the
+    // shared transaction and detach the outer body's remaining writes (the
+    // flush() rule, scheduler.ts). The outer step's own return drains.
+        if (actionStepDepth === 0) flush();
+    setOrigin(r);
+    return i;
 }
 
 /**
@@ -36,15 +47,22 @@ function restoreTransition(e, r) {
  * `yield` is the transaction-safe suspension point: the action waits for a
  * yielded promise and re-enters the transaction before running the code after
  * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
+ * generator's internal await continuations, so code between an `await` and
+ * the next `yield` runs OUTSIDE the transaction: writes to fresh signals
+ * commit immediately, and anything that creates a reader there — `until()`,
+ * `latest()`, a memo or effect, a mount — is created mainline, where a read of
+ * this action's held state makes it born held (A29): staged with the
+ * transaction and replayed at its commit. For `until()` that commit is the
+ * settle its own promise holds open (#3482). `await` is still the ergonomic
+ * choice for typed results; just put a bare `yield` before any write or
+ * reader creation that follows it — including the expression of the next
+ * `yield`, which is evaluated before the step re-enters:
  *
  * ```ts
  * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
+ * yield; // re-enter the transaction before writing or reading
  * setTodos(t => { ... });
+ * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
  * (For the same reason, don't call `flush()` inside an action body — it
@@ -74,36 +92,46 @@ function restoreTransition(e, r) {
  * await addTodo("buy milk");
  * ```
  */ function action(e) {
-    return (...r) => new Promise((t, n) => {
-        const i = e(...r);
+    return (...t) => new Promise((n, r) => {
+        const i = e(...t);
+        const o = ++actionSeq;
+        // The first slice's window runs to the scheduled flush, which clears
+        // the provenance with the window — no restore here.
+                setOrigin(o);
         globalQueue.initTransition();
-        let o = activeTransition;
-        o.ie.push(i);
-        const done = (e, r, u = false) => {
-            o = currentTransition(o);
-            const s = o.ie.indexOf(i);
-            if (s >= 0) o.ie.splice(s, 1);
+        let s = activeTransition;
+        s.pe.push(i);
+        s.Te = true;
+        const done = (e, t, o = false) => {
+            s = currentTransition(s);
+            const u = s.pe.indexOf(i);
+            if (u >= 0) s.pe.splice(u, 1);
             // Re-adopt through initTransition like every other resumption site:
             // a bare setActiveTransition leaves globalQueue._batch as a detached
             // ambient batch, and anything registered before the scheduled flush
             // (held writes on a merging transition, optimistic overrides,
             // affects() marks) lands there with nothing to ever finalize it.
-                        globalQueue.initTransition(o);
+                        globalQueue.initTransition(s);
             schedule();
-            u ? n(r) : t(e);
+            o ? r(t) : n(e);
         };
-        const step = (e, r) => {
-            let t;
+        const step = (e, t) => {
+            let n;
+            // The body is on the stack between these brackets: flush() is
+            // refused inside (FLUSH_IN_ACTION, scheduler.ts).
+                        enterActionStep();
             try {
-                t = r ? i.throw(e) : i.next(e);
+                n = t ? i.throw(e) : i.next(e);
             } catch (e) {
+                exitActionStep();
                 return done(undefined, e, true);
             }
+            exitActionStep();
             // A rejected iterator result (async generators) means the error already
             // escaped the generator body — it is completed, and throwing back in
             // would just reject again forever. Settle instead.
-                        if (isThenable(t)) return void t.then(run, e => done(undefined, e, true));
-            run(t);
+                        if (isThenable(n)) return void n.then(run, e => done(undefined, e, true));
+            run(n);
         };
         const run = e => {
             if (e.done) return done(e.value);
@@ -114,23 +142,23 @@ function restoreTransition(e, r) {
             // the action so its iterator never leaks in the transition. The
             // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
             // already called a callback is ignored.
-                        let r = false;
+                        let t = false;
             try {
                 if (isThenable(e.value)) return void e.value.then(e => {
-                    if (r) return;
-                    r = true;
-                    restoreTransition(o, () => step(e));
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, s, () => step(e));
                 }, e => {
-                    if (r) return;
-                    r = true;
-                    restoreTransition(o, () => step(e, true));
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, s, () => step(e, true));
                 });
             } catch (e) {
-                if (r) return;
-                r = true;
-                return void restoreTransition(o, () => step(e, true));
+                if (t) return;
+                t = true;
+                return void restoreTransition(o, s, () => step(e, true));
             }
-            restoreTransition(o, () => step(e.value));
+            restoreTransition(o, s, () => step(e.value));
         };
         step();
     });