@wakastellar/ui 0.1.6 → 0.1.10

package/dist/utils/error-handling.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Unified Error Handling System for @wakastart/ui
+ *
+ * Provides consistent error handling patterns across all components.
+ *
+ * @module error-handling
+ * @example
+ * ```tsx
+ * import { WakaError, tryCatch, tryCatchAsync, handleError } from '@wakastellar/ui'
+ *
+ * // Sync operations
+ * const result = tryCatch(() => parseJSON(data), {
+ *   context: 'DataTable.parseConfig',
+ *   fallback: defaultConfig,
+ * })
+ *
+ * // Async operations
+ * const data = await tryCatchAsync(() => fetchData(), {
+ *   context: 'DataTable.fetchData',
+ *   onError: (err) => showToast(err.message),
+ * })
+ * ```
+ */
+/**
+ * Error codes for @wakastart/ui
+ */
+export declare const ErrorCode: {
+    readonly UNKNOWN: "WAKA_UNKNOWN";
+    readonly VALIDATION: "WAKA_VALIDATION";
+    readonly NETWORK: "WAKA_NETWORK";
+    readonly TIMEOUT: "WAKA_TIMEOUT";
+    readonly THEME_LOAD_FAILED: "WAKA_THEME_LOAD_FAILED";
+    readonly THEME_PARSE_FAILED: "WAKA_THEME_PARSE_FAILED";
+    readonly THEME_APPLY_FAILED: "WAKA_THEME_APPLY_FAILED";
+    readonly LANG_LOAD_FAILED: "WAKA_LANG_LOAD_FAILED";
+    readonly LANG_PARSE_FAILED: "WAKA_LANG_PARSE_FAILED";
+    readonly TRANSLATION_MISSING: "WAKA_TRANSLATION_MISSING";
+    readonly DATATABLE_EXPORT_FAILED: "WAKA_DATATABLE_EXPORT_FAILED";
+    readonly DATATABLE_IMPORT_FAILED: "WAKA_DATATABLE_IMPORT_FAILED";
+    readonly DATATABLE_PARSE_FAILED: "WAKA_DATATABLE_PARSE_FAILED";
+    readonly COMPONENT_RENDER_FAILED: "WAKA_COMPONENT_RENDER_FAILED";
+    readonly COMPONENT_INIT_FAILED: "WAKA_COMPONENT_INIT_FAILED";
+    readonly PROVIDER_MISSING: "WAKA_PROVIDER_MISSING";
+    readonly PROVIDER_CONFIG_INVALID: "WAKA_PROVIDER_CONFIG_INVALID";
+};
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * Custom error class for @wakastart/ui
+ */
+export declare class WakaError extends Error {
+    /** Error code for programmatic handling */
+    readonly code: ErrorCodeType;
+    /** Context where the error occurred */
+    readonly context?: string;
+    /** Original error if wrapped */
+    readonly cause?: Error;
+    /** Additional metadata */
+    readonly metadata?: Record<string, unknown>;
+    /** Timestamp when error occurred */
+    readonly timestamp: Date;
+    constructor(message: string, options?: {
+        code?: ErrorCodeType;
+        context?: string;
+        cause?: Error;
+        metadata?: Record<string, unknown>;
+    });
+    /**
+     * Create a WakaError from any error type
+     */
+    static from(error: unknown, options?: {
+        code?: ErrorCodeType;
+        context?: string;
+        metadata?: Record<string, unknown>;
+    }): WakaError;
+    /**
+     * Serialize error for logging or transmission
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Options for error handling utilities
+ */
+export interface ErrorHandlerOptions<T> {
+    /** Context identifier for logging */
+    context?: string;
+    /** Error code to use */
+    code?: ErrorCodeType;
+    /** Callback when error occurs */
+    onError?: (error: WakaError) => void;
+    /** Fallback value to return on error */
+    fallback?: T;
+    /** Whether to rethrow the error after handling */
+    rethrow?: boolean;
+    /** Additional metadata to attach to error */
+    metadata?: Record<string, unknown>;
+    /** Whether to suppress logging (default: false) */
+    silent?: boolean;
+}
+/**
+ * Handle an error with consistent logging and callbacks
+ */
+export declare function handleError(error: unknown, options?: Omit<ErrorHandlerOptions<unknown>, "fallback">): WakaError;
+/**
+ * Wrap a synchronous operation with error handling
+ *
+ * @example
+ * ```ts
+ * const config = tryCatch(
+ *   () => JSON.parse(jsonString),
+ *   { context: 'parseConfig', fallback: {} }
+ * )
+ * ```
+ */
+export declare function tryCatch<T>(fn: () => T, options?: ErrorHandlerOptions<T>): T | undefined;
+/**
+ * Wrap an async operation with error handling
+ *
+ * @example
+ * ```ts
+ * const data = await tryCatchAsync(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   { context: 'fetchData', onError: showError }
+ * )
+ * ```
+ */
+export declare function tryCatchAsync<T>(fn: () => Promise<T>, options?: ErrorHandlerOptions<T>): Promise<T | undefined>;
+/**
+ * Create a wrapped version of an async function with error handling
+ *
+ * @example
+ * ```ts
+ * const safeFetch = withErrorHandling(
+ *   fetchUserData,
+ *   { context: 'UserService.fetchData' }
+ * )
+ * ```
+ */
+export declare function withErrorHandling<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, options?: Omit<ErrorHandlerOptions<TReturn>, "fallback">): (...args: TArgs) => Promise<TReturn>;
+/**
+ * Assert a condition, throwing a WakaError if false
+ *
+ * @example
+ * ```ts
+ * assertCondition(user != null, 'User must be authenticated', {
+ *   code: ErrorCode.VALIDATION,
+ *   context: 'UserProfile',
+ * })
+ * ```
+ */
+export declare function assertCondition(condition: boolean, message: string, options?: {
+    code?: ErrorCodeType;
+    context?: string;
+    metadata?: Record<string, unknown>;
+}): asserts condition;
+/**
+ * Type guard to check if an error is a WakaError
+ */
+export declare function isWakaError(error: unknown): error is WakaError;
+/**
+ * Check if error matches a specific code
+ */
+export declare function isErrorCode(error: unknown, code: ErrorCodeType): error is WakaError;
+/**
+ * Create error factories for specific contexts
+ *
+ * @example
+ * ```ts
+ * const createDataTableError = createErrorFactory('DataTable')
+ * throw createDataTableError('Export failed', ErrorCode.DATATABLE_EXPORT_FAILED)
+ * ```
+ */
+export declare function createErrorFactory(context: string): (message: string, code?: ErrorCodeType, metadata?: Record<string, unknown>) => WakaError;
+/**
+ * Retry an async operation with exponential backoff
+ *
+ * @example
+ * ```ts
+ * const data = await retryAsync(
+ *   () => fetchWithTimeout('/api/data'),
+ *   { maxRetries: 3, context: 'fetchData' }
+ * )
+ * ```
+ */
+export declare function retryAsync<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    context?: string;
+    onRetry?: (attempt: number, error: WakaError) => void;
+}): Promise<T>;

package/dist/utils/index.d.ts

@@ -3,3 +3,7 @@ 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/logger.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Conditional logging utility for @wakastart/ui
+ *
+ * Respects NODE_ENV and debug flags to prevent console pollution in production.
+ *
+ * @example
+ * ```ts
+ * import { logger } from '@wakastart/ui'
+ *
+ * // Only logs in development or when debug is enabled
+ * logger.debug('DataTable props:', props)
+ * logger.info('Theme loaded successfully')
+ * logger.warn('Missing translation key')
+ * logger.error('Failed to load theme', error)
+ * ```
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerConfig {
+    /** Enable debug logging (overrides NODE_ENV check) */
+    debug?: boolean;
+    /** Minimum log level to display */
+    minLevel?: LogLevel;
+    /** Prefix for all log messages */
+    prefix?: string;
+}
+declare class Logger {
+    private config;
+    constructor(config?: LoggerConfig);
+    /**
+     * Configure the logger
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Check if logging is enabled for the given level
+     */
+    private shouldLog;
+    /**
+     * Format log message with prefix
+     */
+    private format;
+    /**
+     * Debug level logging (development only by default)
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Info level logging
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Warning level logging (always shown)
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Error level logging (always shown)
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export { Logger };
+export type { LoggerConfig, LogLevel };

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

@@ -1,66 +1,130 @@
 /**
- * Theme Loader pour charger dynamiquement les thèmes depuis S3 ou toute URL
+ * @fileoverview Chargeur dynamique de thèmes pour WakaStart UI
  *
- * Supporte tous les formats de couleurs (hex, rgb, hsl, oklch, etc.)
- * grâce au système TweakCN avec @theme inline
+ * 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`)
+ * }
+ * ```
  */
 export interface ThemeLoaderConfig {
-    /**
-     * URL de base où les thèmes sont stockés (S3, CDN, etc.)
-     */
+    /** URL de base où les fichiers CSS des thèmes sont stockés */
     baseUrl: string;
-    /**
-     * Cache les thèmes déjà chargés pour éviter les requêtes répétées
-     */
+    /** Active le cache des thèmes chargés (défaut: true) */
     cache?: boolean;
-    /**
-     * Timeout en millisecondes pour le chargement d'un thème
-     */
+    /** Timeout en ms pour le chargement d'un thème (défaut: 10000) */
     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é une fois le thème chargé avec succès
-     */
+    /** Callback appelé après chargement réussi d'un thème */
     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 une URL
+     * 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')
+     * ```
      */
     loadTheme(themeName: string): Promise<void>;
     /**
-     * Applique un thème déjà chargé
+     * 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
      */
     applyTheme(themeName: string): void;
     /**
-     * Récupère le thème actuellement appliqué
+     * Récupère le nom du thème actuellement appliqué
+     *
+     * @returns Nom du thème ou null si aucun n'est défini
      */
     getCurrentTheme(): string | null;
     /**
-     * Charge le dernier thème utilisé depuis localStorage
+     * Récupère le dernier thème utilisé depuis localStorage
+     *
+     * @returns Nom du thème sauvegardé ou null
      */
     loadSavedTheme(): string | null;
     /**
-     * Précharge plusieurs thèmes en parallèle
+     * 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'])
+     * ```
      */
     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
+     * Vide complètement le cache et supprime tous les styles injectés
      */
     clearCache(): void;
     /**
-     * Liste tous les thèmes chargés
+     * Retourne la liste des noms de thèmes actuellement en cache
+     *
+     * @returns Tableau des noms de thèmes chargés
      */
     getLoadedThemes(): string[];
     /**
@@ -73,23 +137,69 @@ declare class ThemeLoader {
     private injectThemeStyles;
 }
 /**
- * Initialise le theme loader avec une configuration
+ * 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}`)
+ * })
+ * ```
  */
 export declare function initThemeLoader(config: ThemeLoaderConfig): ThemeLoader;
 /**
- * Récupère l'instance globale du theme loader
+ * Récupère l'instance globale du chargeur de thèmes
+ *
+ * @throws {Error} Si initThemeLoader() n'a pas été appelé
+ * @returns Instance du ThemeLoader
  */
 export declare function getThemeLoader(): ThemeLoader;
 /**
- * Charge un thème depuis l'instance globale
+ * 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é
  */
 export declare function loadTheme(themeName: string): Promise<void>;
 /**
- * Applique un thème depuis l'instance globale
+ * Applique un thème déjà chargé via l'instance globale
+ *
+ * @param themeName - Nom du thème à appliquer
  */
 export declare function applyTheme(themeName: string): void;
 /**
- * Hook React pour charger des thèmes dynamiquement
+ * 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>
+ *   )
+ * }
+ * ```
  */
 export declare function useThemeLoader(config?: Partial<ThemeLoaderConfig>): {
     loadTheme: (themeName: string) => Promise<void>;

package/dist/utils/tweak.d.ts

@@ -1,18 +1,31 @@
 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wakastellar/ui",
-  "version": "0.1.6",
+  "version": "0.1.10",
   "description": "UI Library compatible TweakCN + i18n pour Next.js",
   "keywords": [
     "ui",
@@ -18,39 +18,40 @@
       "require": "./dist/index.cjs.js"
     },
     "./styles": "./src/styles/globals.css",
-    "./styles/*": "./src/styles/*.css"
+    "./styles/*": "./src/styles/*.css",
+    "./dist/ui.css": "./dist/ui.css"
   },
   "files": [
     "dist",
     "src/styles"
   ],
   "dependencies": {
-    "@radix-ui/react-accordion": "^1.1.2",
-    "@radix-ui/react-alert-dialog": "^1.0.5",
-    "@radix-ui/react-aspect-ratio": "^1.0.3",
-    "@radix-ui/react-avatar": "^1.0.4",
-    "@radix-ui/react-checkbox": "^1.0.4",
-    "@radix-ui/react-collapsible": "^1.0.3",
-    "@radix-ui/react-context-menu": "^2.1.5",
-    "@radix-ui/react-dialog": "^1.0.5",
-    "@radix-ui/react-dropdown-menu": "^2.0.6",
-    "@radix-ui/react-hover-card": "^1.0.7",
-    "@radix-ui/react-label": "^2.0.2",
-    "@radix-ui/react-menubar": "^1.0.4",
-    "@radix-ui/react-navigation-menu": "^1.1.4",
-    "@radix-ui/react-popover": "^1.0.7",
-    "@radix-ui/react-progress": "^1.0.3",
-    "@radix-ui/react-radio-group": "^1.1.3",
-    "@radix-ui/react-scroll-area": "^1.0.5",
-    "@radix-ui/react-select": "^2.0.0",
-    "@radix-ui/react-separator": "^1.0.3",
-    "@radix-ui/react-slider": "^1.1.2",
-    "@radix-ui/react-slot": "^1.0.2",
-    "@radix-ui/react-switch": "^1.0.3",
-    "@radix-ui/react-tabs": "^1.0.4",
-    "@radix-ui/react-toast": "^1.1.5",
-    "@radix-ui/react-toggle": "^1.0.3",
-    "@radix-ui/react-tooltip": "^1.0.7",
+    "@radix-ui/react-accordion": "^1.2.12",
+    "@radix-ui/react-alert-dialog": "^1.1.15",
+    "@radix-ui/react-aspect-ratio": "^1.1.8",
+    "@radix-ui/react-avatar": "^1.1.11",
+    "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-collapsible": "^1.1.12",
+    "@radix-ui/react-context-menu": "^2.2.16",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-hover-card": "^1.1.15",
+    "@radix-ui/react-label": "^2.1.8",
+    "@radix-ui/react-menubar": "^1.1.16",
+    "@radix-ui/react-navigation-menu": "^1.2.14",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-progress": "^1.1.8",
+    "@radix-ui/react-radio-group": "^1.3.8",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-separator": "^1.1.8",
+    "@radix-ui/react-slider": "^1.3.6",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-switch": "^1.2.6",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-toast": "^1.2.15",
+    "@radix-ui/react-toggle": "^1.1.10",
+    "@radix-ui/react-tooltip": "^1.2.8",
     "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.13.12",
     "@types/prismjs": "^1.26.5",
@@ -62,28 +63,42 @@
     "lucide-react": "^0.293.0",
     "next-i18next": "^15.2.0",
     "prismjs": "^1.30.0",
-    "react": ">=19.1.0",
+    "react": "^19.2.0",
     "react-datepicker": "^8.7.0",
     "react-day-picker": "^9.11.1",
-    "react-dom": ">=18.0.0",
+    "react-dom": "^19.2.0",
     "react-i18next": "^13.2.0",
     "tailwind-merge": "^3.3.1",
     "tailwind-variants": "^0.1.18"
   },
   "peerDependencies": {
     "next": ">=15.5.4",
-    "react": ">=19.1.0",
-    "react-dom": ">=18.0.0",
+    "react": ">=19.2.0",
+    "react-dom": ">=19.2.0",
     "react-hook-form": "^7.0.0",
-    "xlsx": "*",
-    "jspdf": "*",
-    "jspdf-autotable": "*"
+    "xlsx": ">=0.18.0",
+    "jspdf": ">=2.5.0",
+    "jspdf-autotable": ">=3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "xlsx": {
+      "optional": true
+    },
+    "jspdf": {
+      "optional": true
+    },
+    "jspdf-autotable": {
+      "optional": true
+    },
+    "react-hook-form": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@chromatic-com/storybook": "^4.1.1",
-    "@testing-library/jest-dom": "^6.1.5",
-    "@testing-library/react": "^14.1.2",
-    "@testing-library/user-event": "^14.5.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.2.0",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^24.7.2",
     "@types/react": "^18.3.26",
     "@types/react-datepicker": "^7.0.0",
@@ -113,6 +128,9 @@
     "test": "vitest --config vitest.config.unit.ts",
     "test:watch": "vitest --config vitest.config.unit.ts --watch",
     "test:coverage": "vitest --config vitest.config.unit.ts --coverage",
-    "test:ui": "vitest --config vitest.config.unit.ts --ui"
+    "test:ui": "vitest --config vitest.config.unit.ts --ui",
+    "release": "./scripts/publish.sh patch",
+    "release:minor": "./scripts/publish.sh minor",
+    "release:major": "./scripts/publish.sh major"
   }
 }