@wakastellar/ui 1.0.12 → 2.0.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-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-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-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;

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

@@ -0,0 +1,61 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+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" | "flat" | "glass" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => 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-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;