@wakastellar/ui 3.5.2 → 4.0.0

package/dist/components/waka-success-explosion/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export interface WakaSuccessExplosionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Trigger the explosion animation */
+    trigger?: boolean;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Number of confetti particles */
+    particleCount?: number;
+    /** Duration of the animation in ms */
+    duration?: number;
+    /** Size of the explosion area */
+    size?: "sm" | "md" | "lg" | "xl";
+    /** Primary color for particles (CSS color or Tailwind class) */
+    primaryColor?: string;
+    /** Secondary color for particles (CSS color or Tailwind class) */
+    secondaryColor?: string;
+    /** Accent color for particles (CSS color or Tailwind class) */
+    accentColor?: string;
+    /** Show the checkmark animation */
+    showCheckmark?: boolean;
+    /** Checkmark color */
+    checkmarkColor?: string;
+    /** Auto-hide after animation completes */
+    autoHide?: boolean;
+}
+export interface WakaSuccessExplosionRef {
+    /** Trigger the explosion animation */
+    explode: () => void;
+    /** Reset the component to its initial state */
+    reset: () => void;
+}
+export declare const WakaSuccessExplosion: React.ForwardRefExoticComponent<WakaSuccessExplosionProps & React.RefAttributes<WakaSuccessExplosionRef>>;
+export interface UseSuccessExplosionOptions {
+    particleCount?: number;
+    duration?: number;
+    size?: WakaSuccessExplosionProps["size"];
+    primaryColor?: string;
+    secondaryColor?: string;
+    accentColor?: string;
+    showCheckmark?: boolean;
+    checkmarkColor?: string;
+    autoHide?: boolean;
+    onComplete?: () => void;
+}
+export declare function useSuccessExplosion(options?: UseSuccessExplosionOptions): {
+    ref: React.MutableRefObject<WakaSuccessExplosionRef>;
+    isExploding: boolean;
+    explode: () => void;
+    reset: () => void;
+    ExplosionComponent: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/waka-swipe-card/index.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type SwipeDirection = "left" | "right" | "up" | "down";
+export interface SwipeCardData {
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface WakaSwipeCardProps<T extends SwipeCardData> extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof swipeCardVariants> {
+    /** Array of card data to display */
+    cards: T[];
+    /** Render function for each card */
+    renderCard: (card: T, index: number) => React.ReactNode;
+    /** Called when a card is swiped */
+    onSwipe?: (card: T, direction: SwipeDirection) => void;
+    /** Called when swiping starts */
+    onSwipeStart?: (card: T, direction: SwipeDirection) => void;
+    /** Called during swipe with progress (0-1) */
+    onSwipeProgress?: (card: T, direction: SwipeDirection, progress: number) => void;
+    /** Threshold to trigger swipe (0-1, default 0.3) */
+    swipeThreshold?: number;
+    /** Enable/disable specific swipe directions */
+    allowedDirections?: SwipeDirection[];
+    /** Show overlay indicators during swipe */
+    showOverlay?: boolean;
+    /** Custom overlay content for each direction */
+    overlayContent?: Partial<Record<SwipeDirection, React.ReactNode>>;
+    /** Number of visible cards in stack */
+    stackSize?: number;
+    /** Scale factor for stacked cards */
+    stackScale?: number;
+    /** Vertical offset for stacked cards */
+    stackOffset?: number;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Enable haptic feedback (if available) */
+    hapticFeedback?: boolean;
+    /** Disable interactions */
+    disabled?: boolean;
+    /** Called when all cards are swiped */
+    onEmpty?: () => void;
+}
+export interface WakaSwipeCardRef {
+    swipe: (direction: SwipeDirection) => void;
+    rewind: () => void;
+    getCurrentCard: () => SwipeCardData | null;
+}
+declare const swipeCardVariants: (props?: {
+    size?: "default" | "sm" | "lg" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaSwipeCard: <T extends SwipeCardData>(props: WakaSwipeCardProps<T> & {
+    ref?: React.ForwardedRef<WakaSwipeCardRef>;
+}) => React.ReactElement;
+export interface WakaSwipeCardActionsProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Reference to the SwipeCard component */
+    swipeCardRef: React.RefObject<WakaSwipeCardRef>;
+    /** Show rewind button */
+    showRewind?: boolean;
+    /** Allowed directions to show buttons for */
+    directions?: SwipeDirection[];
+    /** Button size */
+    size?: "sm" | "default" | "lg";
+}
+export declare function WakaSwipeCardActions({ swipeCardRef, showRewind, directions, size, className, ...props }: WakaSwipeCardActionsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/waka-tabs-morph/index.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+export interface TabItem {
+    /** Unique identifier */
+    id: string;
+    /** Tab label */
+    label: string;
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** Badge content (number or text) */
+    badge?: number | string;
+    /** Disable the tab */
+    disabled?: boolean;
+    /** Tab content (for controlled usage) */
+    content?: React.ReactNode;
+}
+export interface WakaTabsMorphProps {
+    /** Tab items */
+    tabs: TabItem[];
+    /** Currently active tab id */
+    activeTab?: string;
+    /** Default active tab id */
+    defaultTab?: string;
+    /** Callback when tab changes */
+    onChange?: (tabId: string) => void;
+    /** Orientation */
+    orientation?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Style variant */
+    variant?: "default" | "pills" | "underline" | "enclosed";
+    /** Full width tabs */
+    fullWidth?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Custom className for the tab list */
+    className?: string;
+    /** Custom className for the tab content */
+    contentClassName?: string;
+    /** Render function for tab content */
+    renderContent?: (tab: TabItem) => React.ReactNode;
+}
+export declare function WakaTabsMorph({ tabs, activeTab, defaultTab, onChange, orientation, size, variant, fullWidth, animationDuration, className, contentClassName, renderContent, }: WakaTabsMorphProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTabs(tabs: TabItem[], initialTab?: string): {
+    activeTab: string;
+    activeTabData: TabItem;
+    setActiveTab: React.Dispatch<React.SetStateAction<string>>;
+    goToTab: (tabId: string) => void;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    goToFirst: () => void;
+    goToLast: () => void;
+};
+export interface WakaTabPanelProps {
+    /** Tab id this panel corresponds to */
+    tabId: string;
+    /** Current active tab id */
+    activeTab: string;
+    /** Panel content */
+    children: React.ReactNode;
+    /** Keep panel mounted when not active */
+    keepMounted?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaTabPanel({ tabId, activeTab, children, keepMounted, className, }: WakaTabPanelProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTabsMorph;

package/dist/components/waka-tag-input/index.d.ts

@@ -0,0 +1,134 @@
+import * as React from "react";
+export interface Tag {
+    /** Unique identifier */
+    id: string;
+    /** Display value */
+    value: string;
+    /** Optional category for color-coding */
+    category?: string;
+    /** Custom color override */
+    color?: string;
+}
+export interface TagCategory {
+    /** Category name */
+    name: string;
+    /** Background color */
+    bgColor: string;
+    /** Text color */
+    textColor: string;
+    /** Border color (optional) */
+    borderColor?: string;
+}
+export interface TagSuggestion {
+    /** Suggestion value */
+    value: string;
+    /** Category (optional) */
+    category?: string;
+    /** Description (optional) */
+    description?: string;
+}
+export interface WakaTagInputProps {
+    /** Current tags */
+    tags: Tag[];
+    /** Callback when tags change */
+    onChange: (tags: Tag[]) => void;
+    /** Autocomplete suggestions */
+    suggestions?: TagSuggestion[];
+    /** Async suggestions loader */
+    onSuggestionsLoad?: (query: string) => Promise<TagSuggestion[]>;
+    /** Callback when a new tag is created */
+    onTagCreate?: (value: string) => void;
+    /** Maximum number of tags allowed */
+    maxTags?: number;
+    /** Allow duplicate tags */
+    allowDuplicates?: boolean;
+    /** Tag validation regex pattern */
+    validationPattern?: RegExp;
+    /** Validation error message */
+    validationMessage?: string;
+    /** Category color mapping */
+    categories?: Record<string, TagCategory>;
+    /** Allow drag to reorder */
+    draggable?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Error message */
+    errorMessage?: string;
+    /** Delimiters to trigger tag creation (default: Enter, comma) */
+    delimiters?: string[];
+    /** Minimum tag length */
+    minLength?: number;
+    /** Maximum tag length */
+    maxLength?: number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Input ID for accessibility */
+    id?: string;
+    /** Input name for forms */
+    name?: string;
+}
+declare const defaultCategories: Record<string, TagCategory>;
+interface TagChipProps {
+    tag: Tag;
+    category?: TagCategory;
+    onRemove: () => void;
+    draggable?: boolean;
+    disabled?: boolean;
+    onDragStart?: (e: React.DragEvent) => void;
+    onDragEnd?: (e: React.DragEvent) => void;
+    onDragOver?: (e: React.DragEvent) => void;
+    onDrop?: (e: React.DragEvent) => void;
+    isDragging?: boolean;
+    isDragOver?: boolean;
+}
+declare function TagChip({ tag, category, onRemove, draggable, disabled, onDragStart, onDragEnd, onDragOver, onDrop, isDragging, isDragOver, }: TagChipProps): import("react/jsx-runtime").JSX.Element;
+interface SuggestionDropdownProps {
+    suggestions: TagSuggestion[];
+    query: string;
+    selectedIndex: number;
+    onSelect: (suggestion: TagSuggestion) => void;
+    categories?: Record<string, TagCategory>;
+    visible: boolean;
+}
+declare function SuggestionDropdown({ suggestions, query, selectedIndex, onSelect, categories, visible, }: SuggestionDropdownProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaTagInput({ tags, onChange, suggestions: staticSuggestions, onSuggestionsLoad, onTagCreate, maxTags, allowDuplicates, validationPattern, validationMessage, categories, draggable, placeholder, disabled, error, errorMessage, delimiters, minLength, maxLength, className, id, name, }: WakaTagInputProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaTagInput {
+    var displayName: string;
+}
+export interface UseTagInputOptions {
+    /** Initial tags */
+    initialTags?: Tag[];
+    /** Maximum tags */
+    maxTags?: number;
+    /** Allow duplicates */
+    allowDuplicates?: boolean;
+    /** Validation pattern */
+    validationPattern?: RegExp;
+    /** Callback when tags change */
+    onTagsChange?: (tags: Tag[]) => void;
+}
+export declare function useTagInput(options?: UseTagInputOptions): {
+    tags: Tag[];
+    setTags: (newTags: Tag[]) => void;
+    addTag: (value: string, category?: string) => boolean;
+    addTags: (values: string[], category?: string) => number;
+    removeTag: (tagId: string) => void;
+    removeTagByValue: (value: string) => void;
+    clearTags: () => void;
+    hasTag: (value: string) => boolean;
+    getTag: (tagId: string) => Tag | undefined;
+    reorderTags: (fromIndex: number, toIndex: number) => void;
+    updateTagCategory: (tagId: string, category?: string) => void;
+    getTagsByCategory: (category: string) => Tag[];
+    values: string[];
+    count: number;
+    isEmpty: boolean;
+    isFull: boolean;
+};
+export type { TagChipProps, SuggestionDropdownProps };
+export { TagChip, SuggestionDropdown, defaultCategories };
+export default WakaTagInput;

package/dist/components/waka-theme-manager/index.d.ts

@@ -0,0 +1,62 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const themeManagerVariants: (props?: {
+    size?: "sm" | "lg" | "base" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface TweakCNTheme {
+    name: string;
+    description?: string;
+    author?: string;
+    version?: string;
+    colors: {
+        background: string;
+        foreground: string;
+        card: string;
+        cardForeground: string;
+        popover: string;
+        popoverForeground: string;
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        muted: string;
+        mutedForeground: string;
+        accent: string;
+        accentForeground: string;
+        destructive: string;
+        destructiveForeground: string;
+        border: string;
+        input: string;
+        ring: string;
+        chart1?: string;
+        chart2?: string;
+        chart3?: string;
+        chart4?: string;
+        chart5?: string;
+    };
+}
+export interface WakaThemeManagerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof themeManagerVariants> {
+    onThemeChange?: (theme: TweakCNTheme) => void;
+    onThemeLoad?: (theme: TweakCNTheme) => void;
+    onThemeSave?: (theme: TweakCNTheme) => void;
+    initialTheme?: TweakCNTheme;
+    showPreview?: boolean;
+    showExport?: boolean;
+    showImport?: boolean;
+    allowCustomColors?: boolean;
+}
+/**
+ * WakaThemeManager - Gestionnaire complet de thèmes TweakCN
+ *
+ * @example
+ * ```tsx
+ * <WakaThemeManager
+ *   onThemeChange={(theme) => console.log('Theme changed:', theme)}
+ *   showPreview={true}
+ *   showExport={true}
+ *   showImport={true}
+ * />
+ * ```
+ */
+declare const WakaThemeManager: React.ForwardRefExoticComponent<WakaThemeManagerProps & React.RefAttributes<HTMLDivElement>>;
+export { WakaThemeManager, themeManagerVariants };

package/dist/components/waka-tooltip-tour/index.d.ts

@@ -0,0 +1,123 @@
+import * as React from "react";
+export type TooltipPlacement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+export interface TourStep {
+    /** Unique identifier for the step */
+    id: string;
+    /** CSS selector or ref for the target element */
+    target: string | React.RefObject<HTMLElement>;
+    /** Title of the tooltip */
+    title: string;
+    /** Description/content of the tooltip */
+    content: React.ReactNode;
+    /** Preferred placement of the tooltip */
+    placement?: TooltipPlacement;
+    /** Custom action button text */
+    actionText?: string;
+    /** Custom action callback */
+    onAction?: () => void;
+    /** Whether to highlight the target element */
+    highlight?: boolean;
+    /** Custom spotlight padding around target */
+    spotlightPadding?: number;
+    /** Disable interaction with target during this step */
+    disableInteraction?: boolean;
+}
+export interface WakaTooltipTourProps {
+    /** Unique tour identifier for persistence */
+    tourId: string;
+    /** Array of tour steps */
+    steps: TourStep[];
+    /** Whether the tour is active */
+    isActive: boolean;
+    /** Callback when tour state changes */
+    onActiveChange?: (active: boolean) => void;
+    /** Callback when tour completes */
+    onComplete?: () => void;
+    /** Callback when tour is skipped */
+    onSkip?: () => void;
+    /** Callback when step changes */
+    onStepChange?: (stepIndex: number) => void;
+    /** Starting step index */
+    startAt?: number;
+    /** Auto-advance to next step after delay (ms) */
+    autoAdvance?: number;
+    /** Show skip button */
+    showSkip?: boolean;
+    /** Show step counter */
+    showProgress?: boolean;
+    /** Show navigation arrows */
+    showNavigation?: boolean;
+    /** Persist completed tours in localStorage */
+    persistCompletion?: boolean;
+    /** Custom class for tooltip */
+    className?: string;
+    /** Custom class for overlay */
+    overlayClassName?: string;
+    /** Scroll to target element */
+    scrollToTarget?: boolean;
+    /** Scroll behavior options */
+    scrollBehavior?: ScrollBehavior;
+    /** Close on overlay click */
+    closeOnOverlayClick?: boolean;
+    /** Close on escape key */
+    closeOnEscape?: boolean;
+    /** Skip button text */
+    skipText?: string;
+    /** Next button text */
+    nextText?: string;
+    /** Previous button text */
+    prevText?: string;
+    /** Finish button text */
+    finishText?: string;
+}
+export interface UseTooltipTourOptions {
+    /** Unique tour identifier */
+    tourId: string;
+    /** Persist completion state */
+    persistCompletion?: boolean;
+    /** Auto-start tour if not completed */
+    autoStart?: boolean;
+    /** Delay before auto-start (ms) */
+    autoStartDelay?: number;
+}
+export interface UseTooltipTourReturn {
+    /** Whether tour is currently active */
+    isActive: boolean;
+    /** Current step index */
+    currentStep: number;
+    /** Start the tour */
+    start: (fromStep?: number) => void;
+    /** Stop the tour */
+    stop: () => void;
+    /** Go to next step */
+    next: () => void;
+    /** Go to previous step */
+    prev: () => void;
+    /** Go to specific step */
+    goTo: (stepIndex: number) => void;
+    /** Complete the tour */
+    complete: () => void;
+    /** Skip the tour */
+    skip: () => void;
+    /** Reset the tour (clear persistence) */
+    reset: () => void;
+    /** Whether tour has been completed before */
+    hasCompleted: boolean;
+    /** Props to spread on WakaTooltipTour */
+    tourProps: {
+        isActive: boolean;
+        onActiveChange: (active: boolean) => void;
+        onComplete: () => void;
+        onSkip: () => void;
+        onStepChange: (stepIndex: number) => void;
+        startAt: number;
+    };
+}
+export declare function useTooltipTour({ tourId, persistCompletion, autoStart, autoStartDelay, }: UseTooltipTourOptions): UseTooltipTourReturn;
+/**
+ * @deprecated Since v3.6 — will be removed in v4.0.
+ * Use `WakaTour` compound (with `Tour.Step`, `Tour.Tooltip`) instead (futur).
+ * See `docs/audit/remove-relocate.md` §2.4.
+ */
+export declare function WakaTooltipTour({ tourId, steps, isActive, onActiveChange, onComplete, onSkip, onStepChange, startAt, autoAdvance, showSkip, showProgress, showNavigation, persistCompletion, className, overlayClassName, scrollToTarget, scrollBehavior, closeOnOverlayClick, closeOnEscape, skipText, nextText, prevText, finishText, }: WakaTooltipTourProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTooltipTour;

package/dist/components/waka-tour-guide/index.d.ts

@@ -0,0 +1,127 @@
+import * as React from "react";
+export type TourPlacement = "top" | "bottom" | "left" | "right" | "auto";
+/** Tour display variant */
+export type TourVariant = "modal" | "tooltip";
+export interface TourStep {
+    /** Unique identifier for the step */
+    id: string;
+    /** CSS selector or element ref for the target element */
+    target: string | React.RefObject<HTMLElement>;
+    /** Title of the step */
+    title: string;
+    /** Description/content of the step */
+    content: React.ReactNode;
+    /** Placement of the tooltip relative to target */
+    placement?: TourPlacement;
+    /** Disable interaction with target element */
+    disableInteraction?: boolean;
+    /** Custom spotlight padding around target */
+    spotlightPadding?: number;
+    /** Custom action button */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Called before advancing to this step */
+    beforeEnter?: () => void | Promise<void>;
+    /** Called before leaving this step */
+    beforeLeave?: () => void | Promise<void>;
+}
+export interface WakaTourGuideProps {
+    /** Array of tour steps */
+    steps: TourStep[];
+    /** Whether the tour is active */
+    isOpen: boolean;
+    /** Callback when tour state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Display variant - "modal" shows dark overlay, "tooltip" shows only the tooltip */
+    variant?: TourVariant;
+    /** Current step index (controlled) */
+    currentStep?: number;
+    /** Callback when step changes */
+    onStepChange?: (step: number) => void;
+    /** Callback when tour is completed */
+    onComplete?: () => void;
+    /** Callback when tour is skipped */
+    onSkip?: () => void;
+    /** Show skip button */
+    showSkip?: boolean;
+    /** Show progress indicator */
+    showProgress?: boolean;
+    /** Show step counter */
+    showStepCounter?: boolean;
+    /** Enable keyboard navigation */
+    keyboardNavigation?: boolean;
+    /** Scroll behavior when navigating */
+    scrollBehavior?: "smooth" | "instant" | "auto";
+    /** Offset from viewport edge when scrolling */
+    scrollOffset?: number;
+    /** Overlay color */
+    overlayColor?: string;
+    /** Overlay opacity (0-1) */
+    overlayOpacity?: number;
+    /** Enable pulse animation on target */
+    pulseAnimation?: boolean;
+    /** Custom class for tooltip */
+    tooltipClassName?: string;
+    /** Labels for buttons */
+    labels?: {
+        next?: string;
+        previous?: string;
+        skip?: string;
+        finish?: string;
+    };
+}
+export interface UseTourGuideOptions {
+    /** Initial step index */
+    initialStep?: number;
+    /** Auto start the tour */
+    autoStart?: boolean;
+    /** Storage key for tracking completion */
+    storageKey?: string;
+    /** Callback when tour completes */
+    onComplete?: () => void;
+}
+export interface UseTourGuideReturn {
+    /** Whether the tour is currently open */
+    isOpen: boolean;
+    /** Current step index */
+    currentStep: number;
+    /** Total number of steps */
+    totalSteps: number;
+    /** Start the tour */
+    start: () => void;
+    /** Stop/close the tour */
+    stop: () => void;
+    /** Go to next step */
+    next: () => void;
+    /** Go to previous step */
+    previous: () => void;
+    /** Go to specific step */
+    goToStep: (step: number) => void;
+    /** Skip the tour */
+    skip: () => void;
+    /** Complete the tour */
+    complete: () => void;
+    /** Reset the tour to first step */
+    reset: () => void;
+    /** Check if tour has been completed before */
+    hasCompleted: boolean;
+    /** Props to spread on WakaTourGuide component */
+    tourProps: {
+        isOpen: boolean;
+        onOpenChange: (open: boolean) => void;
+        currentStep: number;
+        onStepChange: (step: number) => void;
+        onComplete: () => void;
+        onSkip: () => void;
+    };
+}
+export declare function useTourGuide(steps: TourStep[], options?: UseTourGuideOptions): UseTourGuideReturn;
+/**
+ * @deprecated Since v3.6 — will be removed in v4.0.
+ * Use `WakaTour` compound (with `Tour.Step`, `Tour.Tooltip`) instead (futur).
+ * See `docs/audit/remove-relocate.md` §2.4.
+ */
+export declare function WakaTourGuide({ steps, isOpen, onOpenChange, variant, currentStep: controlledStep, onStepChange, onComplete, onSkip, showSkip, showProgress, showStepCounter, keyboardNavigation, scrollBehavior, scrollOffset, overlayColor, overlayOpacity, pulseAnimation, tooltipClassName, labels, }: WakaTourGuideProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTourGuide;