@jsenv/navi 0.29.462 → 0.29.464

package/dist/dev/jsenv_navi.js

@@ -11837,6 +11837,8 @@ const keptNameWeakMap = new WeakMap();
 const getRouteActionKeptName = (routeAction) => {
   return keptNameWeakMap.get(routeAction);
 };
+// Shared by every route action without a `when`.
+const NOT_GATED_SIGNAL = signal(false);
 let activeRouteActionsPrevious = new Set();
 /**
  * The route actions asking something for the page on screen: their route
@@ -11862,6 +11864,24 @@ const activeRouteActionsSignal = computed(() => {
   return active;
 });
 
+/**
+ * Whether a route action of the page on screen waits for app state to ask: its
+ * route matches and its `when` says no. Params that say no are not waiting:
+ * they read the address, and this one asks nothing of the action — a later ask
+ * is the page changing under the reader (a search typed), not arriving. Read
+ * by the scroll restoration, which stays ready for it.
+ *
+ * @type {import("@preact/signals").ReadonlySignal<boolean>}
+ */
+const routeActionYetToAskSignal = computed(() => {
+  for (const { gatedSignal } of routeActionEntriesSignal.value) {
+    if (gatedSignal.value) {
+      return true;
+    }
+  }
+  return false;
+});
+
 let activeRouteReadsPrevious = new Set();
 /**
  * `activeRouteActionsSignal` without the page's code: what to rerun to read
@@ -11928,7 +11948,9 @@ const activeRouteReadsSignal = computed(() => {
  *   params when the condition holds at that moment — a page's code only some
  *   readers may download (`() => meIsAdminSignal.value`). A condition reading
  *   the address belongs in the params: a link reads `when` as it is, not as
- *   the address it leads to will make it.
+ *   the address it leads to will make it. It is also what a reload's scroll
+ *   position waits for: the page is not whole while a `when` says no, whereas
+ *   params that say no ask nothing on this page (see scroll_restoration.js).
  * @param {boolean} [options.prefetch=true] - `false` keeps the action from
  *   being prerun ahead of what asks for it, when the read is not worth a
  *   hover or a press that may not end in an opening.
@@ -11976,6 +11998,9 @@ const routeAction = (
     {
       routeAction: actionBoundToRoute,
       askingSignal: computed(() => Boolean(readParamsAsked())),
+      gatedSignal: when
+        ? computed(() => Boolean(routeMatchingSignal.value) && !when())
+        : NOT_GATED_SIGNAL,
     },
   ];
   for (const route of routes) {
@@ -12131,11 +12156,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 — 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
+ * (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 whose `when` lets it ask after the position is written (see
+ * stayForLateAsks). 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.
  *
@@ -12250,17 +12275,16 @@ 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;
-// `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 };
+const startRestoration = (position) => {
+  const restoration = { position, due: false };
   pendingRestoration = restoration;
   return restoration;
 };
@@ -12275,16 +12299,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);
-  if (restoration.untilReached && fellShortOf(restoration.position)) {
-    restoration.due = false;
-    pendingRestoration = restoration;
-    putBackOnLateAnswer(restoration);
-  }
+  restoration.due = false;
+  stayForLateAsks(restoration);
 };
 
 // A list scrolling the document that opens on a row puts the document where
@@ -12342,9 +12363,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 whose `when` holds 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 });
@@ -12429,19 +12451,22 @@ 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, { untilReached: true });
+  const restoration = startRestoration(position);
   const stopListening = observeRouteRender(() => {
     stopListening();
     putBackOnceAnswered(restoration);
   });
 };
 
-// Reads the actions to wait for at once: from the commit of the first render,
+// 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 = untracked(readUnansweredRouteActions);
+  const unanswered = readUnansweredRouteActions();
   if (unanswered.length === 0) {
     queueMicrotask(() => {
       putBack(restoration);
@@ -12469,10 +12494,10 @@ const putBackOnceAnswered = (restoration) => {
 
 const readUnansweredRouteActions = () => {
   const unanswered = [];
-  for (const routeAction of activeRouteActionsSignal.value) {
+  for (const routeAction of activeRouteActionsSignal.peek()) {
     if (
-      routeAction.runningStateSignal.value === RUNNING &&
-      routeAction.dataSignal.value === undefined
+      routeAction.runningStateSignal.peek() === RUNNING &&
+      routeAction.dataSignal.peek() === undefined
     ) {
       unanswered.push(routeAction);
     }
@@ -12480,33 +12505,49 @@ const readUnansweredRouteActions = () => {
   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
+// A page can still be arriving after the position is written: an action whose
+// `when` waits for app state not there yet (see routeActionYetToAskSignal). So
+// a written position stays pending while one does: the next one 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) => {
+// back once it is drawn. Params that say no are not waited for: the address
+// asks nothing of the action, and one that asks later — a search typed — is
+// the page moving on under the reader, not arriving. 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;
+      }
+      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 (readUnansweredRouteActions().length === 0) {
+    if (running) {
+      this.dispose();
+      putBackOnceAnswered(restoration);
+      return;
+    }
+    if (starting || yetToAsk) {
       return;
     }
     this.dispose();
-    putBackOnceAnswered(restoration);
+    pendingRestoration = null;
   });
 };
 
-// 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) => {
@@ -12555,10 +12596,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;
@@ -12569,7 +12611,7 @@ const restoreScrollPositionOnReturn = (url) => {
   }
   const restoration = startRestoration(position);
   whenPageRendered(() => {
-    putBack(restoration);
+    putBackOnceAnswered(restoration);
   });
 };
 
@@ -84383,6 +84425,24 @@ const PickerButton = props => {
     clearConfirm,
     requestValue
   };
+  // `--navi-select`/`--navi-unselect` about one entry of the list the picker
+  // holds — a chip on the façade, a suggestion beside the field. Answered here
+  // rather than by the control drawing that list in the popup, even though rows
+  // are what such a control owns: a picker given its own value builds its popup
+  // only on first open (see popup_content_mount.js), so before that there is no
+  // such control at all — and building the whole popup to have someone to talk
+  // to, for a cross, is the wrong price. The picker holds the value in the first
+  // place and hands it down whenever the popup is built.
+  //
+  // Heard on both elements, like every request a control answers: a chip inside
+  // the picker aims at its root (the parent control), one standing elsewhere
+  // names it with `commandFor`, and the picker's id is on its input.
+  const onRequestSelect = e => {
+    requestPickerListEntry(ref.current, inputRef.current, e, "select");
+  };
+  const onRequestUnselect = e => {
+    requestPickerListEntry(ref.current, inputRef.current, e, "unselect");
+  };
   return (
     /* Read-only crosses into everything the picker is made of: what it really
        holds is drawn by controls of their own — in the popup, and on the façade
@@ -84443,23 +84503,9 @@ const PickerButton = props => {
         ,
         onnavi_request_open: inputProps.onnavi_request_open,
         onnavi_request_close: inputProps.onnavi_request_close,
-        onnavi_open_press: inputProps.onnavi_open_press
-        // `--navi-select`/`--navi-unselect` about one entry of the list the
-        // picker holds — a chip on the façade, a suggestion beside the field.
-        // Answered here rather than by the control drawing that list in the
-        // popup, even though rows are what such a control owns: a picker given
-        // its own value builds its popup only on first open (see
-        // popup_content_mount.js), so before that there is no such control at
-        // all — and building the whole popup to have someone to talk to, for a
-        // cross, is the wrong price. The picker holds the value in the first
-        // place and hands it down whenever the popup is built.
-        ,
-        onnavi_request_select: e => {
-          requestPickerListEntry(ref.current, inputRef.current, e, "select");
-        },
-        onnavi_request_unselect: e => {
-          requestPickerListEntry(ref.current, inputRef.current, e, "unselect");
-        },
+        onnavi_open_press: inputProps.onnavi_open_press,
+        onnavi_request_select: onRequestSelect,
+        onnavi_request_unselect: onRequestUnselect,
         children: [jsx("span", {
           className: "navi_picker_box",
           style: hangingChevronSize === undefined ? undefined : {
@@ -84481,6 +84527,8 @@ const PickerButton = props => {
               children: undefined // we will render children into the div
               ,
               ui: ui,
+              onnavi_request_select: onRequestSelect,
+              onnavi_request_unselect: onRequestUnselect,
               onCopy: e => {
                 const pickerEl = ref.current;
                 if (isWithinPickerContent(e.target, pickerEl)) {