@allxsmith/bestax-bulma 5.27.0 → 5.27.2

package/dist/esm/form/_pickerInternals/useSegmentedEntry.js

@@ -0,0 +1,427 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { useMemo, useState, useRef, useCallback, useLayoutEffect, useEffect } from 'react';
+import { isWithin } from './dateUtils.js';
+import { buildSegmentMap, segmentIndexAtCaret, setAmPm, setSegmentValue, incrementSegmentValue } from './segmentMap.js';
+
+/**
+ * Single-character literals that, when typed, jump the caret to the next
+ * editable segment — the slash / colon / dash / dot / space separators that
+ * appear between date and time tokens. Lets a user type `12/25/2026` or
+ * `13:45` straight through, skipping over the format's punctuation.
+ */
+const SEPARATOR_RE = /[/:\-.\s]/;
+/**
+ * Segmented manual keyboard entry for a date / time picker input. Computes a
+ * segment map from the token format, tracks the active segment, and returns
+ * the full set of `<input>` event handlers — segment-mutating keys (arrows,
+ * digits, AM/PM, separators) are handled here, while popover open/close and
+ * free-form parse-on-blur/Enter are driven through the host-supplied
+ * `setOpen` / `tryParse` / `commitValue` callbacks. When the format is an
+ * `Intl` options object or contains variable-width tokens, the segment map is
+ * null and the input transparently falls back to free-form text entry.
+ */
+function useSegmentedEntry(params) {
+    const { format, skipKinds, value, commitValue, formatFn, tryParse, text, setText, makeBaseDate, locale, min, max, isBlocked, isUnfinishedBlocked, disabled, readOnly, editable = true, popover = true, openOnFocus = true, closeOnSelect = false, isOpen, setOpen, inputRef, containerRef, onFocus, onClick, onKeyDown, onBlur, } = params;
+    const segmentMap = useMemo(() => {
+        const map = typeof format === 'string' ? buildSegmentMap(format) : null;
+        if (!map || !skipKinds)
+            return map;
+        const editable = map.editable.filter(i => !skipKinds.includes(map.segments[i].kind));
+        return editable.length > 0 ? { ...map, editable } : null;
+    }, [format, skipKinds]);
+    const [activeSegmentIdx, setActiveSegmentIdx] = useState(null);
+    // Buffer of digits typed within the current segment, cleared on segment
+    // change. Kept in a ref because key handlers read+update synchronously
+    // within the same event tick.
+    const typedDigitsRef = useRef('');
+    // The text focus seeded an empty picker with, until the user edits it or
+    // leaves.
+    const seedRef = useRef(null);
+    // Whether the text is still what the picker put there, so nothing in it was
+    // typed: the value's display, or an empty picker's seed until an edit drops
+    // it. Against a value it compares text alone, so typing that ends back on
+    // the display counts as untouched.
+    const isUntouched = useCallback((s) => value
+        ? s === formatFn(value, format, locale)
+        : seedRef.current !== null && s === seedRef.current, [value, formatFn, format, locale]);
+    // A seed the popover never turned into a value closes with it, wherever
+    // focus goes, so a dismissed empty field stays empty.
+    //
+    // As the popover closes, its focus trap hands focus back to the input. That
+    // focus is not the user arriving: it must not open the popover again under
+    // `openOnFocus`, or seed an empty picker. `closingRef` is set in the layout
+    // phase of the commit that closes it and cleared by that commit's effects,
+    // and React runs a commit's effect cleanups, the trap's among them, before
+    // any of its effects, so a focus in between is the one handed back.
+    const closingRef = useRef(false);
+    const wasOpenRef = useRef(isOpen);
+    useLayoutEffect(() => {
+        if (wasOpenRef.current && !isOpen) {
+            closingRef.current = true;
+            if (!value && isUntouched(text))
+                setText('');
+            seedRef.current = null;
+        }
+        wasOpenRef.current = isOpen;
+    }, [isOpen, value, isUntouched, text, setText]);
+    useEffect(() => {
+        closingRef.current = false;
+    }, [isOpen]);
+    // Segment mode is unavailable for disabled / read-only / non-editable
+    // pickers and for Intl-options / variable-width formats (segmentMap null).
+    const segmentEditable = !!segmentMap && !!editable && !disabled && !readOnly;
+    // The Date we edit when the user starts without a current value.
+    const segmentBaseDate = useCallback(() => value ?? makeBaseDate(), [value, makeBaseDate]);
+    // Single gate for every manual-entry commit: min/max bounds plus the
+    // host's blocking predicate.
+    const isAllowed = useCallback((d) => isWithin(d, min, max) && !isBlocked?.(d), [min, max, isBlocked]);
+    // Apply a segment-driven date update: commit through the host pipeline (so
+    // onChange / controlled mode keep working) and re-render the text so the
+    // active selection range stays valid.
+    const applyDateFromSegment = useCallback((next) => {
+        if (!isAllowed(next))
+            return;
+        commitValue(next);
+        setText(formatFn(next, format, locale));
+    }, [commitValue, isAllowed, formatFn, format, locale, setText]);
+    // After every segment-driven change, restore the system selection on the
+    // active segment's char range. useLayoutEffect runs synchronously before
+    // paint so the user never sees a stray caret position. We deliberately do
+    // NOT gate on document.activeElement: when openOnFocus is true the focus
+    // trap moves focus into the popover, but setSelectionRange on an unfocused
+    // input is well-defined and the selection becomes visible on refocus.
+    useLayoutEffect(() => {
+        if (activeSegmentIdx === null || !segmentMap || !inputRef.current)
+            return;
+        const seg = segmentMap.segments[activeSegmentIdx];
+        if (!seg)
+            return;
+        try {
+            inputRef.current.setSelectionRange(seg.start, seg.end);
+        }
+        catch {
+            // Some read-only inputs reject setSelectionRange; harmless.
+        }
+    }, [activeSegmentIdx, segmentMap, text, inputRef]);
+    const moveSegment = useCallback((delta) => {
+        if (!segmentMap || activeSegmentIdx === null)
+            return;
+        const pos = segmentMap.editable.indexOf(activeSegmentIdx);
+        if (pos < 0)
+            return;
+        const nextPos = Math.max(0, Math.min(segmentMap.editable.length - 1, pos + delta));
+        const nextIdx = segmentMap.editable[nextPos];
+        if (nextIdx !== activeSegmentIdx) {
+            typedDigitsRef.current = '';
+            setActiveSegmentIdx(nextIdx);
+        }
+    }, [segmentMap, activeSegmentIdx]);
+    const handleChange = useCallback((e) => {
+        // In segment mode the text is managed programmatically (every edit
+        // re-formats from the canonical Date). Browser-issued input events
+        // would otherwise clobber it. The free-form path runs only when
+        // segment mode is inactive.
+        if (activeSegmentIdx !== null && segmentEditable)
+            return;
+        seedRef.current = null;
+        setText(e.target.value);
+    }, [activeSegmentIdx, segmentEditable, setText]);
+    const handleBlur = useCallback((e) => {
+        // The popover opens on focus by default, and the focus trap moves focus
+        // into the popover panel — that fires this blur even though the user is
+        // still in the same picker. Only tear down segment state and re-parse
+        // when focus has truly left the picker's container.
+        const nextFocus = e.relatedTarget;
+        const stayingInPicker = nextFocus !== null &&
+            containerRef.current !== null &&
+            containerRef.current.contains(nextFocus);
+        if (stayingInPicker) {
+            onBlur?.(e);
+            return;
+        }
+        setActiveSegmentIdx(null);
+        typedDigitsRef.current = '';
+        // Leaving commits only what was typed. Re-parsing the value's display
+        // could drop what the format leaves out, such as seconds, and a seed
+        // nobody typed over is not the user's date.
+        const untouched = isUntouched(text);
+        // An open popover keeps an unused seed until it closes, so one portaled
+        // outside the picker, whose focus reads as leaving, keeps it as one
+        // inside does.
+        if (!isOpen)
+            seedRef.current = null;
+        if (untouched) {
+            if (!value && !isOpen)
+                setText('');
+            onBlur?.(e);
+            return;
+        }
+        const parsed = tryParse(text);
+        if (parsed && isAllowed(parsed)) {
+            commitValue(parsed);
+        }
+        else {
+            setText(value ? formatFn(value, format, locale) : '');
+        }
+        onBlur?.(e);
+    }, [
+        containerRef,
+        isUntouched,
+        isOpen,
+        tryParse,
+        text,
+        isAllowed,
+        commitValue,
+        value,
+        formatFn,
+        format,
+        locale,
+        setText,
+        onBlur,
+    ]);
+    const handleFocus = useCallback((e) => {
+        const handedBack = closingRef.current;
+        if (!handedBack && openOnFocus && popover && !disabled && !readOnly) {
+            setOpen(true);
+        }
+        // Enter segment mode: prime an initial value (so editing works even when
+        // empty), seed the text, and highlight the first editable segment. The
+        // segment base doesn't need the seed, so focus handed back skips it.
+        if (segmentEditable && segmentMap) {
+            if (!value && !handedBack) {
+                const seed = formatFn(makeBaseDate(), format, locale);
+                seedRef.current = seed;
+                setText(seed);
+            }
+            typedDigitsRef.current = '';
+            setActiveSegmentIdx(segmentMap.editable[0]);
+        }
+        onFocus?.(e);
+    }, [
+        openOnFocus,
+        popover,
+        disabled,
+        readOnly,
+        setOpen,
+        segmentEditable,
+        segmentMap,
+        value,
+        makeBaseDate,
+        formatFn,
+        format,
+        locale,
+        setText,
+        onFocus,
+    ]);
+    const handleClick = useCallback((e) => {
+        // Clicking the field opens the popover only when `openOnFocus` is on —
+        // a click is just a focus. With `openOnFocus={false}` (manual-entry
+        // mode) the click positions the caret for typing and the popover is
+        // opened explicitly via the right launcher button (or Alt+ArrowDown).
+        if (openOnFocus && popover && !disabled && !readOnly)
+            setOpen(true);
+        if (segmentEditable && segmentMap && inputRef.current) {
+            const caret = inputRef.current.selectionStart ?? 0;
+            const idx = segmentIndexAtCaret(segmentMap, caret);
+            if (idx !== null && idx !== activeSegmentIdx) {
+                typedDigitsRef.current = '';
+                setActiveSegmentIdx(idx);
+            }
+        }
+        onClick?.(e);
+    }, [
+        openOnFocus,
+        popover,
+        disabled,
+        readOnly,
+        setOpen,
+        segmentEditable,
+        segmentMap,
+        inputRef,
+        activeSegmentIdx,
+        onClick,
+    ]);
+    const inSegmentMode = segmentEditable && segmentMap !== null && activeSegmentIdx !== null;
+    const handleKeyDown = useCallback((e) => {
+        // Segment-mode key routing comes first. When segment mode isn't engaged
+        // (not editable, no map, or no active segment — e.g. after a typed-text
+        // fallback), unhandled keys fall through to the popover / free-form
+        // handling below.
+        if (inSegmentMode && segmentMap && activeSegmentIdx !== null) {
+            const seg = segmentMap.segments[activeSegmentIdx];
+            const base = segmentBaseDate();
+            const isPm = base.getHours() >= 12;
+            switch (e.key) {
+                case 'ArrowUp':
+                case 'ArrowDown':
+                    e.preventDefault();
+                    // The plain arrows step the segment, so the popover opens on
+                    // Alt+ArrowDown and closes on Alt+ArrowUp, as a combobox's does,
+                    // and neither steps it.
+                    if (e.altKey) {
+                        if (e.key === 'ArrowUp') {
+                            if (isOpen)
+                                setOpen(false);
+                        }
+                        else if (!isOpen && popover) {
+                            setOpen(true);
+                        }
+                        return;
+                    }
+                    typedDigitsRef.current = '';
+                    applyDateFromSegment(incrementSegmentValue(seg, base, e.key === 'ArrowUp' ? 1 : -1, isPm));
+                    return;
+                case 'ArrowRight':
+                    e.preventDefault();
+                    moveSegment(1);
+                    return;
+                case 'ArrowLeft':
+                    e.preventDefault();
+                    moveSegment(-1);
+                    return;
+                case 'Backspace':
+                    e.preventDefault();
+                    if (typedDigitsRef.current.length > 0) {
+                        typedDigitsRef.current = '';
+                    }
+                    else {
+                        moveSegment(-1);
+                    }
+                    return;
+                case 'Escape':
+                    if (isOpen) {
+                        e.preventDefault();
+                        setOpen(false);
+                    }
+                    return;
+                case 'Enter':
+                    e.preventDefault();
+                    if (closeOnSelect)
+                        setOpen(false);
+                    return;
+                case 'Tab':
+                    setActiveSegmentIdx(null);
+                    typedDigitsRef.current = '';
+                    return;
+                default:
+                    // AM/PM keys.
+                    if (seg.kind === 'ampm') {
+                        if (e.key === 'a' || e.key === 'A') {
+                            e.preventDefault();
+                            typedDigitsRef.current = '';
+                            applyDateFromSegment(setAmPm(base, false));
+                            moveSegment(1);
+                            return;
+                        }
+                        if (e.key === 'p' || e.key === 'P') {
+                            e.preventDefault();
+                            typedDigitsRef.current = '';
+                            applyDateFromSegment(setAmPm(base, true));
+                            moveSegment(1);
+                            return;
+                        }
+                    }
+                    // Typing a format separator (/, :, -, ., space) jumps to the next
+                    // segment, skipping over the literal punctuation.
+                    if (e.key.length === 1 && SEPARATOR_RE.test(e.key)) {
+                        e.preventDefault();
+                        typedDigitsRef.current = '';
+                        moveSegment(1);
+                        return;
+                    }
+                    // Digit entry for numeric segments.
+                    if (/^[0-9]$/.test(e.key) && seg.kind !== 'ampm') {
+                        e.preventDefault();
+                        const nextBuffer = typedDigitsRef.current + e.key;
+                        typedDigitsRef.current = nextBuffer;
+                        const { date, advance } = setSegmentValue(seg, base, nextBuffer, isPm);
+                        if (!advance && isUnfinishedBlocked?.(date))
+                            return;
+                        applyDateFromSegment(date);
+                        if (advance) {
+                            typedDigitsRef.current = '';
+                            moveSegment(1);
+                        }
+                        return;
+                    }
+            }
+        }
+        // ----- free-form / popover key handling -----
+        // With no segment to step, ArrowDown opens the popover with or without
+        // Alt, unless the field is read-only or disabled, as focus and the
+        // launcher don't open it then either. Alt+ArrowUp closes it.
+        if (e.key === 'ArrowDown' &&
+            !isOpen &&
+            popover &&
+            !disabled &&
+            !readOnly) {
+            e.preventDefault();
+            setOpen(true);
+            return;
+        }
+        if (e.key === 'ArrowUp' && e.altKey && isOpen) {
+            e.preventDefault();
+            setOpen(false);
+            return;
+        }
+        if (e.key === 'Escape' && isOpen) {
+            e.preventDefault();
+            setOpen(false);
+            return;
+        }
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            // Untouched text has nothing to commit, as on leaving, but Enter
+            // still confirms what the field shows.
+            if (isUntouched(text)) {
+                if (closeOnSelect)
+                    setOpen(false);
+            }
+            else {
+                const parsed = tryParse(text);
+                if (parsed && isAllowed(parsed)) {
+                    commitValue(parsed);
+                    if (closeOnSelect)
+                        setOpen(false);
+                }
+            }
+        }
+        onKeyDown?.(e);
+    }, [
+        inSegmentMode,
+        segmentMap,
+        activeSegmentIdx,
+        segmentBaseDate,
+        applyDateFromSegment,
+        isUnfinishedBlocked,
+        moveSegment,
+        isOpen,
+        setOpen,
+        closeOnSelect,
+        popover,
+        disabled,
+        readOnly,
+        isUntouched,
+        tryParse,
+        text,
+        isAllowed,
+        commitValue,
+        onKeyDown,
+    ]);
+    return {
+        segmentMap,
+        activeSegmentIdx,
+        segmentEditable,
+        inSegmentMode,
+        inputHandlers: {
+            onChange: handleChange,
+            onFocus: handleFocus,
+            onClick: handleClick,
+            onKeyDown: handleKeyDown,
+            onBlur: handleBlur,
+        },
+    };
+}
+
+export { useSegmentedEntry };
+//# sourceMappingURL=useSegmentedEntry.js.map

package/dist/esm/form/_pickerInternals/useSegmentedEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSegmentedEntry.js","sources":["../../../../src/form/_pickerInternals/useSegmentedEntry.ts"],"sourcesContent":["import React, {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { DateFormatOption } from './formatters';\nimport { isWithin } from './dateUtils';\nimport {\n  buildSegmentMap,\n  incrementSegmentValue,\n  setSegmentValue,\n  setAmPm,\n  segmentIndexAtCaret,\n  SegmentKind,\n  SegmentMap,\n} from './segmentMap';\n\n/**\n * Single-character literals that, when typed, jump the caret to the next\n * editable segment — the slash / colon / dash / dot / space separators that\n * appear between date and time tokens. Lets a user type `12/25/2026` or\n * `13:45` straight through, skipping over the format's punctuation.\n */\nconst SEPARATOR_RE = /[/:\\-.\\s]/;\n\nexport interface UseSegmentedEntryParams {\n  /** Resolved format actually used to render (the host's default format). */\n  format: DateFormatOption;\n  /**\n   * Segment kinds the caret never stops on: they still render, but arrows,\n   * digits and separators pass over them. A month picker skips `'day'` so a\n   * format such as `'YYYY-MM-DD'` edits only the year and month. Must be\n   * referentially stable. A format left with no editable segment falls back\n   * to free-form entry.\n   */\n  skipKinds?: readonly SegmentKind[];\n  /** Current canonical value (controlled or internal). */\n  value: Date | null;\n  /** Commit a new Date through the host's onChange / internal pipeline. */\n  commitValue: (next: Date | null) => void;\n  /** Host formatter: formatDate | formatTime | formatDateTime. */\n  formatFn: (\n    d: Date,\n    fmt: DateFormatOption | undefined,\n    locale?: string\n  ) => string;\n  /** Host parser used by the free-form fallback (parseDate / parseTime / custom). */\n  tryParse: (s: string) => Date | null;\n  /** Host's displayed-text state and setter (the hook drives it during edits). */\n  text: string;\n  setText: (s: string) => void;\n  /**\n   * Seed for an empty value when the user starts typing: Time → today at noon,\n   * Date → today at 00:00, DateTime → now. Should be referentially stable.\n   */\n  makeBaseDate: () => Date;\n  locale?: string;\n  min?: Date;\n  max?: Date;\n  /**\n   * Host-supplied blocking predicate (composed from shouldDisableDate /\n   * unselectableDates / unselectableTimes). Checked alongside min/max on\n   * every manual-entry commit; return true to reject the candidate value.\n   */\n  isBlocked?: (d: Date) => boolean;\n  /**\n   * Rejects a candidate only while the digits typed into its segment leave\n   * it unfinished, such as the first digits of a year. The digit stays in\n   * the segment and the next one tries again, so a value passing through a\n   * candidate it can't commit on the way to one it can costs nothing. A\n   * finished segment, an arrow step and parsed text answer to `isBlocked`\n   * alone.\n   */\n  isUnfinishedBlocked?: (d: Date) => boolean;\n  disabled?: boolean;\n  readOnly?: boolean;\n  /** Allow segmented typing. When false, segment mode never engages. */\n  editable?: boolean;\n  /** Whether a popover exists; gates open-on-focus / click / Alt+ArrowDown. */\n  popover?: boolean;\n  openOnFocus?: boolean;\n  closeOnSelect?: boolean;\n  isOpen: boolean;\n  /**\n   * The host's open-state setter. The hook asks it to open on focus, click\n   * or Alt+ArrowDown, but not on the focus the popover's focus trap hands\n   * back to the input as it closes, which is not the user arriving.\n   */\n  setOpen: (next: boolean) => void;\n  inputRef: React.RefObject<HTMLInputElement | null>;\n  containerRef: React.RefObject<HTMLElement | null>;\n  onFocus?: React.FocusEventHandler<HTMLInputElement>;\n  onClick?: React.MouseEventHandler<HTMLInputElement>;\n  onKeyDown?: React.KeyboardEventHandler<HTMLInputElement>;\n  onBlur?: React.FocusEventHandler<HTMLInputElement>;\n}\n\nexport interface UseSegmentedEntryResult {\n  segmentMap: SegmentMap | null;\n  activeSegmentIdx: number | null;\n  /** True when segment typing is available (map + editable + not disabled/readOnly). */\n  segmentEditable: boolean;\n  /** True when a segment is actively selected. */\n  inSegmentMode: boolean;\n  /** Spread onto the combobox `<input>`. */\n  inputHandlers: {\n    onChange: React.ChangeEventHandler<HTMLInputElement>;\n    onFocus: React.FocusEventHandler<HTMLInputElement>;\n    onClick: React.MouseEventHandler<HTMLInputElement>;\n    onKeyDown: React.KeyboardEventHandler<HTMLInputElement>;\n    onBlur: React.FocusEventHandler<HTMLInputElement>;\n  };\n}\n\n/**\n * Segmented manual keyboard entry for a date / time picker input. Computes a\n * segment map from the token format, tracks the active segment, and returns\n * the full set of `<input>` event handlers — segment-mutating keys (arrows,\n * digits, AM/PM, separators) are handled here, while popover open/close and\n * free-form parse-on-blur/Enter are driven through the host-supplied\n * `setOpen` / `tryParse` / `commitValue` callbacks. When the format is an\n * `Intl` options object or contains variable-width tokens, the segment map is\n * null and the input transparently falls back to free-form text entry.\n */\nexport function useSegmentedEntry(\n  params: UseSegmentedEntryParams\n): UseSegmentedEntryResult {\n  const {\n    format,\n    skipKinds,\n    value,\n    commitValue,\n    formatFn,\n    tryParse,\n    text,\n    setText,\n    makeBaseDate,\n    locale,\n    min,\n    max,\n    isBlocked,\n    isUnfinishedBlocked,\n    disabled,\n    readOnly,\n    editable = true,\n    popover = true,\n    openOnFocus = true,\n    closeOnSelect = false,\n    isOpen,\n    setOpen,\n    inputRef,\n    containerRef,\n    onFocus,\n    onClick,\n    onKeyDown,\n    onBlur,\n  } = params;\n\n  const segmentMap: SegmentMap | null = useMemo(() => {\n    const map = typeof format === 'string' ? buildSegmentMap(format) : null;\n    if (!map || !skipKinds) return map;\n    const editable = map.editable.filter(\n      i => !skipKinds.includes(map.segments[i].kind)\n    );\n    return editable.length > 0 ? { ...map, editable } : null;\n  }, [format, skipKinds]);\n  const [activeSegmentIdx, setActiveSegmentIdx] = useState<number | null>(null);\n  // Buffer of digits typed within the current segment, cleared on segment\n  // change. Kept in a ref because key handlers read+update synchronously\n  // within the same event tick.\n  const typedDigitsRef = useRef<string>('');\n  // The text focus seeded an empty picker with, until the user edits it or\n  // leaves.\n  const seedRef = useRef<string | null>(null);\n\n  // Whether the text is still what the picker put there, so nothing in it was\n  // typed: the value's display, or an empty picker's seed until an edit drops\n  // it. Against a value it compares text alone, so typing that ends back on\n  // the display counts as untouched.\n  const isUntouched = useCallback(\n    (s: string) =>\n      value\n        ? s === formatFn(value, format, locale)\n        : seedRef.current !== null && s === seedRef.current,\n    [value, formatFn, format, locale]\n  );\n\n  // A seed the popover never turned into a value closes with it, wherever\n  // focus goes, so a dismissed empty field stays empty.\n  //\n  // As the popover closes, its focus trap hands focus back to the input. That\n  // focus is not the user arriving: it must not open the popover again under\n  // `openOnFocus`, or seed an empty picker. `closingRef` is set in the layout\n  // phase of the commit that closes it and cleared by that commit's effects,\n  // and React runs a commit's effect cleanups, the trap's among them, before\n  // any of its effects, so a focus in between is the one handed back.\n  const closingRef = useRef(false);\n  const wasOpenRef = useRef(isOpen);\n  useLayoutEffect(() => {\n    if (wasOpenRef.current && !isOpen) {\n      closingRef.current = true;\n      if (!value && isUntouched(text)) setText('');\n      seedRef.current = null;\n    }\n    wasOpenRef.current = isOpen;\n  }, [isOpen, value, isUntouched, text, setText]);\n  useEffect(() => {\n    closingRef.current = false;\n  }, [isOpen]);\n\n  // Segment mode is unavailable for disabled / read-only / non-editable\n  // pickers and for Intl-options / variable-width formats (segmentMap null).\n  const segmentEditable = !!segmentMap && !!editable && !disabled && !readOnly;\n\n  // The Date we edit when the user starts without a current value.\n  const segmentBaseDate = useCallback(\n    (): Date => value ?? makeBaseDate(),\n    [value, makeBaseDate]\n  );\n\n  // Single gate for every manual-entry commit: min/max bounds plus the\n  // host's blocking predicate.\n  const isAllowed = useCallback(\n    (d: Date) => isWithin(d, min, max) && !isBlocked?.(d),\n    [min, max, isBlocked]\n  );\n\n  // Apply a segment-driven date update: commit through the host pipeline (so\n  // onChange / controlled mode keep working) and re-render the text so the\n  // active selection range stays valid.\n  const applyDateFromSegment = useCallback(\n    (next: Date) => {\n      if (!isAllowed(next)) return;\n      commitValue(next);\n      setText(formatFn(next, format, locale));\n    },\n    [commitValue, isAllowed, formatFn, format, locale, setText]\n  );\n\n  // After every segment-driven change, restore the system selection on the\n  // active segment's char range. useLayoutEffect runs synchronously before\n  // paint so the user never sees a stray caret position. We deliberately do\n  // NOT gate on document.activeElement: when openOnFocus is true the focus\n  // trap moves focus into the popover, but setSelectionRange on an unfocused\n  // input is well-defined and the selection becomes visible on refocus.\n  useLayoutEffect(() => {\n    if (activeSegmentIdx === null || !segmentMap || !inputRef.current) return;\n    const seg = segmentMap.segments[activeSegmentIdx];\n    if (!seg) return;\n    try {\n      inputRef.current.setSelectionRange(seg.start, seg.end);\n    } catch {\n      // Some read-only inputs reject setSelectionRange; harmless.\n    }\n  }, [activeSegmentIdx, segmentMap, text, inputRef]);\n\n  const moveSegment = useCallback(\n    (delta: 1 | -1) => {\n      if (!segmentMap || activeSegmentIdx === null) return;\n      const pos = segmentMap.editable.indexOf(activeSegmentIdx);\n      if (pos < 0) return;\n      const nextPos = Math.max(\n        0,\n        Math.min(segmentMap.editable.length - 1, pos + delta)\n      );\n      const nextIdx = segmentMap.editable[nextPos];\n      if (nextIdx !== activeSegmentIdx) {\n        typedDigitsRef.current = '';\n        setActiveSegmentIdx(nextIdx);\n      }\n    },\n    [segmentMap, activeSegmentIdx]\n  );\n\n  const handleChange = useCallback(\n    (e: React.ChangeEvent<HTMLInputElement>) => {\n      // In segment mode the text is managed programmatically (every edit\n      // re-formats from the canonical Date). Browser-issued input events\n      // would otherwise clobber it. The free-form path runs only when\n      // segment mode is inactive.\n      if (activeSegmentIdx !== null && segmentEditable) return;\n      seedRef.current = null;\n      setText(e.target.value);\n    },\n    [activeSegmentIdx, segmentEditable, setText]\n  );\n\n  const handleBlur = useCallback(\n    (e: React.FocusEvent<HTMLInputElement>) => {\n      // The popover opens on focus by default, and the focus trap moves focus\n      // into the popover panel — that fires this blur even though the user is\n      // still in the same picker. Only tear down segment state and re-parse\n      // when focus has truly left the picker's container.\n      const nextFocus = e.relatedTarget as HTMLElement | null;\n      const stayingInPicker =\n        nextFocus !== null &&\n        containerRef.current !== null &&\n        containerRef.current.contains(nextFocus);\n      if (stayingInPicker) {\n        onBlur?.(e);\n        return;\n      }\n      setActiveSegmentIdx(null);\n      typedDigitsRef.current = '';\n      // Leaving commits only what was typed. Re-parsing the value's display\n      // could drop what the format leaves out, such as seconds, and a seed\n      // nobody typed over is not the user's date.\n      const untouched = isUntouched(text);\n      // An open popover keeps an unused seed until it closes, so one portaled\n      // outside the picker, whose focus reads as leaving, keeps it as one\n      // inside does.\n      if (!isOpen) seedRef.current = null;\n      if (untouched) {\n        if (!value && !isOpen) setText('');\n        onBlur?.(e);\n        return;\n      }\n      const parsed = tryParse(text);\n      if (parsed && isAllowed(parsed)) {\n        commitValue(parsed);\n      } else {\n        setText(value ? formatFn(value, format, locale) : '');\n      }\n      onBlur?.(e);\n    },\n    [\n      containerRef,\n      isUntouched,\n      isOpen,\n      tryParse,\n      text,\n      isAllowed,\n      commitValue,\n      value,\n      formatFn,\n      format,\n      locale,\n      setText,\n      onBlur,\n    ]\n  );\n\n  const handleFocus = useCallback(\n    (e: React.FocusEvent<HTMLInputElement>) => {\n      const handedBack = closingRef.current;\n      if (!handedBack && openOnFocus && popover && !disabled && !readOnly) {\n        setOpen(true);\n      }\n      // Enter segment mode: prime an initial value (so editing works even when\n      // empty), seed the text, and highlight the first editable segment. The\n      // segment base doesn't need the seed, so focus handed back skips it.\n      if (segmentEditable && segmentMap) {\n        if (!value && !handedBack) {\n          const seed = formatFn(makeBaseDate(), format, locale);\n          seedRef.current = seed;\n          setText(seed);\n        }\n        typedDigitsRef.current = '';\n        setActiveSegmentIdx(segmentMap.editable[0]);\n      }\n      onFocus?.(e);\n    },\n    [\n      openOnFocus,\n      popover,\n      disabled,\n      readOnly,\n      setOpen,\n      segmentEditable,\n      segmentMap,\n      value,\n      makeBaseDate,\n      formatFn,\n      format,\n      locale,\n      setText,\n      onFocus,\n    ]\n  );\n\n  const handleClick = useCallback(\n    (e: React.MouseEvent<HTMLInputElement>) => {\n      // Clicking the field opens the popover only when `openOnFocus` is on —\n      // a click is just a focus. With `openOnFocus={false}` (manual-entry\n      // mode) the click positions the caret for typing and the popover is\n      // opened explicitly via the right launcher button (or Alt+ArrowDown).\n      if (openOnFocus && popover && !disabled && !readOnly) setOpen(true);\n      if (segmentEditable && segmentMap && inputRef.current) {\n        const caret = inputRef.current.selectionStart ?? 0;\n        const idx = segmentIndexAtCaret(segmentMap, caret);\n        if (idx !== null && idx !== activeSegmentIdx) {\n          typedDigitsRef.current = '';\n          setActiveSegmentIdx(idx);\n        }\n      }\n      onClick?.(e);\n    },\n    [\n      openOnFocus,\n      popover,\n      disabled,\n      readOnly,\n      setOpen,\n      segmentEditable,\n      segmentMap,\n      inputRef,\n      activeSegmentIdx,\n      onClick,\n    ]\n  );\n\n  const inSegmentMode =\n    segmentEditable && segmentMap !== null && activeSegmentIdx !== null;\n\n  const handleKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLInputElement>) => {\n      // Segment-mode key routing comes first. When segment mode isn't engaged\n      // (not editable, no map, or no active segment — e.g. after a typed-text\n      // fallback), unhandled keys fall through to the popover / free-form\n      // handling below.\n      if (inSegmentMode && segmentMap && activeSegmentIdx !== null) {\n        const seg = segmentMap.segments[activeSegmentIdx];\n        const base = segmentBaseDate();\n        const isPm = base.getHours() >= 12;\n        switch (e.key) {\n          case 'ArrowUp':\n          case 'ArrowDown':\n            e.preventDefault();\n            // The plain arrows step the segment, so the popover opens on\n            // Alt+ArrowDown and closes on Alt+ArrowUp, as a combobox's does,\n            // and neither steps it.\n            if (e.altKey) {\n              if (e.key === 'ArrowUp') {\n                if (isOpen) setOpen(false);\n              } else if (!isOpen && popover) {\n                setOpen(true);\n              }\n              return;\n            }\n            typedDigitsRef.current = '';\n            applyDateFromSegment(\n              incrementSegmentValue(\n                seg,\n                base,\n                e.key === 'ArrowUp' ? 1 : -1,\n                isPm\n              )\n            );\n            return;\n          case 'ArrowRight':\n            e.preventDefault();\n            moveSegment(1);\n            return;\n          case 'ArrowLeft':\n            e.preventDefault();\n            moveSegment(-1);\n            return;\n          case 'Backspace':\n            e.preventDefault();\n            if (typedDigitsRef.current.length > 0) {\n              typedDigitsRef.current = '';\n            } else {\n              moveSegment(-1);\n            }\n            return;\n          case 'Escape':\n            if (isOpen) {\n              e.preventDefault();\n              setOpen(false);\n            }\n            return;\n          case 'Enter':\n            e.preventDefault();\n            if (closeOnSelect) setOpen(false);\n            return;\n          case 'Tab':\n            setActiveSegmentIdx(null);\n            typedDigitsRef.current = '';\n            return;\n          default:\n            // AM/PM keys.\n            if (seg.kind === 'ampm') {\n              if (e.key === 'a' || e.key === 'A') {\n                e.preventDefault();\n                typedDigitsRef.current = '';\n                applyDateFromSegment(setAmPm(base, false));\n                moveSegment(1);\n                return;\n              }\n              if (e.key === 'p' || e.key === 'P') {\n                e.preventDefault();\n                typedDigitsRef.current = '';\n                applyDateFromSegment(setAmPm(base, true));\n                moveSegment(1);\n                return;\n              }\n            }\n            // Typing a format separator (/, :, -, ., space) jumps to the next\n            // segment, skipping over the literal punctuation.\n            if (e.key.length === 1 && SEPARATOR_RE.test(e.key)) {\n              e.preventDefault();\n              typedDigitsRef.current = '';\n              moveSegment(1);\n              return;\n            }\n            // Digit entry for numeric segments.\n            if (/^[0-9]$/.test(e.key) && seg.kind !== 'ampm') {\n              e.preventDefault();\n              const nextBuffer = typedDigitsRef.current + e.key;\n              typedDigitsRef.current = nextBuffer;\n              const { date, advance } = setSegmentValue(\n                seg,\n                base,\n                nextBuffer,\n                isPm\n              );\n              if (!advance && isUnfinishedBlocked?.(date)) return;\n              applyDateFromSegment(date);\n              if (advance) {\n                typedDigitsRef.current = '';\n                moveSegment(1);\n              }\n              return;\n            }\n        }\n      }\n      // ----- free-form / popover key handling -----\n      // With no segment to step, ArrowDown opens the popover with or without\n      // Alt, unless the field is read-only or disabled, as focus and the\n      // launcher don't open it then either. Alt+ArrowUp closes it.\n      if (\n        e.key === 'ArrowDown' &&\n        !isOpen &&\n        popover &&\n        !disabled &&\n        !readOnly\n      ) {\n        e.preventDefault();\n        setOpen(true);\n        return;\n      }\n      if (e.key === 'ArrowUp' && e.altKey && isOpen) {\n        e.preventDefault();\n        setOpen(false);\n        return;\n      }\n      if (e.key === 'Escape' && isOpen) {\n        e.preventDefault();\n        setOpen(false);\n        return;\n      }\n      if (e.key === 'Enter') {\n        e.preventDefault();\n        // Untouched text has nothing to commit, as on leaving, but Enter\n        // still confirms what the field shows.\n        if (isUntouched(text)) {\n          if (closeOnSelect) setOpen(false);\n        } else {\n          const parsed = tryParse(text);\n          if (parsed && isAllowed(parsed)) {\n            commitValue(parsed);\n            if (closeOnSelect) setOpen(false);\n          }\n        }\n      }\n      onKeyDown?.(e);\n    },\n    [\n      inSegmentMode,\n      segmentMap,\n      activeSegmentIdx,\n      segmentBaseDate,\n      applyDateFromSegment,\n      isUnfinishedBlocked,\n      moveSegment,\n      isOpen,\n      setOpen,\n      closeOnSelect,\n      popover,\n      disabled,\n      readOnly,\n      isUntouched,\n      tryParse,\n      text,\n      isAllowed,\n      commitValue,\n      onKeyDown,\n    ]\n  );\n\n  return {\n    segmentMap,\n    activeSegmentIdx,\n    segmentEditable,\n    inSegmentMode,\n    inputHandlers: {\n      onChange: handleChange,\n      onFocus: handleFocus,\n      onClick: handleClick,\n      onKeyDown: handleKeyDown,\n      onBlur: handleBlur,\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/form/controlLoading.js

@@ -0,0 +1,18 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { createContext, useContext } from 'react';
+
+// Whether the nearest enclosing `Control` shows its `isLoading` spinner. The
+// picker bases read it so their right-side launcher gives way to that
+// spinner, which sits at the same edge, whether the `Control` is the one a
+// convenience input renders or one the caller wrapped around the input.
+// Autocomplete reads it for its clear button, which sits there too.
+// Kept apart from `FormContext`, whose contexts only report whether a `Field`
+// or `Control` is present. Internal; not part of the public API.
+const ControlLoadingContext = createContext(false);
+/** Provider for the loading state, used internally by `Control`. */
+const ControlLoadingProvider = ControlLoadingContext.Provider;
+/** Whether the nearest enclosing `Control` is loading; `false` outside one. */
+const useControlLoading = () => useContext(ControlLoadingContext);
+
+export { ControlLoadingProvider, useControlLoading };
+//# sourceMappingURL=controlLoading.js.map

package/dist/esm/form/controlLoading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlLoading.js","sources":["../../../src/form/controlLoading.ts"],"sourcesContent":["import { createContext, useContext } from 'react';\n\n// Whether the nearest enclosing `Control` shows its `isLoading` spinner. The\n// picker bases read it so their right-side launcher gives way to that\n// spinner, which sits at the same edge, whether the `Control` is the one a\n// convenience input renders or one the caller wrapped around the input.\n// Autocomplete reads it for its clear button, which sits there too.\n// Kept apart from `FormContext`, whose contexts only report whether a `Field`\n// or `Control` is present. Internal; not part of the public API.\nconst ControlLoadingContext = createContext(false);\n\n/** Provider for the loading state, used internally by `Control`. */\nexport const ControlLoadingProvider = ControlLoadingContext.Provider;\n\n/** Whether the nearest enclosing `Control` is loading; `false` outside one. */\nexport const useControlLoading = () => useContext(ControlLoadingContext);\n"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,aAAa,CAAC,KAAK,CAAC;AAElD;AACO,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAE5D;AACO,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,qBAAqB;;"}

package/dist/esm/form/useAutoLabelId.js

@@ -0,0 +1,88 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { useId } from 'react';
+import { useFieldLabelElementId, useFieldLabelId, useFieldLabelFor } from './FormContext.js';
+
+/**
+ * Associates the convenience `label` prop with its control (#368): generates
+ * an id for the control and returns labelProps carrying a matching `htmlFor`.
+ * A user-supplied `id` is used as the target instead of the generated one, and
+ * an explicit `htmlFor` key in labelProps — even set to `undefined` — disables
+ * generation entirely: the user has taken over the association (#495 presence
+ * semantics). When the control renders no label of its own, it adopts the id
+ * a labeled Field around it offers, the way the bases do, so that Field's
+ * label names it (#939); a user `id` still wins there.
+ * Internal; not part of the public API.
+ */
+function useAutoLabelId({ label, id, labelProps, rendersLabel, hasInput = true, }) {
+    // Called unconditionally per the rules of hooks; SSR-safe on React 18 and 19.
+    const generatedId = useId();
+    // Read outside the control's own Field, so it is set only when an outer
+    // Field holds the control, which then renders no label of its own.
+    const fieldLabelId = useFieldLabelId();
+    // What an outer Field's label points at, even when wired by hand.
+    const fieldLabelFor = useFieldLabelFor();
+    // Truthiness mirrors Field's own `if (label)` render gate.
+    const active = !!label && rendersLabel;
+    // Presence, not truthiness: `htmlFor: undefined` is an explicit opt-out and
+    // must not leave an orphan generated id on the control.
+    const userWired = !!labelProps && 'htmlFor' in labelProps;
+    const adopted = !active && hasInput ? fieldLabelId : undefined;
+    const controlId = id ?? (active && !userWired ? generatedId : adopted);
+    const ownLabelProps = { htmlFor: controlId, ...labelProps };
+    // Inactive with a label still means an own Field may render it (pickers'
+    // inline mode, Taginput at maxTags) — the explicit `htmlFor: undefined`
+    // tells Field the association is owned here, so it must not generate one
+    // that would dangle (#495 presence semantics).
+    const fieldLabelProps = active
+        ? ownLabelProps
+        : label
+            ? { htmlFor: undefined, ...labelProps }
+            : labelProps;
+    const labelTarget = active ? ownLabelProps.htmlFor : fieldLabelFor;
+    return {
+        controlId,
+        fieldLabelProps,
+        labelled: !!controlId && labelTarget === controlId,
+    };
+}
+/**
+ * Group-input counterpart of {@link useAutoLabelId} (#494): a group of
+ * controls cannot take a single `htmlFor`, so instead the rendered `<label>`
+ * gets a generated id and the group container points at it with
+ * `aria-labelledby`. A user-supplied `labelProps.id` is used as the target
+ * instead of generating one. Any caller `htmlFor` is stripped — a group label
+ * names the group, never a single control — so the merged labelProps always
+ * carry an explicit `htmlFor: undefined`. When the group renders no label of
+ * its own, it points at the label of a labeled Field around it instead
+ * (#939). A caller who named the group with `aria-label` or
+ * `aria-labelledby` gets no `aria-labelledby` from either label, so their
+ * name wins wherever the label sits.
+ * Internal; not part of the public API.
+ */
+function useAutoLabelledBy({ label, labelProps, rendersLabel, callerProps, }) {
+    // Called unconditionally per the rules of hooks; SSR-safe on React 18 and 19.
+    const generatedId = useId();
+    // Set only when an outer Field holds the group (see useAutoLabelId).
+    const fieldLabelElementId = useFieldLabelElementId();
+    const active = !!label && rendersLabel;
+    const labelId = labelProps?.id ?? (active ? generatedId : undefined);
+    const fieldLabelProps = active
+        ? { ...labelProps, id: labelId, htmlFor: undefined }
+        : labelProps;
+    const aria = callerProps;
+    // Presence for aria-labelledby: the caller's key replaces the attribute
+    // through the spread whatever its value, and pointing it at a label would
+    // only take a Rate's fallback name away. Checked before either label, so
+    // the caller's name wins over the group's own `label` as it does over a
+    // Field's, the way an aria-label beats a `<label for>` on a single input.
+    const callerNamed = !!aria['aria-label'] || 'aria-labelledby' in aria;
+    const ariaLabelledBy = callerNamed
+        ? undefined
+        : active
+            ? labelId
+            : fieldLabelElementId;
+    return { ariaLabelledBy, fieldLabelProps };
+}
+
+export { useAutoLabelId, useAutoLabelledBy };
+//# sourceMappingURL=useAutoLabelId.js.map

package/dist/esm/form/useAutoLabelId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoLabelId.js","sources":["../../../src/form/useAutoLabelId.ts"],"sourcesContent":["import React, { useId } from 'react';\nimport type { FieldProps } from './Field';\nimport {\n  useFieldLabelElementId,\n  useFieldLabelFor,\n  useFieldLabelId,\n} from './FormContext';\n\ninterface UseAutoLabelIdOptions {\n  /** The convenience `label` prop as passed by the caller. */\n  label: React.ReactNode;\n  /** User-supplied id for the control, if any. */\n  id?: string;\n  /** User-supplied labelProps, if any. */\n  labelProps?: FieldProps['labelProps'];\n  /**\n   * True when this render actually outputs the label wired to a control —\n   * false inside an outer Field (label is dropped), in variants that render\n   * no Field, and in modes with no labellable control (e.g. inline pickers).\n   */\n  rendersLabel: boolean;\n  /**\n   * False when this render has no input to label at all (an inline picker),\n   * so it takes no id from a surrounding Field either. Defaults to true.\n   */\n  hasInput?: boolean;\n}\n\n/**\n * Associates the convenience `label` prop with its control (#368): generates\n * an id for the control and returns labelProps carrying a matching `htmlFor`.\n * A user-supplied `id` is used as the target instead of the generated one, and\n * an explicit `htmlFor` key in labelProps — even set to `undefined` — disables\n * generation entirely: the user has taken over the association (#495 presence\n * semantics). When the control renders no label of its own, it adopts the id\n * a labeled Field around it offers, the way the bases do, so that Field's\n * label names it (#939); a user `id` still wins there.\n * Internal; not part of the public API.\n */\nexport function useAutoLabelId({\n  label,\n  id,\n  labelProps,\n  rendersLabel,\n  hasInput = true,\n}: UseAutoLabelIdOptions): {\n  controlId: string | undefined;\n  fieldLabelProps: FieldProps['labelProps'] | undefined;\n  /** Whether a rendered label, its own or a surrounding Field's, points at `controlId`. */\n  labelled: boolean;\n} {\n  // Called unconditionally per the rules of hooks; SSR-safe on React 18 and 19.\n  const generatedId = useId();\n  // Read outside the control's own Field, so it is set only when an outer\n  // Field holds the control, which then renders no label of its own.\n  const fieldLabelId = useFieldLabelId();\n  // What an outer Field's label points at, even when wired by hand.\n  const fieldLabelFor = useFieldLabelFor();\n  // Truthiness mirrors Field's own `if (label)` render gate.\n  const active = !!label && rendersLabel;\n  // Presence, not truthiness: `htmlFor: undefined` is an explicit opt-out and\n  // must not leave an orphan generated id on the control.\n  const userWired = !!labelProps && 'htmlFor' in labelProps;\n  const adopted = !active && hasInput ? fieldLabelId : undefined;\n  const controlId = id ?? (active && !userWired ? generatedId : adopted);\n  const ownLabelProps = { htmlFor: controlId, ...labelProps };\n  // Inactive with a label still means an own Field may render it (pickers'\n  // inline mode, Taginput at maxTags) — the explicit `htmlFor: undefined`\n  // tells Field the association is owned here, so it must not generate one\n  // that would dangle (#495 presence semantics).\n  const fieldLabelProps = active\n    ? ownLabelProps\n    : label\n      ? { htmlFor: undefined, ...labelProps }\n      : labelProps;\n  const labelTarget = active ? ownLabelProps.htmlFor : fieldLabelFor;\n  return {\n    controlId,\n    fieldLabelProps,\n    labelled: !!controlId && labelTarget === controlId,\n  };\n}\n\ninterface UseAutoLabelledByOptions {\n  /** The convenience `label` prop as passed by the caller. */\n  label: React.ReactNode;\n  /** User-supplied labelProps, if any. */\n  labelProps?: FieldProps['labelProps'];\n  /** True when this render actually outputs the label naming the group. */\n  rendersLabel: boolean;\n  /**\n   * The caller's remaining props. A non-empty `aria-label` among them names\n   * the group, and so does any `aria-labelledby` key, even an undefined one,\n   * since the group spreads them after its own attribute. Either keeps every\n   * label off the group, its own and a surrounding Field's alike.\n   */\n  callerProps: object;\n}\n\n/**\n * Group-input counterpart of {@link useAutoLabelId} (#494): a group of\n * controls cannot take a single `htmlFor`, so instead the rendered `<label>`\n * gets a generated id and the group container points at it with\n * `aria-labelledby`. A user-supplied `labelProps.id` is used as the target\n * instead of generating one. Any caller `htmlFor` is stripped — a group label\n * names the group, never a single control — so the merged labelProps always\n * carry an explicit `htmlFor: undefined`. When the group renders no label of\n * its own, it points at the label of a labeled Field around it instead\n * (#939). A caller who named the group with `aria-label` or\n * `aria-labelledby` gets no `aria-labelledby` from either label, so their\n * name wins wherever the label sits.\n * Internal; not part of the public API.\n */\nexport function useAutoLabelledBy({\n  label,\n  labelProps,\n  rendersLabel,\n  callerProps,\n}: UseAutoLabelledByOptions): {\n  ariaLabelledBy: string | undefined;\n  fieldLabelProps: FieldProps['labelProps'] | undefined;\n} {\n  // Called unconditionally per the rules of hooks; SSR-safe on React 18 and 19.\n  const generatedId = useId();\n  // Set only when an outer Field holds the group (see useAutoLabelId).\n  const fieldLabelElementId = useFieldLabelElementId();\n  const active = !!label && rendersLabel;\n  const labelId = labelProps?.id ?? (active ? generatedId : undefined);\n  const fieldLabelProps = active\n    ? { ...labelProps, id: labelId, htmlFor: undefined }\n    : labelProps;\n  const aria = callerProps as React.AriaAttributes;\n  // Presence for aria-labelledby: the caller's key replaces the attribute\n  // through the spread whatever its value, and pointing it at a label would\n  // only take a Rate's fallback name away. Checked before either label, so\n  // the caller's name wins over the group's own `label` as it does over a\n  // Field's, the way an aria-label beats a `<label for>` on a single input.\n  const callerNamed = !!aria['aria-label'] || 'aria-labelledby' in aria;\n  const ariaLabelledBy = callerNamed\n    ? undefined\n    : active\n      ? labelId\n      : fieldLabelElementId;\n  return { ariaLabelledBy, fieldLabelProps };\n}\n"],"names":[],"mappings":";;;;AA4BA;;;;;;;;;;AAUG;AACG,SAAU,cAAc,CAAC,EAC7B,KAAK,EACL,EAAE,EACF,UAAU,EACV,YAAY,EACZ,QAAQ,GAAG,IAAI,GACO,EAAA;;AAOtB,IAAA,MAAM,WAAW,GAAG,KAAK,EAAE;;;AAG3B,IAAA,MAAM,YAAY,GAAG,eAAe,EAAE;;AAEtC,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;;AAExC,IAAA,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI,YAAY;;;IAGtC,MAAM,SAAS,GAAG,CAAC,CAAC,UAAU,IAAI,SAAS,IAAI,UAAU;AACzD,IAAA,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,QAAQ,GAAG,YAAY,GAAG,SAAS;AAC9D,IAAA,MAAM,SAAS,GAAG,EAAE,KAAK,MAAM,IAAI,CAAC,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IACtE,MAAM,aAAa,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,UAAU,EAAE;;;;;IAK3D,MAAM,eAAe,GAAG;AACtB,UAAE;AACF,UAAE;cACE,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,UAAU;cACnC,UAAU;AAChB,IAAA,MAAM,WAAW,GAAG,MAAM,GAAG,aAAa,CAAC,OAAO,GAAG,aAAa;IAClE,OAAO;QACL,SAAS;QACT,eAAe;AACf,QAAA,QAAQ,EAAE,CAAC,CAAC,SAAS,IAAI,WAAW,KAAK,SAAS;KACnD;AACH;AAkBA;;;;;;;;;;;;;AAaG;AACG,SAAU,iBAAiB,CAAC,EAChC,KAAK,EACL,UAAU,EACV,YAAY,EACZ,WAAW,GACc,EAAA;;AAKzB,IAAA,MAAM,WAAW,GAAG,KAAK,EAAE;;AAE3B,IAAA,MAAM,mBAAmB,GAAG,sBAAsB,EAAE;AACpD,IAAA,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI,YAAY;AACtC,IAAA,MAAM,OAAO,GAAG,UAAU,EAAE,EAAE,KAAK,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACpE,MAAM,eAAe,GAAG;AACtB,UAAE,EAAE,GAAG,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS;UAChD,UAAU;IACd,MAAM,IAAI,GAAG,WAAmC;;;;;;AAMhD,IAAA,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,iBAAiB,IAAI,IAAI;IACrE,MAAM,cAAc,GAAG;AACrB,UAAE;AACF,UAAE;AACA,cAAE;cACA,mBAAmB;AACzB,IAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE;AAC5C;;"}