@baseline-ui/core 0.58.0 → 0.60.0

package/dist/components/ListBox/ListBox.css.d.ts

@@ -0,0 +1,91 @@
+export declare const listBoxSectionLiCn: string;
+export declare const listBoxOptionCn: ((options?: {
+    isSelected?: undefined;
+    isFocused?: boolean | undefined;
+    isHovered?: boolean | undefined;
+    isFirstChild?: boolean | undefined;
+    isLastChild?: boolean | undefined;
+    isDisabled?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("isSelected" | "isFocused" | "isHovered" | "isFirstChild" | "isLastChild" | "isDisabled")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isSelected: {};
+        isFocused: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isHovered: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+            false: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        isFirstChild: {
+            true: {
+                borderTopWidth: number;
+            };
+        };
+        isLastChild: {
+            true: {
+                borderBottomWidth: number;
+            };
+        };
+        isDisabled: {
+            true: (string | {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            })[];
+        };
+    }>;
+};
+export declare const listBoxCn: string;
+export declare const listBoxHelperTextCn: import("@vanilla-extract/recipes").RuntimeFn<{
+    isDisabled: {
+        true: string;
+    };
+}>;
+export declare const dropIndicatorCn: ((options?: {
+    isDropTarget?: boolean | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
+} | undefined) => string) & {
+    variants: () => ("isDropTarget" | "orientation")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        isDropTarget: {
+            true: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+        orientation: {
+            vertical: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+            horizontal: {
+                "__@@Component_Sprinkles__": boolean;
+                baseSprinkles: string;
+                variantSprinkles: string;
+                compoundVariantSprinkles: string;
+            };
+        };
+    }>;
+};
+export declare const listBoxSectionHeaderCn: string;

package/dist/components/ListBox/ListBox.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { ListItem } from "../shared/types/List";
+import type { ListBoxProps } from "./ListBox.types";
+import type { ComboBoxState, ListState } from "react-stately";
+export declare const ListBoxContext: React.Context<ListState<ListItem> | ComboBoxState<ListItem, "single"> | null>;
+export declare const ListBox: React.ForwardRefExoticComponent<ListBoxProps & React.RefAttributes<HTMLUListElement>>;

package/dist/components/ListBox/ListBox.types.d.ts

@@ -0,0 +1,104 @@
+import type { StylingProps } from "../../utils";
+import type { ListItem, ListOption, ListSection } from "../shared/types/List";
+import type { DragAndDropProps } from "./hooks/useDragDrop";
+import type { DragItem, Node } from "@react-types/shared";
+import type React from "react";
+import type { AriaListBoxOptions, AriaListBoxProps, OptionAria } from "react-aria";
+import type { ListState, Orientation } from "react-stately";
+export interface ListHandle {
+    /** Scrolls the listbox to the specified item. */
+    scrollIntoView: (id: string, options?: ScrollIntoViewOptions) => void;
+    /** Imperatively focuses the specified key */
+    setFocusedKey: (key: string) => void;
+}
+export interface UIState {
+    isFocusVisible: boolean;
+    isSelected: boolean;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isPressed: boolean;
+}
+export interface ListBoxProps extends StylingProps, Omit<AriaListBoxProps<ListItem> & AriaListBoxOptions<ListItem>, "children" | "linkBehavior" | "isVirtualized" | "keyboardDelegate" | "items">, Omit<DragAndDropProps, "preview" | "enableReorder" | "orientation" | "layout">, Partial<Pick<DragAndDropProps, "enableReorder" | "orientation" | "layout">> {
+    /**
+     * The items to render in the listbox. Items have the following shape:
+     *
+     * ```ts
+     * export type ListOption = {
+     *   id: string;
+     *   label: string;
+     *   description?: string;
+     *   icon?: React.FC<IconProps>;
+     * };
+     *
+     * export type ListSection = {
+     *   id: string;
+     *   title?: string;
+     *   type: "section";
+     *   children: ListOption[];
+     * };
+     *
+     * type ListItem = ListOption | ListSection;
+     * ```
+     */
+    items?: ListItem[];
+    /**
+     * The custom render function for the listbox options.
+     *
+     * @param item Node<ListItem>
+     * @param options [OptionAria]()
+     * @param ref React.RefObject<HTMLLIElement>
+     */
+    renderOption?: (item: Node<ListItem>, options: OptionAria & {
+        showSelectedIcon?: boolean;
+        _state: ListState<ListItem>;
+    }, ref: React.Ref<HTMLLIElement>) => React.ReactNode;
+    /** Renders the drop indicator component. */
+    renderDropIndicator?: (options: {
+        dropIndicatorProps: React.HTMLAttributes<HTMLLIElement>;
+        isDropTarget: boolean;
+        isHidden: boolean;
+        orientation: Orientation;
+    }, ref: React.RefObject<HTMLLIElement>) => React.ReactNode;
+    /**
+     * The custom render function for the drag preview. This can be used to render
+     * a custom drag preview when dragging items.
+     */
+    renderDragPreview?: (items: DragItem[]) => React.JSX.Element;
+    /**
+     * The custom render function for the listbox sections.
+     *
+     * @param section ListSection
+     * @param ref React.RefObject<HTMLDivElement>
+     */
+    renderSectionHeader?: (section: Node<ListItem>, ref: React.Ref<HTMLSpanElement>) => React.ReactNode;
+    /** Whether to show the selected checkmark icon. */
+    showSelectedIcon?: boolean;
+    /** The label for the listbox. */
+    label?: React.ReactNode;
+    /** The CSS class name for the drop indicator. */
+    dropIndicatorClassName?: string;
+    /** The style of the drop indicator used in a component. */
+    dropIndicatorStyle?: React.CSSProperties;
+    /** The CSS class name for the option. */
+    optionClassName?: string | ((item: ListOption, state: UIState) => string | undefined);
+    /** The CSS class name for the section. */
+    sectionClassName?: string | ((item: ListSection) => string | undefined);
+    /** The style of the option. */
+    optionStyle?: React.CSSProperties | ((item: ListOption, state: UIState) => React.CSSProperties | undefined);
+    /** The style of the section. */
+    sectionStyle?: React.CSSProperties | ((item: ListSection) => React.CSSProperties | undefined);
+    /**
+     * Whether to show each section title when provided.
+     *
+     * @default false
+     */
+    showSectionHeader?: boolean;
+    /**
+     * Wether to add initial padding to section titles if shown.
+     *
+     * @default false
+     */
+    withSectionHeaderPadding?: boolean;
+    /** Handle to access the listbox methods. */
+    listBoxHandle?: React.RefObject<ListHandle>;
+}

package/dist/components/ListBox/ListBoxSection.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { ListItem } from "../shared/types/List";
+import type { ListBoxProps } from "./ListBox.types";
+import type { ListOptionProps } from "./ListOption";
+import type { Node } from "@react-types/shared";
+export declare const ListBoxSection: React.FC<ListBoxSectionProps>;
+interface ListBoxSectionProps extends Pick<ListOptionProps, "state" | "dragState" | "dropState" | "renderOption" | "renderDropIndicator" | "dropIndicatorStyle" | "dropIndicatorClassName">, Pick<ListBoxProps, "sectionStyle" | "sectionClassName"> {
+    section: Node<ListItem>;
+    showSelectedIcon?: boolean;
+    showSectionHeader?: boolean;
+    renderSectionHeader?: (section: Node<ListItem>, ref: React.Ref<HTMLSpanElement>) => React.ReactNode;
+    withSectionHeaderPadding?: boolean;
+}
+export {};

package/dist/components/ListBox/ListOption.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import type { ListItem } from "../shared/types/List";
+import type { ListBoxProps } from "./ListBox.types";
+import type { Node } from "@react-types/shared";
+import type { DraggableCollectionState, DroppableCollectionState, ListState } from "react-stately";
+export declare const DraggableListOption: React.FC<DraggableListOptionProps>;
+export declare const ListOption: React.ForwardRefExoticComponent<ListOptionProps & React.RefAttributes<HTMLLIElement>>;
+export interface ListOptionProps extends Pick<ListBoxProps, "renderOption" | "renderDropIndicator" | "showSelectedIcon" | "orientation" | "dropIndicatorStyle" | "dropIndicatorClassName" | "optionClassName" | "optionStyle"> {
+    item: Node<ListItem>;
+    state: ListState<ListItem>;
+    dropState?: DroppableCollectionState;
+    dragState?: DraggableCollectionState;
+}
+type DraggableListOptionProps = ListOptionProps & {
+    children: (dragProps: React.HTMLAttributes<HTMLElement>) => React.ReactNode;
+} & Required<Pick<ListOptionProps, "dropState" | "dragState">>;
+export {};

package/dist/components/ListBox/hooks/useDragAndDrop.d.ts

@@ -0,0 +1,3 @@
+import { useDragAndDrop as useDragAndDropAria } from "react-aria-components";
+import type { ListOption } from "../../shared/types/List";
+export declare const useDragAndDrop: typeof useDragAndDropAria<ListOption>;

package/dist/components/ListBox/hooks/useDragAutoScroll.d.ts

@@ -0,0 +1,5 @@
+import type React from "react";
+export declare function useDragAutoScroll({ ref, isDisabled, }: {
+    ref: React.RefObject<HTMLElement>;
+    isDisabled?: boolean;
+}): void;

package/dist/components/ListBox/hooks/useDragDrop.d.ts

@@ -0,0 +1,33 @@
+import { useDroppableCollection } from "react-aria";
+import type { ListItem } from "../../shared/types/List";
+import type React from "react";
+import type { DroppableCollectionOptions } from "react-aria";
+import type { DraggableCollectionState, DraggableCollectionStateOptions, DroppableCollectionState, DroppableCollectionStateOptions, ListState, Orientation } from "react-stately";
+interface UseDragDropResult {
+    collectionProps: ReturnType<typeof useDroppableCollection>["collectionProps"];
+    dragState: DraggableCollectionState;
+    dropState: DroppableCollectionState;
+}
+export declare function useDragDrop(props: DragAndDropProps, state: ListState<ListItem>, ref: React.RefObject<HTMLUListElement>): UseDragDropResult;
+export type DragAndDropProps = Omit<DraggableCollectionStateOptions & DroppableCollectionOptions & DroppableCollectionStateOptions, "keyboardDelegate" | "dropTargetDelegate" | "shouldAcceptItemDrop" | "onDropEnter" | "onDropActivate" | "onDropExit" | "getDropOperation" | "collection" | "selectionManager" | "onRootDrop" | "onInsert" | "getAllowedDropOperations" | "getItems" | "onItemDrop"> & Partial<Pick<DraggableCollectionStateOptions, "getItems">> & {
+    /**
+     * Indicates whether reordering is enabled.
+     *
+     * @default false
+     */
+    enableReorder: boolean;
+    /**
+     * Whether the items are arranged in a stack or grid.
+     *
+     * @default stack
+     */
+    layout: "grid" | "stack";
+    /**
+     * The primary orientation of the items. Usually this is the direction that
+     * the collection scrolls.
+     *
+     * @default vertical
+     */
+    orientation: Orientation;
+};
+export {};

package/dist/components/ListBox/hooks/useSharedList.d.ts

@@ -0,0 +1,8 @@
+import type { ListItem } from "../../shared/types/List";
+import type { ListHandle } from "../ListBox.types";
+import type React from "react";
+import type { ListState } from "react-stately";
+export declare function useSharedList({ type, handle, }: {
+    type?: "listbox" | "gridlist";
+    handle?: React.RefObject<ListHandle>;
+}, state: ListState<ListItem>, ref: React.RefObject<HTMLUListElement>): void;

package/dist/components/ListBox/index.d.ts

@@ -0,0 +1,4 @@
+export { ListBox } from "./ListBox";
+export { type ListBoxProps, type ListHandle } from "./ListBox.types";
+export { type ListOption } from "../shared/types/List";
+export { DefaultListOption } from "./DefaultListOption";

package/dist/components/Markdown/Markdown.css.d.ts

@@ -0,0 +1,3 @@
+export declare const markdownCn: string;
+export declare const markdownContentCn: string;
+export declare const blinkingCaretCn: string;

package/dist/components/Markdown/Markdown.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { MarkdownProps } from "./Markdown.types";
+export declare const Markdown: React.ForwardRefExoticComponent<MarkdownProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Markdown/Markdown.types.d.ts

@@ -0,0 +1,7 @@
+import type { StylingProps } from "../../utils";
+export interface MarkdownProps extends StylingProps {
+    /** The markdown to render. */
+    children: string;
+    /** The flag to show the caret at the end */
+    showCaret?: boolean;
+}

package/dist/components/Markdown/index.d.ts

@@ -0,0 +1,3 @@
+export { Markdown } from "./Markdown";
+export { type MarkdownProps } from "./Markdown.types";
+export * from "./Markdown";

package/dist/components/Menu/Menu.css.d.ts

@@ -0,0 +1,2 @@
+export declare const sectionGroupCn: string;
+export declare const menuContentCn: string;

package/dist/components/Menu/Menu.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { MenuProps } from "./Menu.types";
+export declare const Menu: React.ForwardRefExoticComponent<MenuProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Menu/Menu.types.d.ts

@@ -0,0 +1,63 @@
+import type { ActionButtonProps } from "../ActionButton";
+import type { PopoverContentProps } from "../Popover";
+import type { ListOption, ListSection } from "../shared/types/List";
+import type React from "react";
+import type { AriaMenuProps, AriaMenuTriggerProps } from "react-aria";
+import type { MenuTriggerProps } from "react-stately";
+export type MenuOption = Omit<ListOption, "description"> & {
+    keyboardShortcut?: string;
+};
+export type MenuSection = Omit<ListSection, "children"> & {
+    children: MenuOption[];
+};
+export type MenuItem = MenuOption | MenuSection;
+export type MenuPopoverProps = Pick<PopoverContentProps, "isNonModal" | "placement" | "shouldUpdatePosition" | "shouldFlip" | "boundaryElement" | "boundaryAxis" | "horizontalBoundaryBehavior" | "crossOffset" | "offset" | "portalContainer">;
+export interface MenuProps extends MenuPopoverProps, MenuTriggerProps, Omit<AriaMenuProps<MenuItem>, "children">, Omit<AriaMenuTriggerProps, "type"> {
+    /** The `className` property assigned to the root element of the component. */
+    className?: string;
+    /** The `className` property assigned to the content element of the component. */
+    contentClassName?: string;
+    /** The `className` property assigned to the item element of the component. */
+    itemClassName?: string;
+    /**
+     * A list of items to render in the menu. Items have the following shape:
+     *
+     * ```ts
+     * export type MenuOption = {
+     *   id: string;
+     *   label: string;
+     *   keyboardShortcut?: string;
+     *   icon?: React.FC<IconProps>;
+     * };
+     *
+     * export type MenuSection = {
+     *   id: string;
+     *   title?: string;
+     *   type: "section";
+     *   children: MenuOption[];
+     * };
+     *
+     * export type MenuItem = MenuOption | MenuSection;
+     * ```
+     */
+    items: MenuItem[];
+    /**
+     * A function that renders the trigger element of the component. The default
+     * implementation renders an `ActionButton` component.
+     *
+     * ```tsx
+     * <Menu renderTrigger={({ buttonProps, ref }) => <ActionButton {...buttonProps} label="Label" ref={ref} />
+     * ```
+     */
+    renderTrigger?: (options: {
+        buttonProps: ActionButtonProps & {
+            isOpen: boolean;
+        };
+        ref: React.RefObject<HTMLButtonElement>;
+    }) => React.ReactNode;
+    /**
+     * The label of the trigger element. This can be a string, a React node, or a
+     * function that accepts a boolean indicating whether the menu is open.
+     */
+    triggerLabel?: React.ReactNode | ((isOpen: boolean) => React.ReactNode);
+}

package/dist/components/Menu/index.d.ts

@@ -0,0 +1,2 @@
+export { Menu } from "./Menu";
+export type { MenuProps, MenuItem } from "./Menu.types";

package/dist/components/MessageFormat/MessageFormat.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { MessageFormatProps } from "./MessageFormat.types";
+export declare const MessageFormat: React.FC<MessageFormatProps>;

package/dist/components/MessageFormat/MessageFormat.types.d.ts

@@ -0,0 +1,14 @@
+import type React from "react";
+export interface MessageFormatProps {
+    /**
+     * By default `<MessageFormat>` will render the formatted string into a
+     * `<React.Fragment>`. If you need to customize rendering, you can either wrap
+     * it with another React element (recommended), specify a different tagName
+     * (e.g., 'div')
+     */
+    elementType?: React.ElementType | "div" | "span";
+    /** The id of the message to format. */
+    id: string;
+    /** The default message to use if the message id is not found. */
+    defaultMessage?: string;
+}

package/dist/components/MessageFormat/index.d.ts

@@ -0,0 +1,2 @@
+export { MessageFormat } from "./MessageFormat";
+export { type MessageFormatProps } from "./MessageFormat.types";

package/dist/components/Modal/Modal.css.d.ts

@@ -0,0 +1,39 @@
+export declare const underlayCn: ((options?: {
+    shouldContainOverlays?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => "shouldContainOverlays"[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        shouldContainOverlays: {
+            true: {
+                position: "absolute";
+            };
+            false: {
+                position: "fixed";
+            };
+        };
+    }>;
+};
+export declare const modalContentContainerCn: ((options?: {
+    enableDrawer?: boolean | undefined;
+    shouldContainOverlays?: boolean | undefined;
+} | undefined) => string) & {
+    variants: () => ("shouldContainOverlays" | "enableDrawer")[];
+    classNames: import("@baseline-ui/css").RecipeClassNames<{
+        enableDrawer: {
+            false: string;
+            true: {
+                alignItems: "flex-end";
+            }[];
+        };
+        shouldContainOverlays: {
+            true: {
+                position: "absolute";
+            };
+            false: {
+                position: "fixed";
+            };
+        };
+    }>;
+};
+export declare const modalContentCn: string;
+export declare const drawerModalContentCn: string;

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { ModalProps } from "./Modal.types";
+import type { DOMProps } from "@react-types/shared";
+import type { AriaButtonProps } from "react-aria";
+import type { OverlayTriggerState } from "react-stately";
+export declare const ModalContext: React.Context<{
+    state: OverlayTriggerState | null;
+    triggerProps: AriaButtonProps<"button">;
+    overlayProps?: DOMProps;
+}>;
+export declare const Modal: React.FC<ModalProps>;

package/dist/components/Modal/Modal.types.d.ts

@@ -0,0 +1,70 @@
+import type { StylingProps } from "../../utils";
+import type React from "react";
+import type { AriaModalOverlayProps, OverlayProps } from "react-aria";
+import type { OverlayTriggerProps, OverlayTriggerState } from "react-stately";
+export interface ModalProps extends OverlayTriggerProps {
+    /** The contents of the modal. */
+    children: React.ReactNode;
+}
+export interface ModalContentProps extends Omit<AriaModalOverlayProps, "isDismissable" | "isKeyboardDismissDisabled" | "root" | "shouldUseInert">, Pick<OverlayProps, "disableFocusManagement">, StylingProps {
+    /**
+     * The contents of the modal. Can be a React node or a function that returns a
+     * React node.
+     */
+    children: React.ReactNode | ((props: OverlayTriggerState) => React.ReactNode);
+    /**
+     * The container element for the modal. By default, the modal is rendered as a
+     * child of the body element.
+     *
+     * @default document.body
+     */
+    portalContainer?: HTMLElement;
+    /**
+     * Whether to disable the animation for the modal. This is useful when you
+     * want to render one modal after another without the animation.
+     *
+     * @default false
+     */
+    disableAnimation?: boolean;
+    /**
+     * Whether the modal should be rendered with the initial animation. If set to
+     * false, the modal will be rendered without the initial animation on mount.
+     * This doesn't affect the animation when the modal is is being opened or
+     * closed after it has been mounted. This prop is ignored if
+     * `disableAnimation` is set to `true`.
+     *
+     * @default true
+     */
+    shouldAnimateOnMount?: boolean;
+    /**
+     * Whether the modal should be rendered as a drawer. This will render the
+     * modal with a transparent background and no border at the bottom. The `auto`
+     * value will render the modal as a drawer on mobile and as a dialog on
+     * desktop and tablet.
+     *
+     * @default false
+     */
+    enableDrawer?: boolean | "auto";
+    /**
+     * Specifies if the component is dismissable or not. If the value is a
+     * function, it will be called with a boolean indicating if the modal is
+     * rendered as a drawer or not.
+     *
+     * @default true
+     */
+    isDismissable?: boolean | ((isDrawer: boolean) => boolean);
+    /**
+     * Determines if keyboard dismissal is disabled. If the value is a function,
+     * it will be called with a boolean indicating if the modal is rendered as a
+     * drawer or not.
+     *
+     * @default false
+     */
+    isKeyboardDismissDisabled?: boolean | ((isDrawer: boolean) => boolean);
+    /**
+     * Whether to enable inertia for the modal.
+     *
+     * @default false
+     */
+    UNSAFE_enableInert?: boolean | ((isDrawer: boolean) => boolean);
+}

package/dist/components/Modal/ModalClose.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const ModalClose: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/components/Modal/ModalContent.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { ModalContentProps } from "./Modal.types";
+export declare const ModalDialogContext: React.Context<{
+    isDrawer: boolean;
+    closeDrawer: () => void;
+    dialogStyle: React.CSSProperties;
+    setDialogElement: (element: HTMLDivElement | null) => void;
+    isWithinModal: boolean;
+}>;
+export declare const ModalContentContext: React.Context<{
+    setIsPopoverSafelyClosed: (value: boolean) => void;
+}>;
+export declare const ModalContent: React.ForwardRefExoticComponent<ModalContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Modal/ModalContentCore.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ModalContentProps } from "./Modal.types";
+export declare const ModalContentCore: React.ForwardRefExoticComponent<ModalContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Modal/ModalTrigger.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const ModalTrigger: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/components/Modal/hooks/useDialogPosition.d.ts

@@ -0,0 +1,13 @@
+import type React from "react";
+/**
+ * This hook is used to get the position of the drawer when the keyboard is
+ * visible on mobile devices.
+ *
+ * @param element - The dialog container.
+ * @param shouldUseDrawer - Whether the drawer is enabled.
+ * @returns The position of the dialog.
+ */
+export declare function useDialogPosition(element: HTMLDivElement | null, shouldUseDrawer: boolean, shouldHandleVirtualKeyboard: boolean): {
+    dialogStyle: React.CSSProperties;
+    containerStyle: React.CSSProperties;
+};

package/dist/components/Modal/index.d.ts

@@ -0,0 +1,5 @@
+export { Modal } from "./Modal";
+export { type ModalProps, type ModalContentProps } from "./Modal.types";
+export { ModalContent } from "./ModalContent";
+export { ModalTrigger } from "./ModalTrigger";
+export { ModalClose } from "./ModalClose";

package/dist/components/NumberFormat/NumberFormat.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { NumberFormatProps } from "./NumberFormat.types";
+export declare const NumberFormat: React.FC<NumberFormatProps>;

package/dist/components/NumberFormat/NumberFormat.types.d.ts

@@ -0,0 +1,5 @@
+import type { useNumberFormatter } from "react-aria";
+export type NumberFormatProps = Parameters<typeof useNumberFormatter>[0] & {
+    /** The number to format. */
+    value: number;
+};

package/dist/components/NumberFormat/index.d.ts

@@ -0,0 +1,2 @@
+export { NumberFormat } from "./NumberFormat";
+export { type NumberFormatProps } from "./NumberFormat.types";

package/dist/components/NumberInput/NumberInput.css.d.ts

@@ -0,0 +1,9 @@
+export declare const numberInputContainerLabelStartCn: string;
+export declare const numberActionsContainerCn: import("@vanilla-extract/recipes").RuntimeFn<{
+    isHoveredOrFocused: {
+        true: {};
+    };
+    isInteractive: {
+        false: string;
+    };
+}>;

package/dist/components/NumberInput/NumberInput.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { NumberInputProps } from "./NumberInput.types";
+export declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLDivElement>>;