@rafal.lemieszewski/tide-ui 0.1.1 → 0.1.2

package/dist/components/index.d.ts

@@ -17,6 +17,15 @@ export { Tabs, TabsList, TabsTrigger, TabsContent, TabsGroupLabel } from './ui/t
 export type { TabsProps, TabsListProps, TabsTriggerProps, TabsGroupLabelProps } from './ui/tabs';
 export { Toggle } from './ui/toggle';
 export type { ToggleProps } from './ui/toggle';
+export { AppFrame } from './product/app-frame';
+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, SidebarRail, SidebarGroup, SidebarGroupLabel, SidebarGroupContent, SidebarMenu, SidebarMenuItem, SidebarMenuButton, 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/chart.d.ts

@@ -30,4 +30,4 @@ export interface ChartProps {
 }
 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 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> {
+    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, TValue> 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> {
+    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/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">, 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?: "primary" | "success" | "warning" | "error" | "default" | 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" | "link";
+    };
+    secondaryAction?: {
+        label: string;
+        onClick?: () => void;
+        href?: string;
+        variant?: "default" | "secondary" | "ghost" | "link";
+    };
+}
+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 type { EmptyStateProps };

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

@@ -0,0 +1,76 @@
+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 };
+export type { FileUploadProps, FileUploadDropzoneProps, FileUploadTriggerProps, FileUploadListProps, FileUploadItemProps, FileUploadItemPreviewProps, FileUploadItemMetadataProps, FileUploadItemProgressProps, FileUploadItemDeleteProps, };

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

@@ -0,0 +1,40 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const listboxVariants: (props?: ({
+    orientation?: "grid" | "horizontal" | "vertical" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ListboxContextValue {
+    value: string | string[];
+    onValueChange: (value: string | string[]) => void;
+    multiple?: boolean;
+    orientation?: "vertical" | "horizontal" | "grid";
+    disabled?: boolean;
+}
+export interface ListboxProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof listboxVariants> {
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    multiple?: boolean;
+    disabled?: boolean;
+    gridCols?: number;
+}
+declare const Listbox: React.ForwardRefExoticComponent<ListboxProps & React.RefAttributes<HTMLDivElement>>;
+export interface ListboxItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+}
+declare const ListboxItem: React.ForwardRefExoticComponent<ListboxItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface ListboxItemIndicatorProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children: React.ReactNode;
+}
+declare const ListboxItemIndicator: React.ForwardRefExoticComponent<ListboxItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+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, ListboxItem, ListboxItemIndicator, ListboxGroup, ListboxGroupLabel };

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

@@ -0,0 +1,69 @@
+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>>;
+export type { MentionProps, MentionSuggestion, MentionTextProps };

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">, 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 type { NumberScrubberProps };

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" | "warning" | "error" | "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;

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

@@ -0,0 +1,92 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const spinnerVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+    variant?: "primary" | "secondary" | "success" | "warning" | "error" | "default" | "tertiary" | "disabled" | "inverse" | null | undefined;
+    speed?: "normal" | "slow" | "fast" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinnerVariants> {
+    /**
+     * Text to display alongside the spinner
+     */
+    label?: string;
+    /**
+     * Whether to show the loading text
+     */
+    showLabel?: boolean;
+    /**
+     * Custom loading text
+     */
+    loadingText?: string;
+}
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLDivElement>>;
+export interface LoadingOverlayProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether the overlay is visible
+     */
+    visible: boolean;
+    /**
+     * Loading message to display
+     */
+    message?: string;
+    /**
+     * Spinner size
+     */
+    spinnerSize?: VariantProps<typeof spinnerVariants>["size"];
+    /**
+     * Background opacity
+     */
+    opacity?: "light" | "medium" | "heavy";
+}
+declare const LoadingOverlay: React.ForwardRefExoticComponent<LoadingOverlayProps & React.RefAttributes<HTMLDivElement>>;
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Width of the skeleton
+     */
+    width?: string | number;
+    /**
+     * Height of the skeleton
+     */
+    height?: string | number;
+    /**
+     * Border radius variant
+     */
+    radius?: "none" | "sm" | "md" | "lg" | "full";
+    /**
+     * Whether to animate the skeleton
+     */
+    animate?: boolean;
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface PulseProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Color variant
+     */
+    variant?: "default" | "primary" | "success" | "warning" | "error";
+    /**
+     * Size of the pulse dot
+     */
+    size?: "sm" | "md" | "lg";
+}
+declare const Pulse: React.ForwardRefExoticComponent<PulseProps & React.RefAttributes<HTMLDivElement>>;
+export interface ProgressDotsProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Total number of dots
+     */
+    total: number;
+    /**
+     * Current active dot (0-indexed)
+     */
+    current: number;
+    /**
+     * Size of the dots
+     */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Whether to animate the transition
+     */
+    animate?: boolean;
+}
+declare const ProgressDots: React.ForwardRefExoticComponent<ProgressDotsProps & React.RefAttributes<HTMLDivElement>>;
+export { Spinner, LoadingOverlay, Skeleton, Pulse, ProgressDots, spinnerVariants };
+export type { SpinnerProps, LoadingOverlayProps, SkeletonProps, PulseProps, ProgressDotsProps };

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

@@ -0,0 +1,82 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const tagVariants: (props?: ({
+    intent?: "success" | "warning" | "neutral" | "brand" | "destructive" | null | undefined;
+    appearance?: "solid" | "subtle" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    closable?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TagProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onClick">, VariantProps<typeof tagVariants> {
+    /**
+     * Content of the tag
+     */
+    children: React.ReactNode;
+    /**
+     * Whether the tag can be closed/removed
+     */
+    closable?: boolean;
+    /**
+     * Callback when the close button is clicked
+     */
+    onClose?: () => void;
+    /**
+     * Whether the tag is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Callback when the tag itself is clicked (not the close button)
+     */
+    onClick?: () => void;
+    /**
+     * Whether the tag is clickable/interactive
+     */
+    interactive?: boolean;
+}
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLDivElement>>;
+export interface TagGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Array of tag data
+     */
+    tags: Array<{
+        id: string;
+        label: string;
+        intent?: TagProps["intent"];
+        appearance?: TagProps["appearance"];
+        disabled?: boolean;
+    }>;
+    /**
+     * Callback when a tag is removed
+     */
+    onTagRemove?: (tagId: string) => void;
+    /**
+     * Callback when a tag is clicked
+     */
+    onTagClick?: (tagId: string) => void;
+    /**
+     * Whether tags are closable by default
+     */
+    closable?: boolean;
+    /**
+     * Whether tags are interactive by default
+     */
+    interactive?: boolean;
+    /**
+     * Default size for all tags
+     */
+    size?: TagProps["size"];
+    /**
+     * Default intent for all tags
+     */
+    intent?: TagProps["intent"];
+    /**
+     * Default appearance for all tags
+     */
+    appearance?: TagProps["appearance"];
+    /**
+     * Maximum number of tags to show before collapsing
+     */
+    maxVisible?: number;
+}
+declare const TagGroup: React.ForwardRefExoticComponent<TagGroupProps & React.RefAttributes<HTMLDivElement>>;
+export { Tag, TagGroup, tagVariants };
+export type { TagProps, TagGroupProps };