@jsenv/navi 0.29.485 → 0.29.486

package/dist/jsenv_navi.js

@@ -11489,6 +11489,31 @@ const resolveEffectiveDocumentState = (
   return { ...state, ...sharedState };
 };
 
+/**
+ * What a press on a link handed to the navigation it starts (see the
+ * integrations' `carryByLinkNavigation`): each write is an `editState` applied
+ * to the entry that navigation writes, and an `otherwise` that makes the write
+ * where it would have been made, for a press that starts no navigation here.
+ */
+const applyPressWrites = (state, pressWrites) => {
+  if (!pressWrites) {
+    return state;
+  }
+  let stateWritten = state;
+  for (const { editState } of pressWrites) {
+    stateWritten = editState(stateWritten);
+  }
+  return stateWritten;
+};
+const writePressWritesHere = (pressWrites) => {
+  if (!pressWrites) {
+    return;
+  }
+  for (const { otherwise } of pressWrites) {
+    otherwise();
+  }
+};
+
 // Preact's own useId() (see preact/hooks) returns "P<mask0>-<mask1>", where the
 // mask is derived from render order within the nearest root/async boundary:
 // stable across re-renders of the same mount, but not across two mounts on the
@@ -13133,6 +13158,7 @@ const setupBrowserIntegrationViaHistory = ({
         // Asked to go where we already are: an address that redirects is never
         // the one being displayed, so there is nothing to go to and nothing to
         // stack on the history.
+        writePressWritesHere(options.pressWrites);
         return undefined;
       }
       return handleRoutingTask(redirectionUrl, {
@@ -13144,10 +13170,13 @@ const setupBrowserIntegrationViaHistory = ({
     // Decided before anything is announced: an elided push IS the traversal it
     // becomes, and the traversal will make its own announcements when the
     // browser answers — a before/after cycle here would be about a navigation
-    // that never happens.
+    // that never happens. A push with something of its own for its entry — a
+    // state, what the press handed over (see carryByLinkNavigation) — is a
+    // new entry, never one standing there already.
     if (
       options.navigationType === "push" &&
       options.state === undefined &&
+      !options.pressWrites &&
       url !== readAddress()
     ) {
       const delta = adjacentEntryDelta(url);
@@ -13197,6 +13226,7 @@ const setupBrowserIntegrationViaHistory = ({
       redirected,
       landOn,
       debounce,
+      pressWrites,
     } = options;
     let { state } = options;
 
@@ -13207,15 +13237,18 @@ const setupBrowserIntegrationViaHistory = ({
 
     if (navigationType === "push" || navigationType === "replace") {
       markUrlAsVisited(url);
-      const effectiveState = resolveEffectiveDocumentState(state, {
-        navigationType,
-        isArrival: isArrival(url, { from: urlLeft }),
-        currentState: getDocumentState(),
-        sharedState: {
-          jsenv_visited_urls: Array.from(visitedUrlSet),
-          [NAV_DEPTH_STATE_KEY]: getNavDepth(),
-        },
-      });
+      const effectiveState = applyPressWrites(
+        resolveEffectiveDocumentState(state, {
+          navigationType,
+          isArrival: isArrival(url, { from: urlLeft }),
+          currentState: getDocumentState(),
+          sharedState: {
+            jsenv_visited_urls: Array.from(visitedUrlSet),
+            [NAV_DEPTH_STATE_KEY]: getNavDepth(),
+          },
+        }),
+        pressWrites,
+      );
       if (navigationType === "replace" && debounce && state === undefined) {
         // Nothing of its own for the entry: the address moves, the state is
         // carried over. The one kind of write allowed to lag, and only when
@@ -13315,6 +13348,36 @@ const setupBrowserIntegrationViaHistory = ({
     return requestedResult;
   };
 
+  // A press on a link is one navigation, and what the press asks of the
+  // history entry is part of it: a popup the link's own command closes is
+  // closed on the entry the link leads to, while the one it leaves keeps what
+  // the reader was looking at — a back finds the popup open. The link's
+  // listeners run before the routing is asked (below), so a write they make
+  // is handed over, keyed by the click, rather than written onto the entry
+  // being left. Once the link has been answered there is nothing to hand
+  // over to: the navigation, when there was one, has already written its
+  // entry, and a write lands there by itself.
+  const linkPressWritesMap = new WeakMap();
+  const answeredLinkClickSet = new WeakSet();
+  const carryByLinkNavigation = (event, pressWrite) => {
+    const clickEvent = findEvent(event, "click");
+    if (
+      !clickEvent ||
+      clickEvent.eventPhase === Event.NONE ||
+      answeredLinkClickSet.has(clickEvent) ||
+      !clickEvent.target.closest("a")
+    ) {
+      return false;
+    }
+    const pressWrites = linkPressWritesMap.get(clickEvent);
+    if (pressWrites) {
+      pressWrites.push(pressWrite);
+    } else {
+      linkPressWritesMap.set(clickEvent, [pressWrite]);
+    }
+    return true;
+  };
+
   // A click on a link is answered on the link itself, after the link's own
   // listeners: a navi control decides there whether the press is allowed — it
   // refuses with preventDefault from its click reaction — and runs its command
@@ -13322,34 +13385,42 @@ const setupBrowserIntegrationViaHistory = ({
   // is the order the Navigation API integration gets for free, where the
   // navigation starts once the click has been dispatched.
   const onLinkClick = (e) => {
+    answeredLinkClickSet.add(e);
+    const pressWrites = linkPressWritesMap.get(e);
+    linkPressWritesMap.delete(e);
+    if (!routeLinkClick(e, pressWrites)) {
+      writePressWritesHere(pressWrites);
+    }
+  };
+  const routeLinkClick = (e, pressWrites) => {
     if (e.button !== 0) {
       // Ignore non-left clicks
-      return;
+      return false;
     }
     if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) {
       // A modifier asks the browser for something other than this tab: a new
       // tab (meta on macOS, ctrl elsewhere), a new window (shift), a download
       // (alt).
-      return;
+      return false;
     }
     if (e.defaultPrevented) {
       // Refused — by the link itself, or by whoever came before it.
-      return;
+      return false;
     }
     const linkElement = e.currentTarget;
     if (linkElement.hasAttribute("data-readonly")) {
-      return;
+      return false;
     }
     if (linkOpensElsewhere(linkElement)) {
       // Another tab or window, or a download (see link_elsewhere.js).
-      return;
+      return false;
     }
     const href = linkElement.href;
     const { isEmpty, isCurrent, isSameOrigin, isAnchor } =
       getHrefTargetInfo(href);
     if (isEmpty || !isSameOrigin) {
       // Let link to other origins be handled by the browser
-      return;
+      return false;
     }
     if (isAnchor) {
       // Fragment navigation belongs to the browser: it owns the indicated
@@ -13361,13 +13432,13 @@ const setupBrowserIntegrationViaHistory = ({
         // change reaches whoever is waiting on the designated element.
         rearmUrlTarget();
       }
-      return;
+      return false;
     }
     if (linkAsksForDocument(linkElement)) {
       // The link says its address is another document of this origin (see
       // link_document.js). Routing to it would land on the fallback route
       // instead of loading the page.
-      return;
+      return false;
     }
     // Nothing here declared a route, so there is nothing to route to: the
     // page is a plain document and a link in it is a plain link. Taking it
@@ -13375,7 +13446,7 @@ const setupBrowserIntegrationViaHistory = ({
     // the address bar moves and the page does not (see applyRouting's own
     // "not called yet" branch, which is where that used to end up).
     if (!isRouting()) {
-      return;
+      return false;
     }
     e.preventDefault();
     handleRoutingTask(href, {
@@ -13389,7 +13460,9 @@ const setupBrowserIntegrationViaHistory = ({
       // whoever knows what to do with it, and it is the anchor itself —
       // resolved here, where it already is.
       element: linkElement,
+      pressWrites,
     });
+    return true;
   };
   // Wired from the capture phase on window, the first place a click is seen,
   // so that a link is answered whatever handler stops the click on its way up
@@ -13569,6 +13642,7 @@ const setupBrowserIntegrationViaHistory = ({
     navBack,
     navForward,
     getDocumentState,
+    carryByLinkNavigation,
     isVisited,
     visitedUrlsSignal,
   };
@@ -13968,8 +14042,32 @@ const useNavStateBasic = (
   // 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 } = {}) => {
+  //
+  // event: what asked for it. A leave the press of a link asks for (its
+  //   --navi-close) is made by the navigation that link starts: the entry the
+  //   link leads to does not hold the key, and every entry behind is left as
+  //   the reader saw it — a back finds the state still entered.
+  const leave = ({ isBack, event } = {}) => {
     enteredRef.current = false;
+    if (!Object.hasOwn(browserIntegration.getDocumentState() || {}, id)) {
+      return;
+    }
+    if (
+      event &&
+      browserIntegration.carryByLinkNavigation(event, {
+        editState: (state) => {
+          const stateWithoutKey = { ...state };
+          delete stateWithoutKey[id];
+          return stateWithoutKey;
+        },
+        otherwise: () => leaveEntry({ isBack }),
+      })
+    ) {
+      return;
+    }
+    leaveEntry({ isBack });
+  };
+  const leaveEntry = ({ isBack }) => {
     const currentStateCopy = browserIntegration.getDocumentState() || {};
     if (!Object.hasOwn(currentStateCopy, id)) {
       return;
@@ -14027,6 +14125,9 @@ const useNavStateBasic = (
  *     the value allows associating extra data when needed.
  *   - `leave()`: navigate AWAY FROM this state (removes `id` from document state,
  *     or goes back in history when `type` is "push").
+ *     `leave({ event })` with the event that asked for it: asked by the press
+ *     of a link that navigates, the key is left out of the entry the link
+ *     leads to, and the entry it leaves keeps it.
  */
 const useNavState = useNavStateBasic;
 
@@ -17210,8 +17311,13 @@ const useOpenPropsEffectOnOpenController = (
             } else {
               // Under type "push" a cancel discards everything written while
               // the popup was open — it goes back with the entry; a confirmed
-              // close keeps those writes (see useNavState's own leave()).
-              leaveNavState({ isBack: Boolean(event?.detail?.isCancel) });
+              // close keeps those writes (see useNavState's own leave()). A
+              // close a link's press asked for is written by the navigation
+              // the link starts.
+              leaveNavState({
+                isBack: Boolean(event?.detail?.isCancel),
+                event,
+              });
             }
           }
           if (signal) {
@@ -53123,7 +53229,9 @@ const LinkPseudoElements = ["::-navi-loader", "::-navi-indicator"];
  *   fetching on a hover.
  * @param {string} [props.command] - What the press asks of a control around
  *   the link — `"--navi-close"` on a link that leaves the sheet it is in.
- *   Triggered on the press, before the navigation.
+ *   Triggered on the press, before the navigation. A popup it closes that
+ *   keeps its open state in the history entry (`navState`) is closed on the
+ *   entry the navigation leads to: Back finds it open.
  * @param {Function} [props.action] - Work the press runs, before the
  *   navigation. Nothing waits for it — not the navigation, not `command`: what
  *   the next page must find has to be written synchronously (a draft in a