@jsenv/navi 0.29.471 → 0.29.473

package/dist/dev/jsenv_navi.js

@@ -43943,6 +43943,7 @@ const useRenderScope = (init, update) => {
  *   registerChild(child): void;   // Called on child mount
  *   onChildUIAction(child, e, { stateChanged: boolean }): void; // Called when a child fires a UI action
  *   unregisterChild(child): void; // Called on child unmount
+ *   collectsChild(child): boolean; // Whether registerChild(child) would put it in a value, here or above
  *   props: Object;
  *   ref: Ref; // Used to dispatch DOM events
  *   getManagedControls(): UIStateController[]; // Returns controls whose validity is managed by this controller
@@ -44667,6 +44668,10 @@ const useUIStateController = (
         unregisterChild: (childUIStateController) => {
           s.parentUIStateController?.unregisterChild(childUIStateController);
         },
+        collectsChild: (childUIStateController) =>
+          Boolean(
+            s.parentUIStateController?.collectsChild(childUIStateController),
+          ),
         onChildUIAction: (childUIStateController, e, options) => {
           s.parentUIStateController?.onChildUIAction(
             childUIStateController,
@@ -45053,10 +45058,13 @@ const readNamedChildUIStates = (children, { warnNameless }) => {
 // Looked up in useUIGroupStateController to fill in omitted aggregateChildStates /
 // distributeChildUIState. If neither a default nor an explicit impl is found for a
 // group, creation throws so the caller knows it must supply them.
+// The radio/checkbox filters read `props.type`, which controlHostProps copies:
+// a child is also asked about while rendering, before its first render has
+// built controlHostProps (see collectsChild).
 const GROUP_DEFAULTS = {
   radio_group: {
     childControlFilter: (child) =>
-      child.controlType === "input" && child.controlHostProps?.type === "radio",
+      child.controlType === "input" && child.props?.type === "radio",
     aggregateChildStates: keptOrFirstDefinedChildUIState,
     distributeChildUIState: (newUIState, childUIStateController) => {
       const childSelected = childUIStateController.props.value === newUIState;
@@ -45068,8 +45076,7 @@ const GROUP_DEFAULTS = {
   },
   checkbox_group: {
     childControlFilter: (child) =>
-      child.controlType === "input" &&
-      child.controlHostProps?.type === "checkbox",
+      child.controlType === "input" && child.props?.type === "checkbox",
     aggregateChildStates: keptAndCheckedChildUIStates,
     distributeChildUIState: (newUIState, childUIStateController) => {
       const childSelected =
@@ -45614,6 +45621,9 @@ const useUIGroupStateController = (
 
       const controller = {
         controlType,
+        // Published from the first render, like a leaf's: a group asks its
+        // parent whether anyone listens before its first update.
+        parentUIStateController,
         id,
         name,
         value,
@@ -45837,6 +45847,18 @@ const useUIGroupStateController = (
             notifyExternal: "silent",
           });
         },
+        // registerChild above, asked ahead: monitored here, handed up, or
+        // captured and dropped.
+        collectsChild: (childUIStateController) => {
+          if (isMonitoringChild(childUIStateController)) {
+            return true;
+          }
+          const currentParent = s.parentUIStateController;
+          if (allowCapture || !currentParent) {
+            return false;
+          }
+          return currentParent.collectsChild(childUIStateController);
+        },
         onChildUIAction: (
           childUIStateController,
           e,
@@ -46314,6 +46336,9 @@ const useUIFacadeStateController = (props, realUIStateController) => {
             s.realUIStateController.facadeChild = null;
           }
         },
+        // A refused child is not handed further up: the popup's controls
+        // answer to the picker or to nobody.
+        collectsChild: (child) => canRegisterAsFacadeChild(child),
         getManagedControls: () => {
           const child = firstChildControllerRef.current;
           if (!child) {
@@ -46934,8 +46959,6 @@ const useControlProps = (props, {
   const controlInfo = createControlInfo(props, {
     controlType
   });
-  const readOnlyUncontrolled = useReadOnlyUncontrolled(props, controlInfo);
-  controlInfo.readOnlyUncontrolled = readOnlyUncontrolled;
   const uiStateController = useUIStateController(props, {
     controlInfo,
     syncDomState,
@@ -46943,6 +46966,9 @@ const useControlProps = (props, {
     persists,
     uiActionInternal
   });
+  // After the controller: whether a group listens is asked of the parent it
+  // registers into. Read by useInteractiveProps below.
+  controlInfo.readOnlyUncontrolled = useReadOnlyUncontrolled(props, controlInfo, uiStateController);
   // What the control draws is what it holds by itself, and this read is what
   // re-renders it when that changes. A button inheriting the value of the
   // control around it (a submit in a form, see ownUIStateSignal) draws none of
@@ -47948,16 +47974,21 @@ const INPUT_TYPE_SUPPORTING_READONLY_SET = new Set(["text", "date", "datetime-lo
 // warning below so a group can ask the same question a single control does: a
 // control with a `value` and nobody listening cannot be changed by hand, and
 // that is true whatever the control is.
-const useIsControlListenedTo = props => {
+// The group is asked, not assumed from a controller being above: a control in
+// between may only pass registration along (a <Details> holds none of the
+// values it folds), and a group may hand the control further up or drop it.
+const useIsControlListenedTo = (props, uiStateController) => {
   const isProxy = Boolean(props["navi-control-proxy-for"]);
   const formContext = useContext(FormContext);
-  const parentUIStateController = useContext(ParentUIStateControllerContext);
+  const {
+    parentUIStateController
+  } = uiStateController;
   return Boolean(props.signal ||
   // a bound signal is written back on uiAction → interactive
-  props.uiAction || props.action || formContext || parentUIStateController || isProxy || props.command);
+  props.uiAction || props.action || formContext || parentUIStateController?.collectsChild(uiStateController) || isProxy || props.command);
 };
-const useReadOnlyUncontrolled = (props, controlInfo) => {
-  const listenedTo = useIsControlListenedTo(props);
+const useReadOnlyUncontrolled = (props, controlInfo, uiStateController) => {
+  const listenedTo = useIsControlListenedTo(props, uiStateController);
   const warnedRef = useRef(false);
   if (!controlInfo.hasStateProp) {
     return false;
@@ -48025,7 +48056,7 @@ const useControlgroupProps = (props, {
   // makes the group read-only so children don't appear interactive when they
   // can't change. A form or a group around it IS someone listening — that is
   // what will send the value and hand a new one back.
-  const listenedTo = useIsControlListenedTo(props);
+  const listenedTo = useIsControlListenedTo(props, uiGroupStateController);
   const implicitReadOnlyWarnedRef = useRef(false);
   const implicitReadOnly = uiGroupStateController.hasValueProp && !listenedTo;
   if (implicitReadOnly && !props.readOnly) {
@@ -52857,10 +52888,16 @@ const LinkWithRoute = ({
   currentExcept,
   currentAlso,
   children,
+  // Kept out of `rest`: spread after the route's url, an `href={undefined}`
+  // riding along would erase it.
+  href,
   ...rest
 }) => {
   {
     assertRoute(route);
+    if (href !== undefined) {
+      console.warn(`A link with a "route" ignores its "href" (${href}): the route builds the address.`);
+    }
   }
   const url = route.buildUrl(routeParams);
   {
@@ -58039,15 +58076,21 @@ const ButtonRouteResolver = props => {
 };
 const ButtonWithRoute = props => {
   const Next = useNextResolver();
+  // `href` is kept out of `rest`: spread after the route's url, an
+  // `href={undefined}` riding along would erase it.
   const {
     route,
     routeParams,
     children,
     pseudoState,
+    href,
     ...rest
   } = props;
   {
     assertRoute(route);
+    if (href !== undefined) {
+      console.warn(`A button with a "route" ignores its "href" (${href}): the route builds the address.`);
+    }
   }
   const url = route.buildUrl(routeParams);
   const linkMatching = useRouteCurrent(route, routeParams);
@@ -74434,10 +74477,18 @@ const PickerCustom = props => {
   props.id = props.id || controlId || idDefault;
   // Given no value, the picker holds what the control in its popup holds (see
   // the `mount` decision below) — and a group around it collects that from the
-  // moment both exist.
-  const valueInPopup = !isControlValueGivenByProps(props);
+  // moment both exist. A picker that picks nothing holds none: its popup's
+  // controls are never adopted (see canRegisterAsFacadeChild).
+  const valueInPopup = !props.picksNothing && !isControlValueGivenByProps(props);
+  // Asked of the chain, not read off the context: a control above may only
+  // pass registration along (a <Details> holds none of the values it folds),
+  // and a group may hand a picker further up or drop it. "picker" is what the
+  // picker's own controller registers as (see picker.jsx).
   const parentController = useContext(ParentUIStateControllerContext);
-  const answersToGroup = Boolean(parentController) && !props.standalone;
+  const answersToGroup = !props.standalone && Boolean(parentController?.collectsChild({
+    controlType: "picker",
+    props
+  }));
   // Same narrow-container/maxWidth-compact heuristic Popup itself uses (see
   // popup_mode.jsx's own useResolvedPopupMode) — frozen for the lifetime of an opening
   // (computed when closed, stable while open, so a screen resize mid-session
@@ -75631,12 +75682,7 @@ const PickerConfirmResolver = props => {
     mode: mode,
     focusCapture: focusCapture,
     openWhileReadOnly: openWhileReadOnly,
-    onConfirm: onConfirm
-    // A question holds no value to read before it is asked: the popup is
-    // built on the first open, like that of a picker told its value (see
-    // the `mount` resolution in picker_custom.jsx).
-    ,
-    mount: MOUNT_DEFAULT,
+    onConfirm: onConfirm,
     message: undefined,
     confirmLabel: undefined,
     cancelLabel: undefined,
@@ -87594,8 +87640,9 @@ const PickerFirstResolver = props => {
  *   it (no `ui`, a `Picker.UI.*`, a component `ui`), when there is a clear
  *   cross, or when a form or group around the picker collects it; when an
  *   element `ui` calls `usePickerState()`. Read by nothing, it waits for the
- *   first open, like a picker told a value. A `type="confirm"` picker never
- *   builds them early: its popup is a question, there is nothing to read.
+ *   first open, like a picker told a value. A `picksNothing` picker (and so
+ *   `type="confirm"`) never builds them early: its popup holds no value, there
+ *   is nothing to read.
  */
 // Every picker type is resolved into one of these before it gets here (see
 // PickerTypeResolver and resolveInputProps): a native input type, or navi_js