@wakastellar/ui 0.5.0 → 1.0.0

package/dist/utils/datetime-helpers.d.ts

@@ -1,160 +1,62 @@
 import { DatePreset, DateRange } from '../components/waka-datetime-picker';
 /**
- * Crée des presets pour les dates courantes (aujourd'hui, hier, semaine, mois, etc.)
- *
- * @param locale - Locale date-fns pour le calcul des semaines (défaut: fr)
- * @returns Tableau de presets configurés
- *
- * @example
- * ```tsx
- * <WakaDateTimePicker presets={createCommonPresets()} />
- * ```
+ * Créer des presets de dates courantes
  */
 export declare const createCommonPresets: (locale?: import('date-fns').Locale) => DatePreset[];
 /**
- * Crée des presets pour les 7, 30 et 90 derniers jours
- *
- * @returns Tableau de presets pour les périodes récentes
- *
- * @example
- * ```tsx
- * const presets = [...createCommonPresets(), ...createLastDaysPresets()]
- * ```
+ * Créer des presets pour les 7, 30, 90 derniers jours
  */
 export declare const createLastDaysPresets: () => DatePreset[];
 /**
- * Crée des presets pour les N prochains jours
- *
- * @param days - Tableau des nombres de jours (ex: [7, 14, 30])
- * @returns Tableau de presets pour les périodes futures
- *
- * @example
- * ```tsx
- * const futurePresets = createNextDaysPresets([7, 14, 30])
- * // Génère: "7 prochains jours", "14 prochains jours", "30 prochains jours"
- * ```
+ * Créer des presets pour les N prochains jours
  */
 export declare const createNextDaysPresets: (days: number[]) => DatePreset[];
 /**
- * Crée un preset de date personnalisé
- *
- * @param label - Libellé du preset
- * @param dateOrRange - Date, DateRange, ou fonction retournant l'un ou l'autre
- * @returns Preset configuré
- *
- * @example
- * ```tsx
- * // Preset avec date fixe
- * const christmas = createCustomPreset("Noël", new Date(2025, 11, 25))
- *
- * // Preset avec range dynamique
- * const fiscalYear = createCustomPreset("Année fiscale", () => ({
- *   from: new Date(2025, 3, 1),
- *   to: new Date(2026, 2, 31)
- * }))
- * ```
+ * Créer un preset personnalisé
  */
 export declare const createCustomPreset: (label: string, dateOrRange: Date | DateRange | (() => Date) | (() => DateRange)) => DatePreset;
 /**
- * Vérifie si une date est dans le futur (après aujourd'hui à minuit)
- *
- * @param date - Date à vérifier
- * @returns true si la date est dans le futur
+ * Validation : date dans le futur
  */
 export declare const isFutureDate: (date: Date) => boolean;
 /**
- * Vérifie si une date est dans le passé (avant aujourd'hui à minuit)
- *
- * @param date - Date à vérifier
- * @returns true si la date est dans le passé
+ * Validation : date dans le passé
  */
 export declare const isPastDate: (date: Date) => boolean;
 /**
- * Vérifie si une date correspond à aujourd'hui
- *
- * @param date - Date à vérifier
- * @returns true si la date est aujourd'hui
+ * Validation : date est aujourd'hui
  */
 export declare const isToday: (date: Date) => boolean;
 /**
- * Vérifie si une date est un jour de semaine (lundi à vendredi)
- *
- * @param date - Date à vérifier
- * @returns true si la date est un jour ouvrable
+ * Validation : date est un jour de semaine (lundi-vendredi)
  */
 export declare const isWeekday: (date: Date) => boolean;
 /**
- * Vérifie si une date tombe un weekend (samedi ou dimanche)
- *
- * @param date - Date à vérifier
- * @returns true si la date est un weekend
+ * Validation : date est un weekend (samedi-dimanche)
  */
 export declare const isWeekend: (date: Date) => boolean;
 /**
- * Vérifie si une date est un jour férié
- *
- * @param date - Date à vérifier
- * @param holidays - Liste des jours fériés
- * @returns true si la date est un jour férié
- *
- * @example
- * ```tsx
- * const holidays = getFrenchHolidays(2025)
- * if (isHoliday(selectedDate, holidays)) {
- *   console.log("Jour férié!")
- * }
- * ```
+ * Validation : date est dans une liste de jours fériés
  */
 export declare const isHoliday: (date: Date, holidays: Date[]) => boolean;
 /**
- * Vérifie si une date est comprise dans un intervalle
- *
- * @param date - Date à vérifier
- * @param start - Début de l'intervalle
- * @param end - Fin de l'intervalle
- * @returns true si la date est dans l'intervalle (bornes incluses)
+ * Validation : date est dans un intervalle
  */
 export declare const isDateInRange: (date: Date, start: Date, end: Date) => boolean;
 /**
- * Crée un validateur d'âge minimum
- *
- * @param minAge - Âge minimum requis en années
- * @returns Fonction de validation retournant true ou un message d'erreur
- *
- * @example
- * ```tsx
- * const validateAdult = createMinAgeValidator(18)
- * const result = validateAdult(birthdate)
- * if (result !== true) console.error(result)
- * ```
+ * Validation : âge minimum
  */
 export declare const createMinAgeValidator: (minAge: number) => (birthdate: Date) => boolean | string;
 /**
- * Crée un validateur d'âge maximum
- *
- * @param maxAge - Âge maximum autorisé en années
- * @returns Fonction de validation retournant true ou un message d'erreur
+ * Validation : âge maximum
  */
 export declare const createMaxAgeValidator: (maxAge: number) => (birthdate: Date) => boolean | string;
 /**
- * Valide qu'une date n'est pas expirée (n'est pas dans le passé)
- *
- * @param date - Date à vérifier
- * @returns true si valide, message d'erreur sinon
+ * Validation : date d'expiration
  */
 export declare const isNotExpired: (date: Date) => boolean | string;
 /**
- * Calcule la durée entre deux dates en jours, semaines et mois
- *
- * @param from - Date de début
- * @param to - Date de fin
- * @returns Objet avec les durées en différentes unités
- *
- * @example
- * ```tsx
- * const duration = calculateDuration(startDate, endDate)
- * console.log(`${duration.days} jours (${duration.weeks} semaines)`)
- * ```
+ * Calculer la durée entre deux dates
  */
 export declare const calculateDuration: (from: Date, to: Date) => {
     days: number;
@@ -162,184 +64,74 @@ export declare const calculateDuration: (from: Date, to: Date) => {
     months: number;
 };
 /**
- * Formate une plage de dates en chaîne lisible
- *
- * @param range - Plage de dates à formater
- * @param formatStr - Format date-fns (défaut: "PPP" = "1 janvier 2025")
- * @param locale - Locale pour le formatage (défaut: fr)
- * @returns Chaîne formatée "date1 - date2"
- *
- * @example
- * ```tsx
- * formatDateRange({ from: start, to: end })
- * // => "1 janvier 2025 - 31 janvier 2025"
- * ```
+ * Formater une range de dates
  */
 export declare const formatDateRange: (range: DateRange, formatStr?: string, locale?: import('date-fns').Locale) => string;
 /**
- * Retourne la liste des jours fériés français pour une année donnée
- *
- * Note: N'inclut pas les fêtes mobiles (Pâques, Ascension, Pentecôte)
- *
- * @param year - Année concernée
- * @returns Tableau des dates de jours fériés
- *
- * @example
- * ```tsx
- * const holidays2025 = getFrenchHolidays(2025)
- * // Utiliser pour désactiver ces dates dans un calendrier
- * ```
+ * Obtenir les jours fériés français pour une année
  */
 export declare const getFrenchHolidays: (year: number) => Date[];
 /**
- * Retourne toutes les dates d'un mois donné
- *
- * @param year - Année
- * @param month - Mois (0-11, janvier = 0)
- * @returns Tableau de toutes les dates du mois
+ * Obtenir les dates d'un mois
  */
 export declare const getDatesInMonth: (year: number, month: number) => Date[];
 /**
- * Retourne tous les weekends d'un mois donné
- *
- * @param year - Année
- * @param month - Mois (0-11)
- * @returns Tableau des dates de weekend
+ * Obtenir tous les weekends d'un mois
  */
 export declare const getWeekendsInMonth: (year: number, month: number) => Date[];
 /**
- * Retourne tous les jours ouvrables d'un mois donné (lundi à vendredi)
- *
- * @param year - Année
- * @param month - Mois (0-11)
- * @returns Tableau des dates de jours ouvrables
+ * Obtenir tous les jours de semaine d'un mois
  */
 export declare const getWeekdaysInMonth: (year: number, month: number) => Date[];
 /**
- * Crée un validateur pour les dates d'expiration de carte bancaire
- *
- * Vérifie que la carte n'est pas expirée et avertit si elle expire bientôt.
- *
- * @returns Fonction de validation retournant true ou un message
+ * Créer un validateur de date d'expiration de carte bancaire
  */
 export declare const createCardExpiryValidator: () => (date: Date) => boolean | string;
 /**
- * Crée un validateur pour les réservations nécessitant un délai minimum
- *
- * @param minDaysInAdvance - Nombre de jours minimum avant la date
- * @returns Fonction de validation retournant true ou un message d'erreur
- *
- * @example
- * ```tsx
- * const validateBooking = createBookingDateValidator(3)
- * // Exige une réservation au moins 3 jours à l'avance
- * ```
+ * Créer un validateur de date de réservation (X jours d'avance minimum)
  */
 export declare const createBookingDateValidator: (minDaysInAdvance: number) => (date: Date) => boolean | string;
 /**
- * Crée un validateur limitant la durée maximale d'une plage de dates
- *
- * @param maxDays - Nombre maximum de jours autorisés
- * @returns Fonction de validation pour DateRange
- *
- * @example
- * ```tsx
- * const validateRange = createMaxRangeDaysValidator(30)
- * // Limite la sélection à 30 jours maximum
- * ```
+ * Créer un validateur de plage de dates maximum
  */
 export declare const createMaxRangeDaysValidator: (maxDays: number) => (range: DateRange) => boolean | string;
 /**
- * Vérifie si deux dates correspondent au même jour
- *
- * @param date1 - Première date
- * @param date2 - Seconde date
- * @returns true si les dates sont le même jour
+ * Vérifier si deux dates sont le même jour
  */
 export declare const isSameDay: (date1: Date, date2: Date) => boolean;
 /**
- * Calcule le nombre de jours ouvrés entre deux dates
- *
- * Exclut les weekends et optionnellement les jours fériés.
- *
- * @param from - Date de début
- * @param to - Date de fin
- * @param holidays - Liste optionnelle des jours fériés à exclure
- * @returns Nombre de jours ouvrés
- *
- * @example
- * ```tsx
- * const holidays = getFrenchHolidays(2025)
- * const workDays = getWorkingDays(startDate, endDate, holidays)
- * console.log(`${workDays} jours ouvrés`)
- * ```
+ * Obtenir le nombre de jours ouvrés entre deux dates
  */
 export declare const getWorkingDays: (from: Date, to: Date, holidays?: Date[]) => number;
 /**
- * Crée des presets pour les quatre trimestres d'une année
- *
- * @param year - Année cible (défaut: année courante)
- * @returns Tableau de presets T1, T2, T3, T4
- *
- * @example
- * ```tsx
- * const quarterPresets = createQuarterPresets(2025)
- * // => ["T1 2025", "T2 2025", "T3 2025", "T4 2025"]
- * ```
+ * Créer des presets pour les trimestres
  */
 export declare const createQuarterPresets: (year?: number) => DatePreset[];
 /**
- * Crée des presets pour les 12 mois d'une année
- *
- * @param year - Année cible (défaut: année courante)
- * @param locale - Locale pour le nom des mois (défaut: fr)
- * @returns Tableau de presets pour chaque mois
+ * Créer des presets pour les mois de l'année
  */
 export declare const createMonthlyPresets: (year?: number, locale?: import('date-fns').Locale) => DatePreset[];
 /**
- * Convertit une date en timestamp Unix (millisecondes)
- *
- * @param date - Date à convertir
- * @returns Timestamp en millisecondes
+ * Convertir une date en timestamp
  */
 export declare const dateToTimestamp: (date: Date) => number;
 /**
- * Convertit un timestamp Unix en objet Date
- *
- * @param timestamp - Timestamp en millisecondes
- * @returns Objet Date correspondant
+ * Convertir un timestamp en date
  */
 export declare const timestampToDate: (timestamp: number) => Date;
 /**
- * Normalise une date au début de la journée (00:00:00)
- *
- * Utile pour les comparaisons de dates sans tenir compte de l'heure.
- *
- * @param date - Date à normaliser
- * @returns Date normalisée à minuit
+ * Normaliser une date (début de journée)
  */
 export declare const normalizeDate: (date: Date) => Date;
 /**
- * Compare deux plages de dates pour vérifier leur égalité
- *
- * @param range1 - Première plage
- * @param range2 - Seconde plage
- * @returns true si les plages sont identiques (même jour de début et fin)
+ * Comparer deux ranges de dates
  */
 export declare const compareRanges: (range1: DateRange, range2: DateRange) => boolean;
 /**
- * Fusionne deux plages de dates si elles se chevauchent ou sont adjacentes
- *
- * @param range1 - Première plage
- * @param range2 - Seconde plage
- * @returns Plage fusionnée ou null si les plages ne se chevauchent pas
+ * Merger deux ranges de dates
  */
 export declare const mergeRanges: (range1: DateRange, range2: DateRange) => DateRange | null;
 /**
- * Vérifie si deux plages de dates se chevauchent
- *
- * @param range1 - Première plage
- * @param range2 - Seconde plage
- * @returns true si les plages ont au moins un jour en commun
+ * Vérifier si deux ranges se chevauchent
  */
 export declare const rangesOverlap: (range1: DateRange, range2: DateRange) => boolean;

package/dist/utils/index.d.ts

@@ -3,7 +3,3 @@ export { tweak, type VariantProps } from './tweak';
 export * from './datetime-helpers';
 export { ThemeLoader, initThemeLoader, getThemeLoader, loadTheme, applyTheme, useThemeLoader } from './theme-loader';
 export type { ThemeLoaderConfig } from './theme-loader';
-export { logger, Logger } from './logger';
-export type { LoggerConfig, LogLevel } from './logger';
-export { WakaError, ErrorCode, handleError, tryCatch, tryCatchAsync, withErrorHandling, assertCondition, isWakaError, isErrorCode, createErrorFactory, retryAsync, } from './error-handling';
-export type { ErrorCodeType, ErrorHandlerOptions } from './error-handling';

package/dist/utils/theme-loader.d.ts

@@ -1,130 +1,66 @@
 /**
- * @fileoverview Chargeur dynamique de thèmes pour WakaStart UI
+ * Theme Loader pour charger dynamiquement les thèmes depuis S3 ou toute URL
  *
- * Ce module permet de charger des thèmes CSS depuis n'importe quelle URL
- * (S3, CDN, serveur local) et de les appliquer dynamiquement.
- *
- * Fonctionnalités:
- * - Chargement asynchrone avec timeout configurable
- * - Cache des thèmes déjà chargés
- * - Préchargement de plusieurs thèmes en parallèle
- * - Persistance du thème actif dans localStorage
- * - Support de tous les formats de couleurs (hex, rgb, hsl, oklch)
- *
- * @module utils/theme-loader
- *
- * @example
- * ```tsx
- * // Initialisation
- * import { initThemeLoader, loadTheme } from '@wakastellar/ui'
- *
- * initThemeLoader({ baseUrl: 'https://cdn.example.com/themes' })
- *
- * // Charger et appliquer un thème
- * await loadTheme('dark')
- *
- * // Avec le hook React
- * const { loadTheme, currentTheme, isLoading } = useThemeLoader()
- * ```
- */
-/**
- * Configuration du chargeur de thèmes
- *
- * @example
- * ```tsx
- * const config: ThemeLoaderConfig = {
- *   baseUrl: 'https://cdn.example.com/themes',
- *   cache: true,
- *   timeout: 5000,
- *   onError: (err, name) => console.error(`Theme ${name} failed:`, err),
- *   onSuccess: (name) => console.log(`Theme ${name} loaded`)
- * }
- * ```
+ * Supporte tous les formats de couleurs (hex, rgb, hsl, oklch, etc.)
+ * grâce au système TweakCN avec @theme inline
  */
 export interface ThemeLoaderConfig {
-    /** URL de base où les fichiers CSS des thèmes sont stockés */
+    /**
+     * URL de base où les thèmes sont stockés (S3, CDN, etc.)
+     */
     baseUrl: string;
-    /** Active le cache des thèmes chargés (défaut: true) */
+    /**
+     * Cache les thèmes déjà chargés pour éviter les requêtes répétées
+     */
     cache?: boolean;
-    /** Timeout en ms pour le chargement d'un thème (défaut: 10000) */
+    /**
+     * Timeout en millisecondes pour le chargement d'un thème
+     */
     timeout?: number;
-    /** Callback appelé en cas d'erreur de chargement */
+    /**
+     * Callback appelé en cas d'erreur de chargement
+     */
     onError?: (error: Error, themeName: string) => void;
-    /** Callback appelé après chargement réussi d'un thème */
+    /**
+     * Callback appelé une fois le thème chargé avec succès
+     */
     onSuccess?: (themeName: string) => void;
 }
-/**
- * Classe principale pour le chargement dynamique des thèmes
- *
- * Gère le chargement, le cache et l'application des thèmes CSS.
- * Utilisez `initThemeLoader()` pour créer une instance globale.
- */
 declare class ThemeLoader {
     private config;
     private loadedThemes;
     private styleElements;
-    /**
-     * Crée une nouvelle instance du chargeur de thèmes
-     * @param config - Configuration du chargeur
-     */
     constructor(config: ThemeLoaderConfig);
     /**
-     * Charge un thème depuis l'URL configurée et l'applique
-     *
-     * @param themeName - Nom du thème (sans extension .css)
-     * @throws {Error} Si le chargement échoue ou timeout
-     *
-     * @example
-     * ```tsx
-     * await loader.loadTheme('dark')
-     * ```
+     * Charge un thème depuis une URL
      */
     loadTheme(themeName: string): Promise<void>;
     /**
-     * Applique un thème déjà chargé au document
-     *
-     * Met à jour l'attribut `data-theme` sur `<html>` et sauvegarde dans localStorage.
-     *
-     * @param themeName - Nom du thème à appliquer
+     * Applique un thème déjà chargé
      */
     applyTheme(themeName: string): void;
     /**
-     * Récupère le nom du thème actuellement appliqué
-     *
-     * @returns Nom du thème ou null si aucun n'est défini
+     * Récupère le thème actuellement appliqué
      */
     getCurrentTheme(): string | null;
     /**
-     * Récupère le dernier thème utilisé depuis localStorage
-     *
-     * @returns Nom du thème sauvegardé ou null
+     * Charge le dernier thème utilisé depuis localStorage
      */
     loadSavedTheme(): string | null;
     /**
-     * Précharge plusieurs thèmes en parallèle pour un changement instantané
-     *
-     * @param themeNames - Liste des noms de thèmes à précharger
-     *
-     * @example
-     * ```tsx
-     * await loader.preloadThemes(['light', 'dark', 'forest'])
-     * ```
+     * Précharge plusieurs thèmes en parallèle
      */
     preloadThemes(themeNames: string[]): Promise<void>;
     /**
      * Supprime un thème du cache et du DOM
-     *
-     * @param themeName - Nom du thème à décharger
      */
     unloadTheme(themeName: string): void;
     /**
-     * Vide complètement le cache et supprime tous les styles injectés
+     * Vide complètement le cache
      */
     clearCache(): void;
     /**
-     * Retourne la liste des noms de thèmes actuellement en cache
-     *
-     * @returns Tableau des noms de thèmes chargés
+     * Liste tous les thèmes chargés
      */
     getLoadedThemes(): string[];
     /**
@@ -137,69 +73,23 @@ declare class ThemeLoader {
     private injectThemeStyles;
 }
 /**
- * Initialise le chargeur de thèmes global avec la configuration fournie
- *
- * Cette fonction doit être appelée une fois au démarrage de l'application.
- *
- * @param config - Configuration du chargeur
- * @returns Instance du ThemeLoader
- *
- * @example
- * ```tsx
- * // Dans _app.tsx ou layout.tsx
- * initThemeLoader({
- *   baseUrl: process.env.NEXT_PUBLIC_THEMES_URL,
- *   onError: (err, name) => toast.error(`Échec du thème ${name}`)
- * })
- * ```
+ * Initialise le theme loader avec une configuration
  */
 export declare function initThemeLoader(config: ThemeLoaderConfig): ThemeLoader;
 /**
- * Récupère l'instance globale du chargeur de thèmes
- *
- * @throws {Error} Si initThemeLoader() n'a pas été appelé
- * @returns Instance du ThemeLoader
+ * Récupère l'instance globale du theme loader
  */
 export declare function getThemeLoader(): ThemeLoader;
 /**
- * Charge et applique un thème via l'instance globale
- *
- * @param themeName - Nom du thème à charger
- * @throws {Error} Si le loader n'est pas initialisé
+ * Charge un thème depuis l'instance globale
  */
 export declare function loadTheme(themeName: string): Promise<void>;
 /**
- * Applique un thème déjà chargé via l'instance globale
- *
- * @param themeName - Nom du thème à appliquer
+ * Applique un thème depuis l'instance globale
  */
 export declare function applyTheme(themeName: string): void;
 /**
- * Hook React pour charger et gérer les thèmes dynamiquement
- *
- * Fournit des méthodes pour charger et appliquer des thèmes,
- * ainsi que l'état de chargement et le thème actuel.
- *
- * @param config - Configuration optionnelle (utilise l'instance globale si non fournie)
- * @returns Objet avec méthodes et état du chargeur
- *
- * @example
- * ```tsx
- * function ThemeSwitcher() {
- *   const { loadTheme, currentTheme, isLoading, loadedThemes } = useThemeLoader()
- *
- *   return (
- *     <select
- *       value={currentTheme || ''}
- *       onChange={(e) => loadTheme(e.target.value)}
- *       disabled={isLoading}
- *     >
- *       <option value="light">Clair</option>
- *       <option value="dark">Sombre</option>
- *     </select>
- *   )
- * }
- * ```
+ * Hook React pour charger des thèmes dynamiquement
  */
 export declare function useThemeLoader(config?: Partial<ThemeLoaderConfig>): {
     loadTheme: (themeName: string) => Promise<void>;

package/dist/utils/tweak.d.ts

@@ -1,31 +1,18 @@
 import { ClassValue } from 'clsx';
 import { VariantProps } from 'class-variance-authority';
-/**
- * Configuration des variantes pour un composant
- */
 export type ConfigVariants<T> = T extends Record<string, Record<string, string>> ? {
     [K in keyof T]?: keyof T[K];
 } : never;
-/**
- * Props pour les classes CSS additionnelles
- */
 export type ClassProp = {
     class?: ClassValue;
     className?: ClassValue;
 };
-/**
- * Fusionne des classes CSS en résolvant les conflits Tailwind.
- * Combine clsx pour la logique conditionnelle et tailwind-merge pour la résolution des conflits.
- *
- * @param inputs - Classes CSS à fusionner
- * @returns Chaîne de classes CSS fusionnée
- */
 export declare function tweak(...inputs: ClassValue[]): string;
 export declare namespace tweak {
     var variants: <T extends Record<string, Record<string, string>>, Defaults extends Partial<Record<keyof T, string>> = {}>(config: {
         base?: string;
         variants?: T;
         defaultVariants?: Defaults;
-    }) => (options?: ConfigVariants<T> & ClassProp) => string;
+    }) => (options?: (ConfigVariants<T> & ClassProp)) => string;
 }
 export type { VariantProps };