@jsenv/navi 0.29.421 → 0.29.423

package/dist/dev/jsenv_navi.js

@@ -74248,10 +74248,22 @@ const useListScrollSync = ({
       visibleCount: position.visibleCount
     };
   };
-  const reportPosition = () => {
+  // A position read at a scroll event is read before the window has drawn what
+  // the scroll brought on screen: the items below the top one can still be
+  // fillers then, and `visibleCount` counts the items drawn. So it is read
+  // again once the screen is better known — a window change on screen, items
+  // landing or resizing — and said again when it reads differently (`ifChanged`):
+  // the same scroll, the screen said right.
+  const announcedRef = useRef(null);
+  const reportPosition = ({
+    ifChanged
+  } = {}) => {
     if (!ref.current) {
       return;
     }
+    if (ifChanged && !announcedRef.current) {
+      return;
+    }
     const remember = rememberScrollRef.current;
     const onScrolledChange = onScrolledChangeRef.current;
     const position = captureListAnchor(remember || Boolean(onScrolledChange));
@@ -74263,6 +74275,10 @@ const useListScrollSync = ({
       return;
     }
     const scrolledNow = toScrolledPosition(position);
+    if (ifChanged && isSamePosition(scrolledNow, announcedRef.current)) {
+      return;
+    }
+    announcedRef.current = scrolledNow;
     if (remember) {
       rememberScrollerPosition(listId, scrolledNow);
     }
@@ -74274,8 +74290,15 @@ const useListScrollSync = ({
   // laid out, its items have arrived, one of them grew. A list read where it
   // opened would otherwise come back with nothing kept — opening again as a
   // fresh arrival does, all of its window drawn in the first commit instead of
-  // the items that were on screen. Kept, and told to nobody: nobody scrolled.
+  // the items that were on screen. Kept, and told to nobody while nobody
+  // scrolled; once a position was said, it is said again (see reportPosition).
   const rememberPosition = () => {
+    if (announcedRef.current) {
+      reportPosition({
+        ifChanged: true
+      });
+      return;
+    }
     if (!rememberScrollRef.current || !ref.current) {
       return;
     }
@@ -74768,6 +74791,15 @@ const useListScrollSync = ({
     };
   }, [scrollerElResolved]);
   holdWindow();
+  const {
+    start: windowStart,
+    end: windowEnd
+  } = renderWindowRef.current;
+  useLayoutEffect(() => {
+    reportPosition({
+      ifChanged: true
+    });
+  }, [windowStart, windowEnd]);
   return {
     virtualItemSizeSignal,
     renderWindow: renderWindowRef.current,
@@ -75326,6 +75358,18 @@ const captureScrollAnchor = ({
   }
   return fallbackAnchor;
 };
+// Two positions handed out say the same thing (see reportPosition): the same
+// item, as far below the top within a pixel, as many items on screen.
+const isSamePosition = (a, b) => {
+  if (a.id !== b.id || a.index !== b.index) {
+    return false;
+  }
+  if (a.visibleCount !== b.visibleCount) {
+    return false;
+  }
+  const offsetDelta = a.offset - b.offset;
+  return offsetDelta > -0.5 && offsetDelta < 0.5;
+};
 // How many of the items from `fromIndex` on start before `to` along the scroll
 // axis — the ones on screen, when `to` is where the view ends.
 const countItemsStartingBefore = (itemEls, fromIndex, to, horizontal) => {
@@ -75596,9 +75640,12 @@ const readRoomAround = ({
 // too — and an item not drawn is taken to weigh what the drawn items at that
 // edge of the window weigh. Items of one kind come together (the one-line
 // items of the past, the cards ahead), and an item misjudged is weighed again
-// once it is drawn (see "after slide"): weighing it at the average of all
-// items would draw the cards next to one-line items at the one-line size, and
-// a few dozen of them.
+// once it is drawn (see "after slide"): a window that came up short is
+// extended on the next frame, from what it measured. Weighing an item not drawn
+// at the average of all items, or at the smallest an item can be so that the
+// window never comes up short, walks into the cards at the one-line size,
+// several at a time — the latter measured in wematch: no blank spared, 50–65 ms
+// tasks while reading down through the cards.
 const EDGE_SAMPLE_ITEM_COUNT = 8;
 const createItemSizeReader = (items, start, end, itemSize) => {
   const sizeByIndex = new Map();
@@ -78047,9 +78094,12 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  * @param {(scrolled: {id: string, index: number, offset: number, visibleCount: number}) => void} [props.onScrolledChange]
  *   Where the list is, as the user scrolls: the item at the top of the view and
  *   how far below the place an item lands on its own (see `defaultScrolled`) it
- *   starts, and how many items are on screen from that one on. Keep it whole to
- *   come back to it later through `scrolled`/`defaultScrolled` — an index alone
- *   would not do, since items get inserted while a list is being read.
+ *   starts, and how many items are on screen from that one on. Said again for
+ *   the same scroll when the screen reads differently once the items it
+ *   brought are drawn, or once items landing change what it shows: the last
+ *   one said is the one to keep. Keep it whole to come back to it later
+ *   through `scrolled`/`defaultScrolled` — an index alone would not do, since
+ *   items get inserted while a list is being read.
  * @param {number|string|{initial?: number|string, after?: number|string}} [props.renderBudget="100item"]
  *   How much of a `<List.Items>` run is in the DOM at once: the render window,
  *   which slides as the user scrolls while fillers hold the room of the items
@@ -78080,11 +78130,18 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   source for is a page (see `<List.Items pageSize>`), whatever either says,
  *   so the first picture costs no second request.
  * @param {number} [props.virtualItemSize]
- *   The size of one item along the scroll axis, in px, when every item has the
- *   same: what the fillers are sized with and what a scroll position is
- *   estimated from. Left out, the list measures its items — once when it
- *   mounts, again when a popup around it opens, and after each commit while
- *   items are held off screen. Given, it never measures.
+ *   The room an item not drawn is held at, in px along the scroll axis: what
+ *   the fillers hold for each item outside the render window, what a scroll
+ *   position inside them is read with, and the least an item on its way takes
+ *   (see `renderSkeleton`). Left out, it is the average of the items measured
+ *   so far — once when the list mounts, again when a popup around it opens,
+ *   and after each commit while items are held off screen. Given, it is the
+ *   worst case: the size every item has, or, in a list whose items differ, the
+ *   smallest an item can be (a thread of one-line items and cards: the
+ *   one-line size) — an item guessed too small builds one more, an item
+ *   guessed too big leaves a blank (see docs/scroll.md, "What the list knows,
+ *   and what it guesses"). The items drawn are measured either way: the render
+ *   window is sized on them.
  * @param {"self"|"parent"|"document"|Element|{current: Element}} [props.scroller="self"]
  *   Which box scrolls — and with it, which box the render window follows and
  *   which box a scroll position is read from (`onScrolledChange`). `"self"`