@overmap-ai/blocks 1.0.27-custom-table-component.4 → 1.0.27-custom-table-component.6

package/README.md

@@ -1,3 +1,3 @@
-# overmap-ai blocks
-
-Contains basic components used by overmap-ai libraries.
+# overmap-ai blocks
+
+Contains basic components used by overmap-ai libraries.

package/dist/Breadcrumb/context.d.ts

@@ -1,4 +1,4 @@
-import type { Severity } from "../typings.ts";
+import type { Severity } from "../typings";
 import { ComponentProps } from "react";
 import { Link } from "@radix-ui/themes";
 interface IBreadcrumbContext {

package/dist/Buttons/index.d.ts

@@ -1,4 +1,4 @@
 export { default as Button } from "./Button";
 export { default as IconButton } from "./IconButton";
-export type { ButtonHoverEffect } from "./typings";
+export type { ButtonHoverEffect, ButtonProps, ButtonStyleProps } from "./typings";
 export { divButtonProps } from "./constants";

package/dist/Buttons/typings.d.ts

@@ -14,6 +14,7 @@ export interface ButtonStyleProps {
     severity?: Severity;
     size?: Responsive<Size>;
     hoverEffects?: ButtonHoverEffect[];
+    highContrast?: boolean;
 }
 export type RadixButtonProps = React.ComponentProps<typeof RadixButton>;
 export type ButtonHoverEffect = "spin90Clockwise" | "spin180Clockwise" | "spin360Clockwise";

package/dist/CollapsibleTree/CollapsibleTree.d.ts

@@ -0,0 +1,5 @@
+import { CollapsibleTreeProps } from "./typings";
+/** The Collapsible Tree Component is a reusable UI element that displays hierarchical data in a tree structure.
+ * Nodes in the tree can be expanded or collapsed to show or hide their children, allowing for an intuitive and
+ * space-efficient way to navigate complex data structures.*/
+export declare const CollapsibleTree: <TMeta>(props: CollapsibleTreeProps<TMeta>) => import("react/jsx-runtime").JSX.Element;

package/dist/CollapsibleTree/context.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProps, CSSProperties } from "react";
+import { Flex } from "@radix-ui/themes";
+import { NodeCallbacks, NodeRenderer } from "./typings";
+interface ICollapsibleTreeContext<TMeta> extends NodeCallbacks<TMeta> {
+    nodeClassName?: string;
+    nodeStyles?: CSSProperties;
+    nodeGap: ComponentProps<typeof Flex>["gap"];
+    levelGap: ComponentProps<typeof Flex>["pl"];
+    disabled: boolean;
+    nodeRenderer: NodeRenderer<TMeta>;
+}
+export declare const CollapsibleTreeContext: import("react").Context<ICollapsibleTreeContext<never>>;
+export declare function useCollapsibleTreeContext<TMeta>(): ICollapsibleTreeContext<TMeta>;
+export {};

package/dist/CollapsibleTree/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CollapsibleTree";
+export * from "./typings";

package/dist/CollapsibleTree/typings.d.ts

@@ -0,0 +1,71 @@
+import { ComponentProps, CSSProperties } from "react";
+import { CollapsibleProps } from "@radix-ui/react-collapsible";
+import { Flex } from "@radix-ui/themes";
+import { PropsWithClassNameAndStyle } from "../typings";
+import { OvermapItemProps } from "../OvermapItem";
+import { OvermapItemGroupProps } from "../OvermapItemGroup";
+export type NodeEventHandler<TMeta> = (meta: TMeta) => void;
+export interface NodeCallbacks<TMeta> {
+    /** callback fired when a specific TreeNode is clicked, regardless of the current open state of the specific
+     * TreeNode collapsible. */
+    onNodeClick?: NodeEventHandler<TMeta>;
+    /** callback fired when a specific TreeNode collapsible is opened. */
+    onNodeOpen?: NodeEventHandler<TMeta>;
+    /** callback fired when a specific TreeNode collapsible is closed. */
+    onNodeClose?: NodeEventHandler<TMeta>;
+}
+export type NodeRenderer<TMeta> = (args: {
+    /** passing any meta information defined for the given node*/
+    meta: TMeta;
+    /** a function to toggle the open state of the TreeNode, useful to define what content with the TreeNode is responsible
+     * for triggering the opening and closing of the TreeNode collapsible. */
+    toggleOpen: () => void;
+    /** the current open state of the TreeNode collapsible, useful for changing rendered content within the TreeNode
+     * based on its open state. */
+    open: boolean;
+    /** the current disabled state of the TreeNode, useful for changing rendered content or functionality based on if the
+     * TreeNode is disabled or not. */
+    disabled: boolean;
+}) => {
+    children: OvermapItemProps["children"];
+    className?: string;
+    style?: CSSProperties;
+    leftSlot?: OvermapItemProps["leftSlot"];
+    rightSlot?: OvermapItemProps["rightSlot"];
+};
+export interface TreeNodeProps<TMeta> extends Pick<CollapsibleProps, "disabled"> {
+    /** list of TreeNodes to be rendered within the current TreeNode collapsible */
+    nodes?: TreeNodeProps<TMeta>[];
+    /** any meta-information that should be attached to a given TreeNode uses the TMeta type to specifically type
+     * the structure of this meta-data. */
+    meta: TMeta;
+}
+export interface CollapsibleTreeProps<TMeta> extends PropsWithClassNameAndStyle, Pick<OvermapItemGroupProps, "size">, NodeCallbacks<TMeta> {
+    /** the TreeNode structure that should be rendered within the CollapsibleTree */
+    nodes: TreeNodeProps<TMeta>[];
+    /** the vertical gap between each TreeNode in the CollapsibleTree.
+     * @default "0"
+     * */
+    nodeGap?: ComponentProps<typeof Flex>["gap"];
+    /** the left inset between each TreeNode level in the CollapsibleTree.
+     * @default "2"
+     * */
+    levelGap?: ComponentProps<typeof Flex>["pl"];
+    /** disables all TreeNodes in the CollapsibleTree.
+     * @default false
+     * */
+    disabled?: boolean;
+    /** A className that will be applied to every TreeNode. Useful if all the TreeNodes are required to look
+     * the same stylistically. */
+    nodeClassName?: string;
+    /** styles that will be applied to every TreeNode. Useful if there are styles that need to be applied to all
+     * for stylistic consistency TreeNodes. */
+    nodeStyles?: CSSProperties;
+    /** a callback used to determine the content rendered within a TreeNode. The callback is passed with the following arguments,
+     * @param meta - TreeNodes meta object.
+     * @param toggleOpen - function to toggle the open state of a TreeNode.
+     * @param open - the current open state of the TreeNode collapsible.
+     * @param disabled - the current disabled state of the TreeNode collapsible.
+     * */
+    nodeRenderer: NodeRenderer<TMeta>;
+}

package/dist/DialogMenu/Provider.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from "react";
+import { IDialogMenuContext } from "./context";
+interface DialogMenuContextProviderProps extends Pick<IDialogMenuContext, "size" | "closeOnSelect" | "close" | "selectedIndicator">, PropsWithChildren {
+}
+export declare const DialogMenuContextProvider: import("react").MemoExoticComponent<(props: DialogMenuContextProviderProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/DialogMenu/components/DialogCommandMenu.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogCommandMenuProps } from "../typings";
+/** The Dialog Command Menu component is a flexible UI element designed to present a list of command options within a
+ * dialog overlay. This component enhances user interaction by providing a structured and accessible way to execute
+ * commands or actions from a centralized menu. */
+export declare const DialogCommandMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogCommandMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/components/DialogMultiSelectMenu.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogMultiSelectMenuProps } from "../typings";
+/** The Dialog Multi Select Menu component is a versatile UI element that enables users to select multiple options from
+ * a list within a dialog overlay. This component enhances user interaction by providing a clear and accessible way to
+ * make multiple selections in contexts such as forms, filters, and settings. */
+export declare const DialogMultiSelectMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMultiSelectMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/components/DialogSelectMenu.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { DialogSelectMenuProps } from "../typings";
+/** The Dialog Select Menu component is a user interface element that provides a dropdown single selection menu within a dialog
+ * overlay. It allows users to choose an option from a predefined list, offering an enhanced user experience through a
+ * modal dialog. This component is particularly useful in forms and settings where space is limited, and a clean,
+ * accessible selection method is needed. */
+export declare const DialogSelectMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

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

@@ -0,0 +1,3 @@
+export * from "./DialogCommandMenu";
+export * from "./DialogSelectMenu";
+export * from "./DialogMultiSelectMenu";

package/dist/DialogMenu/constants.d.ts

@@ -0,0 +1,3 @@
+import { OvermapItemSizes } from "../OvermapItem";
+export declare const DEFAULT_DIALOG_MENU_SIZE: OvermapItemSizes;
+export declare const DEFAULT_SELECTED_INDICATOR: import("react/jsx-runtime").JSX.Element;

package/dist/DialogMenu/content/Content.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { DialogMenuContentProps } from "../typings";
+export declare const ContentImpl: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;
+export declare const Content: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/content/SubContent.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { DialogMenuSubContentProps } from "../typings";
+export declare const SubContent: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuSubContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/content/index.d.ts

@@ -0,0 +1,2 @@
+export { Content } from "./Content";
+export * from "./SubContent";

package/dist/DialogMenu/context.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { OvermapItemProps } from "../OvermapItem";
+import { CloseDialogWithOptions } from "../Dialogs";
+import { DialogSelectItemProps } from "./typings";
+export interface IDialogMenuContext {
+    size: OvermapItemProps["size"];
+    closeOnSelect: boolean;
+    close: CloseDialogWithOptions;
+    subContentId: string | null;
+    setSubContentId: (subContent: string | null) => void;
+    selectedIndicator?: DialogSelectItemProps["selectedIndicator"];
+}
+export declare const DialogMenuContext: import("react").Context<IDialogMenuContext>;
+export declare const useDialogMenuContext: () => IDialogMenuContext;

package/dist/DialogMenu/groups/Group.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogGroupProps } from "../typings";
+export declare const Group: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/MultiSelectGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogMultiSelectGroupProps } from "../typings";
+export declare const MultiSelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMultiSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/SelectGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectGroupProps } from "../typings";
+export declare const SelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Group";
+export * from "./SelectGroup";
+export * from "./MultiSelectGroup";

package/dist/DialogMenu/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+export declare const DialogMenu: {
+    Root: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuProps & import("react").RefAttributes<HTMLDivElement>>>;
+    Item: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    MultiSelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    Separator: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<import("..").SeparatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;
+    Content: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuContentProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<HTMLDivElement>>>;
+    Group: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    MultiSelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMultiSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SubTrigger: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSubTriggerProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SubContent: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuSubContentProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<HTMLDivElement>>>;
+};
+export * from "./components";
+export * from "./typings";

package/dist/DialogMenu/items/Item.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogItemProps } from "../typings";
+export declare const Item: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/MultiSelectItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectItemProps } from "../typings";
+export declare const MultiSelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/SelectItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectItemProps } from "../typings";
+export declare const SelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/Separator.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SeparatorProps } from "../../Separator";
+/** A separator component to be used within Dialog Menus. */
+export declare const Separator: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<SeparatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/SubTrigger.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSubTriggerProps } from "../typings";
+export declare const SubTrigger: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSubTriggerProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Item";
+export * from "./SelectItem";
+export * from "./MultiSelectItem";
+export * from "./SubTrigger";
+export * from "./Separator";

package/dist/DialogMenu/root/Root.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogMenuProps } from "../typings";
+/** The Dialog Menu component is a flexible and customizable UI element that allows users to trigger a dialog containing
+ * a menu of items. This component is designed to enhance user interaction by providing a structured and accessible
+ * way to present multiple items/choices/options within a dialog overlay.*/
+export declare const Root: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/root/index.d.ts

@@ -0,0 +1 @@
+export * from "./Root";

package/dist/DialogMenu/typings.d.ts

@@ -0,0 +1,59 @@
+import { OvermapItemProps } from "../OvermapItem";
+import { PropsWithChildren, ReactNode } from "react";
+import { BaseDialogProps } from "../Dialogs/BaseDialog";
+import { OvermapItemGroupProps } from "../OvermapItemGroup";
+import { OvermapInputItemProps } from "../OvermapInputItem";
+export interface DialogItemProps extends OvermapItemProps {
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+}
+export interface DialogSelectItemProps extends DialogItemProps {
+    value: string;
+    selectedIndicator?: ReactNode;
+}
+export interface DialogSubTriggerProps extends DialogItemProps {
+    subContentId: string;
+}
+export interface DialogGroupProps extends PropsWithChildren {
+    size?: OvermapItemGroupProps["size"];
+    grid?: boolean;
+}
+export interface DialogSelectGroupProps extends DialogGroupProps {
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+}
+export interface DialogMultiSelectGroupProps extends DialogGroupProps {
+    values: string[];
+    onValuesChange: (values: string[]) => void;
+}
+export interface DialogMenuContentProps extends FilterProps {
+    topSlot?: ReactNode;
+    bottomSlot?: ReactNode;
+    numberOfItems: number;
+}
+export interface DialogMenuSubContentProps extends DialogMenuContentProps {
+    id: string;
+}
+export interface DialogMenuProps extends Omit<BaseDialogProps, "content"> {
+    size?: OvermapItemProps["size"];
+    closeOnSelect?: boolean;
+    content: ReactNode;
+    selectedIndicator?: DialogSelectItemProps["selectedIndicator"];
+}
+export interface DialogCommandMenuProps extends Omit<DialogMenuProps, "content" | "selectedIndicator">, Omit<DialogGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogItemProps[];
+}
+export interface DialogSelectMenuProps extends Omit<DialogMenuProps, "content">, Omit<DialogSelectGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogSelectItemProps[];
+}
+export interface DialogMultiSelectMenuProps extends Omit<DialogMenuProps, "content">, Omit<DialogMultiSelectGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogSelectItemProps[];
+}
+interface FilterProps {
+    filterValue?: string;
+    onFilterValueChange?: (filterValue: string) => void;
+    placeholder?: string;
+    leftFilterSlot?: OvermapInputItemProps["leftSlot"];
+    rightFilterSlot?: OvermapInputItemProps["rightSlot"];
+}
+export {};

package/dist/Dialogs/AlertDialog/typings.d.ts

@@ -1,7 +1,7 @@
 import { AlertDialog } from "@radix-ui/themes";
 import { ReactNode } from "react";
 import { CloseDialog } from "../typings";
-import { Severity } from "../../typings.ts";
+import { Severity } from "../../typings";
 interface AlertDialogBaseProps {
     open: boolean;
     setOpen: (open: boolean) => void;

package/dist/Dialogs/BaseDialog/BaseDialog.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { BaseDialogProps } from "./typings";
+export declare const BaseDialog: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<BaseDialogProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/Dialogs/BaseDialog/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BaseDialog";
+export * from "./typings";

package/dist/Dialogs/BaseDialog/typings.d.ts

@@ -0,0 +1,31 @@
+import { CSSProperties, ReactElement, ReactNode } from "react";
+import * as RadixDialogPrimitive from "@radix-ui/react-dialog";
+import { CloseDialog, CloseDialogWithOptions } from "../typings";
+export interface BaseDialogProps {
+    /** The content to be displayed within the Overlay. A prop pattern with a passed close function that can be used to
+     * close the Overlay from the components rendering the content. pass {force: true} to the close function to avoid
+     * the onInterruptClose process when using in an uncontrolled state. NOTE: when controlling the open state of the overlay,
+     * the close function will have no effect on the open state of the Overlay */
+    content: (close: CloseDialogWithOptions) => ReactNode;
+    /** the element that should act as a trigger for opening the Overlay */
+    children?: ReactElement;
+    /** the initial open state of the Overlay */
+    defaultOpen?: RadixDialogPrimitive.DialogProps["defaultOpen"];
+    /** callback that is fired upon closing of the Overlay calls the close function to continue the closing process.
+     * If the close function is not called, the Overlay will not be closed */
+    onInterruptClose?: (close: CloseDialog) => void;
+    /** callback fired when the Overlay is being closed, if onInterruptClose is specified, it fires if the closing process
+     * is continued by calling the close function within the callback passed to onInterruptClose.
+     * */
+    onClose?: () => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    style?: CSSProperties;
+    /** when true, renders an unstyled overlay filling the Overlays parent container */
+    overlay?: boolean;
+    /** className to be applied to the overlay component */
+    overlayClass?: string;
+    /** style object to be applied to the overlay component */
+    overlayStyle?: CSSProperties;
+}

package/dist/Dialogs/Overlay/Overlay.d.ts

@@ -1,33 +1,6 @@
-import { CSSProperties, ReactElement, ReactNode } from "react";
-import * as RadixDialogPrimitive from "@radix-ui/react-dialog";
-import { CloseDialog, CloseDialogWithOptions } from "../typings";
-export interface OverlayProps {
-    /** The content to be displayed within the Overlay. A prop pattern with a passed close function that can be used to
-     * close the Overlay from the components rendering the content. pass {force: true} to the close function to avoid
-     * the onInterruptClose process when using in an uncontrolled state. NOTE: when controlling the open state of the overlay,
-     * the close function will have no effect on the open state of the Overlay */
-    content: (close: CloseDialogWithOptions) => ReactNode;
-    /** the element that should act as a trigger for opening the Overlay */
-    children?: ReactElement;
-    /** the initial open state of the Overlay */
-    defaultOpen?: RadixDialogPrimitive.DialogProps["defaultOpen"];
-    /** callback that is fired upon closing of the Overlay calls the close function to continue the closing process.
-     * If the close function is not called, the Overlay will not be closed */
-    onInterruptClose?: (close: CloseDialog) => void;
-    /** callback fired when the Overlay is being closed, if onInterruptClose is specified, it fires if the closing process
-     * is continued by calling the close function within the callback passed to onInterruptClose.
-     * */
-    onClose?: () => void;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    className?: string;
-    style?: CSSProperties;
-    /** when true, renders an unstyled overlay filling the Overlays parent container */
-    overlay?: boolean;
-    /** className to be applied to the overlay component */
-    overlayClass?: string;
-    /** style object to be applied to the overlay component */
-    overlayStyle?: CSSProperties;
+/// <reference types="react" />
+import { BaseDialogProps } from "../BaseDialog";
+export interface OverlayProps extends BaseDialogProps {
 }
 /** The Overlay component is a versatile UI element designed to provide a layer above the existing content.
  * It serves various purposes such as modals, popovers, tooltips, or any other temporary or context-based UI overlay.*/

package/dist/OvermapInputItem/OvermapInputItem.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { OvermapInputItemProps } from "./typings";
+/** The OvermapInputItem component is used as a Base Component to provide an input-based element that follows the
+ * OvermapItem layout, in an item-like format. It supports responsive sizing and slot props to insert content to the
+ * left and right of its input field. */
+export declare const OvermapInputItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<OvermapInputItemProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>>;

package/dist/OvermapInputItem/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OvermapInputItem";
+export * from "./typings";

package/dist/OvermapInputItem/typings.d.ts

@@ -0,0 +1,4 @@
+import { HTMLProps } from "react";
+import { OvermapItemProps } from "../OvermapItem";
+export interface OvermapInputItemProps extends Pick<OvermapItemProps, "size" | "leftSlot" | "rightSlot">, Omit<HTMLProps<HTMLInputElement>, "size"> {
+}

package/dist/OvermapItem/typings.d.ts

@@ -16,5 +16,9 @@ export interface OvermapItemProps extends Omit<HTMLProps<HTMLDivElement>, "ref"
     rightSlot?: ReactNode;
     /** supports five different sizes, changing the overall proportions of the OvermapItem including font size. */
     size?: OvermapResponsive<OvermapItemSizes>;
+    /** displays the item in a "compact" mode.
+     * leftSlot and rightSlot won't be visible, and the width and height are the same
+     * based on the "size" prop.  */
+    compact?: boolean;
 }
 export {};

package/dist/OvermapItemGroup/OvermapItemGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { OvermapItemGroupProps } from "./typings";
+export declare const OvermapItemGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<OvermapItemGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/OvermapItemGroup/context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { OvermapItemProps } from "../OvermapItem";
+interface OvermapItemGroupContext {
+    size: OvermapItemProps["size"];
+    compact: OvermapItemProps["compact"];
+}
+export declare const OvermapItemGroupContext: import("react").Context<OvermapItemGroupContext>;
+export declare const useOvermapItemGroupContext: () => OvermapItemGroupContext;
+export {};

package/dist/OvermapItemGroup/index.d.ts

@@ -0,0 +1,3 @@
+export { useOvermapItemGroupContext } from "./context";
+export * from "./typings";
+export * from "./OvermapItemGroup";

package/dist/OvermapItemGroup/typings.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+import { Grid } from "@radix-ui/themes";
+import { OvermapItemProps } from "../OvermapItem";
+export interface OvermapItemGroupProps extends ComponentProps<typeof Grid> {
+    size?: OvermapItemProps["size"];
+    compact?: OvermapItemProps["compact"];
+}

package/dist/Pagination/PaginationControls.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { PaginationStatus } from "./typings.ts";
-import { Size } from "../typings.ts";
+import { PaginationStatus } from "./typings";
+import { Size } from "../typings";
 type PaginationControlsProps = Pick<PaginationStatus<unknown>, "currentPage" | "setCurrentPage" | "visiblePages"> & {
     size: Size;
 };

package/dist/Pagination/hooks.d.ts

@@ -1,2 +1,2 @@
-import { PaginationStatus } from "./typings.ts";
+import { PaginationStatus } from "./typings";
 export declare const usePagination: <TItem>(items: TItem[], itemsPerPage: number, maxVisiblePages: number) => PaginationStatus<TItem>;

package/dist/RiIcon/RiIcon.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IconBaseProps } from "react-icons";
+interface RemixIconProps extends IconBaseProps {
+    icon: string;
+}
+export declare const RiIcon: import("react").MemoExoticComponent<(props: RemixIconProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/RiIcon/index.d.ts

@@ -0,0 +1 @@
+export * from "./RiIcon";

package/dist/Select/Select.d.ts

@@ -1,3 +1,3 @@
 import { FC } from "react";
-import { SelectProps } from "./typings.ts";
+import { SelectProps } from "./typings";
 export declare const Select: FC<SelectProps>;

package/dist/Select/typings.d.ts

@@ -1,6 +1,6 @@
 import { ComponentProps, ReactNode } from "react";
 import { Responsive, Select as RadixSelect } from "@radix-ui/themes";
-import { Severity, Size, Variant } from "../typings.ts";
+import { Severity, Size, Variant } from "../typings";
 type RadixSelectItemProps = ComponentProps<typeof RadixSelect.Item>;
 type RadixSelectContentProps = ComponentProps<typeof RadixSelect.Content>;
 export interface SelectItemProps extends Omit<RadixSelectItemProps, "asChild" | "textValue"> {

package/dist/SelectContext/Provider.d.ts

@@ -0,0 +1,14 @@
+import { PropsWithChildren } from "react";
+type SelectContextProviderProps = PropsWithChildren & ({
+    type: "single";
+    defaultValue?: string | null;
+    value?: string | null;
+    onValueChange?: (value: string | null) => void;
+} | {
+    type: "multi";
+    defaultValues?: string[];
+    values?: string[];
+    onValuesChange?: (values: string[]) => void;
+});
+export declare const SelectContextProvider: import("react").MemoExoticComponent<(props: SelectContextProviderProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/SelectContext/context.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { MultiSelectContext, SingleSelectContext } from "./typings";
+export type ISelectContext = SingleSelectContext | MultiSelectContext;
+export declare const SelectContext: import("react").Context<ISelectContext>;
+export declare function useSelectContext<Type = SingleSelectContext | MultiSelectContext>(): Type;

package/dist/SelectContext/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Provider";
+export * from "./context";
+export * from "./typings";

package/dist/SelectContext/typings.d.ts

@@ -0,0 +1,10 @@
+export type SingleSelectContext = {
+    type: "single";
+    value: string | null;
+    handleValueChange: (value: string | null) => void;
+};
+export type MultiSelectContext = {
+    type: "multi";
+    values: string[];
+    handleValuesChange: (value: string[]) => void;
+};

package/dist/Table/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./Table";
-export * from "./typings.ts";
+export * from "./typings";