@jsenv/navi 0.29.327 → 0.29.329

package/dist/jsenv_navi.js

@@ -7071,6 +7071,16 @@ const positionCallout = (
           }
           return;
         }
+        if (!calloutElement.isConnected) {
+          // The callout is drawn inside the anchor's subtree (calloutContainer),
+          // so it leaves the document with it — a Suspense boundary parking
+          // the screen while an action re-runs keeps the subtree mounted, refs
+          // intact, but detached. showPopover() throws on a detached element,
+          // and leaving the document already took it out of the top layer, so
+          // there is nothing to hide either: same as ancestorClosed, wait for
+          // the next check, which shows it again once the subtree is back.
+          return;
+        }
         if (!calloutElement.matches(":popover-open")) {
           if (debug) {
             debug(event, "showing callout because anchor is visible again");
@@ -23516,10 +23526,16 @@ const createRoutePattern = (
   // search params are updated. When buildMostPreciseUrl performs an ancestor
   // optimisation (e.g. "/map/isochrone/compare" → "/map/isochrone") it is trusted
   // as-is because the built pathname will differ from the route's own base pathname.
-  // Weak params are never inherited from their signal, but a url that already
-  // carries one keeps it: staying on the same screen while another param
-  // changes must not end the visit this param qualifies.
-  const carryOverWeakParams = (currentUrl, params) => {
+  // A weak param is never inherited from its signal by a url built for a link
+  // (see readSignalForUrlBuild). A url amended in place is another matter: the
+  // route is matching, so the signal IS this visit's state, kept in step with
+  // the address by every routing pass — and what it holds is carried over, so
+  // that changing another param does not end the visit this one qualifies.
+  // Read from the signal, not from the url being amended: several signals
+  // written in one batch flush one url write at a time, and the routing pass
+  // of the first would take the others for gone — and reset them — if the url
+  // it wrote did not already carry what they hold.
+  const carryOverWeakParams = (params) => {
     let paramsWithWeak = params;
     for (const connection of connections) {
       const { paramName } = connection;
@@ -23527,17 +23543,13 @@ const createRoutePattern = (
         continue;
       }
       const currentValue = connection.signal.peek();
-      if (currentValue === undefined) {
-        continue;
-      }
-      const currentParams = applyOn(currentUrl);
-      if (!currentParams || currentParams[paramName] === undefined) {
+      if (connection.isDefaultValue(currentValue)) {
         continue;
       }
       if (paramsWithWeak === params) {
         paramsWithWeak = { ...params };
       }
-      paramsWithWeak[paramName] = currentParams[paramName];
+      paramsWithWeak[paramName] = currentValue;
     }
     return paramsWithWeak;
   };
@@ -23573,7 +23585,7 @@ const createRoutePattern = (
   };
 
   const buildUrlPreservingPath = (currentUrl, params = {}) => {
-    params = carryOverWeakParams(currentUrl, params);
+    params = carryOverWeakParams(params);
     if (currentUrl) {
       params = carryOverPathParams(currentUrl, params);
     }
@@ -26438,20 +26450,28 @@ const setupBrowserIntegrationViaHistory = ({
   // traversal to another document is a full page load, which no press on a
   // link asked for — the entries that are ours are recorded as they are
   // created, starting with the one this document was loaded into.
+  //
+  // The presence of window.navigation says nothing about the entry: the spec
+  // makes currentEntry null in a document that is not fully active, and iOS
+  // Safari answers null in a document that plainly is (a booted app, minutes
+  // into a session). Nothing can be done about it; an entry that cannot be
+  // read is treated as a browser without the API, which only costs the
+  // adjacency.
   const sameDocumentEntryKeys = new Set();
   const rememberEntryIsOfThisDocument = () => {
-    if (window.navigation) {
-      sameDocumentEntryKeys.add(window.navigation.currentEntry.key);
+    const currentEntry = window.navigation?.currentEntry;
+    if (currentEntry) {
+      sameDocumentEntryKeys.add(currentEntry.key);
     }
   };
   rememberEntryIsOfThisDocument();
   const adjacentEntryDelta = (url) => {
-    const { navigation } = window;
-    if (!navigation) {
+    const currentEntry = window.navigation?.currentEntry;
+    if (!currentEntry) {
       return 0;
     }
-    const entries = navigation.entries();
-    const index = navigation.currentEntry.index;
+    const entries = window.navigation.entries();
+    const index = currentEntry.index;
     // Behind first: when the same page stands on both sides (A, B, A and one
     // is on B), a link to it reads as going back.
     for (const delta of [-1, 1]) {
@@ -35880,7 +35900,7 @@ const useUIStateController = (
         // reach until that popup opens. Letting it block interaction would make
         // a picker whose content is loading impossible to open at all.
         getInteractionBlockingControls: () => [],
-        onUIAction: (e, { skipCommand } = {}) => {
+        onUIAction: (e, { skipCommand, skipBoundSignal } = {}) => {
           if (controlType === "button" && controller.controlHostProps.name) {
             const buttonName = controller.controlHostProps.name;
             const parentController = controller.parentUIStateController;
@@ -35906,7 +35926,9 @@ const useUIStateController = (
           }
           // Trigger uiAction/command side effects without changing UI state.
           const currentUIState = controller.uiState;
-          writeBoundSignal(currentUIState);
+          if (!skipBoundSignal) {
+            writeBoundSignal(currentUIState);
+          }
           s.uiActionInternal?.(currentUIState, e);
           if (s.uiAction) {
             s.uiAction(currentUIState, e);
@@ -36128,7 +36150,15 @@ const useUIStateController = (
               // sync, but do NOT fire the command and do NOT notify the parent —
               // both would cause an infinite loop when a parent cascades state
               // down to its children (child command would re-trigger the cascade).
-              controller.onUIAction(e, { skipCommand: true });
+              // A control following what it was given (state_prop_change) does
+              // not write its bound signal either: the signal is what it
+              // follows. The one write that would change it is an emptied
+              // signal refilled with the suggestion the control fell back on —
+              // a state the app just took back, put back by the control.
+              controller.onUIAction(e, {
+                skipCommand: true,
+                skipBoundSignal: e.type === "state_prop_change",
+              });
             }
             if (
               e.type === "facade_propagate_up" ||
@@ -73060,8 +73090,11 @@ const Spin = ({
   // elsewhere on the page — and the control follows it. A control seeded from a
   // signal only writes back into it (see resolveInputProps), which is enough
   // for a field one only ever types into and not for a value that is also moved
-  // from outside. Undefined is not a value: the signal has nothing to say, so
-  // the control goes back to what it started on.
+  // from outside. A signal holding nothing is left alone: the control goes back
+  // to the suggestion it started on by itself (see resolveValueState), and
+  // asking it to reset would be an act of its own, written into the signal —
+  // the signal could then never hold nothing while a spin is bound to it, and a
+  // day the app took back would come back as today.
   const signalValue = signalProp ? signalProp.value : undefined;
   // The value as of the render this effect belongs to, and not one the closure
   // captured a while ago: a step writes the signal, the signal brings us back
@@ -73075,7 +73108,6 @@ const Spin = ({
       return;
     }
     if (signalValue === undefined) {
-      dispatchRequestResetUIState(controlEl);
       return;
     }
     if (signalValue !== valueRef.current) {