@jsenv/navi 0.29.472 → 0.29.473

package/dist/jsenv_navi.js

@@ -42894,6 +42894,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
@@ -43596,6 +43597,10 @@ const useUIStateController = (
         unregisterChild: (childUIStateController) => {
           s.parentUIStateController?.unregisterChild(childUIStateController);
         },
+        collectsChild: (childUIStateController) =>
+          Boolean(
+            s.parentUIStateController?.collectsChild(childUIStateController),
+          ),
         onChildUIAction: (childUIStateController, e, options) => {
           s.parentUIStateController?.onChildUIAction(
             childUIStateController,
@@ -43982,10 +43987,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;
@@ -43997,8 +44005,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 =
@@ -44533,6 +44540,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,
@@ -44756,6 +44766,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,
@@ -45228,6 +45250,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) {
@@ -45769,8 +45794,6 @@ const useControlProps = (props, {
   const controlInfo = createControlInfo(props, {
     controlType
   });
-  const readOnlyUncontrolled = useReadOnlyUncontrolled(props, controlInfo);
-  controlInfo.readOnlyUncontrolled = readOnlyUncontrolled;
   const uiStateController = useUIStateController(props, {
     controlInfo,
     syncDomState,
@@ -45778,6 +45801,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
@@ -46773,16 +46799,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);
   useRef(false);
   if (!controlInfo.hasStateProp) {
     return false;
@@ -46841,7 +46872,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);
   useRef(false);
   const implicitReadOnly = uiGroupStateController.hasValueProp && !listenedTo;
   if (implicitReadOnly && !props.readOnly) {
@@ -73037,8 +73068,15 @@ const PickerCustom = 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