@wakastellar/ui 1.0.12 → 2.0.0

package/dist/components/waka-phone-input/index.d.ts

@@ -0,0 +1,93 @@
+export interface Country {
+    code: string;
+    name: string;
+    dialCode: string;
+    flag: string;
+    format?: string;
+    priority?: number;
+}
+declare const COUNTRIES: Country[];
+export interface PhoneValue {
+    countryCode: string;
+    dialCode: string;
+    nationalNumber: string;
+    fullNumber: string;
+    isValid: boolean;
+}
+export interface WakaPhoneInputProps {
+    /** Current value */
+    value?: PhoneValue | string;
+    /** Callback when value changes */
+    onChange?: (value: PhoneValue) => void;
+    /** Default country code (ISO 3166-1 alpha-2) */
+    defaultCountry?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show copy button */
+    showCopy?: boolean;
+    /** Show clear button */
+    showClear?: boolean;
+    /** Callback when copy is clicked */
+    onCopy?: (value: string) => void;
+    /** Country filter - only show these countries */
+    countries?: string[];
+    /** Popular countries to show at top */
+    preferredCountries?: string[];
+    /** Custom validation function */
+    validate?: (value: PhoneValue) => boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** ID for accessibility */
+    id?: string;
+    /** Name for form submission */
+    name?: string;
+    /** Required field */
+    required?: boolean;
+    /** Auto focus on mount */
+    autoFocus?: boolean;
+}
+declare function formatPhoneNumber(value: string, format?: string): string;
+declare function unformatPhoneNumber(value: string): string;
+declare function getCountryByCode(code: string): Country | undefined;
+declare function getCountryByDialCode(dialCode: string): Country | undefined;
+export interface UsePhoneInputOptions {
+    /** Initial country code */
+    initialCountry?: string;
+    /** Initial phone number */
+    initialValue?: string;
+    /** Custom validation function */
+    validate?: (value: PhoneValue) => boolean;
+}
+export interface UsePhoneInputReturn {
+    /** Current country */
+    country: Country;
+    /** Set country by code */
+    setCountry: (code: string) => void;
+    /** Current national number (without dial code) */
+    nationalNumber: string;
+    /** Set national number */
+    setNationalNumber: (value: string) => void;
+    /** Full phone value object */
+    value: PhoneValue;
+    /** Whether the phone number is valid */
+    isValid: boolean;
+    /** Format a phone number */
+    format: (value: string) => string;
+    /** Unformat a phone number (get only digits) */
+    unformat: (value: string) => string;
+    /** Clear the input */
+    clear: () => void;
+    /** Get full international number */
+    getFullNumber: () => string;
+}
+export declare function usePhoneInput(options?: UsePhoneInputOptions): UsePhoneInputReturn;
+export declare function WakaPhoneInput({ value, onChange, defaultCountry, placeholder, disabled, error, size, showCopy, showClear, onCopy, countries, preferredCountries, validate, className, id, name, required, autoFocus, }: WakaPhoneInputProps): import("react/jsx-runtime").JSX.Element;
+export { COUNTRIES };
+export { formatPhoneNumber, unformatPhoneNumber, getCountryByCode, getCountryByDialCode };
+export default WakaPhoneInput;

package/dist/components/waka-pipeline-view/index.d.ts

@@ -0,0 +1,49 @@
+export type StageStatus = "pending" | "running" | "success" | "failed" | "skipped" | "cancelled";
+export interface PipelineJob {
+    /** Unique identifier */
+    id: string;
+    /** Job name */
+    name: string;
+    /** Job status */
+    status: StageStatus;
+    /** Duration in seconds */
+    duration?: number;
+}
+export interface PipelineStage {
+    /** Unique identifier */
+    id: string;
+    /** Stage name */
+    name: string;
+    /** Stage status */
+    status: StageStatus;
+    /** Duration in seconds */
+    duration?: number;
+    /** Parallel jobs within this stage */
+    jobs?: PipelineJob[];
+    /** When the stage started */
+    startedAt?: Date;
+    /** When the stage finished */
+    finishedAt?: Date;
+}
+export interface WakaPipelineViewProps {
+    /** Pipeline stages */
+    stages: PipelineStage[];
+    /** Callback when a stage is clicked */
+    onStageClick?: (stageId: string) => void;
+    /** Callback when retry is triggered on a failed stage */
+    onRetry?: (stageId: string) => void;
+    /** Layout variant */
+    variant?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show duration for each stage */
+    showDuration?: boolean;
+    /** Show parallel jobs within stages */
+    showJobs?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaPipelineView({ stages, onStageClick, onRetry, variant, size, showDuration, showJobs, animated, className, }: WakaPipelineViewProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPipelineView;

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

@@ -0,0 +1,36 @@
+import * as React from "react";
+export type PlayerRarity = "common" | "rare" | "epic" | "legendary" | "mythic";
+export interface PlayerStat {
+    name: string;
+    value: number;
+    max?: number;
+}
+export interface Player {
+    id: string;
+    name: string;
+    avatar: string;
+    title?: string;
+    level: number;
+    rarity: PlayerRarity;
+    stats: PlayerStat[];
+    achievements?: number;
+    joinedAt?: Date;
+}
+export interface WakaPlayerCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onClick"> {
+    /** Player data */
+    player: Player;
+    /** Card variant */
+    variant?: "default" | "compact" | "full";
+    /** Show back side on hover */
+    showBack?: boolean;
+    /** Custom back content */
+    backContent?: React.ReactNode;
+    /** Click handler */
+    onClick?: () => void;
+    /** Card size */
+    size?: "sm" | "md" | "lg";
+    /** Enable animations */
+    animated?: boolean;
+}
+export declare function WakaPlayerCard({ player, variant, showBack, backContent, onClick, size, animated, className, ...props }: WakaPlayerCardProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPlayerCard;

package/dist/components/waka-points-popup/index.d.ts

@@ -0,0 +1,75 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export interface WakaPointsPopupProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof pointsPopupVariants> {
+    /** The points value to display (positive or negative) */
+    points: number;
+    /** X position (defaults to center) */
+    x?: number;
+    /** Y position (defaults to center) */
+    y?: number;
+    /** Custom color (overrides automatic color coding) */
+    color?: string;
+    /** Animation duration in milliseconds */
+    duration?: number;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Optional prefix (e.g., "XP", "pts") */
+    prefix?: string;
+    /** Optional icon to display before the points */
+    icon?: React.ReactNode;
+}
+export interface PopupInstance {
+    id: string;
+    points: number;
+    x: number;
+    y: number;
+    color?: string;
+    duration: number;
+    size: "sm" | "md" | "lg";
+    prefix?: string;
+    icon?: React.ReactNode;
+}
+export interface TriggerOptions {
+    x?: number;
+    y?: number;
+    color?: string;
+    duration?: number;
+    size?: "sm" | "md" | "lg";
+    prefix?: string;
+    icon?: React.ReactNode;
+}
+export interface UsePointsPopupReturn {
+    /** Trigger a new popup */
+    trigger: (points: number, options?: TriggerOptions) => void;
+    /** Container component to render popups */
+    PopupContainer: React.FC;
+    /** Clear all active popups */
+    clearAll: () => void;
+}
+declare const pointsPopupVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export declare const WakaPointsPopup: React.ForwardRefExoticComponent<WakaPointsPopupProps & React.RefAttributes<HTMLDivElement>>;
+export declare function usePointsPopup(): UsePointsPopupReturn;
+export interface PointsPreset {
+    color: string;
+    prefix: string;
+    icon?: React.ReactNode;
+}
+export declare const POINTS_PRESETS: Record<string, PointsPreset>;
+export interface UsePointsPopupWithPresetsReturn extends UsePointsPopupReturn {
+    /** Trigger XP popup */
+    triggerXP: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger coins popup */
+    triggerCoins: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger health popup */
+    triggerHealth: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger mana popup */
+    triggerMana: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+    /** Trigger score popup */
+    triggerScore: (points: number, options?: Omit<TriggerOptions, "prefix" | "color">) => void;
+}
+export declare function usePointsPopupWithPresets(): UsePointsPopupWithPresetsReturn;
+export {};

package/dist/components/waka-power-up/index.d.ts

@@ -0,0 +1,103 @@
+import { LucideIcon } from 'lucide-react';
+export type PowerUpType = "speed" | "shield" | "damage" | "time" | "star" | "boost" | "accuracy" | "health" | "coins" | "luck" | "custom";
+export interface PowerUp {
+    /** Unique identifier */
+    id: string;
+    /** Power-up type */
+    type: PowerUpType;
+    /** Display name */
+    name: string;
+    /** Description text */
+    description: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Multiplier or boost amount (e.g., 2 for x2, 1.5 for +50%) */
+    multiplier: number;
+    /** Stack count if multiple are active */
+    stackCount?: number;
+    /** Maximum stack count allowed */
+    maxStack?: number;
+    /** Custom icon (only used when type is "custom") */
+    customIcon?: LucideIcon;
+    /** Custom color (overrides type default) */
+    customColor?: string;
+    /** Whether the power-up is currently active */
+    isActive?: boolean;
+    /** Activation timestamp */
+    activatedAt?: number;
+}
+export interface WakaPowerUpProps {
+    /** Power-up data */
+    powerUp: PowerUp;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Visual style variant */
+    variant?: "card" | "badge" | "compact";
+    /** Show countdown timer */
+    showCountdown?: boolean;
+    /** Show description */
+    showDescription?: boolean;
+    /** Enable glow animation */
+    glowEnabled?: boolean;
+    /** Enable pulse animation */
+    pulseEnabled?: boolean;
+    /** Callback when power-up expires */
+    onExpire?: (powerUp: PowerUp) => void;
+    /** Callback when power-up is clicked */
+    onClick?: (powerUp: PowerUp) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UsePowerUpOptions {
+    /** Initial power-ups */
+    initialPowerUps?: PowerUp[];
+    /** Callback when any power-up expires */
+    onPowerUpExpire?: (powerUp: PowerUp) => void;
+    /** Callback when any power-up activates */
+    onPowerUpActivate?: (powerUp: PowerUp) => void;
+}
+export interface UsePowerUpReturn {
+    /** Active power-ups */
+    activePowerUps: PowerUp[];
+    /** Activate a power-up */
+    activate: (powerUp: Omit<PowerUp, "isActive" | "activatedAt">) => void;
+    /** Deactivate a power-up by ID */
+    deactivate: (id: string) => void;
+    /** Get remaining time for a power-up */
+    getRemainingTime: (id: string) => number;
+    /** Check if a specific power-up type is active */
+    isTypeActive: (type: PowerUpType) => boolean;
+    /** Get combined multiplier for a type (considering stacks) */
+    getCombinedMultiplier: (type: PowerUpType) => number;
+    /** Stack a power-up (increases stack count or extends duration) */
+    stack: (id: string, mode?: "count" | "duration") => void;
+    /** Clear all active power-ups */
+    clearAll: () => void;
+}
+export declare function WakaPowerUp({ powerUp, size, variant, showCountdown, showDescription, glowEnabled, pulseEnabled, onExpire, onClick, className, }: WakaPowerUpProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaPowerUp {
+    var displayName: string;
+}
+export declare function usePowerUp({ initialPowerUps, onPowerUpExpire, onPowerUpActivate, }?: UsePowerUpOptions): UsePowerUpReturn;
+export interface WakaPowerUpListProps {
+    /** List of power-ups to display */
+    powerUps: PowerUp[];
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Visual style variant */
+    variant?: "card" | "badge" | "compact";
+    /** Layout direction */
+    direction?: "horizontal" | "vertical";
+    /** Gap between items */
+    gap?: "sm" | "md" | "lg";
+    /** Callback when a power-up expires */
+    onExpire?: (powerUp: PowerUp) => void;
+    /** Callback when a power-up is clicked */
+    onClick?: (powerUp: PowerUp) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaPowerUpList({ powerUps, size, variant, direction, gap, onExpire, onClick, className, }: WakaPowerUpListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaPowerUpList {
+    var displayName: string;
+}

package/dist/components/waka-presence-indicator/index.d.ts

@@ -0,0 +1,188 @@
+export type PresenceStatus = "online" | "away" | "busy" | "offline" | "invisible";
+export interface PresenceState {
+    /** Current status */
+    status: PresenceStatus;
+    /** Custom status message */
+    customMessage?: string;
+    /** When the status was last updated */
+    updatedAt?: Date;
+    /** Last seen timestamp (for offline status) */
+    lastSeen?: Date;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+}
+export interface UsePresenceOptions {
+    /** Initial presence state */
+    initialState?: Partial<PresenceState>;
+    /** Callback when status changes */
+    onStatusChange?: (status: PresenceStatus) => void;
+    /** Auto-away timeout in milliseconds */
+    autoAwayTimeout?: number;
+    /** Persist state to localStorage */
+    persistKey?: string;
+}
+export interface UsePresenceReturn {
+    /** Current presence state */
+    presence: PresenceState;
+    /** Set presence status */
+    setStatus: (status: PresenceStatus) => void;
+    /** Set custom message */
+    setCustomMessage: (message: string | undefined) => void;
+    /** Toggle do not disturb */
+    toggleDoNotDisturb: () => void;
+    /** Set entire presence state */
+    setPresence: (state: Partial<PresenceState>) => void;
+    /** Get formatted status duration */
+    getStatusDuration: () => string | null;
+    /** Get formatted last seen */
+    getLastSeen: () => string | null;
+}
+export declare function usePresence(options?: UsePresenceOptions): UsePresenceReturn;
+export interface WakaPresenceIndicatorProps {
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Show pulsing animation for online status */
+    pulse?: boolean;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceIndicator({ status, size, pulse, doNotDisturb, className, }: WakaPresenceIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceWithAvatarProps {
+    /** Avatar image source */
+    src?: string;
+    /** Avatar fallback text (usually initials) */
+    fallback?: string;
+    /** Alt text for avatar */
+    alt?: string;
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Show pulsing animation */
+    pulse?: boolean;
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Avatar ring style */
+    showRing?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+}
+export declare function WakaPresenceWithAvatar({ src, fallback, alt, status, size, pulse, doNotDisturb, className, showRing, onClick, }: WakaPresenceWithAvatarProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceStatusBadgeProps {
+    /** Current presence status */
+    status: PresenceStatus;
+    /** Custom status message */
+    customMessage?: string;
+    /** Show status duration */
+    showDuration?: boolean;
+    /** Status updated timestamp */
+    updatedAt?: Date;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Do not disturb mode */
+    doNotDisturb?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceStatusBadge({ status, customMessage, showDuration, updatedAt, size, doNotDisturb, className, }: WakaPresenceStatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceSelectorProps {
+    /** Current presence state */
+    presence: PresenceState;
+    /** Set status callback */
+    onStatusChange: (status: PresenceStatus) => void;
+    /** Toggle DND callback */
+    onToggleDND?: () => void;
+    /** Set custom message callback */
+    onSetCustomMessage?: (message: string | undefined) => void;
+    /** Show custom message input */
+    showCustomMessage?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Disabled state */
+    disabled?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Avatar props for trigger */
+    avatar?: {
+        src?: string;
+        fallback?: string;
+        alt?: string;
+    };
+    /** Trigger variant */
+    triggerVariant?: "avatar" | "badge" | "minimal";
+}
+export declare function WakaPresenceSelector({ presence, onStatusChange, onToggleDND, onSetCustomMessage, showCustomMessage, size, disabled, className, avatar, triggerVariant, }: WakaPresenceSelectorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceLastSeenProps {
+    /** Last seen timestamp */
+    lastSeen: Date;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show "Last seen" prefix */
+    showPrefix?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceLastSeen({ lastSeen, size, showPrefix, className, }: WakaPresenceLastSeenProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceCardProps {
+    /** User name */
+    name: string;
+    /** Avatar source */
+    avatarSrc?: string;
+    /** Avatar fallback */
+    avatarFallback?: string;
+    /** Presence state */
+    presence: PresenceState;
+    /** Show status duration */
+    showDuration?: boolean;
+    /** Show last seen for offline */
+    showLastSeen?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+    /** Click handler */
+    onClick?: () => void;
+}
+export declare function WakaPresenceCard({ name, avatarSrc, avatarFallback, presence, showDuration, showLastSeen, size, className, onClick, }: WakaPresenceCardProps): import("react/jsx-runtime").JSX.Element;
+export interface PresenceUser {
+    id: string;
+    name: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+    presence: PresenceState;
+}
+export interface WakaPresenceListProps {
+    /** List of users with presence */
+    users: PresenceUser[];
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show last seen for offline users */
+    showLastSeen?: boolean;
+    /** Group users by status */
+    groupByStatus?: boolean;
+    /** Max users to show (shows "+X more" for rest) */
+    maxVisible?: number;
+    /** User click handler */
+    onUserClick?: (userId: string) => void;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceList({ users, size, showLastSeen, groupByStatus, maxVisible, onUserClick, className, }: WakaPresenceListProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPresenceAvatarStackProps {
+    /** List of users with presence */
+    users: PresenceUser[];
+    /** Max avatars to show */
+    max?: number;
+    /** Size variant */
+    size?: "xs" | "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPresenceAvatarStack({ users, max, size, className, }: WakaPresenceAvatarStackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPresenceIndicator;

package/dist/components/waka-pricing-table/index.d.ts

@@ -0,0 +1,77 @@
+export interface PricingFeature {
+    /** Feature name/description */
+    name: string;
+    /** Tooltip/additional info */
+    tooltip?: string;
+}
+export interface PricingTierFeature {
+    /** Feature reference (matches PricingFeature.name) */
+    name: string;
+    /** Whether this feature is included */
+    included: boolean;
+    /** Custom value to display instead of checkmark (e.g., "10 GB", "Unlimited") */
+    value?: string;
+}
+export interface PricingTier {
+    /** Unique identifier */
+    id: string;
+    /** Tier name (e.g., "Free", "Pro", "Enterprise") */
+    name: string;
+    /** Short description */
+    description?: string;
+    /** Monthly price in cents (null for custom pricing) */
+    monthlyPrice: number | null;
+    /** Annual price in cents (null for custom pricing) */
+    annualPrice: number | null;
+    /** Custom price label (e.g., "Contact us") */
+    customPriceLabel?: string;
+    /** Currency symbol */
+    currency?: string;
+    /** Features included in this tier */
+    features: PricingTierFeature[];
+    /** Whether this tier is highlighted as popular/recommended */
+    highlighted?: boolean;
+    /** Highlight label (e.g., "Most Popular", "Best Value") */
+    highlightLabel?: string;
+    /** CTA button text */
+    ctaText?: string;
+    /** CTA button variant */
+    ctaVariant?: "default" | "primary" | "outline";
+    /** Whether the tier is disabled */
+    disabled?: boolean;
+}
+export interface WakaPricingTableProps {
+    /** Pricing tiers to display */
+    tiers: PricingTier[];
+    /** All available features (for comparison table) */
+    features?: PricingFeature[];
+    /** Currently selected billing period */
+    billingPeriod?: "monthly" | "annual";
+    /** Callback when billing period changes */
+    onBillingPeriodChange?: (period: "monthly" | "annual") => void;
+    /** Callback when CTA is clicked */
+    onCtaClick?: (tier: PricingTier) => void;
+    /** Annual discount percentage to display */
+    annualDiscount?: number;
+    /** Show billing toggle */
+    showBillingToggle?: boolean;
+    /** Layout variant */
+    variant?: "cards" | "table" | "auto";
+    /** Additional class names */
+    className?: string;
+}
+export declare function WakaPricingTable({ tiers, features, billingPeriod: controlledBillingPeriod, onBillingPeriodChange, onCtaClick, annualDiscount, showBillingToggle, variant, className, }: WakaPricingTableProps): import("react/jsx-runtime").JSX.Element;
+export interface UsePricingTableOptions {
+    initialBillingPeriod?: "monthly" | "annual";
+}
+export declare function usePricingTable(options?: UsePricingTableOptions): {
+    billingPeriod: "monthly" | "annual";
+    selectedTier: PricingTier | null;
+    onBillingPeriodChange: (period: "monthly" | "annual") => void;
+    onCtaClick: (tier: PricingTier) => void;
+    calculateSavings: (tier: PricingTier) => number;
+    getEffectiveMonthlyPrice: (tier: PricingTier) => number | null;
+};
+export declare const defaultTiers: PricingTier[];
+export declare const defaultFeatures: PricingFeature[];
+export default WakaPricingTable;