@wakastellar/ui 3.5.0 → 4.0.0-dev.0

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

@@ -0,0 +1,106 @@
+import * as React from "react";
+export interface MentionUser {
+    id: string;
+    name: string;
+    username: string;
+    avatar?: string;
+}
+export interface MentionChannel {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: React.ReactNode;
+}
+export interface MentionItem {
+    id: string;
+    type: string;
+    display: string;
+    value: string;
+    avatar?: string;
+    icon?: React.ReactNode;
+    description?: string;
+    data?: Record<string, unknown>;
+}
+export interface MentionTrigger {
+    trigger: string;
+    type: string;
+    icon?: React.ReactNode;
+    data?: MentionItem[];
+    onSearch?: (query: string) => Promise<MentionItem[]>;
+    allowSpaces?: boolean;
+    markup?: string;
+    renderSuggestion?: (item: MentionItem, isHighlighted: boolean) => React.ReactNode;
+}
+export interface InsertedMention {
+    id: string;
+    type: string;
+    display: string;
+    value: string;
+    trigger: string;
+    startIndex: number;
+    endIndex: number;
+}
+export interface WakaMentionInputProps {
+    /** Current text value */
+    value?: string;
+    /** Callback when value changes */
+    onChange?: (value: string, plainText: string, mentions: InsertedMention[]) => void;
+    /** Mention triggers configuration */
+    triggers?: MentionTrigger[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error message */
+    error?: string;
+    /** Maximum character limit */
+    maxLength?: number;
+    /** Maximum mention limit */
+    maxMentions?: number;
+    /** Show character count */
+    showCharacterCount?: boolean;
+    /** Show mention count */
+    showMentionCount?: boolean;
+    /** Minimum height */
+    minHeight?: number;
+    /** Maximum height (with scroll) */
+    maxHeight?: number;
+    /** Show rich text preview */
+    showPreview?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Debounce for async search (ms) */
+    searchDebounce?: number;
+    /** Auto focus */
+    autoFocus?: boolean;
+    /** On focus callback */
+    onFocus?: () => void;
+    /** On blur callback */
+    onBlur?: () => void;
+    /** On submit callback (Ctrl+Enter / Cmd+Enter) */
+    onSubmit?: (value: string, plainText: string, mentions: InsertedMention[]) => void;
+}
+export interface UseMentionInputOptions {
+    initialValue?: string;
+    triggers?: MentionTrigger[];
+    maxMentions?: number;
+    searchDebounce?: number;
+}
+export interface UseMentionInputReturn {
+    value: string;
+    plainText: string;
+    mentions: InsertedMention[];
+    setValue: (value: string) => void;
+    insertMention: (item: MentionItem, trigger: string) => void;
+    removeMention: (mentionId: string) => void;
+    clear: () => void;
+    mentionCount: number;
+    characterCount: number;
+}
+export declare function useMentionInput(options?: UseMentionInputOptions): UseMentionInputReturn;
+export declare const WakaMentionInput: React.ForwardRefExoticComponent<WakaMentionInputProps & React.RefAttributes<HTMLTextAreaElement>>;
+export default WakaMentionInput;

package/dist/components/waka-metric-sparkline/index.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+export interface WakaMetricSparklineProps {
+    /** Array of numeric data points */
+    data: number[];
+    /** Current/latest value to display */
+    value?: number;
+    /** Previous value for trend calculation */
+    previousValue?: number;
+    /** Chart variant */
+    variant?: "line" | "bar" | "area";
+    /** Width of the sparkline in pixels */
+    width?: number;
+    /** Height of the sparkline in pixels */
+    height?: number;
+    /** Custom color for the chart */
+    color?: string;
+    /** Show trend indicator */
+    showTrend?: boolean;
+    /** Show current value */
+    showValue?: boolean;
+    /** Show min/max markers */
+    showMinMax?: boolean;
+    /** Animate the chart on mount */
+    animated?: boolean;
+    /** Format function for displaying values */
+    formatValue?: (value: number) => string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaMetricSparkline({ data, value, previousValue, variant, width, height, color, showTrend, showValue, showMinMax, animated, formatValue, className, }: WakaMetricSparklineProps): import("react/jsx-runtime").JSX.Element;
+export interface UseSparklineDataOptions {
+    /** Initial data points */
+    initialData?: number[];
+    /** Maximum number of data points to keep */
+    maxPoints?: number;
+}
+export declare function useSparklineData(options?: UseSparklineDataOptions): {
+    data: number[];
+    setData: React.Dispatch<React.SetStateAction<number[]>>;
+    addPoint: (value: number) => void;
+    reset: () => void;
+    clear: () => void;
+    currentValue: number;
+    previousValue: number;
+};
+export default WakaMetricSparkline;

package/dist/components/waka-migration-list/index.d.ts

@@ -0,0 +1,36 @@
+export type MigrationStatus = "pending" | "applied" | "failed" | "rolled_back" | "running";
+export interface Migration {
+    id: string;
+    version: string;
+    name: string;
+    description?: string;
+    status: MigrationStatus;
+    appliedAt?: Date;
+    rolledBackAt?: Date;
+    duration?: number;
+    author?: string;
+    checksum?: string;
+    upScript?: string;
+    downScript?: string;
+    error?: string;
+}
+export interface WakaMigrationListProps {
+    /** List of migrations */
+    migrations: Migration[];
+    /** Callback when applying a migration */
+    onApply?: (migration: Migration) => void;
+    /** Callback when rolling back a migration */
+    onRollback?: (migration: Migration) => void;
+    /** Callback when viewing migration details */
+    onViewDetails?: (migration: Migration) => void;
+    /** Current database version */
+    currentVersion?: string;
+    /** Show scripts */
+    showScripts?: boolean;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaMigrationList({ migrations, onApply, onRollback, onViewDetails, currentVersion, showScripts, title, className, }: WakaMigrationListProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultMigrations: Migration[];

package/dist/components/waka-milestone-road/index.d.ts

@@ -0,0 +1,91 @@
+import * as React from "react";
+export interface MilestoneReward {
+    /** Type of reward */
+    type: "xp" | "badge" | "item" | "currency" | "unlock";
+    /** Value of the reward */
+    value: number | string;
+    /** Custom icon for the reward */
+    icon?: React.ReactNode;
+}
+export interface Milestone {
+    /** Unique identifier */
+    id: string;
+    /** Milestone name */
+    name: string;
+    /** Milestone description */
+    description?: string;
+    /** Custom icon for the milestone */
+    icon?: React.ReactNode;
+    /** Whether the milestone is completed */
+    completed: boolean;
+    /** Whether the milestone is the current one */
+    isCurrent?: boolean;
+    /** Rewards for completing this milestone */
+    rewards?: MilestoneReward[];
+    /** Optional position value (0-100 on the road) */
+    position?: number;
+}
+export interface WakaMilestoneRoadProps {
+    /** Array of milestones to display */
+    milestones: Milestone[];
+    /** Current progress percentage (0-100) */
+    progress: number;
+    /** Callback when a milestone is clicked */
+    onMilestoneClick?: (milestone: Milestone) => void;
+    /** Callback when claim rewards button is clicked */
+    onClaimRewards?: (milestoneId: string) => void;
+    /** Display variant */
+    variant?: "horizontal" | "vertical" | "winding";
+    /** Color theme */
+    theme?: "default" | "gold" | "purple" | "green" | "blue";
+    /** Enable animations */
+    animated?: boolean;
+    /** Show the character/avatar on the road */
+    showCharacter?: boolean;
+    /** Custom character/avatar element */
+    character?: React.ReactNode;
+    /** Show progress percentage label */
+    showProgressLabel?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaMilestoneRoad({ milestones, progress, onMilestoneClick, onClaimRewards, variant, theme, animated, showCharacter, character, showProgressLabel, className, }: WakaMilestoneRoadProps): import("react/jsx-runtime").JSX.Element;
+export interface UseMilestoneRoadOptions {
+    /** Initial milestones */
+    initialMilestones: Milestone[];
+    /** Callback when a milestone is completed */
+    onMilestoneComplete?: (milestone: Milestone) => void;
+    /** Callback when rewards are claimed */
+    onRewardsClaimed?: (milestoneId: string, rewards: MilestoneReward[]) => void;
+    /** Auto-calculate progress based on completed milestones */
+    autoCalculateProgress?: boolean;
+}
+export declare function useMilestoneRoad({ initialMilestones, onMilestoneComplete, onRewardsClaimed, autoCalculateProgress, }: UseMilestoneRoadOptions): {
+    milestones: {
+        isCurrent: boolean;
+        /** Unique identifier */
+        id: string;
+        /** Milestone name */
+        name: string;
+        /** Milestone description */
+        description?: string;
+        /** Custom icon for the milestone */
+        icon?: React.ReactNode;
+        /** Whether the milestone is completed */
+        completed: boolean;
+        /** Rewards for completing this milestone */
+        rewards?: MilestoneReward[];
+        /** Optional position value (0-100 on the road) */
+        position?: number;
+    }[];
+    progress: number;
+    currentMilestone: Milestone;
+    completeMilestone: (milestoneId: string) => void;
+    claimRewards: (milestoneId: string) => void;
+    setProgress: (value: number) => void;
+    reset: () => void;
+    completedCount: number;
+    totalCount: number;
+    unclaimedRewards: MilestoneReward[];
+    hasUnclaimedRewards: boolean;
+};

package/dist/components/waka-modal/index.d.ts

@@ -0,0 +1,87 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+export type ModalSize = "sm" | "md" | "lg" | "xl" | "full";
+export interface WakaModalProps {
+    /** État d'ouverture */
+    open: boolean;
+    /** Callback de fermeture */
+    onOpenChange: (open: boolean) => void;
+    /** Titre du modal */
+    title?: string;
+    /** Description du modal */
+    description?: string;
+    /** Contenu du modal */
+    children: React.ReactNode;
+    /** Taille du modal */
+    size?: ModalSize;
+    /** Afficher le bouton de fermeture */
+    showCloseButton?: boolean;
+    /** Fermer en cliquant sur l'overlay */
+    closeOnOverlayClick?: boolean;
+    /** Fermer avec la touche Escape */
+    closeOnEscape?: boolean;
+    /** Animation d'entrée/sortie */
+    animation?: "fade" | "slide" | "scale" | "none";
+    /** Centré verticalement */
+    centered?: boolean;
+    /** Sticky header */
+    stickyHeader?: boolean;
+    /** Sticky footer (pour les actions) */
+    stickyFooter?: boolean;
+    /** Footer avec actions */
+    footer?: React.ReactNode;
+    /** Classes CSS additionnelles pour le contenu */
+    className?: string;
+    /** Classes CSS pour l'overlay */
+    overlayClassName?: string;
+}
+declare const ModalOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    animation?: "fade" | "slide" | "scale" | "none";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ModalContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: ModalSize;
+    animation?: "fade" | "slide" | "scale" | "none";
+    centered?: boolean;
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface ModalHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    sticky?: boolean;
+}
+declare const ModalHeader: React.ForwardRefExoticComponent<ModalHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const ModalTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ModalBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+interface ModalFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    sticky?: boolean;
+}
+declare const ModalFooter: React.ForwardRefExoticComponent<ModalFooterProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * @deprecated Since v3.6 — will be removed in v4.0.
+ * Use `Dialog` (Radix-based, already exported from `@wakastellar/ui`) instead.
+ * See `docs/audit/remove-relocate.md` §2.6.
+ */
+export declare function WakaModal({ open, onOpenChange, title, description, children, size, showCloseButton, closeOnOverlayClick, closeOnEscape, animation, centered, stickyHeader, stickyFooter, footer, className, overlayClassName, }: WakaModalProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaModalTriggerProps {
+    /** Contenu du trigger */
+    children: React.ReactNode;
+    /** Callback d'ouverture */
+    onOpen?: () => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Désactiver le trigger */
+    disabled?: boolean;
+}
+export declare function WakaModalTrigger({ children, onOpen, className, disabled, }: WakaModalTriggerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseModalOptions {
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function useModal(options?: UseModalOptions): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    onOpenChange: (open: boolean) => void;
+};
+export { ModalOverlay, ModalContent, ModalHeader, ModalTitle, ModalDescription, ModalBody, ModalFooter, };
+export default WakaModal;

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

@@ -0,0 +1,62 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type MorphState = "idle" | "loading" | "success" | "error";
+export interface WakaMorphButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children">, VariantProps<typeof morphButtonVariants> {
+    /** Current state of the button */
+    state?: MorphState;
+    /** Text to show in idle state */
+    idleText: string;
+    /** Text to show in loading state */
+    loadingText?: string;
+    /** Text to show in success state */
+    successText?: string;
+    /** Text to show in error state */
+    errorText?: string;
+    /** Duration of success/error state before returning to idle (ms) */
+    resetDelay?: number;
+    /** Callback when state should reset to idle */
+    onReset?: () => void;
+    /** Custom icon for idle state */
+    idleIcon?: React.ReactNode;
+    /** Custom icon for loading state */
+    loadingIcon?: React.ReactNode;
+    /** Custom icon for success state */
+    successIcon?: React.ReactNode;
+    /** Custom icon for error state */
+    errorIcon?: React.ReactNode;
+    /** Enable haptic feedback */
+    hapticFeedback?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+}
+declare const morphButtonVariants: (props?: {
+    variant?: "default" | "outline" | "ghost";
+    size?: "default" | "sm" | "lg";
+    rounded?: "default" | "sm" | "lg" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaMorphButton: React.ForwardRefExoticComponent<WakaMorphButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export interface UseMorphButtonOptions {
+    onSuccess?: () => void;
+    onError?: (error: unknown) => void;
+    resetDelay?: number;
+}
+export declare function useMorphButton<T>(asyncFn: () => Promise<T>, options?: UseMorphButtonOptions): {
+    state: MorphState;
+    result: T;
+    error: unknown;
+    execute: () => Promise<void>;
+    reset: () => void;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+};
+export interface WakaAsyncButtonProps extends Omit<WakaMorphButtonProps, "state" | "onClick"> {
+    /** Async function to execute on click */
+    onClick: () => Promise<void>;
+    /** Callback on success */
+    onSuccess?: () => void;
+    /** Callback on error */
+    onError?: (error: unknown) => void;
+}
+export declare const WakaAsyncButton: React.ForwardRefExoticComponent<WakaAsyncButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/waka-network-topology/index.d.ts

@@ -0,0 +1,35 @@
+import * as React from "react";
+export interface NetworkNode {
+    id: string;
+    label: string;
+    type: "server" | "database" | "loadbalancer" | "firewall" | "cloud" | "client" | "router";
+    status: "healthy" | "warning" | "error" | "offline";
+    x: number;
+    y: number;
+    metrics?: {
+        cpu?: number;
+        memory?: number;
+        connections?: number;
+    };
+}
+export interface NetworkEdge {
+    source: string;
+    target: string;
+    latency?: number;
+    bandwidth?: number;
+    traffic?: "low" | "medium" | "high";
+    status?: "active" | "degraded" | "down";
+}
+export interface WakaNetworkTopologyProps {
+    nodes: NetworkNode[];
+    edges: NetworkEdge[];
+    onNodeClick?: (nodeId: string) => void;
+    onEdgeClick?: (source: string, target: string) => void;
+    selectedNode?: string;
+    showLatency?: boolean;
+    showTraffic?: boolean;
+    animated?: boolean;
+    className?: string;
+}
+export declare const WakaNetworkTopology: React.FC<WakaNetworkTopologyProps>;
+export default WakaNetworkTopology;

package/dist/components/waka-notifications/index.d.ts

@@ -0,0 +1,40 @@
+import * as React from "react";
+export interface Notification {
+    id: string;
+    title: string;
+    message: string;
+    type: "info" | "success" | "warning" | "error";
+    read: boolean;
+    timestamp: Date;
+    icon?: React.ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+export interface WakaNotificationsProps {
+    notifications: Notification[];
+    onMarkAsRead?: (id: string) => void;
+    onMarkAllAsRead?: () => void;
+    onDelete?: (id: string) => void;
+    onDeleteAll?: () => void;
+    onSettingsClick?: () => void;
+    maxHeight?: string;
+    className?: string;
+    iconClassName?: string;
+    badgeClassName?: string;
+    showBadge?: boolean;
+    showTabs?: boolean;
+    emptyMessage?: string;
+    emptyIcon?: React.ReactNode;
+}
+export declare const WakaNotifications: React.ForwardRefExoticComponent<WakaNotificationsProps & React.RefAttributes<HTMLButtonElement>>;
+export declare function useNotifications(initialNotifications?: Notification[]): {
+    notifications: Notification[];
+    addNotification: (notification: Omit<Notification, "id" | "timestamp" | "read">) => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+    deleteNotification: (id: string) => void;
+    deleteAllNotifications: () => void;
+    unreadCount: number;
+};

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

@@ -0,0 +1,60 @@
+import * as React from "react";
+export interface WakaNumberInputProps {
+    /** Valeur courante */
+    value?: number;
+    /** Callback lors du changement */
+    onChange?: (value: number | undefined) => void;
+    /** Valeur minimum */
+    min?: number;
+    /** Valeur maximum */
+    max?: number;
+    /** Pas d'incrémentation */
+    step?: number;
+    /** Précision décimale */
+    precision?: number;
+    /** Placeholder */
+    placeholder?: string;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Position des boutons */
+    buttonPosition?: "sides" | "right" | "none";
+    /** Permettre la valeur vide */
+    allowEmpty?: boolean;
+    /** Formater l'affichage */
+    formatValue?: (value: number) => string;
+    /** Parser la valeur saisie */
+    parseValue?: (value: string) => number | undefined;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+}
+export declare function WakaNumberInput({ value, onChange, min, max, step, precision, placeholder, disabled, error, size, buttonPosition, allowEmpty, formatValue, parseValue, className, id, name, }: WakaNumberInputProps): import("react/jsx-runtime").JSX.Element;
+export interface UseNumberInputOptions {
+    /** Valeur initiale */
+    initialValue?: number;
+    /** Valeur minimum */
+    min?: number;
+    /** Valeur maximum */
+    max?: number;
+    /** Pas d'incrémentation */
+    step?: number;
+}
+export declare function useNumberInput(options?: UseNumberInputOptions): {
+    value: number;
+    onChange: React.Dispatch<React.SetStateAction<number>>;
+    increment: () => void;
+    decrement: () => void;
+    reset: () => void;
+    clear: () => void;
+    min: number;
+    max: number;
+    step: number;
+};
+export default WakaNumberInput;

package/dist/components/waka-orbital-menu/index.d.ts

@@ -0,0 +1,61 @@
+import * as React from "react";
+export interface OrbitalMenuItem {
+    /** Unique identifier */
+    id: string;
+    /** Icon element to display */
+    icon: React.ReactNode;
+    /** Label for the item */
+    label: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Custom color for the item */
+    color?: string;
+}
+export interface WakaOrbitalMenuProps {
+    /** Menu items to display in the orbital circle */
+    items: OrbitalMenuItem[];
+    /** Whether the menu is open */
+    isOpen?: boolean;
+    /** Callback when menu opens/closes */
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Radius of the orbital circle in pixels */
+    radius?: number;
+    /** Size of menu items */
+    itemSize?: "sm" | "default" | "lg";
+    /** Size of center button */
+    centerSize?: "sm" | "default" | "lg";
+    /** Center button content */
+    centerContent?: React.ReactNode;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Starting angle in degrees (0 = top) */
+    startAngle?: number;
+    /** Total angle span in degrees */
+    angleSpan?: number;
+    /** Show labels on hover */
+    showLabels?: boolean;
+    /** Label position */
+    labelPosition?: "inside" | "outside";
+    /** Custom className for container */
+    className?: string;
+    /** Custom className for items */
+    itemClassName?: string;
+    /** Custom className for center button */
+    centerClassName?: string;
+}
+export declare function useOrbitalMenu(initialOpen?: boolean): {
+    isOpen: boolean;
+    toggle: () => void;
+    open: () => void;
+    close: () => void;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export declare function WakaOrbitalMenu({ items, isOpen: controlledIsOpen, onOpenChange, radius, itemSize, centerSize, centerContent, animationDuration, startAngle, angleSpan, showLabels, labelPosition, className, itemClassName, centerClassName, }: WakaOrbitalMenuProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaOrbitalMenuCompactProps extends Omit<WakaOrbitalMenuProps, "angleSpan" | "startAngle"> {
+    /** Direction the menu opens */
+    direction?: "top" | "bottom" | "left" | "right";
+}
+export declare function WakaOrbitalMenuCompact({ direction, ...props }: WakaOrbitalMenuCompactProps): import("react/jsx-runtime").JSX.Element;
+export default WakaOrbitalMenu;