@jsenv/navi 0.29.461 → 0.29.463

package/dist/dev/jsenv_navi.js

@@ -3424,10 +3424,17 @@ ${lines.join("\n")}`,
   const staysFailedSet = new Set();
   const staysCompletedSet = new Set();
 
+  // Every decision below reads an action's state from its signals. The plain
+  // properties copying them (action.runningState, action.isPrerun) catch up
+  // only once the effect or batch in progress is over: a reset asked just
+  // before this update in the same effect — a kept answer the lookup found
+  // expired — still reads as completed there, and the run asked after it
+  // would join an answer that is gone.
+
   // Step 1: Determine which actions will be reset
   {
     for (const actionToReset of resetSet) {
-      if (actionToReset.runningState !== IDLE) {
+      if (actionToReset.runningStateSignal.peek() !== IDLE) {
         willResetSet.add(actionToReset);
       }
     }
@@ -3441,10 +3448,11 @@ ${lines.join("\n")}`,
     ) => {
       const isPrerun = requestType === "prerun";
       const isRerun = requestType === "rerun";
+      const runningState = action.runningStateSignal.peek();
 
       if (
         isRerun &&
-        action.runningState === COMPLETED &&
+        runningState === COMPLETED &&
         !willResetSet.has(action) &&
         isRerunHeldByNetworkPolicy(action)
       ) {
@@ -3455,10 +3463,7 @@ ${lines.join("\n")}`,
         );
         return;
       }
-      if (
-        action.runningState === RUNNING ||
-        action.runningState === COMPLETED
-      ) {
+      if (runningState === RUNNING || runningState === COMPLETED) {
         // Action is already running/completed
         // By default, we don't interfere with already active actions
         // Unless it's a rerun or the action is also being reset
@@ -3474,6 +3479,12 @@ ${lines.join("\n")}`,
           // The request performs nothing, and still has to be answered: what
           // the caller asked for is the answer, not the running.
           willJoinSet.add(action);
+          if (requestType === "run" && action.isPrerunSignal.peek()) {
+            // A prerun's run, or its answer, becomes the one this run asked
+            // for. A prerun that failed or was aborted carries nothing to
+            // promote: it is run like any other, in the branches below.
+            willPromoteSet.add(action);
+          }
         }
       } else if (isPrerun) {
         willPrerunSet.add(action);
@@ -3497,13 +3508,6 @@ ${lines.join("\n")}`,
         // rerun wins over run - skip run
         continue;
       }
-      if (actionToRun.isPrerun && actionToRun.runningState !== IDLE) {
-        // Special case: action was prerun but not yet requested to run
-        // Just promote it to "run requested" without rerunning
-        willPromoteSet.add(actionToRun);
-        willJoinSet.add(actionToRun);
-        continue;
-      }
       handleActionRequest(actionToRun, "run");
     }
 
@@ -3528,9 +3532,10 @@ ${lines.join("\n")}`,
       }
     }
     for (const actionSettled of settledSet) {
-      if (willResetSet.has(actionSettled)) ; else if (actionSettled.runningState === ABORTED) {
+      const runningState = actionSettled.runningStateSignal.peek();
+      if (willResetSet.has(actionSettled)) ; else if (runningState === ABORTED) {
         staysAbortedSet.add(actionSettled);
-      } else if (actionSettled.runningState === FAILED) {
+      } else if (runningState === FAILED) {
         staysFailedSet.add(actionSettled);
       } else {
         staysCompletedSet.add(actionSettled);
@@ -11857,6 +11862,26 @@ const activeRouteActionsSignal = computed(() => {
   return active;
 });
 
+/**
+ * Whether a route action of the page on screen asks nothing yet: its route
+ * matches and its params (or `when`) say no. Gated on app state not there yet,
+ * or never meant to ask on this page — nothing tells one from the other before
+ * it asks. Read by the scroll restoration, which stays ready for it.
+ *
+ * @type {import("@preact/signals").ReadonlySignal<boolean>}
+ */
+const routeActionYetToAskSignal = computed(() => {
+  for (const {
+    routeMatchingSignal,
+    askingSignal,
+  } of routeActionEntriesSignal.value) {
+    if (routeMatchingSignal.value && !askingSignal.value) {
+      return true;
+    }
+  }
+  return false;
+});
+
 let activeRouteReadsPrevious = new Set();
 /**
  * `activeRouteActionsSignal` without the page's code: what to rerun to read
@@ -11970,6 +11995,7 @@ const routeAction = (
     ...routeActionEntriesSignal.peek(),
     {
       routeAction: actionBoundToRoute,
+      routeMatchingSignal,
       askingSignal: computed(() => Boolean(readParamsAsked())),
     },
   ];
@@ -12126,10 +12152,11 @@ const haveSameMembers = (setA, setB) => {
  * moment it is put back, and a position beyond what has arrived is clamped.
  * What navi knows a first render left out, it waits for: a `<Box
  * mount="after-paint">` is built before the offset that shows it is written
- * (see mount_after_paint.jsx), and a reload waits for the route actions that
- * render had nothing to draw for — the page's code among them (see
- * restoreScrollPositionOnLoad). Anything else only the page knows, and it says
- * so (useHoldScrollRestoration). A wait can be long, so the reader reaching for
+ * (see mount_after_paint.jsx), and a reload or a return waits for the route
+ * actions the page has nothing to draw for — its code among them — including
+ * one that starts asking after the position is written (see
+ * putBackOnceAnswered). Anything else only the page knows, and it says so
+ * (useHoldScrollRestoration). A wait can be long, so the reader reaching for
  * the page during it cancels the position: moved afterwards, they would lose
  * whatever they had started on.
  *
@@ -12244,12 +12271,13 @@ const suspendScrollRecording = () => {
   };
 };
 
-// The position a reload or a return is about to put back, until it is written.
-// Where the document lands is the last arrival's to say: an arrival decided
-// meanwhile — a page that sends the reader elsewhere as it mounts — replaces it
-// (see startAtTop), and must not be scrolled to where the return was going.
-// So does the reader reaching for the page before it is written: where they
-// are is theirs (see installScrollRestoration).
+// The position a reload or a return is about to put back, until it is written
+// into a page that will ask nothing more (see stayForLateAsks). Where the
+// document lands is the last arrival's to say: an arrival decided meanwhile — a
+// page that sends the reader elsewhere as it mounts — replaces it (see
+// startAtTop), and must not be scrolled to where the return was going. So does
+// the reader reaching for the page: where they are is theirs (see
+// installScrollRestoration).
 let pendingRestoration = null;
 const startRestoration = (position) => {
   const restoration = { position, due: false };
@@ -12267,11 +12295,13 @@ const putBack = (restoration) => {
     // The page is not whole yet: the last release puts it back.
     return;
   }
-  pendingRestoration = null;
   if (documentHoldCount) {
+    pendingRestoration = null;
     return;
   }
   scrollTo(restoration.position);
+  restoration.due = false;
+  stayForLateAsks(restoration);
 };
 
 // A list scrolling the document that opens on a row puts the document where
@@ -12329,9 +12359,10 @@ const holdScrollRestoration = () => {
  * `held` turns false — unless the reader has reached for the page in the
  * meantime (a finger, a click, a wheel, a key), or gone elsewhere.
  *
- * After a reload, the page's route actions are waited for without this — its
- * code, a read the previous document did not keep. This is for what navi
- * cannot see: a read the page starts itself, content whose height arrives late.
+ * The page's route actions are waited for without this — its code, a read
+ * with no answer yet, one gated on app state that asks later. This is for
+ * what navi cannot see: a read the page starts itself, content whose height
+ * arrives late.
  *
  * ```jsx
  * const [games] = useAsyncData(GAMES, { loading: true, run: true });
@@ -12419,38 +12450,96 @@ const restoreScrollPositionOnLoad = (position) => {
   const restoration = startRestoration(position);
   const stopListening = observeRouteRender(() => {
     stopListening();
-    const unanswered = [];
-    for (const routeAction of activeRouteActionsSignal.peek()) {
-      if (
-        routeAction.runningStateSignal.peek() === RUNNING &&
-        routeAction.dataSignal.peek() === undefined
-      ) {
-        unanswered.push(routeAction);
-      }
-    }
-    if (unanswered.length === 0) {
-      queueMicrotask(() => {
-        putBack(restoration);
+    putBackOnceAnswered(restoration);
+  });
+};
+
+// Reads the actions to wait for at once: called from the commit of a render,
+// the ones it had nothing to draw for are those still running then. An answer
+// can start another read (params made of that answer), so the actions asking
+// are read again before the position is written.
+//
+// The same for a reload and a return: a return to a page this document has
+// never drawn, or whose read was reset since, finds no answer either.
+const putBackOnceAnswered = (restoration) => {
+  const unanswered = readUnansweredRouteActions();
+  if (unanswered.length === 0) {
+    queueMicrotask(() => {
+      putBack(restoration);
+    });
+    return;
+  }
+  // A reader drawing its own wait subscribes in an effect, after the first
+  // paint (see afterPaint): an answer that came before is drawn only then.
+  let waitCount = 2;
+  const waitOver = () => {
+    waitCount--;
+    if (waitCount === 0) {
+      whenPageRendered(() => {
+        putBackOnceAnswered(restoration);
       });
-      return;
     }
-    // A reader drawing its own wait subscribes in an effect, after the first
-    // paint (see afterPaint): an answer that came before is drawn only then.
-    let waitCount = 2;
-    const waitOver = () => {
-      waitCount--;
-      if (waitCount === 0) {
-        whenPageRendered(() => {
-          putBack(restoration);
-        });
+  };
+  afterPaint(waitOver);
+  whenSettled(unanswered, (answered) => {
+    if (answered) {
+      waitOver();
+    }
+  });
+};
+
+const readUnansweredRouteActions = () => {
+  const unanswered = [];
+  for (const routeAction of activeRouteActionsSignal.peek()) {
+    if (
+      routeAction.runningStateSignal.peek() === RUNNING &&
+      routeAction.dataSignal.peek() === undefined
+    ) {
+      unanswered.push(routeAction);
+    }
+  }
+  return unanswered;
+};
+
+// A page can start asking after the position is written: an action gated on
+// app state not there yet (`when`, or params reading an app-wide read), and
+// nothing tells "not yet" from "never" before it asks (see
+// routeActionYetToAskSignal). So a written position stays pending while a
+// route action of the page has not asked: the next one that starts without an
+// answer is waited for like the first ones, and the position put back once it
+// is drawn. Not told when the restoration is dropped (pendingRestoration is no
+// signal): it notices at its next run.
+const stayForLateAsks = (restoration) => {
+  effect(function () {
+    let running = false;
+    let starting = false;
+    for (const routeAction of activeRouteActionsSignal.value) {
+      if (routeAction.dataSignal.value !== undefined) {
+        continue;
       }
-    };
-    afterPaint(waitOver);
-    whenSettled(unanswered, (answered) => {
-      if (answered) {
-        waitOver();
+      const runningState = routeAction.runningStateSignal.value;
+      if (runningState === RUNNING) {
+        running = true;
+      } else if (runningState === IDLE) {
+        // Asking, and run by an effect of the same batch that has not run yet.
+        starting = true;
       }
-    });
+    }
+    const yetToAsk = routeActionYetToAskSignal.value;
+    if (pendingRestoration !== restoration) {
+      this.dispose();
+      return;
+    }
+    if (running) {
+      this.dispose();
+      putBackOnceAnswered(restoration);
+      return;
+    }
+    if (starting || yetToAsk) {
+      return;
+    }
+    this.dispose();
+    pendingRestoration = null;
   });
 };
 
@@ -12502,10 +12591,11 @@ const restoreScrollPosition = (url) => {
 };
 
 // A traversal back to `url`. The offset is written once the page returned to is
-// rendered: written sooner, the document still holds the page being left and
-// clamps it to that page's height. It is read at once all the same — a page
-// left taller than the one arriving is clamped by the render itself, and that
-// clamp is a scroll recorded under the url already returned to.
+// rendered and answered (see putBackOnceAnswered): written sooner, the document
+// still holds the page being left, or a stand-in for the one arriving, and
+// clamps it to that height. It is read at once all the same — a page left
+// taller than the one arriving is clamped by the render itself, and that clamp
+// is a scroll recorded under the url already returned to.
 const restoreScrollPositionOnReturn = (url) => {
   pendingRestoration = null;
   const href = new URL(url, window.location.href).href;
@@ -12516,7 +12606,7 @@ const restoreScrollPositionOnReturn = (url) => {
   }
   const restoration = startRestoration(position);
   whenPageRendered(() => {
-    putBack(restoration);
+    putBackOnceAnswered(restoration);
   });
 };