@jsenv/navi 0.29.498 → 0.29.500

package/dist/dev/jsenv_navi.js

@@ -10276,15 +10276,16 @@ const [publishRouteRender, observeRouteRender] = createPubSub();
  *
  * A page whose height depends on something still loading is not there at the
  * 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 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.
+ * So it is written into what is there, as far as that goes, and written again
+ * once the page is whole (see putBackMeanwhile). 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 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.
  *
  * WHEN a page is arrived at is not decided here either. A document navigation
  * lands where its kind says (see via_history.js), and one scrollport can be
@@ -10429,8 +10430,8 @@ const suspendScrollRecording = () => {
 // the reader reaching for the page: where they are is theirs (see
 // installScrollRestoration).
 let pendingRestoration = null;
-const startRestoration = (position, { meanwhile = false } = {}) => {
-  const restoration = { position, due: false, meanwhile };
+const startRestoration = (position) => {
+  const restoration = { position, due: false };
   pendingRestoration = restoration;
   return restoration;
 };
@@ -10490,15 +10491,13 @@ const isDocumentHeld = () => {
   return false;
 };
 
-// A return is photographed by its route transition as soon as its page has
-// rendered, stand-ins and all, and a position waiting for the page to be whole
-// is written after the movement, seen as a jump. So it is also written into
-// what is there meanwhile, as far as that goes — the browser clamps the rest —
-// and again once the page is whole, when what it stands on has grown or shrunk.
+// A position waiting for the page to be whole is written after the reader has
+// seen the page at its top, and seen as a jump — after the movement, when a
+// route transition photographs the page as soon as it renders, stand-ins and
+// all. So it is also written into what is there meanwhile, as far as that goes
+// (the browser clamps the rest), and again once the page is whole, when what
+// it stands on has grown or shrunk.
 const putBackMeanwhile = (restoration) => {
-  if (!restoration.meanwhile) {
-    return;
-  }
   // Out of whatever commit or effect is asking: see scrollTo.
   queueMicrotask(() => {
     if (pendingRestoration !== restoration || isDocumentHeld()) {
@@ -10535,11 +10534,11 @@ const holdScrollRestoration = () => {
 };
 
 /**
- * Holds back the scroll position a reload or a back/forward gives the page,
- * while the page is not whole yet: written into what the page shows meanwhile,
- * it is clamped to that height and lost. Put back after the commit in which
- * `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.
+ * Says the page is not whole yet to the scroll position a reload or a
+ * back/forward gives it: written into what the page shows meanwhile, it is
+ * clamped to that height. Put back again after the commit in which `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.
  *
  * 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
@@ -10789,7 +10788,7 @@ const restoreScrollPositionOnReturn = (url) => {
   if (!position) {
     return;
   }
-  const restoration = startRestoration(position, { meanwhile: true });
+  const restoration = startRestoration(position);
   whenPageRendered(() => {
     putBackOnceAnswered(restoration);
   });
@@ -14963,7 +14962,21 @@ const setupBrowserIntegrationViaHistory = ({
   // asked for it (see navBack's `landOn`). Read by the popstate listener,
   // which is the one place the landing is applied.
   let landOnPending = null;
-  const navBack = ({ fallback, landOn } = {}) => {
+  // The back navBack asked for, from history.back() to the "popstate" that
+  // answers it. Meanwhile the document still reads the entry being left (see
+  // whenBackLanded).
+  let backInFlight = null;
+  const whenBackLanded = (callback) => {
+    if (backInFlight) {
+      return backInFlight.then(callback);
+    }
+    return callback();
+  };
+  // A second back asked before the first one landed (two popups closed in the
+  // same handler) waits for it: the browser would queue both, but the landing
+  // has one slot, and its `landOn` was read on the entry the first back leaves.
+  const navBack = (options) => whenBackLanded(() => navBackNow(options));
+  const navBackNow = ({ fallback, landOn } = {}) => {
     if (canNavBackSignal.peek()) {
       // Resolved once the back has landed: the "popstate" it is answered with
       // reaches the routing listener first (registered at setup, before this
@@ -14975,10 +14988,12 @@ const setupBrowserIntegrationViaHistory = ({
             return;
           }
           window.removeEventListener("popstate", onPopstate);
+          backInFlight = null;
           resolve(true);
         };
         window.addEventListener("popstate", onPopstate);
       });
+      backInFlight = landedPromise;
       landOnPending = landOn || null;
       window.history.back();
       return landedPromise;
@@ -15022,6 +15037,7 @@ const setupBrowserIntegrationViaHistory = ({
     stop,
     reload,
     navBack,
+    whenBackLanded,
     navForward,
     getDocumentState,
     carryByLinkNavigation,
@@ -15368,6 +15384,10 @@ const reload = browserIntegration.reload;
  *   current entry's place.
  */
 const navBack = browserIntegration.navBack;
+// Runs `callback` once the back navBack started has landed, at once when there
+// is none: until then the document reads the entry that back is leaving, and
+// a write made there is gone with it.
+const whenBackLanded = browserIntegration.whenBackLanded;
 const navForward = browserIntegration.navForward;
 const isVisited = browserIntegration.isVisited;
 const visitedUrlsSignal = browserIntegration.visitedUrlsSignal;
@@ -15618,7 +15638,14 @@ const useNavStateBasic = (
     }
     leaveEntry({ isBack, discard });
   };
+  // Read and written on the entry the document lands on: a leave asked while
+  // another one's back is in flight (a popup closed with the one under it)
+  // would otherwise carry that entry's url and state — the other key
+  // included — onto the wrong one.
   const leaveEntry = ({ isBack, discard }) => {
+    whenBackLanded(() => leaveLandedEntry({ isBack, discard }));
+  };
+  const leaveLandedEntry = ({ isBack, discard }) => {
     if (!Object.hasOwn(browserIntegration.getDocumentState() || {}, id)) {
       return;
     }
@@ -18922,7 +18949,14 @@ const writeInSignal = (signal, value, { history }) => {
 // `discard` empties what belongs to the popup alone (its `ownSignals`): before
 // a keep-close reads the url it lands on, and once a back has landed — the
 // entry behind may hold them too, written by an `onOpen` before the push.
-const writeOpenedInSignal = (
+//
+// Read and written on the entry the document lands on: a close asked while
+// another popup's back is in flight (a popup closed with the one under it)
+// would otherwise read the url that back is leaving, and write onto it.
+const writeOpenedInSignal = (...args) => {
+  whenBackLanded(() => writeOpenedInLandedSignal(...args));
+};
+const writeOpenedInLandedSignal = (
   signal,
   opened,
   event,