@wakastellar/ui 3.5.2 → 4.0.0

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

@@ -0,0 +1,46 @@
+import * as React from "react";
+/**
+ * Props for the {@link Card} container surface.
+ *
+ * Forwards all native `<div>` attributes (`onClick`, `aria-*`, `data-*`,
+ * `style`, …) to the underlying element.
+ */
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Additional CSS classes merged via `cn()` with the default Card styles. */
+    className?: string;
+}
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Props for {@link CardHeader}, {@link CardContent} and {@link CardFooter}.
+ *
+ * Forwards all native `<div>` attributes; only `className` is layered on top
+ * of the default spacing/typography styles.
+ */
+export interface CardSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Additional CSS classes merged via `cn()` with the section default styles. */
+    className?: string;
+}
+declare const CardHeader: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Props for {@link CardTitle} (rendered as `<h3>`).
+ *
+ * Forwards all native heading attributes (`id`, `aria-*`, `data-*`, …).
+ */
+export interface CardTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    /** Additional CSS classes merged via `cn()` with the default title styles. */
+    className?: string;
+}
+declare const CardTitle: React.ForwardRefExoticComponent<CardTitleProps & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Props for {@link CardDescription} (rendered as `<p>`).
+ *
+ * Forwards all native paragraph attributes.
+ */
+export interface CardDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    /** Additional CSS classes merged via `cn()` with the default description styles. */
+    className?: string;
+}
+declare const CardDescription: React.ForwardRefExoticComponent<CardDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -0,0 +1,49 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import 'prismjs/components/prism-typescript';
+import 'prismjs/components/prism-javascript';
+import 'prismjs/components/prism-jsx';
+import 'prismjs/components/prism-tsx';
+import 'prismjs/components/prism-css';
+import 'prismjs/components/prism-scss';
+import 'prismjs/components/prism-json';
+import 'prismjs/components/prism-bash';
+import 'prismjs/components/prism-python';
+import 'prismjs/components/prism-java';
+import 'prismjs/components/prism-csharp';
+import 'prismjs/components/prism-php';
+import 'prismjs/components/prism-ruby';
+import 'prismjs/components/prism-go';
+import 'prismjs/components/prism-rust';
+import 'prismjs/components/prism-sql';
+import 'prismjs/components/prism-markdown';
+import 'prismjs/components/prism-yaml';
+import 'prismjs/components/prism-docker';
+import 'prismjs/components/prism-git';
+declare const codeVariants: (props?: {
+    variant?: "inline" | "block";
+    size?: "sm" | "lg" | "base";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface CodeProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof codeVariants> {
+    language?: string;
+    showLineNumbers?: boolean;
+    maxHeight?: string | number;
+    copyable?: boolean;
+    filename?: string;
+    theme?: 'light' | 'dark' | 'auto';
+}
+/**
+ * Code - Composant de code avec coloration syntaxique et responsivité complète
+ *
+ * @example
+ * ```tsx
+ * <Code>const hello = "world"</Code>
+ * <Code variant="block" language="typescript" copyable>
+ *   function greet(name: string) {
+ *     return `Hello, ${name}!`
+ *   }
+ * </Code>
+ * ```
+ */
+declare const Code: React.ForwardRefExoticComponent<CodeProps & React.RefAttributes<HTMLElement>>;
+export { Code, codeVariants };

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

@@ -0,0 +1,83 @@
+import * as React from "react";
+import { type DialogProps } from "@radix-ui/react-dialog";
+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 {
+    children?: React.ReactNode;
+}
+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>>, "value" | "onChange" | "type"> & {
+    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>>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "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>>, "value" | "onSelect" | "disabled"> & {
+    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/error-boundary/ErrorBoundary.d.ts

@@ -0,0 +1,102 @@
+import * as React from "react";
+import { WakaError, ErrorCodeType } from "../../utils/error-handling";
+/**
+ * Props for the error fallback component
+ */
+export interface ErrorFallbackProps {
+    /** The error that was caught */
+    error: WakaError;
+    /** Function to reset the error boundary */
+    resetErrorBoundary: () => void;
+    /** Component name where error occurred */
+    componentName?: string;
+}
+/**
+ * Props for ErrorBoundary component
+ */
+export interface ErrorBoundaryProps {
+    /** Children to render */
+    children: React.ReactNode;
+    /** Custom fallback component */
+    fallback?: React.ReactNode | ((props: ErrorFallbackProps) => React.ReactNode);
+    /** Callback when error is caught */
+    onError?: (error: WakaError, errorInfo: React.ErrorInfo) => void;
+    /** Callback when boundary is reset */
+    onReset?: () => void;
+    /** Reset keys - boundary resets when these change */
+    resetKeys?: unknown[];
+    /** Component name for error context */
+    componentName?: string;
+    /** Error code to use for caught errors */
+    errorCode?: ErrorCodeType;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * State for ErrorBoundary
+ */
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: WakaError | null;
+}
+/**
+ * Error Boundary component for catching and handling React errors
+ *
+ * @example
+ * ```tsx
+ * <ErrorBoundary
+ *   componentName="DataTable"
+ *   onError={(error) => reportError(error)}
+ *   fallback={<CustomErrorUI />}
+ * >
+ *   <DataTable data={data} columns={columns} />
+ * </ErrorBoundary>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With reset keys
+ * <ErrorBoundary resetKeys={[userId, tableId]}>
+ *   <UserTable userId={userId} />
+ * </ErrorBoundary>
+ * ```
+ */
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    reset: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element;
+}
+/**
+ * Hook to create an error boundary reset function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const resetBoundary = useErrorBoundaryReset()
+ *
+ *   const handleRetry = () => {
+ *     // Clear local state
+ *     setState(initialState)
+ *     // Reset error boundary
+ *     resetBoundary()
+ *   }
+ * }
+ * ```
+ */
+export declare function useErrorBoundaryReset(): () => void;
+/**
+ * Higher-order component to wrap a component with ErrorBoundary
+ *
+ * @example
+ * ```tsx
+ * const SafeDataTable = withErrorBoundary(DataTable, {
+ *   componentName: 'DataTable',
+ *   onError: reportError,
+ * })
+ * ```
+ */
+export declare function withErrorBoundary<P extends object>(Component: React.ComponentType<P>, errorBoundaryProps: Omit<ErrorBoundaryProps, "children">): React.FC<P>;
+export {};

package/dist/components/error-boundary/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorBoundary, withErrorBoundary, useErrorBoundaryReset, } from "./ErrorBoundary";
+export type { ErrorBoundaryProps, ErrorFallbackProps } from "./ErrorBoundary";

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

@@ -0,0 +1,23 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { ControllerProps, FieldPath, FieldValues } from "react-hook-form";
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => import("react/jsx-runtime").JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-slot").SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

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

@@ -0,0 +1,19 @@
+import * as React from "react";
+/**
+ * Props for the {@link Input} field.
+ *
+ * Forwards every native `<input>` attribute (`type`, `value`, `onChange`,
+ * `placeholder`, `disabled`, `required`, `aria-*`, `data-*`, …) to the
+ * underlying element.
+ */
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    /** Additional CSS classes merged via `cn()` with the default Input styles. */
+    className?: string;
+    /**
+     * Native input type. Defaults to `"text"`. Common values: `"email"`,
+     * `"password"`, `"number"`, `"search"`, `"tel"`, `"url"`, `"file"`.
+     */
+    type?: React.HTMLInputTypeAttribute;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { type VariantProps } from "class-variance-authority";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/components/navigation-menu/index.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
+declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: typeof NavigationMenuPrimitive.Item;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp) => string;
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: typeof NavigationMenuPrimitive.Link;
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { navigationMenuTriggerStyle, NavigationMenu, NavigationMenuList, NavigationMenuItem, NavigationMenuContent, NavigationMenuTrigger, NavigationMenuLink, NavigationMenuIndicator, NavigationMenuViewport, };

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

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import { type VariantProps } from "class-variance-authority";
+declare const Sheet: typeof SheetPrimitive.Root;
+declare const SheetTrigger: typeof SheetPrimitive.Trigger;
+declare const SheetClose: typeof SheetPrimitive.Close;
+declare const SheetPortal: typeof SheetPrimitive.Portal;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: {
+    side?: "left" | "right" | "top" | "bottom";
+} & import("class-variance-authority/types").ClassProp) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+    className?: string;
+    children?: React.ReactNode;
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

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

@@ -0,0 +1,13 @@
+/**
+ * Props for the {@link Skeleton} loading placeholder.
+ *
+ * Forwards all native `<div>` attributes — typically used to size the
+ * placeholder (`className="h-4 w-32"`) or attach `aria-*` hints
+ * (`role="status"`, `aria-label="Loading"`).
+ */
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Additional CSS classes merged via `cn()` with the default Skeleton styles. */
+    className?: string;
+}
+declare function Skeleton({ className, ...props }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

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

@@ -0,0 +1,21 @@
+import * as React from "react";
+/**
+ * Props for the {@link Table} root element.
+ *
+ * Forwards all native `<table>` attributes. The component wraps the
+ * `<table>` in a scrollable container so wide tables remain usable on
+ * narrow viewports.
+ */
+export interface TableProps extends React.HTMLAttributes<HTMLTableElement> {
+    /** Additional CSS classes merged via `cn()` with the default Table styles. */
+    className?: string;
+}
+declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+/**
+ * Props for the {@link Textarea} field.
+ *
+ * Forwards every native `<textarea>` attribute (`value`, `onChange`,
+ * `placeholder`, `rows`, `cols`, `disabled`, `required`, `aria-*`,
+ * `data-*`, …) to the underlying element.
+ */
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Additional CSS classes merged via `cn()` with the default Textarea styles. */
+    className?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { type VariantProps } from "class-variance-authority";
+declare const ToastProvider: typeof ToastPrimitives.Provider;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "destructive";
+} & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

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

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

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

@@ -0,0 +1,85 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const textVariants: (props?: {
+    variant?: "default" | "link" | "destructive" | "muted" | "warning" | "success";
+    size?: "sm" | "lg" | "xl" | "base" | "xs";
+    weight?: "medium" | "bold" | "normal" | "semibold";
+    align?: "left" | "center" | "right" | "justify";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface TextProps extends React.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof textVariants> {
+    asChild?: boolean;
+    truncate?: boolean;
+}
+/**
+ * Text - Composant de texte avec variantes de style
+ *
+ * @example
+ * ```tsx
+ * <Text variant="muted" size="sm">Texte secondaire</Text>
+ * <Text variant="destructive" weight="bold">Erreur importante</Text>
+ * ```
+ */
+declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const headingVariants: (props?: {
+    level?: "h3" | "h2" | "h1" | "h4" | "h5" | "h6";
+    variant?: "default" | "gradient" | "muted";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
+    asChild?: boolean;
+}
+/**
+ * Heading - Composant de titre avec niveaux sémantiques
+ *
+ * @example
+ * ```tsx
+ * <Heading level="h1">Titre principal</Heading>
+ * <Heading level="h2" variant="gradient">Sous-titre avec gradient</Heading>
+ * ```
+ */
+declare const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const blockquoteVariants: (props?: {
+    variant?: "default" | "destructive" | "warning" | "success" | "primary";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface BlockquoteProps extends React.BlockquoteHTMLAttributes<HTMLQuoteElement>, VariantProps<typeof blockquoteVariants> {
+    cite?: string;
+    author?: string;
+}
+/**
+ * Blockquote - Citation avec bordure et style
+ *
+ * @example
+ * ```tsx
+ * <Blockquote author="Oscar Wilde">
+ *   Soyez vous-même, tous les autres sont déjà pris.
+ * </Blockquote>
+ * ```
+ */
+declare const Blockquote: React.ForwardRefExoticComponent<BlockquoteProps & React.RefAttributes<HTMLQuoteElement>>;
+declare const codeVariants: (props?: {
+    variant?: "inline" | "block";
+    size?: "sm" | "lg" | "base";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface CodeProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof codeVariants> {
+    language?: string;
+    showLineNumbers?: boolean;
+    maxHeight?: string | number;
+    copyable?: boolean;
+    filename?: string;
+}
+declare const kbdVariants: (props?: {
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface KbdProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof kbdVariants> {
+}
+/**
+ * Kbd - Affichage de touches clavier
+ *
+ * @example
+ * ```tsx
+ * <Kbd>Ctrl</Kbd> + <Kbd>C</Kbd>
+ * <Kbd size="lg">⌘ Command</Kbd>
+ * ```
+ */
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+export { Text, Heading, Blockquote, Kbd };
+export { textVariants, headingVariants, blockquoteVariants, kbdVariants };

package/dist/components/waka-3d-pie-chart/index.d.ts

@@ -0,0 +1,67 @@
+import * as React from "react";
+export interface PieSlice {
+    /** Unique identifier */
+    id: string;
+    /** Label for the slice */
+    label: string;
+    /** Value */
+    value: number;
+    /** Custom color */
+    color?: string;
+}
+export interface Waka3DPieChartProps {
+    /** Data slices */
+    data: PieSlice[];
+    /** Size of the chart in pixels */
+    size?: number;
+    /** 3D depth in pixels */
+    depth?: number;
+    /** Initial rotation angle in degrees */
+    rotation?: number;
+    /** Enable rotation on hover */
+    rotateOnHover?: boolean;
+    /** Rotation amount on hover (degrees) */
+    hoverRotation?: number;
+    /** Enable slice explosion on click */
+    explodeOnClick?: boolean;
+    /** Explosion distance in pixels */
+    explodeDistance?: number;
+    /** Show tooltips */
+    showTooltip?: boolean;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Legend position */
+    legendPosition?: "right" | "bottom";
+    /** Show values in legend */
+    showValues?: boolean;
+    /** Show percentages */
+    showPercentages?: boolean;
+    /** Inner radius for donut chart (0 for pie) */
+    innerRadius?: number;
+    /** Custom className */
+    className?: string;
+    /** Callback when slice is clicked */
+    onSliceClick?: (slice: PieSlice, index: number) => void;
+}
+export declare function use3DPieChart(): {
+    explodedSlice: string;
+    hoveredSlice: string;
+    setExplodedSlice: React.Dispatch<React.SetStateAction<string>>;
+    setHoveredSlice: React.Dispatch<React.SetStateAction<string>>;
+    toggleExplode: (sliceId: string) => void;
+    reset: () => void;
+};
+export declare function Waka3DPieChart({ data, size, depth, rotation, rotateOnHover, hoverRotation, explodeOnClick, explodeDistance, showTooltip, showLegend, legendPosition, showValues, showPercentages, innerRadius, className, onSliceClick, }: Waka3DPieChartProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPieChartProps extends Omit<Waka3DPieChartProps, "depth" | "rotateOnHover" | "hoverRotation"> {
+    /** Animate on hover */
+    animateOnHover?: boolean;
+}
+export declare function WakaPieChart({ animateOnHover, ...props }: WakaPieChartProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaDonutChartProps extends Waka3DPieChartProps {
+    /** Thickness of the donut ring (percentage of radius) */
+    thickness?: number;
+    /** Content to display in center */
+    centerContent?: React.ReactNode;
+}
+export declare function WakaDonutChart({ thickness, size, centerContent, ...props }: WakaDonutChartProps): import("react/jsx-runtime").JSX.Element;
+export default Waka3DPieChart;