---
title: "Combobox field"
description: "Lets people find one value by typing, as a field of a form — a combobox, with a list of options that narrows as they type and that they choose from or, where the product allows it, a value of their own, under a label that can say the field is required or optional, with a line of help and the reason a value was refused."
url: "https://tanrei.chnotchy.com/components/combobox-field/"
last_updated: 2026-10-23T21:17:12.000Z
---

# Combobox field

> Lets people find one value by typing, as a field of a form — a combobox, with a list of options that narrows as they type and that they choose from or, where the product allows it, a value of their own, under a label that can say the field is required or optional, with a line of help and the reason a value was refused.

## Overview

Use a combobox field wherever a form asks for one value that people would rather type than scroll to: a city out of hundreds, a person, a token. It also serves a field that suggests values and takes one of the person’s own, such as a font family. It is the ordinary case, ready to use: a label, the box with its list, a line of help and the words for a wrong value. The box is drawn and measured as the text field’s of the same variant and size, and the list is drawn as a select’s.

**Built from** a [field](https://tanrei.chnotchy.com/components/field/) and a [combobox](https://tanrei.chnotchy.com/components/combobox/). The field is the frame: the label, the required or optional mark, the help and the error. The combobox is the control: the box, the text typed in it, and the list with its options. The combobox field draws nothing of its own and has no token: every property it has is a property of one of the two, given to it unchanged, and the options you give it are its combobox’s.

It is a block as wide as the place it is put in, and its box fills it. It has no width of its own: for a narrower field, give it a narrower place. Its width never follows its options or its value, because a person types into it before any option is known.

On the web it is `<tanrei-combobox-field>` with `<tanrei-option>` children, the elements a [select](https://tanrei.chnotchy.com/components/select/) holds. The other platforms have not implemented it yet.

### Usage

A combobox field holds what its combobox holds, which is two things. `value` is the committed choice: the chosen option’s value, or a custom text. `inputValue` is the text in the input. The value changes only when the person chooses an option, commits the text (Enter with no option active, or leaving the field) or presses the clear button; typing and moving through the list never change it.

**Web**

```html
<form>
  <tanrei-combobox-field name="city" label="City" value="tokyo" required required-text="Required"
    clearable clear-label="Clear city" empty-text="No matches">
    <tanrei-option value="kyoto">Kyoto</tanrei-option>
    <tanrei-option value="tokyo">Tokyo</tanrei-option>
  </tanrei-combobox-field>
</form>

<!-- The box alone, where a label stands elsewhere: a combobox, named by its own label. Importing the combobox field defines it. -->
<tanrei-combobox label="Token" placeholder="Find a token" no-chevron style="inline-size: 16rem">
  <tanrei-option value="primary">primary</tanrei-option>
</tanrei-combobox>

<!-- The options are suggestions: a text that names none becomes the value. -->
<tanrei-combobox-field label="Font family" value="Recursive" allow-custom-value>
  <tanrei-option value="Inter">Inter</tanrei-option>
</tanrei-combobox-field>

<!-- You filter: on input, from a server. The status row says what your source is doing. -->
<tanrei-combobox-field id="assignee" label="Assignee" filter="none" no-chevron placeholder="Find a person">
  <span slot="leading-icon">person_search</span>
</tanrei-combobox-field>

<script type="module">
  import '@tanrei/web/components/combobox-field';

  const assignee = document.querySelector('#assignee');
  // The person changed the text. The combobox does not delay or drop this event: debounce it yourself.
  assignee.addEventListener('input', async () => {
    assignee.status = 'loading';
    assignee.statusText = 'Loading people';
    const people = await find(assignee.inputValue);
    assignee.replaceChildren(...people.map(option));
    assignee.status = 'idle';
    assignee.statusText = `${people.length} of ${total} people shown`;
  });
  // The committed value changed. The value is already the new one.
  assignee.addEventListener('change', (e) => save(e.detail.value));
  // Opened or closed by the person; a close says why. It does not bubble: listen on the field itself.
  assignee.addEventListener('toggle', (e) => console.log(e.detail.open, e.detail.reason));
</script>
```

**React**

```tsx
import { ComboboxField, Option } from '@tanrei/react';

<ComboboxField label="City" value={city} clearable clearLabel="Clear city" emptyText="No matches" onChange={(event) => setCity(event.detail.value)}>
  <Option value="kyoto">Kyoto</Option>
  <Option value="tokyo">Tokyo</Option>
</ComboboxField>
```

### One level down

A combobox field is a [field](https://tanrei.chnotchy.com/components/field/) with a [combobox](https://tanrei.chnotchy.com/components/combobox/) in it. Write the two yourself where you need something the field does not offer — something of your own between the label and the box, or below the help. The picture, the name, the description and the states are the same.

```html
<!-- The combobox field -->
<tanrei-combobox-field name="city" label="City" required required-text="Required"
  supporting-text="Where the order is sent." value="tokyo">
  <tanrei-option value="kyoto">Kyoto</tanrei-option>
  <tanrei-option value="tokyo">Tokyo</tanrei-option>
</tanrei-combobox-field>

<!-- The same, by hand: the frame's properties on the field, everything else — and the options — on the combobox -->
<tanrei-field label="City" required required-text="Required" supporting-text="Where the order is sent.">
  <tanrei-combobox name="city" value="tokyo">
    <tanrei-option value="kyoto">Kyoto</tanrei-option>
    <tanrei-option value="tokyo">Tokyo</tanrei-option>
  </tanrei-combobox>
</tanrei-field>
```

What differs is where the form’s control is: by hand it is the combobox, which takes the `name`; in the combobox field it is the field.

## Specs

### The field

| Part | What it is |
| --- | --- |
| Label | The field’s row above the container (`stacked`), or the combobox’s own label floating inside it (`filled`, `outlined`). It is the accessible name, drawn or hidden with `labelHidden` |
| Requirement mark | After the label: the requirement tag in its required form, an asterisk or nothing for `required`; the requirement tag in its optional form for `optional`. A floating label takes the asterisk |
| Input | The text: what the person types to find an option and, while they are not typing, the chosen option’s label or the custom value. One line, which scrolls |
| Placeholder | A hint shown while the input is empty. Never a label, and never a value |
| Leading icon | The glyph in the `leading-icon` slot, or else the chosen option’s own |
| Clear button | With `clearable`, while the text is not empty: empties the text and the value |
| Chevron | Says that the field has a list to look through, and opens and closes it. It does not turn. Leave it out (`chevron` false) where suggestions exist only for what was typed |
| Supporting text | The field’s row: a line of help. While `error` is true `errorText` takes its place (below it, where the design system keeps both). Both start where the input’s text starts |

The label row, the mark and the supporting row are the [field](https://tanrei.chnotchy.com/components/field/)’s, drawn from the field’s tokens; everything else is the [combobox](https://tanrei.chnotchy.com/components/combobox/)’s. The three variants and the three sizes, `small` (32), `medium` (40) and `large` (56), are the text field’s. The default system ships `stacked` only.

While the list is open, the label and the help are drawn focused with the box, whether or not the input has focus.

### The list

The list opens `comp.combobox.list.offset` below the container, exactly as wide as it, and above it where there is no room below. It is as tall as its rows up to `list.max-height` (320), and scrolls beyond that.

| Part | What it is |
| --- | --- |
| Option | A row with a label, and optionally a supporting line and a glyph. The chosen one has a quiet fill and a check |
| Match | With `filter="contains"`, the part of each label that matched the text is drawn heavier |
| Group | A run of options under an optional title. A group the filter leaves empty is not drawn |
| Status row | After the options: `statusText`, a loading indicator while `status` is `loading`, the failure while it is `error`, or `emptyText` where nothing matched |

`filter="contains"` shows the options whose label contains the text, whatever the case, the width of a character or the marks on a letter. With `filter="none"` the combobox shows every option you give it and you filter, on `input`. The combobox never fetches, waits, sorts or ranks.

### Typing, moving and choosing

| Input | What happens |
| --- | --- |
| Typing | Edits the text and opens the list, filtered. The first match is the active option, read out once typing pauses; with `allowCustomValue` none is |
| Down Arrow, Up Arrow, list closed; the chevron | Opens the list with every option. The chosen option is the active one, or the first enabled one |
| Down Arrow, Up Arrow, list open | The next or previous option, across groups, going round at the ends — through the text, where `allowCustomValue` is set — unless `wrap` is false |
| Page Down, Page Up | Ten options down or up |
| Home, End, Left Arrow, Right Arrow | Move the caret in the text |
| Enter, an option active; a press on an option | Chooses it and closes the list. It does not submit a form |
| Enter, no option active | Commits the text, emits `action`, and submits the form unless `action` is cancelled |
| Escape | Closes an open list and keeps the text. Pressed again, restores the committed value’s text. It never clears a value |
| Tab; a press outside | Leaves the field: the text is resolved and the list closes. The active option is not chosen |
| A press on the label | Moves focus to the input and opens nothing. While the list is open it is a press outside the combobox: the list closes, and focus stays in the input |

Leaving the field resolves the text: the combobox decides which value the text stands for. An empty text empties the value. The whole label of an option chooses that option. Any other text becomes the value with `allowCustomValue`, and is given up without it.

The list does not open on focus. Set `open` yourself if you want that.

While an input method is composing, every key belongs to it. The Enter that confirms a conversion chooses nothing and submits nothing.

`toggle` carries the reason for a close: `select`, `commit`, `escape`, `outside`, `press`, `tab`, `focus-out`, `anchor-hidden` or `empty`.

- Category: Text inputs
- Level: composed
- Listing: default
- Built from: Field, Combobox
- Page: https://tanrei.chnotchy.com/components/combobox-field/
- Spec: https://github.com/chnotchy/tanrei/blob/main/specs/combobox-field.spec.json

### Availability

| Design system | Has it | Notes |
| --- | --- | --- |
| Tanrei (`tanrei`) | Yes | Variants left out: `filled`, `outlined`. |
| Cupertino (Apple HIG-inspired) (`cupertino`) | Yes | — |
| M3 Expressive-like (Material 3 Expressive-inspired) (`m3-expressive-like`) | Yes | — |
| M3-like (Material 3-inspired) (`m3-like`) | Yes | — |

### Platforms

- Web: the element `<tanrei-combobox-field>`, registered by importing `@tanrei/web` (or only its own module, `@tanrei/web/components/combobox-field`).
- React: `ComboboxField` from `@tanrei/react`.

| Platform | Name | Status |
| --- | --- | --- |
| Web | `tanrei-combobox-field` | lagging |
| SwiftUI | `TanreiComboboxField` | planned |
| Jetpack Compose | `TanreiComboboxField` | planned |
| Flutter | `TanreiComboboxField` | planned |
| React Native | `ComboboxField` | planned |

Names a platform gives in its own idiom:

| Spec | Web | SwiftUI | Jetpack Compose | Flutter | React Native |
| --- | --- | --- | --- | --- | --- |
| `value` (prop) | `value` | `selection` | `value` | `value` | `value` |
| `inputValue` (prop) | `inputValue` | `text` | `inputValue` | `controller` | `inputValue` |
| `label` (prop) | `label` | `label` | `label` | `labelText` | `label` |
| `labelHidden` (prop) | `labelHidden` | `labelsHidden` | `labelHidden` | `labelHidden` | `labelHidden` |
| `placeholder` (prop) | `placeholder` | `prompt` | `placeholder` | `hintText` | `placeholder` |
| `supportingText` (prop) | `supportingText` | `supportingText` | `supportingText` | `helperText` | `supportingText` |
| `error` (prop) | `error` | `error` | `isError` | `isError` | `error` |
| `disabled` (prop) | `disabled` | `disabled` | `enabled` | `enabled` | `disabled` |
| `required` (prop) | `required` | `isRequired` | `required` | `required` | `required` |
| `optional` (prop) | `optional` | `isOptional` | `optional` | `optional` | `optional` |
| `open` (prop) | `open` | `isPresented` | `expanded` | `menuController` | `open` |
| `chevron` (prop) | `noChevron` | `chevron` | `chevron` | `chevron` | `chevron` |
| `clearLabel` (prop) | `clearLabel` | `clearLabel` | `clearContentDescription` | `clearSemanticLabel` | `clearAccessibilityLabel` |
| `input` (event) | `input` | `text` | `onInputValueChange` | `onInputChanged` | `onInputValueChange` |
| `change` (event) | `change` | `selection` | `onValueChange` | `onChanged` | `onValueChange` |
| `toggle` (event) | `toggle` | `isPresented` | `onExpandedChange` | `onOpenChanged` | `onOpenChange` |
| `action` (event) | `action` | `onSubmit` | `keyboardActions` | `onSubmitted` | `onSubmitEditing` |

Statuses: `planned` — In the inventory. Nothing shippable exists yet. `lagging` — An implementation of an earlier spec exists; it has not caught up with the current one. `alpha` — Implemented with tests. The API may still change. `beta` — Feature complete and at parity. Only fixes are expected. `stable` — Covered by semantic versioning. `deprecated` — Still shipped; scheduled for removal.

### Anatomy

- `field`: The Field: the label row with its glyph and its requirement mark, and the supporting row with the help and the error text. In a look whose combobox floats the label it draws no label row.
- `combobox`: The combobox, as the Field's one control: the box and the text typed in it, the leading glyph, the clear button and the chevron, the list with its options, groups and status row, and the label that floats in the box in the looks that float one.

### Props

| Prop | Type | Default | Web attribute | Description |
| --- | --- | --- | --- | --- |
| `variant` | `enum`: `stacked`, `filled`, `outlined` | `"stacked"` | `variant` | The text input's three looks, so that a combobox is drawn as the text inputs beside it: stacked is a filled box that shows focus and error with a line inside its edge and draws no label of its own; filled and outlined float the label inside the box. Use one style per form. A design system may leave some out (the Tanrei system ships stacked only) or add values. (From Combobox.) |
| `size` | `enum`: `small`, `medium`, `large` | `"medium"` | `size` | Minimum height of the container: stacked 32 / 40 / 56, as tall as a Button of the same size, so that the box and a Button side by side in one row stand as tall as each other; filled and outlined 40 / 48 / 56, which hold the label that floats inside them. These are the text input's three sizes, small for a bar, a toolbar or a dense row of controls. The hit area always meets the minimum target. A design system may add values. (From Combobox.) |
| `value` | `string` | `""` | `value` | The committed choice: the chosen option's value, or, with allowCustomValue, a text the person typed that names no option. Empty while nothing is chosen. It is one string, for ever: several values are another component. (From Combobox: Held by the combobox, which changes it by a choice, a commit or the clear button; the combobox field's is the same at every moment (CBF-3).) |
| `inputValue` | `string` | `""` | `input-value` | The text in the input. The combobox writes it as the person types and when a value is chosen or restored; the product may set it, and reads it from input to load options. (From Combobox: Held by the combobox, which writes it as the person types and when a value is chosen or restored; the combobox field's is the same at every moment (CBF-3).) |
| `label` | `string` | `""` | `label` | Names the control, visibly and to assistive technology. Required, unless the control names itself (a checkbox or a switch with its own label): then leave it empty and the field adds only help and an error. (From Field: Names the combobox. In a filled or outlined look the combobox draws it, floating in its box, and the Field draws no label row (FLD-25, CMB-8).) |
| `labelHidden` | `boolean` | `false` | `label-hidden` | Does not draw the label, which stays the accessible name. For a control whose visible label is elsewhere (a table column, a toolbar). (From Field: Hides the label wherever it would be drawn: the Field's row, or the combobox's floating label (FLD-25).) |
| `placeholder` | `string` | `""` | `placeholder` | A hint shown while the input is empty and no label is in the input line. Never a replacement for a name. (From Combobox.) |
| `supportingText` | `string` | `""` | `supporting-text` | Help shown below the control and given to assistive technology as the control's description. While the field is in error it gives way to errorText, unless the design system keeps both (comp.field.error-text.placement append). (From Field.) |
| `errorText` | `string` | `""` | `error-text` | Shown while error is true, in supportingText's place — or below it, which then stays, where the design system's comp.field.error-text.placement is append: what is wrong and how to put it right, in words. (From Field.) |
| `error` | `boolean` | `false` | `error` | Puts the field in the error condition: the error text is drawn, the control is exposed as invalid and, where it has an error condition of its own, drawn in it. What a value means is the product's to validate; the field never sets this itself. (From Field: Puts the Field in its error condition, which puts the combobox in its own (FLD-8, CMB-10).) |
| `disabled` | `boolean` | `false` | `disabled` | Disables the control and draws the frame as disabled. Disable a framed control here, not on the control, so that its label follows. (From Field: Disables the Field, which disables the combobox (FLD-14, CMB-46).) |
| `readOnly` | `boolean` | `false` | `readonly` | The value is shown, can be focused, selected and copied, and is submitted, but cannot be changed: the list does not open and neither the chevron nor the clear button is drawn. (From Combobox.) |
| `required` | `boolean` | `false` | `required` | What the form asks of the control: true exposes it as required and draws the required mark beside the label. It never validates: a missing answer is the product's to report with error. (From Field.) |
| `optional` | `boolean` | `false` | `optional` | Draws the optional tag after the label and adds optionalText to the control's description, because assistive technology has no state for it. Ignored while required is true: a control is never both. (From Field.) |
| `requiredMark` | `enum`: `auto`, `tag`, `asterisk`, `none` | `"auto"` | `required-mark` | How this control shows that it is required: tag is a small filled Tag with requiredText, asterisk is "*" after the label, none draws nothing and keeps the semantics. Auto takes comp.field.requirement.mark, which follows sys.behavior.requirement-mark, the system's one answer. Ignored unless required is true. (From Field.) |
| `requiredText` | `string` | `""` | `required-text` | The text of the required tag, in the product's language ("Required", "必須"). The product's: Tanrei has no word for it. Empty reads the product's words; with neither, FLD-24 says what is drawn. (From Field.) |
| `optionalText` | `string` | `""` | `optional-text` | The text of the optional tag, in the product's language ("Optional", "任意"); also read to assistive technology as part of the description. The product's: Tanrei has no word for it. Empty reads the product's words. (From Field.) |
| `open` | `boolean` | `false` | `open` | Whether the list is shown. The combobox opens and closes itself and emits toggle; the product may also set it (to open on focus, for one). Ignored while the combobox is disabled or read-only or has nothing to show. (From Combobox: Held by the combobox, which opens and closes its list itself; the combobox field's is the same at every moment (CBF-3).) |
| `allowCustomValue` | `boolean` | `false` | `allow-custom-value` | False: the value is always one of the options, and a text that names none is given up when the person leaves. True: the options are suggestions, and a text that names none becomes the value as typed (a font family, a tag, an address). (From Combobox.) |
| `filter` | `enum`: `contains`, `none` | `"contains"` | `filter` | Who decides which options answer the text. contains: the combobox shows the options whose label contains what was typed, ignoring case, and marks the match. none: the combobox shows every option it is given and the product filters — on input, from its own data or a server — and says what it is doing with status. (From Combobox.) |
| `wrap` | `boolean` | `true` | `no-wrap` (turns it off) | Whether the arrow keys go round at the ends of the list: Down Arrow on the last option to the first, Up Arrow on the first to the last — with allowCustomValue true, through the text itself, where no option is active (CMB-26). False stops them at the ends. (From Combobox.) |
| `chevron` | `boolean` | `true` | — | Draws the chevron that opens the whole list without typing. False for a field whose suggestions exist only for what was typed (a remote search): there is no list to look through. (From Combobox.) |
| `clearable` | `boolean` | `false` | `clearable` | Draws a clear button while the text is not empty, for a combobox whose value may be none. Without it, emptying the text and leaving the field clears the value. (From Combobox.) |
| `clearLabel` | `string` | `""` | `clear-label` | The clear button's accessible name, in the product's language ("Clear"). Required while clearable is true. (From Combobox.) |
| `status` | `enum`: `idle`, `loading`, `error` | `"idle"` | `status` | What the product's source of options is doing, which the product sets: idle (the options given are final), loading (options are on their way: the status row shows a loading indicator), error (the source failed: the status row shows statusText in the error color). (From Combobox.) |
| `statusText` | `string` | `""` | `status-text` | The status row's text, in the product's language, announced to assistive technology when it changes: a count ("12 of 340 shown"), that loading failed, or, while status is loading, the loading indicator's name ("Loading options"). (From Combobox.) |
| `emptyText` | `string` | `""` | `empty-text` | Shown in the list while the text names nothing the combobox can show, allowCustomValue is false and no status is set, in the product's language ("No matches"). The product's: Tanrei has no words for it. Empty reads the product's words; with neither, no such row is drawn and it is reported (CMB-32). (From Combobox.) |
| `separation` | `enum`: `auto`, `divider`, `gap` | `"auto"` | `separation` | How a group of options is told from what is next to it. divider: a line between them. gap: empty space and no line. Auto takes comp.combobox.separation, which follows the design system's choice. (From Combobox.) |
| `iconSpace` | `enum`: `auto`, `always`, `never` | `"auto"` | `icon-space` | Whether a shown option keeps the room of the leading icon column where it has no icon, so that the labels of a section start on one line — a section being the shown options of a group, or a run of adjacent shown options outside any group. auto: an option keeps the column while another shown option of its section has a leading icon; an option the filter hides does not count. always: every option keeps it. never: only an option that has an icon has the column. The menu's and the select's iconSpace, with the same values and default (CMB-67). (From Combobox.) |
| `density` | `enum`: `regular`, `compact` | `"regular"` | `density` | How much room an option of the list takes: its least height, its paddings, the gap between its columns and the size of its glyphs (the leading icon, the check), and never its text style. regular (a 48 row in the default system) is for a product used by touch as well as by pointer; compact (a 32 row with 20 glyphs, the menu's compact row) is for a tool used with a pointer, whose lists are long. For touch an option is never lower than the touch target in either (CMB-34). The field's own box is not changed: its height is size's. A design system may add values. (From Combobox.) |

### Events

| Event | Description |
| --- | --- |
| `input` | The person changed the text (typing, deleting, pasting, dictating, the clear button, Escape restoring it); carries the new text. Not emitted when the product sets inputValue or value, or when a choice writes its label. It is the product's cue to load options; the combobox does not delay or drop it. (From Combobox.) |
| `change` | The committed value changed by the person: an option was chosen, a custom text was committed, or the value was cleared; carries the new value and the text now shown. Not emitted when the product sets value, when the chosen option is chosen again, or while the person only types or moves through the list. (From Combobox.) |
| `toggle` | The list was opened or closed by the person or by having nothing left to show; carries the new open and, for a close, the reason: select, commit, escape, back, outside, press, tab, focus-out, anchor-hidden or empty (in the platform's casing). After a choice it follows change. (From Combobox.) |
| `action` | The person pressed Enter with no option active and the text was committed; emitted after any change it caused. On the web it is followed by the form's submission unless cancelled. (From Combobox.) |

### Slots

| Slot | Description |
| --- | --- |
| `leading-icon` | A glyph at the start of the container that stands for the combobox whatever is chosen (a magnifier before a field that searches people). It takes the place of the chosen option's own glyph. (From Combobox.) |
| `label-icon` | A glyph before the label. (From Field.) |

### Item: `option`

One choice of the combobox: a label, the value it stands for, and optionally a supporting line and a glyph. The same kind a select holds.

Names: Web `tanrei-option`, SwiftUI `TanreiComboboxOption`, Jetpack Compose `TanreiComboboxOption`, Flutter `TanreiComboboxOption`, React Native `ComboboxOption`.

| Prop | Type | Default | Web attribute | Description |
| --- | --- | --- | --- | --- |
| `label` | `string` | `""` | `label` | The option's text and its accessible name: what the filter searches and what the input shows once the option is chosen. Required. |
| `value` | `string` | `""` | `value` | Identifies the choice: the option is the chosen one while the combobox's value equals it. Unique within the combobox and not empty: the empty value means that nothing is chosen. |
| `supportingText` | `string` | `""` | `supporting-text` | A line below the label that says more about the choice. Shown in the list, not in the input; not searched. |
| `leadingIcon` | `string` | `""` | `leading-icon` | The name of an icon (a glyph of the system's icon set) before the label; the container shows it too while the option is chosen and the combobox has no leading icon of its own. |
| `disabled` | `boolean` | `false` | `disabled` | Prevents the option from being chosen. It stays reachable with the arrow keys. |

### Item: `option-group`

A run of related options, optionally titled. The combobox separates a group from what is next to it by a divider or a gap, and draws neither a group nor its title while the filter leaves it empty.

Names: Web `tanrei-option-group`, SwiftUI `TanreiComboboxSection`, Jetpack Compose `TanreiComboboxGroup`, Flutter `TanreiComboboxGroup`, React Native `ComboboxOptionGroup`.

| Prop | Type | Default | Web attribute | Description |
| --- | --- | --- | --- | --- |
| `title` | `string` | `""` | — | A short heading drawn above the group's options, which also names the group; empty draws none and leaves the group unnamed. |

### States

`enabled`, `disabled`, `hovered`, `focused`, `pressed`, `selected`, `error`, `loading`

### Accessibility

- Role: `combobox`
- Labeling: The combobox field adds nothing to what its members expose and coordinates nothing: the Field gives the combobox its name, its description and its required, invalid and disabled states (FLD-8, FLD-10, FLD-11, FLD-14), and the combobox carries them on its own input, with its expanded state, its list and its active option (CMB-12, CMB-48). Assistive technology meets one editable combobox named by label, with a list of the same name, exactly as it meets a Field around a combobox written by hand.
- Minimum target size: yes

| Keys | Action |
| --- | --- |
| Every key | The combobox's (its accessibility block; CMB-16, CMB-20, CMB-21, CMB-26 to CMB-30). The combobox field handles no key and adds no focus stop (CBF-5). |

- One level down is the same thing: a Field with a combobox in it, holding the same options. Every fixture has that pair as its twin, and the accessibility tree of the two is the same (CBF-1).
- The options are the product's, and they are the combobox's: the combobox field passes them on and does nothing with them (CBF-2). Value, text and open are the combobox's too, and the combobox field keeps no second copy that could disagree with it (CBF-3).
- On the web the two members stand in the combobox field's own shadow root, so the form meets the combobox field and not the combobox (CBF-4); focus passes through to the input (CBF-5); and the product's option elements stay its own children, read by the combobox through a slot.
- A list is not a second thing the component reports: choosing an option is setting its one value, so the combobox field is composed, not a feature.

### Behaviour

Requirements in EARS form, each with its stable id.

- **CBF-1** THE combobox field SHALL be a Field that frames one combobox, and nothing else. It SHALL give label, labelHidden, supportingText, errorText, error, disabled, required, optional, requiredMark, requiredText and optionalText to its Field and every other prop to its combobox, each unchanged; SHALL hold the label-icon slot for its Field and the leading-icon slot for its combobox; SHALL give its options to its combobox (CBF-2); and SHALL emit its combobox's events as its own, each once. THE combobox field SHALL be as wide as the place it stands in, and its combobox SHALL fill it: it is a block with no width of its own, as its Field is (FLD-1), around a control that fills the width it is given (CMB-49). It SHALL draw no part of its own and have no token of its own: what it shows, how it behaves and what it exposes to assistive technology SHALL be exactly what that Field and that combobox do when a product places the one in the other (FLD-1 to FLD-28; CMB-1 to CMB-62) — the label row and its requirement mark (FLD-2 to FLD-6), or the label that floats in the box with the Field's row left out (FLD-25, CMB-7, CMB-8); the supporting row and the error (FLD-7 to FLD-9, FLD-26, CMB-10); the name, the description and the states (FLD-10, FLD-11, FLD-14, CMB-12, CMB-46); and the list, which is the combobox's alone and as wide as its container (CMB-22).
- **CBF-2** THE combobox field SHALL take the options and the option groups a product gives it — in the platform's form for a combobox's own (its child elements on the web) — and give them to its combobox as that combobox's options, in the order given, each with its label, its value, its supporting text, its leading icon and its disabled, and each group with its title: the option a product wrote SHALL be the option its combobox reads, never a copy of it. THE combobox field SHALL NOT read, filter, order, count or keep an option, and SHALL make no option active or chosen: which options are shown, which is active and which is the chosen one are its combobox's (CMB-25, CMB-26, CMB-36). WHEN the product adds, removes, reorders or changes an option or a group THE combobox field's combobox SHALL meet the change at once and as CMB-31 says, as though the product had changed that combobox's own options.
- **CBF-3** THE combobox field SHALL hold no value, no text and no open state of its own: its value, its inputValue and its open SHALL at every moment be its combobox's. WHEN its combobox changes one of them — a choice, a commit or the clear button (CMB-17, CMB-20, CMB-27 to CMB-29); typing, or a text the combobox writes itself for a choice, for a commit that was given up or for Escape (CMB-16, CMB-27, CMB-29, CMB-30); the list opening or closing, or open taken back because there is nothing to show (CMB-21, CMB-30, CMB-57) — THE combobox field's SHALL be the new one before any event that reports the change is emitted, and equally WHERE no event reports it. WHEN the product sets one on the combobox field THE combobox field SHALL set it on its combobox and nothing else, so that no event follows (CMB-31).
- **CBF-4** WHERE the platform has forms (the web) THE combobox field SHALL be the one control the form sees: it SHALL take name, submit its combobox's value — never the text of an edit that was not committed — reset to the value it was first given, restore it on navigation, report to the form's constraint validation exactly what its combobox would report there (CMB-59), and be left out WHILE disabled is true or a disabled group of the form holds it; its combobox and its Field SHALL take no part in the form themselves. WHEN Enter asks for the form's submission (CMB-28) the form asked SHALL be the combobox field's own, through that form's default button (BTN-30), and not WHEN action was cancelled.
- **CBF-5** WHEN the combobox field is given focus — by the product, by a press on any part of it that FLD-12 or CMB-14 gives to the input, or by a form that reports its validity — THE combobox field SHALL pass the focus to its combobox's input and SHALL add no stop to the focus order: the stops inside it are its combobox's, in that combobox's order (the input, then the clear button while it is shown). WHILE focus is anywhere inside it, or its combobox's list is open, its Field's rows SHALL be drawn focused, because its combobox says so to its Field (FLD-13, CMB-61): the combobox field arranges nothing for it. A press on its Field's label row WHILE the list is open is a press outside the combobox: the list SHALL close with the reason outside, choosing nothing (CMB-30), and focus SHALL go to the input (FLD-12).
- **CBF-6** IF the combobox field is placed in a Field THE combobox field SHALL in debug builds report that it is a field already and that the bare control is the combobox, and both SHALL still render (FLD-15). WHILE it stands in a field group THE combobox field SHALL follow that group's disabled, through its own Field, and take nothing else from the group (FGR-20).
- **CBF-7** THE combobox field SHALL have no words of its own and SHALL read none: requiredText and optionalText are read by its Field (FLD-24), emptyText and clearLabel by its combobox (CMB-60), each from the instance's prop and then from the product's words.
- **CBF-8** WHERE the platform has ARIA attributes (the web), WHEN the product sets an aria- attribute on the host, by the attribute or by the ARIA property that reflects it, THE combobox field SHALL move it to the data-aria- attribute of the same name, so that the host is no second node with its name, description or state, and SHALL expose it on the element that carries its role — an id reference by the elements it names in the host's tree or a tree around it, an error message as part of the description while the combobox field is invalid — except those the combobox field owns (aria-label, aria-labelledby, aria-disabled, aria-haspopup, aria-expanded, aria-controls), which it SHALL move and not expose: its name is label (CBF-1). WHEN the product removes the aria- attribute or its data-aria- twin, or sets the ARIA property that reflects it (ariaLabel, ariaDescribedByElements…) to null, THE combobox field SHALL take it off that element. WHEN the product sets an aria- attribute the combobox field owns THE combobox field SHALL report it in debug builds.

### Tokens

As written in the token documents (DTCG): an alias in braces names the token it takes its value from, which each design system resolves. On the web each token is a CSS custom property: `--tanrei` and the name after `tanrei`, joined by hyphens (`tanrei.comp.field.…` → `--tanrei-comp-field-…`).

#### `tanrei.comp.field`

| Token | Type | Value |
| --- | --- | --- |
| `comp.field.label.typescale` | `typography` | `{tanrei.sys.typescale.label}` |
| `comp.field.label.gap` | `dimension` | `{tanrei.sys.space.space100}` |
| `comp.field.label-icon.size` | `dimension` | `{tanrei.sys.icon.small}` |
| `comp.field.label-icon.gap` | `dimension` | `{tanrei.sys.space.space100}` |
| `comp.field.requirement.mark` | `number` | `{tanrei.sys.behavior.requirement-mark}` |
| `comp.field.requirement.gap` | `dimension` | `{tanrei.sys.space.space100}` |
| `comp.field.requirement.asterisk-gap` | `dimension` | `{tanrei.sys.space.space25}` |
| `comp.field.supporting-text.typescale` | `typography` | `{tanrei.sys.typescale.label-small}` |
| `comp.field.supporting-text.gap` | `dimension` | `{tanrei.sys.space.space50}` |
| `comp.field.counter.gap` | `dimension` | `{tanrei.sys.space.space200}` |
| `comp.field.motion.state-duration` | `duration` | `{tanrei.sys.motion.role.state.default}` |
| `comp.field.motion.state-easing` | `cubicBezier` | `{tanrei.sys.motion.easing.state}` |
| `comp.field.standard.label.color` | `color` | `{tanrei.sys.color.on-surface}` |
| `comp.field.standard.label-icon.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.supporting-text.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.counter.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.required-asterisk.color` | `color` | `{tanrei.sys.color.primary}` |
| `comp.field.standard.error.label.color` | `color` | `{tanrei.sys.color.on-surface}` |
| `comp.field.standard.error.label-icon.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.error.supporting-text.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.error.counter.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.error.required-asterisk.color` | `color` | `{tanrei.sys.color.primary}` |
| `comp.field.standard.error.value-text.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.value-text.color` | `color` | `{tanrei.sys.color.on-surface-variant}` |
| `comp.field.standard.error-text.color` | `color` | `{tanrei.sys.color.error}` |
| `comp.field.value-text.typescale` | `typography` | `{tanrei.sys.typescale.label}` |
| `comp.field.value-text.gap` | `dimension` | `{tanrei.sys.space.space200}` |
| `comp.field.error-text.gap` | `dimension` | `{tanrei.sys.space.space50}` |
| `comp.field.error-text.placement` | `number` | `0` |

Per-state tokens, valued by the design system's pattern rules (not written by hand):

- `comp.field.<variant>.<state>.<property>` for the variants `standard`, the states `focused`, `disabled` and the properties `label.color`, `label-icon.color`, `supporting-text.color`, `required-asterisk.color`, `error.label.color`, `error.label-icon.color`, `error.supporting-text.color`, `error.required-asterisk.color`, `counter.color`, `error.counter.color`, `value-text.color`, `error.value-text.color`, `error-text.color`.

### What the web draws differently

- `<tanrei-option>` and `<tanrei-option-group>` are data: they draw nothing. They are the elements a select holds. An option whose value is the empty string is drawn and cannot be chosen, because the empty value means that nothing is chosen.
- The element’s shadow root holds a `<tanrei-field>` around a `<tanrei-combobox>`. Your `<tanrei-option>` children stay its own children and reach the combobox through a slot; nothing is moved or copied.
- The combobox field is a form-associated element: the one control the form sees. It takes `name`, submits `value` and never the text of an edit that was not committed, resets to the `value` attribute, and reports a missing value to the form while `required` and `value` is empty. Enter with no option active submits its form.
- `value`, `inputValue` and `open` are the combobox’s at every moment: each is already the new one in every listener.
- `chevron` and `wrap` are the inverse attributes `no-chevron` and `no-wrap`, and `readOnly` is `readonly`.
- `input` is the native event of the text element. `change` and `action` carry `detail.value` and `detail.inputValue`. The four events are the combobox’s own, with the combobox field as their target; `toggle` does not bubble.
- `focus()` goes to the input. The element itself is not focusable and has no role: name it with `label`, never with `aria-label`.
- Parts: `field` and `combobox` are the two members; each member’s parts are exported under their own names, and `label` and `requirement-label` also as `field-label`, `combobox-label`, `field-requirement-label` and `combobox-requirement-label`.
- One field is set apart by a custom property on it: `--tanrei-comp-field-*` for the rows, `--tanrei-comp-input-box-*` for the box, `--tanrei-comp-combobox-*` for the list.
- The list is a `popover="manual"` element in the top layer. A press outside closes it and also reaches the element under it.
- The status row stands under the options and does not scroll with them, so a count or a failure stays in view.
- Before the element is defined, its options are running text. Hide `tanrei-combobox-field:not(:defined) > *` and reserve the height.
- The web has no back gesture of its own, so `toggle` never carries the reason `back`.

## Guidelines

### Combobox field, select, search or a text field

| Aspect | Combobox field | Select | Search | Text field |
| --- | --- | --- | --- | --- |
| Holds | One value found by typing | One value of a closed list | A query | Any text |
| Shows choices | As the person types | After a press | Suggestions and results | No |
| Takes a value that is not listed | With `allowCustomValue` | No | Yes | Yes |
| Part of a form | Yes | Yes | No | Yes |

1. With up to about five short options, show them all: radio buttons.
2. If the list is short enough to scan, and closed, it is a select.
3. If people would rather type than scroll, or the field takes a value that is not listed, it is a combobox field.
4. If typing leads to places to go rather than to a value, it is a search.
5. Several values are another component: a combobox holds one.
6. If the label stands elsewhere — a filter in a toolbar, a cell of a table — it is the bare [combobox](https://tanrei.chnotchy.com/components/combobox/), named by its own `label`.

### Do

- Write a label that names what is chosen, and keep it visible in a form.
- Use `allowCustomValue` only where a value that is not listed is a real answer.
- Give `clearable` to a combobox field whose value may be none, and name the button with `clearLabel`.
- When you load options, set `status` and `statusText` so the list says that it is waiting, how many it shows, or that it failed.
- Give `emptyText`, on the combobox field or once for the whole product with `setWords({ emptyText })`. Tanrei ships no words: without it a text that matches nothing draws no row, and the list has nothing to show.

### Don’t

- Don’t use the placeholder as the label. It goes away as soon as the person types.
- Don’t save, navigate or submit on `input`. It fires at every keystroke; `change` is the committed value.
- Don’t treat a text that names no option as an error of the field. It is given up when the person leaves. If you want to say “choose one from the list”, set `error` and `errorText` yourself.
- Don’t put a combobox field inside a field. It is a field already; the control a field frames is the [combobox](https://tanrei.chnotchy.com/components/combobox/).
- Don’t open the list on focus in a form of many fields: it covers the fields below at every stop.

## Accessibility

### What the component handles

- The input is an editable combobox with a list box. Its name is `label`, drawn or hidden, and never the placeholder. The field gives it to the combobox, which carries it on its own input.
- The shown supporting or error text is its description, with `optionalText` while the field is optional.
- An error that appears while focus is in the field is announced once, politely.
- It is exposed as invalid while `error` is true, as required while `required` is set, as read-only, and as expanded while its list is open.
- Focus stays in the input while the list is open. The active option is its active descendant, so typing never stops editing the text. An option that typing made active is named once typing pauses for half a second, so that a screen reader reads the typed letter first and then the option Enter would choose; an option the arrow keys move to is named at once.
- The list is a list box named by the label. Each option has its name, its description, whether it is the chosen one, whether it is disabled, and its position among the options shown. A group is named by its title.
- A match is marked by weight, never by color alone. The label is read as one text.
- The status row is a live region: its text is read politely when it changes, and at once when the source failed. While loading, the list is marked busy and nothing is announced.
- While an input method is composing, the combobox handles no key.
- The chevron is a button for a pointer and for touch exploration, outside the focus order. The keyboard opens the list with Down Arrow.
- The clear button is a button named by `clearLabel`, and the next focus stop after the input.
- Escape closes the list and goes no further, so a dialog around the combobox stays open.
- The field’s hit area meets the minimum target, and options are at least the minimum target tall.
- At 200% text the label, the help, the options, the titles and the status row wrap. Only the text in the input stays on one line, and scrolls.
- In forced colors the field and the list gain an edge, the active option takes the highlight colors, and the chosen option is shown by its check.
- In a right-to-left layout the field and each row are mirrored, and each text keeps its own direction. The chevron, the clear button’s glyph and the check are not mirrored.

Known gaps on the web:

- The divider between two groups is not exposed as a separator: a list box holds options and groups only.
- The filter folds case, width and marks for every script alike. It does not match Hangul by its first consonant or kana by its reading.
- Before the element is defined, the options are text on the page without a control.

### What you need to do

- Give every combobox field a `label`, and every option a label and a value that is not empty.
- Give a clearable combobox field a `clearLabel`.
- Write `statusText` on the combobox field. Give `emptyText`, `requiredText`, `optionalText` and `clearLabel` on the combobox field, or once for the whole product with `setWords()`. Tanrei ships no words; a missing one is reported in development. See [The product’s words](https://tanrei.chnotchy.com/foundations/words/).
- Validate the value yourself, set `error`, and write `errorText` so that it says how to put the answer right.
- Keep option values unique within a combobox field.