solid-baseui 0.1.0-alpha.0

package/dist/lib/types/number-field/root/createPressAndHold.d.ts

@@ -0,0 +1,24 @@
+import { type Accessor } from 'solid-js';
+export declare function isTouchLikePointerType(pointerType: string): boolean;
+interface CreatePressAndHoldParameters {
+    disabled: Accessor<boolean>;
+    element: Accessor<HTMLElement | undefined>;
+    tick: Accessor<(triggerEvent?: Event) => boolean>;
+    onStop: Accessor<((event: PointerEvent) => void) | undefined>;
+}
+export interface PressAndHoldHandlers {
+    onTouchStart: (event: TouchEvent) => void;
+    onTouchEnd: (event: TouchEvent) => void;
+    onPointerDown: (event: PointerEvent) => void;
+    onPointerUp: (event: PointerEvent) => void;
+    onPointerMove: (event: PointerEvent) => void;
+    onMouseEnter: (event: MouseEvent) => void;
+    onMouseLeave: (event: MouseEvent) => void;
+    onMouseUp: (event: MouseEvent) => void;
+}
+/** Adds Base UI's number-stepper press-and-hold behavior to an element. */
+export declare function createPressAndHold(params: CreatePressAndHoldParameters): {
+    pointerHandlers: PressAndHoldHandlers;
+    shouldSkipClick: (event: MouseEvent) => boolean;
+};
+export {};

package/dist/lib/types/number-field/scrub-area/NumberFieldScrubArea.d.ts

@@ -0,0 +1,20 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { NumberFieldRootState } from '../root/NumberFieldRoot.js';
+export interface NumberFieldScrubAreaState extends NumberFieldRootState {
+}
+interface NumberFieldScrubAreaOwnProps {
+    direction?: 'horizontal' | 'vertical' | undefined;
+    pixelSensitivity?: number | undefined;
+    teleportDistance?: number | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type NumberFieldScrubAreaProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, NumberFieldScrubAreaState, NumberFieldScrubAreaOwnProps>;
+/** An interactive area where dragging changes the number field value. */
+export declare function NumberFieldScrubArea<Component extends ValidComponent = 'span'>(props: NumberFieldScrubArea.Props<Component>): JSX.Element;
+export declare namespace NumberFieldScrubArea {
+    type State = NumberFieldScrubAreaState;
+    type Props<Component extends ValidComponent = 'span'> = NumberFieldScrubAreaProps<Component>;
+}
+export {};

package/dist/lib/types/number-field/scrub-area/NumberFieldScrubAreaContext.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor } from 'solid-js';
+export interface NumberFieldScrubAreaContextValue {
+    isScrubbing: Accessor<boolean>;
+    isTouchInput: Accessor<boolean>;
+    isPointerLockDenied: Accessor<boolean>;
+    scrubAreaElement: Accessor<HTMLElement | undefined>;
+    scrubAreaCursorElement: Accessor<HTMLElement | undefined>;
+    setScrubAreaCursorElement: (element: HTMLElement | undefined) => void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const NumberFieldScrubAreaContext: import("solid-js").Context<NumberFieldScrubAreaContextValue | typeof MISSING_CONTEXT>;
+export declare function useNumberFieldScrubAreaContext(): NumberFieldScrubAreaContextValue;
+export {};

package/dist/lib/types/number-field/scrub-area-cursor/NumberFieldScrubAreaCursor.d.ts

@@ -0,0 +1,12 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { NumberFieldRootState } from '../root/NumberFieldRoot.js';
+export interface NumberFieldScrubAreaCursorState extends NumberFieldRootState {
+}
+export type NumberFieldScrubAreaCursorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, NumberFieldScrubAreaCursorState>;
+/** A portaled virtual cursor shown while the scrub area has pointer lock. */
+export declare function NumberFieldScrubAreaCursor<Component extends ValidComponent = 'span'>(props: NumberFieldScrubAreaCursor.Props<Component>): JSX.Element;
+export declare namespace NumberFieldScrubAreaCursor {
+    type State = NumberFieldScrubAreaCursorState;
+    type Props<Component extends ValidComponent = 'span'> = NumberFieldScrubAreaCursorProps<Component>;
+}

package/dist/lib/types/number-field/utils/format.d.ts

@@ -0,0 +1,2 @@
+export declare function getFormatter(locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): Intl.NumberFormat;
+export declare function formatNumber(value: number | null, locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;

package/dist/lib/types/number-field/utils/getViewportRect.d.ts

@@ -0,0 +1,6 @@
+export declare function getViewportRect(teleportDistance: number | undefined, scrubAreaEl: HTMLElement): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};

package/dist/lib/types/number-field/utils/parse.d.ts

@@ -0,0 +1,40 @@
+export declare const PERCENTAGES: string[];
+export declare const PERMILLE: string[];
+export declare const FULLWIDTH_DECIMAL = "\uFF0E";
+export declare const FULLWIDTH_GROUP = "\uFF0C";
+export declare const PERCENT_RE: RegExp;
+export declare const PERMILLE_RE: RegExp;
+export declare const ARABIC_PERSIAN_DETECT_RE: RegExp;
+export declare const HAN_DETECT_RE: RegExp;
+export declare function isNumeralChar(char: string): boolean;
+export declare const BASE_NON_NUMERIC_SYMBOLS: readonly [".", ",", "．", "，", "٫", "٬"];
+export declare const SPACE_SEPARATOR_RE: RegExp;
+export declare const FORMAT_CONTROL_DETECT_RE: RegExp;
+export declare const PLUS_SIGNS_WITH_ASCII: string[];
+export declare const MINUS_SIGNS_WITH_ASCII: string[];
+export declare const ANY_MINUS_RE: RegExp;
+export declare const ANY_PLUS_RE: RegExp;
+export declare const ANY_MINUS_DETECT_RE: RegExp;
+export declare const ANY_PLUS_DETECT_RE: RegExp;
+export declare function getFormatParts(locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): Intl.NumberFormatPart[];
+export declare function getNumberLocaleDetails(locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): {
+    decimal: string;
+    compact?: string | undefined;
+    group?: string | undefined;
+    percent?: string | undefined;
+    currency?: string | undefined;
+    unit?: string | undefined;
+    literal?: string | undefined;
+    nan?: string | undefined;
+    infinity?: string | undefined;
+    integer?: string | undefined;
+    fraction?: string | undefined;
+    plusSign?: string | undefined;
+    minusSign?: string | undefined;
+    percentSign?: string | undefined;
+    exponentInteger?: string | undefined;
+    exponentMinusSign?: string | undefined;
+    exponentSeparator?: string | undefined;
+    unknown?: string | undefined;
+};
+export declare function parseNumber(formattedNumber: string, locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): number | null;

package/dist/lib/types/number-field/utils/platform.d.ts

@@ -0,0 +1,3 @@
+export declare function isIOS(): boolean;
+export declare function isWebKit(): boolean;
+export declare function isGecko(): boolean;

package/dist/lib/types/number-field/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,10 @@
+export declare const stateAttributesMapping: {
+    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;
+    inputValue: () => null;
+    value: () => null;
+};

package/dist/lib/types/number-field/utils/types.d.ts

@@ -0,0 +1,16 @@
+import { REASONS } from '../../internals/reasons.js';
+export type Direction = -1 | 1;
+export type DirectionalChangeReason = typeof REASONS.incrementPress | typeof REASONS.decrementPress | typeof REASONS.wheel | typeof REASONS.scrub | typeof REASONS.keyboard;
+export interface ChangeEventCustomProperties {
+    direction?: Direction | undefined;
+}
+export interface IncrementValueParameters {
+    direction: Direction;
+    event?: Event | undefined;
+    reason: DirectionalChangeReason;
+    currentValue?: number | null | undefined;
+}
+export interface EventWithOptionalKeyState {
+    altKey?: boolean | undefined;
+    shiftKey?: boolean | undefined;
+}

package/dist/lib/types/number-field/utils/validate.d.ts

@@ -0,0 +1,9 @@
+type NumberFormatOptionsWithRounding = Intl.NumberFormatOptions & {
+    roundingIncrement?: number | undefined;
+    roundingMode?: string | undefined;
+    roundingPriority?: string | undefined;
+};
+export declare function hasNumberFormatRoundingOptions(format?: NumberFormatOptionsWithRounding): format is NumberFormatOptionsWithRounding;
+export declare function removeFloatingPointErrors(value: number, format?: NumberFormatOptionsWithRounding): number;
+export declare function toValidatedNumber(value: number | null, step: number | undefined, minWithDefault: number, maxWithDefault: number, minWithZeroDefault: number, format: NumberFormatOptionsWithRounding | undefined, snapOnStep: boolean, small: boolean, shouldClamp: boolean): number | null;
+export {};

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

@@ -0,0 +1,3 @@
+export * as OTPField from './index.parts.js';
+export type * from './root/OTPFieldRoot.js';
+export type * from './input/OTPFieldInput.js';

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

@@ -0,0 +1,3 @@
+export { OTPFieldRoot as Root } from './root/OTPFieldRoot.js';
+export { OTPFieldInput as Input } from './input/OTPFieldInput.js';
+export { Separator } from '../separator/Separator.js';

package/dist/lib/types/otp-field/input/OTPFieldInput.d.ts

@@ -0,0 +1,29 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { OTPFieldRootState } from '../root/OTPFieldRoot.js';
+export interface OTPFieldInputState extends Omit<OTPFieldRootState, 'filled' | 'value'> {
+    filled: boolean;
+    index: number;
+    value: string;
+}
+type OTPFieldInputEventTarget<Component extends ValidComponent> = Component extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[Component] : HTMLElement;
+interface OTPFieldInputOwnProps<Component extends ValidComponent> {
+    index?: never;
+    defaultChecked?: never;
+    defaultValue?: never;
+    onBlur?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, FocusEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, FocusEvent> | undefined;
+    onInput?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, InputEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, MouseEvent> | undefined;
+    onPaste?: BaseUIEventHandlerUnion<OTPFieldInputEventTarget<Component>, ClipboardEvent> | undefined;
+}
+export type OTPFieldInputProps<Component extends ValidComponent = 'input'> = BaseUIComponentProps<Component, OTPFieldInputState, OTPFieldInputOwnProps<Component>>;
+/** An individual character input within an OTP Field. */
+export declare function OTPFieldInput<Component extends ValidComponent = 'input'>(props: OTPFieldInput.Props<Component>): JSX.Element;
+export declare namespace OTPFieldInput {
+    type State = OTPFieldInputState;
+    type Props<Component extends ValidComponent = 'input'> = OTPFieldInputProps<Component>;
+}
+export {};

package/dist/lib/types/otp-field/root/OTPFieldRoot.d.ts

@@ -0,0 +1,56 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIChangeEventDetails, type BaseUIGenericEventDetails } 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';
+import { type OTPValidationType } from '../utils/otp.js';
+export interface OTPFieldRootState extends FieldRootState {
+    complete: boolean;
+    disabled: boolean;
+    length: number;
+    readOnly: boolean;
+    required: boolean;
+    value: string;
+}
+interface OTPFieldRootOwnProps {
+    id?: string | undefined;
+    autoComplete?: string | undefined;
+    form?: string | undefined;
+    length: number;
+    autoSubmit?: boolean | undefined;
+    mask?: boolean | undefined;
+    inputMode?: JSX.InputHTMLAttributes<HTMLInputElement>['inputmode'] | undefined;
+    validationType?: OTPValidationType | undefined;
+    normalizeValue?: ((value: string) => string) | undefined;
+    required?: boolean | undefined;
+    disabled?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    name?: string | undefined;
+    value?: string | undefined;
+    defaultValue?: string | undefined;
+    onValueChange?: ((value: string, eventDetails: OTPFieldRootChangeEventDetails) => void) | undefined;
+    onValueInvalid?: ((value: string, eventDetails: OTPFieldRootInvalidEventDetails) => void) | undefined;
+    onValueComplete?: ((value: string, eventDetails: OTPFieldRootCompleteEventDetails) => void) | undefined;
+    onChange?: never;
+}
+export type OTPFieldRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, OTPFieldRootState, OTPFieldRootOwnProps>;
+/** Groups OTP inputs and coordinates editing, validation, and form submission. */
+export declare function OTPFieldRoot<Component extends ValidComponent = 'div'>(props: OTPFieldRoot.Props<Component>): JSX.Element;
+export type OTPFieldRootChangeEventReason = typeof REASONS.inputChange | typeof REASONS.inputClear | typeof REASONS.inputPaste | typeof REASONS.keyboard;
+export type OTPFieldRootChangeEventDetails = BaseUIChangeEventDetails<OTPFieldRootChangeEventReason>;
+export type OTPFieldRootInvalidEventReason = typeof REASONS.inputChange | typeof REASONS.inputPaste;
+export type OTPFieldRootInvalidEventDetails = BaseUIGenericEventDetails<OTPFieldRootInvalidEventReason>;
+export type OTPFieldRootCompleteEventReason = typeof REASONS.inputChange | typeof REASONS.inputPaste;
+export type OTPFieldRootCompleteEventDetails = BaseUIGenericEventDetails<OTPFieldRootCompleteEventReason>;
+export declare namespace OTPFieldRoot {
+    type State = OTPFieldRootState;
+    type Props<Component extends ValidComponent = 'div'> = OTPFieldRootProps<Component>;
+    type ValidationType = OTPValidationType;
+    type ChangeEventReason = OTPFieldRootChangeEventReason;
+    type ChangeEventDetails = OTPFieldRootChangeEventDetails;
+    type InvalidEventReason = OTPFieldRootInvalidEventReason;
+    type InvalidEventDetails = OTPFieldRootInvalidEventDetails;
+    type CompleteEventReason = OTPFieldRootCompleteEventReason;
+    type CompleteEventDetails = OTPFieldRootCompleteEventDetails;
+}
+export {};

package/dist/lib/types/otp-field/root/OTPFieldRootContext.d.ts

@@ -0,0 +1,45 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { OTPFieldInputState } from '../input/OTPFieldInput.js';
+import type { OTPValidationType } from '../utils/otp.js';
+import type { OTPFieldRootChangeEventDetails, OTPFieldRootInvalidEventDetails, OTPFieldRootState } from './OTPFieldRoot.js';
+export interface OTPFieldInputRegistration {
+    index: Accessor<number>;
+    setElement: (element: HTMLInputElement) => void;
+    unregister: () => void;
+}
+export interface OTPFieldRootContextValue {
+    activeIndex: Accessor<number>;
+    autoComplete: Accessor<string | undefined>;
+    disabled: Accessor<boolean>;
+    form: Accessor<string | undefined>;
+    focusInput: (index: number) => void;
+    queueFocusInput: (index: number, value: string) => void;
+    getInputId: (index: number) => string | undefined;
+    handleInputBlur: (event: FocusEvent & {
+        currentTarget: HTMLInputElement;
+    }) => void;
+    handleInputFocus: (index: number, event: FocusEvent & {
+        currentTarget: HTMLInputElement;
+    }) => void;
+    inputMode: Accessor<JSX.InputHTMLAttributes<HTMLInputElement>['inputmode']>;
+    inputAriaLabelledBy: Accessor<string | undefined>;
+    invalid: Accessor<boolean>;
+    length: Accessor<number>;
+    mask: Accessor<boolean>;
+    normalizeValue: Accessor<((value: string) => string) | undefined>;
+    pattern: Accessor<string | undefined>;
+    readOnly: Accessor<boolean>;
+    registerInput: () => OTPFieldInputRegistration;
+    reportValueInvalid: (value: string, details: OTPFieldRootInvalidEventDetails) => void;
+    required: Accessor<boolean>;
+    setValue: (value: string, details: OTPFieldRootChangeEventDetails) => string | null;
+    state: Accessor<OTPFieldRootState>;
+    validationType: Accessor<OTPValidationType>;
+    value: Accessor<string>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const OTPFieldRootContext: import("solid-js").Context<OTPFieldRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useOTPFieldRootContext(): OTPFieldRootContextValue;
+export declare function getOTPFieldInputState(state: OTPFieldRootState, value: string, index: number): OTPFieldInputState;
+export {};

package/dist/lib/types/otp-field/utils/otp.d.ts

@@ -0,0 +1,14 @@
+interface OTPValidationConfig {
+    slotPattern: string;
+    getRootPattern: (length: number) => string;
+    regexp: RegExp;
+    inputMode: 'numeric' | 'text';
+}
+export type OTPValidationType = 'numeric' | 'alpha' | 'alphanumeric' | 'none';
+export declare function getOTPValidationConfig(validationType: OTPValidationType): OTPValidationConfig | null;
+export declare function stripOTPWhitespace(value: string | null | undefined): string;
+export declare function normalizeOTPValueWithDetails(value: string | null | undefined, length: number, validationType: OTPValidationType, normalizeValue?: ((value: string) => string) | undefined): readonly [value: string, didRejectCharacters: boolean];
+export declare function normalizeOTPValue(value: string | null | undefined, length: number, validationType: OTPValidationType, normalizeValue?: ((value: string) => string) | undefined): string;
+export declare function replaceOTPValue(currentValue: string, index: number, nextValue: string, length: number, validationType: OTPValidationType, normalizeValue?: ((value: string) => string) | undefined): string;
+export declare function removeOTPCharacter(currentValue: string, index: number): string;
+export {};

package/dist/lib/types/otp-field/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,5 @@
+import type { StateAttributesMapping } from '../../internals/getStateAttributesProps.js';
+import type { OTPFieldInputState } from '../input/OTPFieldInput.js';
+import type { OTPFieldRootState } from '../root/OTPFieldRoot.js';
+export declare const rootStateAttributesMapping: StateAttributesMapping<OTPFieldRootState>;
+export declare const inputStateAttributesMapping: StateAttributesMapping<OTPFieldInputState>;

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

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

package/dist/lib/types/popover/close/PopoverClose.d.ts

@@ -0,0 +1,25 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PopoverCloseState {
+}
+type CloseEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface PopoverCloseOwnProps<Component extends ValidComponent> {
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<CloseEventTarget<Component>, PointerEvent> | undefined;
+}
+export type PopoverCloseProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, PopoverCloseState, PopoverCloseOwnProps<Component>>;
+/** A button that closes the popover. */
+export declare function PopoverClose<Component extends ValidComponent = 'button'>(props: PopoverClose.Props<Component>): JSX.Element;
+export declare namespace PopoverClose {
+    type State = PopoverCloseState;
+    type Props<Component extends ValidComponent = 'button'> = PopoverCloseProps<Component>;
+}
+export {};

package/dist/lib/types/popover/description/PopoverDescription.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface PopoverDescriptionState {
+}
+export type PopoverDescriptionProps<Component extends ValidComponent = 'p'> = BaseUIComponentProps<Component, PopoverDescriptionState>;
+/** A paragraph that describes the popover. */
+export declare function PopoverDescription<Component extends ValidComponent = 'p'>(props: PopoverDescription.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PopoverDescription {
+    type State = PopoverDescriptionState;
+    type Props<Component extends ValidComponent = 'p'> = PopoverDescriptionProps<Component>;
+}

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

@@ -0,0 +1,12 @@
+export * as Popover from './index.parts.js';
+export type * from './root/PopoverRoot.js';
+export type * from './trigger/PopoverTrigger.js';
+export type * from './portal/PopoverPortal.js';
+export type * from './positioner/PopoverPositioner.js';
+export type * from './popup/PopoverPopup.js';
+export type * from './arrow/PopoverArrow.js';
+export type * from './backdrop/PopoverBackdrop.js';
+export type * from './title/PopoverTitle.js';
+export type * from './description/PopoverDescription.js';
+export type * from './close/PopoverClose.js';
+export type * from './viewport/PopoverViewport.js';

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

@@ -0,0 +1,12 @@
+export { PopoverRoot as Root } from './root/PopoverRoot.js';
+export { PopoverTrigger as Trigger } from './trigger/PopoverTrigger.js';
+export { PopoverPortal as Portal } from './portal/PopoverPortal.js';
+export { PopoverPositioner as Positioner } from './positioner/PopoverPositioner.js';
+export { PopoverPopup as Popup } from './popup/PopoverPopup.js';
+export { PopoverArrow as Arrow } from './arrow/PopoverArrow.js';
+export { PopoverBackdrop as Backdrop } from './backdrop/PopoverBackdrop.js';
+export { PopoverTitle as Title } from './title/PopoverTitle.js';
+export { PopoverDescription as Description } from './description/PopoverDescription.js';
+export { PopoverClose as Close } from './close/PopoverClose.js';
+export { PopoverViewport as Viewport } from './viewport/PopoverViewport.js';
+export { PopoverHandle as Handle, createPopoverHandle as createHandle } from './store/PopoverHandle.js';

package/dist/lib/types/popover/popup/PopoverPopup.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';
+import type { PopoverInstantType } from '../store/PopoverStore.js';
+export interface PopoverPopupState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    transitionStatus: TransitionStatus;
+    instant: PopoverInstantType;
+}
+interface PopoverPopupOwnProps {
+    initialFocus?: FocusResolver | undefined;
+    finalFocus?: FocusResolver | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type PopoverPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PopoverPopupState, PopoverPopupOwnProps>;
+/** A container for the popover contents. */
+export declare function PopoverPopup<Component extends ValidComponent = 'div'>(props: PopoverPopup.Props<Component>): JSX.Element;
+export declare namespace PopoverPopup {
+    type State = PopoverPopupState;
+    type Props<Component extends ValidComponent = 'div'> = PopoverPopupProps<Component>;
+}
+export {};

package/dist/lib/types/popover/portal/PopoverPortal.d.ts

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

package/dist/lib/types/popover/portal/PopoverPortalContext.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+export interface PopoverPortalContextValue {
+    keepMounted: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const PopoverPortalContext: import("solid-js").Context<PopoverPortalContextValue | typeof MISSING_CONTEXT>;
+export declare function usePopoverPortalContext(): PopoverPortalContextValue;
+export {};

package/dist/lib/types/popover/positioner/PopoverPositioner.d.ts

@@ -0,0 +1,38 @@
+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';
+import type { PopoverInstantType } from '../store/PopoverStore.js';
+export type PopoverAnchor = ReferenceElement | Accessor<ReferenceElement | null> | {
+    current: ReferenceElement | null;
+} | null;
+export interface PopoverPositionerState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    instant: PopoverInstantType | 'initial';
+}
+interface PopoverPositionerOwnProps {
+    anchor?: PopoverAnchor | undefined;
+    positionMethod?: Strategy | undefined;
+    side?: AnchorSide | undefined;
+    sideOffset?: number | OffsetFunction | undefined;
+    align?: AnchorAlign | undefined;
+    alignOffset?: number | OffsetFunction | undefined;
+    collisionBoundary?: AnchorBoundary | undefined;
+    collisionPadding?: number | Partial<Record<'top' | 'right' | 'bottom' | 'left', number>> | undefined;
+    arrowPadding?: number | undefined;
+    sticky?: boolean | undefined;
+    disableAnchorTracking?: boolean | undefined;
+    collisionAvoidance?: CollisionAvoidance | undefined;
+}
+export type PopoverPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, PopoverPositionerState, PopoverPositionerOwnProps>;
+/** Positions the popup against its active trigger or a custom anchor. */
+export declare function PopoverPositioner<Component extends ValidComponent = 'div'>(props: PopoverPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace PopoverPositioner {
+    type State = PopoverPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = PopoverPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/popover/positioner/PopoverPositionerContext.d.ts

@@ -0,0 +1,5 @@
+import type { AnchorPositioning } from '../../internals/overlay/index.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const PopoverPositionerContext: import("solid-js").Context<AnchorPositioning | typeof MISSING_CONTEXT>;
+export declare function usePopoverPositionerContext(): AnchorPositioning;
+export {};

package/dist/lib/types/popover/root/PopoverRoot.d.ts

@@ -0,0 +1,38 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { PopoverHandle } from '../store/PopoverHandle.js';
+export interface PopoverRootState {
+}
+export interface PopoverRootActions {
+    unmount(): void;
+    close(): void;
+}
+export type PopoverRootChangeEventReason = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type PopoverRootChangeEventDetails = BaseUIChangeEventDetails<PopoverRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export interface PopoverRootProps<Payload = unknown> {
+    open?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    modal?: boolean | 'trap-focus' | undefined;
+    onOpenChange?: ((open: boolean, details: PopoverRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    actionsRef?: ((actions: PopoverRootActions) => void) | undefined;
+    handle?: PopoverHandle<Payload> | undefined;
+    children?: JSX.Element | ((state: {
+        payload: Accessor<Payload | undefined>;
+    }) => JSX.Element);
+    triggerId?: string | null | undefined;
+    defaultTriggerId?: string | null | undefined;
+}
+/** Groups all parts of the popover without rendering an element. */
+export declare function PopoverRoot<Payload = unknown>(props: PopoverRoot.Props<Payload>): JSX.Element;
+export declare namespace PopoverRoot {
+    type State = PopoverRootState;
+    type Props<Payload = unknown> = PopoverRootProps<Payload>;
+    type Actions = PopoverRootActions;
+    type ChangeEventReason = PopoverRootChangeEventReason;
+    type ChangeEventDetails = PopoverRootChangeEventDetails;
+}

package/dist/lib/types/popover/root/PopoverRootContext.d.ts

@@ -0,0 +1,25 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { FloatingTreeStore, PopupPresence } from '../../internals/overlay/index.js';
+import type { PopoverStore } from '../store/PopoverStore.js';
+export interface PopoverRootContextValue<Payload = unknown> {
+    store: PopoverStore<Payload>;
+    tree: FloatingTreeStore;
+    modal: Accessor<boolean | 'trap-focus'>;
+    titleId: Accessor<string | undefined>;
+    setTitleId: Setter<string | undefined>;
+    descriptionId: Accessor<string | undefined>;
+    setDescriptionId: Setter<string | undefined>;
+    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;
+    presence: PopupPresence;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const PopoverRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | PopoverRootContextValue<unknown>>;
+export declare function usePopoverRootContext<Payload = unknown>(optional?: boolean): PopoverRootContextValue<Payload> | undefined;
+export {};

package/dist/lib/types/popover/store/PopoverHandle.d.ts

@@ -0,0 +1,10 @@
+import { BasePopupHandle } from '../../internals/overlay/PopupHandle.js';
+import { PopoverStore } from './PopoverStore.js';
+/** Imperatively controls a Popover and connects detached triggers to its Root. */
+export declare class PopoverHandle<Payload = unknown> extends BasePopupHandle<PopoverStore<Payload>> {
+    constructor();
+    open(triggerId: string): void;
+    close(): void;
+    get isOpen(): boolean;
+}
+export declare function createPopoverHandle<Payload = unknown>(): PopoverHandle<Payload>;