ezux 1.1.13 → 1.1.18

package/dist/components/EzTreeView/hooks/useTreeImperative.d.ts

@@ -0,0 +1,28 @@
+import { EzTreeViewProps, TreeNode, EzTreeViewApi } from '../EzTreeView.types';
+import { HierarchyService } from '../../../shared/services/HierarchyService';
+/**
+ * Hook for building and exposing the imperative API for EzTreeView.
+ *
+ * Agregates all tree operations into a single API object and registers it with the component's ref.
+ *
+ * @param props Props for the EzTreeView component.
+ * @param treeData The current tree data.
+ * @param setTreeData Callback to update the tree data.
+ * @param expandedNodes The current expansion state.
+ * @param setExpandedNodes Callback to update expansion state.
+ * @param checkedNodes The current checked state.
+ * @param setCheckedNodes Callback to update checked state.
+ * @param setSelectedNodes Callback to update selection state.
+ * @param setIndeterminateNodes Callback to update indeterminate state.
+ * @param updateCheckState Core check state logic.
+ * @param flattenedNodes The current visible list of nodes.
+ * @param hierarchyService Service for tree structure operations.
+ * @param setEditingNodeId Callback to enter node editing mode.
+ * @param ref The ref to attach the API to.
+ * @param baseApi Optional base API methods.
+ * @group Hooks
+ */
+export declare const useTreeImperative: (props: EzTreeViewProps, treeData: TreeNode[], setTreeData: React.Dispatch<React.SetStateAction<TreeNode[]>>, expandedNodes: Set<string>, setExpandedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, checkedNodes: Set<string>, setCheckedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, setSelectedNodes: React.Dispatch<React.SetStateAction<Set<string>>>, setIndeterminateNodes: React.Dispatch<React.SetStateAction<Set<string>>>, updateCheckState: (id: string, check: boolean) => void, flattenedNodes: {
+    node: TreeNode;
+    level: number;
+}[], hierarchyService: HierarchyService, setEditingNodeId: (id: string | null) => void, ref: React.Ref<EzTreeViewApi>, baseApi?: any) => void;

package/dist/components/EzTreeView/hooks/useTreeSelection.d.ts

@@ -0,0 +1,31 @@
+import { EzTreeViewProps } from '../EzTreeView.types';
+import { HierarchyService } from '../../../shared/services/HierarchyService';
+/**
+ * Hook for managing tree selection (single/multiple) and tri-state check states.
+ *
+ * Handles propagation of check states to ancestors and descendants when autoCheck is enabled.
+ *
+ * @param props Props for the EzTreeView component.
+ * @param hierarchyService Service providing structural information about the tree.
+ * @group Hooks
+ */
+export declare const useTreeSelection: (props: EzTreeViewProps, hierarchyService: HierarchyService, treeData: any[]) => {
+    /** Set of IDs for currently selected nodes. @group State */
+    selectedNodes: Set<string>;
+    /** Manually set the set of selected node IDs. @group Methods */
+    setInternalSelectedNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Toggle selection state of a node. @group Methods */
+    toggleSelect: (nodeId: string) => void;
+    /** Set of IDs for currently checked nodes. @group State */
+    checkedNodes: Set<string>;
+    /** Manually set the set of checked node IDs. @group Methods */
+    setInternalCheckedNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Set of IDs for nodes with indeterminate check state. @group State */
+    indeterminateNodes: Set<string>;
+    /** Manually set the set of indeterminate node IDs. @group Methods */
+    setIndeterminateNodes: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    /** Toggle check state of a node. @group Methods */
+    toggleCheck: (nodeId: string) => void;
+    /** Core logic to update check state and propagate changes. @group Methods */
+    updateCheckState: (nodeId: string, isChecked: boolean) => void;
+};

package/dist/components/EzTreeView/hooks/useTreeState.d.ts

@@ -0,0 +1,21 @@
+import { EzTreeViewProps, TreeNode } from '../EzTreeView.types';
+/**
+ * Hook for managing the core data and processing logic for the tree.
+ *
+ * Handles field mapping, sorting, and synchronizing external data changes.
+ *
+ * @param props Props for the EzTreeView component.
+ * @group Hooks
+ */
+export declare const useTreeState: (props: EzTreeViewProps) => {
+    /** The processed tree data structure. @group State */
+    treeData: TreeNode[];
+    /** Update the internal tree data. @group Methods */
+    setInternalTreeData: (updater: TreeNode[] | ((prev: TreeNode[]) => TreeNode[])) => void;
+    /** Set of node IDs currently in a loading state. @group State */
+    loadingNodes: Set<string>;
+    /** Update the loading state of nodes. @group Methods */
+    setLoadingNodes: (updater: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
+    /** Update a specific node by ID. @group Methods */
+    updateNode: (id: string, updates: Partial<TreeNode>) => void;
+};

package/dist/components/EzTreeView/hooks/useTreeVirtualization.d.ts

@@ -0,0 +1,18 @@
+import { TreeNode } from '../EzTreeView.types';
+/**
+ * Hook for flattening tree data for virtualization and applying search filters.
+ *
+ * Computes a visible flat list of nodes based on expansion state and search term matches.
+ *
+ * @param treeData The full tree data.
+ * @param expandedNodes Set of IDs for currently expanded nodes.
+ * @param searchTerm Optional search query for filtering nodes.
+ * @group Hooks
+ */
+export declare const useTreeVirtualization: (treeData: TreeNode[], expandedNodes: Set<string>, searchTerm?: string) => {
+    /** The flattened list of visible nodes and their levels. @group State */
+    flattenedNodes: {
+        node: TreeNode;
+        level: number;
+    }[];
+};

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

@@ -0,0 +1,40 @@
+import { default as React } from 'react';
+import { EzTreeViewProps } from './EzTreeView.types';
+/**
+ * EzTreeView is a high-performance hierarchical data explorer.
+ * It uses a virtualized engine to efficiently render trees with thousands of
+ * nodes while providing rich interactive features like drag-and-drop and
+ * multi-level selection.
+ *
+
+ * ### Key Features
+ * - **Superior Virtualization**: Flat-list virtualization for smooth scrolling even with deep, expanded trees.
+ * - **Flexible Selection**: Supports `single`, `multiple`, and `checkbox` selection modes with indeterminate state support.
+ * - **Drag & Drop**: Native `@dnd-kit` integration for reordering nodes and changing parent-child relationships.
+ * - **Inline Editing**: Double-click to rename nodes with built-in validation.
+ * - **Search & Filter**: Real-time filtering with automatic expansion of matching parent nodes.
+ * - **Custom Rendering**: Fully customizable node templates and icons via the `components` prop.
+ *
+ * ### Minimal Example
+ * ```tsx
+ * <EzTreeView
+ *   data={myTreeData}
+ *   showCheckboxes
+ *   onNodeClicked={(node) => console.log('Clicked:', node.text)}
+ * />
+ * ```
+ *
+ * ### Advanced Config: Virtualization & DND
+ * ```tsx
+ * <EzTreeView
+ *   data={largeTreeData}
+ *   allowDragAndDrop
+ *   allowEditing
+ *   onNodeDrop={(dragged, target, position) => handleMove(dragged, target, position)}
+ *   className="h-[400px] border rounded-md"
+ * />
+ * ```
+ *
+ * @group Core Components
+ */
+export declare const EzTreeView: React.FC<EzTreeViewProps>;

package/dist/components/EzTreeView/services/TreeService.d.ts

@@ -0,0 +1,11 @@
+import { ITreeService, TreeNode } from '../EzTreeView.types';
+export declare class TreeService implements ITreeService {
+    name: string;
+    constructor();
+    private simulateLatency;
+    loadNodes(parentId?: string): Promise<TreeNode[]>;
+    moveNode(id: string, targetParentId: string, index?: number): Promise<void>;
+    renameNode(id: string, newName: string): Promise<void>;
+    deleteNode(id: string): Promise<void>;
+    addNode(parentId: string, node: Partial<TreeNode>): Promise<TreeNode>;
+}

package/dist/components/EzTreeView/useEzTreeView.d.ts

@@ -0,0 +1,50 @@
+import { EzTreeViewProps, TreeNode } from './EzTreeView.types';
+/**
+ * The main orchestrator hook for EzTreeView.
+ *
+ * Coordinates specialized hooks for tree state, expansion, multi-selection,
+ * virtualization, and imperative API access.
+ *
+ * @param props Props for the EzTreeView component.
+ * @group Hooks
+ */
+export declare const useEzTreeView: (props: EzTreeViewProps) => {
+    state: {
+        treeData: TreeNode[];
+        expandedNodes: Set<string>;
+        selectedNodes: Set<string>;
+        checkedNodes: Set<string>;
+        indeterminateNodes: Set<string>;
+        loadingNodes: Set<string>;
+        flattenedNodes: {
+            node: TreeNode;
+            level: number;
+        }[];
+        editingNodeId: string | null;
+    };
+    actions: {
+        toggleExpand: (nodeId: string) => Promise<void>;
+        toggleSelect: (nodeId: string) => void;
+        toggleCheck: (nodeId: string) => void;
+        handleNodeRename: (nodeId: string, newLabel: string) => void;
+        setEditingNodeId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    };
+    config: {
+        allowTextWrap: boolean | undefined;
+        animation: boolean | {
+            expand?: boolean;
+            collapse?: boolean;
+        } | undefined;
+        checkOnClick: boolean | undefined;
+        fullRowSelect: boolean | undefined;
+        fullRowNavigable: boolean | undefined;
+        onKeyPress: ((event: React.KeyboardEvent) => void) | undefined;
+        onNodeClicked: ((nodeId: string) => void) | undefined;
+        onDrawNode: ((node: TreeNode) => void) | undefined;
+    };
+    dir: "ltr" | "rtl";
+    baseApi: {
+        showSpinner: () => void;
+        hideSpinner: () => void;
+    };
+};

package/dist/components/EzTreeView/utils/treeUtils.d.ts

@@ -0,0 +1,17 @@
+import { TreeNode, EzTreeViewProps } from '../EzTreeView.types';
+/**
+ * Utility to map custom fields to TreeNode structure
+ */
+export declare const mapFieldsToTreeNode: (data: any, fields?: EzTreeViewProps["fields"]) => TreeNode;
+/**
+ * Utility to sort tree data
+ */
+export declare const sortTreeData: (data: TreeNode[], sortOrder?: "None" | "Ascending" | "Descending") => TreeNode[];
+/**
+ * Utility to find a node by ID
+ */
+export declare const findNodeById: (nodes: import('../../../shared/types').TreeNode[], id: string) => import('../../../shared/types').TreeNode | undefined;
+/**
+ * Utility to update a node in the tree
+ */
+export declare const updateNodeInNodes: (nodes: import('../../../shared/types').TreeNode[], id: string, updates: Partial<import('../../../shared/types').TreeNode>) => import('../../../shared/types').TreeNode[];

package/dist/components/shared/components/EzErrorBoundary.d.ts

@@ -0,0 +1,18 @@
+import { Component, ErrorInfo, ReactNode } from 'react';
+interface EzErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface EzErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+}
+export declare class EzErrorBoundary extends Component<EzErrorBoundaryProps, EzErrorBoundaryState> {
+    constructor(props: EzErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): EzErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+export default EzErrorBoundary;

package/dist/components/shared/components/EzLayoutErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzLayoutErrorFallback: React.FC;

package/dist/components/shared/components/EzLoadingSpinner.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export type LoadingSpinnerVariant = 'primary' | 'secondary';
+export interface EzLoadingSpinnerProps {
+    variant?: LoadingSpinnerVariant;
+    text?: string;
+    className?: string;
+}
+export declare const EzLoadingSpinner: React.FC<EzLoadingSpinnerProps>;

package/dist/components/shared/components/EzSchedulerErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzSchedulerErrorFallback: React.FC;

package/dist/components/shared/components/EzSortableList.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { verticalListSortingStrategy, horizontalListSortingStrategy, SortingStrategy } from '@dnd-kit/sortable';
+interface EzSortableListProps<T> {
+    items: T[];
+    onReorder: (items: T[]) => void;
+    renderItem: (item: T, index: number) => React.ReactNode;
+    getId: (item: T) => string;
+    strategy?: SortingStrategy;
+    className?: string;
+}
+export declare function EzSortableList<T>({ items, onReorder, renderItem, getId, strategy, className }: EzSortableListProps<T>): React.JSX.Element;
+export { verticalListSortingStrategy, horizontalListSortingStrategy };

package/dist/components/shared/components/EzTableErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzTableErrorFallback: React.FC;

package/dist/components/shared/components/EzTreeViewErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzTreeViewErrorFallback: React.FC;

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+export interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    ref?: React.Ref<HTMLDivElement>;
+}
+export declare function Avatar({ className, ref, ...props }: AvatarProps): React.JSX.Element;
+export interface AvatarImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+    ref?: React.Ref<HTMLImageElement>;
+}
+export declare function AvatarImage({ className, ref, ...props }: AvatarImageProps): React.JSX.Element;
+export declare function AvatarFallback({ className, ref, ...props }: AvatarProps): React.JSX.Element;

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    isLoading?: boolean;
+    ref?: React.Ref<HTMLButtonElement>;
+}
+export declare function Button({ className, variant, size, asChild, isLoading, children, disabled, ref, ...props }: ButtonProps): React.JSX.Element;
+export { buttonVariants };

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,15 @@
+export type CalendarProps = {
+    selected?: Date;
+    onSelect?: (date: Date | undefined) => void;
+    className?: string;
+    locale?: string;
+    minDate?: Date;
+    modifiers?: {
+        [date: string]: {
+            className?: string;
+            tooltip?: string;
+            disabled?: boolean;
+        };
+    };
+};
+export declare function Calendar({ selected, onSelect, className, locale, minDate, modifiers }: CalendarProps): import("react").JSX.Element;

package/dist/components/ui/card.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    ref?: React.Ref<HTMLDivElement>;
+}
+export declare function Card({ className, ref, ...props }: CardProps): React.JSX.Element;
+export declare function CardHeader({ className, ref, ...props }: CardProps): React.JSX.Element;
+export declare function CardTitle({ className, ref, ...props }: CardProps): React.JSX.Element;
+export declare function CardDescription({ className, ref, ...props }: CardProps): React.JSX.Element;
+export declare function CardContent({ className, ref, ...props }: CardProps): React.JSX.Element;
+export declare function CardFooter({ className, ref, ...props }: CardProps): React.JSX.Element;

package/dist/components/ui/checkbox.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'checked'> {
+    checked?: boolean | 'indeterminate';
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    ref?: React.Ref<HTMLInputElement>;
+}
+export declare function Checkbox({ className, checked, onCheckedChange, ref, ...props }: CheckboxProps): React.JSX.Element;

package/dist/components/ui/combobox.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export interface ComboboxOption {
+    value: string;
+    label: string;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    className?: string;
+    dropdownWidth?: string;
+    disabled?: boolean;
+    dir?: "ltr" | "rtl";
+}
+export declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/ui/command.d.ts

@@ -0,0 +1,78 @@
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/context-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/components/ui/date-time-picker.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface DateTimePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    disabled?: boolean;
+    required?: boolean;
+    id?: string;
+    locale?: string;
+    className?: string;
+    mode?: 'date' | 'datetime';
+    minDate?: Date;
+}
+export declare function DateTimePicker({ date, setDate, disabled, id, locale, className, mode, minDate }: DateTimePickerProps): React.JSX.Element;
+export {};

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement | null;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement | null;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

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

@@ -0,0 +1,27 @@
+export * from './avatar';
+export * from './breadcrumb';
+export * from './button';
+export * from './calendar';
+export * from './card';
+export * from './checkbox';
+export * from './command';
+export * from './context-menu';
+export * from './date-time-picker';
+export * from './dropdown-menu';
+export * from './input';
+export * from './label';
+export * from './password-input';
+export * from './popover';
+export * from './select';
+export * from './skeleton';
+export * from './switch';
+export * from './table';
+export * from './tabs';
+export * from './textarea';
+export * from './tooltip';
+export * from './scroll-area';
+export * from './radio-group';
+export * from './badge';
+export * from './progress';
+export * from './modal';
+export * from './combobox';

package/dist/components/ui/input.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    ref?: React.Ref<HTMLInputElement>;
+}
+export declare function Input({ className, type, ref, ...props }: InputProps): React.JSX.Element;

package/dist/components/ui/label.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const labelVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export interface LabelProps extends React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
+    ref?: React.Ref<React.ElementRef<typeof LabelPrimitive.Root>>;
+}
+export declare function Label({ className, ref, ...props }: LabelProps): React.JSX.Element;
+export {};

package/dist/components/ui/modal.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const Modal: React.FC<ModalProps>;

package/dist/components/ui/password-input.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface PasswordInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+export { PasswordInput };