solid-baseui 0.1.0-alpha.0

package/dist/lib/types/progress/value/ProgressValue.d.ts

@@ -0,0 +1,16 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ProgressRootState } from '../root/ProgressRoot.js';
+export interface ProgressValueState extends ProgressRootState {
+}
+interface ProgressValueOwnProps {
+    children?: null | ((formattedValue: string, value: number | null) => JSX.Element) | undefined;
+}
+export type ProgressValueProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, ProgressValueState, ProgressValueOwnProps>;
+/** Displays the progress's formatted current value. */
+export declare function ProgressValue<Component extends ValidComponent = 'span'>(props: ProgressValue.Props<Component>): JSX.Element;
+export declare namespace ProgressValue {
+    type State = ProgressValueState;
+    type Props<Component extends ValidComponent = 'span'> = ProgressValueProps<Component>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * as Radio from './index.parts.js';
+export type * from './root/RadioRoot.js';
+export type * from './indicator/RadioIndicator.js';

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

@@ -0,0 +1,2 @@
+export { RadioRoot as Root } from './root/RadioRoot.js';
+export { RadioIndicator as Indicator } from './indicator/RadioIndicator.js';

package/dist/lib/types/radio/indicator/RadioIndicator.d.ts

@@ -0,0 +1,20 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { RadioRootState } from '../root/RadioRoot.js';
+export interface RadioIndicatorState extends RadioRootState {
+    /** The current CSS transition phase. */
+    transitionStatus: TransitionStatus;
+}
+interface RadioIndicatorOwnProps {
+    /** Keeps the indicator mounted while the radio is unchecked. @default false */
+    keepMounted?: boolean | undefined;
+}
+export type RadioIndicatorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, RadioIndicatorState, RadioIndicatorOwnProps>;
+/** Indicates whether the enclosing radio is selected. */
+export declare function RadioIndicator<Component extends ValidComponent = 'span'>(props: RadioIndicator.Props<Component>): JSX.Element;
+export declare namespace RadioIndicator {
+    type State = RadioIndicatorState;
+    type Props<Component extends ValidComponent = 'span'> = RadioIndicatorProps<Component>;
+}
+export {};

package/dist/lib/types/radio/root/RadioRoot.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from 'solid-js';
+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 { BaseUIComponentProps } from '../../types/index.js';
+export interface RadioRootState extends FieldRootState {
+    /** Whether the radio is selected. */
+    checked: boolean;
+    /** Whether the radio ignores user interaction. */
+    disabled: boolean;
+    /** Whether the user should be unable to select the radio. */
+    readOnly: boolean;
+    /** Whether the group requires a value. */
+    required: boolean;
+}
+type RadioRootEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface RadioRootOwnProps<Value, Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    id?: string | undefined;
+    inputRef?: Ref<HTMLInputElement>;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<RadioRootEventTarget<Component>, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<RadioRootEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<RadioRootEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<RadioRootEventTarget<Component>, KeyboardEvent> | undefined;
+    readOnly?: boolean | undefined;
+    required?: boolean | undefined;
+    value: Value;
+}
+export type RadioRootProps<Value = any, Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, RadioRootState, RadioRootOwnProps<Value, Component>>;
+/** Represents the visible radio and renders a hidden native radio beside it. */
+export declare function RadioRoot<Value = any, Component extends ValidComponent = 'span'>(props: RadioRoot.Props<Value, Component>): JSX.Element;
+export declare namespace RadioRoot {
+    type State = RadioRootState;
+    type Props<Value = any, Component extends ValidComponent = 'span'> = RadioRootProps<Value, Component>;
+}
+export {};

package/dist/lib/types/radio/root/RadioRootContext.d.ts

@@ -0,0 +1,7 @@
+import { type Accessor } from 'solid-js';
+import type { RadioRootState } from './RadioRoot.js';
+export type RadioRootContextValue = Accessor<RadioRootState>;
+declare const MISSING_CONTEXT: unique symbol;
+export declare const RadioRootContext: import("solid-js").Context<RadioRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useRadioRootContext(): RadioRootContextValue;
+export {};

package/dist/lib/types/radio-group/RadioGroup.d.ts

@@ -0,0 +1,43 @@
+import { type Ref } from 'solid-js';
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../internals/composeEventHandlers.js';
+import { createChangeEventDetails } from '../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../internals/reasons.js';
+import type { FieldRootState } from '../field/root/FieldRoot.js';
+import type { BaseUIComponentProps } from '../types/index.js';
+export interface RadioGroupState extends FieldRootState {
+    /** Whether the user should be unable to select a different radio. */
+    readOnly: boolean;
+    /** Whether the user must choose a value before submitting a form. */
+    required: boolean;
+}
+type RadioGroupEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onKeyDown?: JSX.EventHandlerUnion<infer Target, KeyboardEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface RadioGroupOwnProps<Value, Component extends ValidComponent> {
+    defaultValue?: Value | undefined;
+    disabled?: boolean | undefined;
+    form?: string | undefined;
+    id?: string | undefined;
+    inputRef?: Ref<HTMLInputElement>;
+    name?: string | undefined;
+    onBlur?: BaseUIEventHandlerUnion<RadioGroupEventTarget<Component>, FocusEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<RadioGroupEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<RadioGroupEventTarget<Component>, KeyboardEvent> | undefined;
+    onValueChange?: ((value: Value, eventDetails: RadioGroupChangeEventDetails) => void) | undefined;
+    readOnly?: boolean | undefined;
+    required?: boolean | undefined;
+    value?: Value | undefined;
+}
+export type RadioGroupProps<Value = any, Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, RadioGroupState, RadioGroupOwnProps<Value, Component>>;
+/** Provides shared selection, form, and keyboard state to a series of radios. */
+export declare function RadioGroup<Value = any, Component extends ValidComponent = 'div'>(props: RadioGroup.Props<Value, Component>): JSX.Element;
+export type RadioGroupChangeEventReason = typeof REASONS.none;
+export type RadioGroupChangeEventDetails = ReturnType<typeof createChangeEventDetails<RadioGroupChangeEventReason>>;
+export declare namespace RadioGroup {
+    type State = RadioGroupState;
+    type Props<Value = any, Component extends ValidComponent = 'div'> = RadioGroupProps<Value, Component>;
+    type ChangeEventReason = RadioGroupChangeEventReason;
+    type ChangeEventDetails = RadioGroupChangeEventDetails;
+}
+export {};

package/dist/lib/types/radio-group/RadioGroupContext.d.ts

@@ -0,0 +1,33 @@
+import { type Accessor } from 'solid-js';
+import type { BaseUIChangeEventDetails } from '../types/index.js';
+import type { RadioGroupState } from './RadioGroup.js';
+export interface RegisteredRadio<Value = unknown> {
+    token: symbol;
+    checked: Accessor<boolean>;
+    disabled: Accessor<boolean>;
+    element: Accessor<HTMLElement | undefined>;
+    input: Accessor<HTMLInputElement | undefined>;
+    value: Accessor<Value>;
+}
+export interface RadioGroupContextValue<Value = unknown> {
+    checkedValue: Accessor<Value | undefined>;
+    disabled: Accessor<boolean>;
+    fieldControlSource: symbol;
+    form: Accessor<string | undefined>;
+    name: Accessor<string | undefined>;
+    readOnly: Accessor<boolean>;
+    required: Accessor<boolean>;
+    state: Accessor<RadioGroupState>;
+    touched: Accessor<boolean>;
+    isTabStop: (radio: RegisteredRadio<Value>) => boolean;
+    notifyRadioChange: () => void;
+    registerRadio: (radio: RegisteredRadio<Value>) => () => void;
+    selectValue: (value: Value, eventDetails: BaseUIChangeEventDetails<'none'>) => boolean;
+    setActiveRadio: (radio: RegisteredRadio<Value>) => void;
+    setTouched: (value: boolean) => void;
+    syncInputs: () => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const RadioGroupContext: import("solid-js").Context<RadioGroupContextValue<any> | typeof MISSING_CONTEXT>;
+export declare function useRadioGroupContext<Value = unknown>(): RadioGroupContextValue<Value> | undefined;
+export {};

package/dist/lib/types/radio-group/index.d.ts

@@ -0,0 +1,2 @@
+export { RadioGroup } from './RadioGroup.js';
+export type * from './RadioGroup.js';

package/dist/lib/types/scroll-area/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SCROLL_TIMEOUT = 500;
+export declare const MIN_THUMB_SIZE = 16;

package/dist/lib/types/scroll-area/content/ScrollAreaContent.d.ts

@@ -0,0 +1,12 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ScrollAreaRootState } from '../root/ScrollAreaRoot.js';
+export interface ScrollAreaContentState extends ScrollAreaRootState {
+}
+export type ScrollAreaContentProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaContentState>;
+/** Contains the scroll area's content and observes dynamic size changes. */
+export declare function ScrollAreaContent<Component extends ValidComponent = 'div'>(props: ScrollAreaContent.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaContent {
+    type State = ScrollAreaContentState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaContentProps<Component>;
+}

package/dist/lib/types/scroll-area/corner/ScrollAreaCorner.d.ts

@@ -0,0 +1,11 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ScrollAreaCornerState {
+}
+export type ScrollAreaCornerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaCornerState>;
+/** Fills the intersection between horizontal and vertical scrollbars. */
+export declare function ScrollAreaCorner<Component extends ValidComponent = 'div'>(props: ScrollAreaCorner.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaCorner {
+    type State = ScrollAreaCornerState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaCornerProps<Component>;
+}

package/dist/lib/types/scroll-area/index.d.ts

@@ -0,0 +1,7 @@
+export * as ScrollArea from './index.parts.js';
+export type * from './root/ScrollAreaRoot.js';
+export type * from './viewport/ScrollAreaViewport.js';
+export type * from './scrollbar/ScrollAreaScrollbar.js';
+export type * from './content/ScrollAreaContent.js';
+export type * from './thumb/ScrollAreaThumb.js';
+export type * from './corner/ScrollAreaCorner.js';

package/dist/lib/types/scroll-area/index.parts.d.ts

@@ -0,0 +1,6 @@
+export { ScrollAreaRoot as Root } from './root/ScrollAreaRoot.js';
+export { ScrollAreaViewport as Viewport } from './viewport/ScrollAreaViewport.js';
+export { ScrollAreaScrollbar as Scrollbar } from './scrollbar/ScrollAreaScrollbar.js';
+export { ScrollAreaContent as Content } from './content/ScrollAreaContent.js';
+export { ScrollAreaThumb as Thumb } from './thumb/ScrollAreaThumb.js';
+export { ScrollAreaCorner as Corner } from './corner/ScrollAreaCorner.js';

package/dist/lib/types/scroll-area/root/ScrollAreaRoot.d.ts

@@ -0,0 +1,58 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ScrollAreaEventTarget } from '../utils/eventTarget.js';
+declare const DEFAULT_SIZE: {
+    width: number;
+    height: number;
+};
+declare const DEFAULT_OVERFLOW_EDGES: {
+    xStart: boolean;
+    xEnd: boolean;
+    yStart: boolean;
+    yEnd: boolean;
+};
+declare const DEFAULT_HIDDEN_STATE: {
+    x: boolean;
+    y: boolean;
+    corner: boolean;
+};
+export type Size = typeof DEFAULT_SIZE;
+export type OverflowEdges = typeof DEFAULT_OVERFLOW_EDGES;
+export type HiddenState = typeof DEFAULT_HIDDEN_STATE;
+export interface Coords {
+    x: number;
+    y: number;
+}
+export interface OverflowEdgeThreshold {
+    xStart: number;
+    xEnd: number;
+    yStart: number;
+    yEnd: number;
+}
+export interface ScrollAreaRootState {
+    scrolling: boolean;
+    hasOverflowX: boolean;
+    hasOverflowY: boolean;
+    overflowXStart: boolean;
+    overflowXEnd: boolean;
+    overflowYStart: boolean;
+    overflowYEnd: boolean;
+    cornerHidden: boolean;
+}
+interface ScrollAreaRootOwnProps<Component extends ValidComponent> {
+    /** Pixels that must be passed before overflow edge attributes are applied. @default 0 */
+    overflowEdgeThreshold?: number | Partial<OverflowEdgeThreshold> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerDown', PointerEvent>, PointerEvent> | undefined;
+    onPointerEnter?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerEnter', PointerEvent>, PointerEvent> | undefined;
+    onPointerLeave?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerLeave', PointerEvent>, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerMove', PointerEvent>, PointerEvent> | undefined;
+}
+export type ScrollAreaRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaRootState, ScrollAreaRootOwnProps<Component>>;
+/** Groups all parts of the scroll area. */
+export declare function ScrollAreaRoot<Component extends ValidComponent = 'div'>(props: ScrollAreaRoot.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaRoot {
+    type State = ScrollAreaRootState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaRootProps<Component>;
+}
+export {};

package/dist/lib/types/scroll-area/root/ScrollAreaRootContext.d.ts

@@ -0,0 +1,44 @@
+import { type Accessor } from 'solid-js';
+import type { Coords, HiddenState, OverflowEdgeThreshold, OverflowEdges, ScrollAreaRootState, Size } from './ScrollAreaRoot.js';
+export type ScrollAreaOrientation = 'horizontal' | 'vertical';
+export interface ScrollAreaRootContextValue {
+    cornerElement: Accessor<HTMLElement | undefined>;
+    cornerSize: Accessor<Size>;
+    disableViewportSnap: () => void;
+    handlePointerDown: (event: PointerEvent, orientation: ScrollAreaOrientation) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerUp: (event: PointerEvent) => void;
+    handleScroll: (position: Coords) => void;
+    hasMeasuredScrollbar: Accessor<boolean>;
+    hiddenState: Accessor<HiddenState>;
+    hovering: Accessor<boolean>;
+    overflowEdges: Accessor<OverflowEdges>;
+    overflowEdgeThreshold: Accessor<OverflowEdgeThreshold>;
+    rootId: string;
+    scrollbarXElement: Accessor<HTMLElement | undefined>;
+    scrollbarYElement: Accessor<HTMLElement | undefined>;
+    scrollingX: Accessor<boolean>;
+    scrollingY: Accessor<boolean>;
+    setCornerElement: (element: HTMLElement | undefined) => void;
+    setCornerSize: (size: Size) => void;
+    setHasMeasuredScrollbar: (measured: boolean) => void;
+    setHiddenState: (state: HiddenState) => void;
+    setHovering: (hovering: boolean) => void;
+    setOverflowEdges: (edges: OverflowEdges) => void;
+    setScrollbarXElement: (element: HTMLElement | undefined) => void;
+    setScrollbarYElement: (element: HTMLElement | undefined) => void;
+    setThumbSize: (size: Size) => void;
+    setThumbXElement: (element: HTMLElement | undefined) => void;
+    setThumbYElement: (element: HTMLElement | undefined) => void;
+    setViewportElement: (element: HTMLElement | undefined) => void;
+    state: Accessor<ScrollAreaRootState>;
+    thumbSize: Accessor<Size>;
+    thumbXElement: Accessor<HTMLElement | undefined>;
+    thumbYElement: Accessor<HTMLElement | undefined>;
+    touchModality: Accessor<boolean>;
+    viewportElement: Accessor<HTMLElement | undefined>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ScrollAreaRootContext: import("solid-js").Context<ScrollAreaRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useScrollAreaRootContext(): ScrollAreaRootContextValue;
+export {};

package/dist/lib/types/scroll-area/root/stateAttributes.d.ts

@@ -0,0 +1,3 @@
+import type { StateAttributesMapping } from '../../internals/getStateAttributesProps.js';
+import type { ScrollAreaRootState } from './ScrollAreaRoot.js';
+export declare const scrollAreaStateAttributesMapping: StateAttributesMapping<ScrollAreaRootState>;

package/dist/lib/types/scroll-area/scrollbar/ScrollAreaScrollbar.d.ts

@@ -0,0 +1,28 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ScrollAreaRootState } from '../root/ScrollAreaRoot.js';
+import { type ScrollAreaOrientation } from '../root/ScrollAreaRootContext.js';
+import type { ScrollAreaEventTarget } from '../utils/eventTarget.js';
+export interface ScrollAreaScrollbarState extends ScrollAreaRootState {
+    hovering: boolean;
+    scrolling: boolean;
+    orientation: ScrollAreaOrientation;
+}
+interface ScrollAreaScrollbarOwnProps<Component extends ValidComponent> {
+    /** Whether the scrollbar controls vertical or horizontal scroll. @default 'vertical' */
+    orientation?: ScrollAreaOrientation | undefined;
+    /** Keeps the element mounted when its axis is not scrollable. @default false */
+    keepMounted?: boolean | undefined;
+    onPointerCancel?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerCancel', PointerEvent>, PointerEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerDown', PointerEvent>, PointerEvent> | undefined;
+    onPointerUp?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerUp', PointerEvent>, PointerEvent> | undefined;
+}
+export type ScrollAreaScrollbarProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaScrollbarState, ScrollAreaScrollbarOwnProps<Component>>;
+/** A vertical or horizontal custom scrollbar track. */
+export declare function ScrollAreaScrollbar<Component extends ValidComponent = 'div'>(props: ScrollAreaScrollbar.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaScrollbar {
+    type State = ScrollAreaScrollbarState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaScrollbarProps<Component>;
+}
+export {};

package/dist/lib/types/scroll-area/scrollbar/ScrollAreaScrollbarContext.d.ts

@@ -0,0 +1,7 @@
+import { type Accessor } from 'solid-js';
+import type { ScrollAreaOrientation } from '../root/ScrollAreaRootContext.js';
+export type ScrollAreaScrollbarContextValue = Accessor<ScrollAreaOrientation>;
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ScrollAreaScrollbarContext: import("solid-js").Context<ScrollAreaScrollbarContextValue | typeof MISSING_CONTEXT>;
+export declare function useScrollAreaScrollbarContext(): ScrollAreaScrollbarContextValue;
+export {};

package/dist/lib/types/scroll-area/thumb/ScrollAreaThumb.d.ts

@@ -0,0 +1,22 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ScrollAreaEventTarget } from '../utils/eventTarget.js';
+export interface ScrollAreaThumbState {
+    scrolling: boolean;
+    orientation: 'horizontal' | 'vertical';
+}
+interface ScrollAreaThumbOwnProps<Component extends ValidComponent> {
+    onPointerCancel?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerCancel', PointerEvent>, PointerEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerDown', PointerEvent>, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerMove', PointerEvent>, PointerEvent> | undefined;
+    onPointerUp?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerUp', PointerEvent>, PointerEvent> | undefined;
+}
+export type ScrollAreaThumbProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaThumbState, ScrollAreaThumbOwnProps<Component>>;
+/** The draggable indicator for the current scroll position. */
+export declare function ScrollAreaThumb<Component extends ValidComponent = 'div'>(props: ScrollAreaThumb.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaThumb {
+    type State = ScrollAreaThumbState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaThumbProps<Component>;
+}
+export {};

package/dist/lib/types/scroll-area/utils/dom.d.ts

@@ -0,0 +1,2 @@
+export declare function getEventElement(event: Event): Element | null;
+export declare function contains(container: Node | undefined, target: EventTarget | null): boolean;

package/dist/lib/types/scroll-area/utils/eventTarget.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps, JSX, ValidComponent } from '@solidjs/web';
+export type ScrollAreaEventTarget<Component extends ValidComponent, Handler extends PropertyKey, EventType extends Event> = Handler extends keyof ComponentProps<Component> ? ComponentProps<Component>[Handler] extends JSX.EventHandlerUnion<infer Target, EventType> | undefined ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement : HTMLElement;

package/dist/lib/types/scroll-area/utils/getOffset.d.ts

@@ -0,0 +1 @@
+export declare function getOffset(element: Element | undefined, property: 'margin' | 'padding', axis: 'x' | 'y'): number;

package/dist/lib/types/scroll-area/utils/scrollEdges.d.ts

@@ -0,0 +1 @@
+export declare function normalizeScrollOffset(offset: number, maxOffset: number): number;

package/dist/lib/types/scroll-area/viewport/ScrollAreaViewport.d.ts

@@ -0,0 +1,22 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { ScrollAreaRootState } from '../root/ScrollAreaRoot.js';
+import type { ScrollAreaEventTarget } from '../utils/eventTarget.js';
+export interface ScrollAreaViewportState extends ScrollAreaRootState {
+}
+interface ScrollAreaViewportOwnProps<Component extends ValidComponent> {
+    onKeyDown?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onKeyDown', KeyboardEvent>, KeyboardEvent> | undefined;
+    onPointerEnter?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerEnter', PointerEvent>, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onPointerMove', PointerEvent>, PointerEvent> | undefined;
+    onScroll?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onScroll', Event>, Event> | undefined;
+    onWheel?: BaseUIEventHandlerUnion<ScrollAreaEventTarget<Component, 'onWheel', WheelEvent>, WheelEvent> | undefined;
+}
+export type ScrollAreaViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ScrollAreaViewportState, ScrollAreaViewportOwnProps<Component>>;
+/** The native scrollable container of the scroll area. */
+export declare function ScrollAreaViewport<Component extends ValidComponent = 'div'>(props: ScrollAreaViewport.Props<Component>): JSX.Element;
+export declare namespace ScrollAreaViewport {
+    type State = ScrollAreaViewportState;
+    type Props<Component extends ValidComponent = 'div'> = ScrollAreaViewportProps<Component>;
+}
+export {};

package/dist/lib/types/scroll-area/viewport/ScrollAreaViewportContext.d.ts

@@ -0,0 +1,7 @@
+export interface ScrollAreaViewportContextValue {
+    computeThumbPosition: () => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ScrollAreaViewportContext: import("solid-js").Context<ScrollAreaViewportContextValue | typeof MISSING_CONTEXT>;
+export declare function useScrollAreaViewportContext(): ScrollAreaViewportContextValue;
+export {};

package/dist/lib/types/select/arrow/SelectArrow.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 SelectArrowState {
+    open: boolean;
+    side: AnchorSide | 'none';
+    align: AnchorAlign;
+    uncentered: boolean;
+}
+export type SelectArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectArrowState>;
+/** Displays an arrow positioned against the select anchor. */
+export declare function SelectArrow<Component extends ValidComponent = 'div'>(props: SelectArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectArrow {
+    type State = SelectArrowState;
+    type Props<Component extends ValidComponent = 'div'> = SelectArrowProps<Component>;
+}

package/dist/lib/types/select/backdrop/SelectBackdrop.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 SelectBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+export type SelectBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectBackdropState>;
+/** A presentational overlay displayed beneath the select popup. */
+export declare function SelectBackdrop<Component extends ValidComponent = 'div'>(props: SelectBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectBackdrop {
+    type State = SelectBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = SelectBackdropProps<Component>;
+}

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

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectGroupState {
+}
+export type SelectGroupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectGroupState>;
+/** Groups related select items. */
+export declare function SelectGroup<Component extends ValidComponent = 'div'>(props: SelectGroup.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectGroup {
+    type State = SelectGroupState;
+    type Props<Component extends ValidComponent = 'div'> = SelectGroupProps<Component>;
+}

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

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

package/dist/lib/types/select/group-label/SelectGroupLabel.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectGroupLabelState {
+}
+export type SelectGroupLabelProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, SelectGroupLabelState>;
+/** An accessible label for a select group. */
+export declare function SelectGroupLabel<Component extends ValidComponent = 'div'>(props: SelectGroupLabel.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectGroupLabel {
+    type State = SelectGroupLabelState;
+    type Props<Component extends ValidComponent = 'div'> = SelectGroupLabelProps<Component>;
+}

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

@@ -0,0 +1,12 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectIconState {
+    open: boolean;
+}
+export type SelectIconProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, SelectIconState>;
+/** Displays a decorative select indicator. */
+export declare function SelectIcon<Component extends ValidComponent = 'span'>(props: SelectIcon.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace SelectIcon {
+    type State = SelectIconState;
+    type Props<Component extends ValidComponent = 'span'> = SelectIconProps<Component>;
+}

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

@@ -0,0 +1,20 @@
+export * as Select from './index.parts.js';
+export type * from './root/SelectRoot.js';
+export type * from './label/SelectLabel.js';
+export type * from './trigger/SelectTrigger.js';
+export type * from './value/SelectValue.js';
+export type * from './icon/SelectIcon.js';
+export type * from './portal/SelectPortal.js';
+export type * from './backdrop/SelectBackdrop.js';
+export type * from './positioner/SelectPositioner.js';
+export type * from './popup/SelectPopup.js';
+export type * from './list/SelectList.js';
+export type * from './item/SelectItem.js';
+export type * from './item-indicator/SelectItemIndicator.js';
+export type * from './item-text/SelectItemText.js';
+export type * from './arrow/SelectArrow.js';
+export type * from './scroll-down-arrow/SelectScrollDownArrow.js';
+export type * from './scroll-up-arrow/SelectScrollUpArrow.js';
+export type * from './group/SelectGroup.js';
+export type * from './group-label/SelectGroupLabel.js';
+export type * from './separator/SelectSeparator.js';

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

@@ -0,0 +1,19 @@
+export { SelectRoot as Root } from './root/SelectRoot.js';
+export { SelectLabel as Label } from './label/SelectLabel.js';
+export { SelectTrigger as Trigger } from './trigger/SelectTrigger.js';
+export { SelectValue as Value } from './value/SelectValue.js';
+export { SelectIcon as Icon } from './icon/SelectIcon.js';
+export { SelectPortal as Portal } from './portal/SelectPortal.js';
+export { SelectBackdrop as Backdrop } from './backdrop/SelectBackdrop.js';
+export { SelectPositioner as Positioner } from './positioner/SelectPositioner.js';
+export { SelectPopup as Popup } from './popup/SelectPopup.js';
+export { SelectList as List } from './list/SelectList.js';
+export { SelectItem as Item } from './item/SelectItem.js';
+export { SelectItemIndicator as ItemIndicator } from './item-indicator/SelectItemIndicator.js';
+export { SelectItemText as ItemText } from './item-text/SelectItemText.js';
+export { SelectArrow as Arrow } from './arrow/SelectArrow.js';
+export { SelectScrollDownArrow as ScrollDownArrow } from './scroll-down-arrow/SelectScrollDownArrow.js';
+export { SelectScrollUpArrow as ScrollUpArrow } from './scroll-up-arrow/SelectScrollUpArrow.js';
+export { SelectGroup as Group } from './group/SelectGroup.js';
+export { SelectGroupLabel as GroupLabel } from './group-label/SelectGroupLabel.js';
+export { SelectSeparator as Separator } from './separator/SelectSeparator.js';

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

@@ -0,0 +1,32 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface SelectItemState {
+    disabled: boolean;
+    selected: boolean;
+    highlighted: boolean;
+}
+interface SelectItemOwnProps<Value> {
+    value?: Value | undefined;
+    disabled?: boolean | undefined;
+    label?: string | undefined;
+    nativeButton?: boolean | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerEnter?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type SelectItemProps<Value = unknown, Component extends ValidComponent = 'div'> = Omit<BaseUIComponentProps<Component, SelectItemState, SelectItemOwnProps<Value>>, 'id'>;
+/** An individual option in the select popup. */
+export declare function SelectItem<Value = unknown, Component extends ValidComponent = 'div'>(props: SelectItem.Props<Value, Component>): JSX.Element;
+export declare namespace SelectItem {
+    type State = SelectItemState;
+    type Props<Value = unknown, Component extends ValidComponent = 'div'> = SelectItemProps<Value, Component>;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { type Accessor } from 'solid-js';
+export interface SelectItemContextValue {
+    selected: Accessor<boolean>;
+    selectedByFocus: Accessor<boolean>;
+    index: Accessor<number>;
+    textElement: Accessor<HTMLElement | null>;
+    setTextElement(element: HTMLElement | null): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const SelectItemContext: import("solid-js").Context<SelectItemContextValue | typeof MISSING_CONTEXT>;
+export declare function useSelectItemContext(): SelectItemContextValue;
+export {};