RoadieRoadie
  • Home
  • Brand
  • Foundations
  • Content
  • Tokens
  • Components
  • Charts
  • Widgets
  • Appearance
HomeBrandFoundations
Appearance

Components

  • Navigation

    • Breadcrumb
    • LinkBeta
    • NavigatorAlpha
    • Steps
    • Tabs
  • Layout

    • Accordion
    • CollapsibleBeta
    • PaneAlpha
    • ScrollArea
    • Separator
  • Actions

    • Button
    • IconButton
    • ToggleBeta
    • Toggle groupBeta
    • ToolbarBeta
  • Fields

    • EditorAlpha
    • Field
    • Fieldset
    • Input
    • Label
    • Number fieldBeta
    • OTP fieldBeta
    • Query fieldAlpha
    • Textarea
  • Choices

    • Autocomplete
    • CheckboxBeta
    • Combobox
    • Radio group
    • Select
    • SliderBeta
    • SwitchBeta
  • Date and time

    • CalendarBeta
    • CalendarTile
    • Countdown
    • Dashboard periodBeta
    • Date fieldBeta
    • Date pickerBeta
    • Date range pickerBeta
    • DateTime
    • Duration
    • Time fieldBeta
  • Collections

    • Card
    • Carousel
    • DataTableBeta
    • ListAlpha
    • Marquee
    • RecordGridAlpha
    • RecordTableAlpha
    • SortableAlpha
    • TableBeta
  • Overlays

    • Dialog
    • Drawer
    • MenuBeta
    • Popover
    • ToastBeta
    • Tooltip
  • Status

    • Badge
    • CalloutBeta
    • DeltaBeta
    • Empty state
    • MeterBeta
    • ProgressBeta
    • SkeletonBeta
    • SparklineBeta
    • StatTileBeta
  • Media & brand

    • AvatarBeta
    • Icon Tile
    • Image
    • Logo
    • PatternBeta
    • QR codeBeta
    • SpotIllustration
  • Text

    • Code
    • Highlight
    • KbdBeta
    • Mark
    • Prose

Combobox

Status
Stable
Added
Components 2.0.08 Apr 2026
Updated
Components 2.16.020 Oct 2026
Docs updated
20 Oct 2026

A searchable dropdown for filtering and selecting from a list of options.

Import

import { Combobox } from '@oztix/roadie-components/combobox'

Examples

Default

function ComboboxDefault() {
const bands = [
'Powderfinger',
'Custard',
'Regurgitator',
'The Go-Betweens',

Emphasis

<Combobox>
<Combobox.InputGroup emphasis='normal'>
<Combobox.Input placeholder='Normal emphasis' />
<Combobox.Trigger />
</Combobox.InputGroup>
</Combobox>

Sizes

<Combobox>
<Combobox.InputGroup size='sm'>
<Combobox.Input placeholder='Small' />
<Combobox.Trigger />
</Combobox.InputGroup>
</Combobox>

States

{/* Default */}
<Combobox>
<Combobox.InputGroup>
<Combobox.Input placeholder='Search...' />
<Combobox.Trigger />
</Combobox.InputGroup>

Composition

With Field

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.

function ComboboxWithField() {
const bands = [
'Powderfinger',
'Custard',
'Regurgitator',
'Violent Soho',

With groups

function ComboboxWithGroups() {
const groups = [
{
value: 'Brisbane',
items: ['Powderfinger', 'Custard', 'Regurgitator', 'The Go-Betweens', 'The Saints'],
},

With rich items

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.

function ComboboxRichItems() {
const venues = [
{ name: 'Iguana Teapot Hall', location: 'Fortitude Valley, QLD' },
{ name: 'Clockwork Wattle Brewery', location: 'Newstead, QLD' },
{ name: 'Gooseberry Signal Warehouse', location: 'Fortitude Valley, QLD' },
{ name: 'Opal Harpoon Room', location: 'Fortitude Valley, QLD' },

Multiple selection

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.

function ComboboxMultiple() {
const genres = [
'Rock',
'Indie',
'Hip hop',
'Electronic',

Guidelines

When to use Combobox

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.

  • Venue or event search
  • Assignee pickers (team members from an API)
  • Tag or category selection with many options
  • Any list over ~15 items
  • Lists that load asynchronously

When to use Select instead

If the list is short, fixed, and fully known (under ~15 items), use Select. Users browse rather than search. No text input needed.

Combobox vs Autocomplete

If the user's typed value is always valid and suggestions just help, use Autocomplete. Think address fields or search bars.

QuestionSelectComboboxAutocomplete
User types to filter?NoYesYes
Must pick from the list?YesYesNo, typed value is valid
Options from an API?NoYesYes
Custom/free-text value?NoNoYes
Primary interactionBrowse and pickSearch and pickType with suggestions
Typical list size2-15 items10-500+ itemsAny

Filtering

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 items={bands}>
...
<Combobox.List>
{(band) => <Combobox.Item value={band}>{band}</Combobox.Item>}
</Combobox.List>
<Combobox.Empty>No results</Combobox.Empty>

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.

Async loading

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
items={results}
filter={null}
onInputValueChange={(value) => fetchResults(value)}
>
...

Chips

Name every chip and its remove button

<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.

Let the chips replace the placeholder

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.

Accessibility

  • Arrow keys move through the list; Enter picks the highlighted item and Escape closes the popup. Typing filters the list as you go.
  • Typing puts the closest matches first and highlights the first one, including matches that arrive later, so Enter picks it straight away. Opening the list without typing doesn't highlight the first match, so Enter can't pick a value nobody chose. While a match is highlighted, the arrows wrap at either end. Set autoHighlight={false} to highlight only what the user moves to, or autoHighlight='always' to highlight the first item with no text too.
  • The input points aria-activedescendant at the highlighted item, so screen readers read the first match as the list filters.
  • With 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.
  • With 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.
  • Use a <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.

Hooks

useFilter

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.

ParamTypeDescription
options.multiplebooleanWhether the combobox is in multiple selection mode. Default false.
options.valueanyThe current value, kept visible even while the query no longer matches it.
options.localeIntl.LocalesArgumentLocale for string comparison. Defaults to the runtime locale.

Returns a Filter:

FieldTypeDescription
contains(item, query, itemToString?) => booleanWhether the item matches the query anywhere.
startsWith(item, query, itemToString?) => booleanWhether the item starts with the query.
endsWith(item, query, itemToString?) => booleanWhether the item ends with the query.

API reference

Combobox

Base UI
formstring

Identifies the form that owns the internal input. Useful when the combobox is rendered outside the form.

filter((item: Item, query: string, itemToString?: ((item: Item) => string)) => boolean) | null

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.

idstring

The id of the component.

gridboolean

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.

inlineboolean

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.

disabledboolean

Whether the component should ignore user interaction.

Defaults to false.

namestring

Identifies the field when a form is submitted.

itemsreadonly any[] | readonly Group<any>[] | ComboboxItemCollection<Item, Value>

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.

readOnlyboolean

Whether the user should be unable to choose a different option from the popup.

Defaults to false.

requiredboolean

Whether the user must choose a value before submitting a form.

Defaults to false.

defaultOpenboolean

Whether the popup is initially open. To render a controlled popup, use the `open` prop instead.

Defaults to false.

openboolean

Whether the popup is currently open. Use when controlled.

onOpenChangeComplete((open: boolean) => void)

Event handler called after any animations complete when the popup is opened or closed.

openOnInputClickboolean

Whether the popup opens when clicking the input.

Defaults to true.

loopFocusboolean

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.

inputValuestring | number | readonly string[]

The input value of the combobox. Use when controlled.

defaultInputValuestring | number | readonly string[]

The uncontrolled input value when initially rendered. To render a controlled input, use the `inputValue` prop instead.

inputRefRef<HTMLInputElement>

A ref to the hidden input element.

filteredItemsreadonly Item[] | readonly Group<Item>[]

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.

virtualizedboolean

Whether the items are being externally virtualized.

Defaults to false.

modalboolean

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.

limitnumber

The maximum number of items to display in the list.

Defaults to -1.

localeLocalesArgument

The locale to use for string comparison. Defaults to the user's runtime locale.

autoHighlightboolean | "always"

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.

Combobox.Chip

Base UI
classNamestring | ((state: ComboboxChipState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

selectedboolean

Shows the chip selected while focus stays elsewhere, such as in the input while its values are edited.

Combobox.ChipLabel

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.ChipRemove

Base UI
classNamestring | ((state: ComboboxChipRemoveState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

aria-labelstring
Required

Names the value it removes, such as "Remove Rock".

Inherited from NativeButtonProps

nativeButtonboolean

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.

Combobox.Chips

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Clear

Base UI
classNamestring | ((state: ComboboxClearState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxClearProps

disabledboolean

Whether the component should ignore user interaction.

Defaults to false.

keepMountedboolean

Whether the component should remain mounted in the DOM when not visible.

Defaults to false.

Inherited from NativeButtonProps

nativeButtonboolean

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.

Combobox.Collection

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Empty

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Group

Base UI
classNamestring | ((state: ComboboxGroupState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxGroupProps

itemsreadonly any[]

Items to be rendered within this group. When provided, child `Collection` components will use these items.

Combobox.GroupLabel

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Input

Base UI
classNamestring | ((state: ComboboxInputState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxInputProps

disabledboolean

Whether the component should ignore user interaction.

Defaults to false.

Combobox.InputGroup

Base UI
classNamestring | ((state: ComboboxInputGroupState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

size"sm" | "md" | "lg" | null
intent"neutral" | "brand" | "brand-secondary" | "brand-blue" | "brand-orange" | "brand-purple" | "accent" | "danger" | "success" | "warning" | "info" | null
emphasis"normal" | "subtle" | null

Combobox.Item

Base UI
classNamestring | ((state: ComboboxItemState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxItemProps

onClick((event: BaseUIEvent<MouseEvent<HTMLDivElement, MouseEvent>>) => void)

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.

indexnumber

The index of the item in the list. Improves performance when specified by avoiding the need to calculate the index automatically from the DOM.

valueany

A unique value that identifies this item.

Defaults to null.

disabledboolean

Whether the component should ignore user interaction.

Defaults to false.

Inherited from NativeButtonProps

nativeButtonboolean

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.

Combobox.ItemIndicator

Base UI
classNamestring | ((state: ComboboxItemIndicatorState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxItemIndicatorProps

keepMountedboolean

Whether to keep the HTML element in the DOM when the item is not selected.

Defaults to false.

Combobox.Label

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.List

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Popup

Base UI
classNamestring | ((state: ComboboxPopupState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxPopupProps

initialFocusboolean | RefObject<HTMLElement | null> | ((openType: InteractionType) => boolean | void | HTMLElement | null)

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.

finalFocusboolean | RefObject<HTMLElement | null> | ((closeType: InteractionType) => boolean | void | HTMLElement | null)

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.

Combobox.Portal

Base UI
classNamestring | ((state: ComboboxPortalState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxPortalProps

keepMountedboolean

Whether to keep the portal mounted in the DOM while the popup is hidden.

Defaults to false.

containerHTMLElement | ShadowRoot | RefObject<HTMLElement | ShadowRoot | null> | null

A parent element to render the portal element into.

Combobox.Positioner

Base UI
classNamestring | ((state: ComboboxPositionerState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from UseAnchorPositioningSharedParameters

anchorElement | VirtualElement | RefObject<Element | null> | (() => Element | VirtualElement | null) | null

An element to position the popup against. By default, the popup will be positioned against the trigger.

positionMethod"absolute" | "fixed"

Determines which CSS `position` property to use.

Defaults to 'absolute'.

side"top" | "bottom" | "left" | "right" | "inline-end" | "inline-start"

Which side of the anchor element to align the popup against. May automatically change to avoid collisions.

Defaults to 'bottom'.

sideOffsetnumber | OffsetFunction

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.

align"center" | "start" | "end"

How to align the popup relative to the specified side.

Defaults to 'center'.

alignOffsetnumber | OffsetFunction

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.

collisionBoundaryBoundary

An element or a rectangle that delimits the area that the popup is confined to.

Defaults to 'clipping-ancestors'.

collisionPaddingPadding

Additional space to maintain from the edge of the collision boundary.

Defaults to 5.

stickyboolean

Whether to maintain the popup in the viewport after the anchor element was scrolled out of view.

Defaults to false.

arrowPaddingnumber

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.

disableAnchorTrackingboolean

Whether to disable the popup from tracking any layout shift of its positioning anchor.

Defaults to false.

collisionAvoidanceCollisionAvoidance

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', }} /> ```

Combobox.Status

Base UI

No additional props. It forwards all standard HTML attributes to the underlying element.

Combobox.Trigger

Base UI
classNamestring | ((state: ComboboxTriggerState) => string)

CSS class applied to the element, or a function that returns a class based on the component's state.

Inherited from ComboboxTriggerProps

disabledboolean

Whether the component should ignore user interaction.

Defaults to false.

Inherited from NativeButtonProps

nativeButtonboolean

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.

Combobox.Value

Base UI

Inherited from ComboboxValueProps

childrenReactNode | ((selectedValue: any) => ReactNode)

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.

placeholderReactNode

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`.

Previous page← CheckboxNext pageRadio group →