@jsenv/navi 0.29.499 → 0.29.501

package/dist/dev/jsenv_navi.js

@@ -9102,11 +9102,7 @@ const route = (pattern, options = {}) => {
         );
       }
       // eslint-disable-next-line no-loop-func
-      const cleanupSignalUrlEffect = effect(() => {
-        const value = paramSignal.value;
-        // Use peek() to avoid subscribing to URL-derived signals.
-        // This effect should only re-run when the param signal changes,
-        // not when the URL changes (which would create a cycle: signal→URL→signal).
+      const writeValueInUrl = (value) => {
         const rawParams = route.rawParamsSignal.peek();
         const urlParamValue = rawParams[paramName];
         const matching = route.matchingSignal.peek();
@@ -9181,6 +9177,14 @@ const route = (pattern, options = {}) => {
             debounceUrl,
           },
         );
+      };
+      const cleanupSignalUrlEffect = effect(() => {
+        const value = paramSignal.value;
+        // Only the param signal re-runs this effect. Writing the url reads
+        // more (the route's other params, to build it): subscribed to those,
+        // the write is made again whenever one of them changes — a second
+        // entry when the write pushes.
+        untracked(() => writeValueInUrl(value));
       });
       cleanupSignalUrlEffectSet.add(cleanupSignalUrlEffect);
     }
@@ -14962,7 +14966,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
@@ -14974,10 +14992,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;
@@ -15021,6 +15041,7 @@ const setupBrowserIntegrationViaHistory = ({
     stop,
     reload,
     navBack,
+    whenBackLanded,
     navForward,
     getDocumentState,
     carryByLinkNavigation,
@@ -15367,6 +15388,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;
@@ -15617,7 +15642,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;
     }
@@ -18921,7 +18953,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,