@wakastellar/ui 3.5.2 → 4.0.0

package/dist/components/waka-tournament-bracket/index.d.ts

@@ -0,0 +1,101 @@
+import * as React from "react";
+export type MatchStatus = "pending" | "in_progress" | "completed" | "bye";
+export type BracketType = "single_elimination" | "double_elimination";
+export interface Participant {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Seed number */
+    seed?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface Match {
+    /** Unique identifier */
+    id: string;
+    /** Round number (0-indexed) */
+    round: number;
+    /** Position in round (0-indexed) */
+    position: number;
+    /** Participant 1 */
+    participant1?: Participant;
+    /** Participant 2 */
+    participant2?: Participant;
+    /** Participant 1 score */
+    score1?: number;
+    /** Participant 2 score */
+    score2?: number;
+    /** Match status */
+    status: MatchStatus;
+    /** Winner ID (participant1.id or participant2.id) */
+    winnerId?: string;
+    /** Scheduled time */
+    scheduledAt?: Date;
+    /** Match metadata */
+    metadata?: Record<string, unknown>;
+    /** For double elimination: is this in loser's bracket? */
+    isLosersBracket?: boolean;
+}
+export interface BracketRound {
+    /** Round name (e.g., "Round of 16", "Quarter Finals") */
+    name: string;
+    /** Matches in this round */
+    matches: Match[];
+}
+export interface WakaTournamentBracketProps {
+    /** Tournament name */
+    title?: string;
+    /** Bracket type */
+    type?: BracketType;
+    /** Winner's bracket rounds */
+    rounds: BracketRound[];
+    /** Loser's bracket rounds (for double elimination) */
+    losersRounds?: BracketRound[];
+    /** Grand final match (for double elimination) */
+    grandFinal?: Match;
+    /** Callback when match is clicked */
+    onMatchClick?: (match: Match) => void;
+    /** Callback when match is hovered */
+    onMatchHover?: (match: Match | null) => void;
+    /** Enable zoom/pan */
+    enableZoomPan?: boolean;
+    /** Initial zoom level */
+    initialZoom?: number;
+    /** Show match times */
+    showTimes?: boolean;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Animate match results */
+    animated?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export interface UseTournamentBracketOptions {
+    /** Initial rounds */
+    initialRounds?: BracketRound[];
+    /** Bracket type */
+    type?: BracketType;
+    /** Auto-generate bracket structure from participants */
+    participants?: Participant[];
+}
+export declare function WakaTournamentBracket({ title, type, rounds, losersRounds, grandFinal, onMatchClick, onMatchHover, enableZoomPan, initialZoom, showTimes, size, animated, className, }: WakaTournamentBracketProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTournamentBracket({ initialRounds, type, participants, }?: UseTournamentBracketOptions): {
+    rounds: BracketRound[];
+    losersRounds: BracketRound[];
+    setRounds: React.Dispatch<React.SetStateAction<BracketRound[]>>;
+    setLosersRounds: React.Dispatch<React.SetStateAction<BracketRound[]>>;
+    updateMatch: (matchId: string, updates: Partial<Pick<Match, "score1" | "score2" | "winnerId" | "status">>) => void;
+    startMatch: (matchId: string) => void;
+    completeMatch: (matchId: string, score1: number, score2: number) => void;
+    resetBracket: (newParticipants?: Participant[]) => void;
+    currentMatch: Match;
+    winner: Participant;
+    allMatches: Match[];
+    getMatch: (matchId: string) => Match;
+    generateBracket: (participantList: Participant[]) => BracketRound[];
+    type: BracketType;
+};
+export default WakaTournamentBracket;

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

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export interface TypingUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL (optional) */
+    avatar?: string;
+}
+export type TypingIndicatorVariant = "dots" | "text" | "pulse";
+export interface WakaTypingIndicatorProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof typingIndicatorVariants> {
+    /** List of users currently typing */
+    users?: TypingUser[];
+    /** Variant style of the indicator */
+    variant?: TypingIndicatorVariant;
+    /** Animation speed in milliseconds (default: 300) */
+    animationSpeed?: number;
+    /** Auto-hide timeout in milliseconds (0 to disable) */
+    autoHideTimeout?: number;
+    /** Custom text to show (overrides default text generation) */
+    customText?: string;
+    /** Show avatars of typing users */
+    showAvatars?: boolean;
+    /** Maximum number of avatars to display */
+    maxAvatars?: number;
+    /** Whether the indicator is visible */
+    visible?: boolean;
+    /** Callback when visibility changes due to auto-hide */
+    onVisibilityChange?: (visible: boolean) => void;
+}
+declare const typingIndicatorVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaTypingIndicator: React.ForwardRefExoticComponent<WakaTypingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseTypingIndicatorOptions {
+    /** Timeout for considering a user as no longer typing (ms) */
+    typingTimeout?: number;
+    /** Auto-hide the indicator after this duration (ms) */
+    autoHideTimeout?: number;
+    /** Callback when typing users change */
+    onTypingChange?: (users: TypingUser[]) => void;
+}
+export interface UseTypingIndicatorReturn {
+    /** List of currently typing users */
+    typingUsers: TypingUser[];
+    /** Whether anyone is typing */
+    isTyping: boolean;
+    /** Add a user to the typing list */
+    addTypingUser: (user: TypingUser) => void;
+    /** Remove a user from the typing list */
+    removeTypingUser: (userId: string) => void;
+    /** Update typing status for a user (resets their timeout) */
+    updateTypingStatus: (user: TypingUser) => void;
+    /** Clear all typing users */
+    clearTypingUsers: () => void;
+    /** Set the complete list of typing users */
+    setTypingUsers: React.Dispatch<React.SetStateAction<TypingUser[]>>;
+}
+export declare function useTypingIndicator(options?: UseTypingIndicatorOptions): UseTypingIndicatorReturn;
+export declare const WakaTypingIndicatorDots: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export declare const WakaTypingIndicatorText: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export declare const WakaTypingIndicatorPulse: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export default WakaTypingIndicator;

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

@@ -0,0 +1,117 @@
+import * as React from "react";
+export interface CompetitorStat {
+    /** Stat name */
+    name: string;
+    /** Stat value */
+    value: number;
+    /** Optional icon */
+    icon?: React.ReactNode;
+}
+export interface Competitor {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Current score in the challenge */
+    score: number;
+    /** Previous score (for animations) */
+    previousScore?: number;
+    /** Additional stats to display */
+    stats?: CompetitorStat[];
+    /** Whether this is the current user */
+    isCurrentUser?: boolean;
+    /** Rank/title badge */
+    rank?: string;
+    /** Win streak */
+    winStreak?: number;
+}
+export type ChallengeType = "score" | "time" | "streak" | "collection" | "custom";
+export type ChallengeStatus = "upcoming" | "live" | "finished";
+export interface ChallengeReward {
+    /** Reward type */
+    type: "xp" | "badge" | "item" | "currency";
+    /** Reward value */
+    value: number | string;
+    /** Custom icon */
+    icon?: React.ReactNode;
+}
+export interface Challenge {
+    /** Challenge type */
+    type: ChallengeType;
+    /** Challenge name */
+    name: string;
+    /** Challenge description */
+    description?: string;
+    /** Duration in seconds (for live challenges) */
+    duration?: number;
+    /** Start time */
+    startTime?: Date;
+    /** End time */
+    endTime?: Date;
+    /** Target score/goal (if applicable) */
+    targetScore?: number;
+    /** Rewards for winner */
+    rewards: ChallengeReward[];
+}
+export interface WakaVersusCardProps {
+    /** Left competitor */
+    competitorLeft: Competitor;
+    /** Right competitor */
+    competitorRight: Competitor;
+    /** Challenge details */
+    challenge: Challenge;
+    /** Current status */
+    status: ChallengeStatus;
+    /** Winner ID (when status is 'finished') */
+    winnerId?: string;
+    /** Callback when challenge state changes */
+    onStatusChange?: (status: ChallengeStatus) => void;
+    /** Callback when a competitor's score updates */
+    onScoreUpdate?: (competitorId: string, newScore: number) => void;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Show live pulse animation */
+    showLivePulse?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaVersusCard({ competitorLeft, competitorRight, challenge, status, winnerId, onStatusChange, onScoreUpdate, size, showLivePulse, className, }: WakaVersusCardProps): import("react/jsx-runtime").JSX.Element;
+export interface UseVersusCardOptions {
+    /** Initial left competitor */
+    competitorLeft: Competitor;
+    /** Initial right competitor */
+    competitorRight: Competitor;
+    /** Challenge details */
+    challenge: Challenge;
+    /** Initial status */
+    initialStatus?: ChallengeStatus;
+    /** Callback when status changes */
+    onStatusChange?: (status: ChallengeStatus) => void;
+    /** Callback when winner is determined */
+    onWinner?: (winnerId: string) => void;
+    /** Auto-determine winner when scores change */
+    autoWinner?: boolean;
+}
+export declare function useVersusCard({ competitorLeft: initialLeft, competitorRight: initialRight, challenge, initialStatus, onStatusChange, onWinner, autoWinner, }: UseVersusCardOptions): {
+    competitorLeft: Competitor;
+    competitorRight: Competitor;
+    status: ChallengeStatus;
+    winnerId: string;
+    updateScore: (competitorId: string, newScore: number) => void;
+    incrementScore: (competitorId: string, amount?: number) => void;
+    updateStatus: (newStatus: ChallengeStatus) => void;
+    declareWinner: (id: string) => void;
+    start: () => void;
+    finish: () => void;
+    reset: () => void;
+    isLive: boolean;
+    isFinished: boolean;
+    isUpcoming: boolean;
+    leftIsWinning: boolean;
+    rightIsWinning: boolean;
+    isTied: boolean;
+    scoreDifference: number;
+};
+export default WakaVersusCard;

package/dist/components/waka-video-ad/index.d.ts

@@ -0,0 +1,32 @@
+export interface WakaVideoAdProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Video width */
+    width?: number;
+    /** Video height */
+    height?: number;
+    /** Aspect ratio */
+    aspectRatio?: "16/9" | "4/3" | "1/1" | "9/16";
+    /** Autoplay when visible */
+    autoplay?: boolean;
+    /** Mute by default */
+    muted?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** Skip time in seconds (0 = no skip) */
+    skipAfter?: number;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** CTA overlay position */
+    ctaPosition?: "bottom" | "overlay" | "end";
+    /** Custom class name */
+    className?: string;
+    /** Callback when video completes */
+    onComplete?: () => void;
+    /** Callback when skipped */
+    onSkip?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoAd({ slotId, width, height, aspectRatio, autoplay, muted, showControls, skipAfter, showProgress, ctaPosition, className, onComplete, onSkip, onClick, }: WakaVideoAdProps): import("react/jsx-runtime").JSX.Element;
+export default WakaVideoAd;

package/dist/components/waka-video-call/index.d.ts

@@ -0,0 +1,170 @@
+import * as React from "react";
+export type ConnectionQuality = "excellent" | "good" | "fair" | "poor" | "disconnected";
+export type VideoCallLayout = "grid" | "speaker" | "sidebar";
+export interface Participant {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Video stream (optional for demo purposes) */
+    videoStream?: MediaStream;
+    /** Audio stream (optional for demo purposes) */
+    audioStream?: MediaStream;
+    /** Is audio muted */
+    isMuted: boolean;
+    /** Is video off */
+    isVideoOff: boolean;
+    /** Is screen sharing */
+    isScreenSharing: boolean;
+    /** Has raised hand */
+    hasRaisedHand: boolean;
+    /** Is speaking */
+    isSpeaking: boolean;
+    /** Is pinned */
+    isPinned: boolean;
+    /** Is the local user */
+    isLocal?: boolean;
+    /** Connection quality */
+    connectionQuality?: ConnectionQuality;
+}
+export interface WakaVideoCallProps {
+    /** List of participants */
+    participants: Participant[];
+    /** Current user's participant ID */
+    localParticipantId: string;
+    /** Is currently recording */
+    isRecording?: boolean;
+    /** Call start time (for timer) */
+    callStartTime?: Date;
+    /** Layout mode */
+    layout?: VideoCallLayout;
+    /** Show chat panel */
+    showChat?: boolean;
+    /** Is full screen */
+    isFullscreen?: boolean;
+    /** Callbacks */
+    onToggleMute?: () => void;
+    onToggleVideo?: () => void;
+    onToggleScreenShare?: () => void;
+    onToggleChat?: () => void;
+    onEndCall?: () => void;
+    onToggleFullscreen?: () => void;
+    onTogglePictureInPicture?: () => void;
+    onRaiseHand?: () => void;
+    onChangeLayout?: (layout: VideoCallLayout) => void;
+    onPinParticipant?: (participantId: string) => void;
+    onUnpinParticipant?: (participantId: string) => void;
+    onMuteParticipant?: (participantId: string) => void;
+    onRemoveParticipant?: (participantId: string) => void;
+    /** Custom className */
+    className?: string;
+}
+export interface VideoCallState {
+    isMuted: boolean;
+    isVideoOff: boolean;
+    isScreenSharing: boolean;
+    hasRaisedHand: boolean;
+    layout: VideoCallLayout;
+    showChat: boolean;
+    isFullscreen: boolean;
+    isPictureInPicture: boolean;
+    showParticipantList: boolean;
+    showSettings: boolean;
+    pinnedParticipantId: string | null;
+    elapsedTime: number;
+}
+export interface UseVideoCallOptions {
+    initialMuted?: boolean;
+    initialVideoOff?: boolean;
+    onStateChange?: (state: VideoCallState) => void;
+}
+interface ConnectionQualityIndicatorProps {
+    quality: ConnectionQuality;
+    showLabel?: boolean;
+    size?: "sm" | "default";
+    className?: string;
+}
+declare function ConnectionQualityIndicator({ quality, showLabel, size, className, }: ConnectionQualityIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface RecordingIndicatorProps {
+    className?: string;
+}
+declare function RecordingIndicator({ className }: RecordingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface CallTimerProps {
+    startTime?: Date;
+    className?: string;
+}
+declare function CallTimer({ startTime, className }: CallTimerProps): import("react/jsx-runtime").JSX.Element;
+interface ParticipantAvatarProps {
+    participant: Participant;
+    size?: "sm" | "default" | "lg" | "xl";
+    showStatus?: boolean;
+    className?: string;
+}
+declare function ParticipantAvatar({ participant, size, showStatus, className, }: ParticipantAvatarProps): import("react/jsx-runtime").JSX.Element;
+interface VideoTileProps {
+    participant: Participant;
+    isMain?: boolean;
+    showControls?: boolean;
+    onPin?: () => void;
+    onUnpin?: () => void;
+    onMute?: () => void;
+    onRemove?: () => void;
+    className?: string;
+}
+declare function VideoTile({ participant, isMain, showControls, onPin, onUnpin, onMute, onRemove, className, }: VideoTileProps): import("react/jsx-runtime").JSX.Element;
+interface ControlButtonProps {
+    icon: React.ElementType;
+    label: string;
+    isActive?: boolean;
+    isDestructive?: boolean;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare function ControlButton({ icon: Icon, label, isActive, isDestructive, onClick, disabled, className, }: ControlButtonProps): import("react/jsx-runtime").JSX.Element;
+interface ParticipantsPanelProps {
+    participants: Participant[];
+    isOpen: boolean;
+    onClose: () => void;
+    className?: string;
+}
+declare function ParticipantsPanel({ participants, isOpen, onClose, className, }: ParticipantsPanelProps): import("react/jsx-runtime").JSX.Element;
+interface LayoutSelectorProps {
+    currentLayout: VideoCallLayout;
+    onLayoutChange: (layout: VideoCallLayout) => void;
+    className?: string;
+}
+declare function LayoutSelector({ currentLayout, onLayoutChange, className }: LayoutSelectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaVideoCall({ participants, localParticipantId, isRecording, callStartTime, layout, showChat, isFullscreen, onToggleMute, onToggleVideo, onToggleScreenShare, onToggleChat, onEndCall, onToggleFullscreen, onTogglePictureInPicture, onRaiseHand, onChangeLayout, onPinParticipant, onUnpinParticipant, onMuteParticipant, onRemoveParticipant, className, }: WakaVideoCallProps): import("react/jsx-runtime").JSX.Element;
+export declare function useVideoCall(options?: UseVideoCallOptions): {
+    callStartTime: Date;
+    isInCall: boolean;
+    startCall: () => void;
+    endCall: () => void;
+    toggleMute: () => void;
+    toggleVideo: () => void;
+    toggleScreenShare: () => void;
+    toggleRaiseHand: () => void;
+    setLayout: (layout: VideoCallLayout) => void;
+    toggleChat: () => void;
+    toggleFullscreen: () => void;
+    togglePictureInPicture: () => void;
+    toggleParticipantList: () => void;
+    pinParticipant: (participantId: string | null) => void;
+    isMuted: boolean;
+    isVideoOff: boolean;
+    isScreenSharing: boolean;
+    hasRaisedHand: boolean;
+    layout: VideoCallLayout;
+    showChat: boolean;
+    isFullscreen: boolean;
+    isPictureInPicture: boolean;
+    showParticipantList: boolean;
+    showSettings: boolean;
+    pinnedParticipantId: string | null;
+    elapsedTime: number;
+};
+export { ConnectionQualityIndicator, RecordingIndicator, CallTimer, ParticipantAvatar, VideoTile, ControlButton, ParticipantsPanel, LayoutSelector, };
+export default WakaVideoCall;

package/dist/components/waka-video-overlay/index.d.ts

@@ -0,0 +1,26 @@
+export type OverlayPosition = "bottom" | "top" | "corner";
+export type OverlayTrigger = "start" | "pause" | "time" | "manual";
+export interface WakaVideoOverlayProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether overlay is visible */
+    visible?: boolean;
+    /** Trigger for showing overlay */
+    trigger?: OverlayTrigger;
+    /** Time trigger (seconds from start) */
+    triggerTime?: number;
+    /** Position of overlay */
+    position?: OverlayPosition;
+    /** Allow dismissing */
+    dismissable?: boolean;
+    /** Auto-hide after seconds (0 = manual) */
+    hideAfter?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoOverlay({ slotId, visible, trigger, triggerTime, position, dismissable, hideAfter, className, onDismiss, onClick, }: WakaVideoOverlayProps): import("react/jsx-runtime").JSX.Element;
+export default WakaVideoOverlay;

package/dist/context/admincrumb-context.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+export interface AdmincrumbItem {
+    id: string;
+    name: string;
+    type: "partner" | "network" | "customer";
+    metadata?: Record<string, any>;
+}
+export interface AdmincrumbSelection {
+    partner?: AdmincrumbItem;
+    network?: AdmincrumbItem;
+    customer?: AdmincrumbItem;
+}
+export interface AdmincrumbContextValue {
+    selection: AdmincrumbSelection;
+    setPartner: (item: AdmincrumbItem | undefined) => void;
+    setNetwork: (item: AdmincrumbItem | undefined) => void;
+    setCustomer: (item: AdmincrumbItem | undefined) => void;
+    reset: () => void;
+    isFiltered: boolean;
+    getFilterQuery: () => {
+        partnerId?: string;
+        networkId?: string;
+        customerId?: string;
+    };
+}
+export interface AdmincrumbProviderProps {
+    children: React.ReactNode;
+    initialSelection?: AdmincrumbSelection;
+    onSelectionChange?: (selection: AdmincrumbSelection) => void;
+    persistKey?: string;
+}
+export declare function AdmincrumbProvider({ children, initialSelection, onSelectionChange, persistKey }: AdmincrumbProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAdmincrumbContext(): AdmincrumbContextValue;
+export declare function useAdmincrumbContextOptional(): AdmincrumbContextValue;

package/dist/context/index.d.ts

@@ -0,0 +1,8 @@
+export { ThemeProvider, useTheme } from "./theme-provider";
+export type { ThemeContextValue, ThemeProviderProps, ThemeConfig, ThemeS3Config } from "./theme-provider";
+export { ThemeProvider as LegacyThemeProvider, useTheme as useLegacyTheme } from "./theme-context";
+export type { ThemeContextValue as LegacyThemeContextValue, ThemeProviderProps as LegacyThemeProviderProps } from "./theme-context";
+export { LanguageProvider, useLanguage } from "./language-context";
+export type { LanguageConfig, S3Config, LanguageProviderProps, LanguageContextValue } from "./language-context";
+export { WakaProvider, useWaka } from "./waka-provider";
+export type { WakaProviderConfig, WakaProviderProps } from "./waka-provider";

package/dist/context/theme-context.d.ts

@@ -0,0 +1,39 @@
+import * as React from "react";
+import { WakaThemeConfig, ThemeConfigItem } from "../types/provider";
+export interface ThemeContextValue {
+    theme: string;
+    setTheme: (theme: string) => void;
+    themes: ThemeConfigItem[];
+    systemTheme?: string;
+    isLoadingThemes?: boolean;
+    themesSource?: "config" | "s3" | "fallback";
+}
+export interface ThemeProviderProps {
+    children: React.ReactNode;
+    config?: WakaThemeConfig;
+}
+/**
+ * Provider de thème pour WakaStart UI
+ *
+ * Gère le thème actif, le stockage dans localStorage et la détection du thème système
+ * Charge automatiquement les thèmes depuis S3 si non fournis dans la config
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider config={{ defaultTheme: "light", themes: ["light", "dark"] }}>
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ */
+export declare function ThemeProvider({ children, config }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour accéder au contexte du thème
+ *
+ * @throws {Error} Si utilisé en dehors d'un ThemeProvider
+ *
+ * @example
+ * ```tsx
+ * const { theme, setTheme, themes } = useTheme()
+ * ```
+ */
+export declare function useTheme(): ThemeContextValue;

package/dist/context/waka-provider.d.ts

@@ -0,0 +1,50 @@
+import { WakaProviderConfig, WakaProviderProps } from "../types/provider";
+/**
+ * WakaProvider - Provider principal pour WakaStart UI
+ *
+ * Centralise la configuration du thème, de la langue et des traductions S3
+ *
+ * @example
+ * ```tsx
+ * <WakaProvider config={{
+ *   theme: {
+ *     defaultTheme: "light",
+ *     themes: ["light", "dark", "forest"],
+ *     enableSystem: true
+ *   },
+ *   language: {
+ *     defaultLanguage: "fr",
+ *     supportedLanguages: ["fr", "en"],
+ *     s3Config: {
+ *       bucketUrl: "https://my-bucket.s3.amazonaws.com",
+ *       translationsPath: "translations"
+ *     }
+ *   }
+ * }}>
+ *   <App />
+ * </WakaProvider>
+ * ```
+ */
+export declare function WakaProvider({ children, config }: WakaProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour accéder à la configuration du WakaProvider
+ *
+ * @example
+ * ```tsx
+ * const { changeLanguage, changeTheme, t } = useWaka()
+ * ```
+ */
+export declare function useWaka(): {
+    currentLanguage: string;
+    changeLanguage: (lang: string) => Promise<void>;
+    languages: import("./language-context").LanguageConfig[];
+    isLanguageLoading: boolean;
+    currentTheme: string;
+    changeTheme: (id: string) => Promise<void>;
+    themes: import("./theme-provider").ThemeConfig[];
+    isThemeLoading: boolean;
+    preloadTheme: (id: string) => Promise<void>;
+    isThemeLoaded: (id: string) => boolean;
+    t: import("i18next").TFunction<"translation", undefined>;
+};
+export type { WakaProviderConfig, WakaProviderProps };

package/dist/doc.cjs.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./chunk-14q5BKub.js`),t=require(`./cn-DEtaFQsA.js`),n=require(`./separator-NrkltulH.js`),r=require(`./waka-doc-renderer-CTxC7Trf.js`);let i=require(`react`);i=e.a(i);let a=require(`lucide-react`),o=require(`react/jsx-runtime`);function s({content:e,mode:s=`view`,canEdit:l=!1,onModeChange:u,onChange:d,debounceMs:f=1500,saveStatus:p=`idle`,navItems:m,activePageId:h,onPageChange:g,breadcrumbs:_,onBreadcrumbClick:v,searchPages:y,onSearchSelect:b,versions:x,currentVersion:S,onVersionChange:C,className:w}){let[T,E]=i.useState([]),[D,O]=i.useState(!1),[k,A]=i.useState(e);i.useEffect(()=>{A(e)},[e]);let j=i.useRef(),M=i.useCallback(e=>{A(e),j.current&&clearTimeout(j.current),j.current=setTimeout(()=>{d?.(e)},f)},[d,f]);i.useEffect(()=>()=>{j.current&&clearTimeout(j.current)},[]);let N=m&&m.length>0,P=y&&y.length>0,F=x&&x.length>0&&S;return(0,o.jsxs)(`div`,{className:t.t(`relative flex min-h-screen`,w),children:[N&&(0,o.jsx)(n.n,{variant:`ghost`,size:`icon`,className:`fixed left-4 top-4 z-50 lg:hidden`,onClick:()=>O(!D),children:D?(0,o.jsx)(a.X,{className:`h-5 w-5`}):(0,o.jsx)(a.Menu,{className:`h-5 w-5`})}),N&&(0,o.jsx)(`aside`,{className:t.t(`fixed inset-y-0 left-0 z-40 w-72 shrink-0 border-r border-border/50 bg-background/95 backdrop-blur-md transition-transform duration-300 lg:relative lg:translate-x-0`,D?`translate-x-0`:`-translate-x-full`),children:(0,o.jsxs)(`div`,{className:`flex h-full flex-col gap-4 overflow-y-auto p-4`,children:[P&&(0,o.jsx)(r.o,{pages:y,onSelect:e=>{b?.(e),O(!1)}}),F&&(0,o.jsx)(r.a,{versions:x,current:S,onVersionChange:C}),(0,o.jsx)(r.s,{items:m,activeId:h,onItemClick:e=>{g?.(e),O(!1)}})]})}),N&&D&&(0,o.jsx)(`div`,{className:`fixed inset-0 z-30 bg-black/50 lg:hidden`,onClick:()=>O(!1)}),(0,o.jsxs)(`main`,{className:`flex min-w-0 flex-1 gap-8`,children:[(0,o.jsxs)(`div`,{className:`mx-auto w-full max-w-3xl px-4 py-8 lg:px-8`,children:[(0,o.jsxs)(`div`,{className:`mb-6 flex flex-col gap-3`,children:[_&&_.length>0&&(0,o.jsx)(r.r,{items:_,onItemClick:v}),(0,o.jsx)(r.i,{content:k,mode:s,canEdit:l,onModeChange:u,saveStatus:p})]}),s===`view`?(0,o.jsx)(r.t,{content:k,onHeadingsExtracted:E}):(0,o.jsx)(c,{content:k,onChange:M,onHeadingsExtracted:E})]}),T.length>0&&(0,o.jsx)(`aside`,{className:`hidden w-56 shrink-0 py-8 xl:block`,children:(0,o.jsx)(r.c,{items:T})})]})]})}function c({content:e,onChange:t,onHeadingsExtracted:n}){let[r,a]=i.useState(null);return i.useEffect(()=>{(async()=>{try{let{WakaRichTextEditor:e}=await Promise.resolve().then(()=>require(`./waka-rich-text-editor-BlIdtknG.js`));a(()=>e)}catch{}})()},[]),i.useEffect(()=>{let t=[],r=e.split(`
+"use client";Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./chunk-FDd1SASZ.js`),t=require(`./cn-DEeiGoUV.js`),n=require(`./separator-DviMy-io.js`),r=require(`./waka-doc-renderer-22MUZbyl.js`);let i=require(`react`);i=e.r(i);let a=require(`lucide-react`),o=require(`react/jsx-runtime`);function s({content:e,mode:s=`view`,canEdit:l=!1,onModeChange:u,onChange:d,debounceMs:f=1500,saveStatus:p=`idle`,navItems:m,activePageId:h,onPageChange:g,breadcrumbs:_,onBreadcrumbClick:v,searchPages:y,onSearchSelect:b,versions:x,currentVersion:S,onVersionChange:C,className:w}){let[T,E]=i.useState([]),[D,O]=i.useState(!1),[k,A]=i.useState(e);i.useEffect(()=>{A(e)},[e]);let j=i.useRef(),M=i.useCallback(e=>{A(e),j.current&&clearTimeout(j.current),j.current=setTimeout(()=>{d?.(e)},f)},[d,f]);i.useEffect(()=>()=>{j.current&&clearTimeout(j.current)},[]);let N=m&&m.length>0,P=y&&y.length>0,F=x&&x.length>0&&S;return(0,o.jsxs)(`div`,{className:t.t(`relative flex min-h-screen`,w),children:[N&&(0,o.jsx)(n.n,{variant:`ghost`,size:`icon`,className:`fixed left-4 top-4 z-50 lg:hidden`,onClick:()=>O(!D),children:D?(0,o.jsx)(a.X,{className:`h-5 w-5`}):(0,o.jsx)(a.Menu,{className:`h-5 w-5`})}),N&&(0,o.jsx)(`aside`,{className:t.t(`fixed inset-y-0 left-0 z-40 w-72 shrink-0 border-r border-border/50 bg-background/95 backdrop-blur-md transition-transform duration-300 lg:relative lg:translate-x-0`,D?`translate-x-0`:`-translate-x-full`),children:(0,o.jsxs)(`div`,{className:`flex h-full flex-col gap-4 overflow-y-auto p-4`,children:[P&&(0,o.jsx)(r.o,{pages:y,onSelect:e=>{b?.(e),O(!1)}}),F&&(0,o.jsx)(r.a,{versions:x,current:S,onVersionChange:C}),(0,o.jsx)(r.s,{items:m,activeId:h,onItemClick:e=>{g?.(e),O(!1)}})]})}),N&&D&&(0,o.jsx)(`div`,{className:`fixed inset-0 z-30 bg-black/50 lg:hidden`,onClick:()=>O(!1)}),(0,o.jsxs)(`main`,{className:`flex min-w-0 flex-1 gap-8`,children:[(0,o.jsxs)(`div`,{className:`mx-auto w-full max-w-3xl px-4 py-8 lg:px-8`,children:[(0,o.jsxs)(`div`,{className:`mb-6 flex flex-col gap-3`,children:[_&&_.length>0&&(0,o.jsx)(r.r,{items:_,onItemClick:v}),(0,o.jsx)(r.i,{content:k,mode:s,canEdit:l,onModeChange:u,saveStatus:p})]}),s===`view`?(0,o.jsx)(r.t,{content:k,onHeadingsExtracted:E}):(0,o.jsx)(c,{content:k,onChange:M,onHeadingsExtracted:E})]}),T.length>0&&(0,o.jsx)(`aside`,{className:`hidden w-56 shrink-0 py-8 xl:block`,children:(0,o.jsx)(r.c,{items:T})})]})]})}function c({content:e,onChange:t,onHeadingsExtracted:n}){let[r,a]=i.useState(null);return i.useEffect(()=>{(async()=>{try{let{WakaRichTextEditor:e}=await Promise.resolve().then(()=>require(`./waka-rich-text-editor-DcZuIQ-q.js`)).then(e=>e.n);a(()=>e)}catch{}})()},[]),i.useEffect(()=>{let t=[],r=e.split(`
 `);for(let e of r){let n=e.match(/^(#{2,4})\s+(.+)$/);if(n){let e=n[1].length,r=n[2].replace(/[`*_~]/g,``),i=r.toLowerCase().replace(/[^\w\s-]/g,``).replace(/\s+/g,`-`);t.push({id:i,text:r,level:e})}}n(t)},[e,n]),r?(0,o.jsx)(r,{value:e,onChange:t,placeholder:`Écrivez votre documentation...`,minHeight:400,editable:!0}):(0,o.jsx)(`textarea`,{value:e,onChange:e=>t(e.target.value),className:`min-h-[400px] w-full rounded-lg border border-border/50 bg-background p-4 font-mono text-sm focus:outline-none focus:ring-2 focus:ring-primary/50`,placeholder:`Écrivez en markdown...`})}exports.WakaDocBreadcrumb=r.r,exports.WakaDocCallout=r.u,exports.WakaDocCodeBlock=r.l,exports.WakaDocNav=r.s,exports.WakaDocRenderer=r.t,exports.WakaDocSearch=r.o,exports.WakaDocShell=s,exports.WakaDocTable=r.n,exports.WakaDocToc=r.c,exports.WakaDocToolbar=r.i,exports.WakaDocVersion=r.a;