@wakastellar/ui 3.5.0 → 4.0.0-dev.0

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

@@ -0,0 +1,193 @@
+export interface Resource {
+    /** Unique identifier for the resource */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Optional category for grouping */
+    category?: string;
+    /** Maximum capacity (default: 100) */
+    capacity?: number;
+    /** Custom color for the resource row */
+    color?: string;
+}
+export interface Consumer {
+    /** Unique identifier for the consumer/project */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Optional priority level */
+    priority?: "low" | "medium" | "high" | "critical";
+    /** Custom color for the consumer column */
+    color?: string;
+}
+export interface Allocation {
+    /** Resource ID */
+    resourceId: string;
+    /** Consumer ID */
+    consumerId: string;
+    /** Allocation percentage (0-100+) */
+    value: number;
+}
+export type SortField = "name" | "total" | "allocation";
+export type SortDirection = "asc" | "desc";
+export type FilterMode = "all" | "over-allocated" | "under-allocated" | "unallocated";
+export interface AllocationMatrixState {
+    /** Current allocations */
+    allocations: Map<string, number>;
+    /** Selected cell for editing */
+    selectedCell: {
+        resourceId: string;
+        consumerId: string;
+    } | null;
+    /** Row sort configuration */
+    rowSort: {
+        field: SortField;
+        direction: SortDirection;
+    };
+    /** Column sort configuration */
+    columnSort: {
+        field: SortField;
+        direction: SortDirection;
+    };
+    /** Filter mode */
+    filterMode: FilterMode;
+    /** Search query */
+    searchQuery: string;
+    /** Dragging state */
+    isDragging: boolean;
+    /** Drag start value */
+    dragStartValue: number;
+}
+export interface AllocationSummary {
+    /** Total allocations across all cells */
+    totalAllocations: number;
+    /** Average allocation per cell */
+    averageAllocation: number;
+    /** Number of over-allocated resources (>100%) */
+    overAllocatedCount: number;
+    /** Number of under-allocated resources (<100%) */
+    underAllocatedCount: number;
+    /** Number of fully allocated resources (=100%) */
+    fullyAllocatedCount: number;
+    /** Number of unallocated resources (0%) */
+    unallocatedCount: number;
+    /** Utilization efficiency percentage */
+    utilizationEfficiency: number;
+}
+export interface WakaAllocationMatrixProps {
+    /** Resources (rows) */
+    resources: Resource[];
+    /** Consumers/Projects (columns) */
+    consumers: Consumer[];
+    /** Initial allocations */
+    allocations?: Allocation[];
+    /** Enable editing */
+    editable?: boolean;
+    /** Enable drag to adjust allocations */
+    enableDrag?: boolean;
+    /** Show row totals */
+    showRowTotals?: boolean;
+    /** Show column totals */
+    showColumnTotals?: boolean;
+    /** Show summary statistics */
+    showSummary?: boolean;
+    /** Show filter controls */
+    showFilters?: boolean;
+    /** Show search */
+    showSearch?: boolean;
+    /** Over-allocation threshold (default: 100) */
+    overAllocationThreshold?: number;
+    /** Cell size */
+    cellSize?: "sm" | "md" | "lg";
+    /** Color scheme for intensity */
+    colorScheme?: "blue" | "green" | "purple" | "orange";
+    /** Callback when allocation changes */
+    onAllocationChange?: (resourceId: string, consumerId: string, value: number) => void;
+    /** Callback when allocations are saved */
+    onSave?: (allocations: Allocation[]) => void;
+    /** Custom value formatter */
+    formatValue?: (value: number) => string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UseAllocationMatrixOptions {
+    /** Initial resources */
+    resources: Resource[];
+    /** Initial consumers */
+    consumers: Consumer[];
+    /** Initial allocations */
+    initialAllocations?: Allocation[];
+    /** Over-allocation threshold */
+    overAllocationThreshold?: number;
+    /** Callback when allocation changes */
+    onAllocationChange?: (resourceId: string, consumerId: string, value: number) => void;
+}
+export interface UseAllocationMatrixReturn {
+    /** Current allocations map */
+    allocations: Map<string, number>;
+    /** Set allocation for a cell */
+    setAllocation: (resourceId: string, consumerId: string, value: number) => void;
+    /** Get allocation for a cell */
+    getAllocation: (resourceId: string, consumerId: string) => number;
+    /** Get row total */
+    getRowTotal: (resourceId: string) => number;
+    /** Get column total */
+    getColumnTotal: (consumerId: string) => number;
+    /** Check if resource is over-allocated */
+    isOverAllocated: (resourceId: string) => boolean;
+    /** Get summary statistics */
+    getSummary: () => AllocationSummary;
+    /** Clear all allocations */
+    clearAll: () => void;
+    /** Reset to initial allocations */
+    reset: () => void;
+    /** Export allocations as array */
+    exportAllocations: () => Allocation[];
+    /** Import allocations from array */
+    importAllocations: (allocations: Allocation[]) => void;
+    /** Selected cell */
+    selectedCell: {
+        resourceId: string;
+        consumerId: string;
+    } | null;
+    /** Set selected cell */
+    setSelectedCell: (cell: {
+        resourceId: string;
+        consumerId: string;
+    } | null) => void;
+    /** Row sort */
+    rowSort: {
+        field: SortField;
+        direction: SortDirection;
+    };
+    /** Set row sort */
+    setRowSort: (sort: {
+        field: SortField;
+        direction: SortDirection;
+    }) => void;
+    /** Column sort */
+    columnSort: {
+        field: SortField;
+        direction: SortDirection;
+    };
+    /** Set column sort */
+    setColumnSort: (sort: {
+        field: SortField;
+        direction: SortDirection;
+    }) => void;
+    /** Filter mode */
+    filterMode: FilterMode;
+    /** Set filter mode */
+    setFilterMode: (mode: FilterMode) => void;
+    /** Search query */
+    searchQuery: string;
+    /** Set search query */
+    setSearchQuery: (query: string) => void;
+    /** Sorted and filtered resources */
+    filteredResources: Resource[];
+    /** Sorted consumers */
+    sortedConsumers: Consumer[];
+}
+export declare function useAllocationMatrix({ resources, consumers, initialAllocations, overAllocationThreshold, onAllocationChange, }: UseAllocationMatrixOptions): UseAllocationMatrixReturn;
+export declare function WakaAllocationMatrix({ resources, consumers, allocations: initialAllocations, editable, enableDrag, showRowTotals, showColumnTotals, showSummary, showFilters, showSearch, overAllocationThreshold, cellSize, colorScheme, onAllocationChange, onSave, formatValue, className, }: WakaAllocationMatrixProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAllocationMatrix;

package/dist/components/waka-approval-chain/index.d.ts

@@ -0,0 +1,43 @@
+export type ApprovalStatus = "pending" | "approved" | "rejected" | "skipped";
+export interface Approver {
+    /** Unique identifier for the approver */
+    id: string;
+    /** Approver's display name */
+    name: string;
+    /** Approver's avatar URL */
+    avatar?: string;
+    /** Approver's role/title */
+    role?: string;
+}
+export interface ApprovalStep {
+    /** Unique identifier for the step */
+    id: string;
+    /** Approver information */
+    approver: Approver;
+    /** Current status of the approval step */
+    status: ApprovalStatus;
+    /** Timestamp when action was taken */
+    timestamp?: Date;
+    /** Comment left by the approver */
+    comment?: string;
+}
+export interface WakaApprovalChainProps {
+    /** Array of approval steps */
+    steps: ApprovalStep[];
+    /** Current user's ID (to show approve/reject actions) */
+    currentUserId?: string;
+    /** Callback when approve is clicked */
+    onApprove?: (stepId: string, comment?: string) => void;
+    /** Callback when reject is clicked */
+    onReject?: (stepId: string, comment?: string) => void;
+    /** Layout variant */
+    variant?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Whether to show comments */
+    showComments?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaApprovalChain({ steps, currentUserId, onApprove, onReject, variant, size, showComments, className, }: WakaApprovalChainProps): import("react/jsx-runtime").JSX.Element;
+export default WakaApprovalChain;

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

@@ -0,0 +1,32 @@
+export interface Artifact {
+    id: string;
+    name: string;
+    type: "archive" | "binary" | "log" | "report" | "image" | "other";
+    size: number;
+    createdAt: Date;
+    expiresAt?: Date;
+    downloadUrl?: string;
+    sha256?: string;
+    buildId?: string;
+    metadata?: Record<string, string>;
+}
+export interface WakaArtifactListProps {
+    /** List of artifacts */
+    artifacts: Artifact[];
+    /** Callback when downloading an artifact */
+    onDownload?: (artifact: Artifact) => void;
+    /** Callback when deleting an artifact */
+    onDelete?: (artifact: Artifact) => void;
+    /** Callback when viewing artifact details */
+    onView?: (artifact: Artifact) => void;
+    /** Title */
+    title?: string;
+    /** Show expiration */
+    showExpiration?: boolean;
+    /** Allow deletion */
+    allowDelete?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaArtifactList({ artifacts, onDownload, onDelete, onView, title, showExpiration, allowDelete, className, }: WakaArtifactListProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultArtifacts: Artifact[];

package/dist/components/waka-audit-log/index.d.ts

@@ -0,0 +1,142 @@
+export type AuditEventType = "login" | "logout" | "create" | "update" | "delete" | "view" | "export" | "import" | "settings_change" | "permission_change" | "password_change" | "user_invite" | "user_remove" | "api_key_create" | "api_key_revoke" | "mfa_enable" | "mfa_disable" | "session_revoke" | "file_upload" | "file_download" | "payment" | "subscription_change" | "data_export" | "backup" | "restore";
+export type AuditSeverity = "info" | "warning" | "critical";
+export interface AuditUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Email address */
+    email?: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** User role */
+    role?: string;
+}
+export interface AuditLocation {
+    /** City name */
+    city?: string;
+    /** Country name */
+    country?: string;
+    /** Country code */
+    countryCode?: string;
+}
+export interface AuditEvent {
+    /** Unique event identifier */
+    id: string;
+    /** Event type */
+    type: AuditEventType;
+    /** Severity level */
+    severity: AuditSeverity;
+    /** User who performed the action */
+    user: AuditUser;
+    /** Event description */
+    description: string;
+    /** Detailed action information */
+    details?: Record<string, any>;
+    /** IP address */
+    ipAddress?: string;
+    /** User agent string */
+    userAgent?: string;
+    /** Location information */
+    location?: AuditLocation;
+    /** Resource affected (e.g., "User: john@example.com") */
+    resource?: string;
+    /** When the event occurred */
+    timestamp: Date;
+    /** Session ID */
+    sessionId?: string;
+    /** Request ID for tracing */
+    requestId?: string;
+}
+export interface AuditFilters {
+    /** Filter by event types */
+    eventTypes?: AuditEventType[];
+    /** Filter by severity levels */
+    severities?: AuditSeverity[];
+    /** Filter by user IDs */
+    userIds?: string[];
+    /** Search query */
+    search?: string;
+    /** Start date */
+    startDate?: Date;
+    /** End date */
+    endDate?: Date;
+}
+export interface WakaAuditLogProps {
+    /** List of audit events */
+    events: AuditEvent[];
+    /** Callback when an event is clicked */
+    onEventClick?: (event: AuditEvent) => void;
+    /** Callback when filters change */
+    onFilterChange?: (filters: AuditFilters) => void;
+    /** Callback when load more is triggered (pagination/infinite scroll) */
+    onLoadMore?: () => void;
+    /** Callback when export is requested */
+    onExport?: (format: "csv" | "json") => void;
+    /** Whether more events can be loaded */
+    hasMore?: boolean;
+    /** Whether events are currently loading */
+    loading?: boolean;
+    /** Whether to show filter controls */
+    showFilters?: boolean;
+    /** Whether to show search */
+    showSearch?: boolean;
+    /** Whether to show export button */
+    showExport?: boolean;
+    /** Whether to use infinite scroll instead of pagination */
+    infiniteScroll?: boolean;
+    /** Maximum number of events to display */
+    maxItems?: number;
+    /** Available users for filtering */
+    users?: AuditUser[];
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaAuditLog({ events, onEventClick, onFilterChange, onLoadMore, onExport, hasMore, loading, showFilters, showSearch, showExport, infiniteScroll, maxItems, users, className, }: WakaAuditLogProps): import("react/jsx-runtime").JSX.Element;
+export interface UseAuditLogOptions {
+    /** Initial events */
+    initialEvents?: AuditEvent[];
+    /** Maximum events to keep in memory */
+    maxEvents?: number;
+    /** Initial filters */
+    initialFilters?: AuditFilters;
+}
+export interface UseAuditLogReturn {
+    /** Current audit events */
+    events: AuditEvent[];
+    /** Current filters */
+    filters: AuditFilters;
+    /** Loading state */
+    loading: boolean;
+    /** Whether more events can be loaded */
+    hasMore: boolean;
+    /** Add a new event */
+    addEvent: (event: AuditEvent) => void;
+    /** Add multiple events */
+    addEvents: (events: AuditEvent[]) => void;
+    /** Remove an event */
+    removeEvent: (eventId: string) => void;
+    /** Set filters */
+    setFilters: (filters: AuditFilters) => void;
+    /** Clear all filters */
+    clearFilters: () => void;
+    /** Load more events */
+    loadMore: (fetcher: () => Promise<{
+        events: AuditEvent[];
+        hasMore: boolean;
+    }>) => Promise<void>;
+    /** Refresh all events */
+    refresh: (events: AuditEvent[]) => void;
+    /** Clear all events */
+    clear: () => void;
+    /** Set loading state */
+    setLoading: (loading: boolean) => void;
+    /** Set has more state */
+    setHasMore: (hasMore: boolean) => void;
+    /** Export events to format */
+    exportEvents: (format: "csv" | "json") => string;
+    /** Get filtered events */
+    getFilteredEvents: () => AuditEvent[];
+}
+export declare function useAuditLog({ initialEvents, maxEvents, initialFilters, }?: UseAuditLogOptions): UseAuditLogReturn;
+export default WakaAuditLog;

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

@@ -0,0 +1,59 @@
+import * as React from "react";
+export interface AutocompleteOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+export interface WakaAutocompleteProps {
+    /** Options disponibles */
+    options: AutocompleteOption[];
+    /** Valeur sélectionnée (string ou array pour multiple) */
+    value?: string | string[];
+    /** Callback de changement */
+    onChange?: (value: string | string[] | null) => void;
+    /** Recherche asynchrone */
+    onSearch?: (query: string) => Promise<AutocompleteOption[]>;
+    /** Mode sélection multiple */
+    multiple?: boolean;
+    /** Permet de créer de nouvelles options */
+    creatable?: boolean;
+    /** Callback lors de la création d'une option */
+    onCreate?: (value: string) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Message quand aucun résultat */
+    emptyMessage?: string;
+    /** Chargement en cours */
+    loading?: boolean;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: string;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Nombre max de sélections (mode multiple) */
+    maxSelections?: number;
+    /** Tri des options */
+    sortOptions?: boolean;
+    /** Debounce pour la recherche (ms) */
+    searchDebounce?: number;
+}
+/**
+ * Composant WakaAutocomplete
+ */
+export declare const WakaAutocomplete: React.ForwardRefExoticComponent<WakaAutocompleteProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Version intégrée avec react-hook-form via Controller
+ */
+export interface WakaAutocompleteFormProps extends Omit<WakaAutocompleteProps, "value" | "onChange"> {
+    name: string;
+    value?: string | string[];
+    onChange?: (value: string | string[] | null) => void;
+}
+export declare const WakaAutocompleteForm: React.ForwardRefExoticComponent<WakaAutocompleteFormProps & React.RefAttributes<HTMLButtonElement>>;
+export default WakaAutocomplete;

package/dist/components/waka-badge-showcase/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export type BadgeRarity = "common" | "rare" | "epic" | "legendary";
+export interface Badge {
+    /** Unique identifier */
+    id: string;
+    /** Badge name */
+    name: string;
+    /** Badge description */
+    description: string;
+    /** Badge icon (React node) */
+    icon: React.ReactNode;
+    /** Rarity tier */
+    rarity: BadgeRarity;
+    /** Whether the badge is unlocked */
+    unlocked: boolean;
+    /** When the badge was unlocked */
+    unlockedAt?: Date;
+    /** Progress towards unlocking (0-100) */
+    progress?: number;
+    /** Badge category */
+    category?: string;
+    /** Whether this is a newly unlocked badge */
+    isNew?: boolean;
+}
+export interface WakaBadgeShowcaseProps {
+    /** Array of badges to display */
+    badges: Badge[];
+    /** Callback when a badge is clicked */
+    onBadgeClick?: (id: string) => void;
+    /** Display variant */
+    variant?: "grid" | "list" | "showcase";
+    /** Whether to show locked badges */
+    showLocked?: boolean;
+    /** Whether to show progress indicators */
+    showProgress?: boolean;
+    /** Number of columns for grid layout */
+    columns?: number;
+    /** Size of badge icons */
+    size?: "sm" | "md" | "lg";
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaBadgeShowcase({ badges, onBadgeClick, variant, showLocked, showProgress, columns, size, className, }: WakaBadgeShowcaseProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaBadgeShowcaseCompact(props: Omit<WakaBadgeShowcaseProps, "variant" | "size" | "columns">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaBadgeShowcaseList(props: Omit<WakaBadgeShowcaseProps, "variant">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaBadgeShowcaseHero(props: Omit<WakaBadgeShowcaseProps, "variant" | "size">): import("react/jsx-runtime").JSX.Element;
+export interface WakaBadgeStatsProps {
+    badges: Badge[];
+    className?: string;
+}
+export declare function WakaBadgeStats({ badges, className }: WakaBadgeStatsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,27 @@
+export type BarcodeFormat = "CODE128" | "CODE39" | "EAN13" | "EAN8" | "UPC" | "ITF14";
+export interface WakaBarcodeProps {
+    /** Valeur à encoder */
+    value: string;
+    /** Format du code-barres */
+    format?: BarcodeFormat;
+    /** Largeur en pixels */
+    width?: number;
+    /** Hauteur en pixels */
+    height?: number;
+    /** Afficher le texte sous le code */
+    displayValue?: boolean;
+    /** Couleur des barres */
+    lineColor?: string;
+    /** Couleur de fond */
+    background?: string;
+    /** Taille de la police */
+    fontSize?: number;
+    /** Marge en pixels */
+    margin?: number;
+    /** Afficher les actions */
+    showActions?: boolean;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaBarcode({ value, format, width, height, displayValue, lineColor, background, fontSize, margin, showActions, className, }: WakaBarcodeProps): import("react/jsx-runtime").JSX.Element;
+export default WakaBarcode;

package/dist/components/waka-biometric-prompt/index.d.ts

@@ -0,0 +1,84 @@
+import * as React from "react";
+export type BiometricType = "fingerprint" | "face" | "iris" | "voice";
+export type BiometricState = "idle" | "scanning" | "success" | "error";
+export interface BiometricPromptConfig {
+    /** Type of biometric authentication */
+    type: BiometricType;
+    /** Custom label for the biometric type */
+    label?: string;
+    /** Custom icon component */
+    icon?: React.ReactNode;
+}
+export interface WakaBiometricPromptProps {
+    /** Available biometric types */
+    biometricTypes?: BiometricPromptConfig[];
+    /** Currently selected biometric type */
+    selectedType?: BiometricType;
+    /** Callback when biometric type changes */
+    onTypeChange?: (type: BiometricType) => void;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Current authentication state */
+    state?: BiometricState;
+    /** Error message when state is "error" */
+    errorMessage?: string;
+    /** Callback when authentication is initiated */
+    onAuthenticate?: () => void | Promise<void>;
+    /** Callback when retry is clicked */
+    onRetry?: () => void;
+    /** Callback when cancel is clicked */
+    onCancel?: () => void;
+    /** Callback when fallback to password is clicked */
+    onFallbackToPassword?: () => void;
+    /** Show fallback to password option */
+    showPasswordFallback?: boolean;
+    /** Show cancel button */
+    showCancel?: boolean;
+    /** Custom scanning duration in ms (for demo purposes) */
+    scanningDuration?: number;
+    /** Success message */
+    successMessage?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Color scheme */
+    colorScheme?: "default" | "primary" | "dark";
+}
+export interface UseBiometricPromptOptions {
+    /** Initial biometric type */
+    initialType?: BiometricType;
+    /** Simulated scanning duration */
+    scanningDuration?: number;
+    /** Simulated success rate (0-1, for demo) */
+    successRate?: number;
+    /** Callback on successful authentication */
+    onSuccess?: () => void;
+    /** Callback on authentication error */
+    onError?: (error: string) => void;
+    /** Actual authentication function */
+    authenticate?: () => Promise<boolean>;
+}
+export interface UseBiometricPromptReturn {
+    /** Current state */
+    state: BiometricState;
+    /** Current biometric type */
+    selectedType: BiometricType;
+    /** Error message if any */
+    errorMessage: string | null;
+    /** Set biometric type */
+    setSelectedType: (type: BiometricType) => void;
+    /** Start authentication */
+    startAuthentication: () => Promise<void>;
+    /** Retry authentication */
+    retry: () => void;
+    /** Reset to idle state */
+    reset: () => void;
+    /** Cancel authentication */
+    cancel: () => void;
+}
+export declare function useBiometricPrompt(options?: UseBiometricPromptOptions): UseBiometricPromptReturn;
+export declare const WakaBiometricPrompt: React.ForwardRefExoticComponent<WakaBiometricPromptProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaBiometricPrompt;