solid-baseui 0.1.0-alpha.0

package/dist/lib/types/select/item-indicator/SelectItemIndicator.d.ts

@@ -0,0 +1,18 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectItemIndicatorState {
+    selected: boolean;
+    transitionStatus: TransitionStatus;
+}
+interface SelectItemIndicatorOwnProps {
+    keepMounted?: boolean | undefined;
+}
+export type SelectItemIndicatorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, SelectItemIndicatorState, SelectItemIndicatorOwnProps>;
+/** Indicates whether the enclosing select item is selected. */
+export declare function SelectItemIndicator<Component extends ValidComponent = 'span'>(props: SelectItemIndicator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectItemIndicator {
+    type State = SelectItemIndicatorState;
+    type Props<Component extends ValidComponent = 'span'> = SelectItemIndicatorProps<Component>;
+}
+export {};

package/dist/lib/types/select/item-text/SelectItemText.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectItemTextState {
+}
+export type SelectItemTextProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectItemTextState>;
+/** The primary text of a select item. */
+export declare function SelectItemText<Component extends ValidComponent = 'div'>(props: SelectItemText.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectItemText {
+    type State = SelectItemTextState;
+    type Props<Component extends ValidComponent = 'div'> = SelectItemTextProps<Component>;
+}

package/dist/lib/types/select/label/SelectLabel.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';
+import type { FieldRootState } from '../../field/root/FieldRoot.js';
+export type SelectLabelState = FieldRootState;
+interface SelectLabelOwnProps {
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type SelectLabelProps<Component extends ValidComponent = 'div'> = Omit<BaseUIComponentProps<Component, SelectLabelState, SelectLabelOwnProps>, 'id'>;
+/** An accessible label automatically associated with the select trigger. */
+export declare function SelectLabel<Component extends ValidComponent = 'div'>(props: SelectLabel.Props<Component>): JSX.Element;
+export declare namespace SelectLabel {
+    type State = SelectLabelState;
+    type Props<Component extends ValidComponent = 'div'> = SelectLabelProps<Component>;
+}
+export {};

package/dist/lib/types/select/list/SelectList.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 SelectListState {
+}
+interface SelectListOwnProps {
+    onScroll?: BaseUIEventHandlerUnion<HTMLElement, Event> | undefined;
+}
+export type SelectListProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectListState, SelectListOwnProps>;
+/** A scrolling container for select items. */
+export declare function SelectList<Component extends ValidComponent = 'div'>(props: SelectList.Props<Component>): JSX.Element;
+export declare namespace SelectList {
+    type State = SelectListState;
+    type Props<Component extends ValidComponent = 'div'> = SelectListProps<Component>;
+}
+export {};

package/dist/lib/types/select/popup/SelectPopup.d.ts

@@ -0,0 +1,26 @@
+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 declare const SELECT_LIST_FUNCTIONAL_STYLES: JSX.CSSProperties;
+export interface SelectPopupState {
+    side: AnchorSide | 'none';
+    align: AnchorAlign;
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+interface SelectPopupOwnProps {
+    finalFocus?: FocusResolver | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onScroll?: BaseUIEventHandlerUnion<HTMLElement, Event> | undefined;
+}
+export type SelectPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectPopupState, SelectPopupOwnProps>;
+/** A container for the select list. */
+export declare function SelectPopup<Component extends ValidComponent = 'div'>(props: SelectPopup.Props<Component>): JSX.Element;
+export declare namespace SelectPopup {
+    type State = SelectPopupState;
+    type Props<Component extends ValidComponent = 'div'> = SelectPopupProps<Component>;
+}
+export {};

package/dist/lib/types/select/portal/SelectPortal.d.ts

@@ -0,0 +1,16 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type PopupPortalContainer } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectPortalState {
+}
+interface SelectPortalOwnProps {
+    container?: PopupPortalContainer | undefined;
+}
+export type SelectPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectPortalState, SelectPortalOwnProps>;
+/** Moves the select layer into a portal appended to the document body by default. */
+export declare function SelectPortal<Component extends ValidComponent = 'div'>(props: SelectPortal.Props<Component>): JSX.Element;
+export declare namespace SelectPortal {
+    type State = SelectPortalState;
+    type Props<Component extends ValidComponent = 'div'> = SelectPortalProps<Component>;
+}
+export {};

package/dist/lib/types/select/portal/SelectPortalContext.d.ts

@@ -0,0 +1,4 @@
+declare const MISSING_CONTEXT: unique symbol;
+export declare const SelectPortalContext: import("solid-js").Context<true | typeof MISSING_CONTEXT>;
+export declare function useSelectPortalContext(): void;
+export {};

package/dist/lib/types/select/positioner/SelectPositioner.d.ts

@@ -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 SelectAnchor = ReferenceElement | Accessor<ReferenceElement | null> | {
+    current: ReferenceElement | null;
+} | null;
+export interface SelectPositionerState {
+    open: boolean;
+    side: AnchorSide | 'none';
+    align: AnchorAlign;
+    anchorHidden: boolean;
+}
+interface SelectPositionerOwnProps {
+    anchor?: SelectAnchor | 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;
+    alignItemWithTrigger?: boolean | undefined;
+}
+export type SelectPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectPositionerState, SelectPositionerOwnProps>;
+/** Positions the select popup against its trigger or a custom anchor. */
+export declare function SelectPositioner<Component extends ValidComponent = 'div'>(props: SelectPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectPositioner {
+    type State = SelectPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = SelectPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/select/positioner/SelectPositionerContext.d.ts

@@ -0,0 +1,16 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { AnchorAlign, AnchorPositioning, AnchorSide } from '../../internals/overlay/index.js';
+export interface SelectPositionerContextValue extends AnchorPositioning {
+    side: Accessor<AnchorSide | 'none'>;
+    align: Accessor<AnchorAlign>;
+    alignItemWithTriggerActive: Accessor<boolean>;
+    setControlledAlignItemWithTrigger: Setter<boolean>;
+    scrollUpArrow: Accessor<HTMLElement | null>;
+    setScrollUpArrow(element: HTMLElement | null): void;
+    scrollDownArrow: Accessor<HTMLElement | null>;
+    setScrollDownArrow(element: HTMLElement | null): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const SelectPositionerContext: import("solid-js").Context<SelectPositionerContextValue | typeof MISSING_CONTEXT>;
+export declare function useSelectPositionerContext(): SelectPositionerContextValue;
+export {};

package/dist/lib/types/select/root/SelectRoot.d.ts

@@ -0,0 +1,52 @@
+import { type Ref } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { SelectItems } from '../types.js';
+import { type SelectItemComparator } from '../utils/equality.js';
+type SelectValueType<Value, Multiple extends boolean | undefined> = Multiple extends true ? Value[] : Value;
+export interface SelectRootProps<Value, Multiple extends boolean | undefined = false> {
+    children?: JSX.Element;
+    inputRef?: Ref<HTMLInputElement>;
+    name?: string | undefined;
+    form?: string | undefined;
+    autoComplete?: string | undefined;
+    id?: string | undefined;
+    required?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+    multiple?: Multiple | undefined;
+    highlightItemOnHover?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    onOpenChange?: ((open: boolean, details: SelectRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    open?: boolean | undefined;
+    modal?: boolean | undefined;
+    actionsRef?: ((actions: SelectRootActions) => void) | undefined;
+    items?: SelectItems<Value> | undefined;
+    itemToStringLabel?: ((value: Value) => string) | undefined;
+    itemToStringValue?: ((value: Value) => string) | undefined;
+    isItemEqualToValue?: SelectItemComparator<Value> | undefined;
+    defaultValue?: SelectValueType<Value, Multiple> | null | undefined;
+    value?: SelectValueType<Value, Multiple> | null | undefined;
+    onValueChange?: ((value: SelectValueType<Value, Multiple> | (Multiple extends true ? never : null), details: SelectRootChangeEventDetails) => void) | undefined;
+}
+export interface SelectRootState {
+}
+export interface SelectRootActions {
+    unmount(): void;
+}
+export type SelectRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.windowResize | typeof REASONS.itemPress | typeof REASONS.focusOut | typeof REASONS.listNavigation | typeof REASONS.cancelOpen | typeof REASONS.none;
+export type SelectRootChangeEventDetails = BaseUIChangeEventDetails<SelectRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+/** Groups all parts of the select without rendering a wrapper element. */
+export declare function SelectRoot<Value, Multiple extends boolean | undefined = false>(props: SelectRoot.Props<Value, Multiple>): JSX.Element;
+export declare namespace SelectRoot {
+    type Props<Value, Multiple extends boolean | undefined = false> = SelectRootProps<Value, Multiple>;
+    type State = SelectRootState;
+    type Actions = SelectRootActions;
+    type ChangeEventReason = SelectRootChangeEventReason;
+    type ChangeEventDetails = SelectRootChangeEventDetails;
+}
+export {};

package/dist/lib/types/select/root/SelectRootContext.d.ts

@@ -0,0 +1,63 @@
+import { type Accessor } from 'solid-js';
+import type { FieldRootContextValue } from '../../internals/field-root-context/FieldRootContext.js';
+import type { FormContextValue } from '../../internals/form-context/FormContext.js';
+import type { FloatingNode, FloatingTreeStore, PopupPresence } from '../../internals/overlay/index.js';
+import type { SelectItems } from '../types.js';
+import type { SelectItemComparator } from '../utils/equality.js';
+import type { SelectRootChangeEventDetails } from './SelectRoot.js';
+import type { SelectStore } from '../store/SelectStore.js';
+export interface SelectRootContextValue<Value = unknown> {
+    store: SelectStore<Value>;
+    tree: FloatingTreeStore;
+    node: FloatingNode;
+    presence: PopupPresence;
+    id: Accessor<string>;
+    value: Accessor<Value | Value[] | null>;
+    items: Accessor<SelectItems<Value> | undefined>;
+    multiple: Accessor<boolean>;
+    disabled: Accessor<boolean>;
+    readOnly: Accessor<boolean>;
+    required: Accessor<boolean>;
+    modal: Accessor<boolean>;
+    highlightItemOnHover: Accessor<boolean>;
+    itemToStringLabel: Accessor<((value: Value) => string) | undefined>;
+    itemToStringValue: Accessor<((value: Value) => string) | undefined>;
+    comparator: Accessor<SelectItemComparator<Value>>;
+    hasSelectedValue: Accessor<boolean>;
+    selectedIndex: Accessor<number | null>;
+    setValue(value: Value | Value[] | null, details: SelectRootChangeEventDetails): boolean;
+    setOpen(open: boolean, details: SelectRootChangeEventDetails): boolean;
+    setTriggerElement(element: HTMLElement | null): void;
+    triggerElement: Accessor<HTMLElement | null>;
+    valueElement: Accessor<HTMLElement | null>;
+    setValueElement(element: HTMLElement | null): void;
+    firstItemText: Accessor<HTMLElement | null>;
+    selectedItemText: Accessor<HTMLElement | null>;
+    setFirstItemText(element: HTMLElement | null): void;
+    setSelectedItemText(element: HTMLElement | null): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleTypeaheadBlur(event: FocusEvent): void;
+    handleScroll(scroller: HTMLElement): void;
+    updateScrollArrowVisibility(scroller: HTMLElement): void;
+    scrollHandler: {
+        current: ((scroller: HTMLElement) => void) | null;
+    };
+    scrollArrowsMounted: {
+        count: number;
+    };
+    field: FieldRootContextValue;
+    formContext: FormContextValue;
+    backdropElement: Accessor<HTMLElement | null>;
+    setBackdropElement(element: HTMLElement | null): void;
+    internalBackdropElement: Accessor<HTMLElement | null>;
+    setInternalBackdropElement(element: HTMLElement | null): void;
+    beforeContentGuard: Accessor<HTMLElement | null>;
+    setBeforeContentGuard(element: HTMLElement | null): void;
+    afterTriggerGuard: Accessor<HTMLElement | null>;
+    setAfterTriggerGuard(element: HTMLElement | null): void;
+    initialValue: Value | Value[] | null;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const SelectRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | SelectRootContextValue<unknown>>;
+export declare function useSelectRootContext<Value = unknown>(): SelectRootContextValue<Value>;
+export {};

package/dist/lib/types/select/scroll-arrow/SelectScrollArrow.d.ts

@@ -0,0 +1,22 @@
+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';
+import type { AnchorSide } from '../../internals/overlay/index.js';
+export interface SelectScrollArrowState {
+    direction: 'up' | 'down';
+    visible: boolean;
+    side: AnchorSide | 'none';
+    transitionStatus: TransitionStatus;
+}
+interface SelectScrollArrowOwnProps {
+    direction: 'up' | 'down';
+    keepMounted?: boolean | undefined;
+    onMouseLeave?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type SelectScrollArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectScrollArrowState, SelectScrollArrowOwnProps>;
+/** @internal */
+export declare function SelectScrollArrow<Component extends ValidComponent = 'div'>(props: SelectScrollArrowProps<Component>): JSX.Element;
+export declare function getTargetScrollTop(items: Array<HTMLElement | null>, isUp: boolean, scrollTop: number, clientHeight: number, arrowHeight: number, maximum: number): number;
+export {};

package/dist/lib/types/select/scroll-down-arrow/SelectScrollDownArrow.d.ts

@@ -0,0 +1,15 @@
+import type { ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectScrollDownArrowState {
+}
+interface SelectScrollDownArrowOwnProps {
+    keepMounted?: boolean | undefined;
+}
+export type SelectScrollDownArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectScrollDownArrowState, SelectScrollDownArrowOwnProps>;
+/** An element that scrolls the select popup down when hovered. */
+export declare function SelectScrollDownArrow<Component extends ValidComponent = 'div'>(props: SelectScrollDownArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectScrollDownArrow {
+    type State = SelectScrollDownArrowState;
+    type Props<Component extends ValidComponent = 'div'> = SelectScrollDownArrowProps<Component>;
+}
+export {};

package/dist/lib/types/select/scroll-up-arrow/SelectScrollUpArrow.d.ts

@@ -0,0 +1,15 @@
+import type { ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectScrollUpArrowState {
+}
+interface SelectScrollUpArrowOwnProps {
+    keepMounted?: boolean | undefined;
+}
+export type SelectScrollUpArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectScrollUpArrowState, SelectScrollUpArrowOwnProps>;
+/** An element that scrolls the select popup up when hovered. */
+export declare function SelectScrollUpArrow<Component extends ValidComponent = 'div'>(props: SelectScrollUpArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectScrollUpArrow {
+    type State = SelectScrollUpArrowState;
+    type Props<Component extends ValidComponent = 'div'> = SelectScrollUpArrowProps<Component>;
+}
+export {};

package/dist/lib/types/select/separator/SelectSeparator.d.ts

@@ -0,0 +1,17 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { Orientation } from '../../internals/types.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectSeparatorState {
+    orientation: Orientation;
+}
+interface SelectSeparatorOwnProps {
+    orientation?: Orientation | undefined;
+}
+export type SelectSeparatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectSeparatorState, SelectSeparatorOwnProps>;
+/** A presentational divider between select items or groups. */
+export declare function SelectSeparator<Component extends ValidComponent = 'div'>(props: SelectSeparator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectSeparator {
+    type State = SelectSeparatorState;
+    type Props<Component extends ValidComponent = 'div'> = SelectSeparatorProps<Component>;
+}
+export {};

package/dist/lib/types/select/store/SelectCollection.d.ts

@@ -0,0 +1,25 @@
+import { type Accessor } from 'solid-js';
+export interface SelectCollectionItem<Value = unknown> {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | null>;
+    textElement: Accessor<HTMLElement | null>;
+    value: Accessor<Value>;
+    label: Accessor<string | undefined>;
+    disabled: Accessor<boolean>;
+}
+export declare class SelectCollection<Value = unknown> {
+    private readonly registrations;
+    private readonly revision;
+    private readonly setRevision;
+    private order;
+    constructor();
+    register(item: Omit<SelectCollectionItem<Value>, 'order'>): () => void;
+    touch(): void;
+    items(): SelectCollectionItem<Value>[];
+    indexOf(token: symbol): number;
+    elements(): Array<HTMLElement | null>;
+    labels(): Array<string | null>;
+    values(): Value[];
+    disabledIndices(): number[];
+}

package/dist/lib/types/select/store/SelectStore.d.ts

@@ -0,0 +1,82 @@
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { PopupStore, type InteractionType, type PopupStoreOptions } from '../../internals/overlay/index.js';
+import type { AnchorSide } from '../../internals/overlay/createAnchorPositioning.js';
+import type { SelectRootChangeEventDetails, SelectRootChangeEventReason } from '../root/SelectRoot.js';
+import { SelectCollection } from './SelectCollection.js';
+export interface SelectStoreOptions extends PopupStoreOptions<SelectRootChangeEventDetails> {
+}
+export declare class SelectStore<Value = unknown> extends PopupStore<never, SelectRootChangeEventDetails> {
+    readonly collection: SelectCollection<Value>;
+    readonly selection: {
+        allowSelectedMouseUp: boolean;
+        allowUnselectedMouseUp: boolean;
+        dragY: number;
+    };
+    private readonly activeElementAccessor;
+    private readonly setActiveElementSignal;
+    private activeElementValue;
+    private readonly openMethodAccessor;
+    private readonly setOpenMethodSignal;
+    private readonly openReasonAccessor;
+    private readonly setOpenReasonSignal;
+    private readonly forceMountAccessor;
+    private readonly setForceMountSignal;
+    private readonly labelIdAccessor;
+    private readonly setLabelIdSignal;
+    private readonly listElementAccessor;
+    private readonly setListElementSignal;
+    private readonly popupSideAccessor;
+    private readonly setPopupSideSignal;
+    private readonly scrollUpVisibleAccessor;
+    private readonly setScrollUpVisibleSignal;
+    private readonly scrollDownVisibleAccessor;
+    private readonly setScrollDownVisibleSignal;
+    private readonly hasScrollArrowsAccessor;
+    private readonly setHasScrollArrowsSignal;
+    private readonly alignItemAccessor;
+    private readonly setAlignItemSignal;
+    private readonly typingAccessor;
+    private readonly setTypingSignal;
+    private forceMountAllowed;
+    private focusSequence;
+    private scrollFrame;
+    private pointerX;
+    private pointerY;
+    private pointerHoverBlocked;
+    private readonly pointerMovements;
+    private pointerHoverFrame;
+    constructor(options: SelectStoreOptions);
+    activeIndex(): number | null;
+    activeElement(): HTMLElement | null;
+    setActiveIndex(index: number | null, focus?: boolean): void;
+    setActiveElement(element: HTMLElement | null): void;
+    trackPointer(event: MouseEvent | PointerEvent): void;
+    pointerMoved(event: MouseEvent | PointerEvent): boolean;
+    blockPointerHover(windowNode: Window | null): void;
+    openMethod(): InteractionType | null;
+    setOpenMethod(method: InteractionType | null): void;
+    openChangeReason(): SelectRootChangeEventReason | null;
+    forceMount(): boolean;
+    setForceMount(value: boolean): void;
+    suppressForceMount(): void;
+    labelId(): string | undefined;
+    setLabelId(value: string | undefined): void;
+    listElement(): HTMLElement | null;
+    setListElement(value: HTMLElement | null): void;
+    popupSide(): AnchorSide | null;
+    setPopupSide(value: AnchorSide | null): void;
+    scrollUpVisible(): boolean;
+    setScrollUpVisible(value: boolean): void;
+    scrollDownVisible(): boolean;
+    setScrollDownVisible(value: boolean): void;
+    hasScrollArrows(): boolean;
+    setHasScrollArrows(value: boolean): void;
+    alignItemWithTrigger(): boolean;
+    setAlignItemWithTrigger(value: boolean): void;
+    typing(): boolean;
+    setTyping(value: boolean): void;
+    resetAfterClose(): void;
+    dispose(): void;
+    setOpen(open: boolean, details: SelectRootChangeEventDetails): boolean;
+}
+export type AnySelectChangeDetails = BaseUIChangeEventDetails<string>;

package/dist/lib/types/select/trigger/SelectTrigger.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { FieldRootState } from '../../field/root/FieldRoot.js';
+import { type AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectTriggerState extends FieldRootState {
+    open: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    popupSide: AnchorSide | null;
+    value: unknown;
+    placeholder: boolean;
+}
+type TriggerTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface SelectTriggerOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onBlur?: BaseUIEventHandlerUnion<TriggerTarget<Component>, FocusEvent> | undefined;
+    onClick?: BaseUIEventHandlerUnion<TriggerTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<TriggerTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TriggerTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<TriggerTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<TriggerTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TriggerTarget<Component>, PointerEvent> | undefined;
+}
+export type SelectTriggerProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, SelectTriggerState, SelectTriggerOwnProps<Component>>;
+/** A button that opens the select popup. */
+export declare function SelectTrigger<Component extends ValidComponent = 'button'>(props: SelectTrigger.Props<Component>): JSX.Element;
+export declare namespace SelectTrigger {
+    type State = SelectTriggerState;
+    type Props<Component extends ValidComponent = 'button'> = SelectTriggerProps<Component>;
+}
+export {};

package/dist/lib/types/select/types.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from '@solidjs/web';
+export interface SelectItemDefinition<Value = unknown> {
+    label: JSX.Element;
+    value: Value;
+}
+export interface SelectGroupDefinition<Value = unknown> {
+    heading?: JSX.Element;
+    items: ReadonlyArray<SelectItemDefinition<Value>>;
+}
+export type SelectItems<Value = unknown> = Record<string, JSX.Element> | ReadonlyArray<SelectItemDefinition<Value>> | ReadonlyArray<SelectGroupDefinition<Value>>;

package/dist/lib/types/select/utils/equality.d.ts

@@ -0,0 +1,2 @@
+export type { ItemEqualityComparer as SelectItemComparator } from '../../internals/itemEquality.js';
+export { areItemArraysEqual as areValueArraysEqual, compareItemEquality, defaultItemEquality, findItemIndex, removeItem, } from '../../internals/itemEquality.js';

package/dist/lib/types/select/utils/mergeSelectStyles.d.ts

@@ -0,0 +1 @@
+export { mergeStyleValue as mergeSelectStyles } from '../../internals/mergeStyleValue.js';

package/dist/lib/types/select/utils/scrollEdges.d.ts

@@ -0,0 +1,3 @@
+export declare const SCROLL_EDGE_TOLERANCE = 1;
+export declare function getMaxScrollOffset(scrollSize: number, clientSize: number): number;
+export declare function normalizeScrollOffset(offset: number, maximum: number): number;

package/dist/lib/types/select/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,37 @@
+export declare const selectTriggerStateMapping: {
+    popupSide: (value: import("../../internals/overlay/createAnchorPositioning.js").AnchorSide | null) => {
+        'data-popup-side': import("../../internals/overlay/createAnchorPositioning.js").AnchorSide;
+    } | null;
+    value: () => null;
+    disabled?: ((state: boolean) => Record<string, string> | null) | undefined;
+    touched?: ((state: boolean) => Record<string, string> | null) | undefined;
+    dirty?: ((state: boolean) => Record<string, string> | null) | undefined;
+    valid?: ((state: boolean | null) => Record<string, string> | null) | undefined;
+    filled?: ((state: boolean) => Record<string, string> | null) | undefined;
+    focused?: ((state: boolean) => Record<string, string> | null) | undefined;
+    open: (value: boolean) => {
+        'data-popup-open': string;
+        'data-pressed': string;
+    } | null;
+};
+export declare const selectPositionerStateMapping: {
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const selectPopupStateMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};

package/dist/lib/types/select/utils/value.d.ts

@@ -0,0 +1,7 @@
+import type { JSX } from '@solidjs/web';
+import type { SelectItems } from '../types.js';
+export declare function serializeValue<Value>(value: Value | null | undefined, itemToStringValue?: ((value: Value) => string) | undefined): string;
+export declare function stringifyAsLabel<Value>(value: Value | null | undefined, itemToStringLabel?: ((value: Value) => string) | undefined): string;
+export declare function resolveSelectedLabel<Value>(value: Value | null, items: SelectItems<Value> | undefined, itemToStringLabel?: ((value: Value) => string) | undefined): JSX.Element;
+export declare function resolveMultipleLabels<Value>(values: readonly Value[], items: SelectItems<Value> | undefined, itemToStringLabel?: ((value: Value) => string) | undefined): JSX.Element;
+export declare function hasNullItemLabel<Value>(items: SelectItems<Value> | undefined): boolean;

package/dist/lib/types/select/value/SelectValue.d.ts

@@ -0,0 +1,18 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectValueState {
+    value: unknown;
+    placeholder: boolean;
+}
+interface SelectValueOwnProps {
+    children?: JSX.Element | ((value: unknown) => JSX.Element);
+    placeholder?: JSX.Element;
+}
+export type SelectValueProps<Component extends ValidComponent = 'span'> = Omit<BaseUIComponentProps<Component, SelectValueState, SelectValueOwnProps>, 'children'> & SelectValueOwnProps;
+/** Displays the selected value or a placeholder. */
+export declare function SelectValue<Component extends ValidComponent = 'span'>(props: SelectValue.Props<Component>): JSX.Element;
+export declare namespace SelectValue {
+    type State = SelectValueState;
+    type Props<Component extends ValidComponent = 'span'> = SelectValueProps<Component>;
+}
+export {};

package/dist/lib/types/separator/Separator.d.ts

@@ -0,0 +1,19 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { Orientation } from '../internals/types.js';
+import type { BaseUIComponentProps } from '../types/index.js';
+export interface SeparatorState {
+    /** The orientation of the separator. */
+    orientation: Orientation;
+}
+interface SeparatorOwnProps {
+    /** The orientation of the separator. @default 'horizontal' */
+    orientation?: Orientation | undefined;
+}
+export type SeparatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SeparatorState, SeparatorOwnProps>;
+/** A separator element accessible to screen readers. */
+export declare function Separator<Component extends ValidComponent = 'div'>(props: Separator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace Separator {
+    type State = SeparatorState;
+    type Props<Component extends ValidComponent = 'div'> = SeparatorProps<Component>;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { Separator } from './Separator.js';
+export type { SeparatorProps, SeparatorState } from './Separator.js';