@jsenv/navi 0.29.432 → 0.29.433

package/dist/dev/jsenv_navi.js

@@ -11537,6 +11537,11 @@ const [publishRouteRender, observeRouteRender] = createPubSub();
 const STORAGE_KEY = "navi_scroll_positions";
 
 const positionByUrl = new Map();
+// Where the document stands, as its scroll events last said, whoever it
+// belongs to: what a url shown without the document moving is given (see
+// stayInPlace). Null until the restoration is installed — nothing is recorded
+// before.
+let documentOffset = null;
 // url -> (scroller name -> position). The position is whatever the scroller
 // handed in: what it can put itself back on, in its own terms.
 const scrollerPositionsByUrl = new Map();
@@ -11653,30 +11658,25 @@ const installScrollRestoration = () => {
   }
   window.history.scrollRestoration = "manual";
   loadStore();
+  documentOffset = { x: window.scrollX, y: window.scrollY };
   // Read as it happens rather than when leaving: a traverse changes the url
   // before anything here is told, so a position read then would be read for
   // the wrong page.
   window.addEventListener(
     "scroll",
     () => {
+      documentOffset = { x: window.scrollX, y: window.scrollY };
       if (suspendCount) {
         return;
       }
-      positionByUrl.set(window.location.href, {
-        x: window.scrollX,
-        y: window.scrollY,
-      });
+      positionByUrl.set(window.location.href, documentOffset);
     },
     { passive: true },
   );
   const positionOnLoad = positionByUrl.get(window.location.href);
   if (!positionOnLoad) {
-    // Where the browser landed the first page, written down for the reason
-    // startAtTop writes its top: no scroll event says so.
-    positionByUrl.set(window.location.href, {
-      x: window.scrollX,
-      y: window.scrollY,
-    });
+    // The first page, where the browser landed it.
+    stayInPlace(window.location.href);
     return;
   }
   // What a reload asks for, now that the browser has been told not to do it.
@@ -11767,6 +11767,7 @@ const restoreScrollPositionOnReturn = (url) => {
 // app that scrolls an element of its own scrolls it itself.
 const startAtTop = (url, { from } = {}) => {
   if (!isArrival(url, { from })) {
+    stayInPlace(url);
     return;
   }
   arrivalCount++;
@@ -11788,6 +11789,23 @@ const isArrival = (url, { from }) => {
   return true;
 };
 
+// A url the document is shown under without moving: a replace, a push that
+// keeps the page (see startAtTop), the first page loaded. No scroll event says
+// where it stands, so it is written down here, or a return to it would find
+// nothing and keep the offset of the page being left. The offset the scroll
+// events last told, not read again: a read here would lay the page out in the
+// middle of a routing, once per address a settling param writes.
+//
+// Deaf with the recording: a row of tabs replaces the url as it travels, and
+// the offset belongs to nobody until the row says where its tab lands (see
+// arriveAtScrollPosition).
+const stayInPlace = (url) => {
+  if (documentOffset === null || suspendCount) {
+    return;
+  }
+  positionByUrl.set(new URL(url, window.location.href).href, documentOffset);
+};
+
 // The same arrival, for the page's own scrollers. The document is scrolled to
 // its top once the page is there; a list opens where it decides to in its
 // first render, so what it must not find is dropped before the routing
@@ -12263,14 +12281,18 @@ const setupBrowserIntegrationViaHistory = ({
     // also waits for the page it returns to: an offset is clamped to whatever
     // page the document holds when it is written.
     //
-    // A replace gets neither: it is the same place said differently — a param
-    // settling, a state written — and moving the reader for it would throw
-    // them out of a page they never left. A push that keeps the pathname is
-    // read the same way, by startAtTop itself. The one replace that IS an
-    // arrival is a row of tabs travelling, and the row says so for itself (see
-    // route_travel.jsx).
+    // A replace leaves the document where it is: it is the same place said
+    // differently — a param settling, a state written — and moving the reader
+    // for it would throw them out of a page they never left. Where they stay
+    // is written down for the new address (see stayInPlace). A push that keeps
+    // the pathname is read the same way, by startAtTop itself. The one replace
+    // that IS an arrival is a row of tabs travelling, and the row says so for
+    // itself (see route_travel.jsx) — from inside the routing above, which is
+    // why the replace is written down after it.
     if (navigationType === "push") {
       whenRenderingResumes(() => startAtTop(url, { from: urlLeft }));
+    } else if (navigationType === "replace") {
+      stayInPlace(url);
     } else if (navigationType === "traverse") {
       restoreScrollPositionOnReturn(url);
     }
@@ -71723,32 +71745,43 @@ document.addEventListener(
 );
 
 /*
- * Whether a scroller is gliding: moving on its own toward a place it was sent
- * to, with no hand on it — a key (Home, PageDown, Space), a smooth `scrollTo`
- * or `scrollIntoView`, the status bar tap on iOS. The other scrolls follow a
- * hand: a finger on the screen, a wheel turning.
- *
- * It matters to whoever writes a scroll position while one plays: the write is
- * an instant scroll, and the browser abandons the glide for it, short of where
- * it was going. A hand is not abandoned: its next report moves the scroller on
- * from wherever the write left it.
- *
- * A scroll is followed from its first "scroll" event to its "scrollend". It is
- * a hand's when a finger was down as it started (the fling a finger leaves
- * behind is still its own), when one is down now, or when a wheel turned
- * around the time it started or since. A finger is down from its
- * touchstart to its touchend, heard on what it touched: a list removes the
- * items scrolled out of its window while the finger is still on one of them,
- * and the touchend of a removed element never reaches the document.
- *
- * In a browser without "scrollend", nothing is said to glide: a scroll would
- * never be seen ending.
+ * Whether writing a scroll position now would cost the user the scroll in
+ * progress. A write is an instant scroll, and the browser abandons for it any
+ * scroll it is playing on its own, short of where that one was going: a key
+ * (Home, PageDown, Space), a smooth `scrollTo` or `scrollIntoView`, the status
+ * bar tap on iOS, the fling a finger leaves behind once it lifts. A scroll
+ * following a hand is not abandoned: the wheel's next turn carries on, and on
+ * most engines a finger keeps dragging from wherever the write left it.
+ *
+ * Not on iOS. Its finger places the content from where the drag began, so a
+ * write under it is undone at the finger's next move — or, when the finger
+ * lifts first, lands after the lift and stops the fling dead. And a fling
+ * stops on any write during its momentum, as the status bar's scroll to the
+ * top does (Safari 26.5 on the simulator: flings of 1700px stopped 130 to 340px
+ * after the lift, 3 in 3; a write 50ms before the lift stopped 2 flings in 3).
+ * No finger there is a hand a write could hold to. Chrome flings on through a
+ * write, and loses nothing by not getting one.
+ *
+ * A scroll is followed from its first "scroll" event to its "scrollend", and
+ * is a hand's while a finger is down, or when a wheel turned around the time it
+ * started or since. A finger is down from its touchstart to its touchend,
+ * heard on what it touched: a list removes the items scrolled out of its window
+ * while the finger is still on one of them, and the touchend of a removed
+ * element never reaches the document.
+ *
+ * In a browser without "scrollend", no write is said to interrupt anything: a
+ * scroll would never be seen ending.
  */
 
 // The scroll a wheel turn causes starts in the frame the turn is read, or the
 // next one. A turn further from it moved nothing (a wheel at an edge) and is no
 // hand on a scroll that came from elsewhere.
 const WHEEL_REACH = 100;
+// iOS's touch handling, the one engine whose finger drops writes (see above).
+const FINGER_KEEPS_WRITES = !window.CSS.supports(
+  "-webkit-touch-callout",
+  "none",
+);
 
 const flightMap = new WeakMap();
 let fingersDown = 0;
@@ -71758,13 +71791,13 @@ let wheelTimeStamp = -Infinity;
  * @param {Element} scrollerEl
  * @returns {boolean}
  */
-const isScrollGliding = (scrollerEl) => {
+const wouldInterruptScroll = (scrollerEl) => {
   const flight = flightMap.get(scrollerEl);
   if (!flight) {
     return false;
   }
-  if (flight.fingerDown || fingersDown > 0) {
-    return false;
+  if (fingersDown > 0) {
+    return !FINGER_KEEPS_WRITES;
   }
   if (wheelTimeStamp > flight.timeStamp - WHEEL_REACH) {
     return false;
@@ -71794,10 +71827,7 @@ if ("onscrollend" in window) {
       if (flightMap.has(scroller)) {
         return;
       }
-      flightMap.set(scroller, {
-        timeStamp: e.timeStamp,
-        fingerDown: fingersDown > 0,
-      });
+      flightMap.set(scroller, { timeStamp: e.timeStamp });
     },
     { capture: true, passive: true },
   );
@@ -75487,6 +75517,13 @@ const useListScrollSync = ({
       if (delta > -0.5 && delta < 0.5) {
         return;
       }
+      if (wouldInterruptScroll(scrollerEl)) {
+        // As the anchoring's write would (see holdAnchorStill). The document's
+        // box is the scroller of a list scrolling the page, and it resizes with
+        // every item drawn taller than its filler: while the page scrolls, that
+        // is at every window move.
+        return;
+      }
       anchorRef.current = null;
       if (horizontal) {
         scrollerEl.scrollLeft += delta;
@@ -75584,13 +75621,12 @@ const useListScrollSync = ({
       return;
     }
     anchorRef.current = null;
-    if (isScrollGliding(scrollerEl)) {
+    if (wouldInterruptScroll(scrollerEl)) {
       // Nobody is looking at items standing still: they are passing by, on
-      // their way somewhere the browser was asked to take them (a key, a smooth
-      // scrollTo, the status bar). The write would be an instant scroll, and
-      // the browser abandons the glide for it, short of where it was going.
-      // Left alone, the items drawn above push the rest by `drift` while all
-      // of it moves, and the glide lands.
+      // their way somewhere the browser takes them (a key, a smooth scrollTo,
+      // the status bar, a fling). The write would stop that scroll short of
+      // where it was going. Left alone, the items drawn above push the rest by
+      // `drift` while all of it moves, and the scroll lands.
       return;
     }
     scrolledByListRef.current = true;