@jsenv/navi 0.29.456 → 0.29.458

package/dist/dev/jsenv_navi.js

@@ -25189,10 +25189,9 @@ const useKeyboardShortcuts = (
     );
     shortcut.action = useAction(shortcut.action);
   }
-  const onKeyDown = createOnKeyDownForShortcutArray(
-    shortcuts,
-    shortcutActionIsBusyRef,
-  );
+  const onKeyDown = createOnKeyDownForShortcutArray(shortcuts, {
+    busyRef: shortcutActionIsBusyRef,
+  });
   useEffect(() => {
     const element = elementRef.current;
     if (!element) {
@@ -25210,7 +25209,10 @@ const useKeyboardShortcuts = (
   }, [shortcutDeps]);
 };
 
-const createOnKeyDownForShortcutArray = (shortcuts, busyRef) => {
+const createOnKeyDownForShortcutArray = (
+  shortcuts,
+  { busyRef, ownsTarget } = {},
+) => {
   const shortcutsCopy = [];
   for (const shortcutCandidate of shortcuts) {
     shortcutsCopy.push({
@@ -25256,10 +25258,20 @@ const createOnKeyDownForShortcutArray = (shortcuts, busyRef) => {
   }
 
   return (keyboardEvent) => {
-    return applyKeyboardShortcuts(shortcutsCopy, keyboardEvent);
+    return applyKeyboardShortcuts(shortcutsCopy, keyboardEvent, {
+      ownsTarget,
+    });
   };
 };
-const createOnKeyDownForShortcuts = (shortcuts) => {
+/**
+ * @param {object} shortcuts
+ * @param {object} [options]
+ * @param {(target: Element) => boolean} [options.ownsTarget] Whether a
+ *   descendant the key was pressed in is one the shortcuts speak for, so its
+ *   native behavior (the caret, typing) is theirs to take. Without it only the
+ *   listening element itself is; a descendant keeps every key it has a use for.
+ */
+const createOnKeyDownForShortcuts = (shortcuts, { ownsTarget } = {}) => {
   const shortcutsArray = [];
   for (const key of Object.keys(shortcuts)) {
     const value = shortcuts[key];
@@ -25271,16 +25283,18 @@ const createOnKeyDownForShortcuts = (shortcuts) => {
     }
     shortcutsArray.push(shortcut);
   }
-  return createOnKeyDownForShortcutArray(shortcutsArray);
+  return createOnKeyDownForShortcutArray(shortcutsArray, { ownsTarget });
 };
 
-const applyKeyboardShortcuts = (shortcuts, keyboardEvent) => {
+const applyKeyboardShortcuts = (shortcuts, keyboardEvent, { ownsTarget }) => {
   const currentTarget = keyboardEvent.currentTarget;
   const target = keyboardEvent.target;
   let canIntercept;
   if (target === currentTarget) {
     // the event occurs on the element itself so we are sure we won't interfere with native behaviors of child elements
     canIntercept = true;
+  } else if (ownsTarget && ownsTarget(target)) {
+    canIntercept = true;
   } else {
     // we need to check if the default action is something that we can allow to be intercepted
     const defaultAction = getKeyboardEventDefaultAction(keyboardEvent);
@@ -25498,6 +25512,17 @@ const isSameKey = (browserEventKey, key) => {
  * knows what "ctrl+backspace" means, which keys a control may take without
  * swallowing what the browser owed them, and which it may not.
  *
+ * The control's own element is the exception to that last part. `interactions`
+ * are set up on a field's outer box while the key goes down in its `<input>`,
+ * and that field is the control the declaration speaks for: an ArrowUp declared
+ * on a text field is the field saying what ArrowUp does there, not a container
+ * taking the caret from a field inside it. A field inside a box that declares
+ * keys for something else (a row, a list) keeps every key it has a use for.
+ *
+ * A declared key that matches takes the key: its default does not happen as
+ * well, whether the gate lets the interaction through or refuses it and says
+ * why — the same as a number field's arrows.
+ *
  * The interaction is dispatched under its full name, colon included, so
  * `findEvent(event, "keyboard:ctrl+backspace")` gets back to it — the shortcut
  * that asked is what the action wants to know, not that a key went down.
@@ -25514,9 +25539,12 @@ defineInteractionDetector({
     for (const type of types) {
       shortcuts[type.slice(KEYBOARD_PREFIX.length)] = (keyboardEvent) => {
         trigger(type, keyboardEvent);
+        keyboardEvent.preventDefault();
       };
     }
-    const onKeyDown = createOnKeyDownForShortcuts(shortcuts);
+    const onKeyDown = createOnKeyDownForShortcuts(shortcuts, {
+      ownsTarget: (target) => target === findNearestControlHost(element),
+    });
     element.addEventListener("keydown", onKeyDown);
     return () => {
       element.removeEventListener("keydown", onKeyDown);
@@ -39456,6 +39484,14 @@ const activeRouteReadsSignal = computed(() => {
  *   params read: that address is the current one with the state set to the
  *   popup's value (see `prefetch` on Button).
  * @param {object} [options]
+ * @param {() => any} [options.when] - a condition on app state the action
+ *   asks under, read off signals like the params: falsy, it runs nothing.
+ *   Unlike a params function it leaves the action asking nothing of the
+ *   address, so a link to the route still prefetches an action without
+ *   params when the condition holds at that moment — a page's code only some
+ *   readers may download (`() => meIsAdminSignal.value`). A condition reading
+ *   the address belongs in the params: a link reads `when` as it is, not as
+ *   the address it leads to will make it.
  * @param {boolean} [options.prefetch=true] - `false` keeps the action from
  *   being prerun ahead of what asks for it, when the read is not worth a
  *   hover or a press that may not end in an opening.
@@ -39464,7 +39500,7 @@ const routeAction = (
   routeOrRoutes,
   action,
   paramsEffect,
-  { prefetch = true, ...options } = {},
+  { when, prefetch = true, ...options } = {},
 ) => {
   if (typeof action === "function") {
     action = createAction(action);
@@ -39474,7 +39510,12 @@ const routeAction = (
     routes.length === 1
       ? routes[0].matchingSignal
       : anyMatchingRouteSignal(routes);
-  const readParams = paramsEffect || (() => true);
+  const readParams = () => {
+    if (when && !when()) {
+      return null;
+    }
+    return paramsEffect ? paramsEffect() : true;
+  };
   const readParamsAsked = () => {
     const matching = routeMatchingSignal.value;
     const params = readParams();
@@ -39510,10 +39551,13 @@ const routeAction = (
     for (const route of routes) {
       if (paramsEffect) {
         registerRouteStatePreload(route, (values) => {
-          prefetchAsIf(action, paramsEffect, values);
+          prefetchAsIf(action, readParams, values);
         });
       } else {
         registerRoutePreload(route, () => {
+          if (!untracked(readParams)) {
+            return;
+          }
           prerunAhead(action.bindParams(true));
         });
       }
@@ -39526,12 +39570,12 @@ const routeAction = (
 // (see readStateAsIf), prerun only when that changes them: params the state
 // leaves alone are the ones the action already runs on — or is meant not to,
 // and a prerun would retry a FAILED one behind the screen's back.
-const prefetchAsIf = (action, paramsEffect, values) => {
-  const params = readStateAsIf(values, paramsEffect);
+const prefetchAsIf = (action, readParams, values) => {
+  const params = readStateAsIf(values, readParams);
   if (!params) {
     return;
   }
-  if (compareTwoJsValues(params, untracked(paramsEffect))) {
+  if (compareTwoJsValues(params, untracked(readParams))) {
     return;
   }
   prerunAhead(action.bindParams(params));