@jsenv/navi 0.29.217 → 0.29.218

package/dist/jsenv_navi.js

@@ -26152,9 +26152,10 @@ const setupBrowserIntegrationViaHistory = ({
     const {
       reason,
       navigationType, // "load", "reload", "replace", "push", "traverse"
-      state,
       redirected,
+      landOn,
     } = options;
+    let { state } = options;
 
     // Where the entry being reached stands in this document's own stack —
     // decided before the state that carries it is built (see
@@ -26182,7 +26183,22 @@ const setupBrowserIntegrationViaHistory = ({
     } else {
       // traverse / reload: state comes from the history entry, no push/replace needed.
       markUrlAsVisited(url);
-      if (redirected) {
+      if (landOn) {
+        // The entry the back landed on, written over where it stands with
+        // what must outlive the popped one (see navBack's `landOn`) — before
+        // the routes read anything, so the only address they ever see is the
+        // one being kept.
+        state = resolveEffectiveDocumentState(landOn.state, {
+          navigationType: "replace",
+          currentState: state,
+          sharedState: {
+            jsenv_visited_urls: Array.from(visitedUrlSet),
+            [NAV_DEPTH_STATE_KEY]: getNavDepth(),
+          },
+        });
+        window.history.replaceState(state, null, url);
+        rememberEntryIsOfThisDocument();
+      } else if (redirected) {
         // The entry the browser is on names an address that only sends
         // elsewhere — a cold load on it, or a back into it. Written over where
         // it stands (the entry keeps its place in the stack, hence its state
@@ -26346,6 +26362,17 @@ const setupBrowserIntegrationViaHistory = ({
   window.addEventListener("popstate", (popstateEvent) => {
     const url = window.location.href;
     const state = popstateEvent.state;
+    const landOn = landOnPending;
+    landOnPending = null;
+    if (landOn) {
+      handleRoutingTask(landOn.url, {
+        reason: `"popstate" event for ${url}, landing on ${landOn.url}`,
+        navigationType: "traverse",
+        state,
+        landOn,
+      });
+      return;
+    }
     handleRoutingTask(url, {
       reason: `"popstate" event for ${url}`,
       navigationType: "traverse",
@@ -26387,7 +26414,11 @@ const setupBrowserIntegrationViaHistory = ({
     });
   };
 
-  const navBack = ({ fallback } = {}) => {
+  // What the next "popstate" writes over the entry it lands on, when a back
+  // 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 } = {}) => {
     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
@@ -26398,6 +26429,7 @@ const setupBrowserIntegrationViaHistory = ({
           once: true,
         });
       });
+      landOnPending = landOn || null;
       window.history.back();
       return landedPromise;
     }
@@ -26600,6 +26632,12 @@ const reload = browserIntegration.reload;
  *   Where to land when there is nothing of this document behind. It takes the
  *   place of the current entry rather than stacking on it. Without it, a
  *   navBack() with nowhere to go does nothing.
+ * @param {{ url: string, state?: object }} [options.landOn]
+ *   What the entry the back lands on reads once landed: its url, and its state
+ *   (`undefined` keeps the state it has). Written over that entry within the
+ *   back's own navigation, so the routes never see the entry as it was — the
+ *   way a screen closed over a url keeps what was written to the url while it
+ *   was open (see useNavState's leave()).
  * @returns {Promise<boolean>|undefined}
  *   When there is something to go back to: a promise resolved once the back
  *   has landed and been applied (`true` — the document url and state say
@@ -26691,10 +26729,13 @@ const useNavStateBasic = (
   // Both push-mode closes pop the pushed entry. A keep-close that merely
   // rewrote it in place would leave two entries describing the same closed
   // screen — same url, same state — and the next back press would appear to do
-  // nothing. So the keep path goes back like the cancel does, then writes what
-  // must be kept onto the entry the back lands on. Only with nothing of this
-  // document behind (the state was entered on a cold-loaded url, navBack has
-  // nowhere to go) does it rewrite in place.
+  // nothing. So the keep path goes back like the cancel does, with what must
+  // be kept written onto the entry the back lands on, in the same navigation:
+  // a route param written while the state was entered is in the url being
+  // kept, and a routing pass reading the entry behind as it was would take
+  // that param for gone. Only with nothing of this document behind (the state
+  // was entered on a cold-loaded url, navBack has nowhere to go) does it
+  // rewrite in place.
   const leave = ({ isBack } = {}) => {
     enteredRef.current = false;
     const currentStateCopy = browserIntegration.getDocumentState() || {};
@@ -26706,13 +26747,9 @@ const useNavStateBasic = (
         browserIntegration.navBack();
         return;
       }
-      const urlToKeep = window.location.href;
       delete currentStateCopy[id];
-      browserIntegration.navBack().then((landed) => {
-        if (!landed) {
-          return;
-        }
-        navTo(urlToKeep, { replace: true, state: currentStateCopy });
+      browserIntegration.navBack({
+        landOn: { url: window.location.href, state: currentStateCopy },
       });
       return;
     }
@@ -45007,16 +45044,7 @@ const writeOpenedInSignal = (signal, opened, event) => {
       return;
     }
     writeInSignal(signal, false, { history: "replace" });
-    const urlToKeep = window.location.href;
-    navBack().then((landed) => {
-      if (!landed) {
-        return;
-      }
-      // Often nothing at all: with no other write made while the popup was
-      // open, the entry landed on already reads urlToKeep and navTo skips
-      // the navigation entirely.
-      navTo(urlToKeep, { replace: true });
-    });
+    navBack({ landOn: { url: window.location.href } });
     return;
   }
   writeInSignal(signal, false, { history: "replace" });