solid-baseui 0.1.0-alpha.0

package/dist/lib/types/dialog/title/DialogTitle.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DialogTitleState {
+}
+export type DialogTitleProps<Component extends ValidComponent = 'h2'> = BaseUIComponentProps<Component, DialogTitleState>;
+/** A heading that labels the dialog. */
+export declare function DialogTitle<Component extends ValidComponent = 'h2'>(props: DialogTitle.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DialogTitle {
+    type State = DialogTitleState;
+    type Props<Component extends ValidComponent = 'h2'> = DialogTitleProps<Component>;
+}

package/dist/lib/types/dialog/trigger/DialogTrigger.d.ts

@@ -0,0 +1,30 @@
+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 { DialogHandle } from '../store/DialogHandle.js';
+export interface DialogTriggerState {
+    disabled: boolean;
+    open: boolean;
+}
+type TriggerEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface DialogTriggerOwnProps<Payload, Component extends ValidComponent> {
+    handle?: DialogHandle<Payload> | undefined;
+    payload?: Payload | undefined;
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, PointerEvent> | undefined;
+}
+export type DialogTriggerProps<Payload = unknown, Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, DialogTriggerState, DialogTriggerOwnProps<Payload, Component>>;
+/** A button that opens the dialog. */
+export declare function DialogTrigger<Payload = unknown, Component extends ValidComponent = 'button'>(props: DialogTrigger.Props<Payload, Component>): JSX.Element;
+export declare namespace DialogTrigger {
+    type State = DialogTriggerState;
+    type Props<Payload = unknown, Component extends ValidComponent = 'button'> = DialogTriggerProps<Payload, Component>;
+}
+export {};

package/dist/lib/types/dialog/utils/mergeDialogStyles.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function mergeDialogStyles(internal: JSX.CSSProperties, external: JSX.CSSProperties | string | false | undefined): JSX.CSSProperties | string;

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

@@ -0,0 +1,20 @@
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+export declare const dialogTransitionStateAttributesMapping: {
+    transitionStatus(value: TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+};
+export declare const dialogStateAttributesMapping: {
+    nestedDialogOpen: (value: boolean) => {
+        'data-nested-dialog-open': string;
+    } | null;
+    transitionStatus(value: TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+};

package/dist/lib/types/dialog/viewport/DialogViewport.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DialogViewportState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+    nested: boolean;
+    nestedDialogOpen: boolean;
+}
+export type DialogViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DialogViewportState>;
+/** A positioning container for the dialog popup that can be made scrollable. */
+export declare function DialogViewport<Component extends ValidComponent = 'div'>(props: DialogViewport.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DialogViewport {
+    type State = DialogViewportState;
+    type Props<Component extends ValidComponent = 'div'> = DialogViewportProps<Component>;
+}

package/dist/lib/types/direction-provider/DirectionProvider.d.ts

@@ -0,0 +1,13 @@
+import type { ParentProps } from 'solid-js';
+import { type TextDirection } from '../internals/direction-context/DirectionContext.js';
+export interface DirectionProviderState {
+}
+export interface DirectionProviderProps extends ParentProps {
+    /** The reading direction of the text. @default 'ltr' */
+    direction?: TextDirection | undefined;
+}
+export declare function DirectionProvider(props: DirectionProvider.Props): import("@solidjs/web").JSX.Element;
+export declare namespace DirectionProvider {
+    type State = DirectionProviderState;
+    type Props = DirectionProviderProps;
+}

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

@@ -0,0 +1,4 @@
+export { DirectionProvider } from './DirectionProvider.js';
+export type { DirectionProviderProps, DirectionProviderState, } from './DirectionProvider.js';
+export { useDirection } from '../internals/direction-context/DirectionContext.js';
+export type { TextDirection } from '../internals/direction-context/DirectionContext.js';

package/dist/lib/types/drawer/backdrop/DrawerBackdrop.d.ts

@@ -0,0 +1,24 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DrawerBackdropState {
+    /** Whether the drawer is currently open. */
+    open: boolean;
+    /** The transition status of the component. */
+    transitionStatus: TransitionStatus;
+}
+interface DrawerBackdropOwnProps {
+    /**
+     * Whether the backdrop is forced to render even when nested.
+     * @default false
+     */
+    forceRender?: boolean | undefined;
+}
+export type DrawerBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerBackdropState, DrawerBackdropOwnProps>;
+/** An overlay displayed beneath the drawer popup. */
+export declare function DrawerBackdrop<Component extends ValidComponent = 'div'>(props: DrawerBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DrawerBackdrop {
+    type State = DrawerBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerBackdropProps<Component>;
+}
+export {};

package/dist/lib/types/drawer/backdrop/DrawerBackdropCssVars.d.ts

@@ -0,0 +1,7 @@
+export declare enum DrawerBackdropCssVars {
+    /**
+     * The swipe progress of the drawer gesture.
+     * @type {number}
+     */
+    swipeProgress = "--drawer-swipe-progress"
+}

package/dist/lib/types/drawer/content/DrawerContent.d.ts

@@ -0,0 +1,14 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DrawerContentState {
+}
+export type DrawerContentProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerContentState>;
+/**
+ * A container for the drawer contents. Allows text selection of its children without swipe
+ * interference when using a mouse pointer.
+ */
+export declare function DrawerContent<Component extends ValidComponent = 'div'>(props: DrawerContent.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DrawerContent {
+    type State = DrawerContentState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerContentProps<Component>;
+}

package/dist/lib/types/drawer/content/DrawerContentDataAttributes.d.ts

@@ -0,0 +1 @@
+export declare const DRAWER_CONTENT_ATTRIBUTE = "data-drawer-content";

package/dist/lib/types/drawer/handle.d.ts

@@ -0,0 +1,14 @@
+import { DialogHandle } from '../dialog/store/DialogHandle.js';
+/**
+ * Imperatively controls a Drawer and associates detached `Drawer.Trigger` components with a
+ * `Drawer.Root`. Create one with `Drawer.createHandle()` and pass it to the `handle` prop of the
+ * root and of any triggers rendered outside of it.
+ *
+ * The imperative methods take effect only while a root using this handle is mounted; calls made
+ * before a root attaches (or after it unmounts) are ignored.
+ */
+export declare class DrawerHandle<Payload = unknown> extends DialogHandle<Payload> {
+    private readonly __drawerBrand;
+}
+/** Creates a new handle to connect a Drawer.Root with detached Drawer.Trigger components. */
+export declare function createDrawerHandle<Payload = unknown>(): DrawerHandle<Payload>;

package/dist/lib/types/drawer/indent/DrawerIndent.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DrawerIndentState {
+    /** Whether any drawer within the nearest `<Drawer.Provider>` is open. */
+    active: boolean;
+}
+export type DrawerIndentProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerIndentState>;
+/**
+ * A wrapper element intended to contain your app's main UI. Applies `data-active` when any drawer
+ * within the nearest `<Drawer.Provider>` is open.
+ */
+export declare function DrawerIndent<Component extends ValidComponent = 'div'>(props: DrawerIndent.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DrawerIndent {
+    type State = DrawerIndentState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerIndentProps<Component>;
+}

package/dist/lib/types/drawer/indent-background/DrawerIndentBackground.d.ts

@@ -0,0 +1,23 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface DrawerIndentBackgroundState {
+    /** Whether any drawer within the nearest `<Drawer.Provider>` is open. */
+    active: boolean;
+}
+export declare const drawerIndentStateAttributesMapping: {
+    active: (value: boolean) => {
+        'data-active': string;
+    } | {
+        'data-inactive': string;
+    };
+};
+export type DrawerIndentBackgroundProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerIndentBackgroundState>;
+/**
+ * An element placed before `<Drawer.Indent>` to render a background layer that can be styled
+ * based on whether any drawer is open.
+ */
+export declare function DrawerIndentBackground<Component extends ValidComponent = 'div'>(props: DrawerIndentBackground.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace DrawerIndentBackground {
+    type State = DrawerIndentBackgroundState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerIndentBackgroundProps<Component>;
+}

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

@@ -0,0 +1,17 @@
+export * as Drawer from './index.parts.js';
+export type * from './root/DrawerRoot.js';
+export type * from './provider/DrawerProvider.js';
+export type * from './indent/DrawerIndent.js';
+export type * from './indent-background/DrawerIndentBackground.js';
+export type * from './popup/DrawerPopup.js';
+export type * from './swipe-area/DrawerSwipeArea.js';
+export type * from './content/DrawerContent.js';
+export type * from './backdrop/DrawerBackdrop.js';
+export type * from './viewport/DrawerViewport.js';
+export type * from './virtual-keyboard-provider/DrawerVirtualKeyboardProvider.js';
+export type { DrawerSnapPoint, DrawerSwipeDirection, } from './root/DrawerRootContext.js';
+export type { DialogCloseProps as DrawerCloseProps, DialogCloseState as DrawerCloseState, } from '../dialog/close/DialogClose.js';
+export type { DialogDescriptionProps as DrawerDescriptionProps, DialogDescriptionState as DrawerDescriptionState, } from '../dialog/description/DialogDescription.js';
+export type { DialogPortalProps as DrawerPortalProps, DialogPortalState as DrawerPortalState, } from '../dialog/portal/DialogPortal.js';
+export type { DialogTitleProps as DrawerTitleProps, DialogTitleState as DrawerTitleState, } from '../dialog/title/DialogTitle.js';
+export type { DialogTriggerProps as DrawerTriggerProps, DialogTriggerState as DrawerTriggerState, } from '../dialog/trigger/DialogTrigger.js';

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

@@ -0,0 +1,16 @@
+export { DrawerBackdrop as Backdrop } from './backdrop/DrawerBackdrop.js';
+export { DialogClose as Close } from '../dialog/close/DialogClose.js';
+export { DrawerContent as Content } from './content/DrawerContent.js';
+export { DialogDescription as Description } from '../dialog/description/DialogDescription.js';
+export { DrawerIndent as Indent } from './indent/DrawerIndent.js';
+export { DrawerIndentBackground as IndentBackground } from './indent-background/DrawerIndentBackground.js';
+export { DrawerPopup as Popup } from './popup/DrawerPopup.js';
+export { DialogPortal as Portal } from '../dialog/portal/DialogPortal.js';
+export { DrawerProvider as Provider } from './provider/DrawerProvider.js';
+export { DrawerRoot as Root } from './root/DrawerRoot.js';
+export { DrawerSwipeArea as SwipeArea } from './swipe-area/DrawerSwipeArea.js';
+export { DialogTitle as Title } from '../dialog/title/DialogTitle.js';
+export { DialogTrigger as Trigger } from '../dialog/trigger/DialogTrigger.js';
+export { DrawerViewport as Viewport } from './viewport/DrawerViewport.js';
+export { DrawerVirtualKeyboardProvider as VirtualKeyboardProvider } from './virtual-keyboard-provider/DrawerVirtualKeyboardProvider.js';
+export { DrawerHandle as Handle, createDrawerHandle as createHandle } from './handle.js';

package/dist/lib/types/drawer/popup/DrawerPopup.d.ts

@@ -0,0 +1,46 @@
+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';
+import { type DrawerSwipeDirection } from '../root/DrawerRootContext.js';
+export interface DrawerPopupState {
+    /** Whether the drawer is currently open. */
+    open: boolean;
+    /** The transition status of the component. */
+    transitionStatus: TransitionStatus;
+    /** Whether the active snap point is the full-height expanded state. */
+    expanded: boolean;
+    /** Whether the drawer is nested within a parent drawer. */
+    nested: boolean;
+    /** Whether the drawer has nested drawers open. */
+    nestedDrawerOpen: boolean;
+    /** Whether a nested drawer is currently being swiped. */
+    nestedDrawerSwiping: boolean;
+    /** The swipe direction used to dismiss the drawer. */
+    swipeDirection: DrawerSwipeDirection;
+    /** Whether the drawer is being swiped. */
+    swiping: boolean;
+}
+interface DrawerPopupOwnProps {
+    /**
+     * Determines the element to focus when the drawer is opened.
+     *
+     * - `false`: Do not move focus.
+     * - `true`: Move focus based on the default behavior (first tabbable element or popup).
+     * - `HTMLElement`: Move focus to that element.
+     * - `function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).
+     */
+    initialFocus?: FocusResolver | undefined;
+    /** Determines the element to focus when the drawer is closed. */
+    finalFocus?: FocusResolver | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+}
+export type DrawerPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerPopupState, DrawerPopupOwnProps>;
+/** A container for the drawer contents. */
+export declare function DrawerPopup<Component extends ValidComponent = 'div'>(props: DrawerPopup.Props<Component>): JSX.Element;
+export declare namespace DrawerPopup {
+    type State = DrawerPopupState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerPopupProps<Component>;
+}
+export {};

package/dist/lib/types/drawer/popup/DrawerPopupCssVars.d.ts

@@ -0,0 +1,37 @@
+export declare enum DrawerPopupCssVars {
+    /**
+     * The number of nested drawers that are currently open.
+     * @type {number}
+     */
+    nestedDrawers = "--nested-drawers",
+    /**
+     * The height of the drawer popup.
+     * @type {CSS length}
+     */
+    height = "--drawer-height",
+    /**
+     * The height of the frontmost open drawer in the current nested drawer stack.
+     * @type {CSS length}
+     */
+    frontmostHeight = "--drawer-frontmost-height",
+    /**
+     * The swipe movement on the X axis.
+     * @type {CSS length}
+     */
+    swipeMovementX = "--drawer-swipe-movement-x",
+    /**
+     * The swipe movement on the Y axis.
+     * @type {CSS length}
+     */
+    swipeMovementY = "--drawer-swipe-movement-y",
+    /**
+     * The snap point offset used for translating the drawer.
+     * @type {CSS length}
+     */
+    snapPointOffset = "--drawer-snap-point-offset",
+    /**
+     * A scalar (0.1-1) used to scale the swipe release transition duration in CSS.
+     * @type {number}
+     */
+    swipeStrength = "--drawer-swipe-strength"
+}

package/dist/lib/types/drawer/popup/DrawerPopupDataAttributes.d.ts

@@ -0,0 +1,25 @@
+export declare enum DrawerPopupDataAttributes {
+    /** Present when the drawer is open. */
+    open = "data-open",
+    /** Present when the drawer is closed. */
+    closed = "data-closed",
+    /** Present when the drawer begins animating in. */
+    startingStyle = "data-starting-style",
+    /** Present when the drawer is animating out. */
+    endingStyle = "data-ending-style",
+    /** Present when the drawer is at the expanded (full-height) snap point. */
+    expanded = "data-expanded",
+    /** Present when a nested drawer is open. */
+    nestedDrawerOpen = "data-nested-drawer-open",
+    /** Present when a nested drawer is being swiped. */
+    nestedDrawerSwiping = "data-nested-drawer-swiping",
+    /** Present when the drawer is dismissed by swiping. */
+    swipeDismiss = "data-swipe-dismiss",
+    /**
+     * Indicates the swipe direction.
+     * @type {'up' | 'down' | 'left' | 'right'}
+     */
+    swipeDirection = "data-swipe-direction",
+    /** Present when the drawer is being swiped. */
+    swiping = "data-swiping"
+}

package/dist/lib/types/drawer/provider/DrawerProvider.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from '@solidjs/web';
+export interface DrawerProviderState {
+}
+export interface DrawerProviderProps {
+    children?: JSX.Element;
+}
+/**
+ * Provides a shared context for coordinating global Drawer UI, such as indent/background effects
+ * based on whether any Drawer is open. Doesn't render its own HTML element.
+ */
+export declare function DrawerProvider(props: DrawerProvider.Props): JSX.Element;
+export declare namespace DrawerProvider {
+    type State = DrawerProviderState;
+    type Props = DrawerProviderProps;
+}

package/dist/lib/types/drawer/provider/DrawerProviderContext.d.ts

@@ -0,0 +1,21 @@
+import { type Accessor } from 'solid-js';
+export interface DrawerVisualState {
+    swipeProgress: number;
+    frontmostHeight: number;
+}
+export interface DrawerVisualStateStore {
+    getSnapshot(): DrawerVisualState;
+    subscribe(listener: () => void): () => void;
+    set(state: Partial<DrawerVisualState>): void;
+}
+export interface DrawerProviderContextValue {
+    setDrawerOpen(drawer: object, open: boolean): void;
+    removeDrawer(drawer: object): void;
+    active: Accessor<boolean>;
+    visualStateStore: DrawerVisualStateStore;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const DrawerProviderContext: import("solid-js").Context<DrawerProviderContextValue | typeof MISSING_CONTEXT>;
+export declare function useDrawerProviderContext(): DrawerProviderContextValue | undefined;
+export declare function createVisualStateStore(): DrawerVisualStateStore;
+export {};

package/dist/lib/types/drawer/root/DrawerRoot.d.ts

@@ -0,0 +1,65 @@
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { DialogRootActions, DialogRootProps } from '../../dialog/root/DialogRoot.js';
+import type { DrawerHandle } from '../handle.js';
+import { type DrawerSnapPoint, type DrawerSwipeDirection } from './DrawerRootContext.js';
+export interface DrawerRootState {
+}
+export type DrawerRootActions = DialogRootActions;
+export type DrawerRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closeWatcher | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.swipe | typeof REASONS.none;
+export type DrawerRootChangeEventDetails = BaseUIChangeEventDetails<DrawerRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export type DrawerRootSnapPointChangeEventReason = DrawerRootChangeEventReason;
+export type DrawerRootSnapPointChangeEventDetails = BaseUIChangeEventDetails<DrawerRootSnapPointChangeEventReason>;
+export interface DrawerRootProps<Payload = unknown> extends Omit<DialogRootProps<Payload>, 'actionsRef' | 'handle' | 'onOpenChange'> {
+    /** Event handler called when the drawer is opened or closed. */
+    onOpenChange?: ((open: boolean, details: DrawerRootChangeEventDetails) => void) | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `unmount`: Manually unmounts the drawer. Call this after any externally controlled closing
+     *   animation finishes.
+     * - `close`: Closes the drawer imperatively when called.
+     */
+    actionsRef?: ((actions: DrawerRootActions) => void) | undefined;
+    /**
+     * A handle to associate the drawer with a trigger. If specified, allows detached triggers to
+     * control the drawer's open state. Can be created with the `Drawer.createHandle()` method.
+     */
+    handle?: DrawerHandle<Payload> | undefined;
+    /**
+     * The swipe direction used to dismiss the drawer.
+     * @default 'down'
+     */
+    swipeDirection?: DrawerSwipeDirection | undefined;
+    /**
+     * Snap points used to position the drawer. Use numbers between 0 and 1 to represent fractions
+     * of the viewport height, numbers greater than 1 as pixel values, or strings in `px`/`rem`
+     * units (for example, `'148px'` or `'30rem'`).
+     */
+    snapPoints?: DrawerSnapPoint[] | undefined;
+    /**
+     * Disables velocity-based snap skipping so drag distance determines the next snap point.
+     * @default false
+     */
+    snapToSequentialPoints?: boolean | undefined;
+    /** The currently active snap point. Use with `onSnapPointChange` to control the snap point. */
+    snapPoint?: DrawerSnapPoint | null | undefined;
+    /** The initial snap point value when uncontrolled. */
+    defaultSnapPoint?: DrawerSnapPoint | null | undefined;
+    /** Callback fired when the snap point changes. */
+    onSnapPointChange?: ((snapPoint: DrawerSnapPoint | null, eventDetails: DrawerRootSnapPointChangeEventDetails) => void) | undefined;
+}
+/** Groups all parts of the drawer. Doesn't render its own HTML element. */
+export declare function DrawerRoot<Payload = unknown>(props: DrawerRoot.Props<Payload>): import("@solidjs/web").JSX.Element;
+export declare namespace DrawerRoot {
+    type State = DrawerRootState;
+    type Props<Payload = unknown> = DrawerRootProps<Payload>;
+    type Actions = DrawerRootActions;
+    type ChangeEventReason = DrawerRootChangeEventReason;
+    type ChangeEventDetails = DrawerRootChangeEventDetails;
+    type SnapPointChangeEventReason = DrawerRootSnapPointChangeEventReason;
+    type SnapPointChangeEventDetails = DrawerRootSnapPointChangeEventDetails;
+    type SnapPoint = DrawerSnapPoint;
+    type SwipeDirection = DrawerSwipeDirection;
+}

package/dist/lib/types/drawer/root/DrawerRootContext.d.ts

@@ -0,0 +1,68 @@
+import { type Accessor } from 'solid-js';
+import type { SwipeDirection } from '../../internals/overlay/createSwipeDismiss.js';
+import type { DrawerRootSnapPointChangeEventDetails } from './DrawerRoot.js';
+export type DrawerSwipeDirection = SwipeDirection;
+export type DrawerSnapPoint = number | string;
+export interface DrawerNestedSwipeProgressStore {
+    getSnapshot(): number;
+    subscribe(listener: () => void): () => void;
+}
+export interface DrawerRootContextValue {
+    swipeDirection: Accessor<DrawerSwipeDirection>;
+    /**
+     * Whether `Drawer.SwipeArea` is currently driving an open gesture (writing the popup's
+     * swipe-movement vars imperatively). The viewport reads this to skip resetting them on open.
+     */
+    swipeAreaActive: {
+        current: boolean;
+    };
+    /** Whether to disable velocity-based snap skipping. */
+    snapToSequentialPoints: Accessor<boolean>;
+    /** Snap points used to size/position the drawer. */
+    snapPoints: Accessor<DrawerSnapPoint[] | undefined>;
+    /** The currently active snap point. */
+    activeSnapPoint: Accessor<DrawerSnapPoint | null>;
+    /** Updates the currently active snap point. */
+    setActiveSnapPoint(snapPoint: DrawerSnapPoint | null, eventDetails?: DrawerRootSnapPointChangeEventDetails): void;
+    /** The measured height of the frontmost open drawer within the current nested drawer stack. */
+    frontmostHeight: Accessor<number>;
+    /** The measured height of the drawer popup element. */
+    popupHeight: Accessor<number>;
+    /**
+     * Whether the current drawer has a nested drawer mounted in its stack (including while it is
+     * transitioning out).
+     */
+    hasNestedDrawer: Accessor<boolean>;
+    /** Called by the drawer popup to report its own measured height. */
+    onPopupHeightChange(height: number): void;
+    /** Whether a nested drawer is currently being swiped. */
+    nestedSwiping: Accessor<boolean>;
+    /** Provides nested swipe progress without re-running the drawer tree. */
+    nestedSwipeProgressStore: DrawerNestedSwipeProgressStore;
+    /**
+     * Called by a nested drawer to report whether it is still present (open or transitioning out).
+     */
+    onNestedDrawerPresenceChange(present: boolean): void;
+    /** Called by a nested drawer to report the frontmost height of its own stack. */
+    onNestedFrontmostHeightChange(height: number): void;
+    /** Called by a nested drawer to report whether it's being swiped. */
+    onNestedSwipingChange(swiping: boolean): void;
+    /** Called by a nested drawer to report its swipe progress. */
+    onNestedSwipeProgressChange(progress: number): void;
+    /** Provided to nested drawers so they can report their frontmost height to the parent. */
+    notifyParentFrontmostHeight?: ((height: number) => void) | undefined;
+    /** Provided to nested drawers so they can report swiping to the parent drawer. */
+    notifyParentSwipingChange?: ((swiping: boolean) => void) | undefined;
+    /** Provided to nested drawers so they can report swipe progress to the parent drawer. */
+    notifyParentSwipeProgressChange?: ((progress: number) => void) | undefined;
+    /**
+     * Provided to nested drawers so they can report whether they are still present (open or
+     * transitioning out) to the parent drawer.
+     */
+    notifyParentHasNestedDrawer?: ((present: boolean) => void) | undefined;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const DrawerRootContext: import("solid-js").Context<DrawerRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useDrawerRootContext(optional?: false): DrawerRootContextValue;
+export declare function useDrawerRootContext(optional: true): DrawerRootContextValue | undefined;
+export {};

package/dist/lib/types/drawer/root/createDrawerSnapPoints.d.ts

@@ -0,0 +1,24 @@
+import { type Accessor } from 'solid-js';
+import { type DrawerSnapPoint, type DrawerRootContextValue } from './DrawerRootContext.js';
+export interface ResolvedDrawerSnapPoint {
+    value: DrawerSnapPoint;
+    height: number;
+    offset: number;
+}
+export interface DrawerSnapPoints {
+    snapPoints: Accessor<DrawerSnapPoint[] | undefined>;
+    activeSnapPoint: Accessor<DrawerSnapPoint | null>;
+    setActiveSnapPoint: DrawerRootContextValue['setActiveSnapPoint'];
+    popupHeight: Accessor<number>;
+    viewportHeight: Accessor<number>;
+    resolvedSnapPoints: Accessor<ResolvedDrawerSnapPoint[]>;
+    activeSnapPointOffset: Accessor<number | null>;
+}
+/**
+ * Resolves the vertical swipe movement for a snap point, applying square-root damping once the
+ * drag overshoots the fully-open edge (`nextOffset < 0`) so the popup resists travelling past it.
+ */
+export declare function getSnapPointSwipeMovement(baseOffset: number, movementValue: number): number;
+/** Returns the index of the value closest to `target`, or `-1` if `values` is empty. */
+export declare function closestSnapPointIndex(values: number[], target: number): number;
+export declare function createDrawerSnapPoints(): DrawerSnapPoints;

package/dist/lib/types/drawer/swipe-area/DrawerSwipeArea.d.ts

@@ -0,0 +1,43 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type SwipeDirection } from '../../internals/overlay/createSwipeDismiss.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import { type DrawerSwipeDirection } from '../root/DrawerRootContext.js';
+export interface DrawerSwipeAreaState {
+    /** Whether the drawer is currently open. */
+    open: boolean;
+    /** Whether the swipe area is currently being swiped. */
+    swiping: boolean;
+    /** The swipe direction that opens the drawer. */
+    swipeDirection: SwipeDirection;
+    /** Whether the swipe area is disabled. */
+    disabled: boolean;
+}
+interface DrawerSwipeAreaOwnProps {
+    /**
+     * Whether the swipe area is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * The swipe direction that opens the drawer. Defaults to the opposite of the `Drawer.Root`
+     * `swipeDirection`.
+     */
+    swipeDirection?: DrawerSwipeDirection | undefined;
+    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;
+    onTouchMove?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchEnd?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+    onTouchCancel?: BaseUIEventHandlerUnion<HTMLElement, TouchEvent> | undefined;
+}
+export type DrawerSwipeAreaProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, DrawerSwipeAreaState, DrawerSwipeAreaOwnProps>;
+/** An invisible area that listens for swipe gestures to open the drawer. */
+export declare function DrawerSwipeArea<Component extends ValidComponent = 'div'>(props: DrawerSwipeArea.Props<Component>): JSX.Element;
+export declare namespace DrawerSwipeArea {
+    type State = DrawerSwipeAreaState;
+    type Props<Component extends ValidComponent = 'div'> = DrawerSwipeAreaProps<Component>;
+}
+export {};

package/dist/lib/types/drawer/swipe-area/DrawerSwipeAreaDataAttributes.d.ts

@@ -0,0 +1,15 @@
+export declare enum DrawerSwipeAreaDataAttributes {
+    /** Present when the drawer is open. */
+    open = "data-open",
+    /** Present when the drawer is closed. */
+    closed = "data-closed",
+    /** Present when the swipe area is disabled. */
+    disabled = "data-disabled",
+    /**
+     * Indicates the swipe direction.
+     * @type {'up' | 'down' | 'left' | 'right'}
+     */
+    swipeDirection = "data-swipe-direction",
+    /** Present when the drawer is being swiped. */
+    swiping = "data-swiping"
+}