@jsenv/navi 0.29.227 → 0.29.229

package/dist/dev/jsenv_navi.js

@@ -3209,6 +3209,12 @@ const actionWeakMap = new WeakMap();
  *
  * @param {Function} callback
  * @param {object} [rootOptions]
+ * @param {(params: any, action: object) => any} [rootOptions.provisionalValue] -
+ *   a value the action holds while a run is in flight and it has none of its
+ *   own, so a screen already knowing the answer draws it as a refresh rather
+ *   than a first load (data_states.md). Called at the start of every run whose
+ *   value is undefined; the answer replaces it as usual, and `undefined` means
+ *   "nothing known". A resource `GET` uses it to draw the row its store holds.
  * @param {{ ms?: number, max?: number }} [rootOptions.keep] - how long an
  *   answer stays good once it has landed. Without it an answer lives exactly as
  *   long as something references it: the screen that asked goes away, and
@@ -3248,6 +3254,7 @@ const createAction = (callback, rootOptions = {}) => {
       value,
       resultToValue,
       valueToData,
+      provisionalValue,
       dataDefault,
       data = dataDefault,
 
@@ -3706,6 +3713,12 @@ const createAction = (callback, rootOptions = {}) => {
         actionAbortMap.set(action, abort);
 
         batch(() => {
+          if (provisionalValue && valueSignal.peek() === undefined) {
+            const provisional = provisionalValue(params, action);
+            if (provisional !== undefined) {
+              valueSignal.value = provisional;
+            }
+          }
           runningStateSignal.value = RUNNING;
           if (!isPrerun) {
             isPrerunSignal.value = false;
@@ -15129,17 +15142,15 @@ const resource = (
       return item;
     },
   });
-  const createRestActionForRoot = createRestActionFactoryForRoot(name, {
-    idKey,
-    store,
-    declarationSite,
-  });
   // The row a GET designates, when the store already holds it — by its params:
   // the value under idKey may be the id or any unique key (a route opening a
   // user by id or by slug names both `id`), and a unique key may be given under
-  // its own name; or, when the params name no row (a GET without params, or
-  // whose params carry no key), the row the action last completed with.
-  // Answers a GET under a network policy (see applyNetworkPolicy).
+  // its own name. findItemByParams is what a GET draws while its request is in
+  // flight (the action's provisionalValue). findItemInStore adds, when the
+  // params name no row (a GET without params, or whose params carry no key),
+  // the row the action last completed with: that fallback answers a GET under
+  // a network policy (see applyNetworkPolicy) and only there — a GET of a row
+  // the store lacks must draw its skeleton, never the row read just before.
   const selectByAnyKey = (value) => {
     const item = store.select(value);
     if (item) {
@@ -15191,6 +15202,12 @@ const resource = (
       return store.select(lastItemId) || null;
     });
   };
+  const createRestActionForRoot = createRestActionFactoryForRoot(name, {
+    idKey,
+    store,
+    findItemByParams,
+    declarationSite,
+  });
   return createResource(name, {
     idKey,
     uniqueKeys,
@@ -16182,6 +16199,7 @@ const createRestActionFactoryForRoot = (
   {
     idKey,
     store, // see array_signal_store.js
+    findItemByParams,
     declarationSite,
   },
 ) => {
@@ -16253,6 +16271,16 @@ const createRestActionFactoryForRoot = (
         return applyResultToValue(result);
       },
       valueToData: (itemId) => store.select(itemId),
+      // While the request is out, the row the store already holds for these
+      // params is drawn: the action starts on the "refresh over a known
+      // answer" line of data_states.md rather than the first-load one.
+      provisionalValue:
+        verb === "GET"
+          ? (params) => {
+              const item = untracked(() => findItemByParams(params));
+              return item ? item[idKey] : undefined;
+            }
+          : undefined,
       completeSideEffect: onActionComplete,
     });
   };
@@ -65632,52 +65660,59 @@ const ListContent = ({
   children
 }) => {
   const listProps = useContext(BoxForwardedPropsContext);
-  return jsx(Box, {
-    className: "navi_list_scroll_container",
-    overflow: overflow,
-    overflowX: overflowX,
-    overflowY: overflowY,
-    ...scrollBoxPaddingProps,
-    children: jsx(UnorderedList, {
-      role: role,
-      fallback: fallback,
-      fallbackShown: fallbackShown,
-      searchFallback: searchFallback,
-      searchFallbackShown: searchFallbackShown,
-      loadingPlaceholderShown: loadingPlaceholderShown,
-      error: error,
-      searchNoMatchMode: searchNoMatchMode,
-      separator: separator,
-      itemTransition: itemTransition,
-      expandX: expandX
-      // Deliberately not expandY here (unlike expandX above): the outer
-      // .navi_list_container already gets its own expandY treatment (see
-      // ListUI's own Box above) to fill whatever space its *own* parent
-      // gives it (e.g. a flex-column ancestor's flex-grow) — the <ul>
-      // itself must stay auto-height regardless, or it gets capped to
-      // match .navi_list_scroll_container's own (possibly much smaller)
-      // flex-resolved height instead of its real content height. That
-      // breaks two things at once: virtual scroll's own filler sizing
-      // (nothing to overflow into the scroll container in the first
-      // place) and any sticky List.Item header/footer inside it (their
-      // sticky "containing block" — the <ul>'s own box — would be
-      // artificially small, so they run out of room to stay stuck well
-      // before the user has actually scrolled through all the content).
-      ,
-      horizontal: horizontal,
-      spacing: spacing,
-      columns: columns,
-      itemColumns: itemColumns,
-      ...listProps,
-      tracker: tracker,
-      renderWindow: renderWindow,
-      virtual: virtual,
-      children: jsx(PendingScrollRefContext.Provider, {
-        value: pendingScrollRef,
-        children: children
+  return (
+    // Every provider the list puts around its items stands OUTSIDE the <ul>:
+    // the walk that gives the rows their places (see ListDeclaredChildren) is
+    // over the <ul>'s children, and one component between it and the caller's
+    // rows is one child — all the rows would then stand in a single slot, and
+    // reordering them would move nothing.
+    jsx(PendingScrollRefContext.Provider, {
+      value: pendingScrollRef,
+      children: jsx(Box, {
+        className: "navi_list_scroll_container",
+        overflow: overflow,
+        overflowX: overflowX,
+        overflowY: overflowY,
+        ...scrollBoxPaddingProps,
+        children: jsx(UnorderedList, {
+          role: role,
+          fallback: fallback,
+          fallbackShown: fallbackShown,
+          searchFallback: searchFallback,
+          searchFallbackShown: searchFallbackShown,
+          loadingPlaceholderShown: loadingPlaceholderShown,
+          error: error,
+          searchNoMatchMode: searchNoMatchMode,
+          separator: separator,
+          itemTransition: itemTransition,
+          expandX: expandX
+          // Deliberately not expandY here (unlike expandX above): the outer
+          // .navi_list_container already gets its own expandY treatment (see
+          // ListUI's own Box above) to fill whatever space its *own* parent
+          // gives it (e.g. a flex-column ancestor's flex-grow) — the <ul>
+          // itself must stay auto-height regardless, or it gets capped to
+          // match .navi_list_scroll_container's own (possibly much smaller)
+          // flex-resolved height instead of its real content height. That
+          // breaks two things at once: virtual scroll's own filler sizing
+          // (nothing to overflow into the scroll container in the first
+          // place) and any sticky List.Item header/footer inside it (their
+          // sticky "containing block" — the <ul>'s own box — would be
+          // artificially small, so they run out of room to stay stuck well
+          // before the user has actually scrolled through all the content).
+          ,
+          horizontal: horizontal,
+          spacing: spacing,
+          columns: columns,
+          itemColumns: itemColumns,
+          ...listProps,
+          tracker: tracker,
+          renderWindow: renderWindow,
+          virtual: virtual,
+          children: children
+        })
       })
     })
-  });
+  );
 };
 // Where the items sit is a question about the track (the <ul>), not about the
 // frame around it: the frame's only child is the scroll box, which fills it and
@@ -65882,17 +65917,14 @@ const useListScrollSync = ({
         item
       });
     };
-    const {
-      start,
-      end
-    } = renderWindowRef.current;
-    const isInWindow = index >= start && index < end;
-    if (isInWindow) {
-      const itemEl = findRowElement(getListEl(), item.id);
-      if (itemEl) {
-        scrollItemIntoView(itemEl);
-        return;
-      }
+
+    // Whether the row is drawn is asked of the dom, not of the render window:
+    // the window says what a run draws, and a list whose rows are declared one
+    // by one has them all in the dom whatever the window says.
+    const itemEl = findRowElement(getListEl(), item.id);
+    if (itemEl) {
+      scrollItemIntoView(itemEl);
+      return;
     }
     // Not in DOM — shift the render window. The item will read
     // pendingScrollRef on mount and scroll into view.
@@ -66014,9 +66046,8 @@ const useListScrollSync = ({
   }, []);
   // Watch scores of the top renderBudget items.
   // When scores change during an active search, scroll to top to reveal the most relevant items.
-  // When search becomes empty, restore the scroll position from before the search started.
-  // We save the first-visible item ID so restoration is item-precise
-  // and survives render-window shifts or item reordering.
+  // When search becomes empty, put the list back at the offset (and the render
+  // window) it was at when the search started — see docs/scroll.md.
 
   // NOTE POUR LE JOUR OU ON A LE MULTISELECT:
   // Lorsqu'on selectionne quelque chose pendant une recherche, alors ensuite meme si on clear