npm - solid-baseui - Versions diffs - 0.1.0-alpha.0 - Mend

solid-baseui 0.1.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (810) hide show

package/dist/lib/types/combobox/popup/ComboboxPopup.d.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type AnchorAlign, type AnchorSide, type FocusResolver } from '../../internals/overlay/index.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxPopupState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    transitionStatus: TransitionStatus;
+    empty: boolean;
+    /** Set when the open or close should skip its animation, such as an Escape dismissal. */
+    instant: 'delay' | 'dismiss' | 'focus' | undefined;
+}
+interface ComboboxPopupOwnProps {
+    /**
+     * Determines the element to focus when the popup is opened.
+     * - `false`: do not move focus.
+     * - `true`: use the default behavior.
+     * - an element or a function of the interaction type: focus that element.
+     */
+    initialFocus?: FocusResolver | undefined;
+    /** Determines the element to focus when the popup is closed. */
+    finalFocus?: FocusResolver | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+}
+export type ComboboxPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxPopupState, ComboboxPopupOwnProps>;
+/** A container for the list. */
+export declare function ComboboxPopup<Component extends ValidComponent = 'div'>(props: ComboboxPopup.Props<Component>): JSX.Element;
+export declare namespace ComboboxPopup {
+    type State = ComboboxPopupState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxPopupProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/portal/ComboboxPortal.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type PopupPortalContainer } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxPortalState {
+}
+interface ComboboxPortalOwnProps {
+    /** A parent element to render the portal element into. */
+    container?: PopupPortalContainer | undefined;
+    /**
+     * Whether to keep the portal mounted in the DOM while the popup is hidden.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+export type ComboboxPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxPortalState, ComboboxPortalOwnProps>;
+/**
+ * Moves the popup to a different part of the DOM. By default the portal element is appended to
+ * `<body>`.
+ */
+export declare function ComboboxPortal<Component extends ValidComponent = 'div'>(props: ComboboxPortal.Props<Component>): JSX.Element;
+export declare namespace ComboboxPortal {
+    type State = ComboboxPortalState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxPortalProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/portal/ComboboxPortalContext.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxPortalContext: import("solid-js").Context<boolean | typeof MISSING_CONTEXT>;
+/** The enclosing portal's `keepMounted`, which the positioner needs while it stays mounted. */
+export declare function useComboboxPortalContext(): boolean;
+export {};

package/dist/lib/types/combobox/positioner/ComboboxPositioner.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import { type Accessor } from 'solid-js';
+import { type ValidComponent } from '@solidjs/web';
+import type { ReferenceElement, Strategy } from '@floating-ui/dom';
+import { type AnchorAlign, type AnchorBoundary, type AnchorSide, type CollisionAvoidance, type OffsetFunction } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export type ComboboxAnchor = ReferenceElement | Accessor<ReferenceElement | null> | {
+    current: ReferenceElement | null;
+} | null;
+export interface ComboboxPositionerState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    empty: boolean;
+}
+interface ComboboxPositionerOwnProps {
+    anchor?: ComboboxAnchor | undefined;
+    positionMethod?: Strategy | undefined;
+    side?: AnchorSide | undefined;
+    sideOffset?: number | OffsetFunction | undefined;
+    align?: AnchorAlign | undefined;
+    alignOffset?: number | OffsetFunction | undefined;
+    collisionBoundary?: AnchorBoundary | undefined;
+    collisionPadding?: number | Partial<Record<'top' | 'right' | 'bottom' | 'left', number>> | undefined;
+    arrowPadding?: number | undefined;
+    sticky?: boolean | undefined;
+    disableAnchorTracking?: boolean | undefined;
+    collisionAvoidance?: CollisionAvoidance | undefined;
+}
+export type ComboboxPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxPositionerState, ComboboxPositionerOwnProps>;
+/** Positions the popup against the input, or against the trigger when the input is inside it. */
+export declare function ComboboxPositioner<Component extends ValidComponent = 'div'>(props: ComboboxPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxPositioner {
+    type State = ComboboxPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/positioner/ComboboxPositionerContext.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { type Accessor } from 'solid-js';
+import type { AnchorAlign, AnchorPositioning, AnchorSide } from '../../internals/overlay/index.js';
+export interface ComboboxPositionerContextValue extends AnchorPositioning {
+    side: Accessor<AnchorSide>;
+    align: Accessor<AnchorAlign>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ComboboxPositionerContext: import("solid-js").Context<ComboboxPositionerContextValue | typeof MISSING_CONTEXT>;
+export declare function useComboboxPositionerContext(optional?: false): ComboboxPositionerContextValue;
+export declare function useComboboxPositionerContext(optional: true): ComboboxPositionerContextValue | undefined;
+export {};

package/dist/lib/types/combobox/root/AriaCombobox.d.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import { type Ref } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import { type BaseUIChangeEventDetails, type BaseUIGenericEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { type ItemEqualityComparer } from '../../internals/itemEquality.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { ComboboxAutoComplete, ComboboxAutoHighlight, ComboboxItemFilter, ComboboxItemsInput, ComboboxSelectionMode } from '../types.js';
+export type ComboboxRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.inputPress | typeof REASONS.outsidePress | typeof REASONS.itemPress | typeof REASONS.closePress | typeof REASONS.escapeKey | typeof REASONS.listNavigation | typeof REASONS.focusOut | typeof REASONS.inputChange | typeof REASONS.inputClear | typeof REASONS.clearPress | typeof REASONS.chipRemovePress | typeof REASONS.cancelOpen | typeof REASONS.none;
+export type ComboboxRootChangeEventDetails = BaseUIChangeEventDetails<ComboboxRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export type ComboboxHighlightEventReason = typeof REASONS.keyboard | typeof REASONS.pointer | typeof REASONS.none;
+export type ComboboxHighlightEventDetails = BaseUIGenericEventDetails<ComboboxHighlightEventReason, {
+    index: number;
+}>;
+export interface ComboboxRootActions {
+    /** Unmounts the popup. Call after an externally controlled closing animation finishes. */
+    unmount(): void;
+}
+export interface AriaComboboxState {
+}
+type ComboboxItemValueType<Item, Mode extends ComboboxSelectionMode> = Mode extends 'multiple' ? Item[] : Item;
+export interface AriaComboboxProps<Value, Mode extends ComboboxSelectionMode = 'none'> {
+    children?: JSX.Element;
+    /** How the combobox remembers what was picked. */
+    selectionMode: Mode;
+    selectedValue?: ComboboxItemValueType<Value, Mode> | null | undefined;
+    defaultSelectedValue?: ComboboxItemValueType<Value, Mode> | null | undefined;
+    onSelectedValueChange?: ((value: ComboboxItemValueType<Value, Mode>, details: ComboboxRootChangeEventDetails) => void) | undefined;
+    name?: string | undefined;
+    form?: string | undefined;
+    id?: string | undefined;
+    required?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    open?: boolean | undefined;
+    onOpenChange?: ((open: boolean, details: ComboboxRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    openOnInputClick?: boolean | undefined;
+    autoHighlight?: ComboboxAutoHighlight | undefined;
+    keepHighlight?: boolean | undefined;
+    highlightItemOnHover?: boolean | undefined;
+    loopFocus?: boolean | undefined;
+    inputValue?: string | undefined;
+    defaultInputValue?: string | undefined;
+    onInputValueChange?: ((value: string, details: ComboboxRootChangeEventDetails) => void) | undefined;
+    actionsRef?: ((actions: ComboboxRootActions) => void) | undefined;
+    onItemHighlighted?: ((itemValue: Value | undefined, details: ComboboxHighlightEventDetails) => void) | undefined;
+    inputRef?: Ref<HTMLInputElement>;
+    grid?: boolean | undefined;
+    items?: ComboboxItemsInput<Value> | undefined;
+    filteredItems?: ComboboxItemsInput<Value> | undefined;
+    filter?: ComboboxItemFilter<Value> | null | undefined;
+    itemToStringLabel?: ((itemValue: Value) => string) | undefined;
+    itemToStringValue?: ((itemValue: Value) => string) | undefined;
+    isItemEqualToValue?: ItemEqualityComparer<Value> | undefined;
+    virtualized?: boolean | undefined;
+    inline?: boolean | undefined;
+    modal?: boolean | undefined;
+    limit?: number | undefined;
+    autoComplete?: ComboboxAutoComplete | undefined;
+    formAutoComplete?: string | undefined;
+    locale?: Intl.LocalesArgument | undefined;
+    submitOnItemClick?: boolean | undefined;
+    /** INTERNAL: with `selectionMode="none"`, whether selecting an item fills the input. */
+    fillInputOnItemPress?: boolean | undefined;
+}
+/**
+ * The shared combobox engine behind `Combobox.Root` and `Autocomplete.Root`.
+ * @internal
+ */
+export declare function AriaCombobox<Value, Mode extends ComboboxSelectionMode = 'none'>(props: AriaComboboxProps<Value, Mode>): JSX.Element;
+export declare namespace AriaCombobox {
+    type Props<Value, Mode extends ComboboxSelectionMode = 'none'> = AriaComboboxProps<Value, Mode>;
+    type State = AriaComboboxState;
+    type Actions = ComboboxRootActions;
+    type ChangeEventReason = ComboboxRootChangeEventReason;
+    type ChangeEventDetails = ComboboxRootChangeEventDetails;
+    type HighlightEventReason = ComboboxHighlightEventReason;
+    type HighlightEventDetails = ComboboxHighlightEventDetails;
+}
+export {};

package/dist/lib/types/combobox/root/ComboboxRoot.d.ts ADDED Viewed

@@ -0,0 +1,180 @@
+import type { JSX } from '@solidjs/web';
+import type { ItemEqualityComparer } from '../../internals/itemEquality.js';
+import type { ComboboxItemFilter, ComboboxItemsInput } from '../types.js';
+import { type AriaComboboxState, type ComboboxHighlightEventDetails, type ComboboxHighlightEventReason, type ComboboxRootActions, type ComboboxRootChangeEventDetails, type ComboboxRootChangeEventReason } from './AriaCombobox.js';
+type ComboboxValueType<Value, Multiple extends boolean | undefined> = Multiple extends true ? Value[] : Value;
+export interface ComboboxRootProps<Value, Multiple extends boolean | undefined = false> {
+    children?: JSX.Element;
+    /**
+     * Whether multiple items can be selected.
+     * @default false
+     */
+    multiple?: Multiple | undefined;
+    /** The selected value of the combobox. Use when controlled. */
+    value?: ComboboxValueType<Value, Multiple> | null | undefined;
+    /**
+     * The uncontrolled selected value when initially rendered.
+     *
+     * To render a controlled combobox, use the `value` prop instead.
+     */
+    defaultValue?: ComboboxValueType<Value, Multiple> | null | undefined;
+    /** Event handler called when the selected value changes. */
+    onValueChange?: ((value: ComboboxValueType<Value, Multiple> | (Multiple extends true ? never : null), eventDetails: ComboboxRootChangeEventDetails) => void) | undefined;
+    /** Identifies the field when a form is submitted. */
+    name?: string | undefined;
+    /**
+     * Identifies the form that owns the internal input.
+     * Useful when the combobox is rendered outside the form.
+     */
+    form?: string | undefined;
+    /** The id of the component. */
+    id?: string | undefined;
+    /**
+     * Whether the user must choose a value before submitting a form.
+     * @default false
+     */
+    required?: boolean | undefined;
+    /**
+     * Whether the user should be unable to choose a different option from the popup.
+     * @default false
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Whether the popup is initially open.
+     *
+     * To render a controlled popup, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /** Whether the popup is currently open. Use when controlled. */
+    open?: boolean | undefined;
+    /** Event handler called when the popup is opened or closed. */
+    onOpenChange?: ((open: boolean, eventDetails: ComboboxRootChangeEventDetails) => void) | undefined;
+    /** Event handler called after any animations complete when the popup is opened or closed. */
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    /**
+     * Whether the popup opens when clicking the input.
+     * @default true
+     */
+    openOnInputClick?: boolean | undefined;
+    /**
+     * Whether the first matching item is highlighted automatically while filtering.
+     * @default false
+     */
+    autoHighlight?: boolean | undefined;
+    /**
+     * Whether the highlighted item should be preserved when the pointer leaves the list.
+     * @default false
+     */
+    keepHighlight?: boolean | undefined;
+    /**
+     * Whether moving the pointer over items should highlight them.
+     * Disabling this prop allows CSS `:hover` to be differentiated from the `:focus`
+     * (`data-highlighted`) state.
+     * @default true
+     */
+    highlightItemOnHover?: boolean | undefined;
+    /**
+     * Whether to loop keyboard focus back to the input when the end of the list is reached with the
+     * arrow keys. The input is always part of the focus loop per ARIA Authoring Practices.
+     * @default true
+     */
+    loopFocus?: boolean | undefined;
+    /** The input value of the combobox. Use when controlled. */
+    inputValue?: string | undefined;
+    /** The uncontrolled input value when initially rendered. */
+    defaultInputValue?: string | undefined;
+    /** Event handler called when the input value changes. */
+    onInputValueChange?: ((inputValue: string, eventDetails: ComboboxRootChangeEventDetails) => void) | undefined;
+    /**
+     * Receives imperative actions.
+     * - `unmount`: manually unmounts the combobox after an externally controlled closing animation.
+     */
+    actionsRef?: ((actions: ComboboxRootActions) => void) | undefined;
+    /**
+     * Callback fired when an item is highlighted or unhighlighted. The `reason` is `'keyboard'`,
+     * `'pointer'`, or `'none'` for a programmatic change.
+     */
+    onItemHighlighted?: ((highlightedValue: Value | undefined, eventDetails: ComboboxHighlightEventDetails) => void) | undefined;
+    /** A ref to the hidden input element. */
+    inputRef?: JSX.HTMLAttributes<HTMLInputElement>['ref'];
+    /**
+     * Whether list items are presented in a grid layout.
+     * When enabled, arrow keys navigate across the rows and columns inferred from DOM rows.
+     * @default false
+     */
+    grid?: boolean | undefined;
+    /** The items to display, either a flat array or an array of groups. */
+    items?: ComboboxItemsInput<Value> | undefined;
+    /**
+     * Filtered items to display in the list. When provided, the list uses these instead of
+     * filtering `items` internally. Use with the `useFilter()` helper.
+     */
+    filteredItems?: ComboboxItemsInput<Value> | undefined;
+    /** Filter function used to match items against the input query. */
+    filter?: ComboboxItemFilter<Value> | null | undefined;
+    /**
+     * Converts an object item value to the string shown in the input.
+     * A `{ value, label }` shape uses its label automatically.
+     */
+    itemToStringLabel?: ((itemValue: Value) => string) | undefined;
+    /**
+     * Converts an object item value to the string submitted with a form.
+     * A `{ value, label }` shape uses its value automatically.
+     */
+    itemToStringValue?: ((itemValue: Value) => string) | undefined;
+    /**
+     * Custom comparison used to decide whether an item matches the selected value.
+     * Defaults to `Object.is`.
+     */
+    isItemEqualToValue?: ItemEqualityComparer<Value> | undefined;
+    /**
+     * Whether the items are being externally virtualized.
+     * @default false
+     */
+    virtualized?: boolean | undefined;
+    /**
+     * Whether the list is rendered inline without the component's own popup.
+     * Specify `open` unconditionally alongside this prop.
+     * @default false
+     */
+    inline?: boolean | undefined;
+    /**
+     * Whether the popup enters a modal state when open.
+     * @default false
+     */
+    modal?: boolean | undefined;
+    /**
+     * The maximum number of items to display in the list.
+     * @default -1
+     */
+    limit?: number | undefined;
+    /** Provides a hint to the browser for autofill. */
+    autoComplete?: string | undefined;
+    /** The locale used for string comparison. Defaults to the runtime locale. */
+    locale?: Intl.LocalesArgument | undefined;
+}
+export interface ComboboxRootState extends AriaComboboxState {
+}
+/**
+ * Groups all parts of the combobox.
+ * Doesn't render its own HTML element.
+ */
+export declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false>(props: ComboboxRoot.Props<Value, Multiple>): JSX.Element;
+export type { ComboboxRootActions, ComboboxRootChangeEventDetails, ComboboxRootChangeEventReason, };
+export type ComboboxRootHighlightEventReason = ComboboxHighlightEventReason;
+export type ComboboxRootHighlightEventDetails = ComboboxHighlightEventDetails;
+export declare namespace ComboboxRoot {
+    type Props<Value, Multiple extends boolean | undefined = false> = ComboboxRootProps<Value, Multiple>;
+    type State = ComboboxRootState;
+    type Actions = ComboboxRootActions;
+    type ChangeEventReason = ComboboxRootChangeEventReason;
+    type ChangeEventDetails = ComboboxRootChangeEventDetails;
+    type HighlightEventReason = ComboboxHighlightEventReason;
+    type HighlightEventDetails = ComboboxHighlightEventDetails;
+}

package/dist/lib/types/combobox/root/ComboboxRootContext.d.ts ADDED Viewed

@@ -0,0 +1,99 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { FieldRootContextValue } from '../../internals/field-root-context/FieldRootContext.js';
+import type { FormContextValue } from '../../internals/form-context/FormContext.js';
+import type { ItemEqualityComparer } from '../../internals/itemEquality.js';
+import type { ClickInteractionHandlers, DismissHandlers, FloatingNode, FloatingTreeStore, ListNavigationHandlers, PopupPresence } from '../../internals/overlay/index.js';
+import type { ComboboxStore } from '../store/ComboboxStore.js';
+import type { ComboboxAutoComplete, ComboboxItemGroup, ComboboxItemsInput, ComboboxSelectionMode, ResolvedAutoHighlight } from '../types.js';
+import type { ComboboxHighlightEventReason, ComboboxRootChangeEventDetails } from './AriaCombobox.js';
+export interface ComboboxIndicesUpdate {
+    activeIndex?: number | null | undefined;
+    selectedIndex?: number | null | undefined;
+    type?: ComboboxHighlightEventReason | undefined;
+}
+export interface ComboboxRootContextValue<Value = unknown> {
+    store: ComboboxStore<Value>;
+    tree: FloatingTreeStore;
+    node: FloatingNode;
+    presence: PopupPresence;
+    id: Accessor<string>;
+    /** The raw `items` prop, before filtering. */
+    items: Accessor<ComboboxItemsInput<Value>>;
+    hasItems: Accessor<boolean>;
+    /** The trimmed query the list is filtered by, frozen while the popup animates out. */
+    query: Accessor<string>;
+    filteredItems: Accessor<ReadonlyArray<Value> | ReadonlyArray<ComboboxItemGroup<Value>>>;
+    flatFilteredItems: Accessor<ReadonlyArray<Value>>;
+    listEmpty: Accessor<boolean>;
+    /** Item values addressed by index, whether they come from `items` or from rendered items. */
+    itemValues: Accessor<ReadonlyArray<Value>>;
+    selectedValue: Accessor<Value | Value[] | null>;
+    inputValue: Accessor<string>;
+    hasSelectedValue: Accessor<boolean>;
+    hasSelectionChips: Accessor<boolean>;
+    selectionMode: Accessor<ComboboxSelectionMode>;
+    multiple: Accessor<boolean>;
+    single: Accessor<boolean>;
+    disabled: Accessor<boolean>;
+    readOnly: Accessor<boolean>;
+    required: Accessor<boolean>;
+    modal: Accessor<boolean>;
+    grid: Accessor<boolean>;
+    virtualized: Accessor<boolean>;
+    inline: Accessor<boolean>;
+    openOnInputClick: Accessor<boolean>;
+    autoHighlight: Accessor<ResolvedAutoHighlight>;
+    keepHighlight: Accessor<boolean>;
+    highlightItemOnHover: Accessor<boolean>;
+    loopFocus: Accessor<boolean>;
+    autoComplete: Accessor<ComboboxAutoComplete>;
+    submitOnItemClick: Accessor<boolean>;
+    hasInputValueProp: Accessor<boolean>;
+    name: Accessor<string | undefined>;
+    form: Accessor<string | undefined>;
+    itemToStringLabel: Accessor<((itemValue: Value) => string) | undefined>;
+    itemToStringValue: Accessor<((itemValue: Value) => string) | undefined>;
+    comparator: Accessor<ItemEqualityComparer<Value>>;
+    inputElement: Accessor<HTMLInputElement | null>;
+    setInputElement(element: HTMLInputElement | null): void;
+    triggerElement: Accessor<HTMLElement | null>;
+    setTriggerElement(element: HTMLElement | null): void;
+    inputGroupElement: Accessor<HTMLElement | null>;
+    setInputGroupElement(element: HTMLElement | null): void;
+    internalBackdropElement: Accessor<HTMLElement | null>;
+    setInternalBackdropElement(element: HTMLElement | null): void;
+    setOpen(open: boolean, details: ComboboxRootChangeEventDetails): boolean;
+    setInputValue(value: string, details: ComboboxRootChangeEventDetails): void;
+    setSelectedValue(value: Value | Value[] | null, details: ComboboxRootChangeEventDetails): void;
+    setIndices(update: ComboboxIndicesUpdate): void;
+    handleSelection(event: MouseEvent | PointerEvent | KeyboardEvent, itemValue: Value): void;
+    /** Mounts the closed list (or derives its labels) so typeahead and autofill can match. */
+    forceMount(): void;
+    requestSubmit(): void;
+    focusInput(): void;
+    /** Clicks the item at `index`, tagging the keyboard event that stood in for the press. */
+    clickHighlightedItem(index: number, event: KeyboardEvent): void;
+    listNavigation: ListNavigationHandlers;
+    dismiss: DismissHandlers;
+    click: ClickInteractionHandlers;
+    cols: Accessor<number>;
+    /** ARIA the reference control carries; `undefined` while a non-input trigger stays collapsed. */
+    referenceAria: Accessor<Record<string, string | undefined>>;
+    expanded: Accessor<boolean>;
+    field: FieldRootContextValue;
+    formContext: FormContextValue;
+}
+export interface ComboboxGroupCollectionContextValue<Value = unknown> {
+    /** `undefined` when the enclosing group does not scope its own items. */
+    items: Accessor<ReadonlyArray<Value> | undefined>;
+}
+declare const MISSING_ROOT: unique symbol;
+export declare const ComboboxRootContext: import("solid-js").Context<typeof MISSING_ROOT | ComboboxRootContextValue<never>>;
+export declare function useComboboxRootContext<Value = unknown>(): ComboboxRootContextValue<Value>;
+declare const MISSING_GROUP_COLLECTION: unique symbol;
+/** Scopes `<Combobox.Collection>` to the items of the enclosing `<Combobox.Group items>`. */
+export declare const ComboboxGroupCollectionContext: import("solid-js").Context<typeof MISSING_GROUP_COLLECTION | ComboboxGroupCollectionContextValue<never>>;
+export declare function useComboboxGroupCollectionContext<Value = unknown>(): ComboboxGroupCollectionContextValue<Value> | undefined;
+export type ComboboxCollectionChildren<Value = unknown> = (item: Value, index: number) => JSX.Element;
+export {};

package/dist/lib/types/combobox/root/utils/useFilter.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { type Filter, type FilterOptions } from '../../../internals/filter.js';
+export type { Filter, FilterOptions };
+export interface ComboboxFilterOptions extends FilterOptions {
+    /**
+     * Whether the combobox is in multiple selection mode.
+     * @default false
+     */
+    multiple?: boolean | undefined;
+    /** The current selected value, so a single selection's own label never filters the list. */
+    value?: unknown;
+}
+/** Matches items against the query, showing every item while nothing has been typed. */
+export declare function createCollatorItemFilter<Item>(collatorFilter: Filter, itemToStringLabel?: ((item: Item) => string) | undefined): (item: Item, query: string) => boolean;
+/**
+ * The single-selection variant. A query that exactly matches the current selection's label shows
+ * every item again, so reopening the popup on a chosen value stays browsable.
+ */
+export declare function createSingleSelectionCollatorFilter<Item>(collatorFilter: Filter, itemToStringLabel?: ((item: Item) => string) | undefined, selectedValue?: unknown): (item: Item, query: string) => boolean;
+/**
+ * Matches items against a query using `Intl.Collator` for robust string matching.
+ *
+ * Options may be a plain object or an accessor; either way they are read at match time, so a
+ * changing `value` or `locale` is picked up without recreating the filter.
+ */
+export declare function useFilter(options?: ComboboxFilterOptions | (() => ComboboxFilterOptions)): Filter;

package/dist/lib/types/combobox/root/utils/useFilteredItems.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { Accessor } from 'solid-js';
+/**
+ * The internally filtered items, as an accessor so consumers stay reactive to the query.
+ */
+export declare function useFilteredItems<Item>(): Accessor<ReadonlyArray<Item>>;

package/dist/lib/types/combobox/row/ComboboxRow.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxRowState {
+}
+export type ComboboxRowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxRowState>;
+/**
+ * A single row of items in a grid list.
+ * Enable `grid` on the root component to turn the listbox into a grid.
+ */
+export declare function ComboboxRow<Component extends ValidComponent = 'div'>(props: ComboboxRow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxRow {
+    type State = ComboboxRowState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxRowProps<Component>;
+}

package/dist/lib/types/combobox/row/ComboboxRowContext.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare const ComboboxRowContext: import("solid-js").Context<boolean>;
+/** Whether the enclosing list is a grid row, which turns items into grid cells. */
+export declare function useComboboxRowContext(): boolean;

package/dist/lib/types/combobox/separator/ComboboxSeparator.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { Orientation } from '../../internals/types.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxSeparatorState {
+    orientation: Orientation;
+}
+interface ComboboxSeparatorOwnProps {
+    /**
+     * The orientation of the separator.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation | undefined;
+}
+export type ComboboxSeparatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxSeparatorState, ComboboxSeparatorOwnProps>;
+/** A visual separator between items or groups. */
+export declare function ComboboxSeparator<Component extends ValidComponent = 'div'>(props: ComboboxSeparator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxSeparator {
+    type State = ComboboxSeparatorState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxSeparatorProps<Component>;
+}
+export {};

package/dist/lib/types/combobox/status/ComboboxStatus.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxStatusState {
+}
+export type ComboboxStatusProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ComboboxStatusState>;
+/**
+ * Displays a status message whose content changes are announced politely, which is useful for
+ * the loading state of an asynchronously fetched list.
+ *
+ * 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 ComboboxStatus<Component extends ValidComponent = 'div'>(props: ComboboxStatus.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace ComboboxStatus {
+    type State = ComboboxStatusState;
+    type Props<Component extends ValidComponent = 'div'> = ComboboxStatusProps<Component>;
+}

package/dist/lib/types/combobox/store/ComboboxItemRegistry.d.ts ADDED Viewed

@@ -0,0 +1,39 @@
+import { type Accessor } from 'solid-js';
+export interface ComboboxItemRegistration<Value = unknown> {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | null>;
+    value: Accessor<Value>;
+    /** An explicit `index` prop, which wins over the DOM-derived position. */
+    index: Accessor<number | undefined>;
+    disabled: Accessor<boolean>;
+}
+/**
+ * The live registry of rendered `<Combobox.Item>` elements.
+ *
+ * Registration order seeds the position; once every item has an element the list is ordered by
+ * document position so a reordered or conditionally rendered list keeps indices in sync with
+ * what the user sees. An item that declares an explicit `index` keeps that index instead, which
+ * is how externally virtualized and `items`-driven lists address their windowed rows.
+ */
+export declare class ComboboxItemRegistry<Value = unknown> {
+    private readonly registrations;
+    private readonly revision;
+    private readonly setRevision;
+    private order;
+    constructor();
+    register(item: Omit<ComboboxItemRegistration<Value>, 'order'>): () => void;
+    touch(): void;
+    items(): ComboboxItemRegistration<Value>[];
+    /** The index the item at `token` occupies, or `-1` when it is not registered. */
+    indexOf(token: symbol): number;
+    /**
+     * DOM elements addressed by index. Explicit indices can leave holes, which list navigation
+     * treats as absent rather than disabled.
+     */
+    elements(): Array<HTMLElement | null>;
+    values(): Value[];
+    labels(): Array<string | null>;
+    disabledIndices(): number[];
+    size(): number;
+}