@jsenv/navi 0.29.428 → 0.29.430

package/dist/jsenv_navi.js

@@ -30015,14 +30015,14 @@ import.meta.css = /* css */[`[data-scrollable] > .navi_loading_outline_wrapper,
 }
 
 [data-scrollable] {
-  overflow: var(--x-scrollable-overflow, auto);
   scroll-padding: var(--navi-scroll-padding, var(--navi-s));
   --box-header-z-index: var(--navi-z-index-sticky);
   --box-footer-z-index: var(--navi-z-index-sticky);
   isolation: isolate;
+  overflow: auto;
 
   &[data-scrollable-overflow="scroll"] {
-    --x-scrollable-overflow: scroll;
+    overflow: scroll;
   }
 
   & > [data-header] {
@@ -30044,9 +30044,9 @@ import.meta.css = /* css */[`[data-scrollable] > .navi_loading_outline_wrapper,
   }
 
   &:has( > [data-body]) {
-    --x-scrollable-overflow: hidden;
     flex-direction: column;
     display: flex;
+    overflow: hidden;
 
     & > [data-header], & > [data-footer] {
       z-index: auto;
@@ -38775,6 +38775,16 @@ const resolveAfterSend = (target, requester) => {
   }
   return undefined;
 };
+// What follows a send is caused by the send, not by the gesture: the send
+// answered the gesture and may have prevented it (an Enter must not also click
+// the submit button, nor activate the trigger of the popup it closed), and a
+// follow-up judged on that event is refused as a gesture someone cancelled.
+// Chained, so the gesture stays readable behind it.
+const createSentEvent = (event) => {
+  const sentEvent = new CustomEvent("sent", { detail: {} });
+  chainEvent(sentEvent, event);
+  return sentEvent;
+};
 
 registerNaviCommand("--navi-send", (source, event, { requester }) => {
   const expandable = resolveExpandableAround(source);
@@ -38807,7 +38817,9 @@ registerNaviCommand("--navi-send", (source, event, { requester }) => {
           source.getAttribute("data-after-send") ||
           target.getAttribute("data-after-send");
         if (afterSend) {
-          triggerNaviCommand(target, afterSend, event, { optional: true });
+          triggerNaviCommand(target, afterSend, createSentEvent(event), {
+            optional: true,
+          });
         }
         return result;
       },
@@ -38851,7 +38863,9 @@ registerNaviCommand("--navi-send", (source, event, { requester }) => {
         if (!afterSend) {
           return;
         }
-        triggerNaviCommand(source, afterSend, event, { optional: true });
+        triggerNaviCommand(source, afterSend, createSentEvent(event), {
+          optional: true,
+        });
       };
       const {
         result: sent,
@@ -72728,9 +72742,12 @@ const useListScrollSync = ({
   };
   const [renderWindow, setRenderWindow] = useState(() => {
     // Opening somewhere else than the beginning starts by framing there: the
-    // items the list will draw are the items it will ask for.
+    // items the list will draw are the items it will ask for. A named item is
+    // framed where it stood when it was written down, which is where holdWindow
+    // aims before anyone can say where it is.
     const openAt = scrolled ?? defaultScrolled;
-    const start = typeof openAt === "number" ? openAt - itemsAboveOpening(openAt, firstWindowItemCount) : 0;
+    const openIndex = typeof openAt === "number" ? openAt : openAt && typeof openAt === "object" && typeof openAt.index === "number" ? openAt.index : null;
+    const start = openIndex === null ? 0 : openIndex - itemsAboveOpening(openAt, firstWindowItemCount);
     const startClamped = start < 0 ? 0 : start;
     return {
       start: startClamped,
@@ -72856,14 +72873,11 @@ const useListScrollSync = ({
     if (wantedStart < 0) {
       wantedStart = 0;
     }
-    if (wantedStart === start) {
-      listItems.holdPending = false;
-      return;
-    }
-    renderWindowRef.current = {
-      start: wantedStart,
-      end: wantedStart + windowSize
-    };
+    // The window the hold frames goes into the state, not into this render
+    // alone: the next render starts from the state, and once the item stands
+    // inside the window the hold stops framing it — a window left where the
+    // state had it would draw around another place.
+    updateRenderWindow(wantedStart, wantedStart + windowSize);
     listItems.holdPending = false;
   };
   const pendingScrollRef = useRef();
@@ -73011,6 +73025,13 @@ const useListScrollSync = ({
       return;
     }
     hasBeenDisplayedRef.current = true;
+    const place = startPlaceRef.current;
+    if (!place.userTookOver && place.wanted !== "start" && place.wanted !== undefined) {
+      // Held somewhere: where the list opens is the hold's to say (see
+      // placeWhereHeld). Scrolled here too, the list would go to the top or
+      // the selected item for as long as the hold takes to put it back.
+      return;
+    }
     const items = listItems.itemsSignal.peek();
     const firstSelected = items.find(i => {
       if (i.selected) {
@@ -77308,7 +77329,8 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   "Many rows"). The window keeps three quarters of what the screen leaves of
  *   it ahead of the scroll, and moves once that falls under half a screen; it
  *   has to hold more than the screen shows, with room for that lookahead — the
- *   list warns when it leaves less than two items beyond the screen.
+ *   list warns when it holds no more than the screen. How much more is
+ *   measured: fling the list on the slowest device it runs on.
  *
  *   `{ initial, after }` for a list whose first picture is taken as it is
  *   built — drawn in the click that opens a popup, or in the update callback