A searchable dropdown for filtering and selecting from a list of options.
import { Combobox } from '@oztix/roadie-components/combobox'
Wrap Combobox in Field for consistent layout, labels, and
error handling. Field.Label's htmlFor wires directly to the Combobox input:
clicking the label focuses the search field.
Use custom markup inside Combobox.Item to show metadata like a subtitle or
secondary label alongside the primary text. Pass the item itself as value, and
use itemToStringLabel to set the text the input shows and filters on.
Set multiple to pick more than one value. Combobox.Value hands the current
values to a function; render a Combobox.Chip for each one inside
Combobox.Chips, with the input last. Put the text in Combobox.ChipLabel so a
long value truncates. The input group grows as the chips wrap. A chip with
focus shows as selected. Set selected on Combobox.Chip to show it selected
while focus stays in the input, as QueryField does while it edits a chip.
Use Combobox when the user needs to search or filter a list, or when options are loaded from an API. The input lets users narrow results by typing. They usually know roughly what they're looking for.
If the list is short, fixed, and fully known (under ~15 items), use Select. Users browse rather than search. No text input needed.
If the user's typed value is always valid and suggestions just help, use Autocomplete. Think address fields or search bars.
| Question | Select | Combobox | Autocomplete |
|---|---|---|---|
| User types to filter? | No | Yes | Yes |
| Must pick from the list? | Yes | Yes | No, typed value is valid |
| Options from an API? | No | Yes | Yes |
| Custom/free-text value? | No | No | Yes |
| Primary interaction | Browse and pick | Search and pick | Type with suggestions |
| Typical list size | 2-15 items | 10-500+ items | Any |
Pass the items prop to Combobox root for built-in client-side filtering. Use
Combobox.List with a render function child to template each filtered item:
Combobox.Empty only renders when the filtered list is empty. It requires the
items prop on root.
The closest matches come first, so Enter picks the likeliest one. An exact
match leads, then labels that start with the text, then labels with a word that
starts with it, then labels that contain it anywhere. Matches of the same kind
keep the order of items, and grouped items are ranked within their group.
Case and accents don't count, as in the filter.
Typing "Rock" over ['Hard rock', 'Rock'] lists Rock first, so Enter picks it.
Opening the list without typing shows items in your order. With limit on a
flat list, ranking comes first, so the closest matches are the ones kept.
Grouped items fill the limit group by group, in your group order.
Roadie ranks only with its default filter, and only an array of items; a
createItems() collection keeps its order. Pass your own filter or
filteredItems to set the order yourself.
For server-side search, update the items prop as results arrive, and pass
filter={null} so the server's matches keep their order. Use
Combobox.Status to announce state changes to screen readers:
<Combobox.Chip aria-label={genre}><Combobox.ChipLabel>{genre}</Combobox.ChipLabel><Combobox.ChipRemove aria-label={`Remove ${genre}`} /></Combobox.Chip>
Do
Label each chip with its value and each remove button with what it removes, such as "Remove Folk".
<Combobox.ChipRemove aria-label='Remove' />
Don’t
Don't give every remove button the same name. A screen reader can't tell them apart.
Do
Clear the placeholder once a value is chosen. The chips already say what the field holds.
Don’t
Don't keep "Search genres..." beside three chosen genres.
autoHighlight={false} to highlight only what the
user moves to, or autoHighlight='always' to highlight the first item with
no text too.aria-activedescendant at the highlighted item, so screen
readers read the first match as the list filters.multiple, Backspace in an empty input selects the last chip, and
a second Backspace removes it. A click on a chip selects it too.
Escape on a chip returns focus to the input and keeps every value.
Left Arrow from the start of the input moves to the chips, Left and
Right move between them (swapped in a right-to-left layout), and
Backspace or Delete removes the focused one. Focus moves to the
next chip, or the previous one after the last, and returns to the input
once no chips are left. To handle these keys yourself, call
event.preventBaseUIHandler() in the input's onKeyDown.multiple, Escape while the popup is closed clears the typed text
and keeps every value.Combobox.Chips becomes a toolbar once it holds chips, so screen readers
stay in focus mode while the arrows move between them. Name it with
aria-label while it holds chips.Combobox.ChipRemove stays out of the tab order. Click it to remove a chip;
from the keyboard, press Backspace on the chip. Leave it out of a readOnly
combobox, where it can't remove anything.aria-description on the chip and input, as in the example, adds a hint for
screen readers that support it. The labels must make sense without it.<label> or Combobox.Label to name the input.Combobox.ItemIndicator shows a check on the selected item, include it for clarity.Combobox.Empty announces "no results" to screen readers automatically.Combobox.Status is a live region, use it for async status like loading or result counts.function useFilter(options?: FilterOptions): Filter
Base UI's item matcher, re-exported for filtering items yourself before
passing them to Combobox (server-side search, custom ranking) rather than
relying on the built-in client-side filter.
| Param | Type | Description |
|---|---|---|
options.multiple | boolean | Whether the combobox is in multiple selection mode. Default false. |
options.value | any | The current value, kept visible even while the query no longer matches it. |
options.locale | Intl.LocalesArgument | Locale for string comparison. Defaults to the runtime locale. |
Returns a Filter:
| Field | Type | Description |
|---|---|---|
contains | (item, query, itemToString?) => boolean | Whether the item matches the query anywhere. |
startsWith | (item, query, itemToString?) => boolean | Whether the item starts with the query. |
endsWith | (item, query, itemToString?) => boolean | Whether the item ends with the query. |
Identifies the form that owns the internal input. Useful when the combobox is rendered outside the form.
Filter function used to match items vs input query. Receives the source item, which is the derived value's item when `items` is a `createItems()` collection, and the item itself otherwise.
The id of the component.
Whether list items are presented in a grid layout. When enabled, arrow keys navigate across rows and columns inferred from DOM rows.
Defaults to false.
Whether the list is rendered inline without using the component's own popup. Specify `open` unconditionally in conjunction with this prop so the list is considered visible: `<Combobox.Root inline open>` In a `Combobox.Root` > `Dialog.Root` composition, bind the Combobox's `open` and `onOpenChange` props to the `Dialog`'s `open` and `onOpenChange` state instead so the component resets its transient state (filter query, highlighted item, and input value) when the dialog closes.
Defaults to false.
Whether the component should ignore user interaction.
Defaults to false.
Identifies the field when a form is submitted.
The items to be displayed in the list. Can be a flat array of items, an array of groups with items, or a collection created by the `createItems()` function, which derives each item's selection value and label. Nullish entries are not supported: remove them from the data before passing it.
Whether the user should be unable to choose a different option from the popup.
Defaults to false.
Whether the user must choose a value before submitting a form.
Defaults to false.
Whether the popup is initially open. To render a controlled popup, use the `open` prop instead.
Defaults to false.
Whether the popup is currently open. Use when controlled.
Event handler called after any animations complete when the popup is opened or closed.
Whether the popup opens when clicking the input.
Defaults to true.
Whether to loop keyboard focus back to the input when the end of the list is reached while using the arrow keys. The first item can then be reached by pressing <kbd>ArrowDown</kbd> again from the input, or the last item can be reached by pressing <kbd>ArrowUp</kbd> from the input. The input is always included in the focus loop per [ARIA Authoring Practices](https://www.w3.org/WAI/ARIA/apg/patterns/combobox/). When disabled, focus does not move when on the last element and the user presses <kbd>ArrowDown</kbd>, or when on the first element and the user presses <kbd>ArrowUp</kbd>.
Defaults to true.
The input value of the combobox. Use when controlled.
The uncontrolled input value when initially rendered. To render a controlled input, use the `inputValue` prop instead.
A ref to the hidden input element.
Filtered items to display in the list. When provided, the list uses these items instead of filtering the `items` prop internally. When `items` is also provided, this array must preserve its flat or grouped structure. With a `createItems()` collection, pass source items rather than derived values. Nullish entries are not supported, as in `items`. Use when you want to control filtering logic externally with the `useFilter()` hook.
Whether the items are being externally virtualized.
Defaults to false.
Determines if the popup enters a modal state when open. - `true`: user interaction is limited to the popup: document page scroll is locked and pointer interactions on outside elements are disabled. - `false`: user interaction with the rest of the document is allowed. On touch devices, a `true` modal blocks outside taps but leaves the page scrollable unless the popup spans nearly the full viewport width, matching native iOS behavior.
Defaults to false.
The maximum number of items to display in the list.
Defaults to -1.
The locale to use for string comparison. Defaults to the user's runtime locale.
Whether the first match is highlighted, so Enter picks it. - `true`: once the user types, including matches that arrive later. Opening the list without typing highlights nothing. - `'always'`: whenever the list shows an item, even with no text. - `false`: only an item moved to with the arrows or the pointer.
Defaults to true.
CSS class applied to the element, or a function that returns a class based on the component's state.
Shows the chip selected while focus stays elsewhere, such as in the input while its values are edited.
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Names the value it removes, such as "Remove Rock".
Inherited from NativeButtonProps
Whether the component renders a native `<button>` element when replacing it via the `render` prop. Set to `false` if the rendered element is not a button (for example, `<div>`).
Defaults to true.
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxClearProps
Whether the component should ignore user interaction.
Defaults to false.
Whether the component should remain mounted in the DOM when not visible.
Defaults to false.
Inherited from NativeButtonProps
Whether the component renders a native `<button>` element when replacing it via the `render` prop. Set to `false` if the rendered element is not a button (for example, `<div>`).
Defaults to true.
No additional props. It forwards all standard HTML attributes to the underlying element.
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxGroupProps
Items to be rendered within this group. When provided, child `Collection` components will use these items.
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxInputProps
Whether the component should ignore user interaction.
Defaults to false.
CSS class applied to the element, or a function that returns a class based on the component's state.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxItemProps
An optional click handler for the item when selected. It fires when clicking the item with the pointer, as well as when pressing `Enter` with the keyboard if the item is highlighted when the `Input` or `List` element has focus.
The index of the item in the list. Improves performance when specified by avoiding the need to calculate the index automatically from the DOM.
A unique value that identifies this item.
Defaults to null.
Whether the component should ignore user interaction.
Defaults to false.
Inherited from NativeButtonProps
Whether the component renders a native `<button>` element when replacing it via the `render` prop. Set to `false` if the rendered element is not a button (for example, `<div>`).
Defaults to true.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxItemIndicatorProps
Whether to keep the HTML element in the DOM when the item is not selected.
Defaults to false.
No additional props. It forwards all standard HTML attributes to the underlying element.
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxPopupProps
Determines the element to focus when the popup is opened. - `false`: Do not move focus. - `true`: Move focus based on the default behavior (first tabbable element or popup). - `RefObject`: Move focus to the ref element. - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`). Return an element to focus, `true` to use the default behavior, or `false`/`undefined` to do nothing.
Determines the element to focus when the popup is closed. - `false`: Do not move focus. - `true`: Move focus based on the default behavior (trigger or previously focused element). - `RefObject`: Move focus to the ref element. - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`). Return an element to focus, `true` to use the default behavior, or `false`/`undefined` to do nothing.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxPortalProps
Whether to keep the portal mounted in the DOM while the popup is hidden.
Defaults to false.
A parent element to render the portal element into.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from UseAnchorPositioningSharedParameters
An element to position the popup against. By default, the popup will be positioned against the trigger.
Determines which CSS `position` property to use.
Defaults to 'absolute'.
Which side of the anchor element to align the popup against. May automatically change to avoid collisions.
Defaults to 'bottom'.
Distance between the anchor and the popup in pixels. Also accepts a function that returns the distance to read the dimensions of the anchor and positioner elements, along with its side and alignment. The function takes a `data` object parameter with the following properties: - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`. - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`. - `data.side`: which side of the anchor element the positioner is aligned against. - `data.align`: how the positioner is aligned relative to the specified side. @example ```jsx <Positioner sideOffset={({ side, align, anchor, positioner }) => { return side === 'top' || side === 'bottom' ? anchor.height : anchor.width; }} /> ```
Defaults to 0.
How to align the popup relative to the specified side.
Defaults to 'center'.
Additional offset along the alignment axis in pixels. Also accepts a function that returns the offset to read the dimensions of the anchor and positioner elements, along with its side and alignment. The function takes a `data` object parameter with the following properties: - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`. - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`. - `data.side`: which side of the anchor element the positioner is aligned against. - `data.align`: how the positioner is aligned relative to the specified side. @example ```jsx <Positioner alignOffset={({ side, align, anchor, positioner }) => { return side === 'top' || side === 'bottom' ? anchor.width : anchor.height; }} /> ```
Defaults to 0.
An element or a rectangle that delimits the area that the popup is confined to.
Defaults to 'clipping-ancestors'.
Additional space to maintain from the edge of the collision boundary.
Defaults to 5.
Whether to maintain the popup in the viewport after the anchor element was scrolled out of view.
Defaults to false.
Minimum distance to maintain between the arrow and the edges of the popup. Use it to prevent the arrow element from hanging out of the rounded corners of a popup.
Defaults to 5.
Whether to disable the popup from tracking any layout shift of its positioning anchor.
Defaults to false.
Determines how to handle collisions when positioning the popup. `side` controls overflow on the preferred placement axis (`top`/`bottom` or `left`/`right`): - `'flip'`: keep the requested side when it fits; otherwise try the opposite side (`top` and `bottom`, or `left` and `right`). - `'shift'`: never change side; keep the requested side and move the popup within the clipping boundary so it stays visible. - `'none'`: do not correct side-axis overflow. `align` controls overflow on the alignment axis (`start`/`center`/`end`): - `'flip'`: keep side, but swap `start` and `end` when the requested alignment overflows. - `'shift'`: keep side and requested alignment, then nudge the popup along the alignment axis to fit. - `'none'`: do not correct alignment-axis overflow. `fallbackAxisSide` controls fallback behavior on the perpendicular axis when the preferred axis cannot fit: - `'start'`: allow perpendicular fallback and try the logical start side first (`top` before `bottom`, or `left` before `right` in LTR). - `'end'`: allow perpendicular fallback and try the logical end side first (`bottom` before `top`, or `right` before `left` in LTR). - `'none'`: do not fallback to the perpendicular axis. When `side` is `'shift'`, explicitly setting `align` only supports `'shift'` or `'none'`. If `align` is omitted, it defaults to `'flip'`. @example ```jsx <Positioner collisionAvoidance={{ side: 'shift', align: 'shift', fallbackAxisSide: 'none', }} /> ```
No additional props. It forwards all standard HTML attributes to the underlying element.
CSS class applied to the element, or a function that returns a class based on the component's state.
Inherited from ComboboxTriggerProps
Whether the component should ignore user interaction.
Defaults to false.
Inherited from NativeButtonProps
Whether the component renders a native `<button>` element when replacing it via the `render` prop. Set to `false` if the rendered element is not a button (for example, `<div>`).
Defaults to true.
Inherited from ComboboxValueProps
Accepts a function that returns a `ReactNode` to format the selected value. Treat the value as read-only: in `multiple` mode it may be a shared frozen array when nothing is selected.
The placeholder value to display when no value is selected. This is overridden by `children` if specified, or by a null item's label in `items`.