Skip to main content

Select

A headless, fully accessible dropdown component that allows users to choose a single value from a list of options with complete WAI-ARIA Listbox pattern implementation.

Select does not include dedicated trigger-icon or selected-indicator primitives. Add any chevron, caret, or selected marker directly inside Select.Trigger and Select.Item so the visual layer stays fully application-owned.

Pair it with the Field primitive to get label, description, and error-message wiring with coordinated ARIA IDs — Select reads the enclosing Field's invalid, disabled, required, and readOnly state automatically.

Live Demo​

JavaScript
<Field.Root className='select-demo-container' invalid>
<Field.Label className='select-label'>Plan</Field.Label>
<Select.Root defaultValue="basic">
  <Select.Trigger className='select-trigger' placeholder='Choose a plan' />
  <Select.Content className='select-content'>
    <Select.Viewport className='select-viewport'>
      <Select.Item className='select-item' value='basic' label='Basic'>
        Basic
        <span aria-hidden='true' className='select-item-check'>✓</span>
      </Select.Item>
      <Select.Item className='select-item' value='premium' label='Premium'>
        Premium
        <span aria-hidden='true' className='select-item-check'>✓</span>
      </Select.Item>
      <Select.Item className='select-item' value='enterprise' label='Enterprise'>
        Enterprise
        <span aria-hidden='true' className='select-item-check'>✓</span>
      </Select.Item>
    </Select.Viewport>
    <Select.Arrow className='select-arrow' />
  </Select.Content>
</Select.Root>
<Field.Description className='select-description'>
  Pick the subscription tier you want.
</Field.Description>
<Field.ErrorMessage className='select-error'>
  Plan is required.
</Field.ErrorMessage>
</Field.Root>

The live demo shows the recommended pattern: a Field wrapper supplying label, helper text, and error message wiring around the Select primitive — with a custom chevron in the trigger and a checkmark inside each item to illustrate how visual indicators are composed manually.

Features​

  • ✅ Single-value selection (value: string)
  • ✅ Controlled and uncontrolled usage (value/defaultValue, open/defaultOpen)
  • ✅ Reads validation, disabled, required, and read-only state from a parent Field automatically (direct props still override)
  • ✅ Built-in typeahead search (default 700ms buffer)
  • ✅ Positioning with useFloating (offset, flip, shift, hide)
  • ✅ Form integration (generates a hidden input when name is provided)
  • ✅ Portal-based content rendering (container or document.body)
  • ✅ Grouping lists with groups, labels, and separators
  • ✅ Optional scrollable Select.Viewport that keeps the highlighted option in view
  • ✅ Disabling at the Root or Item level
  • ✅ Compound structure built around Root/Trigger/Content/Item

Import​

import { Field, Select } from '@turkish-technology/spar';

Select and Select.Root refer to the same component — the difference is only notation style. Label, description, and error message are owned by the Field primitive when you need them:

<Field.Root>
<Field.Label />
<Select.Root>
<Select.Trigger placeholder="Choose..." />
<Select.Content>{/* items */}</Select.Content>
</Select.Root>
<Field.Description />
<Field.ErrorMessage />
</Field.Root>

Anatomy​

Select is built as a compound component:

Parts
RootMain container managing state and context
TriggerButton that toggles dropdown visibility and displays selected value or placeholder
ContentDropdown container with smart positioning
ViewportOptional scrollable region wrapping the options
GroupGroups related items together
LabelLabel for item groups
ItemIndividual selectable option
SeparatorPresentational (aria-hidden) divider between items/groups
ArrowOptional arrow pointing to trigger

Structure​

<Select.Root>
<Select.Trigger placeholder="Choose..." />

<Select.Content>
<Select.Viewport>
<Select.Group>
<Select.Label />
<Select.Item value="..." label="...">
...
</Select.Item>
</Select.Group>

<Select.Separator />
</Select.Viewport>
<Select.Arrow />
</Select.Content>
</Select.Root>

Select.Viewport is optional — omit it for short lists. Wrap the items in a viewport when the list can grow long enough to need a bounded, scrollable area. Keep the Select.Arrow outside the viewport so it stays pinned while the options scroll.

Data Flow:

  • Select.Root manages open/closed state and the selected value, and provides context.
  • Select.Trigger toggles the Root state, displays the selected item's label or the placeholder, and sets the focus strategy for Content on arrow-key input.
  • Select.Content renders into a portal when open and manages highlight state and keyboard navigation.
  • Select.Viewport is an optional scrollable wrapper around the options; it only bounds the height and provides the scroll region. Keeping the highlighted item in view during keyboard navigation and typeahead is handled by Select.Item, which scrolls itself into the nearest scrollable region (the viewport when present), so it works with or without a viewport.
  • Select.Item updates the selection and changes the Root value through click or keyboard interaction. The label prop registers the text used for typeahead and for display in the Trigger.
  • Select.Group + Select.Label establish the semantic group structure.
  • Select.Separator is a purely visual divider. It renders role="presentation" + aria-hidden="true" by default, because a listbox may only own option/group children (aria-required-children); pass role='separator' to expose it when the divider carries meaning.
  • Select.Arrow is an optional arrow positioned relative to the Content placement.

Alternative: Tree-shakeable named imports

import { SelectRoot, SelectTrigger } from '@turkish-technology/spar';

<SelectRoot>
<SelectTrigger placeholder="Choose..." />
{/* ... */}
</SelectRoot>;

Custom Visual Composition​

Select does not include a separate icon/indicator primitive. The trigger arrow or selected marker is added as a normal React element inside the existing parts.

<Select.Trigger className='select-trigger' placeholder='Choose an option'>
<span aria-hidden='true' className='select-trigger-addon'>
▾
</span>
</Select.Trigger>

<Select.Item className='select-item' value='option1' label='Option 1'>
Option 1
<span aria-hidden='true' className='select-item-check'>
✓
</span>
</Select.Item>

Code Examples​

Basic Controlled Select​

Basic example where the open state and selected value are controlled by the parent component:

function ControlledSelect() {
const [selectedFruit, setSelectedFruit] = React.useState('');
const [open, setOpen] = React.useState(false);

return (
<Select.Root
value={selectedFruit}
onChange={setSelectedFruit}
open={open}
onOpenChange={setOpen}
>
<Select.Trigger placeholder="Choose a fruit" />

<Select.Content>
<Select.Item value="apple" label="Apple">
Apple
</Select.Item>
<Select.Item value="banana" label="Banana">
Banana
</Select.Item>
<Select.Item value="orange" label="Orange">
Orange
</Select.Item>
</Select.Content>
</Select.Root>
);
}

Grouped Items with Labels​

You can section options with Group + Label + Separator:

function GroupedSelect() {
const [value, setValue] = React.useState('');

return (
<Select.Root value={value} onChange={setValue}>
<Select.Trigger placeholder="Select a country" />

<Select.Content>
<Select.Group>
<Select.Label>North America</Select.Label>
<Select.Item value="us" label="United States">
United States
</Select.Item>
<Select.Item value="ca" label="Canada">
Canada
</Select.Item>
<Select.Item value="mx" label="Mexico">
Mexico
</Select.Item>
</Select.Group>

<Select.Separator />

<Select.Group>
<Select.Label>Europe</Select.Label>
<Select.Item value="uk" label="United Kingdom">
United Kingdom
</Select.Item>
<Select.Item value="de" label="Germany">
Germany
</Select.Item>
<Select.Item value="fr" label="France">
France
</Select.Item>
</Select.Group>
</Select.Content>
</Select.Root>
);
}

Scrollable Select​

Wrap the options in Select.Viewport to keep a long list within a bounded, scrollable area. The Viewport is headless — set a max-height and overflow via CSS to enable scrolling. Keyboard navigation and typeahead automatically keep the highlighted option in view. Keep Select.Arrow outside the viewport so it stays pinned while the options scroll.

JavaScript
<Select.Root defaultValue='utc'>
<Select.Trigger className='select-scroll-trigger' placeholder='Choose a timezone' />
<Select.Content className='select-scroll-content'>
  <Select.Viewport className='select-scroll-viewport'>
    <Select.Item className='select-scroll-item' value='utc' label='UTC'>UTC</Select.Item>
    <Select.Item className='select-scroll-item' value='london' label='London (GMT)'>London (GMT)</Select.Item>
    <Select.Item className='select-scroll-item' value='paris' label='Paris (CET)'>Paris (CET)</Select.Item>
    <Select.Item className='select-scroll-item' value='istanbul' label='Istanbul (TRT)'>Istanbul (TRT)</Select.Item>
    <Select.Item className='select-scroll-item' value='moscow' label='Moscow (MSK)'>Moscow (MSK)</Select.Item>
    <Select.Item className='select-scroll-item' value='dubai' label='Dubai (GST)'>Dubai (GST)</Select.Item>
    <Select.Item className='select-scroll-item' value='karachi' label='Karachi (PKT)'>Karachi (PKT)</Select.Item>
    <Select.Item className='select-scroll-item' value='dhaka' label='Dhaka (BST)'>Dhaka (BST)</Select.Item>
    <Select.Item className='select-scroll-item' value='bangkok' label='Bangkok (ICT)'>Bangkok (ICT)</Select.Item>
    <Select.Item className='select-scroll-item' value='singapore' label='Singapore (SGT)'>Singapore (SGT)</Select.Item>
    <Select.Item className='select-scroll-item' value='tokyo' label='Tokyo (JST)'>Tokyo (JST)</Select.Item>
    <Select.Item className='select-scroll-item' value='sydney' label='Sydney (AEST)'>Sydney (AEST)</Select.Item>
    <Select.Item className='select-scroll-item' value='auckland' label='Auckland (NZST)'>Auckland (NZST)</Select.Item>
  </Select.Viewport>
  <Select.Arrow className='select-scroll-arrow' />
</Select.Content>
</Select.Root>

With Field (label, description, error)​

Wrap Select with Field to attach a label, helper text, and an error message. The trigger's aria-labelledby and aria-describedby are wired automatically through Field context, and invalid / disabled / required / readOnly propagate down to the trigger and the hidden form input.

function FieldSelect() {
const [plan, setPlan] = React.useState('');

return (
<Field.Root invalid={plan === ''} required>
<Field.Label>Plan</Field.Label>
<Select.Root value={plan} onChange={setPlan} name="plan">
<Select.Trigger placeholder="Choose a plan" />
<Select.Content>
<Select.Item value="basic" label="Basic">
Basic
</Select.Item>
<Select.Item value="premium" label="Premium">
Premium
</Select.Item>
</Select.Content>
</Select.Root>
<Field.Description>
Choose the tier you want to subscribe to.
</Field.Description>
<Field.ErrorMessage>Plan is required.</Field.ErrorMessage>
</Field.Root>
);
}

When the enclosing Field is invalid, the trigger receives aria-invalid="true" and its aria-describedby points to the rendered Field.ErrorMessage instead of Field.Description.

Disabled and Read-only via Field​

disabled and readOnly propagate from Field. A read-only Select can still be opened and inspected, but its value cannot change.

function ReadOnlyField() {
return (
<Field.Root readOnly>
<Field.Label>Region</Field.Label>
<Select.Root defaultValue="eu-west-1">
<Select.Trigger />
<Select.Content>
<Select.Item value="eu-west-1" label="EU (Ireland)">
EU (Ireland)
</Select.Item>
<Select.Item value="us-east-1" label="US (N. Virginia)">
US (N. Virginia)
</Select.Item>
</Select.Content>
</Select.Root>
<Field.Description>Locked to your billing region.</Field.Description>
</Field.Root>
);
}

Form Integration​

When name is provided, Root generates a hidden input for the selected value.

function SelectInForm() {
const [category, setCategory] = React.useState('');

const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
event.preventDefault();
const formData = new FormData(event.currentTarget);
console.log('Category:', formData.get('category'));
};

return (
<form onSubmit={handleSubmit}>
<label htmlFor="category-select">Product Category</label>
<Select.Root
name="category"
value={category}
onChange={setCategory}
required
>
<Select.Trigger id="category-select" placeholder="Select category" />

<Select.Content>
<Select.Item value="electronics" label="Electronics">
Electronics
</Select.Item>
<Select.Item value="clothing" label="Clothing">
Clothing
</Select.Item>
<Select.Item value="books" label="Books">
Books
</Select.Item>
</Select.Content>
</Select.Root>
<button type="submit">Submit</button>
</form>
);
}

API Reference​

Select / Select.Root​

Provides the root state and context. Select and Select.Root are the same component - the difference is only import/notation style.

Props

NameTypeDefaultDescription
id?stringundefinedBase id for ARIA relationship ids
value?stringundefinedControlled selected value
defaultValue?stringundefinedInitial uncontrolled value
onChange?(value: string) => voidundefinedValue change callback
open?booleanundefinedControlled open/closed state
defaultOpen?booleanfalseInitial uncontrolled open state
onOpenChange?(open: boolean) => voidundefinedOpen/closed change callback
invalid?booleanfalseValidation state; inherited from a parent Field when present
disabled?booleanfalseDisables the entire Select; inherited from Field when present
required?booleanfalseMarks the field as required; inherited from Field when present
readOnly?booleanfalseRead-only state; inherited from Field when present
name?stringundefinedForm field name; generates a hidden input when value is defined
dir?'ltr' | 'rtl''ltr'Writing direction
autoFocus?booleanfalseFocuses the trigger on mount
as?React.ElementType'div'Polymorphic element for Root
children?React.ReactNodeundefinedRoot content

Events

NameParametersDescriptionWhen Triggered
onChange(value: string)Selected value changesWhen an item is selected or controlled state is updated
onOpenChange(open: boolean)Open/closed state changesOn trigger interaction or programmatic open/close calls

HTML Attributes

AttributeValuePurpose
data-invalid""Added when Root (or the enclosing Field) is in an invalid state
data-disabled""Added when Root (or the enclosing Field) is disabled
data-required""Added when Root (or the enclosing Field) is required
data-readonly""Added when Root (or the enclosing Field) is read-only
data-autofocus""Added when autoFocus is true

Select.Trigger​

Trigger part that opens and closes the root state.

Props

NameTypeDefaultDescription
placeholder?stringundefinedText shown when no value is selected
children?React.ReactNode | ((state: SelectTriggerRenderProps) => React.ReactNode)undefinedNormal content or a render-props function
as?React.ElementType'button'Polymorphic element for Trigger
disabled?booleanRoot disabled valueTrigger disabled value; falls back to Root if omitted
autoFocus?booleanRoot autoFocus valueAutofocus at the button level
isLoading?booleanfalseButton loading state (ButtonOwnProps)
isPressed?booleanundefinedButton toggle state (ButtonOwnProps)
onPressedChange?(pressed: boolean) => voidundefinedButton toggle change callback
ref?React.Ref<HTMLElement>undefinedForwarded ref
...propsButtonProps-Other HTML/ARIA props inherited from Button

Render Props (SelectTriggerRenderProps)

PropertyTypeDescription
isOpenbooleanWhether the dropdown is currently visible
valuestring | undefinedThe currently selected value
labelstring | undefinedThe label of the currently selected item
disabledbooleanWhether the trigger is disabled
open() => voidFunction to programmatically open the dropdown
close() => voidFunction to programmatically close the dropdown
toggle() => voidFunction to programmatically toggle the dropdown

Events

NameParametersDescriptionWhen Triggered
onClick(event: React.MouseEvent<HTMLElement>)Trigger click/activation callbackAfter mouse click or Button activation
onKeyDown(event: React.KeyboardEvent<HTMLElement>)Trigger keydown callbackOn every keydown event, before internal handling
onFocus(event: React.FocusEvent<HTMLElement>)Button focus callbackWhen the trigger receives focus
onBlur(event: React.FocusEvent<HTMLElement>)Button blur callbackWhen the trigger loses focus

HTML Attributes

AttributeValuePurpose
role"combobox"Trigger semantic role
aria-haspopup"listbox"Type of panel that opens
aria-expandedbooleanOpen/closed state
aria-controlsstringId of the content element
aria-labelledbystringReferences the Field label id when inside Field; omitted standalone (use aria-label)
aria-describedbystringPoints to Field.Description, or Field.ErrorMessage while invalid is true
aria-requiredtrueAdded when Root required is true
aria-invalidtrueAdded when Root (or the enclosing Field) is in an invalid state
aria-readonlytrueAdded when Root (or the enclosing Field) is read-only
idstringEquals the Field's fieldId when wrapped in a Field, so Field.Label htmlFor lands on the trigger
data-state"open" | "closed"Open/closed state
data-invalid""Added when invalid (own prop or inherited from Field)
data-required""Added when required (own prop or inherited from Field)
data-readonly""Added when read-only (own prop or inherited from Field)
data-placeholder""Added when there is no selected value
data-disabled""Button disabled state
data-loading""Button loading state
data-pressed""Button toggle pressed state
data-autofocus""Button autofocus state

Select.Content​

Popup content layer. It does not render when closed.

Props

NameTypeDefaultDescription
side?'top' | 'right' | 'bottom' | 'left''bottom'Preferred placement side
align?'start' | 'center' | 'end''center'Alignment relative to the Trigger
container?HTMLElement | nulldocument.bodyPortal target
onEscapeKeyDown?(event: KeyboardEvent) => voidundefinedEscape key callback (preventDefault can stop closing)
onPointerDownOutside?(event: PointerEvent) => voidundefinedOutside click callback (preventDefault can stop closing)
onCloseAutoFocus?(event: FocusEvent) => voidundefinedCalled before focus returns to the Trigger (preventDefault keeps focus put)
as?React.ElementType'div'Polymorphic element for Content
ref?React.Ref<HTMLElement>undefinedForwarded ref
children?React.ReactNodeundefinedContent children

Events

NameParametersDescriptionWhen Triggered
onKeyDown(event: React.KeyboardEvent<HTMLDivElement>)Content keydown callbackWhen keydown occurs while Content is focused
onEscapeKeyDown(event: KeyboardEvent)Escape callbackWhen Escape is pressed while Content is focused
onPointerDownOutside(event: PointerEvent)Outside click callbackWhen pointer down happens outside Trigger/Content
onCloseAutoFocus(event: FocusEvent)Focus-return callbackWhen Content closes from inside (Escape, Enter/Space, Tab, item click), right before focus returns to the Trigger. Not called for outside-pointer dismissal, which moves no focus

HTML Attributes

AttributeValuePurpose
idstringARIA connection to the Trigger
role"listbox"Listbox semantics
aria-labelledbystringReference to the Trigger id
tabIndex-1Programmatic focus for the popup panel
data-state"open"Content renders only while open
data-side"top" | "right" | "bottom" | "left"Computed floating side
data-align"start" | "center" | "end"Computed floating alignment

Positioning Notes

  • useFloating middleware: offset(8), flip(), shift({ padding: 8 }), hide()
  • minWidth is matched to the trigger width
  • Select.Arrow is positioned automatically through context when rendered inside Content

Select.Viewport​

An optional scrollable region that wraps the options. Use it when the list can grow long enough to need a bounded, scrollable area. Headless: renders a plain element with no visual opinions — apply a max-height and overflow (e.g. overflow-y: auto) via className/style to enable scrolling.

The Viewport is purely presentational — it just provides the bounded, scrollable box. Keeping the highlighted option visible during keyboard navigation and typeahead is handled by Select.Item, which scrolls itself into its nearest scrollable ancestor (this Viewport when present). It works the same whether or not a Viewport is used. Keep Select.Arrow as a sibling outside the Viewport so it stays pinned while the options scroll.

Defaults to role="presentation" so it stays transparent in the accessibility tree, preserving the listbox → option structure. Override role if you need different semantics.

Props

NameTypeDefaultDescription
as?React.ElementType'div'Polymorphic element type to render
role?string'presentation'ARIA role for the viewport element
ref?React.Ref<HTMLElement | null>undefinedForwarded ref to the viewport element
children?React.ReactNodeundefinedOptions, groups, labels, and separators
...propsHTMLAttributes-All standard element attributes (className, style, etc.)

Events

NameParametersDescriptionWhen Triggered
--No interactive eventsViewport is a non-interactive wrapper

HTML Attributes

AttributeValuePurpose
role'presentation'Keeps the viewport transparent in the a11y tree

Select.Item​

Selectable option part.

Props

NameTypeDefaultDescription
valuestring-Item value (required)
disabled?booleanfalseDisables the item
label?stringundefinedText label — shown in the Trigger when selected, and used for typeahead
children?React.ReactNode | ((state: SelectItemRenderProps) => React.ReactNode)undefinedNormal content or render-props
as?React.ElementType'div'Polymorphic element for Item
ref?React.Ref<HTMLElement>undefinedForwarded ref

Render Props (SelectItemRenderProps)

PropertyTypeDescription
isSelectedbooleanWhether this item is currently selected
isHighlightedbooleanWhether this item is currently highlighted
disabledbooleanWhether this item is disabled
select() => voidFunction to programmatically select this item

Events

NameParametersDescriptionWhen Triggered
onClick(event: React.MouseEvent<HTMLDivElement>)Item click callbackWhen the item is clicked (selection occurs unless preventDefault is used)
onPointerMove(event: React.PointerEvent<HTMLDivElement>)Pointer move callbackWhen the pointer moves over the item (updates highlight state)

HTML Attributes

AttributeValuePurpose
role"option"Option semantics
aria-selectedbooleanSelected item state
aria-disabledtrueAdded when the item is disabled
data-state"checked" | "unchecked"Selected/unselected state
data-disabled""Added when the item is disabled
data-highlighted""Added when the item is highlighted

Select.Group​

Item grouping part.

Props

NameTypeDefaultDescription
as?React.ElementType'div'Polymorphic element for Group
children?React.ReactNodeundefinedGroup content

Events

NameParametersDescriptionWhen Triggered
--No component-specific events on the Group part-

HTML Attributes

AttributeValuePurpose
role"group"Group semantics
aria-labelledbystringReference to the group label id

Select.Label​

Group label part.

Props

NameTypeDefaultDescription
as?React.ElementType'label'Polymorphic element for Label
children?React.ReactNodeundefinedLabel content

Events

NameParametersDescriptionWhen Triggered
--No component-specific events on the Label part-

HTML Attributes

AttributeValuePurpose
idstringReceives the labelId generated by Group

Select.Separator​

Visual divider between groups or items. It is presentational by default: a listbox may only own option/group children, so exposing role="separator" inside Content would fail aria-required-children.

Props

NameTypeDefaultDescription
as?React.ElementType'div'Polymorphic element for Separator
role?string'presentation'Pass 'separator' (plus aria-orientation if needed) to expose the divider to AT
aria-hidden?booleantrueDefaults to true only while role is 'presentation'; omitted for any other role
children?React.ReactNodeundefinedOptional content

Events

NameParametersDescriptionWhen Triggered
--No component-specific events on the Separator part-

HTML Attributes

AttributeValuePurpose
role"presentation"Keeps the divider out of the listbox's owned children
aria-hidden"true"Hides the divider from assistive technology (by default)

Select.Arrow​

Optional arrow part positioned according to the Content/Trigger placement.

Props

NameTypeDefaultDescription
as?React.ElementType'svg'Polymorphic element for Arrow
ref?React.Ref<Element>undefinedForwarded ref
children?React.ReactNodeundefinedCustom content instead of the default polygon when using svg
className?stringundefinedClass name
style?React.CSSPropertiesundefinedStyle override

Events

NameParametersDescriptionWhen Triggered
--No component-specific events on the Arrow part-

HTML Attributes

AttributeValuePurpose
aria-hidden"true"Hides it from assistive technologies
data-placement"top" | "top-start" | ... | "left-end"Provides computed placement information
width10Only for the default svg
height5Only for the default svg
viewBox"0 0 10 5"Only for the default svg

Note: For arrow positioning, Select.Arrow should be used inside Select.Content.

SelectTriggerRenderProps​

NameTypeDescription
isOpenbooleanRoot open/closed state
valuestring | undefinedSelected value
labelstring | undefinedSelected item label
disabledbooleanTrigger disabled state
open() => voidOpen programmatically
close() => voidClose programmatically
toggle() => voidToggle programmatically

SelectItemRenderProps​

NameTypeDescription
isSelectedbooleanWhether the item is selected
isHighlightedbooleanWhether the item is highlighted
disabledbooleanWhether the item is disabled
select() => voidFunction to select programmatically

Keyboard Interactions​

Keyboard behavior in the current implementation:

KeyActionContextNotes
Enter / SpaceToggle open/closeTrigger focusedWorks through the Button activation flow
ArrowDownOpen and set focus strategy to the selected/first itemTrigger focusedOnly opens when currently closed
ArrowUpOpen and set focus strategy to the selected/first itemTrigger focusedOnly opens when currently closed
EscapeClose and return focus to TriggerContent focusedUnless preventDefault is used in onEscapeKeyDown; onCloseAutoFocus can veto the focus return
Enter / SpaceSelect the highlighted item, close, and focus TriggerContent focusedNo selection happens if nothing is highlighted
ArrowDownHighlight the next enabled itemContent focusedWraps from the end of the list to the start
ArrowUpHighlight the previous enabled itemContent focusedWraps from the start of the list to the end
Home / PageUpHighlight the first enabled itemContent focused-
End / PageDownHighlight the last enabled itemContent focused-
TabClose the ContentContent focusedCalls event.preventDefault()
A-Z / a-zHighlight the matching enabled item via typeaheadContent focusedDefault timeout is 700ms