@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-bottom-sheet/index.d.ts

@@ -0,0 +1,61 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type SnapPoint = number | "content" | "full";
+export interface WakaBottomSheetProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onDragStart" | "onDragEnd">, VariantProps<typeof bottomSheetVariants> {
+    /** Whether the sheet is open */
+    open: boolean;
+    /** Callback when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Snap points as percentages (0-100) or special values */
+    snapPoints?: SnapPoint[];
+    /** Default snap point index */
+    defaultSnapPoint?: number;
+    /** Current snap point index (controlled) */
+    snapPoint?: number;
+    /** Callback when snap point changes */
+    onSnapPointChange?: (index: number) => void;
+    /** Whether to show backdrop */
+    showBackdrop?: boolean;
+    /** Whether clicking backdrop closes sheet */
+    closeOnBackdropClick?: boolean;
+    /** Whether to show drag handle */
+    showHandle?: boolean;
+    /** Whether to block scroll when open */
+    blockScroll?: boolean;
+    /** Enable haptic feedback */
+    hapticFeedback?: boolean;
+    /** Custom header content */
+    header?: React.ReactNode;
+    /** Custom footer content */
+    footer?: React.ReactNode;
+    /** Main content */
+    children: React.ReactNode;
+    /** Callback when drag starts */
+    onDragStart?: () => void;
+    /** Callback when drag ends */
+    onDragEnd?: (snapPointIndex: number) => void;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Enable keyboard escape to close */
+    closeOnEscape?: boolean;
+}
+declare const bottomSheetVariants: (props?: {
+    variant?: "default" | "glass" | "flat";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaBottomSheet: React.ForwardRefExoticComponent<WakaBottomSheetProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseBottomSheetOptions {
+    defaultOpen?: boolean;
+    defaultSnapPoint?: number;
+    onOpenChange?: (open: boolean) => void;
+    onSnapPointChange?: (index: number) => void;
+}
+export declare function useBottomSheet(options?: UseBottomSheetOptions): {
+    open: boolean;
+    snapPoint: number;
+    onOpenChange: (newOpen: boolean) => void;
+    onSnapPointChange: (index: number) => void;
+    openSheet: (snapPointIndex?: number) => void;
+    closeSheet: () => void;
+    toggleSheet: () => void;
+};
+export {};

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

@@ -0,0 +1,43 @@
+import * as React from "react";
+export interface BreadcrumbItem {
+    /** Libellé de l'élément */
+    label: string;
+    /** URL de destination (optionnel pour le dernier élément) */
+    href?: string;
+    /** Icône personnalisée */
+    icon?: React.ReactNode;
+    /** Désactiver le lien */
+    disabled?: boolean;
+    /** Données additionnelles */
+    data?: Record<string, unknown>;
+}
+export interface WakaBreadcrumbProps {
+    /** Liste des éléments du fil d'Ariane */
+    items: BreadcrumbItem[];
+    /** Séparateur entre les éléments */
+    separator?: React.ReactNode;
+    /** Afficher l'icône Home pour le premier élément */
+    showHomeIcon?: boolean;
+    /** Nombre maximum d'éléments visibles (collapse les autres) */
+    maxItems?: number;
+    /** Fonction de rendu personnalisée pour les liens */
+    renderLink?: (item: BreadcrumbItem, children: React.ReactNode) => React.ReactNode;
+    /** Callback lors du clic sur un élément */
+    onItemClick?: (item: BreadcrumbItem, index: number) => void;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Variante visuelle */
+    variant?: "default" | "ghost" | "outline";
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaBreadcrumb({ items, separator, showHomeIcon, maxItems, renderLink, onItemClick, size, variant, className, }: WakaBreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour générer un fil d'Ariane à partir d'un chemin URL
+ */
+export declare function useBreadcrumbFromPath(pathname: string, options?: {
+    homeLabel?: string;
+    labelMap?: Record<string, string>;
+    excludePaths?: string[];
+}): BreadcrumbItem[];
+export default WakaBreadcrumb;

package/dist/components/waka-breadcrumb-path/index.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+export interface BreadcrumbPathItem {
+    /** Unique identifier */
+    id: string;
+    /** Label for the item */
+    label: string;
+    /** Icon element */
+    icon?: React.ReactNode;
+    /** URL or href */
+    href?: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+export interface WakaBreadcrumbPathProps {
+    /** Breadcrumb items */
+    items: BreadcrumbPathItem[];
+    /** Maximum visible items (will collapse middle items) */
+    maxItems?: number;
+    /** Show SVG path connecting items */
+    showPath?: boolean;
+    /** Path color */
+    pathColor?: string;
+    /** Path stroke width */
+    pathStrokeWidth?: number;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Custom render for items */
+    renderItem?: (item: BreadcrumbPathItem, isLast: boolean) => React.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaBreadcrumbPath({ items, maxItems, showPath, pathColor, pathStrokeWidth, animationDuration, size, renderItem, className, }: WakaBreadcrumbPathProps): import("react/jsx-runtime").JSX.Element;
+export declare function useBreadcrumbPath(initialItems?: BreadcrumbPathItem[]): {
+    items: BreadcrumbPathItem[];
+    push: (item: BreadcrumbPathItem) => void;
+    pop: () => void;
+    goTo: (id: string) => void;
+    reset: (newItems?: BreadcrumbPathItem[]) => void;
+    replace: (id: string, newItem: BreadcrumbPathItem) => void;
+    setItems: React.Dispatch<React.SetStateAction<BreadcrumbPathItem[]>>;
+};
+export default WakaBreadcrumbPath;

package/dist/components/waka-budget-burn/index.d.ts

@@ -0,0 +1,154 @@
+import * as React from "react";
+export interface SpendDataPoint {
+    /** Date of the spend */
+    date: Date;
+    /** Amount spent on this day */
+    amount: number;
+    /** Category breakdown (optional) */
+    categories?: Record<string, number>;
+}
+export interface BudgetCategory {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Allocated budget for this category */
+    budget: number;
+    /** Current spend for this category */
+    spent: number;
+    /** Custom color */
+    color?: string;
+}
+export interface BudgetBurnState {
+    /** Total budget amount */
+    totalBudget: number;
+    /** Total amount spent */
+    totalSpent: number;
+    /** Budget period start date */
+    startDate: Date;
+    /** Budget period end date */
+    endDate: Date;
+    /** Daily spending data */
+    spendHistory: SpendDataPoint[];
+    /** Budget categories */
+    categories: BudgetCategory[];
+    /** Current burn rate (spend per day) */
+    burnRate: number;
+    /** Ideal burn rate to stay on budget */
+    idealBurnRate: number;
+    /** Projected depletion date */
+    depletionDate: Date | null;
+    /** Days remaining in period */
+    daysRemaining: number;
+    /** Time elapsed percentage */
+    timeElapsedPercent: number;
+    /** Budget used percentage */
+    budgetUsedPercent: number;
+    /** Danger zone (burn rate is too high) */
+    isDangerZone: boolean;
+    /** Warning zone (burn rate approaching danger) */
+    isWarningZone: boolean;
+}
+export interface WakaBudgetBurnProps {
+    /** Total budget amount */
+    budget: number;
+    /** Budget period start date */
+    startDate: Date;
+    /** Budget period end date */
+    endDate: Date;
+    /** Daily spending history */
+    spendHistory: SpendDataPoint[];
+    /** Budget categories (optional) */
+    categories?: BudgetCategory[];
+    /** Currency symbol */
+    currency?: string;
+    /** Danger threshold (percentage over ideal burn rate) */
+    dangerThreshold?: number;
+    /** Warning threshold (percentage over ideal burn rate) */
+    warningThreshold?: number;
+    /** Show projected burn line */
+    showProjection?: boolean;
+    /** Show ideal burn line */
+    showIdealLine?: boolean;
+    /** Show category breakdown */
+    showCategories?: boolean;
+    /** Show daily/weekly/monthly trends */
+    showTrends?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Chart height in pixels */
+    height?: number;
+    /** Custom value formatter */
+    formatValue?: (value: number) => string;
+    /** Callback when danger zone is entered */
+    onDangerZone?: () => void;
+    /** Callback when budget is depleted */
+    onBudgetDepleted?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaBudgetBurn({ budget, startDate, endDate, spendHistory, categories, currency, dangerThreshold, warningThreshold, showProjection, showIdealLine, showCategories, showTrends, animated, height, formatValue: customFormatValue, onDangerZone, onBudgetDepleted, className, }: WakaBudgetBurnProps): import("react/jsx-runtime").JSX.Element;
+export interface UseBudgetBurnOptions {
+    /** Total budget amount */
+    budget: number;
+    /** Budget period start date */
+    startDate: Date;
+    /** Budget period end date */
+    endDate: Date;
+    /** Initial spending history */
+    initialHistory?: SpendDataPoint[];
+    /** Initial categories */
+    initialCategories?: BudgetCategory[];
+    /** Danger threshold percentage */
+    dangerThreshold?: number;
+    /** Warning threshold percentage */
+    warningThreshold?: number;
+    /** Callback when danger zone is entered */
+    onDangerZone?: () => void;
+    /** Callback when budget is depleted */
+    onBudgetDepleted?: () => void;
+}
+export declare function useBudgetBurn({ budget, startDate, endDate, initialHistory, initialCategories, dangerThreshold, warningThreshold, onDangerZone, onBudgetDepleted, }: UseBudgetBurnOptions): {
+    spendHistory: SpendDataPoint[];
+    categories: BudgetCategory[];
+    addSpend: (date: Date, amount: number, categoryBreakdown?: Record<string, number>) => void;
+    removeSpend: (date: Date) => void;
+    updateCategory: (id: string, updates: Partial<BudgetCategory>) => void;
+    addCategory: (category: BudgetCategory) => void;
+    removeCategory: (id: string) => void;
+    reset: () => void;
+    setSpendHistory: React.Dispatch<React.SetStateAction<SpendDataPoint[]>>;
+    setCategories: React.Dispatch<React.SetStateAction<BudgetCategory[]>>;
+    getForecast: (days: number) => {
+        projectedSpend: number;
+        projectedRemaining: number;
+        projectedPercentUsed: number;
+        willDeplete: boolean;
+        daysUntilDepletion: number;
+    };
+    /** Total budget amount */
+    totalBudget: number;
+    /** Total amount spent */
+    totalSpent: number;
+    /** Budget period start date */
+    startDate: Date;
+    /** Budget period end date */
+    endDate: Date;
+    /** Current burn rate (spend per day) */
+    burnRate: number;
+    /** Ideal burn rate to stay on budget */
+    idealBurnRate: number;
+    /** Projected depletion date */
+    depletionDate: Date | null;
+    /** Days remaining in period */
+    daysRemaining: number;
+    /** Time elapsed percentage */
+    timeElapsedPercent: number;
+    /** Budget used percentage */
+    budgetUsedPercent: number;
+    /** Danger zone (burn rate is too high) */
+    isDangerZone: boolean;
+    /** Warning zone (burn rate approaching danger) */
+    isWarningZone: boolean;
+};
+export default WakaBudgetBurn;

package/dist/components/waka-build-matrix/index.d.ts

@@ -0,0 +1,36 @@
+export type BuildStatus = "success" | "failed" | "running" | "pending" | "skipped" | "cancelled";
+export interface BuildCell {
+    id: string;
+    status: BuildStatus;
+    duration?: number;
+    startedAt?: Date;
+    finishedAt?: Date;
+    url?: string;
+    logs?: string;
+}
+export interface BuildMatrixRow {
+    label: string;
+    description?: string;
+    cells: BuildCell[];
+}
+export interface WakaBuildMatrixProps {
+    /** Column headers (e.g., OS names or versions) */
+    columns: string[];
+    /** Row data with cells */
+    rows: BuildMatrixRow[];
+    /** Callback when clicking on a cell */
+    onCellClick?: (rowIndex: number, colIndex: number, cell: BuildCell) => void;
+    /** Callback when retrying a build */
+    onRetry?: (rowIndex: number, colIndex: number) => void;
+    /** Callback when viewing logs */
+    onViewLogs?: (cell: BuildCell) => void;
+    /** Title of the matrix */
+    title?: string;
+    /** Show duration in cells */
+    showDuration?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaBuildMatrix({ columns, rows, onCellClick, onRetry, onViewLogs, title, showDuration, className, }: WakaBuildMatrixProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultBuildMatrixColumns: string[];
+export declare const defaultBuildMatrixRows: BuildMatrixRow[];

package/dist/components/waka-capacity-planner/index.d.ts

@@ -0,0 +1,132 @@
+import * as React from "react";
+export type ResourceType = "cpu" | "memory" | "storage" | "network" | "custom";
+export type TimelineRange = "1m" | "3m" | "6m" | "12m";
+export type ThresholdStatus = "safe" | "warning" | "danger" | "critical";
+export interface ResourceData {
+    /** Unique identifier for the resource */
+    id: string;
+    /** Display name of the resource */
+    name: string;
+    /** Resource type for icon selection */
+    type: ResourceType;
+    /** Custom icon component (for custom type) */
+    customIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    /** Current usage value */
+    current: number;
+    /** Total available capacity */
+    total: number;
+    /** Unit of measurement */
+    unit: string;
+    /** Historical usage data points */
+    history?: number[];
+    /** Projected usage at different time ranges */
+    projections: {
+        "1m": number;
+        "3m": number;
+        "6m": number;
+        "12m"?: number;
+    };
+    /** Growth rate per month (percentage) */
+    growthRate?: number;
+}
+export interface Threshold {
+    /** Warning threshold percentage (default: 70) */
+    warning: number;
+    /** Danger threshold percentage (default: 85) */
+    danger: number;
+    /** Critical threshold percentage (default: 95) */
+    critical: number;
+}
+export interface ScalingRecommendation {
+    /** Unique identifier */
+    id: string;
+    /** Resource this recommendation applies to */
+    resourceId: string;
+    /** Type of recommendation */
+    type: "scale_up" | "scale_out" | "optimize" | "monitor";
+    /** Priority level */
+    priority: "low" | "medium" | "high" | "urgent";
+    /** Short title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Suggested action */
+    action: string;
+    /** Estimated time until action needed */
+    timeframe?: string;
+    /** Potential cost impact */
+    costImpact?: string;
+}
+export interface WakaCapacityPlannerProps {
+    /** Array of resources to display */
+    resources: ResourceData[];
+    /** Threshold configuration */
+    thresholds?: Threshold;
+    /** Scaling recommendations */
+    recommendations?: ScalingRecommendation[];
+    /** Initial timeline range */
+    initialTimelineRange?: TimelineRange;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Enable animations */
+    animated?: boolean;
+    /** Show recommendations panel */
+    showRecommendations?: boolean;
+    /** Show timeline slider */
+    showTimeline?: boolean;
+    /** Show projection chart */
+    showProjectionChart?: boolean;
+    /** Callback when timeline range changes */
+    onTimelineChange?: (range: TimelineRange) => void;
+    /** Callback when resource is clicked */
+    onResourceClick?: (resource: ResourceData) => void;
+    /** Callback when recommendation action is triggered */
+    onRecommendationAction?: (recommendation: ScalingRecommendation) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UseCapacityPlannerOptions {
+    /** Initial resources */
+    resources: ResourceData[];
+    /** Threshold configuration */
+    thresholds?: Threshold;
+    /** Initial timeline range */
+    initialTimelineRange?: TimelineRange;
+}
+export interface UseCapacityPlannerReturn {
+    /** Current resources state */
+    resources: ResourceData[];
+    /** Selected timeline range */
+    timelineRange: TimelineRange;
+    /** Current thresholds */
+    thresholds: Threshold;
+    /** Resources at risk (warning or above) */
+    resourcesAtRisk: ResourceData[];
+    /** Resources in critical state */
+    criticalResources: ResourceData[];
+    /** Overall health status */
+    overallHealth: ThresholdStatus;
+    /** Set timeline range */
+    setTimelineRange: (range: TimelineRange) => void;
+    /** Update a resource */
+    updateResource: (id: string, updates: Partial<ResourceData>) => void;
+    /** Get projected value for a resource */
+    getProjectedValue: (resource: ResourceData) => number;
+    /** Get status for a resource */
+    getResourceStatus: (resource: ResourceData) => ThresholdStatus;
+    /** Get projected status for a resource */
+    getProjectedStatus: (resource: ResourceData) => ThresholdStatus;
+    /** Calculate time until threshold breach */
+    getTimeUntilBreach: (resource: ResourceData, threshold: ThresholdStatus) => string | null;
+    /** Set thresholds */
+    setThresholds: (thresholds: Threshold) => void;
+    /** Add a new resource */
+    addResource: (resource: ResourceData) => void;
+    /** Remove a resource */
+    removeResource: (id: string) => void;
+}
+export declare function useCapacityPlanner({ resources: initialResources, thresholds: initialThresholds, initialTimelineRange, }: UseCapacityPlannerOptions): UseCapacityPlannerReturn;
+export declare function WakaCapacityPlanner({ resources, thresholds, recommendations, initialTimelineRange, size, animated, showRecommendations, showTimeline, showProjectionChart, onTimelineChange, onResourceClick, onRecommendationAction, className, }: WakaCapacityPlannerProps): import("react/jsx-runtime").JSX.Element;
+export default WakaCapacityPlanner;

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

@@ -0,0 +1,105 @@
+import React from 'react';
+export interface CarouselImage {
+    src: string;
+    alt: string;
+    title?: string;
+    description?: string;
+    caption?: string;
+    downloadUrl?: string;
+    shareUrl?: string;
+    metadata?: {
+        width?: number;
+        height?: number;
+        size?: string;
+        format?: string;
+    };
+}
+export type CarouselTransition = 'fade' | 'slide' | 'zoom' | 'flip';
+export type CarouselLayout = 'default' | 'fullscreen' | 'compact' | 'gallery';
+export type CarouselTheme = 'light' | 'dark' | 'auto';
+export interface WakaCarouselProps {
+    images: CarouselImage[];
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    showIndicators?: boolean;
+    showNavigation?: boolean;
+    showThumbnails?: boolean;
+    showFullscreen?: boolean;
+    showDownload?: boolean;
+    showShare?: boolean;
+    showCounter?: boolean;
+    showProgress?: boolean;
+    transition?: CarouselTransition;
+    layout?: CarouselLayout;
+    theme?: CarouselTheme;
+    aspectRatio?: '16/9' | '4/3' | '1/1' | '3/2' | 'auto';
+    maxHeight?: string | number;
+    className?: string;
+    imageClassName?: string;
+    indicatorClassName?: string;
+    navigationClassName?: string;
+    thumbnailClassName?: string;
+    overlayClassName?: string;
+    counterClassName?: string;
+    progressClassName?: string;
+    onImageChange?: (index: number, image: CarouselImage) => void;
+    onImageClick?: (image: CarouselImage, index: number) => void;
+    onFullscreenToggle?: (isFullscreen: boolean) => void;
+    onDownload?: (image: CarouselImage, index: number) => void;
+    onShare?: (image: CarouselImage, index: number) => void;
+    onPlayPause?: (isPlaying: boolean) => void;
+    onThumbnailClick?: (index: number) => void;
+    onIndicatorClick?: (index: number) => void;
+    onNavigationClick?: (direction: 'prev' | 'next') => void;
+    onKeyboardNavigation?: (key: string) => void;
+    onTouchStart?: (event: React.TouchEvent) => void;
+    onTouchEnd?: (event: React.TouchEvent) => void;
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeUp?: () => void;
+    onSwipeDown?: () => void;
+    onLoadStart?: (index: number) => void;
+    onLoadEnd?: (index: number) => void;
+    onError?: (index: number, error: Error) => void;
+    onReady?: () => void;
+    onDestroy?: () => void;
+    loop?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnFocus?: boolean;
+    pauseOnTouch?: boolean;
+    keyboardNavigation?: boolean;
+    touchNavigation?: boolean;
+    swipeThreshold?: number;
+    animationDuration?: number;
+    preloadImages?: boolean;
+    lazyLoading?: boolean;
+    imageQuality?: 'low' | 'medium' | 'high' | 'auto';
+    placeholder?: string;
+    errorImage?: string;
+    loadingSpinner?: React.ReactNode;
+    emptyState?: React.ReactNode;
+    customControls?: React.ReactNode;
+    customOverlay?: React.ReactNode;
+    customThumbnails?: React.ReactNode;
+    customIndicators?: React.ReactNode;
+    customNavigation?: React.ReactNode;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    role?: string;
+    virtualScrolling?: boolean;
+    maxVisibleThumbnails?: number;
+    thumbnailSize?: 'small' | 'medium' | 'large';
+    overlayOpacity?: number;
+    overlayGradient?: string;
+    navigationSize?: 'small' | 'medium' | 'large';
+    indicatorSize?: 'small' | 'medium' | 'large';
+    indicatorShape?: 'circle' | 'square' | 'diamond' | 'line';
+    thumbnailAspectRatio?: '1/1' | '4/3' | '16/9' | 'auto';
+    onMount?: () => void;
+    onUnmount?: () => void;
+    onBeforeChange?: (fromIndex: number, toIndex: number) => boolean;
+    onAfterChange?: (index: number) => void;
+}
+export declare const WakaCarousel: React.FC<WakaCarouselProps>;
+export default WakaCarousel;