solid-baseui 0.1.0-alpha.0

package/dist/lib/types/collapsible/root/CollapsibleRoot.d.ts

@@ -0,0 +1,34 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { REASONS } from '../../internals/reasons.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIChangeEventDetails, BaseUIComponentProps } from '../../types/index.js';
+export interface CollapsibleRootState {
+    /** Whether the component should ignore user interaction. */
+    disabled: boolean;
+    /** Whether the collapsible panel is currently open. */
+    open: boolean;
+    /** The current CSS transition phase. */
+    transitionStatus: TransitionStatus;
+}
+interface CollapsibleRootOwnProps {
+    /** Whether the collapsible panel is initially open. @default false */
+    defaultOpen?: boolean | undefined;
+    /** Whether the component should ignore user interaction. @default false */
+    disabled?: boolean | undefined;
+    /** Event handler called when the panel is opened or closed. */
+    onOpenChange?: ((open: boolean, eventDetails: CollapsibleRootChangeEventDetails) => void) | undefined;
+    /** Whether the collapsible panel is currently open. */
+    open?: boolean | undefined;
+}
+export type CollapsibleRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, CollapsibleRootState, CollapsibleRootOwnProps>;
+export type CollapsibleRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.none;
+export type CollapsibleRootChangeEventDetails = BaseUIChangeEventDetails<CollapsibleRootChangeEventReason>;
+/** Groups all parts of the collapsible. Renders a `<div>` element by default. */
+export declare function CollapsibleRoot<Component extends ValidComponent = 'div'>(props: CollapsibleRoot.Props<Component>): JSX.Element;
+export declare namespace CollapsibleRoot {
+    type State = CollapsibleRootState;
+    type Props<Component extends ValidComponent = 'div'> = CollapsibleRootProps<Component>;
+    type ChangeEventReason = CollapsibleRootChangeEventReason;
+    type ChangeEventDetails = CollapsibleRootChangeEventDetails;
+}
+export {};

package/dist/lib/types/collapsible/root/CollapsibleRootContext.d.ts

@@ -0,0 +1,19 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { CollapsibleRootChangeEventReason, CollapsibleRootState } from './CollapsibleRoot.js';
+export interface CollapsibleRootContextValue {
+    defaultPanelId: string;
+    disabled: Accessor<boolean>;
+    mounted: Accessor<boolean>;
+    open: Accessor<boolean>;
+    panelId: Accessor<string | undefined>;
+    requestOpenChange: (open: boolean, event: Event, reason: CollapsibleRootChangeEventReason, beforeCommit?: (() => void) | undefined) => boolean;
+    setMounted: Setter<boolean>;
+    setPanelIdState: Setter<string | null | undefined>;
+    state: Accessor<CollapsibleRootState>;
+    transitionStatus: Accessor<TransitionStatus>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const CollapsibleRootContext: import("solid-js").Context<CollapsibleRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useCollapsibleRootContext(): CollapsibleRootContextValue;
+export {};

package/dist/lib/types/collapsible/root/createCollapsibleTransitionStatus.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+export interface CollapsibleTransitionStatus {
+    mounted: Accessor<boolean>;
+    setMounted: Setter<boolean>;
+    transitionStatus: Accessor<TransitionStatus>;
+}
+/** Adds an idle phase and a frame boundary before Collapsible exit styles apply. */
+export declare function createCollapsibleTransitionStatus(open: Accessor<boolean>): CollapsibleTransitionStatus;

package/dist/lib/types/collapsible/root/stateAttributesMapping.d.ts

@@ -0,0 +1,14 @@
+export declare const collapsibleStateAttributesMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open(value: boolean): {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+};
+export declare const collapsibleTriggerStateAttributesMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open(value: boolean): {
+        'data-panel-open': string;
+    } | null;
+};

package/dist/lib/types/collapsible/trigger/CollapsibleTrigger.d.ts

@@ -0,0 +1,28 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { CollapsibleRootState } from '../root/CollapsibleRoot.js';
+export interface CollapsibleTriggerState extends CollapsibleRootState {
+}
+type TriggerEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface CollapsibleTriggerOwnProps<Component extends ValidComponent> {
+    /** Whether this trigger should ignore user interaction. */
+    disabled?: boolean | undefined;
+    /** Whether the rendered element is a native button. @default true */
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, PointerEvent> | undefined;
+}
+export type CollapsibleTriggerProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, CollapsibleTriggerState, CollapsibleTriggerOwnProps<Component>>;
+/** A button that opens and closes the collapsible panel. */
+export declare function CollapsibleTrigger<Component extends ValidComponent = 'button'>(props: CollapsibleTrigger.Props<Component>): JSX.Element;
+export declare namespace CollapsibleTrigger {
+    type State = CollapsibleTriggerState;
+    type Props<Component extends ValidComponent = 'button'> = CollapsibleTriggerProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/arrow/ComboboxArrow.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type AnchorAlign, type AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxArrowState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    uncentered: boolean;
+}
+export type ComboboxArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxArrowState>;
+/** Displays an element positioned against the anchor. */
+export declare function ComboboxArrow<Component extends ValidComponent = 'div'>(props: ComboboxArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxArrow {
+    type State = ComboboxArrowState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxArrowProps<Component>;
+}

package/dist/lib/types/combobox/backdrop/ComboboxBackdrop.d.ts

@@ -0,0 +1,14 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+export type ComboboxBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxBackdropState>;
+/** An overlay displayed beneath the popup. */
+export declare function ComboboxBackdrop<Component extends ValidComponent = 'div'>(props: ComboboxBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxBackdrop {
+    type State = ComboboxBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxBackdropProps<Component>;
+}

package/dist/lib/types/combobox/chip/ComboboxChip.d.ts

@@ -0,0 +1,17 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxChipState {
+    disabled: boolean;
+}
+interface ComboboxChipOwnProps {
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type ComboboxChipProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxChipState, ComboboxChipOwnProps>;
+/** An individual chip representing one value in a multiselectable input. */
+export declare function ComboboxChip<Component extends ValidComponent = 'div'>(props: ComboboxChip.Props<Component>): JSX.Element;
+export declare namespace ComboboxChip {
+    type State = ComboboxChipState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxChipProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/chip/ComboboxChipContext.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+export interface ComboboxChipContextValue {
+    index: Accessor<number>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxChipContext: import("solid-js").Context<ComboboxChipContextValue | typeof MISSING_CONTEXT>;
+export declare function useComboboxChipContext(): ComboboxChipContextValue;
+export {};

package/dist/lib/types/combobox/chip-remove/ComboboxChipRemove.d.ts

@@ -0,0 +1,26 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxChipRemoveState {
+    disabled: boolean;
+}
+interface ComboboxChipRemoveOwnProps {
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type ComboboxChipRemoveProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ComboboxChipRemoveState, ComboboxChipRemoveOwnProps>;
+/** A button that removes a chip. */
+export declare function ComboboxChipRemove<Component extends ValidComponent = 'button'>(props: ComboboxChipRemove.Props<Component>): JSX.Element;
+export declare namespace ComboboxChipRemove {
+    type State = ComboboxChipRemoveState;
+    type Props<Component extends ValidComponent = 'button'> = ComboboxChipRemoveProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/chips/ComboboxChips.d.ts

@@ -0,0 +1,16 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxChipsState {
+}
+interface ComboboxChipsOwnProps {
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type ComboboxChipsProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxChipsState, ComboboxChipsOwnProps>;
+/** A container for the chips in a multiselectable input. */
+export declare function ComboboxChips<Component extends ValidComponent = 'div'>(props: ComboboxChips.Props<Component>): JSX.Element;
+export declare namespace ComboboxChips {
+    type State = ComboboxChipsState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxChipsProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/chips/ComboboxChipsContext.d.ts

@@ -0,0 +1,26 @@
+import { type Accessor } from 'solid-js';
+/** The DOM-ordered registry of rendered chips, which the keyboard highlight walks. */
+export declare class ComboboxChipRegistry {
+    private readonly registrations;
+    private readonly revision;
+    private readonly setRevision;
+    private order;
+    private readonly orders;
+    constructor();
+    register(token: symbol, element: Accessor<HTMLElement | null>): () => void;
+    touch(): void;
+    tokens(): symbol[];
+    elements(): Array<HTMLElement | null>;
+    indexOf(token: symbol): number;
+    size(): number;
+}
+export interface ComboboxChipsContextValue {
+    highlightedChipIndex: Accessor<number | undefined>;
+    setHighlightedChipIndex(index: number | undefined): void;
+    chips: ComboboxChipRegistry;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxChipsContext: import("solid-js").Context<ComboboxChipsContextValue | typeof MISSING_CONTEXT>;
+export declare function useComboboxChipsContext(): ComboboxChipsContextValue | undefined;
+export declare function useRequiredComboboxChipsContext(): ComboboxChipsContextValue;
+export {};

package/dist/lib/types/combobox/clear/ComboboxClear.d.ts

@@ -0,0 +1,35 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxClearState {
+    open: boolean;
+    disabled: boolean;
+    visible: boolean;
+    transitionStatus: TransitionStatus;
+}
+interface ComboboxClearOwnProps {
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Whether the component should remain mounted in the DOM when not visible.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type ComboboxClearProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ComboboxClearState, ComboboxClearOwnProps>;
+/** Clears the value when clicked. */
+export declare function ComboboxClear<Component extends ValidComponent = 'button'>(props: ComboboxClear.Props<Component>): JSX.Element;
+export declare namespace ComboboxClear {
+    type State = ComboboxClearState;
+    type Props<Component extends ValidComponent = 'button'> = ComboboxClearProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/collection/ComboboxCollection.d.ts

@@ -0,0 +1,19 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+export interface ComboboxCollectionState {
+}
+export interface ComboboxCollectionProps<Value = unknown> {
+    children: (item: Value, index: Accessor<number>) => JSX.Element;
+}
+/**
+ * Renders the filtered list items, or the items of the enclosing `<Combobox.Group items>`.
+ * Doesn't render its own HTML element.
+ *
+ * If rendering a flat list, pass the same function as a child of `List`, which wraps it
+ * implicitly.
+ */
+export declare function ComboboxCollection<Value = unknown>(props: ComboboxCollection.Props<Value>): JSX.Element;
+export declare namespace ComboboxCollection {
+    type State = ComboboxCollectionState;
+    type Props<Value = unknown> = ComboboxCollectionProps<Value>;
+}

package/dist/lib/types/combobox/empty/ComboboxEmpty.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxEmptyState {
+}
+export type ComboboxEmptyProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxEmptyState>;
+/**
+ * Renders its children only when the list is empty, announcing the change politely.
+ *
+ * The root element must stay mounted for screen readers to announce consistently, so hide or
+ * conditionally render its children rather than the component itself.
+ */
+export declare function ComboboxEmpty<Component extends ValidComponent = 'div'>(props: ComboboxEmpty.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxEmpty {
+    type State = ComboboxEmptyState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxEmptyProps<Component>;
+}

package/dist/lib/types/combobox/group/ComboboxGroup.d.ts

@@ -0,0 +1,19 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxGroupState {
+}
+interface ComboboxGroupOwnProps<Value> {
+    /**
+     * Items rendered within this group. When provided, nested `Collection` components render
+     * these instead of the whole filtered list.
+     */
+    items?: ReadonlyArray<Value> | undefined;
+}
+export type ComboboxGroupProps<Value = unknown, Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxGroupState, ComboboxGroupOwnProps<Value>>;
+/** Groups related items with the corresponding label. */
+export declare function ComboboxGroup<Value = unknown, Component extends ValidComponent = 'div'>(props: ComboboxGroup.Props<Value, Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxGroup {
+    type State = ComboboxGroupState;
+    type Props<Value = unknown, Component extends ValidComponent = 'div'> = ComboboxGroupProps<Value, Component>;
+}
+export {};

package/dist/lib/types/combobox/group/ComboboxGroupContext.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor } from 'solid-js';
+export interface ComboboxGroupContextValue {
+    labelId: Accessor<string | undefined>;
+    setLabelId(id: string | undefined): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxGroupContext: import("solid-js").Context<ComboboxGroupContextValue | typeof MISSING_CONTEXT>;
+export declare function useComboboxGroupContext(): ComboboxGroupContextValue;
+export {};

package/dist/lib/types/combobox/group-label/ComboboxGroupLabel.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxGroupLabelState {
+}
+export type ComboboxGroupLabelProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxGroupLabelState>;
+/** An accessible label automatically associated with its parent group. */
+export declare function ComboboxGroupLabel<Component extends ValidComponent = 'div'>(props: ComboboxGroupLabel.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxGroupLabel {
+    type State = ComboboxGroupLabelState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxGroupLabelProps<Component>;
+}

package/dist/lib/types/combobox/icon/ComboboxIcon.d.ts

@@ -0,0 +1,12 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxIconState {
+    open: boolean;
+}
+export type ComboboxIconProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, ComboboxIconState>;
+/** An icon indicating that the trigger opens the popup. */
+export declare function ComboboxIcon<Component extends ValidComponent = 'span'>(props: ComboboxIcon.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxIcon {
+    type State = ComboboxIconState;
+    type Props<Component extends ValidComponent = 'span'> = ComboboxIconProps<Component>;
+}

package/dist/lib/types/combobox/index.d.ts

@@ -0,0 +1,29 @@
+export * as Combobox from './index.parts.js';
+export type * from './root/ComboboxRoot.js';
+export type * from './label/ComboboxLabel.js';
+export type * from './value/ComboboxValue.js';
+export type * from './input/ComboboxInput.js';
+export type * from './input-group/ComboboxInputGroup.js';
+export type * from './trigger/ComboboxTrigger.js';
+export type * from './list/ComboboxList.js';
+export type * from './status/ComboboxStatus.js';
+export type * from './portal/ComboboxPortal.js';
+export type * from './backdrop/ComboboxBackdrop.js';
+export type * from './positioner/ComboboxPositioner.js';
+export type * from './popup/ComboboxPopup.js';
+export type * from './arrow/ComboboxArrow.js';
+export type * from './icon/ComboboxIcon.js';
+export type * from './group/ComboboxGroup.js';
+export type * from './group-label/ComboboxGroupLabel.js';
+export type * from './item/ComboboxItem.js';
+export type * from './item-indicator/ComboboxItemIndicator.js';
+export type * from './chips/ComboboxChips.js';
+export type * from './chip/ComboboxChip.js';
+export type * from './chip-remove/ComboboxChipRemove.js';
+export type * from './row/ComboboxRow.js';
+export type * from './collection/ComboboxCollection.js';
+export type * from './empty/ComboboxEmpty.js';
+export type * from './clear/ComboboxClear.js';
+export type * from './separator/ComboboxSeparator.js';
+export type * from './types.js';
+export type { ComboboxFilterOptions, Filter as ComboboxFilter, } from './root/utils/useFilter.js';

package/dist/lib/types/combobox/index.parts.d.ts

@@ -0,0 +1,28 @@
+export { ComboboxRoot as Root } from './root/ComboboxRoot.js';
+export { ComboboxLabel as Label } from './label/ComboboxLabel.js';
+export { ComboboxValue as Value } from './value/ComboboxValue.js';
+export { ComboboxInput as Input } from './input/ComboboxInput.js';
+export { ComboboxInputGroup as InputGroup } from './input-group/ComboboxInputGroup.js';
+export { ComboboxTrigger as Trigger } from './trigger/ComboboxTrigger.js';
+export { ComboboxList as List } from './list/ComboboxList.js';
+export { ComboboxStatus as Status } from './status/ComboboxStatus.js';
+export { ComboboxPortal as Portal } from './portal/ComboboxPortal.js';
+export { ComboboxBackdrop as Backdrop } from './backdrop/ComboboxBackdrop.js';
+export { ComboboxPositioner as Positioner } from './positioner/ComboboxPositioner.js';
+export { ComboboxPopup as Popup } from './popup/ComboboxPopup.js';
+export { ComboboxArrow as Arrow } from './arrow/ComboboxArrow.js';
+export { ComboboxIcon as Icon } from './icon/ComboboxIcon.js';
+export { ComboboxGroup as Group } from './group/ComboboxGroup.js';
+export { ComboboxGroupLabel as GroupLabel } from './group-label/ComboboxGroupLabel.js';
+export { ComboboxItem as Item } from './item/ComboboxItem.js';
+export { ComboboxItemIndicator as ItemIndicator } from './item-indicator/ComboboxItemIndicator.js';
+export { ComboboxChips as Chips } from './chips/ComboboxChips.js';
+export { ComboboxChip as Chip } from './chip/ComboboxChip.js';
+export { ComboboxChipRemove as ChipRemove } from './chip-remove/ComboboxChipRemove.js';
+export { ComboboxRow as Row } from './row/ComboboxRow.js';
+export { ComboboxCollection as Collection } from './collection/ComboboxCollection.js';
+export { ComboboxEmpty as Empty } from './empty/ComboboxEmpty.js';
+export { ComboboxClear as Clear } from './clear/ComboboxClear.js';
+export { ComboboxSeparator as Separator } from './separator/ComboboxSeparator.js';
+export { useFilter } from './root/utils/useFilter.js';
+export { useFilteredItems } from './root/utils/useFilteredItems.js';

package/dist/lib/types/combobox/input/ComboboxInput.d.ts

@@ -0,0 +1,36 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type FieldState } from '../../internals/field-constants.js';
+import type { AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxInputState extends FieldState {
+    open: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    popupSide: AnchorSide | null;
+    listEmpty: boolean;
+}
+interface ComboboxInputOwnProps {
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLInputElement, FocusEvent> | undefined;
+    onCompositionEnd?: BaseUIEventHandlerUnion<HTMLInputElement, CompositionEvent> | undefined;
+    onCompositionStart?: BaseUIEventHandlerUnion<HTMLInputElement, CompositionEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLInputElement, FocusEvent> | undefined;
+    onInput?: BaseUIEventHandlerUnion<HTMLInputElement, InputEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLInputElement, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLInputElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLInputElement, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<HTMLInputElement, PointerEvent> | undefined;
+}
+export type ComboboxInputProps<Component extends ValidComponent = 'input'> = BaseUIComponentProps<Component, ComboboxInputState, ComboboxInputOwnProps>;
+/** A text input to search for items in the list. */
+export declare function ComboboxInput<Component extends ValidComponent = 'input'>(props: ComboboxInput.Props<Component>): JSX.Element;
+export declare namespace ComboboxInput {
+    type State = ComboboxInputState;
+    type Props<Component extends ValidComponent = 'input'> = ComboboxInputProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/input-group/ComboboxInputGroup.d.ts

@@ -0,0 +1,24 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { FieldState } from '../../internals/field-constants.js';
+import { type AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxInputGroupState extends FieldState {
+    open: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    popupSide: AnchorSide | null;
+    listEmpty: boolean;
+    placeholder: boolean;
+}
+interface ComboboxInputGroupOwnProps {
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type ComboboxInputGroupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxInputGroupState, ComboboxInputGroupOwnProps>;
+/** A wrapper for the input and its associated controls. */
+export declare function ComboboxInputGroup<Component extends ValidComponent = 'div'>(props: ComboboxInputGroup.Props<Component>): JSX.Element;
+export declare namespace ComboboxInputGroup {
+    type State = ComboboxInputGroupState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxInputGroupProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/item/ComboboxItem.d.ts

@@ -0,0 +1,40 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxItemState {
+    disabled: boolean;
+    selected: boolean;
+    highlighted: boolean;
+}
+interface ComboboxItemOwnProps<Value> {
+    /**
+     * A unique value that identifies this item.
+     * @default null
+     */
+    value?: Value | undefined;
+    /**
+     * The index of the item in the list. Improves performance when specified, and is required for
+     * externally virtualized lists whose rows do not all exist in the DOM.
+     */
+    index?: number | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerLeave?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type ComboboxItemProps<Value = unknown, Component extends ValidComponent = 'div'> = Omit<BaseUIComponentProps<Component, ComboboxItemState, ComboboxItemOwnProps<Value>>, 'id'>;
+/** An individual item in the list. */
+export declare function ComboboxItem<Value = unknown, Component extends ValidComponent = 'div'>(props: ComboboxItem.Props<Value, Component>): JSX.Element;
+export declare namespace ComboboxItem {
+    type State = ComboboxItemState;
+    type Props<Value = unknown, Component extends ValidComponent = 'div'> = ComboboxItemProps<Value, Component>;
+}
+export {};

package/dist/lib/types/combobox/item/ComboboxItemContext.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor } from 'solid-js';
+export interface ComboboxItemContextValue {
+    selected: Accessor<boolean>;
+    index: Accessor<number>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxItemContext: import("solid-js").Context<ComboboxItemContextValue | typeof MISSING_CONTEXT>;
+export declare function useComboboxItemContext(): ComboboxItemContextValue;
+export {};

package/dist/lib/types/combobox/item-indicator/ComboboxItemIndicator.d.ts

@@ -0,0 +1,22 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxItemIndicatorState {
+    selected: boolean;
+    transitionStatus: TransitionStatus;
+}
+interface ComboboxItemIndicatorOwnProps {
+    /**
+     * Whether to keep the HTML element in the DOM when the item is not selected.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+export type ComboboxItemIndicatorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, ComboboxItemIndicatorState, ComboboxItemIndicatorOwnProps>;
+/** Indicates whether the enclosing item is selected. */
+export declare function ComboboxItemIndicator<Component extends ValidComponent = 'span'>(props: ComboboxItemIndicator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxItemIndicator {
+    type State = ComboboxItemIndicatorState;
+    type Props<Component extends ValidComponent = 'span'> = ComboboxItemIndicatorProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/label/ComboboxLabel.d.ts

@@ -0,0 +1,22 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type FieldState } from '../../internals/field-constants.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export type ComboboxLabelState = FieldState;
+interface ComboboxLabelOwnProps {
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type ComboboxLabelProps<Component extends ValidComponent = 'div'> = Omit<BaseUIComponentProps<Component, ComboboxLabelState, ComboboxLabelOwnProps>, 'id'>;
+/**
+ * An accessible label automatically associated with the combobox trigger.
+ *
+ * When `<Combobox.Input>` is the form control rather than a popup field, use a native `<label>`
+ * or `<Field.Label>` instead; this part labels the trigger.
+ */
+export declare function ComboboxLabel<Component extends ValidComponent = 'div'>(props: ComboboxLabel.Props<Component>): JSX.Element;
+export declare namespace ComboboxLabel {
+    type State = ComboboxLabelState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxLabelProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/list/ComboboxList.d.ts

@@ -0,0 +1,24 @@
+import { type Accessor } from 'solid-js';
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxListState {
+    empty: boolean;
+}
+interface ComboboxListOwnProps<Value> {
+    children?: JSX.Element | ((item: Value, index: Accessor<number>) => JSX.Element);
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type ComboboxListProps<Value = unknown, Component extends ValidComponent = 'div'> = Omit<BaseUIComponentProps<Component, ComboboxListState, ComboboxListOwnProps<Value>>, 'children'> & ComboboxListOwnProps<Value>;
+/**
+ * A list container for the items.
+ *
+ * A function child is implicitly wrapped in `<Combobox.Collection>`, so a flat list can be
+ * rendered without naming the collection part.
+ */
+export declare function ComboboxList<Value = unknown, Component extends ValidComponent = 'div'>(props: ComboboxList.Props<Value, Component>): JSX.Element;
+export declare namespace ComboboxList {
+    type State = ComboboxListState;
+    type Props<Value = unknown, Component extends ValidComponent = 'div'> = ComboboxListProps<Value, Component>;
+}
+export {};