@allxsmith/bestax-bulma 5.26.3 → 5.26.5

package/dist/index.cjs

@@ -5201,10 +5201,17 @@ const focusedElement = (doc) => getDeepestActiveElement(doc) ?? doc.body;
  * container, or give them a trap of their own. To trap content a `Portal`
  * renders, pass a ref to the element inside the `Portal` as `containerRef`.
  *
- * The container has to be in the DOM when the trap turns on. The trap waits
- * for hydration, so a container that only appears once the page has
- * hydrated, the way portaled content does, still has it attach in the commit
- * where the container appears.
+ * The trap looks at `containerRef` again each time the component calling it
+ * renders. A container that mounts after the trap turns on, such as a panel
+ * waiting for a `Portal` target held in state, has it attach once that
+ * component renders with the container in the DOM. When the container leaves
+ * or is replaced, the trap lets go of it as it would turning off, handing
+ * focus back, and attaches to the next one.
+ * A child that mounts the container in a render of its own (from its own
+ * state, or as a `Suspense` boundary resolves) goes unseen until the
+ * component calling the hook renders again. The trap waits for hydration, so
+ * that component renders again when the page hydrates, and portaled content,
+ * which first appears then, is found.
  *
  * @function useFocusTrap
  * @param containerRef - Ref to the element focus stays inside.
@@ -5224,12 +5231,18 @@ function useFocusTrap(containerRef, options = {}) {
     // Portaled content has no server-rendered counterpart, so a portaled
     // container only exists from the commit after hydration.
     const hydrated = useIsHydrated();
+    // The container the trap is attached to, or `null` while it has none.
+    const heldRef = React.useRef(null);
+    // Bumped to run the trap again when the container in the ref changes.
+    const [refChanges, setRefChanges] = React.useState(0);
     React.useEffect(() => {
+        heldRef.current = null;
         if (!active || !hydrated)
             return undefined;
         const container = containerRef.current;
         if (!container)
             return undefined;
+        heldRef.current = container;
         const doc = container.ownerDocument;
         const opener = focusedElement(doc);
         // `initialFocusRef` counts only when focusing it puts focus inside. Focus
@@ -5304,7 +5317,28 @@ function useFocusTrap(containerRef, options = {}) {
                 target.focus();
             }
         };
-    }, [active, hydrated, containerRef, initialFocusRef, restoreFocus]);
+    }, [
+        active,
+        hydrated,
+        containerRef,
+        initialFocusRef,
+        restoreFocus,
+        refChanges,
+    ]);
+    // Nothing says when a ref is set, so after every render, a ref that no
+    // longer matches what the trap holds (a container that mounted, left or was
+    // replaced) runs it again. Effects run in order, so whenever the effect
+    // above ran in this commit, it read the ref just before this does, and a
+    // mismatch means the ref changed in a render it didn't run for. The render
+    // a bump asks for runs it, so the two match and the trap settles. An empty
+    // ref matches a trap holding nothing, so a container that never mounts
+    // costs no render.
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- after every render on purpose
+    React.useEffect(() => {
+        if (active && hydrated && containerRef.current !== heldRef.current) {
+            setRefChanges(n => n + 1);
+        }
+    });
 }
 
 // INTERNAL: deliberately not exported from src/index.ts.
@@ -8737,6 +8771,108 @@ const useInsideControl = () => React.useContext(ControlContext);
 const FieldProvider = FieldContext.Provider;
 /** Provider for Control context — used internally by Control component. */
 const ControlProvider = ControlContext.Provider;
+// Each Field-shaping prop, with what takes its place on a `Field` the caller
+// wraps around the `Control`. `message` needs nothing there, because the
+// wrapper still renders it inside `Field > Control`. The other Field-level
+// props (`labelSize`, `labelProps`, `messageColor`) change nothing unless a
+// `label` or `message` renders, so on their own they keep no `Field`.
+// `bare-control.test.tsx` holds this list to what each wrapper hands its
+// `Field` and to which props change its markup, so a new Field-level prop
+// fails there until it is sorted into one group or the other.
+const FIELD_SHAPING = [
+    ['label', 'label'],
+    ['message', undefined],
+    ['horizontal', 'horizontal'],
+    ['fieldClassName', 'className (for fieldClassName)'],
+];
+/** `a`, `a and b`, `a, b and c`. */
+const listOf = (items) => items.length > 1
+    ? `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`
+    : items[0];
+/**
+ * Whether a convenience form wrapper renders a `Field` of its own (#905).
+ * Never inside an outer `Field`. Inside a `Control` with no `Field` around
+ * it, a `Field` of its own would put a `.field` inside the `.control`, where
+ * Bulma's control styles break (its icon rules are sibling selectors on the
+ * input). So it renders one there only when a prop that shapes the `Field`'s
+ * markup is set (`label`, `message`, `horizontal`, `fieldClassName`), keeping
+ * the markup it always had, and warns in development that the fix is a
+ * `Field` around that `Control`. A prop counts when it is truthy, the same
+ * test that decides whether it changes the `Field`'s output.
+ * Internal; not part of the public API.
+ */
+const rendersOwnField = (component, options) => {
+    if (options.insideField)
+        return false;
+    if (!options.insideControl)
+        return true;
+    const held = FIELD_SHAPING.filter(([prop]) => options[prop]);
+    if (held.length === 0)
+        return false;
+    const names = held.map(([prop]) => prop);
+    const moved = held
+        .map(([, onField]) => onField)
+        .filter((onField) => onField !== undefined);
+    warnOnce(`${component}:Field-in-bare-Control:${names.join('+')}`, `[bestax-bulma] <${component} ${names.join(' ')}> inside a <Control> ` +
+        `with no <Field> around it renders its own <Field> for ` +
+        `${names.length > 1 ? 'those props' : 'that prop'}, which puts a ` +
+        `.field inside the .control, a nesting Bulma's styles are not ` +
+        `written for. Wrap the <Control> in a <Field> instead` +
+        (moved.length > 0 ? `, and set ${listOf(moved)} on that <Field>.` : '.'));
+    return true;
+};
+// Each Control-level prop, with what takes its place on the `Control` the
+// caller wrapped around the wrapper. `bare-control.test.tsx` holds this to
+// what each wrapper hands its own `Control`, so a new Control-level prop
+// fails there until it is added here and passed to `rendersOwnControl`.
+const ON_CONTROL = {
+    isLoading: 'isLoading',
+    iconLeft: 'iconLeft',
+    iconLeftName: 'iconLeftName',
+    iconLeftSize: 'iconLeftSize',
+    iconRight: 'iconRight',
+    iconRightName: 'iconRightName',
+    iconRightSize: 'iconRightSize',
+    hasIconsLeft: 'hasIconsLeft',
+    hasIconsRight: 'hasIconsRight',
+    isExpanded: 'isExpanded',
+    controlSize: 'size (for controlSize)',
+    controlClassName: 'className (for controlClassName)',
+};
+/**
+ * Whether a convenience form wrapper renders a `Control` of its own (#921):
+ * only outside one. Inside a `Control` it renders none, so the props it
+ * would have handed its own do nothing there, and it warns in development,
+ * naming them and saying to set them on that `Control`. An `inline` picker
+ * renders none in either place, so it drops them inside a `Control` or not,
+ * and its warning says so without pointing at a `Control`. A wrapper passes
+ * only the props it hands its own `Control`, as the caller gave them, so a
+ * default the wrapper fills in itself never warns. A prop counts when it is
+ * truthy, since a falsy one would change nothing on a `Control` either.
+ * Internal; not part of the public API.
+ */
+const rendersOwnControl = (component, options) => {
+    if (!options.inline && !options.insideControl)
+        return true;
+    const held = Object.keys(ON_CONTROL).filter(prop => options[prop]);
+    if (held.length === 0)
+        return false;
+    const names = held.join(' ');
+    const doNothing = held.length > 1 ? 'those props do' : 'that prop does';
+    if (options.inline) {
+        warnOnce(`${component}:Control-props-inline:${held.join('+')}`, `[bestax-bulma] <${component} inline ${names}> renders no <Control> ` +
+            `in inline mode, inside a <Control> or not, so ${doNothing} ` +
+            `nothing. Leave ${held.length > 1 ? 'them' : 'it'} out of an ` +
+            `inline picker.`);
+    }
+    else {
+        warnOnce(`${component}:Control-props-in-Control:${held.join('+')}`, `[bestax-bulma] <${component} ${names}> inside a <Control> renders ` +
+            `no <Control> of its own, so ${doNothing} nothing there. Set ` +
+            `${listOf(held.map(prop => ON_CONTROL[prop]))} on that <Control> ` +
+            `instead.`);
+    }
+    return false;
+};
 const FieldLabelIdContext = React.createContext(undefined);
 /**
  * The id a labeled Field wants its single composed control to adopt (#495).
@@ -8867,6 +9003,19 @@ const Checkbox = React.forwardRef(({ color, size, className, children, textColor
 });
 Checkbox.displayName = 'Checkbox';
 
+// 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 = React.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 = () => React.useContext(ControlLoadingContext);
+
 const allowedColors = [...validColors, 'inherit', 'current'];
 /**
  * The `Control` component is a Bulma-styled wrapper for form controls (`Input`, `Select`, `TextArea`, etc.), supporting icons (left/right), loading state, expansion, size, and Bulma helper props for layout and color.
@@ -8926,7 +9075,7 @@ const Control = React.forwardRef(({ as = 'div', hasIconsLeft, hasIconsRight, isL
     });
     const controlClass = classNames(mainClass, bulmaHelperClasses, className);
     // --- FIX: Spread both restProps (for data-testid, etc) AND rest (from useBulmaClasses) ---
-    return (jsxRuntime.jsx(ControlProvider, { value: true, children: jsxRuntime.jsxs(Component, { className: controlClass, ref: ref, ...restProps, ...rest, children: [children, leftIconValue &&
+    return (jsxRuntime.jsx(ControlProvider, { value: true, children: jsxRuntime.jsxs(Component, { className: controlClass, ref: ref, ...restProps, ...rest, children: [jsxRuntime.jsx(ControlLoadingProvider, { value: !!isLoading, children: children }), leftIconValue &&
                     (isIconProps(leftIconValue) ? (jsxRuntime.jsx(Icon, { ...leftIconValue, className: prefixedClassNames(classPrefix, 'is-left') })) : (jsxRuntime.jsx(Icon, { className: prefixedClassNames(classPrefix, 'is-left'), children: leftIconValue }))), rightIconValue &&
                     (isIconProps(rightIconValue) ? (jsxRuntime.jsx(Icon, { ...rightIconValue, className: prefixedClassNames(classPrefix, 'is-right') })) : (jsxRuntime.jsx(Icon, { className: prefixedClassNames(classPrefix, 'is-right'), children: rightIconValue })))] }) }));
 });
@@ -9151,10 +9300,18 @@ function useAutoLabelledBy({ label, labelProps, rendersLabel, }) {
 const CheckboxesComponent = ({ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName, name, value, defaultValue, onChange, children, className, ...props }) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Checkboxes', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { ariaLabelledBy, fieldLabelProps } = useAutoLabelledBy({
         label,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         ...props,
@@ -9180,10 +9337,10 @@ const CheckboxesComponent = ({ label, labelSize, labelProps, horizontal, message
     }), [name, groupActive, currentValue, handleChange]);
     const checkboxesElement = (jsxRuntime.jsx("div", { className: wrapperClass, role: "group", "aria-labelledby": ariaLabelledBy, ...rest, children: jsxRuntime.jsx(CheckboxesProvider, { value: ctx, children: children }) }));
     let content = checkboxesElement;
-    if (!insideControl) {
+    if (rendersOwnControl('Checkboxes', { insideControl })) {
         content = jsxRuntime.jsx(Control, { children: content });
     }
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -9202,11 +9359,20 @@ const File = React.forwardRef(({
 // Field props
 label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName, color, size, isBoxed, isFullwidth, isFullWidth, isRight, isCentered, hasName, buttonLabel, iconLeft, iconRight, className, inputClassName, fileName, ...props }, ref) => {
     const insideField = useInsideField();
+    const insideControl = useInsideControl();
+    const ownField = rendersOwnField('File', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: props.id,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const { classPrefix } = useConfig();
     const { bulmaHelperClasses, rest } = useBulmaClasses({
@@ -9238,7 +9404,7 @@ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName,
     });
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
     const fileElement = (jsxRuntime.jsx("div", { className: fileClass, children: jsxRuntime.jsxs("label", { className: usePrefixedClassNames('file-label'), children: [jsxRuntime.jsx("input", { ref: ref, className: classNames(usePrefixedClassNames('file-input'), inputClassName), type: "file", id: controlId, ...rest }), jsxRuntime.jsxs("span", { className: usePrefixedClassNames('file-cta'), children: [iconLeft && (jsxRuntime.jsx("span", { className: prefixedClassNames(classPrefix, 'file-icon'), children: iconLeft })), jsxRuntime.jsx("span", { className: usePrefixedClassNames('file-label'), children: buttonLabel || 'Choose a file\u2026' }), iconRight && (jsxRuntime.jsx("span", { className: prefixedClassNames(classPrefix, 'file-icon'), children: iconRight }))] }), hasName && fileName && (jsxRuntime.jsx("span", { className: prefixedClassNames(classPrefix, 'file-name'), children: fileName }))] }) }));
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [fileElement, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [fileElement, messageEl] }));
@@ -9371,10 +9537,18 @@ Radio.displayName = 'Radio';
 const RadiosComponent = ({ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName, name, value, defaultValue, onChange, children, className, ...props }) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Radios', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { ariaLabelledBy, fieldLabelProps } = useAutoLabelledBy({
         label,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         ...props,
@@ -9403,10 +9577,10 @@ const RadiosComponent = ({ label, labelSize, labelProps, horizontal, message, me
     }), [name, groupActive, currentValue, handleChange]);
     const radiosElement = (jsxRuntime.jsx("div", { className: wrapperClass, role: "radiogroup", "aria-labelledby": ariaLabelledBy, ...rest, children: jsxRuntime.jsx(RadiosProvider, { value: ctx, children: children }) }));
     let content = radiosElement;
-    if (!insideControl) {
+    if (rendersOwnControl('Radios', { insideControl })) {
         content = jsxRuntime.jsx(Control, { children: content });
     }
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -9586,6 +9760,14 @@ const Slider = React.forwardRef((props, ref) => {
     range: _range, value: _value, defaultValue: _defaultValue, onChange: _onChange, ariaLabel: _ariaLabel, minDistance: _minDistance, nameLow: _nameLow, nameHigh: _nameHigh, ...restProps } = props;
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Slider', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { bulmaHelperClasses, rest } = useBulmaClasses(restProps);
     // In range mode the low thumb carries `rest` (and any user id), so the
     // label targets it; each thumb keeps its own aria-label for AT.
@@ -9593,7 +9775,7 @@ const Slider = React.forwardRef((props, ref) => {
         label,
         id: restProps.id,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     // Resolve tooltip mode: explicit tooltip prop takes precedence, else showOutput maps to 'auto'
     const tooltipMode = tooltip ?? (showOutput ? 'auto' : 'hidden');
@@ -9929,10 +10111,10 @@ const Slider = React.forwardRef((props, ref) => {
                         '--slider-output-arrow-offset': `calc(50% - ${nudgeXHigh}px)`,
                     }, children: formatValue(currentRange[1]) })), renderTicks()] }));
     let content = sliderElement;
-    if (!insideControl) {
+    if (rendersOwnControl('Slider', { insideControl })) {
         content = jsxRuntime.jsx(Control, { children: content });
     }
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -10162,10 +10344,18 @@ function getFillPercent(iconIndex, value) {
 const Rate = React.forwardRef(({ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName, value: controlledValue, defaultValue = 0, max = 5, size, disabled = false, showScore = false, showText = false, texts, onChange, customIcon, spaced = false, rtl = false, iconName, iconLibrary: iconLibraryProp, iconVariant, iconFeatures, color, precision = 1, customText, name, form, className, ...props }, ref) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Rate', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { ariaLabelledBy, fieldLabelProps } = useAutoLabelledBy({
         label,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const [internalValue, setInternalValue] = React.useState(defaultValue);
@@ -10365,10 +10555,10 @@ const Rate = React.forwardRef(({ label, labelSize, labelProps, horizontal, messa
     const rateCustomTextClass = usePrefixedClassNames('rate-custom-text');
     const rateElement = (jsxRuntime.jsxs("div", { ref: ref, className: combinedClasses, role: "radiogroup", "aria-label": ariaLabelledBy ? undefined : 'Rating', "aria-labelledby": ariaLabelledBy, "aria-valuenow": currentValue, "aria-valuemin": 0, "aria-valuemax": max, "aria-valuetext": ariaValueText, tabIndex: disabled ? -1 : 0, onKeyDown: handleKeyDown, ...rest, children: [jsxRuntime.jsx("div", { className: rateItemsClass, children: renderIcons() }), showScore && (jsxRuntime.jsx("span", { className: rateScoreClass, children: getScoreDisplay() })), text && jsxRuntime.jsx("span", { className: rateTextClass, children: text }), customText && (jsxRuntime.jsx("span", { className: rateCustomTextClass, children: customText })), name && (jsxRuntime.jsx("input", { type: "hidden", name: name, value: currentValue, form: form }))] }));
     let content = rateElement;
-    if (!insideControl) {
+    if (rendersOwnControl('Rate', { insideControl })) {
         content = jsxRuntime.jsx(Control, { children: content });
     }
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -10604,7 +10794,11 @@ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName,
         [`is-${messageColor}`]: !!messageColor,
     });
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    const autocompleteElement = (jsxRuntime.jsxs("div", { ref: containerRef, className: combinedClasses, ...rest, children: [jsxRuntime.jsxs("div", { className: controlClasses, children: [jsxRuntime.jsx("input", { ref: combinedRef, type: "text", className: inputClasses, id: controlId, value: inputValue, placeholder: placeholder, disabled: disabled, name: name, form: form, required: required, onChange: handleInputChange, onFocus: handleFocus, onKeyDown: handleKeyDown, role: "combobox", "aria-expanded": isActive, "aria-haspopup": "listbox", "aria-autocomplete": "list", autoComplete: "off" }), clearable && inputValue && !disabled && (jsxRuntime.jsx("span", { className: iconRightClickableClass, onClick: handleClear, role: "button", "aria-label": "Clear", children: jsxRuntime.jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", width: "16", height: "16", children: [jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }), jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })] }) })), loading && (jsxRuntime.jsx("span", { className: iconRightClass, children: jsxRuntime.jsx("span", { className: loaderClass }) }))] }), isActive && (filteredData.length > 0 || empty) && (jsxRuntime.jsx("div", { className: dropdownMenuClasses, children: jsxRuntime.jsxs("div", { ref: dropdownRef, className: dropdownContentClass, style: { maxHeight: `${maxHeight}px`, overflowY: 'auto' }, role: "listbox", onScroll: handleDropdownScroll, children: [header && jsxRuntime.jsx("div", { className: dropdownHeaderClass, children: header }), filteredData.length > 0 ? (filteredData.map((item, index) => {
+    // The clear button gives way to a spinner at its spot: the `loading` one,
+    // or that of a loading Control this sits in.
+    const controlLoading = useControlLoading();
+    const showClear = clearable && !!inputValue && !disabled && !loading && !controlLoading;
+    const autocompleteElement = (jsxRuntime.jsxs("div", { ref: containerRef, className: combinedClasses, ...rest, children: [jsxRuntime.jsxs("div", { className: controlClasses, children: [jsxRuntime.jsx("input", { ref: combinedRef, type: "text", className: inputClasses, id: controlId, value: inputValue, placeholder: placeholder, disabled: disabled, name: name, form: form, required: required, onChange: handleInputChange, onFocus: handleFocus, onKeyDown: handleKeyDown, role: "combobox", "aria-expanded": isActive, "aria-haspopup": "listbox", "aria-autocomplete": "list", autoComplete: "off" }), showClear && (jsxRuntime.jsx("button", { type: "button", className: iconRightClickableClass, onClick: handleClear, "aria-label": "Clear", children: jsxRuntime.jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", width: "16", height: "16", "aria-hidden": "true", children: [jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }), jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })] }) })), loading && (jsxRuntime.jsx("span", { className: iconRightClass, children: jsxRuntime.jsx("span", { className: loaderClass }) }))] }), isActive && (filteredData.length > 0 || empty) && (jsxRuntime.jsx("div", { className: dropdownMenuClasses, children: jsxRuntime.jsxs("div", { ref: dropdownRef, className: dropdownContentClass, style: { maxHeight: `${maxHeight}px`, overflowY: 'auto' }, role: "listbox", onScroll: handleDropdownScroll, children: [header && jsxRuntime.jsx("div", { className: dropdownHeaderClass, children: header }), filteredData.length > 0 ? (filteredData.map((item, index) => {
                             const isDisabled = typeof item !== 'string' && item.disabled;
                             const isHighlighted = index === highlightedIndex;
                             const itemClasses = prefixedClassNames(classPrefix, 'dropdown-item', {
@@ -10649,6 +10843,15 @@ const Taginput = React.forwardRef(({
 // Field props
 label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName, value: controlledValue, defaultValue = [], data = [], placeholder, field = 'label', allowNew = true, allowDuplicates = false, openOnFocus = false, removeOnKeys = true, confirmKeys = ['Enter', ','], closable = true, attached = false, maxTags, maxlength, disabled = false, readonly = false, rounded = false, ellipsis = false, hasCounter = true, onPasteSeparators = [','], beforeAdding, createTag, keepFirst = false, keepOpen = true, loading = false, ariaCloseLabel, icon, iconLibrary: iconLibraryProp, iconVariant, iconFeatures, color, tagColor, size, onChange, onAdd, onRemove, onTyping, tagTemplate, name, form, id, className, ...props }, ref) => {
     const insideField = useInsideField();
+    const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Taginput', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const { classPrefix } = useConfig();
     const defaultIconLibrary = useIconLibrary();
@@ -10670,7 +10873,7 @@ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName,
         label,
         id,
         labelProps,
-        rendersLabel: !insideField && !isMaxReached,
+        rendersLabel: ownField && !isMaxReached,
     });
     // Get display value from tag
     const getDisplayValue = (tag) => {
@@ -10942,7 +11145,7 @@ label, labelSize, labelProps, horizontal, message, messageColor, fieldClassName,
                             'is-active': index === highlightedIndex,
                         }), onClick: () => addTag(item), onMouseEnter: () => setHighlightedIndex(index), role: "option", "aria-selected": index === highlightedIndex, children: item }, index))) }) })), showCounter && jsxRuntime.jsx("small", { className: counterClasses, children: counterText }), name &&
                 tags.map((tag, i) => (jsxRuntime.jsx("input", { type: "hidden", name: name, value: getDisplayValue(tag), form: form }, `tag-input-${i}`)))] }));
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [taginputElement, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [taginputElement, messageEl] }));
@@ -11095,21 +11298,44 @@ fieldClassName, controlClassName,
 ...inputProps }, ref) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Input', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    const ownControl = rendersOwnControl('Input', {
+        insideControl,
+        isLoading,
+        iconLeft,
+        iconLeftName,
+        iconLeftSize,
+        iconRight,
+        iconRightName,
+        iconRightSize,
+        hasIconsLeft,
+        hasIconsRight,
+        isExpanded,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: inputProps.id,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
     let content = jsxRuntime.jsx(InputBase, { ref: ref, id: controlId, ...inputProps });
-    if (!insideControl) {
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { iconLeft: iconLeft, iconRight: iconRight, iconLeftName: iconLeftName, iconRightName: iconRightName, iconLeftSize: iconLeftSize, iconRightSize: iconRightSize, hasIconsLeft: hasIconsLeft, hasIconsRight: hasIconsRight, isLoading: isLoading, isExpanded: isExpanded, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -11145,21 +11371,40 @@ fieldClassName, controlClassName,
 ...selectProps }, ref) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('Select', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    // Not isLoading, which the select draws itself and so keeps in a Control.
+    const ownControl = rendersOwnControl('Select', {
+        insideControl,
+        iconLeft,
+        iconLeftName,
+        iconLeftSize,
+        hasIconsLeft,
+        isExpanded,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: selectProps.id,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
     let content = jsxRuntime.jsx(SelectBase, { ref: ref, id: controlId, ...selectProps });
-    if (!insideControl) {
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { iconLeft: iconLeft, iconLeftName: iconLeftName, iconLeftSize: iconLeftSize, hasIconsLeft: hasIconsLeft, isExpanded: isExpanded, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -11196,21 +11441,35 @@ fieldClassName, controlClassName,
 ...textAreaProps }, ref) => {
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('TextArea', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    const ownControl = rendersOwnControl('TextArea', {
+        insideControl,
+        isLoading: controlIsLoading,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: textAreaProps.id,
         labelProps,
-        rendersLabel: !insideField,
+        rendersLabel: ownField,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
     let content = jsxRuntime.jsx(TextAreaBase, { ref: ref, id: controlId, ...textAreaProps });
-    if (!insideControl) {
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { isLoading: controlIsLoading, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -11297,6 +11556,21 @@ function makeDate(year, month = 0, day = 1) {
     d.setFullYear(year, month, day);
     return d;
 }
+/**
+ * The earliest year the pickers accept. HTML's date, month and datetime-local
+ * inputs hold no year below 1, so the calendar, typing and parsing stop there
+ * too.
+ */
+const FIRST_YEAR = 1;
+/**
+ * The lower bound a picker applies: `min`, raised to local midnight on
+ * 1 January of {@link FIRST_YEAR} when it is earlier or absent. A `min` in
+ * range comes back as the same object.
+ */
+function floorMin(min) {
+    const floor = makeDate(FIRST_YEAR);
+    return min && min.getTime() >= floor.getTime() ? min : floor;
+}
 /**
  * First instant of the day, month or year containing `d`. Works by setters on
  * a copy rather than the `Date(y, m, d)` constructor, which reads years 0–99
@@ -11390,12 +11664,14 @@ function setTimeOfDay(d, parts) {
         r.setSeconds(parts.seconds);
     return r;
 }
+/**
+ * A copy of `d` moved into `[min, max]`. When `min` is after `max` nothing is
+ * in range and `min` wins, so clamping twice gives the same date and a
+ * picker's focus stays off the years before 1 under a `max` before then.
+ */
 function clampDate(d, min, max) {
-    if (min && isBefore(d, min))
-        return new Date(min);
-    if (max && isAfter(d, max))
-        return new Date(max);
-    return new Date(d);
+    const capped = max && isAfter(d, max) ? max : d;
+    return new Date(min && isBefore(capped, min) ? min : capped);
 }
 /**
  * Snap a Date's time-of-day to the nearest grid defined by the given
@@ -11468,7 +11744,9 @@ function formatToken(d, token) {
         case 'YYYY':
             // Zero-pad to a fixed 4 chars so the rendered width matches the
             // segment-map width during digit-by-digit keyboard entry (and to match
-            // ISO 8601). Years >9999 keep their natural width.
+            // ISO 8601), so year 19 shows as `0019`. Years >9999 keep their natural
+            // width. The pickers commit no year below 1, so a minus sign reaches
+            // this only from a `value` passed in.
             return pad(d.getFullYear(), 4);
         case 'YY':
             return pad(d.getFullYear() % 100);
@@ -11742,9 +12020,10 @@ function getMonthNames(locale, length = 'long') {
 
 /**
  * Selects the calendar's focused cell, the one tab stop of whichever grid or
- * year list is on show, for a popover to put focus on as it opens.
+ * year list is on show, for a popover to put focus on as it opens. It runs
+ * against the whole panel, so it matches only inside the grid or the list.
  */
-const CALENDAR_FOCUSED_CELL = '[data-focused="true"], [data-focused-year="true"]';
+const CALENDAR_FOCUSED_CELL = '[role="grid"] [data-focused="true"], [role="listbox"] [data-focused-year="true"]';
 const BASE_VIEW = {
     day: 'days',
     month: 'months',
@@ -11818,10 +12097,11 @@ function nearestEnabled(i, disabled) {
     return i;
 }
 /**
- * The year list's keyboard when it is the selection surface: arrows move a
- * year or a row, Home/End go to the list's ends. Returns the year to start
- * from and the direction to search past disabled years, or `null` for a key
- * the list doesn't handle.
+ * The year list's keyboard, as the selection surface and as navigation:
+ * arrows move a year or a row, Home/End go to the list's ends. Returns the
+ * year to start from and the direction to search past disabled years, or
+ * `null` for a key the list doesn't handle. As navigation no year is
+ * disabled, so only the year is used.
  */
 function yearStep(key, focusedYear, years) {
     switch (key) {
@@ -11841,7 +12121,7 @@ function yearStep(key, focusedYear, years) {
             return null;
     }
 }
-const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max, shouldDisableDate, unselectableDates, firstDayOfWeek = 0, locale, dayNames, monthNames, nearbyMonthDays = true, color, size, className, id, autoFocusCell = false, labels, yearsRange, granularity = 'day', }) => {
+const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min: minProp, max, shouldDisableDate, unselectableDates, firstDayOfWeek = 0, locale, dayNames, monthNames, nearbyMonthDays = true, color, size, className, id, autoFocusCell = false, labels, yearsRange, granularity = 'day', }) => {
     const gridRef = React.useRef(null);
     const monthGridRef = React.useRef(null);
     const yearGridRef = React.useRef(null);
@@ -11851,6 +12131,8 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
     const isDayGranularity = granularity === 'day';
     const isYearGranularity = granularity === 'year';
     const [view, setView] = React.useState(baseView);
+    // Nothing before year 1 can be picked or reached, as in HTML's date inputs.
+    const min = React.useMemo(() => floorMin(minProp), [minProp]);
     const computedDayNames = React.useMemo(() => {
         if (dayNames && dayNames.length === 7)
             return dayNames;
@@ -11921,7 +12203,7 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
     const moveFocus = React.useCallback((next, direction) => {
         let candidate = next;
         for (let i = 0; i < 366; i++) {
-            if (min && candidate.getTime() < startOfDay(min).getTime())
+            if (candidate.getTime() < startOfDay(min).getTime())
                 return;
             if (max && candidate.getTime() > startOfDay(max).getTime())
                 return;
@@ -11987,7 +12269,7 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
         let candidate = next;
         for (let i = 0; i < 120; i++) {
             const month = startOfMonth(candidate).getTime();
-            if (min && month < startOfMonth(min).getTime())
+            if (month < startOfMonth(min).getTime())
                 return;
             if (max && month > startOfMonth(max).getTime())
                 return;
@@ -12035,25 +12317,22 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
     const today = new Date();
     const todayYear = today.getFullYear();
     // The header steps a month at a time over the day grid and a year at a
-    // time over the month grid, kept inside min/max.
-    const prevMonthAnchor = addMonths(focusedDate, -1);
-    const nextMonthAnchor = addMonths(focusedDate, 1);
+    // time over the month grid, kept inside min/max. A step is off once the
+    // month or year on show holds the bound or lies past it, as picking a year
+    // from the list can leave it.
     const prevAnchor = isDayGranularity
-        ? prevMonthAnchor
+        ? addMonths(focusedDate, -1)
         : clampDate(addYears(focusedDate, -1), min, max);
     const nextAnchor = isDayGranularity
-        ? nextMonthAnchor
+        ? addMonths(focusedDate, 1)
         : clampDate(addYears(focusedDate, 1), min, max);
+    const focusedMonth = startOfMonth(focusedDate).getTime();
     const prevDisabled = isDayGranularity
-        ? !!(min &&
-            prevMonthAnchor.getTime() < startOfDay(min).getTime() &&
-            isSameMonth(focusedDate, min))
-        : !!(min && focusedYear <= min.getFullYear());
+        ? focusedMonth <= startOfMonth(min).getTime()
+        : focusedYear <= min.getFullYear();
     const nextDisabled = isDayGranularity
-        ? !!(max &&
-            nextMonthAnchor.getTime() > startOfDay(max).getTime() &&
-            isSameMonth(focusedDate, max))
-        : !!(max && focusedYear >= max.getFullYear());
+        ? !!max && focusedMonth >= startOfMonth(max).getTime()
+        : !!max && focusedYear >= max.getFullYear();
     const labelId = id ? `${id}-label` : undefined;
     const monthLabel = isDayGranularity
         ? `${computedMonthNames[focusedDate.getMonth()]} ${focusedYear}`
@@ -12064,7 +12343,9 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
     const [mountYear] = React.useState(focusedYear);
     const windowYear = isYearGranularity ? mountYear : focusedYear;
     const yearList = React.useMemo(() => {
-        const minYear = min ? min.getFullYear() : windowYear - 100;
+        const minYear = minProp
+            ? min.getFullYear()
+            : Math.max(FIRST_YEAR, windowYear - 100);
         const maxYear = max ? max.getFullYear() : windowYear + 100;
         const [lo, hi] = yearsRange ?? [minYear, maxYear];
         const start = Math.max(lo, minYear);
@@ -12073,20 +12354,31 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
         for (let y = start; y <= end; y++)
             out.push(y);
         return out;
-    }, [windowYear, min, max, yearsRange]);
+    }, [windowYear, minProp, min, max, yearsRange]);
     // Only the selection surface disables years; as navigation every listed
     // year can be visited.
     const disabledYears = React.useMemo(() => new Set(isYearGranularity ? yearList.filter(y => isYearUnselectable(y)) : []), [isYearGranularity, yearList, isYearUnselectable]);
     // The year list's one tab stop, after the month grid's: when the focused
     // year is disabled the stop moves to the nearest enabled year in the list,
-    // and focusing it makes it the focused year. A year outside the list keeps
-    // the stop, which then marks no option.
+    // and focusing it makes it the focused year. As the selection surface a
+    // year outside a non-empty list starts from the end it fell past, so the
+    // list keeps a stop. As navigation it marks the current year, so a year
+    // outside the list marks no option, and the stop itself follows focus.
     const tabStopYear = React.useMemo(() => {
-        const i = yearList.indexOf(focusedYear);
-        if (i < 0)
-            return focusedYear;
+        let i = yearList.indexOf(focusedYear);
+        if (i < 0) {
+            if (!isYearGranularity || yearList.length === 0)
+                return focusedYear;
+            i = focusedYear < yearList[0] ? 0 : yearList.length - 1;
+        }
         return yearList[nearestEnabled(i, yearList.map(y => disabledYears.has(y)))];
-    }, [yearList, focusedYear, disabledYears]);
+    }, [yearList, focusedYear, disabledYears, isYearGranularity]);
+    // As navigation the keys move focus and leave the focused year alone, so
+    // the tab stop goes to the year that last had focus while it is listed,
+    // and Tab leaves the list rather than landing on the current year. It
+    // starts over each time the list opens.
+    const [navYear, setNavYear] = React.useState(null);
+    const listTabStop = navYear !== null && yearList.includes(navYear) ? navYear : tabStopYear;
     // Which of the focused year's months have no selectable day.
     const disabledMonths = React.useMemo(() => granularity === 'month'
         ? Array.from({ length: 12 }, (_, m) => isMonthUnselectable(makeDate(focusedYear, m)))
@@ -12122,19 +12414,39 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
         }
     }, [yearList, disabledYears, onFocusedDateChange, min, max]);
     const handleYearListKeyDown = React.useCallback((e) => {
-        if (!isYearGranularity) {
-            // As navigation, Escape returns to the grid the list was opened from.
-            if (e.key === 'Escape') {
-                e.preventDefault();
-                setView(baseView);
-            }
+        if (isYearGranularity) {
+            const step = yearStep(e.key, focusedYear, yearList);
+            if (!step)
+                return;
+            e.preventDefault();
+            moveYearFocus(step[0], step[1]);
+            return;
+        }
+        // As navigation, Escape returns to the grid the list was opened from.
+        // It stops there, so a popover around the calendar stays open and only
+        // a second Escape closes it.
+        if (e.key === 'Escape') {
+            e.preventDefault();
+            e.stopPropagation();
+            setView(baseView);
             return;
         }
-        const step = yearStep(e.key, focusedYear, yearList);
+        // The other keys move DOM focus from the year that has it and leave
+        // the focused date alone. The list is centred on that date, so moving
+        // it would reflow the list under the keyboard, and it would turn the
+        // grid behind the list before anything is picked. Enter or Space
+        // clicks the year with focus, which picks it.
+        const options = Array.from(e.currentTarget.querySelectorAll('[role="option"]'));
+        const from = options.indexOf(e.target);
+        if (from < 0)
+            return;
+        const step = yearStep(e.key, yearList[from], yearList);
         if (!step)
             return;
         e.preventDefault();
-        moveYearFocus(step[0], step[1]);
+        // The listed years run one apart, so a year's index is its distance
+        // from the first. A step past either end finds no option.
+        options[step[0] - yearList[0]]?.focus();
     }, [isYearGranularity, baseView, focusedYear, yearList, moveYearFocus]);
     // The day or month grid takes focus as the popover opens on it, or comes
     // back to it from the year list.
@@ -12205,7 +12517,10 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
         list.querySelector('[data-focused-year="true"]')?.focus();
     }, [isYearGranularity, focusedYear]);
     const navArrow = (d) => (jsxRuntime.jsx("svg", { viewBox: "0 0 16 16", width: "14", height: "14", "aria-hidden": "true", children: jsxRuntime.jsx("path", { d: d, fill: "none", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }) }));
-    return (jsxRuntime.jsxs("div", { className: classNames(calendarClass, className), id: id, children: [jsxRuntime.jsxs("div", { className: headerClass, children: [isYearGranularity ? (jsxRuntime.jsx("span", { className: monthLabelClass, id: labelId, children: monthLabel })) : (jsxRuntime.jsxs("button", { type: "button", className: monthTriggerClass, "aria-haspopup": "listbox", "aria-expanded": view === 'years', onClick: () => setView(v => (v === 'years' ? baseView : 'years')), children: [jsxRuntime.jsx("span", { className: monthLabelClass, id: labelId, "aria-live": "polite", children: monthLabel }), jsxRuntime.jsx("svg", { className: monthCaretClass, viewBox: "0 0 12 12", width: "10", height: "10", "aria-hidden": "true", children: jsxRuntime.jsx("path", { d: "M2 4l4 4 4-4", fill: "none", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }) })] })), !isYearGranularity && (jsxRuntime.jsxs("div", { className: navGroupClass, children: [jsxRuntime.jsx("button", { type: "button", className: navPrevClass, "aria-label": isDayGranularity ? t.prevMonth : t.prevYear, disabled: prevDisabled || view !== baseView, onClick: () => onFocusedDateChange(prevAnchor), children: navArrow('M10 3l-5 5 5 5') }), jsxRuntime.jsx("button", { type: "button", className: navNextClass, "aria-label": isDayGranularity ? t.nextMonth : t.nextYear, disabled: nextDisabled || view !== baseView, onClick: () => onFocusedDateChange(nextAnchor), children: navArrow('M6 3l5 5-5 5') })] }))] }), view === 'days' && (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("div", { className: dayNamesRowClass, "aria-hidden": "true", children: computedDayNames.map((name, i) => (jsxRuntime.jsx("div", { className: dayNameClass, children: name }, i))) }), jsxRuntime.jsx("div", { ref: gridRef, role: "grid", "aria-labelledby": labelId, className: gridClass, onKeyDown: handleKeyDown, ...gridFocusHandlers, children: cells.map(cell => {
+    return (jsxRuntime.jsxs("div", { className: classNames(calendarClass, className), id: id, children: [jsxRuntime.jsxs("div", { className: headerClass, children: [isYearGranularity ? (jsxRuntime.jsx("span", { className: monthLabelClass, id: labelId, children: monthLabel })) : (jsxRuntime.jsxs("button", { type: "button", className: monthTriggerClass, "aria-haspopup": "listbox", "aria-expanded": view === 'years', onClick: () => {
+                            setNavYear(null);
+                            setView(v => (v === 'years' ? baseView : 'years'));
+                        }, children: [jsxRuntime.jsx("span", { className: monthLabelClass, id: labelId, "aria-live": "polite", children: monthLabel }), jsxRuntime.jsx("svg", { className: monthCaretClass, viewBox: "0 0 12 12", width: "10", height: "10", "aria-hidden": "true", children: jsxRuntime.jsx("path", { d: "M2 4l4 4 4-4", fill: "none", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }) })] })), !isYearGranularity && (jsxRuntime.jsxs("div", { className: navGroupClass, children: [jsxRuntime.jsx("button", { type: "button", className: navPrevClass, "aria-label": isDayGranularity ? t.prevMonth : t.prevYear, disabled: prevDisabled || view !== baseView, onClick: () => onFocusedDateChange(prevAnchor), children: navArrow('M10 3l-5 5 5 5') }), jsxRuntime.jsx("button", { type: "button", className: navNextClass, "aria-label": isDayGranularity ? t.nextMonth : t.nextYear, disabled: nextDisabled || view !== baseView, onClick: () => onFocusedDateChange(nextAnchor), children: navArrow('M6 3l5 5-5 5') })] }))] }), view === 'days' && (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("div", { className: dayNamesRowClass, "aria-hidden": "true", children: computedDayNames.map((name, i) => (jsxRuntime.jsx("div", { className: dayNameClass, children: name }, i))) }), jsxRuntime.jsx("div", { ref: gridRef, role: "grid", "aria-labelledby": labelId, className: gridClass, onKeyDown: handleKeyDown, ...gridFocusHandlers, children: cells.map(cell => {
                             const disabled = isDateUnselectable(cell.date);
                             const isSelected = !!value && isSameDay(value, cell.date);
                             const isFocused = isSameDay(cell.date, tabStopDay);
@@ -12265,10 +12580,16 @@ const Calendar = ({ value, focusedDate, onSelect, onFocusedDateChange, min, max,
                         'is-today': isToday,
                         'is-disabled': disabled,
                     });
-                    return (jsxRuntime.jsx("button", { type: "button", role: "option", "aria-selected": isSelected, "aria-disabled": isYearGranularity ? disabled : undefined, "aria-current": isYearGranularity && isToday ? 'date' : undefined, "data-focused-year": isFocused ? 'true' : undefined, tabIndex: isFocused ? 0 : -1, disabled: disabled, className: cellCls, onFocus: () => {
-                            // Reached by Tab while the focused year is disabled, or by
-                            // pointer: keys move on from here.
-                            if (isYearGranularity && year !== focusedYear) {
+                    return (jsxRuntime.jsx("button", { type: "button", role: "option", "aria-selected": isSelected, "aria-disabled": isYearGranularity ? disabled : undefined, "aria-current": isYearGranularity && isToday ? 'date' : undefined, "data-focused-year": isFocused ? 'true' : undefined, tabIndex: year === listTabStop ? 0 : -1, disabled: disabled, className: cellCls, onFocus: () => {
+                            // As navigation, focusing a year by key or pointer only
+                            // moves the tab stop: nothing is committed until a year is
+                            // picked. As the selection surface it is reached by Tab
+                            // while the focused year is disabled, or by pointer, and
+                            // keys move on from here.
+                            if (!isYearGranularity) {
+                                setNavYear(year);
+                            }
+                            else if (year !== focusedYear) {
                                 onFocusedDateChange(clampDate(makeDate(year), min, max));
                             }
                         }, onClick: () => isYearGranularity
@@ -12293,11 +12614,10 @@ const PickerPopover = ({ isOpen, onClose, anchorRef, children, position = 'botto
         active: isOpen,
         position,
         fixed: appendToBody,
-        // A portaled panel takes its gap from `--bulma-picker-popover-offset` as
-        // a margin, so its coordinates leave the gap out and `auto` reads it off
-        // the panel. An in-place panel's gap is in its `top` or `bottom`, which
-        // `auto` cannot read, so it keeps the hook's default estimate.
-        offset: appendToBody ? 0 : undefined,
+        // The gap comes from `--bulma-picker-popover-offset` as a margin, in place
+        // or portaled, so the coordinates leave it out and `auto` reads it off
+        // the panel.
+        offset: 0,
         styledGap: marginGap,
     });
     React.useEffect(() => {
@@ -12743,33 +13063,35 @@ function useSegmentedEntry(params) {
     // within the same event tick.
     const typedDigitsRef = React.useRef('');
     // The text focus seeded an empty picker with, until the user edits it or
-    // leaves. While the text still matches it, nothing has been typed.
+    // leaves.
     const seedRef = React.useRef(null);
-    // Whether the input's current focus is the one a closing popover handed
-    // back, until focus leaves the picker.
-    const handedBackRef = React.useRef(false);
+    // 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 = React.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 that leaving would then commit.
-    // `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.
+    // `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 = React.useRef(false);
     const wasOpenRef = React.useRef(isOpen);
     React.useLayoutEffect(() => {
         if (wasOpenRef.current && !isOpen) {
             closingRef.current = true;
-            if (!value && seedRef.current !== null && text === seedRef.current) {
+            if (!value && isUntouched(text))
                 setText('');
-            }
             seedRef.current = null;
         }
         wasOpenRef.current = isOpen;
-    }, [isOpen, value, text, setText]);
+    }, [isOpen, value, isUntouched, text, setText]);
     React.useEffect(() => {
         closingRef.current = false;
     }, [isOpen]);
@@ -12847,13 +13169,18 @@ function useSegmentedEntry(params) {
         }
         setActiveSegmentIdx(null);
         typedDigitsRef.current = '';
-        seedRef.current = null;
-        const handedBack = handedBackRef.current;
-        handedBackRef.current = false;
-        // Leaving after a dismiss commits only what was typed since. Text that
-        // still shows the value wasn't, and re-parsing it could drop what the
-        // format leaves out, such as seconds.
-        if (handedBack && value && text === formatFn(value, format, locale)) {
+        // 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;
         }
@@ -12867,6 +13194,8 @@ function useSegmentedEntry(params) {
         onBlur?.(e);
     }, [
         containerRef,
+        isUntouched,
+        isOpen,
         tryParse,
         text,
         isAllowed,
@@ -12880,7 +13209,6 @@ function useSegmentedEntry(params) {
     ]);
     const handleFocus = React.useCallback((e) => {
         const handedBack = closingRef.current;
-        handedBackRef.current = handedBack;
         if (!handedBack && openOnFocus && popover && !disabled && !readOnly) {
             setOpen(true);
         }
@@ -13048,12 +13376,20 @@ function useSegmentedEntry(params) {
         }
         if (e.key === 'Enter') {
             e.preventDefault();
-            const parsed = tryParse(text);
-            if (parsed && isAllowed(parsed)) {
-                commitValue(parsed);
+            // 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);
     }, [
@@ -13067,6 +13403,7 @@ function useSegmentedEntry(params) {
         setOpen,
         closeOnSelect,
         popover,
+        isUntouched,
         tryParse,
         text,
         isAllowed,
@@ -13115,9 +13452,12 @@ const pad2$1 = (n) => String(n).padStart(2, '0');
  * The value as the native input and the hidden form input carry it:
  * `YYYY-MM-DD`, `YYYY-MM` or `YYYY`, the shapes `<input type="date">` and
  * `<input type="month">` use. The year is padded to four digits, as those
- * inputs require and as the `YYYY` token displays it.
+ * inputs require and as the `YYYY` token displays it. HTML has no such shape
+ * for a year before 1, so a date then is empty, as those inputs would make it.
  */
 const toIsoValue = (d, granularity) => {
+    if (d.getFullYear() < FIRST_YEAR)
+        return '';
     const year = String(d.getFullYear()).padStart(4, '0');
     if (granularity === 'year')
         return year;
@@ -13158,14 +13498,19 @@ const SKIPPED_SEGMENTS = {
  * @returns {JSX.Element}
  */
 const DateInputBase = React.forwardRef((props, ref) => {
-    const { value: controlledValue, defaultValue, onChange, onOpen, onClose, min, max, disabled, readOnly, placeholder, granularity = 'day', format, parse, locale, inline = false, mobileNative = 'auto', editable = true, popover = true, openOnFocus = true, closeOnSelect = true, position = 'bottom-left', appendToBody = false, color, size, isRounded, shouldDisableDate, unselectableDates, firstDayOfWeek = 0, dayNames, monthNames, nearbyMonthDays = true, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon = true, triggerIconName = 'chevron-down', labels, ...rest } = props;
+    const { value: controlledValue, defaultValue, onChange, onOpen, onClose, min, max, disabled, readOnly, placeholder, granularity = 'day', format, parse, locale, inline = false, mobileNative = 'auto', editable = true, popover = true, openOnFocus = true, closeOnSelect = true, position = 'bottom-left', appendToBody = false, color, size, isRounded, shouldDisableDate, unselectableDates, firstDayOfWeek = 0, dayNames, monthNames, nearbyMonthDays = true, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon: triggerIconProp, triggerIconName = 'chevron-down', labels, ...rest } = props;
+    // The launcher gives way to the loading spinner of a Control this sits in.
+    const controlLoading = useControlLoading();
+    const triggerIcon = triggerIconProp ?? !controlLoading;
     const t = mergeLabels(labels);
     const isDayGranularity = granularity === 'day';
     const resolvedFormat = format ?? DEFAULT_FORMATS[granularity];
     const isControlled = controlledValue !== undefined;
     const [internalValue, setInternalValue] = React.useState(defaultValue ?? null);
     const value = isControlled ? (controlledValue ?? null) : internalValue;
-    const initialFocused = React.useMemo(() => clampDate(value ?? new Date(), min, max), 
+    // Nothing before year 1 is in range, as in HTML's date inputs.
+    const lowerBound = React.useMemo(() => floorMin(min), [min]);
+    const initialFocused = React.useMemo(() => clampDate(value ?? new Date(), lowerBound, max), 
     // intentionally only on mount: keep focusedDate stable until value/open change
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []);
@@ -13173,8 +13518,8 @@ const DateInputBase = React.forwardRef((props, ref) => {
     // Re-clamp focusedDate if min/max change after mount so the focused cell
     // never disappears outside the displayable range.
     React.useEffect(() => {
-        setFocusedDate(prev => clampDate(prev, min, max));
-    }, [min, max]);
+        setFocusedDate(prev => clampDate(prev, lowerBound, max));
+    }, [lowerBound, max]);
     const [open, setOpenState] = React.useState(false);
     const [text, setText] = React.useState(value ? formatDate(value, resolvedFormat, locale) : '');
     const inputRef = React.useRef(null);
@@ -13232,7 +13577,7 @@ const DateInputBase = React.forwardRef((props, ref) => {
     }, [isControlled, onChange, isDayGranularity, granularity]);
     // At month or year granularity the bounds widen to the periods holding
     // them, so the month or year containing `min` stays reachable.
-    const periodMin = React.useMemo(() => (min && !isDayGranularity ? startOfPeriod(min, granularity) : min), [min, isDayGranularity, granularity]);
+    const periodMin = React.useMemo(() => isDayGranularity ? lowerBound : startOfPeriod(lowerBound, granularity), [lowerBound, isDayGranularity, granularity]);
     const periodMax = React.useMemo(() => (max && !isDayGranularity ? endOfPeriod(max, granularity) : max), [max, isDayGranularity, granularity]);
     const handleSelect = React.useCallback((d) => {
         if (!isWithin(d, periodMin, periodMax))
@@ -13283,7 +13628,7 @@ const DateInputBase = React.forwardRef((props, ref) => {
     ]);
     // Typing, and the re-parse on blur or Enter, that lands in the period the
     // value already holds commits nothing, so a `value` elsewhere in its month
-    // or year isn't rewritten by focus passing through the field.
+    // or year changes only when the user picks or types a different period.
     const commitTyped = React.useCallback((next) => {
         if (next &&
             value &&
@@ -13349,7 +13694,7 @@ const DateInputBase = React.forwardRef((props, ref) => {
                     ? fromIsoValue(e.target.value, granularity)
                     : null;
                 commitValue(parsed);
-            }, min: min ? toIsoValue(min, granularity) : undefined, max: max ? toIsoValue(max, granularity) : undefined, disabled: disabled, readOnly: readOnly, placeholder: placeholder, name: name, form: form, required: required, id: id }));
+            }, min: min ? toIsoValue(lowerBound, granularity) : undefined, max: max ? toIsoValue(max, granularity) : undefined, disabled: disabled, readOnly: readOnly, placeholder: placeholder, name: name, form: form, required: required, id: id }));
     }
     const chooseLabel = granularity === 'month'
         ? t.chooseMonth
@@ -13358,7 +13703,11 @@ const DateInputBase = React.forwardRef((props, ref) => {
             : t.chooseDate;
     const calendar = (jsxRuntime.jsx(Calendar
     // A new granularity starts the calendar over on its own view.
-    , { granularity: granularity, value: value, focusedDate: focusedDate, onSelect: handleSelect, onFocusedDateChange: setFocusedDate, min: min, max: max, shouldDisableDate: shouldDisableDate, unselectableDates: unselectableDates, firstDayOfWeek: firstDayOfWeek, locale: locale, dayNames: dayNames, monthNames: monthNames, nearbyMonthDays: nearbyMonthDays, color: color, size: size, id: `${popoverId}-cal`, autoFocusCell: open, labels: labels }, granularity));
+    , { granularity: granularity, value: value, focusedDate: focusedDate, onSelect: handleSelect, onFocusedDateChange: setFocusedDate, min: min, max: max, shouldDisableDate: shouldDisableDate, unselectableDates: unselectableDates, firstDayOfWeek: firstDayOfWeek, locale: locale, dayNames: dayNames, monthNames: monthNames, nearbyMonthDays: nearbyMonthDays, color: color, size: size, 
+        // The popover panel takes `popoverId`, so the calendar inside it
+        // takes one of its own. Inline there is no panel, and the calendar
+        // keeps the id it released with.
+        id: inline ? popoverId : `${popoverId}-cal`, autoFocusCell: open, labels: labels }, granularity));
     if (inline) {
         return (jsxRuntime.jsxs("div", { ...cleanRest, ref: containerRef, className: classNames(containerClass, bulmaHelperClasses, className), children: [calendar, name && (jsxRuntime.jsx("input", { type: "hidden", name: name, form: form, value: value ? toIsoValue(value, granularity) : '', required: required }))] }));
     }
@@ -13386,29 +13735,57 @@ DateInputBase.displayName = 'DateInputBase';
  *   shouldDisableDate={d => d.getDay() === 0 || d.getDay() === 6}
  * />
  */
-const DateInput = React.forwardRef(({ label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'calendar', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps }, ref) => {
+const DateInput = React.forwardRef((props, ref) => {
+    const { label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'calendar', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps } = props;
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('DateInput', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    // Inline mode renders a bare calendar with no input, so the Control's
+    // icon-left container has nothing to anchor to, and it renders no
+    // Control inside one or out. The left icon is checked as the caller
+    // passed it: the default glyph is this component's own choice, not a
+    // prop the caller set.
+    const ownControl = rendersOwnControl('DateInput', {
+        insideControl,
+        inline: baseProps.inline,
+        isLoading,
+        iconLeft,
+        iconLeftName: props.iconLeftName,
+        iconLeftSize,
+        iconRight,
+        iconRightName,
+        iconRightSize,
+        hasIconsLeft,
+        hasIconsRight,
+        isExpanded,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: baseProps.id,
         labelProps,
         // Inline mode renders a bare calendar with no input to label.
-        rendersLabel: !insideField && !baseProps.inline,
+        rendersLabel: ownField && !baseProps.inline,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
-    // The right-side launcher is on by default; suppress it while the Control
-    // shows its loading spinner (also on the right) unless explicitly set.
-    let content = (jsxRuntime.jsx(DateInputBase, { ref: ref, id: controlId, ...baseProps, triggerIcon: baseProps.triggerIcon ?? !isLoading }));
-    // Inline mode renders a bare calendar with no input, so the Control's
-    // icon-left container has nothing to anchor to. Skip the Control wrap.
-    if (!insideControl && !baseProps.inline) {
+    // The base hides its launcher while the Control it sits in is loading,
+    // whether that is the one rendered below or an enclosing one.
+    let content = (jsxRuntime.jsx(DateInputBase, { ref: ref, id: controlId, ...baseProps }));
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { iconLeft: iconLeft, iconRight: iconRight, iconLeftName: iconLeftName, iconRightName: iconRightName, iconLeftSize: iconLeftSize, iconRightSize: iconRightSize, hasIconsLeft: hasIconsLeft || !!iconLeftName, hasIconsRight: hasIconsRight, isLoading: isLoading, isExpanded: isExpanded, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
@@ -14282,7 +14659,10 @@ const fromIsoTime = (s) => {
  * @returns {JSX.Element}
  */
 const TimeInputBase = React.forwardRef((props, ref) => {
-    const { value: controlledValue, defaultValue, onChange, onOpen, onClose, min, max, disabled, readOnly, placeholder, format, parse, locale, inline = false, mobileNative = 'auto', editable = true, popover = true, openOnFocus = true, closeOnSelect = false, position = 'bottom-left', appendToBody = false, color, size, isRounded, hourFormat = '24', enableSeconds = false, incrementHours = 1, incrementMinutes = 1, incrementSeconds = 1, unselectableTimes, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon = true, triggerIconName = 'chevron-down', labels, audioTick = false, haptics = false, ...rest } = props;
+    const { value: controlledValue, defaultValue, onChange, onOpen, onClose, min, max, disabled, readOnly, placeholder, format, parse, locale, inline = false, mobileNative = 'auto', editable = true, popover = true, openOnFocus = true, closeOnSelect = false, position = 'bottom-left', appendToBody = false, color, size, isRounded, hourFormat = '24', enableSeconds = false, incrementHours = 1, incrementMinutes = 1, incrementSeconds = 1, unselectableTimes, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon: triggerIconProp, triggerIconName = 'chevron-down', labels, audioTick = false, haptics = false, ...rest } = props;
+    // The launcher gives way to the loading spinner of a Control this sits in.
+    const controlLoading = useControlLoading();
+    const triggerIcon = triggerIconProp ?? !controlLoading;
     // Platform-appropriate feedback routing: when `haptics` is opted in and
     // the runtime has no Vibration API (notably iOS Safari), enable the
     // audio thunk so the user still gets *some* tactile cue. When vibrate
@@ -14359,6 +14739,8 @@ const TimeInputBase = React.forwardRef((props, ref) => {
     React.useEffect(() => {
         setText(value ? formatTime(value, defaultFormat, locale) : '');
     }, [value, defaultFormat, locale]);
+    // A value's date before year 1 is out of range, as in the date pickers.
+    const lowerBound = React.useMemo(() => floorMin(min), [min]);
     const commitValue = React.useCallback((next) => {
         if (!isControlled)
             setInternalValue(next);
@@ -14367,10 +14749,10 @@ const TimeInputBase = React.forwardRef((props, ref) => {
     const handleSpinnerChange = React.useCallback((parts) => {
         const base = value ?? new Date();
         const next = setTimeOfDay(base, parts);
-        if (!isWithin(next, min, max))
+        if (!isWithin(next, lowerBound, max))
             return;
         commitValue(next);
-    }, [value, min, max, commitValue]);
+    }, [value, lowerBound, max, commitValue]);
     const tryParse = React.useCallback((s) => {
         const trimmed = s.trim();
         if (!trimmed)
@@ -14402,7 +14784,7 @@ const TimeInputBase = React.forwardRef((props, ref) => {
         setText,
         makeBaseDate,
         locale,
-        min,
+        min: lowerBound,
         max,
         isBlocked: unselectableTimes,
         disabled,
@@ -14481,37 +14863,69 @@ TimeInputBase.displayName = 'TimeInputBase';
  * @example
  * <TimeInput label="Slot" hourFormat="12" incrementMinutes={15} />
  */
-const TimeInput = React.forwardRef(({ label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'clock', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps }, ref) => {
+const TimeInput = React.forwardRef((props, ref) => {
+    const { label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'clock', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps } = props;
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('TimeInput', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    // Inline mode renders a bare panel with no input, so the Control's
+    // icon-left container has nothing to anchor to, and it renders no
+    // Control inside one or out. The left icon is checked as the caller
+    // passed it: the default glyph is this component's own choice, not a
+    // prop the caller set.
+    const ownControl = rendersOwnControl('TimeInput', {
+        insideControl,
+        inline: baseProps.inline,
+        isLoading,
+        iconLeft,
+        iconLeftName: props.iconLeftName,
+        iconLeftSize,
+        iconRight,
+        iconRightName,
+        iconRightSize,
+        hasIconsLeft,
+        hasIconsRight,
+        isExpanded,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: baseProps.id,
         labelProps,
         // Inline mode renders a bare panel with no input to label.
-        rendersLabel: !insideField && !baseProps.inline,
+        rendersLabel: ownField && !baseProps.inline,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
-    // The right-side launcher is on by default; suppress it while the Control
-    // shows its loading spinner (also on the right) unless explicitly set.
-    let content = (jsxRuntime.jsx(TimeInputBase, { ref: ref, id: controlId, ...baseProps, triggerIcon: baseProps.triggerIcon ?? !isLoading }));
-    // Inline mode renders a bare panel with no input, so the Control's
-    // icon-left container has nothing to anchor to. Skip the Control wrap.
-    if (!insideControl && !baseProps.inline) {
+    // The base hides its launcher while the Control it sits in is loading,
+    // whether that is the one rendered below or an enclosing one.
+    let content = (jsxRuntime.jsx(TimeInputBase, { ref: ref, id: controlId, ...baseProps }));
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { iconLeft: iconLeft, iconRight: iconRight, iconLeftName: iconLeftName, iconRightName: iconRightName, iconLeftSize: iconLeftSize, iconRightSize: iconRightSize, hasIconsLeft: hasIconsLeft || !!iconLeftName, hasIconsRight: hasIconsRight, isLoading: isLoading, isExpanded: isExpanded, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));
 });
 TimeInput.displayName = 'TimeInput';
 
-// The year is padded to four digits, as `datetime-local` requires.
+// The year is padded to four digits, as `datetime-local` requires. HTML has
+// no such shape for a year before 1, so a date then is empty, as that input
+// would make it.
 const toIsoDateTime = (d, withSeconds) => {
+    if (d.getFullYear() < FIRST_YEAR)
+        return '';
     const yyyy = String(d.getFullYear()).padStart(4, '0');
     const mo = String(d.getMonth() + 1).padStart(2, '0');
     const dd = String(d.getDate()).padStart(2, '0');
@@ -14544,7 +14958,10 @@ const fromIsoDateTime = (s) => {
 const DateTimeInputBase = React.forwardRef((props, ref) => {
     const { value: controlledValue, defaultValue, onChange, onOpen, onClose, min, max, disabled, readOnly, placeholder, format, parse, locale, inline = false, mobileNative = 'auto', editable = true, popover = true, openOnFocus = true, closeOnSelect = false, position = 'bottom-left', appendToBody = false, color, size, isRounded, shouldDisableDate, unselectableDates, firstDayOfWeek = 0, dayNames, monthNames, nearbyMonthDays = true, hourFormat = '24', enableSeconds = false, incrementHours = 1, 
     // Step between visible wheel values; 1 gives the iOS-style every-minute wheel.
-    incrementMinutes = 1, incrementSeconds = 1, unselectableTimes, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon = true, triggerIconName = 'chevron-down', audioTick = false, haptics = false, labels, ...rest } = props;
+    incrementMinutes = 1, incrementSeconds = 1, unselectableTimes, className, name, form, required, id, onFocus, onClick, onKeyDown, onBlur, iconLeftName: _iconLeftName, triggerIcon: triggerIconProp, triggerIconName = 'chevron-down', audioTick = false, haptics = false, labels, ...rest } = props;
+    // The launcher gives way to the loading spinner of a Control this sits in.
+    const controlLoading = useControlLoading();
+    const triggerIcon = triggerIconProp ?? !controlLoading;
     const t = mergeLabels(labels);
     // Platform-appropriate feedback routing for the time wheel: on iOS (no
     // navigator.vibrate) the audio thunk fills in; on Android the real haptic
@@ -14554,14 +14971,16 @@ const DateTimeInputBase = React.forwardRef((props, ref) => {
     const isControlled = controlledValue !== undefined;
     const [internalValue, setInternalValue] = React.useState(defaultValue ?? null);
     const value = isControlled ? (controlledValue ?? null) : internalValue;
-    const initialFocused = React.useMemo(() => clampDate(value ?? new Date(), min, max), 
+    // Nothing before year 1 is in range, as in HTML's date inputs.
+    const lowerBound = React.useMemo(() => floorMin(min), [min]);
+    const initialFocused = React.useMemo(() => clampDate(value ?? new Date(), lowerBound, max), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []);
     const [focusedDate, setFocusedDate] = React.useState(initialFocused);
     // Re-clamp focusedDate when min/max change so the focused cell stays valid.
     React.useEffect(() => {
-        setFocusedDate(prev => clampDate(prev, min, max));
-    }, [min, max]);
+        setFocusedDate(prev => clampDate(prev, lowerBound, max));
+    }, [lowerBound, max]);
     const defaultFormat = format ??
         (hourFormat === '12'
             ? enableSeconds
@@ -14658,18 +15077,18 @@ const DateTimeInputBase = React.forwardRef((props, ref) => {
             minutes: value?.getMinutes() ?? 0,
             seconds: enableSeconds ? (value?.getSeconds() ?? 0) : undefined,
         });
-        if (!isWithin(merged, min, max))
+        if (!isWithin(merged, lowerBound, max))
             return;
         commitValue(merged);
         setFocusedDate(d);
-    }, [value, enableSeconds, min, max, commitValue]);
+    }, [value, enableSeconds, lowerBound, max, commitValue]);
     const handleTimeChange = React.useCallback((parts) => {
         const base = value ?? focusedDate;
         const next = setTimeOfDay(base, parts);
-        if (!isWithin(next, min, max))
+        if (!isWithin(next, lowerBound, max))
             return;
         commitValue(next);
-    }, [value, focusedDate, min, max, commitValue]);
+    }, [value, focusedDate, lowerBound, max, commitValue]);
     const tryParse = React.useCallback((s) => {
         const trimmed = s.trim();
         if (!trimmed)
@@ -14704,7 +15123,7 @@ const DateTimeInputBase = React.forwardRef((props, ref) => {
         setText,
         makeBaseDate,
         locale,
-        min,
+        min: lowerBound,
         max,
         isBlocked,
         disabled,
@@ -14737,7 +15156,7 @@ const DateTimeInputBase = React.forwardRef((props, ref) => {
                     ? fromIsoDateTime(e.target.value)
                     : null;
                 commitValue(parsed);
-            }, min: min ? toIsoDateTime(min, enableSeconds) : undefined, max: max ? toIsoDateTime(max, enableSeconds) : undefined, disabled: disabled, readOnly: readOnly, placeholder: placeholder, name: name, form: form, required: required, id: id }));
+            }, min: min ? toIsoDateTime(lowerBound, enableSeconds) : undefined, max: max ? toIsoDateTime(max, enableSeconds) : undefined, disabled: disabled, readOnly: readOnly, placeholder: placeholder, name: name, form: form, required: required, id: id }));
     }
     const spinnerValue = {
         hours: value?.getHours() ?? 0,
@@ -14785,29 +15204,57 @@ DateTimeInputBase.displayName = 'DateTimeInputBase';
  *   shouldDisableDate={d => d.getDay() === 0 || d.getDay() === 6}
  * />
  */
-const DateTimeInput = React.forwardRef(({ label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'calendar-alt', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps }, ref) => {
+const DateTimeInput = React.forwardRef((props, ref) => {
+    const { label, labelSize, labelProps, horizontal, iconLeft, iconRight, iconLeftName = 'calendar-alt', iconRightName, iconLeftSize, iconRightSize, hasIconsLeft, hasIconsRight, isLoading, isExpanded, controlSize, message, messageColor, fieldClassName, controlClassName, ...baseProps } = props;
     const insideField = useInsideField();
     const insideControl = useInsideControl();
+    const ownField = rendersOwnField('DateTimeInput', {
+        insideField,
+        insideControl,
+        label,
+        message,
+        horizontal,
+        fieldClassName,
+    });
+    // Inline mode renders a bare picker with no input, so the Control's
+    // icon-left container has nothing to anchor to, and it renders no
+    // Control inside one or out. The left icon is checked as the caller
+    // passed it: the default glyph is this component's own choice, not a
+    // prop the caller set.
+    const ownControl = rendersOwnControl('DateTimeInput', {
+        insideControl,
+        inline: baseProps.inline,
+        isLoading,
+        iconLeft,
+        iconLeftName: props.iconLeftName,
+        iconLeftSize,
+        iconRight,
+        iconRightName,
+        iconRightSize,
+        hasIconsLeft,
+        hasIconsRight,
+        isExpanded,
+        controlSize,
+        controlClassName,
+    });
     const { controlId, fieldLabelProps } = useAutoLabelId({
         label,
         id: baseProps.id,
         labelProps,
         // Inline mode renders a bare picker with no input to label.
-        rendersLabel: !insideField && !baseProps.inline,
+        rendersLabel: ownField && !baseProps.inline,
     });
     const helpClass = usePrefixedClassNames('help', {
         [`is-${messageColor}`]: !!messageColor,
     });
-    // The right-side launcher is on by default; suppress it while the Control
-    // shows its loading spinner (also on the right) unless explicitly set.
-    let content = (jsxRuntime.jsx(DateTimeInputBase, { ref: ref, id: controlId, ...baseProps, triggerIcon: baseProps.triggerIcon ?? !isLoading }));
-    // Inline mode renders a bare picker with no input, so the Control's
-    // icon-left container has nothing to anchor to. Skip the Control wrap.
-    if (!insideControl && !baseProps.inline) {
+    // The base hides its launcher while the Control it sits in is loading,
+    // whether that is the one rendered below or an enclosing one.
+    let content = (jsxRuntime.jsx(DateTimeInputBase, { ref: ref, id: controlId, ...baseProps }));
+    if (ownControl) {
         content = (jsxRuntime.jsx(Control, { iconLeft: iconLeft, iconRight: iconRight, iconLeftName: iconLeftName, iconRightName: iconRightName, iconLeftSize: iconLeftSize, iconRightSize: iconRightSize, hasIconsLeft: hasIconsLeft || !!iconLeftName, hasIconsRight: hasIconsRight, isLoading: isLoading, isExpanded: isExpanded, size: controlSize, className: controlClassName, children: content }));
     }
     const messageEl = message ? jsxRuntime.jsx("p", { className: helpClass, children: message }) : null;
-    if (!insideField) {
+    if (ownField) {
         return (jsxRuntime.jsxs(Field, { label: label, labelSize: labelSize, labelProps: fieldLabelProps, horizontal: horizontal, className: fieldClassName, children: [content, messageEl] }));
     }
     return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [content, messageEl] }));