@jsenv/navi 0.29.513 → 0.29.515

package/dist/dev/jsenv_navi.js

@@ -10973,6 +10973,19 @@ const recallScrollerPosition = (name) => {
   return positionByName.get(name);
 };
 
+// Said by a scroller sent back to its start while it stays mounted: where it
+// was is a place in what it no longer shows, so nothing is carried and nothing
+// is come back to under this address until it says where it is again. What it
+// said under another address stays, for the way back to that address.
+const forgetScrollerPosition = (name) => {
+  loadStore();
+  saidByScrollerName.delete(name);
+  const positionByName = scrollerPositionsByUrl.get(readShownUrl());
+  if (positionByName) {
+    positionByName.delete(name);
+  }
+};
+
 // Said by a scroller as it unmounts. Its page is being left when the url is
 // already another one — the history is written before the page it names is
 // taken down — and then its position is kept for the way back. The url still
@@ -38356,9 +38369,11 @@ const releaseTransitionDestination = (owner) => {
  * inside its rectangle — which is where the hand thinks it pressed. The same
  * move route_travel.jsx makes for the box a finger reaches for mid-flight.
  *
- * A `RouteTravel` holds this too. It leaves the bars live, so a control there
- * gets its click on its own; what this serves is a control in the part of a bar
- * photographed for the travel (`data-navi-fixed-bar-overhang`, fixed_bar.jsx).
+ * A `RouteTravel` holds this too, for the bars it leaves live. A control there
+ * gets its click on its own except in the first frames of the travel, when a
+ * press falls to the document root like any other; the part of a bar photographed
+ * for the travel (`data-navi-fixed-bar-overhang`, fixed_bar.jsx) is deaf
+ * throughout.
  *
  * ASKED FOR, never derived, and that is the whole safety of it: only the
  * application knows the control does not move. One that travels with the pages
@@ -39362,6 +39377,21 @@ const placeTransitionWindow = (owner, groupName) => {
   document.documentElement.setAttribute(WINDOW_PLACED_ATTRIBUTE, "");
 };
 
+/**
+ * Whether a point of the window lies in a band the furniture keeps: the pictures
+ * are cut at those bands, so what is seen there is never a page, however far the
+ * box runs under it.
+ */
+const isPointInTransitionBand = (clientX, clientY) => {
+  const band = readBand();
+  return (
+    clientX < band.left ||
+    clientX > window.innerWidth - band.right ||
+    clientY < band.top ||
+    clientY > window.innerHeight - band.bottom
+  );
+};
+
 // The live layout takes the box back. A discontinuity by construction — the
 // window stands at the held height, the box is at its own — and an invisible
 // one: the page arriving is fully in place, and the strip below it that the
@@ -42549,11 +42579,16 @@ const RouteTravel = ({
     gestureRef.current = gesture;
   };
 
-  // A press that lands ON the box while a travel is playing does not reach it:
-  // the browser's transition covers the page and the press is delivered to the
-  // document root instead, whatever the pictures are told about pointer events.
-  // So while a travel plays, the press is caught at the document and handed to
-  // the box when it fell inside it — which is where the hand thinks it pressed.
+  // A press aimed at a page while a travel is playing does not always reach the
+  // box: the browser's transition covers the page and the press can be delivered
+  // to the document root instead, whatever the pictures are told about pointer
+  // events. So while a travel plays, the press is caught at the document and
+  // handed to the box when it fell where a page is SEEN, which is where the hand
+  // thinks it pressed.
+  //
+  // Decided by the position and never by the target: in the first frames of a
+  // travel a press on a live bar falls to the root like any other, and what lies
+  // under a picture is not what the hand is aiming at.
   pointerDownRef.current = onPointerDown;
   useLayoutEffect(() => {
     const onDocumentPointerDown = pointerDownEvent => {
@@ -42578,6 +42613,11 @@ const RouteTravel = ({
       if (clientX < left || clientX > right || clientY < top || clientY > bottom) {
         return;
       }
+      // A box scrolled under a bar still has the press in its rectangle, but
+      // the pictures are cut at that bar: the press is aimed at the bar.
+      if (isPointInTransitionBand(clientX, clientY)) {
+        return;
+      }
       pointerDownRef.current(pointerDownEvent);
     };
     document.addEventListener("pointerdown", onDocumentPointerDown, true);
@@ -58011,8 +58051,9 @@ const LinkPseudoElements = ["::-navi-loader", "::-navi-indicator"];
  *   press on it is aimed at what the reader can see. Say it there, and only
  *   there: a control that TRAVELS with the pages has a rectangle where it will
  *   be, not where it is seen, and a press handed to it fires something nobody
- *   aimed at. A `RouteTravel` honours it as well, for a control in the part of
- *   a `FixedBar` it photographs (`data-navi-fixed-bar-overhang`).
+ *   aimed at. A `RouteTravel` honours it as well, for a control in a `FixedBar`:
+ *   the part it photographs (`data-navi-fixed-bar-overhang`) is deaf for the
+ *   whole travel, and the rest for its first frames.
  * @param {boolean} [props.replace] - Go to the destination by TAKING THE PLACE
  *   of the current history entry instead of stacking onto it: the link stays a
  *   link (an address, a middle click, the keyboard, `aria-current`), only the
@@ -64006,7 +64047,8 @@ const COMMAND_DEFAULT_PROPS_FACTORIES = {
  *   drawn — must still close it. What `<Link pressableDuringRouteTransition>`
  *   says, for the other half of a toggle. Only for a control that does not
  *   travel with the pages. A `RouteTravel` honours it as well, for a control in
- *   the part of a `FixedBar` it photographs (`data-navi-fixed-bar-overhang`).
+ *   a `FixedBar`: the part it photographs (`data-navi-fixed-bar-overhang`) is
+ *   deaf for the whole travel, and the rest for its first frames.
  * @param {Function} [action] What the press runs: a button holds no value, so
  *   every press is one call. Inside a `<Form>` or a group it carries the value
  *   around it, merged over the action's bound params — a value that is not an
@@ -85831,6 +85873,7 @@ const ListUI = props => {
     scroller = "self",
     hoverWhileScrolling = false,
     scrollResetOnNavigation = false,
+    scrollResetKey,
     lockSize,
     columns,
     itemColumns,
@@ -85949,6 +85992,7 @@ const ListUI = props => {
     scrolled,
     defaultScrolled,
     onScrolledChange,
+    scrollResetKey,
     rememberScroll,
     listId: rest.id,
     scroller,
@@ -86319,6 +86363,7 @@ const useListScrollSync = ({
   scrolled,
   defaultScrolled,
   onScrolledChange,
+  scrollResetKey,
   rememberScroll,
   listId,
   scroller,
@@ -86327,6 +86372,8 @@ const useListScrollSync = ({
   columns
 }) => {
   const debugScroll = useDebugScroll();
+  // The offset a search gives back once emptied (see below).
+  const savedScrollRef = useRef(null);
   // Where the list must be: what the caller holds it at (`scrolled`), or where
   // it opens and then lets go (`defaultScrolled`). A `scrolled` that changes is
   // the caller moving the list, so the hold is armed again — that is what makes
@@ -86335,7 +86382,9 @@ const useListScrollSync = ({
   // one kept from the previous visit): followed for as long as nobody has
   // moved the list, and compared by value, since it is said at every render.
   // Nothing to hold it at (a position not saved yet) is not a position: the
-  // list opens where it opens.
+  // list opens where it opens. A `scrollResetKey` that changes sends it back to
+  // its start ("back_to_start", see placeBackAtStart), unless a `scrolled`
+  // changing in the same render says where it goes.
   const startPlaceRef = useRef(null);
   if (startPlaceRef.current === null) {
     startPlaceRef.current = {
@@ -86343,6 +86392,7 @@ const useListScrollSync = ({
       wanted: scrolled ?? defaultScrolled,
       scrolled,
       defaultScrolled,
+      scrollResetKey,
       way: null,
       arrived: false,
       // Whether the hold's writes glide (--navi-scroll:smooth).
@@ -86350,6 +86400,20 @@ const useListScrollSync = ({
     };
   } else {
     const place = startPlaceRef.current;
+    if (!compareTwoJsValues(place.scrollResetKey, scrollResetKey)) {
+      place.scrollResetKey = scrollResetKey;
+      place.wanted = "back_to_start";
+      place.userTookOver = false;
+      place.way = null;
+      place.arrived = false;
+      place.smooth = false;
+      // What the list said it was reading, and what a search would give back,
+      // are places in what it no longer shows.
+      savedScrollRef.current = null;
+      if (rememberScroll) {
+        forgetScrollerPosition(listId);
+      }
+    }
     if (place.scrolled !== scrolled) {
       place.scrolled = scrolled;
       place.defaultScrolled = defaultScrolled;
@@ -86358,7 +86422,7 @@ const useListScrollSync = ({
       place.smooth = false;
     } else if ((scrolled === undefined || scrolled === null) && !compareTwoJsValues(place.defaultScrolled, defaultScrolled)) {
       place.defaultScrolled = defaultScrolled;
-      if (!place.userTookOver) {
+      if (!place.userTookOver && place.wanted !== "back_to_start") {
         place.wanted = defaultScrolled;
         // Placed again from where it stands: the way to the previous place
         // says nothing about whose the next scrolls are.
@@ -86702,6 +86766,8 @@ const useListScrollSync = ({
       wantedStart = total - windowSize;
     } else if (typeof scrolledWanted === "number") {
       heldItem = scrolledWanted;
+    } else if (scrolledWanted === "back_to_start") {
+      heldItem = 0;
     } else if (scrolledWanted && scrolledWanted.id !== undefined) {
       const itemIndex = listItems.locateItem(scrolledWanted.id);
       if (itemIndex !== null) {
@@ -86937,7 +87003,6 @@ const useListScrollSync = ({
   // Lorsqu'on selectionne quelque chose pendant une recherche, alors ensuite meme si on clear
   // on veut pas revenir a la position scroll précédente car on veut garde l'item qu'on a selectionné visible
   // (pour l'instant pas grave car on travaille pour le mode select qui fermera le dialog au select)
-  const savedScrollRef = useRef(null);
   const topMatchScoresKeyRef = useRef("");
   const restoreScrollRafRef = useRef(null);
   useLayoutEffect(() => {
@@ -87047,6 +87112,10 @@ const useListScrollSync = ({
     if (scrolledWanted === "start" || scrolledWanted === undefined || startPlaceRef.current.userTookOver || !ref.current) {
       return;
     }
+    if (scrolledWanted === "back_to_start") {
+      placeBackAtStart();
+      return;
+    }
     if (listItems.totalSignal.peek() === 0 || virtualItemSizeSignal.peek() === 0) {
       return;
     }
@@ -87145,6 +87214,24 @@ const useListScrollSync = ({
     }
     sendHeldScroll(scrollNow + delta);
   };
+  // The start of the list, what comes before its first item included, not an
+  // item: a box of its own goes to 0. A box the list is further down of also
+  // shows what stands above it, the control that asked for this among others, so
+  // the list is brought back to the box's start and never sent forward to it.
+  const placeBackAtStart = () => {
+    const scrollerEl = getScroller();
+    if (ref.current.contains(scrollerEl)) {
+      sendHeldScroll(0);
+      return;
+    }
+    const scale = readScrollerScale(scrollerEl, horizontal);
+    const viewportRect = getScrollerViewportRect(scrollerEl);
+    const listRect = ref.current.getBoundingClientRect();
+    const offsetNow = (horizontal ? listRect.left - viewportRect.left : listRect.top - viewportRect.top) / scale;
+    const delta = offsetNow - getItemScrollInset(scrollerEl, ref.current, horizontal);
+    const scrollNow = horizontal ? scrollerEl.scrollLeft : scrollerEl.scrollTop;
+    sendHeldScroll(delta < 0 ? scrollNow + delta : scrollNow);
+  };
   // Every placement goes through here, the ones that find the list in place
   // too: it keeps the way from where the scroller was to where it is sent,
   // which is how a scroll event tells the hold's own scrolls from anyone
@@ -92015,6 +92102,7 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   scroller?: "self" | "parent" | "document" | Element | {current: Element},
  *   hoverWhileScrolling?: boolean,
  *   scrollResetOnNavigation?: boolean,
+ *   scrollResetKey?: any,
  *   fallback?: import("preact").ComponentChildren,
  *   searchFallback?: import("preact").ComponentChildren,
  *   searchText?: string,
@@ -92259,6 +92347,15 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   overwrite each other (see docs/scroll.md). A fresh arrival at the page
  *   opens at `defaultScrolled` either way, and so does a list the caller holds
  *   through `scrolled`.
+ * @param {any} [props.scrollResetKey]
+ *   What the list shows, said as a value: another order, another filter. When
+ *   it changes after mount (compared by value: `[order, filter]` can be written
+ *   at every render) the list goes back to its start before the paint, in
+ *   whichever box `scroller` names, and is held there until the user reaches
+ *   for it. A list whose start is in view in a box that also shows what stands
+ *   above it does not move. A `scrolled` changing in the same render wins. The
+ *   position remembered under the `id` for the address shown is dropped; see
+ *   docs/scroll.md.
  * @param {boolean} [props.deselectable]
  *   A single-select list allowed to hold nothing: the selected item, pressed
  *   again, lets go. Without it the list is a radio group — a choice, once