@wakastellar/ui 0.1.8 → 0.1.11

package/dist/components/DataTable/hooks/useDataTableColumnTemplates.d.ts

@@ -0,0 +1,28 @@
+import { ColumnTemplatesConfig, ColumnTemplatesResult } from '../types';
+/**
+ * Hook pour créer des colonnes DataTable à partir de templates prédéfinis
+ *
+ * @template TData - Type des données de la table
+ * @param config - Configuration des templates (locale, currency, etc.)
+ * @returns Fonctions pour créer des colonnes et accéder aux formatters
+ *
+ * @example
+ * ```tsx
+ * const { createColumns, getFormatter } = useDataTableColumnTemplates({
+ *   locale: 'fr-FR',
+ *   currency: 'EUR',
+ * })
+ *
+ * const columns = createColumns<User>([
+ *   { accessorKey: 'email', template: 'email' },
+ *   { accessorKey: 'salary', template: 'currency' },
+ *   { accessorKey: 'status', template: 'status', options: {
+ *     templateOptions: {
+ *       statusColors: { active: 'bg-green-100 text-green-800' }
+ *     }
+ *   }},
+ * ])
+ * ```
+ */
+export declare function useDataTableColumnTemplates<TData extends Record<string, unknown>>(config?: ColumnTemplatesConfig): ColumnTemplatesResult<TData>;
+export default useDataTableColumnTemplates;

package/dist/components/DataTable/hooks/useDataTableExport.d.ts

@@ -1,11 +1,15 @@
+import { ColumnDef } from '@tanstack/react-table';
 import { ExportConfig } from '../types';
+import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'export des données du DataTable
+ * @template TData - Type des données de la table
  */
-export declare function useDataTableExport<TData>({ data, columns, exportConfig, }: {
+export declare function useDataTableExport<TData extends Record<string, unknown>>({ data, columns, exportConfig, onError, }: {
     data: TData[];
-    columns: any[];
-    exportConfig?: ExportConfig;
+    columns: ColumnDef<TData, unknown>[];
+    exportConfig?: ExportConfig<TData>;
+    onError?: (error: WakaError) => void;
 }): {
     exportData: (format: string, customData?: TData[], customFilename?: string) => Promise<void>;
     exportAll: (format: string) => Promise<void>;

package/dist/components/DataTable/hooks/useDataTableImport.d.ts

@@ -1,9 +1,11 @@
 import { ImportConfig } from '../types';
+import { WakaError } from '../../../utils/error-handling';
 /**
  * Hook pour gérer l'import des données dans le DataTable
  */
-export declare function useDataTableImport<TData>({ importConfig, }: {
-    importConfig?: ImportConfig;
+export declare function useDataTableImport<TData>({ importConfig, onError, }: {
+    importConfig?: ImportConfig<TData>;
+    onError?: (error: WakaError) => void;
 }): {
     importData: (file: File) => Promise<TData[]>;
     importWithUI: () => Promise<TData[]>;

package/dist/components/DataTable/hooks/useDataTableOffline.d.ts

@@ -0,0 +1,80 @@
+import { SyncQueueItem, ConflictEntry } from '../services/IndexedDBService';
+export type ConflictResolution = "client-wins" | "server-wins" | "latest-wins" | "manual";
+export interface SyncResult<TData> {
+    id: string;
+    success: boolean;
+    data?: Partial<TData>;
+    error?: string;
+    serverData?: Partial<TData>;
+    serverTimestamp?: Date;
+}
+export interface OfflineConfig<TData> {
+    /** ID unique de la table pour le stockage */
+    tableId: string;
+    /** Activer le mode offline */
+    enabled?: boolean;
+    /** Stratégie de résolution des conflits */
+    conflictResolution?: ConflictResolution;
+    /** Callback de synchronisation vers le serveur */
+    onSync?: (changes: SyncQueueItem<TData>[]) => Promise<SyncResult<TData>[]>;
+    /** Intervalle de synchronisation automatique (ms) */
+    autoSyncInterval?: number;
+    /** Taille max du cache (nombre d'entrées) */
+    maxCacheSize?: number;
+    /** Durée d'expiration du cache (ms) */
+    cacheExpiration?: number;
+    /** Callback quand le statut online change */
+    onOnlineStatusChange?: (isOnline: boolean) => void;
+    /** Callback après synchronisation */
+    onSyncComplete?: (results: SyncResult<TData>[]) => void;
+    /** Callback sur conflit */
+    onConflict?: (conflict: ConflictEntry<TData>) => void;
+}
+export interface OfflineState<TData> {
+    /** Connexion internet disponible */
+    isOnline: boolean;
+    /** Synchronisation en cours */
+    isSyncing: boolean;
+    /** Nombre de changements en attente */
+    pendingChangesCount: number;
+    /** Données en cache */
+    cachedData: TData[] | null;
+    /** Timestamp du dernier cache */
+    lastCacheUpdate: Date | null;
+    /** Conflits à résoudre */
+    conflicts: ConflictEntry<TData>[];
+    /** Erreur de synchronisation */
+    syncError: string | null;
+    /** Dernière synchronisation réussie */
+    lastSyncTime: Date | null;
+    /** IndexedDB disponible */
+    isAvailable: boolean;
+}
+export interface OfflineActions<TData> {
+    /** Cache les données */
+    cacheData: (data: TData[]) => Promise<void>;
+    /** Ajoute un changement à la queue */
+    queueChange: (change: {
+        rowId: string;
+        type: SyncQueueItem<TData>["type"];
+        data: Partial<TData> | null;
+    }) => Promise<void>;
+    /** Lance la synchronisation */
+    sync: () => Promise<void>;
+    /** Résout un conflit */
+    resolveConflict: (conflictId: string, resolution: "local" | "server" | "merge", mergedData?: Partial<TData>) => Promise<void>;
+    /** Récupère les données du cache */
+    loadFromCache: () => Promise<TData[] | null>;
+    /** Vide le cache */
+    clearCache: () => Promise<void>;
+    /** Vide la queue de synchronisation */
+    clearQueue: () => Promise<void>;
+    /** Force le rafraîchissement de l'état */
+    refresh: () => Promise<void>;
+}
+export type UseDataTableOfflineResult<TData> = [OfflineState<TData>, OfflineActions<TData>];
+/**
+ * Hook pour gérer le mode offline du DataTable
+ */
+export declare function useDataTableOffline<TData extends Record<string, unknown>>(config: OfflineConfig<TData>): UseDataTableOfflineResult<TData>;
+export default useDataTableOffline;

package/dist/components/DataTable/hooks/useDataTableVirtualization.d.ts

@@ -2,7 +2,7 @@ import { VirtualizationConfig } from '../types';
 /**
  * Hook pour gérer la virtualisation du DataTable
  */
-export declare function useDataTableVirtualization<TData>({ data, virtualization, containerRef, }: {
+export declare function useDataTableVirtualization<TData extends Record<string, unknown>>({ data, virtualization, containerRef, }: {
     data: TData[];
     virtualization?: VirtualizationConfig;
     containerRef: React.RefObject<HTMLElement>;

package/dist/components/DataTable/index.d.ts

@@ -6,13 +6,38 @@
  * Composant de table de données hautement configurable avec support de :
  * - Tri, filtrage, pagination
  * - Sélection multiple
- * - Export/Import (CSV, JSON)
+ * - Export/Import (CSV, JSON, XLSX)
  * - Layouts multiples (standard, card, compact, split, infinite)
  * - Thème clair/sombre via TweakCN
  * - i18n complet
  * - Virtualisation pour grandes données
  * - Toolbar customisable
  * - Actions par ligne et groupées
+ * - Édition inline
+ * - Groupement avec agrégations
+ * - Redimensionnement des colonnes
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   DataTableAdvanced,
+ *   useDataTableAdvanced,
+ *   type DataTableProps,
+ *   type ColumnDef
+ * } from '@wakastellar/ui'
+ *
+ * const columns: ColumnDef<User>[] = [
+ *   { accessorKey: 'name', header: 'Name' },
+ *   { accessorKey: 'email', header: 'Email' },
+ * ]
+ *
+ * <DataTableAdvanced
+ *   data={users}
+ *   columns={columns}
+ *   selection="multiple"
+ *   enableExport={{ formats: ['csv', 'xlsx'] }}
+ * />
+ * ```
  */
 export { DataTable } from './DataTable';
 export { DataTableAdvanced } from './DataTableAdvanced';
@@ -24,6 +49,14 @@ export { DataTableColumnResizer } from './DataTableColumnResizer';
 export { DataTableGrouping, DataTableGroupTotals, DataTableGroupingControls } from './DataTableGrouping';
 export { DataTableContextMenu } from './DataTableContextMenu';
 export { DataTableSelection, useDataTableSelection } from './DataTableSelection';
+export { DataTableCell } from './DataTableCell';
+export type { DataTableCellProps } from './DataTableCell';
+export { DataTableHeader, DataTableHeaderRow } from './DataTableHeader';
+export type { DataTableHeaderProps } from './DataTableHeader';
+export { DataTableBody, DataTableBodyRow } from './DataTableBody';
+export type { DataTableBodyProps } from './DataTableBody';
+export { DataTableRow } from './DataTableRow';
+export { DataTableGroupRow } from './DataTableGroupRow';
 export { useDataTable } from './hooks/useDataTable';
 export { useDataTableAdvanced } from './hooks/useDataTableAdvanced';
 export { useDataTableVirtualization } from './hooks/useDataTableVirtualization';
@@ -32,6 +65,19 @@ export { useDataTableImport } from './hooks/useDataTableImport';
 export { useDataTableTheme } from './hooks/useDataTableTheme';
 export { useTableLayout } from './hooks/useTableLayout';
 export { useDataTableEdit } from './hooks/useDataTableEdit';
-export type { DataTableProps, DataTableLayout, DataTableVariant, DataTableDensity, DataTableState, FilterConfig, FilterPosition, PaginationConfig, ToolbarConfig, TableAction, ExportConfig, ImportConfig, SelectionState, EditConfig, ColumnEditConfig, SelectionMode, SortMode, VirtualizationType, GroupingConfig, VirtualizationConfig, ColumnResizeConfig, ColumnOrderConfig, RowExpansionConfig, DataTableTheme, } from './types';
+export { useDataTableColumnTemplates } from './hooks/useDataTableColumnTemplates';
+export { useDataTableAdvancedFilters, OPERATORS_BY_TYPE, OPERATOR_LABELS } from './hooks/useDataTableAdvancedFilters';
+export { useDataTableOffline } from './hooks/useDataTableOffline';
+export type { OfflineConfig, OfflineState, OfflineActions, SyncResult, ConflictResolution, UseDataTableOfflineResult, } from './hooks/useDataTableOffline';
+export { DataTableFilterBuilder } from './DataTableFilterBuilder';
+export { DataTableSyncStatus } from './DataTableSyncStatus';
+export type { DataTableSyncStatusProps } from './DataTableSyncStatus';
+export { DataTableConflictResolver } from './DataTableConflictResolver';
+export type { DataTableConflictResolverProps } from './DataTableConflictResolver';
+export { IndexedDBService, getIndexedDBService } from './services/IndexedDBService';
+export type { CacheEntry, SyncQueueItem, ConflictEntry, } from './services/IndexedDBService';
+export { formatters } from './formatters';
+export { templatesMap, getTemplate, availableTemplateNames, createActionsTemplate, dateTemplate, datetimeTemplate, timeTemplate, currencyTemplate, percentageTemplate, numberTemplate, statusTemplate, badgeTemplate, emailTemplate, phoneTemplate, urlTemplate, avatarTemplate, booleanTemplate, actionsTemplate, indexTemplate, idTemplate, ratingTemplate, progressTemplate, tagsTemplate, jsonTemplate, textTemplate, } from './templates';
+export type { DataTableProps, DataTableLayout, DataTableVariant, DataTableDensity, DataTableState, FilterConfig, FilterPosition, FilterValue, PaginationConfig, ToolbarConfig, TableAction, ExportConfig, ImportConfig, SelectionState, EditConfig, ColumnEditConfig, EditableCellValue, SelectionMode, SortMode, VirtualizationType, GroupingConfig, VirtualizationConfig, ColumnResizeConfig, ColumnOrderConfig, RowExpansionConfig, DataTableTheme, RangeValue, DateRangeValue, AggregatedValue, ExportableCellValue, ImportedRowData, TypographyConfig, ColumnTemplateName, FormatterType, ColumnTemplateAction, ColumnTemplateOptions, ColumnTemplateDefinition, ColumnTemplate, ColumnTemplatesConfig, ColumnTemplatesResult, FilterOperator, FilterColumnType, FilterRule, FilterGroup, FilterPreset, FilterableColumn, AdvancedFiltersConfig, AdvancedFiltersState, AdvancedFiltersActions, AdvancedFiltersResult, } from './types';
 export type { EditCellConfig } from './DataTableEditCell';
 export { exportToCSV, exportToJSON, parseCSV, saveTableState, loadTableState, } from './utils';

package/dist/components/DataTable/services/IndexedDBService.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Service IndexedDB pour le mode offline du DataTable
+ * Gère le cache des données, la queue de synchronisation et les conflits
+ */
+export interface CacheEntry<TData> {
+    id: string;
+    tableId: string;
+    data: TData[];
+    timestamp: Date;
+    version: number;
+}
+export interface SyncQueueItem<TData> {
+    id: string;
+    tableId: string;
+    rowId: string;
+    type: "create" | "update" | "delete";
+    data: Partial<TData> | null;
+    timestamp: Date;
+    attempts: number;
+    lastError?: string;
+}
+export interface ConflictEntry<TData> {
+    id: string;
+    tableId: string;
+    rowId: string;
+    localData: Partial<TData> | null;
+    serverData: Partial<TData> | null;
+    localTimestamp: Date;
+    serverTimestamp: Date;
+    type: "create" | "update" | "delete";
+}
+/**
+ * Service pour gérer IndexedDB
+ */
+export declare class IndexedDBService {
+    private db;
+    private initPromise;
+    /**
+     * Initialise la connexion à IndexedDB
+     */
+    init(): Promise<void>;
+    /**
+     * Vérifie si IndexedDB est disponible
+     */
+    isAvailable(): boolean;
+    /**
+     * Ferme la connexion
+     */
+    close(): void;
+    /**
+     * Sauvegarde les données en cache
+     */
+    cacheData<TData>(tableId: string, data: TData[], version?: number): Promise<void>;
+    /**
+     * Récupère les données du cache
+     */
+    getCachedData<TData>(tableId: string): Promise<CacheEntry<TData> | null>;
+    /**
+     * Supprime les données du cache
+     */
+    clearCache(tableId: string): Promise<void>;
+    /**
+     * Supprime les entrées de cache expirées
+     */
+    cleanExpiredCache(maxAgeMs: number): Promise<number>;
+    /**
+     * Ajoute un changement à la queue de synchronisation
+     */
+    queueChange<TData>(tableId: string, rowId: string, type: SyncQueueItem<TData>["type"], data: Partial<TData> | null): Promise<string>;
+    /**
+     * Récupère les changements en attente
+     */
+    getPendingChanges<TData>(tableId: string): Promise<SyncQueueItem<TData>[]>;
+    /**
+     * Compte les changements en attente
+     */
+    countPendingChanges(tableId: string): Promise<number>;
+    /**
+     * Marque un changement comme traité (le supprime)
+     */
+    removeFromQueue(id: string): Promise<void>;
+    /**
+     * Met à jour le nombre de tentatives d'un changement
+     */
+    updateAttempts<TData>(id: string, error?: string): Promise<void>;
+    /**
+     * Vide la queue de synchronisation
+     */
+    clearQueue(tableId: string): Promise<void>;
+    /**
+     * Ajoute un conflit
+     */
+    addConflict<TData>(conflict: Omit<ConflictEntry<TData>, "id">): Promise<string>;
+    /**
+     * Récupère les conflits d'une table
+     */
+    getConflicts<TData>(tableId: string): Promise<ConflictEntry<TData>[]>;
+    /**
+     * Supprime un conflit résolu
+     */
+    resolveConflict(id: string): Promise<void>;
+    /**
+     * Vide tous les conflits d'une table
+     */
+    clearConflicts(tableId: string): Promise<void>;
+    /**
+     * Obtient des statistiques sur la base de données
+     */
+    getStats(tableId: string): Promise<{
+        cacheSize: number;
+        pendingChanges: number;
+        conflicts: number;
+        lastCacheUpdate: Date | null;
+    }>;
+}
+export declare function getIndexedDBService(): IndexedDBService;
+export default IndexedDBService;

package/dist/components/DataTable/templates/index.d.ts

@@ -0,0 +1,104 @@
+import { ColumnTemplate } from '../types';
+/**
+ * Template Date
+ */
+export declare const dateTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template DateTime
+ */
+export declare const datetimeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Time
+ */
+export declare const timeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Currency
+ */
+export declare const currencyTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Percentage
+ */
+export declare const percentageTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Number
+ */
+export declare const numberTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Status/Badge
+ */
+export declare const statusTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Badge (alias de status)
+ */
+export declare const badgeTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Email
+ */
+export declare const emailTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Phone
+ */
+export declare const phoneTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template URL
+ */
+export declare const urlTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Avatar
+ */
+export declare const avatarTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Boolean
+ */
+export declare const booleanTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Actions
+ */
+export declare function createActionsTemplate<TData>(): ColumnTemplate<TData, unknown>;
+/**
+ * Template Actions par défaut
+ */
+export declare const actionsTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Index (numéro de ligne)
+ */
+export declare const indexTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template ID
+ */
+export declare const idTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Rating (étoiles)
+ */
+export declare const ratingTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Progress
+ */
+export declare const progressTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Tags
+ */
+export declare const tagsTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template JSON
+ */
+export declare const jsonTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Template Text (par défaut)
+ */
+export declare const textTemplate: ColumnTemplate<unknown, unknown>;
+/**
+ * Map des templates par nom
+ * Note: Les templates sont typés avec `unknown` pour permettre l'accès dynamique par nom.
+ * Le typage précis est assuré lors de l'utilisation via useDataTableColumnTemplates.
+ */
+export declare const templatesMap: Record<string, ColumnTemplate<unknown, unknown>>;
+/**
+ * Récupère un template par son nom
+ */
+export declare function getTemplate(name: string): ColumnTemplate<unknown, unknown> | undefined;
+/**
+ * Liste des noms de templates disponibles
+ */
+export declare const availableTemplateNames: string[];
+export default templatesMap;