@base-ui/react 1.0.0 → 1.2.0

package/esm/select/root/SelectRoot.d.ts

@@ -14,74 +14,79 @@ export interface SelectRootProps<Value, Multiple extends boolean | undefined = f
   /**
    * A ref to access the hidden input element.
    */
-  inputRef?: React.Ref<HTMLInputElement>;
+  inputRef?: React.Ref<HTMLInputElement> | undefined;
   /**
    * Identifies the field when a form is submitted.
    */
-  name?: string;
+  name?: string | undefined;
+  /**
+   * Provides a hint to the browser for autofill.
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/autocomplete
+   */
+  autoComplete?: string | undefined;
   /**
    * The id of the Select.
    */
-  id?: string;
+  id?: string | undefined;
   /**
    * Whether the user must choose a value before submitting a form.
    * @default false
    */
-  required?: boolean;
+  required?: boolean | undefined;
   /**
    * Whether the user should be unable to choose a different option from the select popup.
    * @default false
    */
-  readOnly?: boolean;
+  readOnly?: boolean | undefined;
   /**
    * Whether the component should ignore user interaction.
    * @default false
    */
-  disabled?: boolean;
+  disabled?: boolean | undefined;
   /**
    * Whether multiple items can be selected.
    * @default false
    */
-  multiple?: Multiple;
+  multiple?: Multiple | undefined;
   /**
    * Whether moving the pointer over items should highlight them.
    * Disabling this prop allows CSS `:hover` to be differentiated from the `:focus` (`data-highlighted`) state.
    * @default true
    */
-  highlightItemOnHover?: boolean;
+  highlightItemOnHover?: boolean | undefined;
   /**
    * Whether the select popup is initially open.
    *
    * To render a controlled select popup, use the `open` prop instead.
    * @default false
    */
-  defaultOpen?: boolean;
+  defaultOpen?: boolean | undefined;
   /**
    * Event handler called when the select popup is opened or closed.
    */
-  onOpenChange?: (open: boolean, eventDetails: SelectRootChangeEventDetails) => void;
+  onOpenChange?: ((open: boolean, eventDetails: SelectRootChangeEventDetails) => void) | undefined;
   /**
    * Event handler called after any animations complete when the select popup is opened or closed.
    */
-  onOpenChangeComplete?: (open: boolean) => void;
+  onOpenChangeComplete?: ((open: boolean) => void) | undefined;
   /**
    * Whether the select popup is currently open.
    */
-  open?: boolean;
+  open?: boolean | undefined;
   /**
    * Determines if the select enters a modal state when open.
-   * - `true`: user interaction is limited to the select: document page scroll is locked and and pointer interactions on outside elements are disabled.
+   * - `true`: user interaction is limited to the select: document page scroll is locked and pointer interactions on outside elements are disabled.
    * - `false`: user interaction with the rest of the document is allowed.
    * @default true
    */
-  modal?: boolean;
+  modal?: boolean | undefined;
   /**
    * A ref to imperative actions.
    * - `unmount`: When specified, the select will not be unmounted when closed.
    * Instead, the `unmount` function must be called to unmount the select manually.
    * Useful when the select's animation is controlled by an external library.
    */
-  actionsRef?: React.RefObject<SelectRootActions>;
+  actionsRef?: React.RefObject<SelectRootActions | null> | undefined;
   /**
    * Data structure of the items rendered in the select popup.
    * When specified, `<Select.Value>` renders the label of the selected item instead of the raw value.
@@ -96,39 +101,39 @@ export interface SelectRootProps<Value, Multiple extends boolean | undefined = f
    * <Select.Root items={items} />
    * ```
    */
-  items?: Record<string, React.ReactNode> | ReadonlyArray<{
+  items?: (Record<string, React.ReactNode> | ReadonlyArray<{
     label: React.ReactNode;
     value: any;
-  }>;
+  }>) | undefined;
   /**
    * When the item values are objects (`<Select.Item value={object}>`), this function converts the object value to a string representation for display in the trigger.
    * If the shape of the object is `{ value, label }`, the label will be used automatically without needing to specify this prop.
    */
-  itemToStringLabel?: (itemValue: Value) => string;
+  itemToStringLabel?: ((itemValue: Value) => string) | undefined;
   /**
    * When the item values are objects (`<Select.Item value={object}>`), this function converts the object value to a string representation for form submission.
    * If the shape of the object is `{ value, label }`, the value will be used automatically without needing to specify this prop.
    */
-  itemToStringValue?: (itemValue: Value) => string;
+  itemToStringValue?: ((itemValue: Value) => string) | undefined;
   /**
    * Custom comparison logic used to determine if a select item value matches the current selected value. Useful when item values are objects without matching referentially.
    * Defaults to `Object.is` comparison.
    */
-  isItemEqualToValue?: (itemValue: Value, value: Value) => boolean;
+  isItemEqualToValue?: ((itemValue: Value, value: Value) => boolean) | undefined;
   /**
    * The uncontrolled value of the select when it’s initially rendered.
    *
    * To render a controlled select, use the `value` prop instead.
    */
-  defaultValue?: SelectValueType<Value, Multiple> | null;
+  defaultValue?: (SelectValueType<Value, Multiple> | null) | undefined;
   /**
    * The value of the select. Use when controlled.
    */
-  value?: SelectValueType<Value, Multiple> | null;
+  value?: (SelectValueType<Value, Multiple> | null) | undefined;
   /**
    * Event handler called when the value of the select changes.
    */
-  onValueChange?: (value: SelectValueType<Value, Multiple> | (Multiple extends true ? never : null), eventDetails: SelectRootChangeEventDetails) => void;
+  onValueChange?: ((value: SelectValueType<Value, Multiple> | (Multiple extends true ? never : null), eventDetails: SelectRootChangeEventDetails) => void) | undefined;
 }
 export interface SelectRootState {}
 export interface SelectRootActions {

package/esm/select/root/SelectRoot.js

@@ -1,7 +1,7 @@
 'use client';
 
 import * as React from 'react';
-import { visuallyHidden } from '@base-ui/utils/visuallyHidden';
+import { visuallyHidden, visuallyHiddenInput } from '@base-ui/utils/visuallyHidden';
 import { useMergedRefs } from '@base-ui/utils/useMergedRefs';
 import { useRefWithInit } from '@base-ui/utils/useRefWithInit';
 import { useOnFirstRender } from '@base-ui/utils/useOnFirstRender';
@@ -13,7 +13,6 @@ import { useStore, Store } from '@base-ui/utils/store';
 import { useClick, useDismiss, useFloatingRootContext, useInteractions, useListNavigation, useTypeahead } from "../../floating-ui-react/index.js";
 import { SelectRootContext, SelectFloatingContext } from "./SelectRootContext.js";
 import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
-import { useLabelableContext } from "../../labelable-provider/LabelableContext.js";
 import { useLabelableId } from "../../labelable-provider/useLabelableId.js";
 import { useTransitionStatus } from "../../utils/useTransitionStatus.js";
 import { selectors } from "../store.js";
@@ -23,7 +22,7 @@ import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
 import { useFormContext } from "../../form/FormContext.js";
 import { useField } from "../../field/useField.js";
 import { stringifyAsValue } from "../../utils/resolveValueLabel.js";
-import { EMPTY_ARRAY } from "../../utils/constants.js";
+import { EMPTY_ARRAY, EMPTY_OBJECT } from "../../utils/constants.js";
 import { defaultItemEquality, findItemIndex } from "../../utils/itemEquality.js";
 import { useValueChanged } from "../../utils/useValueChanged.js";
 import { useOpenInteractionType } from "../../utils/useOpenInteractionType.js";
@@ -46,6 +45,7 @@ export function SelectRoot(props) {
     defaultOpen = false,
     onOpenChange,
     name: nameProp,
+    autoComplete,
     disabled: disabledProp = false,
     readOnly = false,
     required = false,
@@ -66,16 +66,16 @@ export function SelectRoot(props) {
   } = useFormContext();
   const {
     setDirty,
+    setTouched,
+    setFocused,
     shouldValidateOnChange,
     validityData,
     setFilled,
     name: fieldName,
     disabled: fieldDisabled,
-    validation
+    validation,
+    validationMode
   } = useFieldRootContext();
-  const {
-    controlId
-  } = useLabelableContext();
   const generatedId = useLabelableId({
     id
   });
@@ -176,8 +176,8 @@ export function SelectRoot(props) {
     }
   }, [store, value]);
   useIsoLayoutEffect(() => {
-    setFilled(value !== null);
-  }, [value, setFilled]);
+    setFilled(multiple ? Array.isArray(value) && value.length > 0 : value != null);
+  }, [multiple, value, setFilled]);
   useIsoLayoutEffect(function syncSelectedIndex() {
     if (open) {
       return;
@@ -212,6 +212,13 @@ export function SelectRoot(props) {
       return;
     }
     setOpenUnwrapped(nextOpen);
+    if (!nextOpen && (eventDetails.reason === REASONS.focusOut || eventDetails.reason === REASONS.outsidePress)) {
+      setTouched(true);
+      setFocused(false);
+      if (validationMode === 'onBlur') {
+        validation.commit(value);
+      }
+    }
 
     // The active index will sync to the last selected index on the next open.
     // Workaround `enableFocusInside` in Floating UI setting `tabindex=0` of a non-highlighted
@@ -324,7 +331,11 @@ export function SelectRoot(props) {
     getFloatingProps,
     getItemProps
   } = useInteractions([click, dismiss, listNavigation, typeahead]);
-  const mergedTriggerProps = React.useMemo(() => mergeProps(getReferenceProps(), interactionTypeProps), [getReferenceProps, interactionTypeProps]);
+  const mergedTriggerProps = React.useMemo(() => {
+    return mergeProps(getReferenceProps(), interactionTypeProps, generatedId ? {
+      id: generatedId
+    } : EMPTY_OBJECT);
+  }, [getReferenceProps, interactionTypeProps, generatedId]);
   useOnFirstRender(() => {
     store.update({
       popupProps: getFloatingProps(),
@@ -403,7 +414,11 @@ export function SelectRoot(props) {
         ...validation.getInputValidationProps({
           onFocus() {
             // Move focus to the trigger element when the hidden input is focused.
-            store.state.triggerElement?.focus();
+            store.state.triggerElement?.focus({
+              // Supported in Chrome from 144 (January 2026)
+              // @ts-expect-error - focusVisible is not yet in the lib.dom.d.ts
+              focusVisible: true
+            });
           },
           // Handle browser autofill.
           onChange(event) {
@@ -439,14 +454,14 @@ export function SelectRoot(props) {
             queueMicrotask(handleChange);
           }
         }),
-        id: id || controlId || undefined,
         name: multiple ? undefined : name,
+        autoComplete: autoComplete,
         value: serializedValue,
         disabled: disabled,
         required: required && !hasMultipleSelection,
         readOnly: readOnly,
         ref: ref,
-        style: visuallyHidden,
+        style: name ? visuallyHiddenInput : visuallyHidden,
         tabIndex: -1,
         "aria-hidden": true
       }), hiddenInputs]

package/esm/select/root/SelectRootContext.d.ts

@@ -14,30 +14,30 @@ export interface SelectRootContext {
   highlightItemOnHover: boolean;
   setValue: (nextValue: any, eventDetails: SelectRoot.ChangeEventDetails) => void;
   setOpen: (open: boolean, eventDetails: SelectRoot.ChangeEventDetails) => void;
-  listRef: React.MutableRefObject<Array<HTMLElement | null>>;
-  popupRef: React.MutableRefObject<HTMLDivElement | null>;
-  scrollHandlerRef: React.MutableRefObject<((el: HTMLDivElement) => void) | null>;
+  listRef: React.RefObject<Array<HTMLElement | null>>;
+  popupRef: React.RefObject<HTMLDivElement | null>;
+  scrollHandlerRef: React.RefObject<((el: HTMLDivElement) => void) | null>;
   handleScrollArrowVisibility: () => void;
   scrollArrowsMountedCountRef: React.RefObject<number>;
   getItemProps: (props?: HTMLProps & {
-    active?: boolean;
-    selected?: boolean;
+    active?: boolean | undefined;
+    selected?: boolean | undefined;
   }) => Record<string, unknown>;
   events: FloatingEvents;
-  valueRef: React.MutableRefObject<HTMLSpanElement | null>;
-  valuesRef: React.MutableRefObject<Array<any>>;
-  labelsRef: React.MutableRefObject<Array<string | null>>;
-  typingRef: React.MutableRefObject<boolean>;
-  selectionRef: React.MutableRefObject<{
+  valueRef: React.RefObject<HTMLSpanElement | null>;
+  valuesRef: React.RefObject<Array<any>>;
+  labelsRef: React.RefObject<Array<string | null>>;
+  typingRef: React.RefObject<boolean>;
+  selectionRef: React.RefObject<{
     allowUnselectedMouseUp: boolean;
     allowSelectedMouseUp: boolean;
   }>;
-  selectedItemTextRef: React.MutableRefObject<HTMLSpanElement | null>;
+  selectedItemTextRef: React.RefObject<HTMLSpanElement | null>;
   validation: UseFieldValidationReturnValue;
-  onOpenChangeComplete?: (open: boolean) => void;
-  keyboardActiveRef: React.MutableRefObject<boolean>;
+  onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+  keyboardActiveRef: React.RefObject<boolean>;
   alignItemWithTriggerActiveRef: React.RefObject<boolean>;
-  initialValueRef: React.MutableRefObject<any>;
+  initialValueRef: React.RefObject<any>;
 }
 export declare const SelectRootContext: React.Context<SelectRootContext | null>;
 export declare const SelectFloatingContext: React.Context<import("../../floating-ui-react/components/FloatingRootStore.js").FloatingRootStore | null>;

package/esm/select/root/SelectRootContext.js

@@ -1,3 +1,5 @@
+'use client';
+
 import _formatErrorMessage from "@base-ui/utils/formatErrorMessage";
 import * as React from 'react';
 export const SelectRootContext = /*#__PURE__*/React.createContext(null);

package/esm/select/scroll-arrow/SelectScrollArrow.d.ts

@@ -5,7 +5,7 @@ import { type TransitionStatus } from "../../utils/useTransitionStatus.js";
 /**
  * @internal
  */
-export declare const SelectScrollArrow: React.ForwardRefExoticComponent<SelectScrollArrowProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectScrollArrow: React.ForwardRefExoticComponent<Omit<SelectScrollArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface SelectScrollArrowState {
   direction: 'up' | 'down';
   visible: boolean;
@@ -18,7 +18,7 @@ export interface SelectScrollArrowProps extends BaseUIComponentProps<'div', Sele
    * Whether to keep the HTML element in the DOM while the select popup is not scrollable.
    * @default false
    */
-  keepMounted?: boolean;
+  keepMounted?: boolean | undefined;
 }
 export declare namespace SelectScrollArrow {
   type State = SelectScrollArrowState;

package/esm/select/scroll-arrow/SelectScrollArrow.js

@@ -67,12 +67,12 @@ export const SelectScrollArrow = /*#__PURE__*/React.forwardRef(function SelectSc
       }
     }
   });
-  const state = React.useMemo(() => ({
+  const state = {
     direction,
     visible,
     side,
     transitionStatus
-  }), [direction, visible, side, transitionStatus]);
+  };
   const defaultProps = {
     'aria-hidden': true,
     children: direction === 'up' ? '▲' : '▼',

package/esm/select/scroll-down-arrow/SelectScrollDownArrow.d.ts

@@ -6,14 +6,14 @@ import type { BaseUIComponentProps } from "../../utils/types.js";
  *
  * Documentation: [Base UI Select](https://base-ui.com/react/components/select)
  */
-export declare const SelectScrollDownArrow: React.ForwardRefExoticComponent<SelectScrollDownArrowProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectScrollDownArrow: React.ForwardRefExoticComponent<Omit<SelectScrollDownArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface SelectScrollDownArrowState {}
 export interface SelectScrollDownArrowProps extends BaseUIComponentProps<'div', SelectScrollDownArrow.State> {
   /**
    * Whether to keep the HTML element in the DOM while the select popup is not scrollable.
    * @default false
    */
-  keepMounted?: boolean;
+  keepMounted?: boolean | undefined;
 }
 export declare namespace SelectScrollDownArrow {
   type State = SelectScrollDownArrowState;

package/esm/select/scroll-down-arrow/SelectScrollDownArrowDataAttributes.js

@@ -21,6 +21,6 @@ export let SelectScrollDownArrowDataAttributes = function (SelectScrollDownArrow
    * Indicates which side the popup is positioned relative to the trigger.
    * @type {'none' | 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start'}
    */
-  SelectScrollDownArrowDataAttributes["side"] = "data-side";
+  SelectScrollDownArrowDataAttributes[SelectScrollDownArrowDataAttributes["side"] = CommonPopupDataAttributes.side] = "side";
   return SelectScrollDownArrowDataAttributes;
 }({});

package/esm/select/scroll-up-arrow/SelectScrollUpArrow.d.ts

@@ -6,14 +6,14 @@ import type { BaseUIComponentProps } from "../../utils/types.js";
  *
  * Documentation: [Base UI Select](https://base-ui.com/react/components/select)
  */
-export declare const SelectScrollUpArrow: React.ForwardRefExoticComponent<SelectScrollUpArrowProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectScrollUpArrow: React.ForwardRefExoticComponent<Omit<SelectScrollUpArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface SelectScrollUpArrowState {}
 export interface SelectScrollUpArrowProps extends BaseUIComponentProps<'div', SelectScrollUpArrow.State> {
   /**
    * Whether to keep the HTML element in the DOM while the select popup is not scrollable.
    * @default false
    */
-  keepMounted?: boolean;
+  keepMounted?: boolean | undefined;
 }
 export declare namespace SelectScrollUpArrow {
   type State = SelectScrollUpArrowState;

package/esm/select/scroll-up-arrow/SelectScrollUpArrowDataAttributes.js

@@ -21,6 +21,6 @@ export let SelectScrollUpArrowDataAttributes = function (SelectScrollUpArrowData
    * Indicates which side the popup is positioned relative to the trigger.
    * @type {'none' | 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start'}
    */
-  SelectScrollUpArrowDataAttributes["side"] = "data-side";
+  SelectScrollUpArrowDataAttributes[SelectScrollUpArrowDataAttributes["side"] = CommonPopupDataAttributes.side] = "side";
   return SelectScrollUpArrowDataAttributes;
 }({});

package/esm/select/store.d.ts

@@ -12,7 +12,7 @@ export type State = {
   }> | undefined;
   itemToStringLabel: ((item: any) => string) | undefined;
   itemToStringValue: ((item: any) => string) | undefined;
-  isItemEqualToValue: (item: any, value: any) => boolean;
+  isItemEqualToValue: (itemValue: any, selectedValue: any) => boolean;
   value: any;
   open: boolean;
   mounted: boolean;
@@ -41,8 +41,10 @@ export declare const selectors: {
   }[] | undefined;
   itemToStringLabel: (state: State) => ((item: any) => string) | undefined;
   itemToStringValue: (state: State) => ((item: any) => string) | undefined;
-  isItemEqualToValue: (state: State) => (item: any, value: any) => boolean;
+  isItemEqualToValue: (state: State) => (itemValue: any, selectedValue: any) => boolean;
   value: (state: State) => any;
+  hasSelectedValue: (state: State) => boolean;
+  hasNullItemLabel: (state: State, enabled: boolean) => boolean;
   open: (state: State) => boolean;
   mounted: (state: State) => boolean;
   forceMount: (state: State) => boolean;
@@ -51,7 +53,7 @@ export declare const selectors: {
   activeIndex: (state: State) => number | null;
   selectedIndex: (state: State) => number | null;
   isActive: (state: State, index: number) => boolean;
-  isSelected: (state: State, index: number, candidate: any) => boolean;
+  isSelected: (state: State, index: number, itemValue: any) => boolean;
   isSelectedByFocus: (state: State, index: number) => boolean;
   popupProps: (state: State) => HTMLProps;
   triggerProps: (state: State) => HTMLProps;
@@ -61,5 +63,4 @@ export declare const selectors: {
   scrollUpArrowVisible: (state: State) => boolean;
   scrollDownArrowVisible: (state: State) => boolean;
   hasScrollArrows: (state: State) => boolean;
-  serializedValue: (state: State) => string;
 };

package/esm/select/store.js

@@ -1,6 +1,6 @@
 import { createSelector } from '@base-ui/utils/store';
 import { compareItemEquality } from "../utils/itemEquality.js";
-import { stringifyAsValue } from "../utils/resolveValueLabel.js";
+import { hasNullItemLabel, stringifyAsValue } from "../utils/resolveValueLabel.js";
 export const selectors = {
   id: createSelector(state => state.id),
   modal: createSelector(state => state.modal),
@@ -10,6 +10,23 @@ export const selectors = {
   itemToStringValue: createSelector(state => state.itemToStringValue),
   isItemEqualToValue: createSelector(state => state.isItemEqualToValue),
   value: createSelector(state => state.value),
+  hasSelectedValue: createSelector(state => {
+    const {
+      value,
+      multiple,
+      itemToStringValue
+    } = state;
+    if (value == null) {
+      return false;
+    }
+    if (multiple && Array.isArray(value)) {
+      return value.length > 0;
+    }
+    return stringifyAsValue(value, itemToStringValue) !== '';
+  }),
+  hasNullItemLabel: createSelector((state, enabled) => {
+    return enabled ? hasNullItemLabel(state.items) : false;
+  }),
   open: createSelector(state => state.open),
   mounted: createSelector(state => state.mounted),
   forceMount: createSelector(state => state.forceMount),
@@ -18,11 +35,11 @@ export const selectors = {
   activeIndex: createSelector(state => state.activeIndex),
   selectedIndex: createSelector(state => state.selectedIndex),
   isActive: createSelector((state, index) => state.activeIndex === index),
-  isSelected: createSelector((state, index, candidate) => {
+  isSelected: createSelector((state, index, itemValue) => {
     const comparer = state.isItemEqualToValue;
     const storeValue = state.value;
     if (state.multiple) {
-      return Array.isArray(storeValue) && storeValue.some(item => compareItemEquality(item, candidate, comparer));
+      return Array.isArray(storeValue) && storeValue.some(selectedItem => compareItemEquality(itemValue, selectedItem, comparer));
     }
 
     // `selectedIndex` is only updated after the items mount for the first time,
@@ -30,7 +47,7 @@ export const selectors = {
     if (state.selectedIndex === index && state.selectedIndex !== null) {
       return true;
     }
-    return compareItemEquality(storeValue, candidate, comparer);
+    return compareItemEquality(itemValue, storeValue, comparer);
   }),
   isSelectedByFocus: createSelector((state, index) => {
     return state.selectedIndex === index;
@@ -42,16 +59,5 @@ export const selectors = {
   listElement: createSelector(state => state.listElement),
   scrollUpArrowVisible: createSelector(state => state.scrollUpArrowVisible),
   scrollDownArrowVisible: createSelector(state => state.scrollDownArrowVisible),
-  hasScrollArrows: createSelector(state => state.hasScrollArrows),
-  serializedValue: createSelector(state => {
-    const {
-      multiple,
-      value,
-      itemToStringValue
-    } = state;
-    if (multiple && Array.isArray(value) && value.length === 0) {
-      return '';
-    }
-    return stringifyAsValue(value, itemToStringValue);
-  })
+  hasScrollArrows: createSelector(state => state.hasScrollArrows)
 };

package/esm/select/trigger/SelectTrigger.d.ts

@@ -7,19 +7,29 @@ import type { FieldRoot } from "../../field/root/FieldRoot.js";
  *
  * Documentation: [Base UI Select](https://base-ui.com/react/components/select)
  */
-export declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export interface SelectTriggerState extends FieldRoot.State {
-  /** Whether the select popup is currently open. */
+  /**
+   * Whether the select popup is currently open.
+   */
   open: boolean;
-  /** Whether the select popup is readonly. */
+  /**
+   * Whether the select popup is readonly.
+   */
   readOnly: boolean;
-  /** The value of the currently selected item. */
+  /**
+   * The value of the currently selected item.
+   */
   value: any;
+  /**
+   * Whether the select doesn't have a value.
+   */
+  placeholder: boolean;
 }
 export interface SelectTriggerProps extends NativeButtonProps, BaseUIComponentProps<'button', SelectTrigger.State> {
   children?: React.ReactNode;
   /** Whether the component should ignore user interaction. */
-  disabled?: boolean;
+  disabled?: boolean | undefined;
 }
 export declare namespace SelectTrigger {
   type State = SelectTriggerState;