@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-schedule-picker/index.d.ts

@@ -0,0 +1,100 @@
+import * as React from "react";
+export type SlotStatus = "available" | "selected" | "booked" | "unavailable";
+export interface TimeSlot {
+    id: string;
+    date: Date;
+    startTime: string;
+    endTime: string;
+    status: SlotStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface RecurrenceConfig {
+    enabled: boolean;
+    pattern: "daily" | "weekly" | "biweekly" | "monthly";
+    endDate?: Date;
+    daysOfWeek?: number[];
+}
+export interface BusinessHours {
+    start: string;
+    end: string;
+    daysOfWeek: number[];
+}
+export interface WakaSchedulePickerProps {
+    /** Available time slots */
+    slots?: TimeSlot[];
+    /** Selected slot IDs */
+    selectedSlots?: string[];
+    /** Callback when slots change */
+    onSlotsChange?: (slotIds: string[]) => void;
+    /** Enable multiple slot selection */
+    multiSelect?: boolean;
+    /** Available durations in minutes */
+    durations?: number[];
+    /** Selected duration */
+    selectedDuration?: number;
+    /** Callback when duration changes */
+    onDurationChange?: (duration: number) => void;
+    /** Available time zones */
+    timeZones?: string[];
+    /** Selected time zone */
+    selectedTimeZone?: string;
+    /** Callback when timezone changes */
+    onTimeZoneChange?: (timeZone: string) => void;
+    /** Business hours configuration */
+    businessHours?: BusinessHours;
+    /** Enable recurrence options */
+    showRecurrence?: boolean;
+    /** Recurrence configuration */
+    recurrence?: RecurrenceConfig;
+    /** Callback when recurrence changes */
+    onRecurrenceChange?: (recurrence: RecurrenceConfig) => void;
+    /** Start of week (0 = Sunday, 1 = Monday) */
+    weekStartsOn?: 0 | 1;
+    /** Min selectable date */
+    minDate?: Date;
+    /** Max selectable date */
+    maxDate?: Date;
+    /** Hour format */
+    hourFormat?: "12h" | "24h";
+    /** Locale for date formatting */
+    locale?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** CSS class name */
+    className?: string;
+    /** Slot interval in minutes */
+    slotInterval?: number;
+    /** Show selected slots summary */
+    showSummary?: boolean;
+    /** Custom slot render */
+    renderSlot?: (slot: TimeSlot, isSelected: boolean) => React.ReactNode;
+}
+export interface UseSchedulePickerOptions {
+    initialSlots?: TimeSlot[];
+    initialSelectedSlots?: string[];
+    initialDuration?: number;
+    initialTimeZone?: string;
+    multiSelect?: boolean;
+}
+export interface UseSchedulePickerReturn {
+    slots: TimeSlot[];
+    setSlots: React.Dispatch<React.SetStateAction<TimeSlot[]>>;
+    selectedSlots: string[];
+    setSelectedSlots: React.Dispatch<React.SetStateAction<string[]>>;
+    duration: number;
+    setDuration: React.Dispatch<React.SetStateAction<number>>;
+    timeZone: string;
+    setTimeZone: React.Dispatch<React.SetStateAction<string>>;
+    recurrence: RecurrenceConfig;
+    setRecurrence: React.Dispatch<React.SetStateAction<RecurrenceConfig>>;
+    toggleSlot: (slotId: string) => void;
+    clearSelection: () => void;
+    getSelectedSlotDetails: () => TimeSlot[];
+    isSlotSelected: (slotId: string) => boolean;
+}
+export declare function useSchedulePicker(options?: UseSchedulePickerOptions): UseSchedulePickerReturn;
+export declare function WakaSchedulePicker({ slots: propSlots, selectedSlots: propSelectedSlots, onSlotsChange, multiSelect, durations, selectedDuration: propSelectedDuration, onDurationChange, timeZones, selectedTimeZone: propSelectedTimeZone, onTimeZoneChange, businessHours, showRecurrence, recurrence: propRecurrence, onRecurrenceChange, weekStartsOn, minDate, maxDate, hourFormat, locale, disabled, className, slotInterval, showSummary, renderSlot, }: WakaSchedulePickerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaSchedulePicker {
+    var displayName: string;
+}
+export default WakaSchedulePicker;

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

@@ -0,0 +1,87 @@
+import * as React from "react";
+export type PrizeRarity = "common" | "rare" | "epic" | "legendary";
+export interface Prize {
+    /** Unique identifier */
+    id: string;
+    /** Prize name */
+    name: string;
+    /** Prize description */
+    description?: string;
+    /** Prize rarity */
+    rarity: PrizeRarity;
+    /** Custom icon */
+    icon?: React.ReactNode;
+    /** Image URL for the prize */
+    imageUrl?: string;
+    /** Prize value (points, currency, etc.) */
+    value?: string | number;
+    /** Any additional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface WakaScratchCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The prize to reveal */
+    prize: Prize;
+    /** Width of the card */
+    width?: number;
+    /** Height of the card */
+    height?: number;
+    /** Scratch reveal threshold (0-1) */
+    revealThreshold?: number;
+    /** Brush size for scratching */
+    brushSize?: number;
+    /** Overlay image URL */
+    overlayImage?: string;
+    /** Overlay pattern type */
+    overlayPattern?: "solid" | "stripes" | "dots" | "gradient";
+    /** Overlay color */
+    overlayColor?: string;
+    /** Enable scratch sound */
+    enableSound?: boolean;
+    /** Scratch sound source URL */
+    scratchSoundSrc?: string;
+    /** Reveal sound source URL */
+    revealSoundSrc?: string;
+    /** Callback when scratching starts */
+    onScratchStart?: () => void;
+    /** Callback while scratching with percentage */
+    onScratch?: (percentage: number) => void;
+    /** Callback when fully revealed */
+    onReveal?: (prize: Prize) => void;
+    /** Callback on card reset */
+    onReset?: () => void;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Show scratch progress indicator */
+    showProgress?: boolean;
+    /** Custom render for prize content */
+    renderPrize?: (prize: Prize, revealed: boolean) => React.ReactNode;
+}
+export interface UseScratchCardOptions {
+    /** Initial scratch percentage (0-100) */
+    initialPercentage?: number;
+    /** Reveal threshold (0-100) */
+    threshold?: number;
+    /** Callback when revealed */
+    onReveal?: () => void;
+}
+export interface UseScratchCardReturn {
+    /** Current scratch percentage (0-100) */
+    percentage: number;
+    /** Whether the prize is revealed */
+    isRevealed: boolean;
+    /** Whether currently scratching */
+    isScratching: boolean;
+    /** Set the percentage */
+    setPercentage: (value: number) => void;
+    /** Force reveal */
+    reveal: () => void;
+    /** Reset the card */
+    reset: () => void;
+    /** Start scratching */
+    startScratching: () => void;
+    /** Stop scratching */
+    stopScratching: () => void;
+}
+export declare function useScratchCard({ initialPercentage, threshold, onReveal, }?: UseScratchCardOptions): UseScratchCardReturn;
+export declare const WakaScratchCard: React.ForwardRefExoticComponent<WakaScratchCardProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaScratchCard;

package/dist/components/waka-season-pass/index.d.ts

@@ -0,0 +1,65 @@
+import * as React from "react";
+export interface SeasonPassReward {
+    /** Reward type identifier */
+    type: string;
+    /** Reward value (e.g., amount, item name, etc.) */
+    value: any;
+    /** Custom icon for the reward */
+    icon?: React.ReactNode;
+    /** Whether the reward has been claimed */
+    claimed?: boolean;
+}
+export interface SeasonPassLevel {
+    /** Level number */
+    level: number;
+    /** Free tier reward (available to all players) */
+    freeReward?: SeasonPassReward;
+    /** Premium tier reward (requires premium pass) */
+    premiumReward?: SeasonPassReward;
+    /** XP required to reach this level */
+    xpRequired: number;
+}
+export interface WakaSeasonPassProps {
+    /** Array of season pass levels with rewards */
+    levels: SeasonPassLevel[];
+    /** Current player level */
+    currentLevel: number;
+    /** Current XP amount */
+    currentXP: number;
+    /** Whether the player has the premium pass */
+    isPremium: boolean;
+    /** Date when the season ends */
+    seasonEndsAt?: Date;
+    /** Callback when a reward is claimed */
+    onClaimReward?: (level: number, tier: "free" | "premium") => void;
+    /** Callback when upgrade button is clicked */
+    onUpgrade?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaSeasonPass({ levels, currentLevel, currentXP, isPremium, seasonEndsAt, onClaimReward, onUpgrade, className, }: WakaSeasonPassProps): import("react/jsx-runtime").JSX.Element;
+export interface UseSeasonPassOptions {
+    /** Initial levels configuration */
+    levels: SeasonPassLevel[];
+    /** Initial player level */
+    initialLevel?: number;
+    /** Initial XP */
+    initialXP?: number;
+    /** Initial premium status */
+    initialIsPremium?: boolean;
+    /** Callback when level up occurs */
+    onLevelUp?: (newLevel: number) => void;
+    /** Callback when reward is claimed */
+    onClaimReward?: (level: number, tier: "free" | "premium") => void;
+}
+export declare function useSeasonPass({ levels: initialLevels, initialLevel, initialXP, initialIsPremium, onLevelUp, onClaimReward, }: UseSeasonPassOptions): {
+    levels: SeasonPassLevel[];
+    currentLevel: number;
+    currentXP: number;
+    isPremium: boolean;
+    addXP: (amount: number) => void;
+    claimReward: (level: number, tier: "free" | "premium") => void;
+    upgradeToPremium: () => void;
+    claimableRewardsCount: number;
+    progressPercent: number;
+};

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

@@ -0,0 +1,43 @@
+export interface SecretAccess {
+    user: string;
+    action: "read" | "write" | "rotate";
+    timestamp: Date;
+}
+export interface Secret {
+    id: string;
+    name: string;
+    description?: string;
+    type: "api-key" | "password" | "certificate" | "token" | "other";
+    value?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt?: Date;
+    rotatedAt?: Date;
+    rotationPeriod?: number;
+    lastAccessedAt?: Date;
+    lastAccessedBy?: string;
+    accessHistory?: SecretAccess[];
+    tags?: string[];
+}
+export interface WakaSecretCardProps {
+    /** Secret data */
+    secret: Secret;
+    /** Callback when rotating secret */
+    onRotate?: () => void;
+    /** Callback when deleting secret */
+    onDelete?: () => void;
+    /** Callback when copying secret */
+    onCopy?: () => void;
+    /** Callback when viewing secret value */
+    onView?: () => void;
+    /** Whether the secret value is visible */
+    isValueVisible?: boolean;
+    /** Show access history */
+    showHistory?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaSecretCard({ secret, onRotate, onDelete, onCopy, onView, isValueVisible, showHistory, compact, className, }: WakaSecretCardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultSecret: Secret;

package/dist/components/waka-security-scan-result/index.d.ts

@@ -0,0 +1,45 @@
+export type VulnerabilitySeverity = "critical" | "high" | "medium" | "low" | "info";
+export type ScanType = "sast" | "dast" | "sca" | "secret" | "container";
+export interface Vulnerability {
+    id: string;
+    title: string;
+    description: string;
+    severity: VulnerabilitySeverity;
+    type: ScanType;
+    cveId?: string;
+    cweId?: string;
+    cvssScore?: number;
+    package?: string;
+    version?: string;
+    fixedVersion?: string;
+    file?: string;
+    line?: number;
+    url?: string;
+    remediation?: string;
+}
+export interface ScanSummary {
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+    info: number;
+    total: number;
+}
+export interface WakaSecurityScanResultProps {
+    /** List of vulnerabilities */
+    vulnerabilities: Vulnerability[];
+    /** Scan type */
+    scanType?: ScanType | "all";
+    /** Scan timestamp */
+    scannedAt?: Date;
+    /** Callback when clicking on a vulnerability */
+    onVulnerabilityClick?: (vuln: Vulnerability) => void;
+    /** Callback when viewing CVE details */
+    onViewCVE?: (cveId: string) => void;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaSecurityScanResult({ vulnerabilities, scanType, scannedAt, onVulnerabilityClick, onViewCVE, title, className, }: WakaSecurityScanResultProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultVulnerabilities: Vulnerability[];

package/dist/components/waka-security-score/index.d.ts

@@ -0,0 +1,124 @@
+import * as React from "react";
+export type SecurityLevel = "critical" | "low" | "medium" | "high" | "excellent";
+export type RecommendationPriority = "critical" | "high" | "medium" | "low";
+export type RecommendationStatus = "pending" | "in_progress" | "completed" | "dismissed";
+export interface SecurityCategory {
+    /** Unique identifier for the category */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Score for this category (0-100) */
+    score: number;
+    /** Weight for overall score calculation (default: 1) */
+    weight?: number;
+    /** Icon for the category */
+    icon?: React.ReactNode;
+    /** Description of what this category measures */
+    description?: string;
+}
+export interface SecurityRecommendation {
+    /** Unique identifier */
+    id: string;
+    /** Title of the recommendation */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Priority level */
+    priority: RecommendationPriority;
+    /** Current status */
+    status: RecommendationStatus;
+    /** Category this belongs to */
+    categoryId?: string;
+    /** Impact on score if fixed (points) */
+    impact?: number;
+    /** Estimated time to fix */
+    estimatedTime?: string;
+    /** Action button label */
+    actionLabel?: string;
+    /** Action callback */
+    onAction?: () => void;
+}
+export interface ScoreHistoryPoint {
+    /** Timestamp */
+    timestamp: Date | string;
+    /** Score at this point */
+    score: number;
+    /** Optional label */
+    label?: string;
+}
+export interface WakaSecurityScoreProps {
+    /** Overall security score (0-100) */
+    score: number;
+    /** Score breakdown by category */
+    categories?: SecurityCategory[];
+    /** Security recommendations */
+    recommendations?: SecurityRecommendation[];
+    /** Score history for graph */
+    history?: ScoreHistoryPoint[];
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show category breakdown */
+    showCategories?: boolean;
+    /** Show recommendations list */
+    showRecommendations?: boolean;
+    /** Show score history graph */
+    showHistory?: boolean;
+    /** Animate score on mount */
+    animated?: boolean;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Maximum recommendations to show (default: 5) */
+    maxRecommendations?: number;
+    /** Custom className */
+    className?: string;
+    /** Callback when recommendation action is triggered */
+    onRecommendationAction?: (recommendation: SecurityRecommendation) => void;
+    /** Callback when score changes */
+    onScoreChange?: (score: number) => void;
+}
+export interface UseSecurityScoreOptions {
+    /** Initial score */
+    initialScore?: number;
+    /** Initial categories */
+    initialCategories?: SecurityCategory[];
+    /** Initial recommendations */
+    initialRecommendations?: SecurityRecommendation[];
+    /** Callback when score updates */
+    onScoreUpdate?: (score: number, previousScore: number) => void;
+}
+export declare function useSecurityScore({ initialScore, initialCategories, initialRecommendations, onScoreUpdate, }?: UseSecurityScoreOptions): {
+    score: number;
+    setScore: (newScore: number) => void;
+    categories: SecurityCategory[];
+    setCategories: React.Dispatch<React.SetStateAction<SecurityCategory[]>>;
+    recommendations: SecurityRecommendation[];
+    setRecommendations: React.Dispatch<React.SetStateAction<SecurityRecommendation[]>>;
+    history: ScoreHistoryPoint[];
+    setHistory: React.Dispatch<React.SetStateAction<ScoreHistoryPoint[]>>;
+    updateCategory: (categoryId: string, updates: Partial<SecurityCategory>) => void;
+    updateRecommendation: (recommendationId: string, updates: Partial<SecurityRecommendation>) => void;
+    completeRecommendation: (recommendationId: string) => void;
+    calculateScore: (cats: SecurityCategory[]) => number;
+    completedCount: number;
+    pendingCount: number;
+    level: SecurityLevel;
+};
+export declare function WakaSecurityScore({ score, categories, recommendations, history, size, showCategories, showRecommendations, showHistory, animated, animationDuration, maxRecommendations, className, onRecommendationAction, onScoreChange, }: WakaSecurityScoreProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaSecurityScore {
+    var displayName: string;
+}
+export interface WakaSecurityScoreCompactProps {
+    /** Security score (0-100) */
+    score: number;
+    /** Show trend indicator */
+    showTrend?: boolean;
+    /** Previous score for trend calculation */
+    previousScore?: number;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaSecurityScoreCompact({ score, showTrend, previousScore, className, }: WakaSecurityScoreCompactProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaSecurityScoreCompact {
+    var displayName: string;
+}
+export default WakaSecurityScore;

package/dist/components/waka-segmented-control/index.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+export interface SegmentOption<T = string> {
+    /** Valeur de l'option */
+    value: T;
+    /** Libellé affiché */
+    label: string;
+    /** Icône */
+    icon?: React.ReactNode;
+    /** Désactiver l'option */
+    disabled?: boolean;
+}
+export interface WakaSegmentedControlProps<T = string> {
+    /** Options disponibles */
+    options: SegmentOption<T>[];
+    /** Valeur sélectionnée */
+    value?: T;
+    /** Callback lors du changement */
+    onChange?: (value: T) => void;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Variante */
+    variant?: "default" | "pills";
+    /** Prendre toute la largeur */
+    fullWidth?: boolean;
+    /** Désactiver tout le contrôle */
+    disabled?: boolean;
+    /** Nom pour les formulaires */
+    name?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaSegmentedControl<T = string>({ options, value, onChange, size, variant, fullWidth, disabled, name, className, }: WakaSegmentedControlProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function useSegmentedControl<T = string>(options: SegmentOption<T>[], initialValue?: T): {
+    value: T;
+    onChange: React.Dispatch<React.SetStateAction<T>>;
+    selectNext: () => void;
+    selectPrevious: () => void;
+    selectFirst: () => void;
+    selectLast: () => void;
+    options: SegmentOption<T>[];
+};
+export default WakaSegmentedControl;

package/dist/components/waka-server-rack/index.d.ts

@@ -0,0 +1,44 @@
+export interface ServerUnit {
+    /** Unique server identifier */
+    id: string;
+    /** Server display name */
+    name: string;
+    /** Rack position (1-42 from bottom) */
+    unit: number;
+    /** Height in rack units (1U, 2U, etc.) */
+    height: number;
+    /** Server operational status */
+    status: "online" | "warning" | "offline" | "maintenance";
+    /** CPU usage percentage (0-100) */
+    cpu: number;
+    /** RAM usage percentage (0-100) */
+    ram: number;
+    /** Disk usage percentage (0-100) */
+    disk: number;
+    /** Network throughput */
+    network?: {
+        in: number;
+        out: number;
+    };
+}
+export interface WakaServerRackProps {
+    /** Array of server units to display */
+    servers: ServerUnit[];
+    /** Total rack units available (default 42) */
+    totalUnits?: number;
+    /** Callback when a server is clicked */
+    onServerClick?: (id: string) => void;
+    /** Currently selected server ID */
+    selectedServer?: string;
+    /** Show CPU/RAM/Disk metrics bars */
+    showMetrics?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaServerRack({ servers, totalUnits, onServerClick, selectedServer, showMetrics, animated, className, }: WakaServerRackProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaServerRackDemoProps {
+    className?: string;
+}
+export declare function WakaServerRackDemo({ className }: WakaServerRackDemoProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/waka-service-graph/index.d.ts

@@ -0,0 +1,44 @@
+export type ServiceHealth = "healthy" | "degraded" | "unhealthy" | "unknown";
+export type ServiceType = "api" | "database" | "cache" | "queue" | "gateway" | "external";
+export interface ServiceNode {
+    id: string;
+    name: string;
+    type: ServiceType;
+    health: ServiceHealth;
+    namespace?: string;
+    version?: string;
+    replicas?: number;
+    requestsPerSec?: number;
+    errorRate?: number;
+    latencyP50?: number;
+    latencyP99?: number;
+}
+export interface ServiceConnection {
+    source: string;
+    target: string;
+    protocol?: string;
+    requestsPerSec?: number;
+    errorRate?: number;
+    latency?: number;
+}
+export interface WakaServiceGraphProps {
+    /** List of services */
+    services: ServiceNode[];
+    /** List of connections between services */
+    connections: ServiceConnection[];
+    /** Selected service ID */
+    selectedService?: string;
+    /** Callback when clicking on a service */
+    onServiceClick?: (service: ServiceNode) => void;
+    /** Callback when clicking on a connection */
+    onConnectionClick?: (connection: ServiceConnection) => void;
+    /** Callback when refreshing */
+    onRefresh?: () => void;
+    /** Show metrics on nodes */
+    showMetrics?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaServiceGraph({ services, connections, selectedService, onServiceClick, onConnectionClick, onRefresh, showMetrics, className, }: WakaServiceGraphProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultServices: ServiceNode[];
+export declare const defaultConnections: ServiceConnection[];