@rafal.lemieszewski/tide-ui 0.1.0

package/README.md

@@ -0,0 +1,141 @@
+# Tide UI
+
+A comprehensive React component library built with Tailwind CSS and Radix UI primitives, designed for internal company use with a focus on design consistency and developer experience.
+
+## Features
+
+- 🎨 **Design System First** - Built with semantic design tokens and CSS variables
+- ⚡ **Modern Stack** - React 18+, TypeScript, Tailwind CSS v4, Radix UI primitives  
+- 📦 **Tree Shakeable** - Import only the components you need
+- 🔧 **Developer Experience** - Full TypeScript support with comprehensive type definitions
+- 📚 **Interactive Documentation** - Storybook playground for all components
+- ♿ **Accessible** - Built on Radix UI primitives with accessibility in mind
+
+## Installation
+
+```bash
+npm install @rafal.lemieszewski/tide-ui
+```
+
+### Peer Dependencies
+
+Make sure you have React 18+ installed:
+
+```bash
+npm install react@>=18.0.0 react-dom@>=18.0.0
+```
+
+### Setup Tailwind CSS
+
+This library requires Tailwind CSS. Add the preset to your `tailwind.config.js`:
+
+```javascript
+module.exports = {
+  presets: [
+    // Add Tide UI preset here when available
+  ],
+  content: [
+    "./src/**/*.{js,ts,jsx,tsx}",
+    "./node_modules/@rafal.lemieszewski/tide-ui/**/*.{js,ts,jsx,tsx}",
+  ],
+  // ... rest of your config
+}
+```
+
+## Quick Start
+
+```typescript
+import { Button, Card, CardContent, Badge } from '@rafal.lemieszewski/tide-ui'
+
+function App() {
+  return (
+    <Card>
+      <CardContent>
+        <div className="flex items-center gap-4">
+          <Button>Get Started</Button>
+          <Badge intent="success">v0.1.0</Badge>
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
+```
+
+## Available Components
+
+### Core Components
+
+- **Button** - Versatile button component with multiple variants
+- **Badge** - Status indicators with intent-based styling
+- **Card** - Container component for content organization  
+- **Input** - Form input with consistent styling
+- **Label** - Accessible form labels
+- **Switch** - Toggle switch component
+- **Tabs** - Tab navigation with multiple sizes
+- **Toggle** - Toggle button component
+
+### Design Tokens
+
+Access design tokens for consistent theming:
+
+```typescript
+import { designTokens } from '@rafal.lemieszewski/tide-ui'
+
+// Use design tokens in your components
+const customStyles = {
+  backgroundColor: designTokens.colors.backgroundBrand,
+  padding: designTokens.spacing.md,
+  borderRadius: designTokens.sizing.sm,
+}
+```
+
+## Development
+
+This library is built using:
+
+- **Vite** - Fast build tool and development server
+- **Storybook** - Component documentation and playground
+- **TypeScript** - Type safety and better DX
+- **Tailwind CSS** - Utility-first CSS framework
+- **Radix UI** - Headless UI components
+
+### Available Scripts
+
+```bash
+# Development
+npm run dev              # Start development server
+npm run storybook        # Start Storybook
+
+# Building  
+npm run build:lib        # Build library for npm
+npm run build-storybook  # Build Storybook for deployment
+
+# Quality
+npm run lint             # Run ESLint
+```
+
+## Documentation
+
+- **Storybook**: [Component playground and documentation](https://tide-ui-storybook.vercel.app)
+- **Repository**: [GitHub repository](https://github.com/rafal-lemieszewski/tide-ui)
+
+## Browser Support
+
+Tide UI supports all modern browsers:
+
+- Chrome (latest)
+- Firefox (latest) 
+- Safari (latest)
+- Edge (latest)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+This is an internal library. For bugs and feature requests, please create an issue in the repository.
+
+---
+
+Built with ❤️ for internal company projects.

package/dist/components/index.d.ts

@@ -0,0 +1,48 @@
+export { Avatar, AvatarImage, AvatarFallback, avatarVariants, avatarFallbackVariants } from './ui/avatar';
+export type { AvatarProps, AvatarFallbackProps } from './ui/avatar';
+export { Badge } from './ui/badge';
+export type { BadgeProps } from './ui/badge';
+export { Button } from './ui/button';
+export type { ButtonProps } from './ui/button';
+export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from './ui/card';
+export { Checkbox, checkboxVariants } from './ui/checkbox';
+export { Input } from './ui/input';
+export type { InputProps } from './ui/input';
+export { Label } from './ui/label';
+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 { 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 { cn } from '../lib/utils';
+export declare const designTokens: {
+    readonly colors: {
+        readonly primary: "var(--color-surface-primary)";
+        readonly secondary: "var(--color-surface-secondary)";
+        readonly textPrimary: "var(--color-text-primary)";
+        readonly textSecondary: "var(--color-text-secondary)";
+        readonly textBrand: "var(--color-text-brand)";
+        readonly backgroundBrand: "var(--color-background-brand)";
+        readonly backgroundBrandSelected: "var(--color-background-brand-selected)";
+        readonly borderPrimary: "var(--color-border-primary-subtle)";
+        readonly borderBrand: "var(--color-border-brand)";
+        readonly borderFocus: "var(--color-border-focus)";
+    };
+    readonly spacing: {
+        readonly xsm: "var(--space-xsm)";
+        readonly sm: "var(--space-sm)";
+        readonly md: "var(--space-md)";
+        readonly lg: "var(--space-lg)";
+        readonly xlg: "var(--space-xlg)";
+    };
+    readonly sizing: {
+        readonly xsm: "var(--size-xsm)";
+        readonly sm: "var(--size-sm)";
+        readonly md: "var(--size-md)";
+        readonly lg: "var(--size-lg)";
+        readonly xlg: "var(--size-xlg)";
+    };
+};

package/dist/components/product/app-frame.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface AppFrameProps {
+    children: React.ReactNode;
+    breadcrumbs?: Array<{
+        label: string;
+        href?: string;
+    }>;
+}
+export declare function AppFrame({ children, breadcrumbs }: AppFrameProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

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

@@ -0,0 +1,22 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ 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";
+} & 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, };

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

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const alertVariants: (props?: ({
+    variant?: "success" | "warning" | "default" | "destructive" | "info" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+export interface AlertTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+}
+declare const AlertTitle: React.ForwardRefExoticComponent<AlertTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+export interface AlertDescriptionProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const AlertDescription: React.ForwardRefExoticComponent<AlertDescriptionProps & React.RefAttributes<HTMLDivElement>>;
+export { Alert, AlertTitle, AlertDescription, alertVariants };

package/dist/components/ui/aspect-ratio.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare const AspectRatio: import('react').ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & import('react').RefAttributes<HTMLDivElement>>;
+export { AspectRatio };

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

@@ -0,0 +1,21 @@
+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;
+    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;
+    shape?: "circle" | "rounded" | "square" | null | undefined;
+    variant?: "primary" | "secondary" | "accent" | "success" | "warning" | "error" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+interface AvatarFallbackProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>, VariantProps<typeof avatarFallbackVariants> {
+}
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback, avatarVariants, avatarFallbackVariants };
+export type { AvatarProps, AvatarFallbackProps };

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

@@ -0,0 +1,11 @@
+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;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLDivElement>>;
+export { Badge, badgeVariants };

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

@@ -0,0 +1,21 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ComponentType<{
+        className?: string;
+    }>;
+} & 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">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

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

@@ -0,0 +1,18 @@
+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;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    iconPosition?: "none" | "left" | "right" | "only" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    icon?: IconType;
+    dropdown?: boolean;
+    /** Whether the dropdown is currently open (for accessibility) */
+    dropdownOpen?: boolean;
+    /** Loading state - shows spinner and disables interaction */
+    loading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1,7 @@
+import { DayPickerProps } from 'react-day-picker';
+export type CalendarProps = DayPickerProps;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -0,0 +1,33 @@
+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"];
+};
+export type ChartType = "bar" | "horizontal-bar" | "line" | "scatter";
+export type ChartColorScheme = keyof typeof chartColorSchemes;
+export interface ChartDataPoint {
+    [key: string]: string | number;
+}
+export interface ChartConfig {
+    [key: string]: {
+        label: string;
+        color?: string;
+    };
+}
+export interface ChartProps {
+    type: ChartType;
+    data: ChartDataPoint[];
+    config: ChartConfig;
+    className?: string;
+    height?: number;
+    width?: number;
+    onDataPointClick?: (data: ChartDataPoint, index: number) => void;
+    onDataPointHover?: (data: ChartDataPoint | null, index?: number) => void;
+    highlightedIndex?: number;
+    showGrid?: boolean;
+    showLegend?: boolean;
+    showTooltip?: 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;

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

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const checkboxVariants: (props?: ({
+    variant?: "error" | "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof checkboxVariants> {
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox, checkboxVariants };

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

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare const Collapsible: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import('react').ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

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

@@ -0,0 +1,32 @@
+export interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    className?: string;
+    popoverClassName?: string;
+    triggerClassName?: string;
+}
+export declare function Combobox({ options, value, onValueChange, placeholder, searchPlaceholder, emptyMessage, disabled, className, popoverClassName, triggerClassName, }: ComboboxProps): import("react/jsx-runtime").JSX.Element;
+export interface MultiComboboxProps {
+    options: ComboboxOption[];
+    values?: string[];
+    onValuesChange?: (values: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    className?: string;
+    popoverClassName?: string;
+    triggerClassName?: string;
+    maxDisplayedItems?: number;
+}
+export declare function MultiCombobox({ options, values, onValuesChange, placeholder, searchPlaceholder, emptyMessage, disabled, className, popoverClassName, triggerClassName, maxDisplayedItems, }: MultiComboboxProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,82 @@
+import { DialogProps } from '@radix-ui/react-dialog';
+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;
+}, "key" | "asChild" | 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>>;
+interface CommandDialogProps extends DialogProps {
+}
+declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => import("react/jsx-runtime").JSX.Element;
+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;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    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;
+}, "key" | "asChild" | 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;
+}, "key" | "asChild" | 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;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "heading" | "value"> & {
+    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;
+}, "key" | "asChild" | 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;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "onSelect" | "disabled" | "value"> & {
+    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>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

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

@@ -0,0 +1,26 @@
+export interface Country {
+    name: string;
+    alpha2: string;
+    alpha3: string;
+    numeric: string;
+    emoji?: string;
+}
+export interface CountryDropdownProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    disabled?: boolean;
+    className?: string;
+    flagSize?: number;
+    showFlag?: boolean;
+    showCode?: boolean;
+    variant?: "default" | "slim";
+    priorityCountries?: string[];
+}
+export declare function CountryDropdown({ value, onValueChange, placeholder, searchPlaceholder, disabled, className, flagSize, showFlag, showCode, variant, priorityCountries, }: CountryDropdownProps): import("react/jsx-runtime").JSX.Element;
+export declare function useCountryData(): {
+    countries: Country[];
+    getCountryByCode: (code: string) => Country | undefined;
+    getCountryByName: (name: string) => Country | undefined;
+};

package/dist/components/ui/custom-icons.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export declare const customIcons: {
+    readonly "chart-bar": import("react/jsx-runtime").JSX.Element;
+    readonly "chart-line": import("react/jsx-runtime").JSX.Element;
+    readonly "chart-dashline": import("react/jsx-runtime").JSX.Element;
+    readonly "chart-dashline-2": import("react/jsx-runtime").JSX.Element;
+    readonly "chart-dotline": import("react/jsx-runtime").JSX.Element;
+    readonly "chart-dot": import("react/jsx-runtime").JSX.Element;
+    readonly dot: import("react/jsx-runtime").JSX.Element;
+    readonly "bubble-size": import("react/jsx-runtime").JSX.Element;
+    readonly "broken-scale": import("react/jsx-runtime").JSX.Element;
+    readonly "ship-unload": import("react/jsx-runtime").JSX.Element;
+    readonly "ship-load": import("react/jsx-runtime").JSX.Element;
+    readonly "star-full": import("react/jsx-runtime").JSX.Element;
+};
+export type CustomIconName = keyof typeof customIcons;
+export declare function addCustomIcon(name: string, iconElement: React.ReactNode): void;

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

@@ -0,0 +1,19 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ 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, };

package/dist/components/ui/drop-drawer.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropDrawer: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropDrawerTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropDrawerGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropDrawerSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropDrawerRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    destructive?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropDrawerShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropDrawer, DropDrawerTrigger, DropDrawerContent, DropDrawerItem, DropDrawerCheckboxItem, DropDrawerRadioItem, DropDrawerLabel, DropDrawerSeparator, DropDrawerShortcut, DropDrawerGroup, DropDrawerPortal, DropDrawerSub, DropDrawerSubContent, DropDrawerSubTrigger, DropDrawerRadioGroup, };