@jsenv/navi 0.29.461 → 0.29.462

package/dist/jsenv_navi.js

@@ -3307,10 +3307,17 @@ const updateActions = ({
   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);
       }
     }
@@ -3324,10 +3331,11 @@ const updateActions = ({
     ) => {
       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)
       ) {
@@ -3338,10 +3346,7 @@ const updateActions = ({
         );
         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
@@ -3357,6 +3362,12 @@ const updateActions = ({
           // 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);
@@ -3380,13 +3391,6 @@ const updateActions = ({
         // 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");
     }
 
@@ -3411,9 +3415,10 @@ const updateActions = ({
       }
     }
     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);
@@ -11699,7 +11704,8 @@ const haveSameMembers = (setA, setB) => {
  * 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
+ * render had nothing to draw for — the page's code among them — and for one
+ * that starts asking later, when the position did not fit what was there (see
  * restoreScrollPositionOnLoad). 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
@@ -11823,8 +11829,10 @@ const suspendScrollRecording = () => {
 // So does the reader reaching for the page before it is written: where they
 // are is theirs (see installScrollRestoration).
 let pendingRestoration = null;
-const startRestoration = (position) => {
-  const restoration = { position, due: false };
+// `untilReached`: a write the document is too short for leaves it pending (see
+// putBackOnLateAnswer).
+const startRestoration = (position, { untilReached = false } = {}) => {
+  const restoration = { position, due: false, untilReached };
   pendingRestoration = restoration;
   return restoration;
 };
@@ -11844,6 +11852,11 @@ const putBack = (restoration) => {
     return;
   }
   scrollTo(restoration.position);
+  if (restoration.untilReached && fellShortOf(restoration.position)) {
+    restoration.due = false;
+    pendingRestoration = restoration;
+    putBackOnLateAnswer(restoration);
+  }
 };
 
 // A list scrolling the document that opens on a row puts the document where
@@ -11988,44 +12001,84 @@ const installScrollRestoration = ({ readAddress }) => {
 // page the position was taken on, and the position stays for the reload that
 // brings the page back.
 const restoreScrollPositionOnLoad = (position) => {
-  const restoration = startRestoration(position);
+  const restoration = startRestoration(position, { untilReached: true });
   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: from the commit of the first 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.
+const putBackOnceAnswered = (restoration) => {
+  const unanswered = untracked(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);
       });
+    }
+  };
+  afterPaint(waitOver);
+  whenSettled(unanswered, (answered) => {
+    if (answered) {
+      waitOver();
+    }
+  });
+};
+
+const readUnansweredRouteActions = () => {
+  const unanswered = [];
+  for (const routeAction of activeRouteActionsSignal.value) {
+    if (
+      routeAction.runningStateSignal.value === RUNNING &&
+      routeAction.dataSignal.value === undefined
+    ) {
+      unanswered.push(routeAction);
+    }
+  }
+  return unanswered;
+};
+
+// A page can start asking after its first render: an action gated on app
+// state that render did not have yet (`when`, or params reading an app-wide
+// read), and nothing tells "not yet" from "never" before it asks. So the
+// position is written into what the page lets it, and a write the document
+// could not hold is not the end of it: the next route action that starts
+// without an answer is waited for like the first ones, and the position put
+// back again. Not told when the restoration is dropped (pendingRestoration is
+// no signal): it notices at its next run.
+const putBackOnLateAnswer = (restoration) => {
+  effect(function () {
+    if (pendingRestoration !== restoration) {
+      this.dispose();
       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();
-      }
-    });
+    if (readUnansweredRouteActions().length === 0) {
+      return;
+    }
+    this.dispose();
+    putBackOnceAnswered(restoration);
   });
 };
 
+// A pixel of slack: the offset kept is the fractional one the browser reports.
+const fellShortOf = (position) => {
+  return position.y - window.scrollY > 1;
+};
+
 // Calls back once none of the actions is running, saying whether all of them
 // completed.
 const whenSettled = (actions, callback) => {