@rafal.lemieszewski/tide-ui 0.1.1 → 0.2.0

package/dist/components/index.d.ts

@@ -13,10 +13,26 @@ export type { LabelProps } from './ui/label';
 export { Separator } from './ui/separator';
 export { Skeleton, SkeletonAvatar, SkeletonButton, SkeletonCard, SkeletonTable, skeletonVariants } from './ui/skeleton';
 export { Switch } from './ui/switch';
+export { Textarea } from './ui/textarea';
+export type { TextareaProps } from './ui/textarea';
 export { Tabs, TabsList, TabsTrigger, TabsContent, TabsGroupLabel } from './ui/tabs';
 export type { TabsProps, TabsListProps, TabsTriggerProps, TabsGroupLabelProps } from './ui/tabs';
 export { Toggle } from './ui/toggle';
 export type { ToggleProps } from './ui/toggle';
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, selectTriggerVariants, selectContentVariants, selectItemVariants, } from './ui/select';
+export type { SelectTriggerProps, SelectContentProps, SelectItemProps } from './ui/select';
+export { TextLink } from './ui/text-link';
+export type { TextLinkProps } from './ui/text-link';
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, } from './ui/accordion';
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogBody, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, } from './ui/alert-dialog';
+export { Icon } from './ui/icon';
+export type { IconColor, IconSize, CustomIconName } from './ui/icon';
+export { Kbd } from './ui/kbd';
+export { CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, } from './ui/command';
+export { Breadcrumb, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, } from './ui/breadcrumb';
+export { Sidebar, SidebarContent, SidebarFooter, SidebarHeader, SidebarInput, SidebarRail, SidebarSeparator, SidebarGroup, SidebarGroupAction, SidebarGroupLabel, SidebarGroupContent, SidebarMenu, SidebarMenuItem, SidebarMenuButton, SidebarMenuAction, SidebarMenuBadge, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubItem, SidebarMenuSubButton, SidebarInset, SidebarProvider, SidebarTrigger, useSidebar, } from './ui/sidebar';
+export { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger, DropdownMenuLabel, DropdownMenuGroup, } from './ui/dropdown-menu';
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, } from './ui/tooltip';
 export { cn } from '../lib/utils';
 export declare const designTokens: {
     readonly colors: {

package/dist/components/ui/alert-dialog.d.ts

@@ -13,10 +13,13 @@ declare const AlertDialogFooter: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+declare const AlertDialogBody: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
 declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
 declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
-    variant?: "default" | "destructive";
+    variant?: "default" | "primary" | "destructive";
 } & React.RefAttributes<HTMLButtonElement>>;
 declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogBody, AlertDialogFooter, AlertDialogTitle, AlertDialogAction, AlertDialogCancel, };

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

@@ -2,13 +2,13 @@ import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 import * as AvatarPrimitive from "@radix-ui/react-avatar";
 declare const avatarVariants: (props?: ({
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    size?: "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
     shape?: "circle" | "rounded" | "square" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare const avatarFallbackVariants: (props?: ({
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    size?: "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
     shape?: "circle" | "rounded" | "square" | null | undefined;
-    variant?: "primary" | "secondary" | "accent" | "success" | "warning" | "error" | null | undefined;
+    variant?: "information" | "success" | "error" | "warning" | "violet" | "magenta" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
 }

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

@@ -1,8 +1,9 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 declare const badgeVariants: (props?: ({
-    intent?: "success" | "warning" | "neutral" | "brand" | "destructive" | null | undefined;
-    appearance?: "solid" | "subtle" | "outline" | null | undefined;
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+    intent?: "success" | "warning" | "destructive" | "neutral" | "brand" | null | undefined;
+    appearance?: "outline" | "solid" | "subtle" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {

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

@@ -2,7 +2,7 @@ import { default as React } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { IconType } from './icon';
 declare const buttonVariants: (props?: ({
-    variant?: "primary" | "success" | "default" | "destructive" | "ghost" | null | undefined;
+    variant?: "success" | "default" | "secondary" | "destructive" | "primary" | "ghost" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
     iconPosition?: "none" | "left" | "right" | "only" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;

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

@@ -1,9 +1,10 @@
 export declare const chartColorSchemes: {
-    readonly bar: readonly ["#3B82F6", "#1D4ED8", "#1E40AF", "#1E3A8A", "#312E81", "#1E1B4B"];
-    readonly line: readonly ["#10B981", "#059669", "#047857", "#065F46", "#064E3B", "#022C22"];
-    readonly scatter: readonly ["#8B5CF6", "#7C3AED", "#6D28D9", "#5B21B6", "#4C1D95", "#312E81"];
+    readonly bar: readonly ["#3B82F6", "#1D4ED8", "#1E40AF", "#1E3A8A", "#312E81", "#1E1B4B", "#F59E0B", "#DC2626"];
+    readonly line: readonly ["#10B981", "#059669", "#047857", "#065F46", "#064E3B", "#022C22", "#8B5CF6", "#DC2626"];
+    readonly scatter: readonly ["#8B5CF6", "#7C3AED", "#6D28D9", "#5B21B6", "#4C1D95", "#312E81", "#10B981", "#F59E0B"];
+    readonly accessible: readonly ["#0066CC", "#CC6600", "#009966", "#CC0066", "#6600CC", "#CC9900", "#006666", "#CC0000"];
 };
-export type ChartType = "bar" | "horizontal-bar" | "line" | "scatter";
+export type ChartType = "bar" | "horizontal-bar" | "line" | "scatter" | "composed";
 export type ChartColorScheme = keyof typeof chartColorSchemes;
 export interface ChartDataPoint {
     [key: string]: string | number;
@@ -12,6 +13,7 @@ export interface ChartConfig {
     [key: string]: {
         label: string;
         color?: string;
+        type?: "bar" | "line" | "area";
     };
 }
 export interface ChartProps {
@@ -27,7 +29,10 @@ export interface ChartProps {
     showGrid?: boolean;
     showLegend?: boolean;
     showTooltip?: boolean;
+    colorScheme?: ChartColorScheme;
+    responsive?: boolean;
+    maintainAspectRatio?: boolean;
 }
-export declare function Chart({ type, data, config, className, height, width, onDataPointClick, onDataPointHover, highlightedIndex, showGrid, showLegend, showTooltip, ...props }: ChartProps): import("react/jsx-runtime").JSX.Element;
-export declare const generateChartColors: (count: number, scheme?: ChartColorScheme) => ("#3B82F6" | "#1D4ED8" | "#1E40AF" | "#1E3A8A" | "#312E81" | "#1E1B4B" | "#10B981" | "#059669" | "#047857" | "#065F46" | "#064E3B" | "#022C22" | "#8B5CF6" | "#7C3AED" | "#6D28D9" | "#5B21B6" | "#4C1D95")[];
-export declare const createChartConfig: (keys: string[], labels: string[], colors?: string[]) => ChartConfig;
+export declare function Chart({ type, data, config, className, height, width, onDataPointClick, onDataPointHover, highlightedIndex, showGrid, showLegend, showTooltip, colorScheme, responsive, maintainAspectRatio, ...props }: ChartProps): import("react/jsx-runtime").JSX.Element;
+export declare const generateChartColors: (count: number, scheme?: ChartColorScheme) => ("#3B82F6" | "#1D4ED8" | "#1E40AF" | "#1E3A8A" | "#312E81" | "#1E1B4B" | "#F59E0B" | "#DC2626" | "#10B981" | "#059669" | "#047857" | "#065F46" | "#064E3B" | "#022C22" | "#8B5CF6" | "#7C3AED" | "#6D28D9" | "#5B21B6" | "#4C1D95" | "#0066CC" | "#CC6600" | "#009966" | "#CC0066" | "#6600CC" | "#CC9900" | "#006666" | "#CC0000")[];
+export declare const createChartConfig: (input: ChartConfig | string[], labels?: string[], colors?: string[]) => ChartConfig;

package/dist/components/ui/data-table.d.ts

@@ -0,0 +1,44 @@
+import { ColumnDef, FilterFn } from '@tanstack/react-table';
+import * as React from "react";
+export type FilterVariant = "text" | "select" | "multiselect" | "number" | "date" | "boolean";
+export interface ColumnMeta {
+    label?: string;
+    filterVariant?: FilterVariant;
+    filterOptions?: Array<{
+        label: string;
+        value: string;
+        icon?: React.ComponentType<any>;
+    }>;
+    placeholder?: string;
+    icon?: React.ComponentType<any>;
+}
+declare const fuzzyFilter: FilterFn<any>;
+declare const multiSelectFilter: FilterFn<any>;
+interface DataTableToolbarProps<_TData = any> {
+    table: any;
+    searchKey?: string;
+    searchPlaceholder?: string;
+}
+declare function DataTableToolbar<TData>({ table, searchKey, searchPlaceholder }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+interface DataTableFilterProps {
+    column: any;
+}
+declare function DataTableFilter({ column }: DataTableFilterProps): import("react/jsx-runtime").JSX.Element;
+interface DataTableColumnHeaderProps<_TData = any, _TValue = any> extends React.HTMLAttributes<HTMLDivElement> {
+    column: any;
+    title: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+interface DataTablePaginationProps<_TData = any> {
+    table: any;
+}
+declare function DataTablePagination<TData>({ table }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    searchKey?: string;
+    searchPlaceholder?: string;
+    className?: string;
+}
+export declare function DataTable<TData, TValue>({ columns, data, searchKey, searchPlaceholder, className, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export { DataTableColumnHeader, DataTableFilter, DataTableToolbar, DataTablePagination, fuzzyFilter, multiSelectFilter };

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

@@ -0,0 +1,30 @@
+import * as React from "react";
+export interface DatePickerProps {
+    date?: Date;
+    onDateChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    formatStr?: string;
+    fromDate?: Date;
+    toDate?: Date;
+}
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export interface DateRangePickerProps {
+    dateRange?: {
+        from: Date | undefined;
+        to: Date | undefined;
+    };
+    onDateRangeChange?: (range: {
+        from: Date | undefined;
+        to: Date | undefined;
+    }) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    formatStr?: string;
+    fromDate?: Date;
+    toDate?: Date;
+}
+declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { DatePicker, DateRangePicker };

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

@@ -10,10 +10,13 @@ declare const DialogHeader: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+declare const DialogBody: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
 declare const DialogFooter: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogBody, DialogFooter, DialogTitle, };

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

@@ -0,0 +1,51 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const editableVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface EditableContextValue {
+    isEditing: boolean;
+    value: string;
+    originalValue: string;
+    onEdit: () => void;
+    onCancel: () => void;
+    onSubmit: () => void;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    invalid?: boolean;
+    required?: boolean;
+    maxLength?: number;
+    disabled?: boolean;
+    triggerMode: "click" | "dblclick" | "focus";
+}
+declare const useEditable: () => EditableContextValue;
+export interface EditableProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange" | "onSubmit">, VariantProps<typeof editableVariants> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onEdit?: () => void;
+    onCancel?: () => void;
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    invalid?: boolean;
+    required?: boolean;
+    maxLength?: number;
+    disabled?: boolean;
+    triggerMode?: "click" | "dblclick" | "focus";
+    controlled?: boolean;
+}
+declare const Editable: React.ForwardRefExoticComponent<EditableProps & React.RefAttributes<HTMLDivElement>>;
+export interface EditablePreviewProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+declare const EditablePreview: React.ForwardRefExoticComponent<EditablePreviewProps & React.RefAttributes<HTMLDivElement>>;
+export interface EditableInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
+    autoFocus?: boolean;
+}
+declare const EditableInput: React.ForwardRefExoticComponent<EditableInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface EditableTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "onChange"> {
+    autoFocus?: boolean;
+    autoResize?: boolean;
+}
+declare const EditableTextarea: React.ForwardRefExoticComponent<EditableTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Editable, EditablePreview, EditableInput, EditableTextarea, useEditable };

package/dist/components/ui/empty-state.d.ts

@@ -0,0 +1,47 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const emptyStateVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const emptyStateIconVariants: (props?: ({
+    variant?: "success" | "error" | "warning" | "default" | "primary" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
+    icon?: React.ComponentType<{
+        className?: string;
+    }> | string;
+    iconVariant?: VariantProps<typeof emptyStateIconVariants>["variant"];
+    iconSize?: VariantProps<typeof emptyStateIconVariants>["size"];
+    heading: string;
+    description?: string;
+    image?: string;
+    imageAlt?: string;
+    action?: {
+        label: string;
+        onClick?: () => void;
+        href?: string;
+        variant?: "default" | "secondary" | "ghost" | "primary" | "destructive" | "success";
+    };
+    secondaryAction?: {
+        label: string;
+        onClick?: () => void;
+        href?: string;
+        variant?: "default" | "secondary" | "ghost" | "primary" | "destructive" | "success";
+    };
+}
+export declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+export declare const EmptyStates: {
+    NoData: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    NoSearchResults: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    EmptyInbox: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    EmptyCart: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    NoFiles: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    ConnectionError: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    NotFound: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    Unauthorized: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    ComingSoon: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+    NoNotifications: ({ title, description, ...props }: Partial<EmptyStateProps>) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/components/ui/file-upload.d.ts

@@ -0,0 +1,75 @@
+import { Button } from './button';
+import * as React from "react";
+interface FileUploadContextValue {
+    files: FileUploadFile[];
+    onFilesChange: (files: FileUploadFile[]) => void;
+    maxFiles?: number;
+    maxSize?: number;
+    accept?: string[];
+    disabled?: boolean;
+    multiple?: boolean;
+    onUpload?: (files: File[]) => Promise<void>;
+}
+declare const useFileUpload: () => FileUploadContextValue;
+export interface FileUploadFile {
+    id: string;
+    file: File;
+    status: "pending" | "uploading" | "success" | "error";
+    progress?: number;
+    error?: string;
+    preview?: string;
+}
+export interface FileUploadProps extends React.HTMLAttributes<HTMLDivElement> {
+    files: FileUploadFile[];
+    onFilesChange: (files: FileUploadFile[]) => void;
+    maxFiles?: number;
+    maxSize?: number;
+    accept?: string[];
+    disabled?: boolean;
+    multiple?: boolean;
+    onUpload?: (files: File[]) => Promise<void>;
+}
+declare const FileUploadRoot: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadDropzoneProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const FileUploadDropzone: React.ForwardRefExoticComponent<FileUploadDropzoneProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadTriggerProps extends React.ComponentProps<typeof Button> {
+}
+declare const FileUploadTrigger: React.ForwardRefExoticComponent<Omit<FileUploadTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export interface FileUploadListProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const FileUploadList: React.ForwardRefExoticComponent<FileUploadListProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    file: FileUploadFile;
+}
+declare const FileUploadItem: React.ForwardRefExoticComponent<FileUploadItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemPreviewProps extends React.HTMLAttributes<HTMLDivElement> {
+    file: FileUploadFile;
+}
+declare const FileUploadItemPreview: React.ForwardRefExoticComponent<FileUploadItemPreviewProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemMetadataProps extends React.HTMLAttributes<HTMLDivElement> {
+    file: FileUploadFile;
+}
+declare const FileUploadItemMetadata: React.ForwardRefExoticComponent<FileUploadItemMetadataProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    file: FileUploadFile;
+    variant?: "linear" | "circular";
+}
+declare const FileUploadItemProgress: React.ForwardRefExoticComponent<FileUploadItemProgressProps & React.RefAttributes<HTMLDivElement>>;
+export interface FileUploadItemDeleteProps extends React.ComponentProps<typeof Button> {
+    file: FileUploadFile;
+}
+declare const FileUploadItemDelete: React.ForwardRefExoticComponent<Omit<FileUploadItemDeleteProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const formatFileSize: (bytes: number) => string;
+export declare const FileUpload: {
+    Root: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLDivElement>>;
+    Dropzone: React.ForwardRefExoticComponent<FileUploadDropzoneProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<Omit<FileUploadTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    List: React.ForwardRefExoticComponent<FileUploadListProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<FileUploadItemProps & React.RefAttributes<HTMLDivElement>>;
+    ItemPreview: React.ForwardRefExoticComponent<FileUploadItemPreviewProps & React.RefAttributes<HTMLDivElement>>;
+    ItemMetadata: React.ForwardRefExoticComponent<FileUploadItemMetadataProps & React.RefAttributes<HTMLDivElement>>;
+    ItemProgress: React.ForwardRefExoticComponent<FileUploadItemProgressProps & React.RefAttributes<HTMLDivElement>>;
+    ItemDelete: React.ForwardRefExoticComponent<Omit<FileUploadItemDeleteProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+};
+export { FileUploadRoot, FileUploadDropzone, FileUploadTrigger, FileUploadList, FileUploadItem, FileUploadItemPreview, FileUploadItemMetadata, FileUploadItemProgress, FileUploadItemDelete, useFileUpload, formatFileSize, };

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

@@ -28,12 +28,12 @@ export type IconSize = keyof typeof iconSizes;
 export type { CustomIconName };
 export type LucideIconName = string;
 export type IconType = CustomIconName | LucideIconName;
-export interface IconProps extends Omit<React.SVGAttributes<SVGElement>, 'color'> {
+export interface IconProps extends Omit<React.SVGAttributes<SVGElement>, "color"> {
     name: IconType;
     size?: IconSize;
     color?: IconColor;
     /** Accessible label for the icon. If not provided, icon will be marked as decorative (aria-hidden) */
-    'aria-label'?: string;
+    "aria-label"?: string;
 }
 declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<SVGSVGElement>>;
 export { Icon, iconColors, iconSizes };

package/dist/components/ui/linked-chart.d.ts

@@ -3,7 +3,7 @@ export interface LinkedChartColumn {
     key: string;
     label: string;
     type?: "text" | "number" | "currency" | "percentage";
-    format?: (value: any) => string;
+    format?: (value: any, row?: any) => string;
 }
 export interface LinkedChartProps extends Omit<ChartProps, "onDataPointClick" | "onDataPointHover" | "highlightedIndex"> {
     title?: string;

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

@@ -0,0 +1,43 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const listboxVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ListboxContextValue {
+    value: string | string[] | undefined;
+    onChange: (value: string | string[]) => void;
+    multiple?: boolean;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    options: {
+        value: string;
+        disabled: boolean;
+        ref: React.RefObject<HTMLDivElement>;
+    }[];
+    registerOption: (value: string, disabled: boolean, ref: React.RefObject<HTMLDivElement>) => void;
+    unregisterOption: (value: string) => void;
+    activeValue: string | null;
+    setActiveValue: (value: string | null) => void;
+}
+export interface ListboxProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof listboxVariants> {
+    value?: string | string[];
+    onChange?: (value: string | string[]) => void;
+    multiple?: boolean;
+    disabled?: boolean;
+}
+declare const Listbox: React.ForwardRefExoticComponent<ListboxProps & React.RefAttributes<HTMLDivElement>>;
+export interface ListboxOptionProps extends React.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+}
+declare const ListboxOption: React.ForwardRefExoticComponent<ListboxOptionProps & React.RefAttributes<HTMLDivElement>>;
+export interface ListboxGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+declare const ListboxGroup: React.ForwardRefExoticComponent<ListboxGroupProps & React.RefAttributes<HTMLDivElement>>;
+export interface ListboxGroupLabelProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+}
+declare const ListboxGroupLabel: React.ForwardRefExoticComponent<ListboxGroupLabelProps & React.RefAttributes<HTMLDivElement>>;
+export { Listbox, ListboxOption, ListboxGroup, ListboxGroupLabel };

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

@@ -0,0 +1,68 @@
+import * as React from "react";
+export interface MentionSuggestion {
+    id: string;
+    label: string;
+    value: string;
+    avatar?: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface MentionProps {
+    /**
+     * Current text value
+     */
+    value: string;
+    /**
+     * Callback when the text changes
+     */
+    onChange: (value: string) => void;
+    /**
+     * Array of suggestion items
+     */
+    suggestions: MentionSuggestion[];
+    /**
+     * Character that triggers the mention dropdown
+     */
+    trigger?: string;
+    /**
+     * Placeholder text for the input
+     */
+    placeholder?: string;
+    /**
+     * Whether the input is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Callback when a mention is selected
+     */
+    onMentionSelect?: (suggestion: MentionSuggestion) => void;
+    /**
+     * Custom filter function for suggestions
+     */
+    filterFn?: (suggestions: MentionSuggestion[], query: string) => MentionSuggestion[];
+}
+export declare const Mention: React.ForwardRefExoticComponent<MentionProps & React.RefAttributes<HTMLTextAreaElement>>;
+export declare const extractMentions: (text: string, trigger?: string) => {
+    mention: string;
+    index: number;
+}[];
+export declare const highlightMentions: (text: string, trigger?: string, className?: string) => (string | import("react/jsx-runtime").JSX.Element)[];
+export interface MentionTextProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Text content with mentions
+     */
+    text: string;
+    /**
+     * Mention trigger character
+     */
+    trigger?: string;
+    /**
+     * Custom className for mention highlights
+     */
+    mentionClassName?: string;
+    /**
+     * Callback when a mention is clicked
+     */
+    onMentionClick?: (mention: string) => void;
+}
+export declare const MentionText: React.ForwardRefExoticComponent<MentionTextProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/ui/number-scrubber.d.ts

@@ -0,0 +1,21 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const numberScrubberVariants: (props?: ({
+    variant?: "default" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface NumberScrubberProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "type" | "size">, VariantProps<typeof numberScrubberVariants> {
+    value?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    sensitivity?: number;
+    precision?: number;
+    formatValue?: (value: number) => string;
+    parseValue?: (value: string) => number;
+    onScrubStart?: () => void;
+    onScrubEnd?: () => void;
+}
+export declare const NumberScrubber: React.ForwardRefExoticComponent<NumberScrubberProps & React.RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ProgressPrimitive from "@radix-ui/react-progress";
+declare const progressVariants: (props?: ({
+    variant?: "success" | "error" | "warning" | "default" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>, VariantProps<typeof progressVariants> {
+    showLabel?: boolean;
+    formatLabel?: (value: number) => string;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { Progress };

package/dist/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const sortableVariants: (props?: ({
+    orientation?: "grid" | "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SortableRootProps<T = any> extends Omit<React.HTMLAttributes<HTMLDivElement>, "onDragEnd">, VariantProps<typeof sortableVariants> {
+    items: T[];
+    onItemsChange: (items: T[]) => void;
+    getItemId?: (item: T) => string;
+    disabled?: boolean;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    renderOverlay?: (item: T) => React.ReactNode;
+}
+declare const SortableRoot: <T extends any>({ className, orientation, items, onItemsChange, getItemId, disabled, renderItem, renderOverlay, children, ...props }: SortableRootProps<T>) => import("react/jsx-runtime").JSX.Element;
+export interface SortableContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SortableContent: React.ForwardRefExoticComponent<SortableContentProps & React.RefAttributes<HTMLDivElement>>;
+export interface SortableItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    id: string;
+    item?: any;
+    index?: number;
+    disabled?: boolean;
+}
+declare const SortableItem: React.ForwardRefExoticComponent<SortableItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface SortableHandleProps extends React.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+}
+declare const SortableHandle: React.ForwardRefExoticComponent<SortableHandleProps & React.RefAttributes<HTMLDivElement>>;
+export interface SortableOverlayProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SortableOverlay: React.ForwardRefExoticComponent<SortableOverlayProps & React.RefAttributes<HTMLDivElement>>;
+export { SortableRoot as Root, SortableContent as Content, SortableItem as Item, SortableHandle as Handle, SortableOverlay as Overlay, };
+declare const Sortable: {
+    Root: <T extends unknown>({ className, orientation, items, onItemsChange, getItemId, disabled, renderItem, renderOverlay, children, ...props }: SortableRootProps<T>) => import("react/jsx-runtime").JSX.Element;
+    Content: React.ForwardRefExoticComponent<SortableContentProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<SortableItemProps & React.RefAttributes<HTMLDivElement>>;
+    Handle: React.ForwardRefExoticComponent<SortableHandleProps & React.RefAttributes<HTMLDivElement>>;
+    Overlay: React.ForwardRefExoticComponent<SortableOverlayProps & React.RefAttributes<HTMLDivElement>>;
+};
+export { Sortable };
+export default Sortable;