solid-baseui 0.1.0-alpha.0

package/dist/lib/types/combobox/store/ComboboxStore.d.ts

@@ -0,0 +1,65 @@
+import { type Accessor } from 'solid-js';
+import { PopupStore, type InteractionType, type PopupStoreOptions } from '../../internals/overlay/index.js';
+import type { AnchorSide } from '../../internals/overlay/createAnchorPositioning.js';
+import type { ComboboxRootChangeEventDetails } from '../root/AriaCombobox.js';
+import { ComboboxItemRegistry } from './ComboboxItemRegistry.js';
+export interface ComboboxStoreOptions extends PopupStoreOptions<ComboboxRootChangeEventDetails> {
+}
+/**
+ * Combobox popup state shared by every part.
+ *
+ * The highlighted and selected positions are indices rather than elements because a combobox can
+ * be driven by the `items` prop or by an external virtualizer, where no element exists for a row
+ * until it is windowed in.
+ */
+export declare class ComboboxStore<Value = unknown> extends PopupStore<never, ComboboxRootChangeEventDetails> {
+    readonly collection: ComboboxItemRegistry<Value>;
+    /**
+     * Whether the last interaction came from the keyboard. Read at event time to attribute a
+     * highlight change, so it stays a plain field rather than a signal.
+     */
+    keyboardActive: boolean;
+    /**
+     * The item element that received the last `pointerdown`, used to tell a click apart from the
+     * release of a drag-select gesture that started somewhere else.
+     */
+    pointerDownItem: Element | null;
+    /** A keyboard event standing in for the synthetic click it dispatched on the active item. */
+    selectionEvent: MouseEvent | PointerEvent | KeyboardEvent | null;
+    chipsContainerElement: HTMLElement | null;
+    clearElement: HTMLElement | null;
+    emptyElement: HTMLElement | null;
+    startDismissElement: HTMLElement | null;
+    endDismissElement: HTMLElement | null;
+    readonly activeIndex: Accessor<number | null>;
+    readonly setActiveIndex: (value: number | null) => void;
+    readonly selectedIndex: Accessor<number | null>;
+    readonly setSelectedIndex: (value: number | null) => void;
+    readonly forceMounted: Accessor<boolean>;
+    readonly setForceMounted: (value: boolean) => void;
+    readonly labelId: Accessor<string | undefined>;
+    readonly setLabelId: (value: string | undefined) => void;
+    readonly listElement: Accessor<HTMLElement | null>;
+    readonly setListElement: (value: HTMLElement | null) => void;
+    readonly popupSide: Accessor<AnchorSide | null>;
+    readonly setPopupSide: (value: AnchorSide | null) => void;
+    readonly openMethod: Accessor<InteractionType | null>;
+    readonly setOpenMethod: (value: InteractionType | null) => void;
+    /**
+     * Whether `<Combobox.Input>` is rendered inside the popup. That inverts the anatomy: the
+     * trigger becomes the labelled combobox control and the popup becomes a dialog.
+     */
+    readonly inputInsidePopup: Accessor<boolean>;
+    readonly setInputInsidePopup: (value: boolean) => void;
+    readonly inputOwnsFormValue: Accessor<boolean>;
+    readonly setInputOwnsFormValue: (value: boolean) => void;
+    constructor(options: ComboboxStoreOptions);
+    /** The item elements addressed by index, as list navigation and typeahead see them. */
+    elements(): Array<HTMLElement | null>;
+    /**
+     * The popup side is only meaningful while the positioner is mounted; the store retains the last
+     * resolved side after the popup unmounts so an exit animation does not lose it.
+     */
+    resolvedPopupSide(): AnchorSide | null;
+    resetAfterClose(): void;
+}

package/dist/lib/types/combobox/trigger/ComboboxTrigger.d.ts

@@ -0,0 +1,36 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { FieldState } from '../../internals/field-constants.js';
+import { type AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ComboboxTriggerState extends FieldState {
+    open: boolean;
+    disabled: boolean;
+    popupSide: AnchorSide | null;
+    listEmpty: boolean;
+    placeholder: boolean;
+}
+interface ComboboxTriggerOwnProps {
+    /**
+     * Whether the component should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | 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;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+    onPointerEnter?: BaseUIEventHandlerUnion<HTMLElement, PointerEvent> | undefined;
+}
+export type ComboboxTriggerProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, ComboboxTriggerState, ComboboxTriggerOwnProps>;
+/** A button that opens the popup. */
+export declare function ComboboxTrigger<Component extends ValidComponent = 'button'>(props: ComboboxTrigger.Props<Component>): JSX.Element;
+export declare namespace ComboboxTrigger {
+    type State = ComboboxTriggerState;
+    type Props<Component extends ValidComponent = 'button'> = ComboboxTriggerProps<Component>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import type { ItemGroup, ItemsInput } from '../internals/valueLabel.js';
+/** A named collection of combobox items. Extra keys carry caller-defined group metadata. */
+export type ComboboxItemGroup<Item = unknown> = ItemGroup<Item>;
+/** The `items` (or `filteredItems`) prop: a flat list, or a list of groups. */
+export type ComboboxItems<Item = unknown> = ReadonlyArray<Item> | ReadonlyArray<ComboboxItemGroup<Item>>;
+export type ComboboxItemsInput<Item = unknown> = ItemsInput<Item>;
+/** Matches one item against the current query. */
+export type ComboboxItemFilter<Item = unknown> = (itemValue: Item, query: string, itemToString?: ((itemValue: Item) => string) | undefined) => boolean;
+/** How the combobox remembers what the user picked. */
+export type ComboboxSelectionMode = 'single' | 'multiple' | 'none';
+/** How the input and the list relate while the user types. */
+export type ComboboxAutoComplete = 'list' | 'both' | 'inline' | 'none';
+/** When the first matching item is highlighted automatically. */
+export type ComboboxAutoHighlight = boolean | 'always';
+export type ResolvedAutoHighlight = false | 'input-change' | 'always';

package/dist/lib/types/combobox/utils/ComboboxInternalDismissButton.d.ts

@@ -0,0 +1,9 @@
+import type { JSX } from '@solidjs/web';
+/**
+ * A visually hidden control that gives screen reader users a way out of the popup when the input
+ * is inside it and the trigger is no longer reachable.
+ * @internal
+ */
+export declare function ComboboxInternalDismissButton(props: {
+    ref?: (element: HTMLElement | null) => void;
+}): JSX.Element;

package/dist/lib/types/combobox/utils/comboboxPopupId.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The default id `<Combobox.Popup>` takes when the input is rendered inside it. The popup applies
+ * it and the trigger references it through `aria-controls`, so the convention lives in one place.
+ */
+export declare function getComboboxPopupId(rootId: string | null | undefined): string | undefined;

package/dist/lib/types/combobox/utils/createInitialLiveRegionTextMutation.d.ts

@@ -0,0 +1,7 @@
+/** Safari VoiceOver needs roughly this long to notice the first polite live-region change. */
+export declare const INITIAL_LIVE_REGION_TEXT_MUTATION_RESET_DELAY = 200;
+/**
+ * Marks the first rendered text of a polite live region so screen readers announce content that
+ * was already present when the region mounted. Later text updates announce on their own.
+ */
+export declare function createInitialLiveRegionTextMutation(element: () => HTMLElement | null): void;

package/dist/lib/types/combobox/utils/handleInputPress.d.ts

@@ -0,0 +1,7 @@
+import type { ComboboxRootContextValue } from '../root/ComboboxRootContext.js';
+import type { BaseUIEvent } from '../../types/index.js';
+/**
+ * Routes a press anywhere in the input's surroundings back to the input, so clicking the padding
+ * of an input group or the empty space beside the chips focuses and opens the combobox.
+ */
+export declare function handleInputPress(event: BaseUIEvent<MouseEvent>, context: ComboboxRootContextValue<never>, disabled: boolean, readOnly: boolean, shouldIgnoreTarget?: ((target: Element | null) => boolean) | undefined): void;

package/dist/lib/types/combobox/utils/parts.d.ts

@@ -0,0 +1,4 @@
+/** The arrow keys that move the chip highlight backwards and forwards, in that order. */
+export declare function getChipNavigationKeys(direction: 'ltr' | 'rtl'): readonly ['ArrowLeft' | 'ArrowRight', 'ArrowLeft' | 'ArrowRight'];
+/** Where the highlight lands once the chip at `index` is removed, or `undefined` for none. */
+export declare function getIndexAfterChipRemoval(index: number, chipCount: number): number | undefined;

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

@@ -0,0 +1,58 @@
+import type { AnchorSide } from '../../internals/overlay/index.js';
+/** Shared by the input, input group, and trigger, which all reflect the popup's state. */
+export declare const comboboxControlStateMapping: {
+    popupSide: (side: AnchorSide | null) => {
+        'data-popup-side': AnchorSide;
+    } | null;
+    listEmpty: (empty: boolean) => {
+        'data-list-empty': string;
+    } | null;
+    disabled?: ((state: boolean) => Record<string, string> | null) | undefined;
+    touched?: ((state: boolean) => Record<string, string> | null) | undefined;
+    dirty?: ((state: boolean) => Record<string, string> | null) | undefined;
+    valid?: ((state: boolean | null) => Record<string, string> | null) | undefined;
+    filled?: ((state: boolean) => Record<string, string> | null) | undefined;
+    focused?: ((state: boolean) => Record<string, string> | null) | undefined;
+    open: (value: boolean) => {
+        'data-popup-open': string;
+        'data-pressed': string;
+    } | null;
+};
+export declare const comboboxPositionerStateMapping: {
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const comboboxPopupStateMapping: {
+    instant: (value: "focus" | "delay" | "dismiss" | undefined) => {
+        'data-instant': "focus" | "delay" | "dismiss";
+    } | null;
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const comboboxBackdropStateMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+};
+export declare const comboboxClearStateMapping: {
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-popup-open': string;
+    } | null;
+};

package/dist/lib/types/combobox/value/ComboboxValue.d.ts

@@ -0,0 +1,20 @@
+import type { JSX } from '@solidjs/web';
+export interface ComboboxValueState {
+}
+export interface ComboboxValueProps<Value = unknown> {
+    children?: JSX.Element | ((selectedValue: Value | Value[] | null) => JSX.Element);
+    /**
+     * The placeholder to display when no value is selected.
+     * Overridden by `children`, or by a null item's label in `items`.
+     */
+    placeholder?: JSX.Element;
+}
+/**
+ * The current value of the combobox.
+ * Doesn't render its own HTML element.
+ */
+export declare function ComboboxValue<Value = unknown>(props: ComboboxValue.Props<Value>): JSX.Element;
+export declare namespace ComboboxValue {
+    type State = ComboboxValueState;
+    type Props<Value = unknown> = ComboboxValueProps<Value>;
+}

package/dist/lib/types/context-menu/index.d.ts

@@ -0,0 +1,19 @@
+export * as ContextMenu from './index.parts.js';
+export type * from './root/ContextMenuRoot.js';
+export type * from './trigger/ContextMenuTrigger.js';
+export type { MenuBackdropProps as ContextMenuBackdropProps, MenuBackdropState as ContextMenuBackdropState, } from '../menu/backdrop/MenuBackdrop.js';
+export type { MenuPortalProps as ContextMenuPortalProps, MenuPortalState as ContextMenuPortalState, } from '../menu/portal/MenuPortal.js';
+export type { MenuPositionerProps as ContextMenuPositionerProps, MenuPositionerState as ContextMenuPositionerState, } from '../menu/positioner/MenuPositioner.js';
+export type { MenuPopupProps as ContextMenuPopupProps, MenuPopupState as ContextMenuPopupState, } from '../menu/popup/MenuPopup.js';
+export type { MenuArrowProps as ContextMenuArrowProps, MenuArrowState as ContextMenuArrowState, } from '../menu/arrow/MenuArrow.js';
+export type { MenuGroupProps as ContextMenuGroupProps, MenuGroupState as ContextMenuGroupState, } from '../menu/group/MenuGroup.js';
+export type { MenuGroupLabelProps as ContextMenuGroupLabelProps, MenuGroupLabelState as ContextMenuGroupLabelState, } from '../menu/group-label/MenuGroupLabel.js';
+export type { MenuItemProps as ContextMenuItemProps, MenuItemState as ContextMenuItemState, } from '../menu/item/MenuItem.js';
+export type { MenuLinkItemProps as ContextMenuLinkItemProps, MenuLinkItemState as ContextMenuLinkItemState, } from '../menu/link-item/MenuLinkItem.js';
+export type { MenuCheckboxItemProps as ContextMenuCheckboxItemProps, MenuCheckboxItemState as ContextMenuCheckboxItemState, } from '../menu/checkbox-item/MenuCheckboxItem.js';
+export type { MenuCheckboxItemIndicatorProps as ContextMenuCheckboxItemIndicatorProps, MenuCheckboxItemIndicatorState as ContextMenuCheckboxItemIndicatorState, } from '../menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js';
+export type { MenuRadioGroupProps as ContextMenuRadioGroupProps, MenuRadioGroupState as ContextMenuRadioGroupState, } from '../menu/radio-group/MenuRadioGroup.js';
+export type { MenuRadioItemProps as ContextMenuRadioItemProps, MenuRadioItemState as ContextMenuRadioItemState, } from '../menu/radio-item/MenuRadioItem.js';
+export type { MenuRadioItemIndicatorProps as ContextMenuRadioItemIndicatorProps, MenuRadioItemIndicatorState as ContextMenuRadioItemIndicatorState, } from '../menu/radio-item-indicator/MenuRadioItemIndicator.js';
+export type { MenuSubmenuRootProps as ContextMenuSubmenuRootProps, MenuSubmenuRootState as ContextMenuSubmenuRootState, } from '../menu/submenu-root/MenuSubmenuRoot.js';
+export type { MenuSubmenuTriggerProps as ContextMenuSubmenuTriggerProps, MenuSubmenuTriggerState as ContextMenuSubmenuTriggerState, } from '../menu/submenu-trigger/MenuSubmenuTrigger.js';

package/dist/lib/types/context-menu/index.parts.d.ts

@@ -0,0 +1,19 @@
+export { ContextMenuRoot as Root } from './root/ContextMenuRoot.js';
+export { ContextMenuTrigger as Trigger } from './trigger/ContextMenuTrigger.js';
+export { MenuBackdrop as Backdrop } from '../menu/backdrop/MenuBackdrop.js';
+export { MenuPortal as Portal } from '../menu/portal/MenuPortal.js';
+export { MenuPositioner as Positioner } from '../menu/positioner/MenuPositioner.js';
+export { MenuPopup as Popup } from '../menu/popup/MenuPopup.js';
+export { MenuArrow as Arrow } from '../menu/arrow/MenuArrow.js';
+export { MenuGroup as Group } from '../menu/group/MenuGroup.js';
+export { MenuGroupLabel as GroupLabel } from '../menu/group-label/MenuGroupLabel.js';
+export { MenuItem as Item } from '../menu/item/MenuItem.js';
+export { MenuCheckboxItem as CheckboxItem } from '../menu/checkbox-item/MenuCheckboxItem.js';
+export { MenuCheckboxItemIndicator as CheckboxItemIndicator } from '../menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js';
+export { MenuLinkItem as LinkItem } from '../menu/link-item/MenuLinkItem.js';
+export { MenuRadioGroup as RadioGroup } from '../menu/radio-group/MenuRadioGroup.js';
+export { MenuRadioItem as RadioItem } from '../menu/radio-item/MenuRadioItem.js';
+export { MenuRadioItemIndicator as RadioItemIndicator } from '../menu/radio-item-indicator/MenuRadioItemIndicator.js';
+export { MenuSubmenuRoot as SubmenuRoot } from '../menu/submenu-root/MenuSubmenuRoot.js';
+export { MenuSubmenuTrigger as SubmenuTrigger } from '../menu/submenu-trigger/MenuSubmenuTrigger.js';
+export { Separator } from '../separator/Separator.js';

package/dist/lib/types/context-menu/root/ContextMenuRoot.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { MenuRoot, type MenuRootProps } from '../../menu/root/MenuRoot.js';
+export interface ContextMenuRootState {
+}
+export type ContextMenuRootProps = Omit<MenuRootProps, 'children' | 'defaultTriggerId' | 'handle' | 'modal' | 'onOpenChange' | 'triggerId'> & {
+    onOpenChange?: ((open: boolean, details: ContextMenuRoot.ChangeEventDetails) => void) | undefined;
+    children?: JSX.Element;
+};
+export type ContextMenuRootActions = MenuRoot.Actions;
+export type ContextMenuRootChangeEventReason = MenuRoot.ChangeEventReason;
+export type ContextMenuRootChangeEventDetails = BaseUIChangeEventDetails<ContextMenuRootChangeEventReason>;
+/** Groups all parts of a context menu without rendering an element. */
+export declare function ContextMenuRoot(props: ContextMenuRoot.Props): JSX.Element;
+export declare namespace ContextMenuRoot {
+    type State = ContextMenuRootState;
+    type Props = ContextMenuRootProps;
+    type Actions = ContextMenuRootActions;
+    type ChangeEventReason = ContextMenuRootChangeEventReason;
+    type ChangeEventDetails = ContextMenuRootChangeEventDetails;
+}

package/dist/lib/types/context-menu/root/ContextMenuRootContext.d.ts

@@ -0,0 +1,19 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { ReferenceElement } from '@floating-ui/dom';
+export interface ContextMenuRootContextValue {
+    anchor: Accessor<ReferenceElement>;
+    setAnchor: Setter<ReferenceElement>;
+    initialCursorPoint: {
+        current: {
+            x: number;
+            y: number;
+        } | null;
+    };
+    allowOutsidePressDismissal: {
+        current: boolean;
+    };
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const ContextMenuRootContext: import("solid-js").Context<ContextMenuRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useContextMenuRootContext(optional?: boolean): ContextMenuRootContextValue | undefined;
+export {};

package/dist/lib/types/context-menu/trigger/ContextMenuTrigger.d.ts

@@ -0,0 +1,21 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface ContextMenuTriggerState {
+    open: boolean;
+}
+interface ContextMenuTriggerOwnProps {
+    onContextMenu?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onTouchStart?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchMove?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchEnd?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchCancel?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+}
+export type ContextMenuTriggerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, ContextMenuTriggerState, ContextMenuTriggerOwnProps>;
+/** An area that opens the menu on right click or long press. */
+export declare function ContextMenuTrigger<Component extends ValidComponent = 'div'>(props: ContextMenuTrigger.Props<Component>): JSX.Element;
+export declare namespace ContextMenuTrigger {
+    type State = ContextMenuTriggerState;
+    type Props<Component extends ValidComponent = 'div'> = ContextMenuTriggerProps<Component>;
+}
+export {};

package/dist/lib/types/csp-provider/CSPProvider.d.ts

@@ -0,0 +1,14 @@
+import type { ParentProps } from 'solid-js';
+export interface CSPProviderState {
+}
+export interface CSPProviderProps extends ParentProps {
+    /** The nonce applied to inline style and script elements. */
+    nonce?: string | undefined;
+    /** Prevents Base UI components from creating inline style elements. @default false */
+    disableStyleElements?: boolean | undefined;
+}
+export declare function CSPProvider(props: CSPProvider.Props): import("@solidjs/web").JSX.Element;
+export declare namespace CSPProvider {
+    type State = CSPProviderState;
+    type Props = CSPProviderProps;
+}

package/dist/lib/types/csp-provider/index.d.ts

@@ -0,0 +1,2 @@
+export { CSPProvider } from './CSPProvider.js';
+export type { CSPProviderProps, CSPProviderState } from './CSPProvider.js';

package/dist/lib/types/dialog/backdrop/DialogBackdrop.d.ts

@@ -0,0 +1,18 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DialogBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+interface DialogBackdropOwnProps {
+    forceRender?: boolean | undefined;
+}
+export type DialogBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DialogBackdropState, DialogBackdropOwnProps>;
+/** An overlay displayed beneath the dialog popup. */
+export declare function DialogBackdrop<Component extends ValidComponent = 'div'>(props: DialogBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DialogBackdrop {
+    type State = DialogBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = DialogBackdropProps<Component>;
+}
+export {};

package/dist/lib/types/dialog/close/DialogClose.d.ts

@@ -0,0 +1,26 @@
+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 DialogCloseState {
+    disabled: boolean;
+}
+type CloseEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface DialogCloseOwnProps<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 DialogCloseProps<Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, DialogCloseState, DialogCloseOwnProps<Component>>;
+/** A button that closes the dialog. */
+export declare function DialogClose<Component extends ValidComponent = 'button'>(props: DialogClose.Props<Component>): JSX.Element;
+export declare namespace DialogClose {
+    type State = DialogCloseState;
+    type Props<Component extends ValidComponent = 'button'> = DialogCloseProps<Component>;
+}
+export {};

package/dist/lib/types/dialog/description/DialogDescription.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DialogDescriptionState {
+}
+export type DialogDescriptionProps<Component extends ValidComponent = 'p'> = BaseUIComponentProps<Component, DialogDescriptionState>;
+/** A paragraph with additional information about the dialog. */
+export declare function DialogDescription<Component extends ValidComponent = 'p'>(props: DialogDescription.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DialogDescription {
+    type State = DialogDescriptionState;
+    type Props<Component extends ValidComponent = 'p'> = DialogDescriptionProps<Component>;
+}

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

@@ -0,0 +1,10 @@
+export * as Dialog from './index.parts.js';
+export type * from './root/DialogRoot.js';
+export type * from './trigger/DialogTrigger.js';
+export type * from './portal/DialogPortal.js';
+export type * from './backdrop/DialogBackdrop.js';
+export type * from './viewport/DialogViewport.js';
+export type * from './popup/DialogPopup.js';
+export type * from './title/DialogTitle.js';
+export type * from './description/DialogDescription.js';
+export type * from './close/DialogClose.js';

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

@@ -0,0 +1,10 @@
+export { DialogRoot as Root } from './root/DialogRoot.js';
+export { DialogTrigger as Trigger } from './trigger/DialogTrigger.js';
+export { DialogPortal as Portal } from './portal/DialogPortal.js';
+export { DialogBackdrop as Backdrop } from './backdrop/DialogBackdrop.js';
+export { DialogViewport as Viewport } from './viewport/DialogViewport.js';
+export { DialogPopup as Popup } from './popup/DialogPopup.js';
+export { DialogTitle as Title } from './title/DialogTitle.js';
+export { DialogDescription as Description } from './description/DialogDescription.js';
+export { DialogClose as Close } from './close/DialogClose.js';
+export { DialogHandle as Handle, createDialogHandle as createHandle } from './store/DialogHandle.js';

package/dist/lib/types/dialog/popup/DialogPopup.d.ts

@@ -0,0 +1,24 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type FocusResolver } from '../../internals/overlay/index.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DialogPopupState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+    nested: boolean;
+    nestedDialogOpen: boolean;
+}
+interface DialogPopupOwnProps {
+    initialFocus?: FocusResolver | undefined;
+    finalFocus?: FocusResolver | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type DialogPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DialogPopupState, DialogPopupOwnProps>;
+/** A container for the dialog contents. */
+export declare function DialogPopup<Component extends ValidComponent = 'div'>(props: DialogPopup.Props<Component>): JSX.Element;
+export declare namespace DialogPopup {
+    type State = DialogPopupState;
+    type Props<Component extends ValidComponent = 'div'> = DialogPopupProps<Component>;
+}
+export {};

package/dist/lib/types/dialog/portal/DialogPortal.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 DialogPortalState {
+}
+interface DialogPortalOwnProps {
+    keepMounted?: boolean | undefined;
+    container?: PopupPortalContainer | undefined;
+}
+export type DialogPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DialogPortalState, DialogPortalOwnProps>;
+/** Moves the dialog layer into a portal appended to the document body by default. */
+export declare function DialogPortal<Component extends ValidComponent = 'div'>(props: DialogPortal.Props<Component>): JSX.Element;
+export declare namespace DialogPortal {
+    type State = DialogPortalState;
+    type Props<Component extends ValidComponent = 'div'> = DialogPortalProps<Component>;
+}
+export {};

package/dist/lib/types/dialog/portal/DialogPortalContext.d.ts

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

package/dist/lib/types/dialog/root/DialogRoot.d.ts

@@ -0,0 +1,44 @@
+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 { DialogHandle } from '../store/DialogHandle.js';
+export interface DialogRootState {
+}
+export interface DialogRootActions {
+    unmount(): void;
+    close(): void;
+}
+export type DialogRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type DialogRootChangeEventDetails = BaseUIChangeEventDetails<DialogRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export interface DialogRootProps<Payload = unknown> {
+    open?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    modal?: boolean | 'trap-focus' | undefined;
+    onOpenChange?: ((open: boolean, details: DialogRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    disablePointerDismissal?: boolean | undefined;
+    actionsRef?: ((actions: DialogRootActions) => void) | undefined;
+    handle?: DialogHandle<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 dialog without rendering an element. */
+export declare function DialogRoot<Payload = unknown>(props: DialogRoot.Props<Payload>): JSX.Element;
+export type DialogRootMode = 'dialog' | 'alert-dialog' | 'drawer';
+/** @internal Shared root implementation for Dialog specializations. */
+export declare function renderDialogRoot<Payload = unknown>(mode: DialogRootMode, props: DialogRoot.Props<Payload>, options?: {
+    extraContent?: (() => JSX.Element) | undefined;
+}): JSX.Element;
+export declare namespace DialogRoot {
+    type State = DialogRootState;
+    type Props<Payload = unknown> = DialogRootProps<Payload>;
+    type Actions = DialogRootActions;
+    type ChangeEventReason = DialogRootChangeEventReason;
+    type ChangeEventDetails = DialogRootChangeEventDetails;
+}

package/dist/lib/types/dialog/root/DialogRootContext.d.ts

@@ -0,0 +1,38 @@
+import { type Accessor, type Setter } from 'solid-js';
+import type { FloatingTreeStore, PopupPresence } from '../../internals/overlay/index.js';
+import type { DialogStore } from '../store/DialogStore.js';
+export interface DialogRootContextValue<Payload = unknown> {
+    store: DialogStore<Payload>;
+    tree: FloatingTreeStore;
+    nested: boolean;
+    role: 'dialog' | 'alertdialog';
+    modal: Accessor<boolean | 'trap-focus'>;
+    disablePointerDismissal: Accessor<boolean>;
+    nestedOpenDialogCount: Accessor<number>;
+    nestedOpenDrawerCount: Accessor<number>;
+    /**
+     * Imperative gate for outside-press dismissal. `Drawer.SwipeArea` clears it while a
+     * swipe-to-open gesture is in flight so the synthesized release click cannot dismiss the
+     * drawer it just opened.
+     */
+    outsidePressEnabled: {
+        current: boolean;
+    };
+    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;
+    viewportElement: Accessor<HTMLElement | null>;
+    setViewportElement(element: HTMLElement | null): void;
+    presence: PopupPresence;
+    updateNestedLayer(token: symbol, dialogCount: number, drawerCount: number): void;
+    removeNestedLayer(token: symbol): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const DialogRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | DialogRootContextValue<unknown>>;
+export declare function useDialogRootContext<Payload = unknown>(optional?: boolean): DialogRootContextValue<Payload> | undefined;
+export {};

package/dist/lib/types/dialog/store/DialogHandle.d.ts

@@ -0,0 +1,11 @@
+import { BasePopupHandle } from '../../internals/overlay/PopupHandle.js';
+import { DialogStore } from './DialogStore.js';
+/** Imperatively controls a Dialog and connects detached triggers to its Root. */
+export declare class DialogHandle<Payload = unknown> extends BasePopupHandle<DialogStore<Payload>> {
+    constructor();
+    open(triggerId: string | null): void;
+    openWithPayload(payload: Payload): void;
+    close(): void;
+    get isOpen(): boolean;
+}
+export declare function createDialogHandle<Payload = unknown>(): DialogHandle<Payload>;

package/dist/lib/types/dialog/store/DialogStore.d.ts

@@ -0,0 +1,20 @@
+import type { InteractionType } from '../../internals/overlay/FocusManager.js';
+import { DetachedPopupStore, PopupStore, type PopupStoreOptions } from '../../internals/overlay/index.js';
+import type { DialogRootChangeEventDetails } from '../root/DialogRoot.js';
+export declare class DialogStore<Payload = unknown> extends PopupStore<Payload, DialogRootChangeEventDetails> {
+    private readonly openMethodAccessor;
+    private readonly setOpenMethodSignal;
+    private readonly openMethodRevisionAccessor;
+    private readonly setOpenMethodRevision;
+    constructor(options?: PopupStoreOptions<DialogRootChangeEventDetails>);
+    openMethod(): InteractionType | null;
+    setOpenMethod(value: InteractionType | null): void;
+    openMethodRevision(): number;
+    setPayload(payload: Payload): void;
+    setOpen(open: boolean, details: DialogRootChangeEventDetails): boolean;
+}
+export declare class DetachedDialogStore<Payload = unknown> extends DetachedPopupStore<Payload> {
+    openMethod(): InteractionType | null;
+    setOpenMethod(_value: InteractionType | null): void;
+    setPayload(_payload: Payload): void;
+}