---
title: BaseSelect
description: Compose a custom listbox with selection, navigation, and popup ownership.
package: moraine
version: 0.11.0
repository: https://github.com/subframe7536/moraine
---

# BaseSelect

> Compose a custom listbox with selection, navigation, and popup ownership.

## Anatomy

```text
BaseSelect [component; no DOM]
├── BaseSelect.Control [part; slot=control]
│   └── BaseSelect.Trigger [part; slot=trigger]
└── positioner [internal]
    └── BaseSelect.Content [part; slot=content]
        ├── BaseSelect.Listbox [part; slot=listbox]
        │   ├── BaseSelect.Group [part; slot=group]
        │   │   ├── BaseSelect.GroupLabel [part; slot=groupLabel]
        │   │   └── BaseSelect.Item [part; slot=item]
        │   ├── BaseSelect.Item [part; slot=item]
        │   └── BaseSelect.Separator [part; slot=separator]
        └── BaseSelect.Empty [part; slot=empty]
```

Control is an optional layout container and floating anchor; without it, Content anchors to the registered focus owner.

## Usage

Use BaseSelect to build a custom selection control from a trigger and listbox parts. It manages
selected values, open state, keyboard navigation, and native form values. Your application owns
filtering, query text, grouping, and item creation.

For a ready-made field, start with [Select](https://moraine.subf.dev/components/select.md), [Combobox](https://moraine.subf.dev/components/combobox.md),
or [MultiSelect](https://moraine.subf.dev/components/multi-select.md).

```tsx
import { BaseSelect } from 'moraine'

export function Example() {
  return (
    <BaseSelect items={[{ label: 'Option A', value: 'a' }]}>
      <BaseSelect.Control>
        <BaseSelect.Trigger>Choose an option</BaseSelect.Trigger>
      </BaseSelect.Control>
      <BaseSelect.Content>
        <BaseSelect.Listbox>
          <BaseSelect.Item item={{ label: 'Option A', value: 'a' }}>Option A</BaseSelect.Item>
        </BaseSelect.Listbox>
      </BaseSelect.Content>
    </BaseSelect>
  )
}
```

### Values and form submission

`value`, `defaultValue`, and `onValueChange` always use arrays, even for single selection; without
`multiple`, only the first entry is used. `value={undefined}` keeps the selection uncontrolled and
`value={[]}` keeps it controlled and empty. Choosing an item closes the popup unless you set
`multiple` or `closeOnSelect={false}`. Set `name` to submit the selection with the enclosing native
form; use `serializeValue` to change or omit a submitted value.

### Control and focus ownership

Control is an optional, non-interactive layout container and floating anchor. It does not toggle,
own keyboard navigation, become a tab stop, or receive `role="combobox"`. Trigger is the primary
select-like focus owner and activator. If Control is omitted, Content anchors to the registered
focus owner.

For an editable composition, bind your own `<input>` with `createBaseSelectSearchInput` from
`moraine/utils`. Call it in a component rendered inside `BaseSelect`, passing `BaseSelect.useContext()`
as `state`, and spread `inputProps` on the input. The helper registers the input as the focus owner
and adds the combobox ARIA attributes and keyboard handling. It does not make the input the floating
anchor, so render a `BaseSelect.Control` around it. You own the input, the canonical source,
filtering, and query reset. No `BaseSelect.Trigger` is required in that pattern.

```tsx
import { BaseSelect } from 'moraine'
import { createBaseSelectSearchInput } from 'moraine/utils'

function SearchControl(props: { query: () => string; setQuery: (value: string) => string }) {
  const input = createBaseSelectSearchInput({
    state: BaseSelect.useContext(),
    searchValue: props.query,
    setSearchValue: props.setQuery,
  })
  return (
    <BaseSelect.Control>
      <input {...input.inputProps} />
    </BaseSelect.Control>
  )
}
```

### Item fields

`BaseSelect.Item` takes the collection entry through the `item` prop: `<BaseSelect.Item item={item} />`.
Other props are DOM and rendering props for the rendered `<div>`. Custom item fields are available
through render state, and arbitrary item fields never leak into DOM attributes:
`<BaseSelect.Item<MyItem> item={item}>{(state) => state.item.custom}</BaseSelect.Item>`.
Without children, Item renders `item.label`.

### Filtered collections

`items` is the flat list of every item you render as `BaseSelect.Item`; an item whose value is not
in `items` cannot be selected. By default, `items` is both the canonical data source and the active
navigation collection. Values must be unique. Groups and separators are rendering concerns and do
not belong in `items`.

For custom filtered compositions such as searchable controls, provide `getItemByValue` alongside
a filtered `items` view:

```tsx
<BaseSelect items={filteredItems()} getItemByValue={(value) => allItemsByValue.get(value)}>
  {/* ... */}
</BaseSelect>
```

The filtered `items` array controls which options users can navigate. `getItemByValue` looks up
selected items in the full collection, so labels, disabled state, and form values remain available
when an item is filtered out.

### Styling

BaseSelect exposes the style slots `control`, `trigger`, `content`, `listbox`, `item`, `group`,
`groupLabel`, `separator`, and `empty` through `classes` and `styles` on the root. Each part also
accepts `class` and `style` for its own element. See [Customization](https://moraine.subf.dev/docs/customization.md) and
[Theming](https://moraine.subf.dev/docs/theming.md) for nested Provider, Portal, and class-merging behavior.

## Examples

### Pick a grouped framework

Compose groups, group labels, and item render state when Select's built-in collection is not enough.
Resolve the trigger label from the full collection.

```tsx
import { BaseSelect, Button, Icon } from 'moraine'
import { For } from 'solid-js'

const GROUPS = [
  {
    label: 'Frontend',
    items: [
      { value: 'solid', label: 'Solid', description: 'Fine-grained reactive UI' },
      { value: 'react', label: 'React', description: 'Component-based UI' },
    ],
  },
  {
    label: 'Meta-frameworks',
    items: [
      { value: 'astro', label: 'Astro', description: 'Content-focused web framework' },
      { value: 'sveltekit', label: 'SvelteKit', description: 'Application framework for Svelte' },
    ],
  },
]

const FRAMEWORKS = GROUPS.flatMap((group) => group.items)

export default function Example() {
  return (
    <BaseSelect items={FRAMEWORKS} getItemLabel={(item) => `${item.value} ${item.description}`}>
      <BaseSelect.Control>
        <BaseSelect.Trigger
          as={Button}
          variant="outline"
          class="min-w-52 justify-between"
          trailing="i-lucide:chevrons-up-down"
        >
          {(state) => (
            <span>
              {FRAMEWORKS.find((item) => item.value === state.value[0])?.label ??
                'Select framework…'}
            </span>
          )}
        </BaseSelect.Trigger>
      </BaseSelect.Control>
      <BaseSelect.Content>
        <BaseSelect.Listbox>
          <For each={GROUPS}>
            {(group) => (
              <BaseSelect.Group>
                <BaseSelect.GroupLabel>{group.label}</BaseSelect.GroupLabel>
                <For each={group.items}>
                  {(item) => (
                    <BaseSelect.Item item={item}>
                      {(state) => (
                        <>
                          <Icon
                            name="i-lucide:check"
                            class={state.selected ? 'opacity-100' : 'opacity-0'}
                          />
                          <span>
                            {state.item.label}
                            <small class="text-muted-foreground block">
                              {state.item.description}
                            </small>
                          </span>
                        </>
                      )}
                    </BaseSelect.Item>
                  )}
                </For>
              </BaseSelect.Group>
            )}
          </For>
        </BaseSelect.Listbox>
        <BaseSelect.Empty>No frameworks found.</BaseSelect.Empty>
      </BaseSelect.Content>
    </BaseSelect>
  )
}
```

### Search a custom listbox

Own the query and the filtered `items`, and bind the input with `createBaseSelectSearchInput`. Pass
`getItemByValue` so a selected option still resolves after it leaves the filtered view.

```tsx
import { BaseSelect, Icon } from 'moraine'
import { createBaseSelectSearchInput } from 'moraine/utils'
import type { BaseSelectSearchInputOptions } from 'moraine/utils'
import { createMemo, createSignal, For } from 'solid-js'

const FRAMEWORKS = [
  { value: 'solid', label: 'Solid', description: 'Fine-grained reactive UI' },
  { value: 'react', label: 'React', description: 'Component-based UI' },
  { value: 'astro', label: 'Astro', description: 'Content-focused web framework' },
  { value: 'sveltekit', label: 'SvelteKit', description: 'Application framework for Svelte' },
]

function SearchControl(
  props: Pick<BaseSelectSearchInputOptions, 'searchValue' | 'setSearchValue'>,
) {
  const state = BaseSelect.useContext()
  const input = createBaseSelectSearchInput({
    state,
    searchValue: () => props.searchValue(),
    setSearchValue: (value) => props.setSearchValue(value),
  })
  return (
    <BaseSelect.Control class="px-2 border border-input rounded-md flex w-64 items-center">
      <input
        {...input.inputProps}
        class="py-1.5 outline-none bg-transparent flex-1"
        placeholder="Search frameworks…"
      />
      <button
        type="button"
        tabIndex={-1}
        aria-label="Toggle frameworks"
        onPointerDown={(event) => {
          event.preventDefault()
          event.stopPropagation()
          state.focusOwner()?.focus()
        }}
        onClick={(event) => {
          event.stopPropagation()
          state.setOpen(!state.open())
        }}
      >
        <Icon name="i-lucide:chevrons-up-down" />
      </button>
    </BaseSelect.Control>
  )
}

export default function Example() {
  const [searchValue, setSearchValue] = createSignal('')
  const items = createMemo(() => {
    const query = searchValue().toLowerCase()
    return query
      ? FRAMEWORKS.filter(
          (item) =>
            item.label.toLowerCase().includes(query) ||
            item.description.toLowerCase().includes(query),
        )
      : FRAMEWORKS
  })
  return (
    <BaseSelect
      items={items()}
      getItemByValue={(value) => FRAMEWORKS.find((item) => item.value === value)}
      getItemLabel={(item) => `${item.label} ${item.description}`}
      onExitComplete={() => setSearchValue('')}
    >
      <SearchControl searchValue={searchValue} setSearchValue={setSearchValue} />
      <BaseSelect.Content>
        <BaseSelect.Listbox>
          <For each={items()}>
            {(item) => (
              <BaseSelect.Item item={item}>
                {(state) => (
                  <>
                    <Icon
                      name="i-lucide:check"
                      class={state.selected ? 'opacity-100' : 'opacity-0'}
                    />
                    <span>
                      {state.item.label}
                      <small class="text-muted-foreground block">{state.item.description}</small>
                    </span>
                  </>
                )}
              </BaseSelect.Item>
            )}
          </For>
        </BaseSelect.Listbox>
        <BaseSelect.Empty>No frameworks found.</BaseSelect.Empty>
      </BaseSelect.Content>
    </BaseSelect>
  )
}
```

### Select multiple frameworks

Set `multiple` and read `state.value` as an array. Summarize the whole selection in the trigger
instead of showing a single label. The popup stays open after each choice.

```tsx
import { BaseSelect, Button, Icon } from 'moraine'
import type { BaseSelectT } from 'moraine'
import { For } from 'solid-js'

const FRAMEWORKS = [
  { value: 'solid', label: 'Solid' },
  { value: 'react', label: 'React' },
  { value: 'vue', label: 'Vue' },
] satisfies BaseSelectT.Item[]

export default function Example() {
  return (
    <BaseSelect items={FRAMEWORKS} multiple defaultValue={['solid']} name="frameworks">
      <BaseSelect.Control>
        <BaseSelect.Trigger as={Button} variant="outline" class="min-w-52">
          {(state) => <span>{state.value.length} framework(s) selected</span>}
        </BaseSelect.Trigger>
      </BaseSelect.Control>
      <BaseSelect.Content>
        <BaseSelect.Listbox>
          <For each={FRAMEWORKS}>
            {(item) => (
              <BaseSelect.Item item={item}>
                {(state) => (
                  <>
                    <Icon
                      name="i-lucide:check"
                      class={state.selected ? 'opacity-100' : 'opacity-0'}
                    />
                    {state.item.label}
                  </>
                )}
              </BaseSelect.Item>
            )}
          </For>
        </BaseSelect.Listbox>
        <BaseSelect.Empty>No frameworks found.</BaseSelect.Empty>
      </BaseSelect.Content>
    </BaseSelect>
  )
}
```

### Submit a native form value

Give the root a `name`. BaseSelect writes the selected value into the enclosing native form without
`createForm`.

```tsx
import { BaseSelect, Button } from 'moraine'
import type { BaseSelectT } from 'moraine'
import { createSignal, For } from 'solid-js'

const FRAMEWORKS = [
  { value: 'solid', label: 'Solid' },
  { value: 'react', label: 'React' },
  { value: 'vue', label: 'Vue' },
] satisfies BaseSelectT.Item[]

export default function Example() {
  const [submitted, setSubmitted] = createSignal('Not submitted')
  return (
    <form
      class="flex gap-2 items-start"
      onSubmit={(event) => {
        event.preventDefault()
        const value = new FormData(event.currentTarget).get('framework')
        setSubmitted(typeof value === 'string' ? value : 'No selection')
      }}
    >
      <BaseSelect items={FRAMEWORKS} name="framework" required>
        <BaseSelect.Control>
          <BaseSelect.Trigger as={Button} variant="outline" class="min-w-52">
            {(state) => (
              <span>
                {FRAMEWORKS.find((item) => item.value === state.value[0])?.label ??
                  'Select framework…'}
              </span>
            )}
          </BaseSelect.Trigger>
        </BaseSelect.Control>
        <BaseSelect.Content>
          <BaseSelect.Listbox>
            <For each={FRAMEWORKS}>
              {(item) => <BaseSelect.Item item={item}>{item.label}</BaseSelect.Item>}
            </For>
          </BaseSelect.Listbox>
        </BaseSelect.Content>
      </BaseSelect>
      <Button type="submit">Submit</Button>
      <output class="text-sm text-muted-foreground self-center">{submitted()}</output>
    </form>
  )
}
```

## API Reference

### Attributes

| Attributes | Slot | Description |
| --- | --- | --- |
| `data-closed` | `base-select-control`, `base-select-trigger`, `base-select-content` | Present when disclosure or transition content is closed. |
| `data-disabled` | `base-select-control`, `base-select-trigger`, `base-select-item` | Present when the component, slot, or item is disabled. |
| `data-expanded` | `base-select-control`, `base-select-trigger`, `base-select-content` | Present when the panel, accordion, or menu is expanded. |
| `data-invalid` | `base-select-control`, `base-select-trigger` | Present when the field or form has a validation error. |
| `data-readonly` | `base-select-control` | Present when the field is in read-only mode. |
| `data-required` | `base-select-control` | Present when the field input is required. |
| `data-side` | `base-select-content` | Stores the resolved floating or drawer content side. |
| `data-highlighted` | `base-select-item` | Present when the item is highlighted by pointer or keyboard navigation. |
| `data-selected` | `base-select-item` | Present when the item or tab is selected. |

### Props

#### BaseSelect

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| align | 'start' \| 'center' \| 'end' \| undefined | 'start' | Alignment of the popup along the anchor's edge: `'start'`, `'center'`, or `'end'`. |
| closeOnEscape | boolean \| undefined | true | Whether `Escape` closes the popup. When `false` the popup stays open and `onClosePrevented`<br>is called instead. |
| closeOnOutsideClick | boolean \| undefined | true | Whether an outside interaction, pointer press or focus moving elsewhere, closes the popup.<br>When `false` the popup stays open and `onClosePrevented` is called instead. Tabbing out of<br>the control still closes it. |
| closeOnSelect | boolean \| undefined | — | Whether choosing an item closes the popup and returns focus to the control. Defaults to<br>`true` for single selection and `false` when `multiple` is set on `BaseSelect`; `MultiSelect`<br>always keeps the popup open. |
| defaultOpen | boolean \| undefined | false | Initial popup state when `open` is not set. |
| defaultValue | readonly TItem['value'][] \| undefined | [] | Initial selection when `value` is not set. Read once on creation; a native form reset<br>restores it. |
| disabled | boolean \| undefined | false | Whether the control is disabled: it cannot be interacted with and sets `aria-disabled`.<br>When omitted, the control inherits `disabled` from the surrounding `Field`; an explicit<br>`false` overrides the `Field`. |
| flip | boolean \| string \| undefined | true | Whether to flip placement when the preferred side lacks space. `false` disables flipping. A<br>string is a space-delimited list of fallback placements tried in order, each `top`,<br>`bottom`, `left`, or `right` optionally followed by `-start` or `-end` (for example<br>`'top bottom-end'`); an invalid entry throws. |
| getItemByValue | ((value: TItem['value']) => TItem \| undefined) \| undefined | — | Resolves an item from the canonical collection by value.<br><br>Use this when `items` represents only the current navigation view,<br>such as a filtered collection. When omitted, items are resolved from<br>the current `items` collection. The resolved item decides whether a selected value counts<br>as disabled and is omitted from the form value. |
| getItemLabel | ((item: TItem) => string) \| undefined | — | Plain-text label of an item, used for typeahead, filtering, form values, and plain-text<br>displays such as an input value or tag title; does not change rendered labels.<br>Defaults to the string `label`, otherwise `String(value)`. In `Select` and `Combobox`,<br>string items arrive as `{ value, label }`. |
| gutter | number \| undefined | 4 | Gap in pixels between anchor and popup. |
| id | string \| undefined | — | The ID of the control's main focusable element, which a surrounding `Field` label points to<br>with `for`. A unique ID is generated when omitted. The control's related parts (hidden<br>input, label, description) derive their IDs from it, so keep it unique on the page. |
| isItemDisabled | ((item: TItem, values: readonly TItem['value'][]) => boolean) \| undefined | — | Extra disabled rule, evaluated for every item together with the current selected values;<br>return `true` to disable the item in addition to `item.disabled`. Disabled items cannot be<br>selected, highlighted, or reached by typeahead. In `MultiSelect`, a selected disabled item<br>keeps its tag (it cannot be removed) and survives clearing. In `Select` and `Combobox`,<br>string items arrive as `{ value, label }`. |
| items | readonly ({<br>  /** Unique selection and form value. Values compare by identity, so `1` and `'1'` differ. */<br>  value: string \| number;<br>  /** Visual label. May be any JSX; when it is not a string, plain-text uses (typeahead,<br>filtering) fall back to `String(value)` unless `getItemLabel` is set. */<br>  label: JSX.Element;<br>  /** Whether this item cannot be selected. A disabled item is also left out of form submission. */<br>  disabled?: boolean;<br>})[] \| undefined | — | Flat list of items available for keyboard navigation, typeahead, and selection. It must<br>list the same items you render as `BaseSelect.Item`: an item whose value is not here cannot<br>be selected. Values must be unique (duplicates log an error in development). Groups and<br>separators are rendering concerns and do not belong here. |
| loop | boolean \| undefined | true | Whether arrow-key navigation wraps from the ends. |
| multiple | boolean \| undefined | — | Whether selecting an item toggles it among several values instead of replacing the single<br>value. Without it, `value` and `defaultValue` are truncated to their first entry. |
| name | string \| undefined | — | The name of the control, used for native form submission. When omitted, the control uses<br>the name of its form binding or a string `name` set on the surrounding `Field`. |
| onClosePrevented | (() => void) \| undefined | — | Called, without arguments, when `Escape` or an outside interaction was blocked by<br>`closeOnEscape={false}` or `closeOnOutsideClick={false}`. The popup remains open. |
| onExitComplete | (() => void) \| undefined | — | Called once each time the popup finishes its exit after closing. It is not called while<br>the popup is open. |
| onOpenChange | ((open: boolean) => void) \| undefined | — | Called with the next state whenever the popup should open or close (typing, arrow keys,<br>selecting an item, `Escape`, `Tab`, or an outside press). Not called when the state would not<br>change. A disabled select never opens. |
| onReset | (() => void) \| undefined | — | Called after a native `<form>` reset has restored the initial selection (and, in `Combobox`<br>and `MultiSelect`, cleared the search text). It runs in a microtask after the `reset` event<br>and is skipped when the event was default-prevented. In controlled mode the selection stays<br>at `value`, so use this callback to reset your own state. |
| onValueChange | ((value: TItem['value'][]) => void) \| undefined | — | Called with the new array of selected values when the user changes the selection. Not<br>called for prop updates, when the selection is unchanged, or while disabled or read-only. |
| open | boolean \| undefined | — | Controlled popup state. `undefined` keeps it uncontrolled. In controlled mode the popup<br>opens or closes only when you update this prop in `onOpenChange`. Page scrolling is locked<br>while the popup is open. |
| overflowPadding | number \| undefined | 4 | Viewport collision padding in pixels. |
| placement | 'top' \| 'right' \| 'bottom' \| 'left' \| undefined | 'bottom' | Preferred side of the anchor (the control) on which the popup opens. Combined with `align`;<br>see `flip` for when the side can change. |
| readOnly | boolean \| undefined | false | Whether the control is read-only: the value is visible and focusable but cannot be changed,<br>and `aria-readonly` is set. When omitted, the control inherits `readOnly` from the<br>surrounding `Field`. |
| required | boolean \| undefined | false | Whether the control is required, which sets `aria-required` (and the native `required`<br>attribute where the control renders a native input). When omitted, the control inherits<br>`required` from the surrounding `Field`. |
| serializeValue | ((value: TItem['value']) => string \| undefined) \| undefined | — | Maps a selected value to the string submitted under `name`; return `undefined` to omit the<br>value from the submission. Defaults to `String(value)`, omitting items with<br>`disabled: true`. With `multiple`, each selected value is submitted as its own entry. |
| shift | number \| undefined | 0 | Cross-axis offset in pixels from the resolved placement. |
| size | 'sm' \| 'md' \| 'lg' \| undefined | 'md' | Popup and item size. |
| slide | boolean \| undefined | true | Whether the popup may slide along its main axis to remain visible. |
| value | readonly TItem['value'][] \| undefined | — | Controlled selection, always an array. `undefined` keeps it uncontrolled; `[]` keeps it<br>controlled and empty. Single mode uses at most the first value. |
| children | JSX.Element \| undefined | — | Composed trigger and popup parts. |
| classes | Classes \| undefined | — | Family slot class defaults for this instance. |
| styles | Styles \| undefined | — | Family slot style defaults for this instance. |

**`getItemLabel` example**

```tsx
import { Combobox } from 'moraine'

<Combobox
  items={[
    { label: <strong>Apple</strong>, value: 'apple' },
    { label: <strong>Pear</strong>, value: 'pear' },
  ]}
  getItemLabel={(item) => String(item.value)}
/>
```

**`isItemDisabled` example**

```tsx
import { MultiSelect } from 'moraine'

<MultiSelect
  items={[
    { label: 'Admin', value: 'admin' },
    { label: 'Guest', value: 'guest' },
  ]}
  isItemDisabled={(item, values) => item.value === 'guest' && values.includes('admin')}
/>
```

#### BaseSelect.Control

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Trigger

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| disabled | boolean \| undefined | — | Whether this trigger is disabled. |
| as | T \| undefined | 'button' | Element or component to render as. |
| children | JSX.Element \| Component<TriggerRenderProps<TItem>> \| undefined | — | Label or reactive presentation function.<br>A render function must declare its parameter, even when unused. A zero-argument<br>function is called as an accessor and is not mounted as a component. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Content

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Listbox

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Item

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| item* | TItem | — | Raw item belonging to the current navigation collection. |
| children | JSX.Element \| Component<ItemRenderProps<TItem>> \| undefined | — | Visual content or reactive row presentation.<br>A render function must declare its parameter, even when unused. A zero-argument<br>function is called as an accessor and is not mounted as a component. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Group

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.GroupLabel

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Separator

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |

#### BaseSelect.Empty

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| children | JSX.Element \| undefined | — | Content rendered inside the element. |
| class | SlotClassValue \| undefined | — | Class applied to the component root or trigger element. |
| style | SlotStyleValue \| undefined | — | Style applied to the component root or trigger element. |
