@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-feature-announcement/index.d.ts

@@ -0,0 +1,112 @@
+export interface FeatureMedia {
+    /** Media type */
+    type: "image" | "video";
+    /** Media URL */
+    src: string;
+    /** Alt text for accessibility */
+    alt: string;
+    /** Poster image for video */
+    poster?: string;
+}
+export interface FeatureData {
+    /** Unique identifier */
+    id: string;
+    /** Feature title */
+    title: string;
+    /** Feature description */
+    description: string;
+    /** Screenshot or video preview */
+    media?: FeatureMedia;
+    /** Version number (e.g., "2.0.0") */
+    version?: string;
+    /** Release date */
+    releaseDate?: Date | string;
+    /** Learn more link */
+    learnMoreUrl?: string;
+    /** Learn more link text */
+    learnMoreText?: string;
+    /** Custom badge text (defaults to "What's New") */
+    badgeText?: string;
+    /** Custom badge color */
+    badgeVariant?: "default" | "primary" | "success" | "warning";
+}
+export type FeatureAnnouncementMode = "modal" | "banner";
+export interface WakaFeatureAnnouncementProps {
+    /** Array of features to display */
+    features: FeatureData[];
+    /** Display mode - modal or inline banner */
+    mode?: FeatureAnnouncementMode;
+    /** Whether the announcement is open/visible */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Callback when a feature is viewed */
+    onFeatureView?: (feature: FeatureData, index: number) => void;
+    /** Callback when learn more is clicked */
+    onLearnMore?: (feature: FeatureData) => void;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+    /** Dismiss button text */
+    dismissText?: string;
+    /** Show navigation dots */
+    showDots?: boolean;
+    /** Show navigation arrows */
+    showArrows?: boolean;
+    /** Auto-advance through features */
+    autoAdvance?: boolean;
+    /** Auto-advance interval in milliseconds */
+    autoAdvanceInterval?: number;
+    /** Close on overlay click (modal mode only) */
+    closeOnOverlayClick?: boolean;
+    /** Close on escape key */
+    closeOnEscape?: boolean;
+    /** Size variant (modal mode only) */
+    size?: "sm" | "md" | "lg";
+    /** Custom className */
+    className?: string;
+    /** Custom className for overlay (modal mode only) */
+    overlayClassName?: string;
+}
+export interface UseFeatureAnnouncementOptions {
+    /** Initial open state */
+    defaultOpen?: boolean;
+    /** Storage key for dismissed state */
+    storageKey?: string;
+    /** Features to display */
+    features?: FeatureData[];
+    /** Version to track for dismissal */
+    currentVersion?: string;
+    /** Callback when opened */
+    onOpen?: () => void;
+    /** Callback when closed */
+    onClose?: () => void;
+}
+export interface UseFeatureAnnouncementReturn {
+    /** Whether the announcement is open */
+    isOpen: boolean;
+    /** Open the announcement */
+    open: () => void;
+    /** Close the announcement */
+    close: () => void;
+    /** Toggle the announcement */
+    toggle: () => void;
+    /** Handle open change from component */
+    onOpenChange: (open: boolean) => void;
+    /** Mark as seen/dismissed */
+    markAsSeen: () => void;
+    /** Check if has been seen */
+    hasBeenSeen: boolean;
+    /** Current feature index */
+    currentIndex: number;
+    /** Set current feature index */
+    setCurrentIndex: (index: number) => void;
+    /** Go to next feature */
+    nextFeature: () => void;
+    /** Go to previous feature */
+    previousFeature: () => void;
+    /** Total number of features */
+    totalFeatures: number;
+}
+export declare function WakaFeatureAnnouncement({ features, mode, open, onOpenChange, onFeatureView, onLearnMore, onDismiss, dismissText, showDots, showArrows, autoAdvance, autoAdvanceInterval, closeOnOverlayClick, closeOnEscape, size, className, overlayClassName, }: WakaFeatureAnnouncementProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFeatureAnnouncement({ defaultOpen, storageKey, features, currentVersion, onOpen, onClose, }?: UseFeatureAnnouncementOptions): UseFeatureAnnouncementReturn;
+export default WakaFeatureAnnouncement;

package/dist/components/waka-feature-flag-row/index.d.ts

@@ -0,0 +1,45 @@
+export type FeatureFlagStatus = "enabled" | "disabled" | "percentage" | "segment";
+export interface FeatureFlagSegment {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface FeatureFlag {
+    id: string;
+    key: string;
+    name: string;
+    description?: string;
+    status: FeatureFlagStatus;
+    enabled: boolean;
+    percentage?: number;
+    segments?: FeatureFlagSegment[];
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy?: string;
+    environment?: string;
+    tags?: string[];
+}
+export interface WakaFeatureFlagRowProps {
+    /** Feature flag data */
+    flag: FeatureFlag;
+    /** Callback when toggling the flag */
+    onToggle?: (enabled: boolean) => void;
+    /** Callback when changing percentage */
+    onPercentageChange?: (percentage: number) => void;
+    /** Callback when editing the flag */
+    onEdit?: () => void;
+    /** Callback when deleting the flag */
+    onDelete?: () => void;
+    /** Callback when viewing history */
+    onViewHistory?: () => void;
+    /** Callback when duplicating the flag */
+    onDuplicate?: () => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaFeatureFlagRow({ flag, onToggle, onPercentageChange, onEdit, onDelete, onViewHistory, onDuplicate, readOnly, compact, className, }: WakaFeatureFlagRowProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultFeatureFlags: FeatureFlag[];

package/dist/components/waka-file-upload/index.d.ts

@@ -0,0 +1,49 @@
+import * as React from "react";
+export type FileUploadVariant = "dropzone" | "button" | "inline";
+export interface UploadedFile {
+    id: string;
+    file: File;
+    progress: number;
+    status: "pending" | "uploading" | "success" | "error";
+    error?: string;
+    url?: string;
+}
+export interface WakaFileUploadProps {
+    /** Variant d'affichage */
+    variant?: FileUploadVariant;
+    /** Types de fichiers acceptés (ex: "image/*", ".pdf,.doc") */
+    accept?: string;
+    /** Taille max par fichier en bytes */
+    maxSize?: number;
+    /** Nombre max de fichiers */
+    maxFiles?: number;
+    /** Upload multiple */
+    multiple?: boolean;
+    /** Callback d'upload (retourne l'URL ou throw une erreur) */
+    onUpload?: (file: File, onProgress: (progress: number) => void) => Promise<string>;
+    /** Callback après tous les uploads */
+    onComplete?: (files: UploadedFile[]) => void;
+    /** Callback lors de la suppression */
+    onRemove?: (file: UploadedFile) => void;
+    /** Callback d'erreur */
+    onError?: (error: string, file?: File) => void;
+    /** Afficher la prévisualisation */
+    showPreview?: boolean;
+    /** Afficher la barre de progression */
+    showProgress?: boolean;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Placeholder */
+    placeholder?: string;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+}
+/**
+ * Composant WakaFileUpload
+ */
+export declare const WakaFileUpload: React.ForwardRefExoticComponent<WakaFileUploadProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaFileUpload;

package/dist/components/waka-floating-nav/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export interface FloatingNavItem {
+    /** Unique identifier */
+    id: string;
+    /** Label for the nav item */
+    label: string;
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** URL or href */
+    href?: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Whether this item is currently active */
+    active?: boolean;
+    /** Disable the item */
+    disabled?: boolean;
+}
+export interface WakaFloatingNavProps {
+    /** Navigation items */
+    items: FloatingNavItem[];
+    /** Logo or brand element for full nav */
+    logo?: React.ReactNode;
+    /** Compact logo for scrolled state */
+    compactLogo?: React.ReactNode;
+    /** Scroll threshold to trigger compact mode (px) */
+    scrollThreshold?: number;
+    /** Scroll threshold to show nav (px) */
+    showThreshold?: number;
+    /** Always show nav (don't hide on scroll up) */
+    alwaysVisible?: boolean;
+    /** Custom render for nav items */
+    renderItem?: (item: FloatingNavItem, isCompact: boolean) => React.ReactNode;
+    /** Right side actions (buttons, etc.) */
+    actions?: React.ReactNode;
+    /** Compact actions for scrolled state */
+    compactActions?: React.ReactNode;
+    /** Position of the nav */
+    position?: "top" | "bottom";
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaFloatingNav({ items, logo, compactLogo, scrollThreshold, showThreshold, alwaysVisible, renderItem, actions, compactActions, position, className, }: WakaFloatingNavProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFloatingNav(initialItems: FloatingNavItem[]): {
+    items: FloatingNavItem[];
+    setItems: React.Dispatch<React.SetStateAction<FloatingNavItem[]>>;
+    setActiveItem: (id: string) => void;
+    updateItem: (id: string, updates: Partial<FloatingNavItem>) => void;
+    addItem: (item: FloatingNavItem) => void;
+    removeItem: (id: string) => void;
+};
+export default WakaFloatingNav;

package/dist/components/waka-flow-diagram/index.d.ts

@@ -0,0 +1,71 @@
+import * as React from "react";
+export interface FlowNode {
+    id: string;
+    type: "start" | "end" | "action" | "decision" | "process" | "custom";
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    position: {
+        x: number;
+        y: number;
+    };
+    data?: Record<string, unknown>;
+}
+export interface FlowConnection {
+    id: string;
+    from: string;
+    to: string;
+    label?: string;
+    animated?: boolean;
+    color?: string;
+}
+export interface WakaFlowDiagramProps {
+    /** Flow nodes */
+    nodes: FlowNode[];
+    /** Connections between nodes */
+    connections: FlowConnection[];
+    /** Called when nodes change */
+    onNodesChange?: (nodes: FlowNode[]) => void;
+    /** Called when connections change */
+    onConnectionsChange?: (connections: FlowConnection[]) => void;
+    /** Called when a node is clicked */
+    onNodeClick?: (node: FlowNode) => void;
+    /** Called when a node is double-clicked */
+    onNodeDoubleClick?: (node: FlowNode) => void;
+    /** Enable drag and drop */
+    draggable?: boolean;
+    /** Enable editing (add/remove nodes) */
+    editable?: boolean;
+    /** Zoom level (1 = 100%) */
+    zoom?: number;
+    /** Grid size for snapping */
+    gridSize?: number;
+    /** Show grid */
+    showGrid?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaFlowDiagram({ nodes: initialNodes, connections: initialConnections, onNodesChange, onConnectionsChange, onNodeClick, onNodeDoubleClick, draggable, editable, zoom, gridSize, showGrid, className, }: WakaFlowDiagramProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFlowDiagram(initialNodes?: FlowNode[], initialConnections?: FlowConnection[]): {
+    nodes: FlowNode[];
+    connections: FlowConnection[];
+    setNodes: React.Dispatch<React.SetStateAction<FlowNode[]>>;
+    setConnections: React.Dispatch<React.SetStateAction<FlowConnection[]>>;
+    addNode: (node: Omit<FlowNode, "id">) => {
+        id: string;
+        data?: Record<string, unknown>;
+        description?: string;
+        type: "start" | "end" | "action" | "decision" | "process" | "custom";
+        label: string;
+        icon?: React.ReactNode;
+        position: {
+            x: number;
+            y: number;
+        };
+    };
+    removeNode: (nodeId: string) => void;
+    updateNode: (nodeId: string, updates: Partial<FlowNode>) => void;
+    addConnection: (from: string, to: string, options?: Partial<FlowConnection>) => FlowConnection;
+    removeConnection: (connectionId: string) => void;
+    clear: () => void;
+};

package/dist/components/waka-funnel-chart/index.d.ts

@@ -0,0 +1,108 @@
+export type ValueFormat = "number" | "percentage" | "currency";
+export interface FunnelStage {
+    /** Unique identifier */
+    id: string;
+    /** Label for the stage */
+    label: string;
+    /** Value for the stage */
+    value: number;
+    /** Custom color for the stage */
+    color?: string;
+    /** Additional details for tooltip */
+    details?: string;
+}
+export interface FunnelCalculatedStage extends FunnelStage {
+    /** Percentage of total (first stage) */
+    percentageOfTotal: number;
+    /** Percentage of previous stage (conversion rate) */
+    conversionRate: number | null;
+    /** Drop-off from previous stage */
+    dropOff: number | null;
+    /** Drop-off percentage from previous stage */
+    dropOffPercentage: number | null;
+    /** Width percentage relative to max */
+    widthPercentage: number;
+}
+export interface WakaFunnelChartProps {
+    /** Funnel stages data */
+    data: FunnelStage[];
+    /** Orientation of the funnel */
+    orientation?: "vertical" | "horizontal";
+    /** Width of the chart */
+    width?: number;
+    /** Height of the chart (for vertical) or stage height (for horizontal) */
+    height?: number;
+    /** Show conversion rates between stages */
+    showConversionRates?: boolean;
+    /** Show drop-off percentages */
+    showDropOff?: boolean;
+    /** Show stage values */
+    showValues?: boolean;
+    /** Show percentage of total */
+    showPercentages?: boolean;
+    /** Value format type */
+    valueFormat?: ValueFormat;
+    /** Currency symbol (when valueFormat is "currency") */
+    currencySymbol?: string;
+    /** Locale for number formatting */
+    locale?: string;
+    /** Animate funnel fill on mount */
+    animated?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Animation delay between stages in ms */
+    staggerDelay?: number;
+    /** Show tooltips on hover */
+    showTooltips?: boolean;
+    /** Minimum width percentage for smallest stage */
+    minWidthPercentage?: number;
+    /** Gap between stages */
+    gap?: number;
+    /** Custom className */
+    className?: string;
+    /** Callback when stage is clicked */
+    onStageClick?: (stage: FunnelCalculatedStage, index: number) => void;
+    /** Callback when stage is hovered */
+    onStageHover?: (stage: FunnelCalculatedStage | null, index: number | null) => void;
+}
+export interface UseFunnelChartOptions {
+    /** Funnel stages data */
+    data: FunnelStage[];
+    /** Minimum width percentage */
+    minWidthPercentage?: number;
+}
+export interface UseFunnelChartReturn {
+    /** Calculated stages with metrics */
+    stages: FunnelCalculatedStage[];
+    /** Total value (first stage value) */
+    totalValue: number;
+    /** Overall conversion rate (last / first) */
+    overallConversionRate: number;
+    /** Total drop-off */
+    totalDropOff: number;
+    /** Currently hovered stage */
+    hoveredStage: string | null;
+    /** Set hovered stage */
+    setHoveredStage: (id: string | null) => void;
+    /** Currently active/selected stage */
+    activeStage: string | null;
+    /** Set active stage */
+    setActiveStage: (id: string | null) => void;
+}
+export declare function useFunnelChart({ data, minWidthPercentage, }: UseFunnelChartOptions): UseFunnelChartReturn;
+export declare function WakaFunnelChart({ data, orientation, width, height, showConversionRates, showDropOff, showValues, showPercentages, valueFormat, currencySymbol, locale, animated, animationDuration, staggerDelay, showTooltips, minWidthPercentage, gap, className, onStageClick, onStageHover, }: WakaFunnelChartProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaFunnelChartSimpleProps extends Omit<WakaFunnelChartProps, "data"> {
+    /** Stage labels */
+    labels: string[];
+    /** Stage values */
+    values: number[];
+    /** Optional colors per stage */
+    colors?: string[];
+}
+export declare function WakaFunnelChartSimple({ labels, values, colors, ...props }: WakaFunnelChartSimpleProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaFunnelChartCompactProps extends Omit<WakaFunnelChartProps, "showConversionRates" | "showDropOff" | "showPercentages"> {
+    /** Show only essential info */
+    minimal?: boolean;
+}
+export declare function WakaFunnelChartCompact({ minimal, width, height, gap, ...props }: WakaFunnelChartCompactProps): import("react/jsx-runtime").JSX.Element;
+export default WakaFunnelChart;

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

@@ -0,0 +1,32 @@
+import * as React from "react";
+export interface WakaGlowCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Glow color (CSS color value) */
+    glowColor?: string;
+    /** Glow intensity (0-1) */
+    glowIntensity?: number;
+    /** Glow size in pixels */
+    glowSize?: number;
+    /** Whether to show border glow */
+    borderGlow?: boolean;
+    /** Whether glow follows cursor */
+    followCursor?: boolean;
+    /** Animation on hover */
+    hoverEffect?: "lift" | "scale" | "tilt" | "none";
+    /** Gradient background */
+    gradient?: boolean;
+    /** Children */
+    children: React.ReactNode;
+}
+export declare function WakaGlowCard({ glowColor, glowIntensity, glowSize, borderGlow, followCursor, hoverEffect, gradient, className, children, ...props }: WakaGlowCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaGlowCardPrimary(props: Omit<WakaGlowCardProps, "glowColor">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaGlowCardSuccess(props: Omit<WakaGlowCardProps, "glowColor">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaGlowCardWarning(props: Omit<WakaGlowCardProps, "glowColor">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaGlowCardDanger(props: Omit<WakaGlowCardProps, "glowColor">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaGlowCardRainbow(props: Omit<WakaGlowCardProps, "glowColor" | "borderGlow">): import("react/jsx-runtime").JSX.Element;
+export interface WakaGlowGridProps {
+    children: React.ReactNode;
+    columns?: 1 | 2 | 3 | 4;
+    gap?: "sm" | "md" | "lg";
+    className?: string;
+}
+export declare function WakaGlowGrid({ children, columns, gap, className, }: WakaGlowGridProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/waka-goal-progress/index.d.ts

@@ -0,0 +1,139 @@
+import * as React from "react";
+export type GoalType = "revenue" | "users" | "sales" | "engagement" | "custom";
+export type PaceStatus = "ahead" | "behind" | "on-track";
+export interface GoalMilestone {
+    /** Value at this milestone */
+    value: number;
+    /** Label for the milestone */
+    label?: string;
+    /** Optional icon */
+    icon?: React.ReactNode;
+    /** Is this milestone reached */
+    reached?: boolean;
+}
+export interface HistoricalDataPoint {
+    /** Date or label for the data point */
+    date: string;
+    /** Value at this point */
+    value: number;
+}
+export interface GoalProjection {
+    /** Projected completion date */
+    completionDate?: Date;
+    /** Projected final value (if date-based goal) */
+    projectedValue?: number;
+    /** Confidence level 0-100 */
+    confidence?: number;
+}
+export interface WakaGoalProgressProps {
+    /** Current progress value */
+    currentValue: number;
+    /** Target goal value */
+    targetValue: number;
+    /** Goal start value (defaults to 0) */
+    startValue?: number;
+    /** Goal type for formatting */
+    goalType?: GoalType;
+    /** Custom unit label (e.g., "$", "users", etc.) */
+    unit?: string;
+    /** Unit position */
+    unitPosition?: "prefix" | "suffix";
+    /** Goal title/name */
+    title?: string;
+    /** Goal description */
+    description?: string;
+    /** Start date of the goal period */
+    startDate?: Date;
+    /** End/deadline date of the goal */
+    endDate?: Date;
+    /** Milestone markers */
+    milestones?: GoalMilestone[];
+    /** Historical trend data */
+    historicalData?: HistoricalDataPoint[];
+    /** Show historical trend line */
+    showTrendLine?: boolean;
+    /** Manual pace status override */
+    paceStatus?: PaceStatus;
+    /** Projected completion info */
+    projection?: GoalProjection;
+    /** Show time remaining */
+    showTimeRemaining?: boolean;
+    /** Show percentage complete */
+    showPercentage?: boolean;
+    /** Show current/target values */
+    showValues?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Color theme */
+    theme?: "default" | "success" | "warning" | "danger" | "purple" | "blue";
+    /** Custom className */
+    className?: string;
+    /** Callback when goal is reached */
+    onGoalReached?: () => void;
+}
+export interface UseGoalProgressOptions {
+    /** Current value */
+    currentValue: number;
+    /** Target value */
+    targetValue: number;
+    /** Start value */
+    startValue?: number;
+    /** Start date */
+    startDate?: Date;
+    /** End date */
+    endDate?: Date;
+    /** Historical data for trend analysis */
+    historicalData?: HistoricalDataPoint[];
+}
+export interface UseGoalProgressReturn {
+    /** Progress percentage (0-100) */
+    progressPercent: number;
+    /** Remaining value to reach goal */
+    remainingValue: number;
+    /** Pace status based on time and progress */
+    paceStatus: PaceStatus;
+    /** Projected completion date */
+    projectedCompletionDate: Date | null;
+    /** Days remaining until deadline */
+    daysRemaining: number | null;
+    /** Time remaining formatted string */
+    timeRemainingFormatted: string | null;
+    /** Is goal completed */
+    isCompleted: boolean;
+    /** Daily rate needed to hit goal */
+    requiredDailyRate: number | null;
+    /** Current daily rate based on historical data */
+    currentDailyRate: number | null;
+    /** Trend direction */
+    trendDirection: "up" | "down" | "stable";
+}
+export declare function useGoalProgress({ currentValue, targetValue, startValue, startDate, endDate, historicalData, }: UseGoalProgressOptions): UseGoalProgressReturn;
+export declare function WakaGoalProgress({ currentValue, targetValue, startValue, goalType, unit, unitPosition, title, description, startDate, endDate, milestones, historicalData, showTrendLine, paceStatus: paceStatusOverride, projection, showTimeRemaining, showPercentage, showValues, animated, size, theme, className, onGoalReached, }: WakaGoalProgressProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaGoalProgress {
+    var displayName: string;
+}
+export interface WakaCompactGoalProgressProps {
+    currentValue: number;
+    targetValue: number;
+    goalType?: GoalType;
+    unit?: string;
+    unitPosition?: "prefix" | "suffix";
+    theme?: "default" | "success" | "warning" | "danger" | "purple" | "blue";
+    showPercentage?: boolean;
+    className?: string;
+}
+export declare function WakaCompactGoalProgress({ currentValue, targetValue, goalType, unit, unitPosition, theme, showPercentage, className, }: WakaCompactGoalProgressProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaCompactGoalProgress {
+    var displayName: string;
+}
+export interface WakaGoalCardProps extends WakaGoalProgressProps {
+    /** Show border */
+    bordered?: boolean;
+}
+export declare function WakaGoalCard({ bordered, className, ...props }: WakaGoalCardProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaGoalCard {
+    var displayName: string;
+}
+export default WakaGoalProgress;

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

@@ -0,0 +1,50 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type HapticPattern = "light" | "medium" | "heavy" | "success" | "warning" | "error" | "selection" | number[];
+export interface WakaHapticButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof hapticButtonVariants> {
+    /** Render as child component */
+    asChild?: boolean;
+    /** Haptic pattern on press */
+    hapticPattern?: HapticPattern;
+    /** Enable/disable haptic feedback */
+    hapticEnabled?: boolean;
+    /** Enable ripple effect */
+    ripple?: boolean;
+    /** Ripple color (CSS color value) */
+    rippleColor?: string;
+    /** Ripple duration in ms */
+    rippleDuration?: number;
+    /** Enable press scale animation */
+    pressScale?: boolean;
+    /** Scale factor on press (0-1) */
+    pressScaleFactor?: number;
+    /** Enable glow effect on press */
+    glowOnPress?: boolean;
+    /** Glow color (CSS color value) */
+    glowColor?: string;
+    /** Loading state */
+    loading?: boolean;
+    /** Icon to show before children */
+    leftIcon?: React.ReactNode;
+    /** Icon to show after children */
+    rightIcon?: React.ReactNode;
+}
+declare const hapticButtonVariants: (props?: {
+    variant?: "default" | "gradient" | "outline" | "glass" | "destructive" | "secondary" | "ghost" | "neon";
+    size?: "default" | "sm" | "lg" | "xl" | "icon" | "icon-sm" | "icon-lg";
+    rounded?: "default" | "sm" | "lg" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+/**
+ * @deprecated Since v3.6 — will be removed in v4.0.
+ * Use `WakaFancyButton variant="haptic"` instead (futur, dans `@wakastellar/ui-effects-decorative`).
+ * See `docs/audit/remove-relocate.md` §2.1.
+ */
+export declare const WakaHapticButton: React.ForwardRefExoticComponent<WakaHapticButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export interface WakaHapticIconButtonProps extends Omit<WakaHapticButtonProps, "children" | "leftIcon" | "rightIcon"> {
+    /** Icon to display */
+    icon: React.ReactNode;
+    /** Accessible label */
+    "aria-label": string;
+}
+export declare const WakaHapticIconButton: React.ForwardRefExoticComponent<WakaHapticIconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};