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

package/dist/prod/attribution.js

@@ -0,0 +1,32 @@
+const EMPTY = Object.freeze([]);
+
+const noop = () => {};
+
+const attribution = {
+    enable: noop,
+    disable: noop,
+    subscribe: () => noop,
+    history: () => EMPTY,
+    why: () => [],
+    subscriptions: () => [],
+    costs: () => ({
+        scopes: [],
+        writes: []
+    }),
+    waterfalls: () => EMPTY,
+    holds: () => EMPTY,
+    navigations: () => EMPTY,
+    interactions: () => EMPTY,
+    feedback: () => ({
+        sources: [],
+        interactions: [],
+        navigations: [],
+        flights: [],
+        fallbacks: []
+    }),
+    markFlight: noop,
+    format: () => "",
+    formatOrigin: () => ""
+};
+
+export { attribution };

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;
 }
 
 /**
@@ -74,36 +85,45 @@ 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.ue.push(i);
-        const done = (e, r, u = false) => {
-            o = currentTransition(o);
-            const s = o.ue.indexOf(i);
-            if (s >= 0) o.ue.splice(s, 1);
+        let s = activeTransition;
+        s.ue.push(i);
+        const done = (e, t, o = false) => {
+            s = currentTransition(s);
+            const u = s.ue.indexOf(i);
+            if (u >= 0) s.ue.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 +134,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();
     });