solid-baseui 0.1.0-alpha.0

package/dist/lib/types/drawer/viewport/DrawerViewport.d.ts

@@ -0,0 +1,31 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+export interface DrawerViewportState {
+    /** Whether the drawer is currently open. */
+    open: boolean;
+    /** The transition status of the component. */
+    transitionStatus: TransitionStatus;
+    /** Whether the drawer is nested within another drawer. */
+    nested: boolean;
+    /** Whether the drawer has nested drawers open. */
+    nestedDialogOpen: boolean;
+}
+interface DrawerViewportOwnProps {
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerMove?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerUp?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerCancel?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onTouchStart?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchEnd?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchCancel?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+}
+export type DrawerViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerViewportState, DrawerViewportOwnProps>;
+/** A positioning container for the drawer popup that can be made scrollable. */
+export declare function DrawerViewport<Component extends ValidComponent = 'div'>(props: DrawerViewport.Props<Component>): JSX.Element;
+export declare namespace DrawerViewport {
+    type State = DrawerViewportState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerViewportProps<Component>;
+}
+export {};

package/dist/lib/types/drawer/viewport/DrawerViewportContext.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+export interface DrawerViewportContextValue {
+    swiping: Accessor<boolean>;
+    getDragStyles(): JSX.CSSProperties;
+    swipeStrength: Accessor<number | null>;
+    setSwipeDismissed(dismissed: boolean): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const DrawerViewportContext: import("solid-js").Context<DrawerViewportContextValue | typeof MISSING_CONTEXT>;
+export declare function useDrawerViewportContext(): DrawerViewportContextValue | undefined;
+export {};

package/dist/lib/types/drawer/viewport/DrawerViewportCssVars.d.ts

@@ -0,0 +1,8 @@
+export declare enum DrawerViewportCssVars {
+    /**
+     * The software keyboard inset, measured from the bottom edge of the layout viewport.
+     * Present only when the drawer is wrapped in `Drawer.VirtualKeyboardProvider`.
+     * @type {CSS length}
+     */
+    keyboardInset = "--drawer-keyboard-inset"
+}

package/dist/lib/types/drawer/virtual-keyboard-provider/DrawerVirtualKeyboardContext.d.ts

@@ -0,0 +1,14 @@
+export interface DrawerVirtualKeyboardContextValue {
+    onTouchStart(event: TouchEvent): void;
+    /**
+     * Driven by the viewport's native `touchmove` listener so it still fires when the swipe gesture
+     * claims the event with `stopPropagation()`.
+     */
+    onTouchMove(event: TouchEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    onTouchCancel(): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const DrawerVirtualKeyboardContext: import("solid-js").Context<DrawerVirtualKeyboardContextValue | typeof MISSING_CONTEXT>;
+export declare function useDrawerVirtualKeyboardContext(): DrawerVirtualKeyboardContextValue | undefined;
+export {};

package/dist/lib/types/drawer/virtual-keyboard-provider/DrawerVirtualKeyboardProvider.d.ts

@@ -0,0 +1,14 @@
+import type { JSX } from '@solidjs/web';
+export interface DrawerVirtualKeyboardProviderState {
+}
+export interface DrawerVirtualKeyboardProviderProps {
+    children?: JSX.Element;
+}
+/**
+ * Provides keyboard-aware focus and scroll handling for bottom-sheet drawers with form fields.
+ */
+export declare function DrawerVirtualKeyboardProvider(props: DrawerVirtualKeyboardProvider.Props): JSX.Element;
+export declare namespace DrawerVirtualKeyboardProvider {
+    type State = DrawerVirtualKeyboardProviderState;
+    type Props = DrawerVirtualKeyboardProviderProps;
+}

package/dist/lib/types/field/control/FieldControl.d.ts

@@ -0,0 +1,35 @@
+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 { BaseUIComponentProps } from '../../types/index.js';
+import type { FieldRootState } from '../root/FieldRoot.js';
+export interface FieldControlState extends FieldRootState {
+}
+type FieldControlEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onInput?: JSX.EventHandlerUnion<infer Target, InputEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface FieldControlOwnProps<Component extends ValidComponent> {
+    defaultValue?: string | number | string[] | undefined;
+    disabled?: boolean | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    onValueChange?: ((value: string, eventDetails: FieldControlChangeEventDetails) => void) | undefined;
+    value?: string | number | string[] | undefined;
+    onBlur?: BaseUIEventHandlerUnion<FieldControlEventTarget<Component>, FocusEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<FieldControlEventTarget<Component>, FocusEvent> | undefined;
+    onInput?: BaseUIEventHandlerUnion<FieldControlEventTarget<Component>, InputEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<FieldControlEventTarget<Component>, KeyboardEvent> | undefined;
+}
+export type FieldControlProps<Component extends ValidComponent = 'input'> = BaseUIComponentProps<Component, FieldControlState, FieldControlOwnProps<Component>>;
+/** The native field control. Renders an `<input>` by default. */
+export declare function FieldControl<Component extends ValidComponent = 'input'>(props: FieldControl.Props<Component>): JSX.Element;
+export type FieldControlChangeEventReason = typeof REASONS.none;
+export type FieldControlChangeEventDetails = ReturnType<typeof createChangeEventDetails<FieldControlChangeEventReason>>;
+export declare namespace FieldControl {
+    type State = FieldControlState;
+    type Props<Component extends ValidComponent = 'input'> = FieldControlProps<Component>;
+    type ChangeEventReason = FieldControlChangeEventReason;
+    type ChangeEventDetails = FieldControlChangeEventDetails;
+}
+export {};

package/dist/lib/types/field/description/FieldDescription.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { FieldRootState } from '../root/FieldRoot.js';
+export interface FieldDescriptionState extends FieldRootState {
+}
+interface FieldDescriptionOwnProps {
+    id?: string | undefined;
+}
+export type FieldDescriptionProps<Component extends ValidComponent = 'p'> = BaseUIComponentProps<Component, FieldDescriptionState, FieldDescriptionOwnProps>;
+/** Additional information that is automatically associated with the control. */
+export declare function FieldDescription<Component extends ValidComponent = 'p'>(props: FieldDescription.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace FieldDescription {
+    type State = FieldDescriptionState;
+    type Props<Component extends ValidComponent = 'p'> = FieldDescriptionProps<Component>;
+}
+export {};

package/dist/lib/types/field/error/FieldError.d.ts

@@ -0,0 +1,19 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { FieldRootState } from '../root/FieldRoot.js';
+export interface FieldErrorState extends FieldRootState {
+    transitionStatus: TransitionStatus;
+}
+interface FieldErrorOwnProps {
+    id?: string | undefined;
+    match?: boolean | keyof ValidityState | undefined;
+}
+export type FieldErrorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, FieldErrorState, FieldErrorOwnProps>;
+/** A conditional validation message associated with the current control. */
+export declare function FieldError<Component extends ValidComponent = 'div'>(props: FieldError.Props<Component>): JSX.Element;
+export declare namespace FieldError {
+    type State = FieldErrorState;
+    type Props<Component extends ValidComponent = 'div'> = FieldErrorProps<Component>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export * as Field from './index.parts.js';
+export type { FieldRootActions, FieldRootProps, FieldRootState, FieldValidityData, } from './root/FieldRoot.js';
+export type { FieldLabelProps, FieldLabelState } from './label/FieldLabel.js';
+export type { FieldControlChangeEventDetails, FieldControlChangeEventReason, FieldControlProps, FieldControlState, } from './control/FieldControl.js';
+export type { FieldDescriptionProps, FieldDescriptionState, } from './description/FieldDescription.js';
+export type { FieldItemProps, FieldItemState } from './item/FieldItem.js';
+export type { FieldErrorProps, FieldErrorState } from './error/FieldError.js';
+export type { FieldValidityProps, FieldValidityState } from './validity/FieldValidity.js';

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

@@ -0,0 +1,8 @@
+export { FieldRoot as Root } from './root/FieldRoot.js';
+export { FieldLabel as Label } from './label/FieldLabel.js';
+export { FieldControl as Control } from './control/FieldControl.js';
+export { FieldDescription as Description } from './description/FieldDescription.js';
+export { FieldItem as Item } from './item/FieldItem.js';
+export { FieldError as Error } from './error/FieldError.js';
+export { FieldValidity as Validity } from './validity/FieldValidity.js';
+export type { FieldValidityData as ValidityData } from './root/FieldRoot.js';

package/dist/lib/types/field/item/FieldItem.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { FieldRootState } from '../root/FieldRoot.js';
+export interface FieldItemState extends FieldRootState {
+}
+interface FieldItemOwnProps {
+    disabled?: boolean | undefined;
+}
+export type FieldItemProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, FieldItemState, FieldItemOwnProps>;
+/** Groups one item in a grouped field with its own labelable scope. */
+export declare function FieldItem<Component extends ValidComponent = 'div'>(props: FieldItem.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace FieldItem {
+    type State = FieldItemState;
+    type Props<Component extends ValidComponent = 'div'> = FieldItemProps<Component>;
+}
+export {};

package/dist/lib/types/field/item/FieldItemContext.d.ts

@@ -0,0 +1,6 @@
+import { type Accessor } from 'solid-js';
+export interface FieldItemContextValue {
+    disabled: Accessor<boolean>;
+}
+export declare const FieldItemContext: import("solid-js").Context<FieldItemContextValue>;
+export declare function useFieldItemContext(): FieldItemContextValue;

package/dist/lib/types/field/label/FieldLabel.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { FieldRootState } from '../root/FieldRoot.js';
+export interface FieldLabelState extends FieldRootState {
+}
+type FieldLabelEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface FieldLabelOwnProps<Component extends ValidComponent> {
+    id?: string | undefined;
+    nativeLabel?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<FieldLabelEventTarget<Component>, MouseEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<FieldLabelEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<FieldLabelEventTarget<Component>, PointerEvent> | undefined;
+}
+export type FieldLabelProps<Component extends ValidComponent = 'label'> = BaseUIComponentProps<Component, FieldLabelState, FieldLabelOwnProps<Component>>;
+/** A label automatically associated with the current field control. */
+export declare function FieldLabel<Component extends ValidComponent = 'label'>(props: FieldLabel.Props<Component>): JSX.Element;
+export declare namespace FieldLabel {
+    type State = FieldLabelState;
+    type Props<Component extends ValidComponent = 'label'> = FieldLabelProps<Component>;
+}
+export {};

package/dist/lib/types/field/root/FieldRoot.d.ts

@@ -0,0 +1,30 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type FieldState, type FieldValidityData as InternalFieldValidityData } from '../../internals/field-constants.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { Form } from '../../form/index.js';
+export type FieldValidityData = InternalFieldValidityData;
+export interface FieldRootState extends FieldState {
+}
+export interface FieldRootActions {
+    validate: () => void;
+}
+interface FieldRootOwnProps {
+    actionsRef?: ((actions: FieldRootActions) => void) | undefined;
+    dirty?: boolean | undefined;
+    disabled?: boolean | undefined;
+    invalid?: boolean | undefined;
+    name?: string | undefined;
+    touched?: boolean | undefined;
+    validate?: ((value: unknown, formValues: Form.Values) => string | string[] | null | Promise<string | string[] | null>) | undefined;
+    validationDebounceTime?: number | undefined;
+    validationMode?: Form.ValidationMode | undefined;
+}
+export type FieldRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, FieldRootState, FieldRootOwnProps>;
+/** Groups all parts of a field and coordinates validation and form registration. */
+export declare function FieldRoot<Component extends ValidComponent = 'div'>(props: FieldRoot.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace FieldRoot {
+    type State = FieldRootState;
+    type Props<Component extends ValidComponent = 'div'> = FieldRootProps<Component>;
+    type Actions = FieldRootActions;
+}
+export {};

package/dist/lib/types/field/root/createFieldValidation.d.ts

@@ -0,0 +1,22 @@
+import { type Accessor } from 'solid-js';
+import { type FieldState, type FieldValidityData } from '../../internals/field-constants.js';
+import type { FormContextValue } from '../../internals/form-context/FormContext.js';
+export type NativeFieldControl = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export interface FieldValidationController {
+    commit: (value: unknown, revalidate?: boolean) => void;
+    change: (value: unknown) => void;
+    registerInput: (source: symbol, element: NativeFieldControl, getControl?: () => HTMLElement | null) => () => void;
+    getInputControl: () => HTMLElement | null;
+    setActiveInputSource: (source: symbol | null) => void;
+}
+export interface CreateFieldValidationOptions {
+    form: FormContextValue;
+    getValidityData: () => FieldValidityData;
+    publish: (data: FieldValidityData) => void;
+    validate: () => ((value: unknown, formValues: Record<string, unknown>) => string | string[] | null | Promise<string | string[] | null>) | undefined;
+    validationDebounceTime: Accessor<number>;
+    state: Accessor<FieldState>;
+    isMarkedDirty: () => boolean;
+    shouldValidateOnChange: () => boolean;
+}
+export declare function createFieldValidation(options: CreateFieldValidationOptions): FieldValidationController;

package/dist/lib/types/field/validity/FieldValidity.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from '@solidjs/web';
+import type { FieldValidityData } from '../../internals/field-constants.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+export interface FieldValidityState extends Omit<FieldValidityData, 'state'> {
+    validity: FieldValidityData['state'];
+    transitionStatus: TransitionStatus;
+}
+export interface FieldValidityProps {
+    children: (state: FieldValidityState) => JSX.Element;
+}
+/** Exposes the current validity data to a render callback without adding a DOM node. */
+export declare function FieldValidity(props: FieldValidity.Props): JSX.Element;
+export declare namespace FieldValidity {
+    type State = FieldValidityState;
+    type Props = FieldValidityProps;
+}

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

@@ -0,0 +1,3 @@
+export * as Fieldset from './index.parts.js';
+export type { FieldsetRootProps, FieldsetRootState, } from './root/FieldsetRoot.js';
+export type { FieldsetLegendProps, FieldsetLegendState, } from './legend/FieldsetLegend.js';

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

@@ -0,0 +1,2 @@
+export { FieldsetRoot as Root } from './root/FieldsetRoot.js';
+export { FieldsetLegend as Legend } from './legend/FieldsetLegend.js';

package/dist/lib/types/fieldset/legend/FieldsetLegend.d.ts

@@ -0,0 +1,21 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface FieldsetLegendState {
+    /** Whether the component should ignore user interaction. */
+    disabled: boolean;
+}
+interface FieldsetLegendOwnProps {
+    /** The id used to label the fieldset. */
+    id?: string | undefined;
+}
+export type FieldsetLegendProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, FieldsetLegendState, FieldsetLegendOwnProps>;
+/**
+ * An accessible label that is automatically associated with the fieldset.
+ * Renders a `<div>` element by default.
+ */
+export declare function FieldsetLegend<Component extends ValidComponent = 'div'>(props: FieldsetLegend.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace FieldsetLegend {
+    type State = FieldsetLegendState;
+    type Props<Component extends ValidComponent = 'div'> = FieldsetLegendProps<Component>;
+}
+export {};

package/dist/lib/types/fieldset/root/FieldsetRoot.d.ts

@@ -0,0 +1,21 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface FieldsetRootState {
+    /** Whether the component should ignore user interaction. */
+    disabled: boolean;
+}
+interface FieldsetRootOwnProps {
+    /** Whether the fieldset should ignore user interaction. @default false */
+    disabled?: boolean | undefined;
+}
+export type FieldsetRootProps<Component extends ValidComponent = 'fieldset'> = BaseUIComponentProps<Component, FieldsetRootState, FieldsetRootOwnProps>;
+/**
+ * Groups a shared legend with related controls.
+ * Renders a `<fieldset>` element by default.
+ */
+export declare function FieldsetRoot<Component extends ValidComponent = 'fieldset'>(props: FieldsetRoot.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace FieldsetRoot {
+    type State = FieldsetRootState;
+    type Props<Component extends ValidComponent = 'fieldset'> = FieldsetRootProps<Component>;
+}
+export {};

package/dist/lib/types/fieldset/root/FieldsetRootContext.d.ts

@@ -0,0 +1,11 @@
+import { type Accessor, type Setter } from 'solid-js';
+export interface FieldsetRootContextValue {
+    legendId: Accessor<string | undefined>;
+    setLegendId: Setter<string | undefined>;
+    disabled: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const FieldsetRootContext: import("solid-js").Context<FieldsetRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useFieldsetRootContext(optional: true): FieldsetRootContextValue | undefined;
+export declare function useFieldsetRootContext(optional?: false): FieldsetRootContextValue;
+export {};

package/dist/lib/types/form/Form.d.ts

@@ -0,0 +1,39 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../internals/composeEventHandlers.js';
+import { type FormErrors, type FormValidationMode } from '../internals/form-types.js';
+import { REASONS } from '../internals/reasons.js';
+import type { BaseUIComponentProps, BaseUIGenericEventDetails } from '../types/index.js';
+type FormEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onSubmit?: JSX.EventHandlerUnion<infer Target, SubmitEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+export interface FormActions {
+    validate: (fieldName?: string | undefined) => void;
+}
+export interface FormState {
+}
+interface FormOwnProps<FormValues extends object, Component extends ValidComponent> {
+    /** A callback that receives imperative form actions after setup. */
+    actionsRef?: ((actions: FormActions) => void) | undefined;
+    /** External validation errors keyed by field name. */
+    errors?: FormErrors | undefined;
+    /** Called with registered field values after synchronous validation succeeds. */
+    onFormSubmit?: ((formValues: FormValues, eventDetails: FormSubmitEventDetails) => void) | undefined;
+    onSubmit?: BaseUIEventHandlerUnion<FormEventTarget<Component>, SubmitEvent> | undefined;
+    /** Determines when fields validate. @default 'onSubmit' */
+    validationMode?: FormValidationMode | undefined;
+}
+export type FormProps<FormValues extends object = Record<string, unknown>, Component extends ValidComponent = 'form'> = BaseUIComponentProps<Component, FormState, FormOwnProps<FormValues, Component>>;
+/** A native form element with consolidated validation and error handling. */
+export declare function Form<FormValues extends object = Record<string, unknown>, Component extends ValidComponent = 'form'>(props: Form.Props<FormValues, Component>): JSX.Element;
+export type FormSubmitEventReason = typeof REASONS.none;
+export type FormSubmitEventDetails = BaseUIGenericEventDetails<FormSubmitEventReason>;
+export type { FormErrors, FormValidationMode };
+export declare namespace Form {
+    type Props<FormValues extends object = Record<string, unknown>, Component extends ValidComponent = 'form'> = FormProps<FormValues, Component>;
+    type State = FormState;
+    type Actions = FormActions;
+    type ValidationMode = FormValidationMode;
+    type SubmitEventReason = FormSubmitEventReason;
+    type SubmitEventDetails = FormSubmitEventDetails;
+    type Values<FormValues extends object = Record<string, unknown>> = FormValues;
+}

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

@@ -0,0 +1,2 @@
+export { Form } from './Form.js';
+export type { FormActions, FormErrors, FormProps, FormState, FormSubmitEventDetails, FormSubmitEventReason, FormValidationMode, } from './Form.js';

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

@@ -0,0 +1,41 @@
+export * from './accordion/index.js';
+export * from './alert-dialog/index.js';
+export * from './autocomplete/index.js';
+export * from './avatar/index.js';
+export * from './button/index.js';
+export * from './checkbox/index.js';
+export * from './checkbox-group/index.js';
+export * from './collapsible/index.js';
+export * from './combobox/index.js';
+export * from './context-menu/index.js';
+export * from './csp-provider/index.js';
+export * from './direction-provider/index.js';
+export * from './dialog/index.js';
+export * from './drawer/index.js';
+export * from './field/index.js';
+export * from './fieldset/index.js';
+export * from './form/index.js';
+export * from './input/index.js';
+export * from './meter/index.js';
+export * from './menu/index.js';
+export * from './menubar/index.js';
+export * from './navigation-menu/index.js';
+export * from './number-field/index.js';
+export * from './otp-field/index.js';
+export * from './popover/index.js';
+export * from './progress/index.js';
+export * from './preview-card/index.js';
+export * from './radio/index.js';
+export * from './radio-group/index.js';
+export * from './scroll-area/index.js';
+export * from './select/index.js';
+export * from './separator/index.js';
+export * from './slider/index.js';
+export * from './switch/index.js';
+export * from './tabs/index.js';
+export * from './toast/index.js';
+export * from './toolbar/index.js';
+export * from './tooltip/index.js';
+export * from './toggle/index.js';
+export * from './toggle-group/index.js';
+export type * from './types/index.js';

package/dist/lib/types/input/Input.d.ts

@@ -0,0 +1,20 @@
+import type { ValidComponent } from '@solidjs/web';
+import { type FieldControlChangeEventDetails, type FieldControlChangeEventReason, type FieldControlProps, type FieldControlState } from '../field/control/FieldControl.js';
+export interface InputState extends FieldControlState {
+}
+export type InputProps<Component extends ValidComponent = 'input'> = FieldControlProps<Component> & {
+    defaultChecked?: never;
+};
+export type InputChangeEventReason = FieldControlChangeEventReason;
+export type InputChangeEventDetails = FieldControlChangeEventDetails;
+/**
+ * A native input element that automatically integrates with Field.
+ * Renders an `<input>` element by default.
+ */
+export declare function Input<Component extends ValidComponent = 'input'>(props: Input.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace Input {
+    type Props<Component extends ValidComponent = 'input'> = InputProps<Component>;
+    type State = InputState;
+    type ChangeEventReason = InputChangeEventReason;
+    type ChangeEventDetails = InputChangeEventDetails;
+}

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

@@ -0,0 +1,2 @@
+export { Input } from './Input.js';
+export type { InputChangeEventDetails, InputChangeEventReason, InputProps, InputState, } from './Input.js';

package/dist/lib/types/internals/buttonSemantics.d.ts

@@ -0,0 +1,10 @@
+import type { BaseUIEvent } from '../types/index.js';
+export declare function preventButtonInteraction<EventType extends Event>(event: BaseUIEvent<EventType>): void;
+export declare function stopButtonInteraction<EventType extends Event>(event: BaseUIEvent<EventType>): void;
+export declare function preventDisabledButtonKeyDown(event: BaseUIEvent<KeyboardEvent>): void;
+export declare function handleNonNativeButtonKeyDown(event: BaseUIEvent<KeyboardEvent> & {
+    currentTarget: HTMLElement;
+}): void;
+export declare function handleNonNativeButtonKeyUp(event: BaseUIEvent<KeyboardEvent> & {
+    currentTarget: HTMLElement;
+}): void;

package/dist/lib/types/internals/clamp.d.ts

@@ -0,0 +1 @@
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/lib/types/internals/composeEventHandlers.d.ts

@@ -0,0 +1,11 @@
+import type { Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { BaseUIEvent } from '../types/index.js';
+export type BaseUIEventHandlerUnion<T, EventType extends Event> = JSX.EventHandlerUnion<T, BaseUIEvent<EventType>>;
+export type EventHandlerSource<T, EventType extends Event> = Accessor<BaseUIEventHandlerUnion<T, EventType> | undefined>;
+/**
+ * Composes native event handlers in argument order. Calling
+ * `event.preventBaseUIHandler()` prevents the remaining handlers from running.
+ */
+export declare function composeEventHandlers<T, EventType extends Event>(...getHandlers: Array<EventHandlerSource<T, EventType>>): JSX.EventHandler<T, BaseUIEvent<EventType>>;
+export declare function makeEventPreventable<EventType extends Event>(event: EventType): BaseUIEvent<EventType>;

package/dist/lib/types/internals/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
+export declare const LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
+export declare const BASE_UI_SWIPE_IGNORE_SELECTOR = "[data-base-ui-swipe-ignore]";
+export declare const LEGACY_SWIPE_IGNORE_SELECTOR = "[data-swipe-ignore]";

package/dist/lib/types/internals/createBaseUIEventDetails.d.ts

@@ -0,0 +1,57 @@
+import { REASONS } from './reasons.js';
+interface ReasonToEventMap {
+    [REASONS.none]: Event;
+    [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.triggerHover]: MouseEvent;
+    [REASONS.triggerFocus]: FocusEvent;
+    [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.linkPress]: MouseEvent | PointerEvent;
+    [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.inputChange]: InputEvent | Event;
+    [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+    [REASONS.inputBlur]: FocusEvent;
+    [REASONS.inputPaste]: ClipboardEvent;
+    [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+    [REASONS.escapeKey]: KeyboardEvent;
+    [REASONS.closeWatcher]: Event;
+    [REASONS.listNavigation]: KeyboardEvent;
+    [REASONS.keyboard]: KeyboardEvent;
+    [REASONS.pointer]: PointerEvent;
+    [REASONS.drag]: PointerEvent | TouchEvent;
+    [REASONS.swipe]: PointerEvent | TouchEvent;
+    [REASONS.wheel]: WheelEvent;
+    [REASONS.scrub]: PointerEvent;
+    [REASONS.cancelOpen]: MouseEvent;
+    [REASONS.siblingOpen]: Event;
+    [REASONS.disabled]: Event;
+    [REASONS.missing]: Event;
+    [REASONS.initial]: Event;
+    [REASONS.imperativeAction]: Event;
+    [REASONS.windowResize]: UIEvent;
+}
+export type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+    reason: Reason;
+    event: ReasonToEvent<Reason>;
+    cancel: () => void;
+    allowPropagation: () => void;
+    isCanceled: boolean;
+    isPropagationAllowed: boolean;
+    trigger: Element | undefined;
+} & CustomProperties;
+export type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = Record<never, never>> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> : never;
+type BaseUIGenericEventDetail<Reason extends string, CustomProperties extends object> = {
+    reason: Reason;
+    event: ReasonToEvent<Reason>;
+} & CustomProperties;
+export type BaseUIGenericEventDetails<Reason extends string, CustomProperties extends object = Record<never, never>> = Reason extends string ? BaseUIGenericEventDetail<Reason, CustomProperties> : never;
+export declare function createChangeEventDetails<Reason extends string, CustomProperties extends object = Record<never, never>>(reason: Reason, event?: ReasonToEvent<Reason>, trigger?: Element, customProperties?: CustomProperties): BaseUIChangeEventDetails<Reason, CustomProperties>;
+export declare function createGenericEventDetails<Reason extends keyof ReasonToEventMap, CustomProperties extends object = Record<never, never>>(reason: Reason, event?: ReasonToEvent<Reason>, customProperties?: CustomProperties): BaseUIGenericEventDetails<Reason, CustomProperties>;
+export {};

package/dist/lib/types/internals/createTransitionStatus.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { TransitionStatus } from './stateAttributesMapping.js';
+export interface TransitionStatusState {
+    mounted: Accessor<boolean>;
+    setMounted: Setter<boolean>;
+    transitionStatus: Accessor<TransitionStatus>;
+}
+/** Tracks mount retention and CSS starting/ending states for a visibility accessor. */
+export declare function createTransitionStatus(open: Accessor<boolean>): TransitionStatusState;

package/dist/lib/types/internals/csp-context/CSPContext.d.ts

@@ -0,0 +1,7 @@
+import { type Accessor } from 'solid-js';
+export interface CSPContextValue {
+    nonce: Accessor<string | undefined>;
+    disableStyleElements: Accessor<boolean>;
+}
+export declare const CSPContext: import("solid-js").Context<CSPContextValue>;
+export declare function useCSPContext(): CSPContextValue;

package/dist/lib/types/internals/csp-context/index.d.ts

@@ -0,0 +1,2 @@
+export { CSPContext, useCSPContext } from './CSPContext.js';
+export type { CSPContextValue } from './CSPContext.js';

package/dist/lib/types/internals/direction-context/DirectionContext.d.ts

@@ -0,0 +1,6 @@
+import { type Accessor } from 'solid-js';
+export type TextDirection = 'ltr' | 'rtl';
+export type DirectionContext = Accessor<TextDirection>;
+export declare const DirectionContext: import("solid-js").Context<DirectionContext>;
+/** Returns a reactive accessor for the nearest reading direction. */
+export declare function useDirection(): Accessor<TextDirection>;

package/dist/lib/types/internals/direction-context/index.d.ts

@@ -0,0 +1,2 @@
+export { DirectionContext, useDirection } from './DirectionContext.js';
+export type { TextDirection, DirectionContext as DirectionContextValue, } from './DirectionContext.js';