@oneteme/jquery-table 0.0.1 → 0.0.3

package/lib/component/export.manager.d.ts

@@ -0,0 +1,16 @@
+import { TableColumnProvider, TableExportConfig } from '../jquery-table.model';
+/**
+ * ExportManager
+ *
+ * Encapsule l'export CSV : construction du fichier BOM/UTF-8, échappement et déclenchement du téléchargement.
+ * Aucune dépendance Angular — indépendant du cycle de vie du composant.
+ */
+export declare class ExportManager<T> {
+    private readonly getRows;
+    private readonly getColumns;
+    private readonly getConfig;
+    private readonly resolveCellValue;
+    constructor(getRows: () => T[], getColumns: () => TableColumnProvider<T>[], getConfig: () => TableExportConfig<T> | undefined, resolveCellValue: (col: TableColumnProvider<T>, row: T, index: number) => any);
+    export(): void;
+    private _csvEscape;
+}

package/lib/component/group-by.manager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GroupByManager
+ *
+ * Encapsule tout l'état et la logique liés au mode Group By :
+ * - état collapsed / expanded des groupes
+ * - pagination interne par groupe
+ * - tri des groupes (asc / desc)
+ * - scroll vers un groupe
+ *
+ * Le composant TableComponent l'instancie et lui passe deux callbacks :
+ *   - `onNeedProjection` : demande une reprojection légère de la page courante
+ *   - `onNeedRender`     : demande un rebuild complet (tri changé etc.)
+ */
+export declare class GroupByManager {
+    private readonly onNeedProjection;
+    private readonly onNeedRender;
+    /** Groupes actuellement ouverts (mode default-collapsed) ou fermés (mode default-expanded). */
+    private readonly _collapsedGroups;
+    /** Page courante par clé de groupe. */
+    private readonly _groupPages;
+    /** Taille de page pour la pagination interne des groupes. */
+    groupPageSize: number;
+    /** Ordre de tri des groupes ('asc' | 'desc'). */
+    groupSortOrder: 'asc' | 'desc';
+    /**
+     * Quand `true`, tous les groupes sont collapsés par défaut.
+     * `_collapsedGroups` contient alors le seul groupe ouvert.
+     */
+    private _defaultGroupCollapsed;
+    constructor(onNeedProjection: () => void, onNeedRender: () => void);
+    /** Initialise le mode par défaut selon qu'un groupBy vient d'être activé. */
+    setDefaultCollapsed(collapsed: boolean): void;
+    /** Réinitialise l'état (à appeler quand le groupBy change de colonne). */
+    reset(): void;
+    isGroupCollapsed(groupKey: string): boolean;
+    toggleGroupCollapse(groupKey: string, scrollTo: (key: string) => void): void;
+    /** Retourne le groupe actuellement ouvert (seulement en mode default-collapsed avec exactement 1 ouvert). */
+    getSingleOpenGroup(): string | null;
+    getPage(groupKey: string): number;
+    groupPageBack(groupKey: string): void;
+    groupPageForward(groupKey: string, totalCount: number): void;
+    onGroupPageSizeChange(size: number): void;
+    onGroupSortToggle(dir: 'asc' | 'desc', scrollTo: (key: string) => void): void;
+}

package/lib/component/lazy-column-manager.d.ts

@@ -0,0 +1,26 @@
+import { TableColumnProvider } from '../jquery-table.model';
+export interface LazyCallbacks {
+    onRefresh(): void;
+    onMarkForCheck(): void;
+}
+/**
+ * Gère le cycle de vie des colonnes à chargement différé (lazy) :
+ * statuts, données, annulation des requêtes en cours.
+ *
+ * Pas de dépendance Angular/DOM — peut être instancié manuellement dans le composant.
+ */
+export declare class LazyColumnManager<T = any> {
+    private _status;
+    private _data;
+    private _cancels;
+    get status(): Map<string, 'idle' | 'loading' | 'loaded' | 'error'>;
+    get data(): Map<string, Map<any, any>>;
+    getStatus(key: string): 'idle' | 'loading' | 'loaded' | 'error';
+    getRenderType(rowValue: any): 'loading' | 'error' | 'value';
+    /** Annule tous les fetches en cours et réinitialise l'état (appeler lors d'un changement de données). */
+    cancelAll(): void;
+    /** Réinitialise une colonne et relance son fetch. */
+    retry(column: TableColumnProvider<T>, resolvedData: T[], callbacks: LazyCallbacks): void;
+    /** Lance le chargement différé d'une colonne. No-op si déjà en cours. */
+    fetch(column: TableColumnProvider<T>, resolvedData: T[], callbacks: LazyCallbacks): void;
+}

package/lib/component/slice-panel/slice-panel.component.d.ts

@@ -1,5 +1,6 @@
 import { ElementRef, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
 import { SliceColumnDef, SliceConfig } from './slice-panel.model';
+import { JqtI18n } from '../../jqt-i18n.token';
 import * as i0 from "@angular/core";
 export declare class SlicePanelComponent<T = any> implements OnChanges, OnInit {
     sliceConfigs: SliceConfig<T>[];
@@ -17,6 +18,8 @@ export declare class SlicePanelComponent<T = any> implements OnChanges, OnInit {
     collapsedChange: EventEmitter<boolean>;
     slicePanelBodyRef?: ElementRef<HTMLElement>;
     private _cdr;
+    private _i18nRaw;
+    readonly i18n: JqtI18n;
     isCollapsed: boolean;
     activeKeysBySlice: Map<number, Set<string>>;
     private _expandedSlices;
@@ -24,7 +27,6 @@ export declare class SlicePanelComponent<T = any> implements OnChanges, OnInit {
         key: string;
         slice: SliceConfig<T>;
     }>;
-    private _hiddenStaticSliceKeys;
     _cachedSlices: SliceConfig<T>[];
     private _countCache;
     readonly trackBySliceIndex: (index: number, _: any) => number;
@@ -46,8 +48,8 @@ export declare class SlicePanelComponent<T = any> implements OnChanges, OnInit {
     togglePanel(): void;
     isSliceDynamic(sliceIndex: number): boolean;
     isSliceLoading(sliceIndex: number): boolean;
-    isStaticSliceVisible(columnKey: string): boolean;
-    toggleStaticSlice(columnKey: string): void;
+    isStaticSliceVisible(_columnKey: string): boolean;
+    toggleStaticSlice(_columnKey: string): void;
     getSliceIcon(slice: SliceConfig<T>): string | undefined;
     isSliceCategoryActive(sliceIndex: number, categoryKey: string): boolean;
     isSliceAllActive(sliceIndex: number): boolean;
@@ -55,6 +57,12 @@ export declare class SlicePanelComponent<T = any> implements OnChanges, OnInit {
     isSliceEmpty(sliceIndex: number): boolean;
     onSliceCategorySelected(sliceIndex: number, categoryKey: string): void;
     onSliceAllSelected(sliceIndex: number): void;
+    /** Retourne l'état des filtres actifs sous forme sérialisable (sliceIndex → tableau de clés).
+     * Inclut les slices sans sélection (tableau vide) pour distinguer "aucune tranche sélectionnée"
+     * (= filtre ouvert, rien coché) de "slice absente". */
+    getActiveFilters(): Record<number, string[]>;
+    /** Restaure les filtres actifs depuis un snapshot sérialisé et réémet le filtre. */
+    restoreFilters(filters: Record<number, string[]>): void;
     addDynamicSlice(column: SliceColumnDef<T>): void;
     removeDynamicSlice(sliceIndex: number): void;
     removeDynamicSliceByKey(key: string): void;

package/lib/component/slice-panel/slice-panel.model.d.ts

@@ -4,7 +4,17 @@ import { Observable } from 'rxjs';
 export interface SliceCategory<T = any> {
     key: string;
     label: string;
-    filter: (row: T) => boolean;
+    /**
+     * Prédicat de filtrage en mémoire — **optionnel**.
+     *
+     * - **Tableau** : requis. Le slice-panel applique ce prédicat sur les lignes locales.
+     * - **Graphique** : omis. Le parent écoute `(activeKeysChange)` pour déclencher
+     *   une nouvelle requête API avec les clés sélectionnées.
+     *
+     * Si `filter` est absent, la sélection n'a aucun effet sur les données locales ;
+     * c'est au composant parent de réagir via `(activeKeysChange)`.
+     */
+    filter?: (row: T) => boolean;
 }
 /**
  * Groupe de filtres affiché dans le panneau latéral.

package/lib/component/table-preferences.manager.d.ts

@@ -0,0 +1,17 @@
+import { SavedTableConfig } from '../jquery-table.model';
+/**
+ * Gère la persistance de la configuration d'un tableau dans le localStorage.
+ * Identifie chaque tableau par un `tableId` unique fourni par l'utilisateur.
+ */
+export declare class TablePreferencesManager {
+    readonly key: string;
+    constructor(tableId: string);
+    /** Retourne la configuration sauvegardée, ou `null` si absente / corrompue. */
+    load(): SavedTableConfig | null;
+    /** Persiste la configuration dans le localStorage. */
+    save(config: SavedTableConfig): void;
+    /** Supprime la configuration sauvegardée. */
+    clear(): void;
+    /** Indique si une configuration est actuellement sauvegardée. */
+    hasSaved(): boolean;
+}

package/lib/component/table.component.d.ts

@@ -1,13 +1,16 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
+import { AfterContentInit, AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
 import { MatMenuTrigger } from '@angular/material/menu';
 import { MatPaginator } from '@angular/material/paginator';
 import { MatSort } from '@angular/material/sort';
 import { MatTableDataSource } from '@angular/material/table';
-import { TableColumnProvider, TableProvider } from '../jquery-table.model';
+import { TableColumnProvider, TableProvider, TableViewConfig } from '../jquery-table.model';
+import { JqtI18n } from '../jqt-i18n.token';
 import { JqtCellDefDirective } from '../directive/jqt-cell-def.directive';
 import { SlicePanelComponent } from './slice-panel/slice-panel.component';
+import { ViewFacade } from './view/view.facade';
+import { GroupByManager } from './group-by.manager';
 import * as i0 from "@angular/core";
-export declare class TableComponent<T = any> implements OnChanges, AfterViewInit, OnDestroy {
+export declare class TableComponent<T = any> implements OnChanges, AfterContentInit, AfterViewInit, OnDestroy {
     config?: TableProvider<T>;
     dataSource?: T[] | {
         data: T[];
@@ -15,6 +18,12 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     data?: T[];
     displayedColumns?: string[];
     columnsConfig?: TableColumnProvider<T>[];
+    /**
+     * Mode HTML : active et configure le panneau View indépendamment du `[config]`.
+     * Prend le dessus sur `config.view` si défini.
+     * Exemple : `<jquery-table [view]="{ enabled: true }">`
+     */
+    view?: TableViewConfig;
     columnLabels?: Record<string, string>;
     isLoading: boolean;
     addRequested: EventEmitter<void>;
@@ -22,6 +31,22 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     columnRemoved: EventEmitter<TableColumnProvider<T>>;
     categorySelected: EventEmitter<string>;
     rowSelected: EventEmitter<T>;
+    /** Émis à chaque changement de tri (y compris le tri initial). */
+    sortChange: EventEmitter<{
+        active: string;
+        direction: 'asc' | 'desc' | '';
+    }>;
+    /** Émis à chaque changement de page ou de taille de page. */
+    pageChange: EventEmitter<{
+        pageIndex: number;
+        pageSize: number;
+    }>;
+    /** Émis à chaque changement de la recherche texte. */
+    searchChange: EventEmitter<string>;
+    /** Émis quand le Group by change (clé de colonne, ou `null` si désactivé). */
+    groupByChange: EventEmitter<string>;
+    /** Émis quand la liste des colonnes visibles change (clés dans l’ordre d’affichage). */
+    columnsChange: EventEmitter<string[]>;
     set paginator(value: MatPaginator | undefined);
     get paginator(): MatPaginator | undefined;
     private _paginator?;
@@ -30,48 +55,108 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     slicePanelRef?: SlicePanelComponent<T>;
     viewMenuTrigger?: MatMenuTrigger;
     _cellDefs: QueryList<JqtCellDefDirective>;
+    /** Map clé→TemplateRef pré-calculée depuis _cellDefs. Mise à jour dans ngAfterContentInit et sur _cellDefs.changes. */
+    private _cellDefMap;
     renderedColumns: string[];
     tableDataSource: MatTableDataSource<any, import("@angular/material/table").MatTableDataSourcePaginator>;
+    /** Constante exposée au template pour le matColumnDef de la ligne de groupe. */
+    readonly _GROUP_ROW_COLUMN = "__group_row";
+    /** Clés d'accès aux propriétés des lignes projetées — exposées pour le template. */
+    readonly _ROW_RAW_KEY = "__raw";
+    readonly _ROW_INDEX_KEY = "__index";
+    readonly _ROW_GROUP_KEY = "__groupKey";
+    readonly _ROW_GROUP_COUNT = "__groupCount";
+    readonly _ROW_GROUP_PAGE = "__groupPage";
+    readonly _ROW_GROUP_PAGE_COUNT = "__groupPageCount";
+    /** Facade View : état et actions centralisés (Champs / Group by / Slice by) */
+    readonly _view: ViewFacade<T>;
+    /**
+     * Snapshot stable synchronisé depuis _view.fields.activeColumns dans refreshViewModel().
+     * Propriété (non getter) pour qu'Angular puisse la suivre sans NG0100.
+     */
     activeColumns: TableColumnProvider<T>[];
     activeSliceFilter: (row: T) => boolean;
     _sliceConfigs: any[];
     _sliceColumns: TableColumnProvider<T>[];
     _sliceData: T[];
     _sliceShowToggle: boolean;
-    _staticSlicesForMenu: Array<{
+    /** Snapshot stable de la visibilité du panneau slice — jamais calculé depuis @ViewChild */
+    _showSlicePanel: boolean;
+    /** Snapshot stable de l'état collapsed du panneau slice, mis à jour via (collapsedChange) */
+    _slicePanelCollapsed: boolean;
+    get _staticSlicesForMenu(): Array<{
+        key: string;
+        title: string;
+        icon?: string;
+    }>;
+    get _activeDynamicSliceColumns(): TableColumnProvider<T>[];
+    get _availableColumnsForDynamicSlice(): TableColumnProvider<T>[];
+    get _allDynamicSliceColumns(): TableColumnProvider<T>[];
+    get _activeSliceByLabel(): string;
+    _sliceByMenuItems: Array<{
+        isStatic: boolean;
         key: string;
         title: string;
         icon?: string;
+        col?: TableColumnProvider<T>;
     }>;
-    _activeDynamicSliceColumns: TableColumnProvider<T>[];
-    _availableColumnsForDynamicSlice: TableColumnProvider<T>[];
-    _allDynamicSliceColumns: TableColumnProvider<T>[];
-    _activeSliceByLabel: string;
     searchQuery: string;
-    activeGroupByKey: string | null;
+    get activeGroupByKey(): string | null;
     _matSortActive: string;
     _matSortDirection: 'asc' | 'desc' | '';
-    private _collapsedGroups;
     private _activeSort;
     private _sortSubscribed;
     private _destroy$;
-    private _defaultGroupCollapsed;
-    private _groupPages;
     private _totalFilteredCount;
-    _lazyColumnStatus: Map<string, "error" | "loaded" | "idle" | "loading">;
-    _lazyColumnData: Map<string, Map<any, any>>;
-    private _lazyFetchCancels;
+    /** Gestionnaire du mode Group By (état collapsed, pagination, tri des groupes). */
+    readonly _groupBy: GroupByManager;
+    /** Délégués vers GroupByManager pour la compatibilité des templates. */
+    get groupPageSize(): number;
+    set groupPageSize(v: number);
+    get groupSortOrder(): 'asc' | 'desc';
+    set groupSortOrder(v: 'asc' | 'desc');
+    /** Gestionnaire du cycle de vie des colonnes lazy (fetch, annulation, statuts, données). */
+    private _lazy;
+    /** Compatibilité template : retourne la map de statuts lazy. */
+    get _lazyColumnStatus(): Map<string, "error" | "loaded" | "idle" | "loading">;
+    /** Compatibilité template : retourne la map de données lazy. */
+    get _lazyColumnData(): Map<string, Map<any, any>>;
     private _cdr;
     private _el;
+    private _ngZone;
+    private _i18nRaw;
+    /** Labels de l’interface. Fusionnés depuis JQT_I18N_DEFAULTS et le token JQT_I18N injecté. */
+    readonly i18n: JqtI18n;
     isGroupHeader: (_: number, row: any) => boolean;
+    /** Retourne true si la ligne de groupe est une ligne normale (ni lazy, ni too-many). */
+    isNormalGroupRow(row: any): boolean;
+    isGroupRowLoading(row: any): boolean;
+    isGroupRowTooMany(row: any): boolean;
+    /** Gère le clic sur une ligne d'en-tête de groupe (no-op pour les états spéciaux). */
+    onGroupHeaderClick(row: any): void;
+    /** Gestionnaire export CSV. */
+    private readonly _export;
     pageSize: number;
     pageSizeOptions: number[];
     pageSizeOptionsGroupBy: number[];
-    groupPageSize: number;
-    groupSortOrder: 'asc' | 'desc';
     draggedColumnKey: string | null;
     dragOverColumnKey: string | null;
-    private userCustomizedColumns;
+    /** Vrai quand le mode édition est actif (resize + drag colonnes, interactions désactivées). */
+    _editMode: boolean;
+    /** Largeurs de colonnes personnalisées par l'utilisateur (clé → px). */
+    _columnWidths: Record<string, number>;
+    /** Message de feedback après save/clear. `null` = pas de message. */
+    _preferencesMessage: string | null;
+    /** Vrai si une configuration est sauvegardée pour ce tableau. */
+    _hasSavedConfig: boolean;
+    private _preferencesManager;
+    /** true une fois que le group-by par défaut a été initialisé (évite de reconfigurer GroupByManager à chaque changement de données). */
+    private _defaultGroupByApplied;
+    private _resizeState;
+    /** Dynamic slice keys à restaurer après ngAfterViewInit (slicePanelRef pas encore dispo). */
+    private _pendingDynamicSliceKeys;
+    /** Filtres de slice à restaurer après ngAfterViewInit (slicePanelRef pas encore dispo). */
+    private _pendingSliceFilters;
     private resolvedConfig;
     private _columnMap;
     private _resolvedData;
@@ -80,16 +165,17 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     private static readonly MAX_GROUP_COUNT;
     private _allFilteredRows;
     private _paginatorSubscribed;
-    private _groupCacheRows;
-    private _groupCacheKey;
-    private _groupCacheSortOrder;
-    private _groupCacheSortActive;
-    private _groupCacheSortDir;
-    private _groupCacheOrder;
-    private _groupCacheMap;
+    /** Cache groupBy — invalidé dès que rows/key/tri changent. */
+    private _groupCache;
     private _pendingRender;
+    private _staticSliceHiddenKeys;
+    private _configHiddenKeys;
+    /** Clés des colonnes visibles du dernier émission columnsChange (pour éviter les émissions dupliquement). */
+    private _prevColumnKeys;
     ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
     ngAfterViewInit(): void;
+    private _applyPendingDynamicSliceKeys;
     ngOnDestroy(): void;
     private _measureHeaderHeight;
     get title(): string;
@@ -97,7 +183,12 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     get visibleColumns(): TableColumnProvider<T>[];
     get showSearchBar(): boolean;
     get showViewButton(): boolean;
+    get showSliceExpandBtn(): boolean;
+    get showExportButton(): boolean;
+    get showPreferencesMenu(): boolean;
+    get hasSavedPreferences(): boolean;
     get showToolbar(): boolean;
+    expandSlicePanel(): void;
     get showFields(): boolean;
     get showGroupBySection(): boolean;
     get filteredRowCount(): number;
@@ -119,6 +210,7 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     getLazyRenderType(rowValue: any): 'loading' | 'error' | 'value';
     retryLazyColumn(column: TableColumnProvider<T>): void;
     triggerLazyFetch(column: TableColumnProvider<T>): void;
+    private _lazyCallbacks;
     toggleGroupCollapse(groupKey: string): void;
     private scrollToGroupHeader;
     isGroupCollapsed(groupKey: string): boolean;
@@ -131,6 +223,8 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     get allowColumnRemoval(): boolean;
     get hasSliceConfig(): boolean;
     get showSlicePanel(): boolean;
+    onSlicePanelCollapsedChange(collapsed: boolean): void;
+    private _recomputeShowSlicePanel;
     get showAddSliceButton(): boolean;
     get staticSlicesForMenu(): Array<{
         key: string;
@@ -157,12 +251,17 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     onColumnVisibilityChange(column: TableColumnProvider<T>, checked: boolean): void;
     isColumnVisible(columnKey: string): boolean;
     onRemoveColumn(columnKey: string, event?: Event): void;
+    private _rebuildCellDefMap;
     getCellTemplate(key: string): TemplateRef<{
         $implicit: any;
         index: number;
     }> | null;
     get hasCustomCellDefs(): boolean;
     get hasRowClickHandler(): boolean;
+    /** Largeur minimale du tableau en px, calculée depuis les largeurs explicites des colonnes actives.
+     * Retourne null si aucune colonne n'a de largeur définie (le tableau remplit alors 100% du conteneur).
+     * Seules les valeurs explicitement en `px` sont sommables ; les pourcentages ou autres unités sont ignorés. */
+    get tableMinWidth(): string | null;
     trackRowFn: (_index: number, row: any) => any;
     getRowClass(row: any): string | string[] | Record<string, boolean>;
     onRowClick(row: any, event: MouseEvent | null): void;
@@ -171,20 +270,59 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     onHeaderDrop(targetColumnKey: string, event: DragEvent): void;
     onHeaderDragEnd(): void;
     isHeaderDropTarget(columnKey: string): boolean;
+    enterEditMode(): void;
+    confirmEditMode(): void;
+    /** Démarre le resize d'une colonne (mousedown sur la poignée droite). */
+    onResizeStart(columnKey: string, event: MouseEvent): void;
+    /** Retourne la largeur CSS d'une colonne (px si personnalisée, sinon la valeur de config ou auto). */
+    getColumnWidth(key: string): string;
+    savePreferences(): void;
+    clearPreferences(): void;
+    private _preferencesMessageTimer;
+    private _showPreferencesMessage;
+    private _applyPreferences;
     canRemoveColumn(column: TableColumnProvider<T>): boolean;
     isCellEmpty(value: any): boolean;
     asTitle(value: any): string;
+    onExport(): void;
     private refreshViewModel;
-    private _computeSliceLabel;
+    /** Retourne uniquement les slices visibles (non cachées par _staticSliceHiddenKeys).
+     * Le SlicePanelComponent affiche tout ce qu'il reçoit — c'est ici que se fait le filtrage. */
+    private _computeSliceConfigs;
+    private static _setsEqual;
+    private _buildSliceByMenuItems;
+    get sliceByMenuItems(): {
+        isStatic: boolean;
+        key: string;
+        title: string;
+        icon?: string;
+        col?: TableColumnProvider<T>;
+    }[];
+    onSliceMenuItemClick(item: {
+        isStatic: boolean;
+        key: string;
+        col?: TableColumnProvider<T>;
+    }): void;
+    isSliceMenuItemActive(item: {
+        isStatic: boolean;
+        key: string;
+    }): boolean;
     private _scheduleRender;
     private _executeRender;
     private _projectCurrentPage;
     private buildEffectiveConfig;
+    private static _hashColumns;
     private resolveData;
     private resolveColumnsFromCompat;
     private getCategoryFilteredData;
     private projectRows;
     private _buildSortComparator;
+    /**
+     * Retourne la valeur telle qu'elle est affichée dans la cellule, en suivant exactement
+     * le même chemin que resolveCellValue — utilisée pour la recherche plein-texte.
+     * Ne passe pas par sortValue (valeur brute de tri) contrairement à getLazyAwareValue.
+     */
+    private getDisplayValueForSearch;
     private getLazyAwareValue;
     private resolveCellValue;
     private resolvePageSize;
@@ -195,5 +333,5 @@ export declare class TableComponent<T = any> implements OnChanges, AfterViewInit
     private attachPaginator;
     private attachSort;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "jquery-table", never, { "config": { "alias": "config"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "data": { "alias": "data"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "columnsConfig": { "alias": "columnsConfig"; "required": false; }; "columnLabels": { "alias": "columnLabels"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, { "addRequested": "addRequested"; "columnAdded": "columnAdded"; "columnRemoved": "columnRemoved"; "categorySelected": "categorySelected"; "rowSelected": "rowSelected"; }, ["_cellDefs"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "jquery-table", never, { "config": { "alias": "config"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "data": { "alias": "data"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "columnsConfig": { "alias": "columnsConfig"; "required": false; }; "view": { "alias": "view"; "required": false; }; "columnLabels": { "alias": "columnLabels"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, { "addRequested": "addRequested"; "columnAdded": "columnAdded"; "columnRemoved": "columnRemoved"; "categorySelected": "categorySelected"; "rowSelected": "rowSelected"; "sortChange": "sortChange"; "pageChange": "pageChange"; "searchChange": "searchChange"; "groupByChange": "groupByChange"; "columnsChange": "columnsChange"; }, ["_cellDefs"], never, true, never>;
 }

package/lib/component/table.constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Constantes sentinel utilisées pour les identifiants de colonnes et les valeurs
+ * projetées dans le datasource interne de la table.
+ *
+ * Centraliser ici évite les typos silencieuses et facilite les tests unitaires.
+ */
+/** Identifiant de la colonne virtuelle rendue sur toute la largeur pour les en-têtes de groupe. */
+export declare const GROUP_ROW_COLUMN = "__group_row";
+/** Marqueur posé sur les objets de ligne pour signaler une ligne d'en-tête de groupe. */
+export declare const GROUP_HEADER_MARKER = "__groupHeader";
+/** Clé du groupe spéciale « chargement lazy en cours ». */
+export declare const GROUP_KEY_LAZY_LOADING = "__lazy_loading__";
+/** Clé du groupe spéciale « trop de groupes ». */
+export declare const GROUP_KEY_TOO_MANY = "__too_many_groups__";
+/** Propriété injectée dans chaque ligne projetée : référence vers la ligne brute d'origine. */
+export declare const ROW_RAW_KEY = "__raw";
+/** Propriété injectée dans chaque ligne projetée : index global de la ligne dans le jeu de données filtré. */
+export declare const ROW_INDEX_KEY = "__index";
+/** Propriété injectée dans chaque ligne projetée : clé du groupe auquel appartient la ligne d'en-tête. */
+export declare const ROW_GROUP_KEY = "__groupKey";
+/** Propriété injectée dans chaque ligne projetée : nombre de lignes dans le groupe. */
+export declare const ROW_GROUP_COUNT = "__groupCount";
+/** Propriété injectée dans chaque ligne projetée : page courante du groupe. */
+export declare const ROW_GROUP_PAGE = "__groupPage";
+/** Propriété injectée dans chaque ligne projetée : nombre de pages du groupe. */
+export declare const ROW_GROUP_PAGE_COUNT = "__groupPageCount";
+/** Valeur sentinelle posée dans une cellule lazy en cours de chargement. */
+export declare const LAZY_LOADING_VALUE = "__lazy_loading__";
+/** Valeur sentinelle posée dans une cellule lazy en erreur. */
+export declare const LAZY_ERROR_VALUE = "__lazy_error__";

package/lib/component/view/view.facade.d.ts

@@ -0,0 +1,95 @@
+import { ViewEvent, ViewField, ViewState } from '@oneteme/jquery-core';
+import { TableColumnProvider, TableViewConfig } from '../../jquery-table.model';
+import { SliceConfig } from '../slice-panel/slice-panel.model';
+export type { ViewField, ViewConfig, ViewState, ViewEvent } from '@oneteme/jquery-core';
+export { viewField, groupableViewFields, sliceableViewFields, initialViewState } from '@oneteme/jquery-core';
+export interface ViewFieldState {
+    activeColumns: TableColumnProvider<any>[];
+    /** true si l'utilisateur a déjà personnalisé la sélection de colonnes */
+    userCustomized: boolean;
+}
+export interface ViewGroupByState {
+    activeKey: string | null;
+    userCustomized: boolean;
+}
+export interface ViewSliceByState {
+    activeDynamicColumns: TableColumnProvider<any>[];
+    availableForDynamic: TableColumnProvider<any>[];
+    allDynamicColumns: TableColumnProvider<any>[];
+    activeLabel: string;
+}
+export interface ViewPanelConfig {
+    /** Config brute issue de TableProvider.view */
+    config?: TableViewConfig;
+    /** Toutes les colonnes résolues (non filtrées) */
+    columns: TableColumnProvider<any>[];
+    /** Slices statiques */
+    sliceConfigs: SliceConfig<any>[];
+    /** Label utilisé quand aucun groupe / aucune slice n’est actif. Défaut : 'Aucun'. */
+    noneLabel?: string; /** Clé de colonne utilisée comme group-by par défaut au chargement. */
+    defaultGroupBy?: string | null;
+}
+/**
+ * Centralise l'état et les actions du panneau View (Champs / Group by / Slice by).
+ * Pas de dépendance Angular/DOM : peut être extraite vers jquery-core à terme.
+ *
+ * Usage :
+ *   this._view = new ViewFacade();
+ *   this._view.events$.subscribe(e => { ... });
+ *   this._view.update({ config, columns, sliceConfigs });
+ */
+export declare class ViewFacade<T = any> {
+    readonly fields: ViewFieldState;
+    readonly groupBy: ViewGroupByState;
+    readonly sliceBy: ViewSliceByState;
+    private _panelConfig;
+    private _hiddenStaticKeys;
+    private readonly _events$;
+    readonly events$: import("rxjs").Observable<ViewEvent>;
+    get enabled(): boolean;
+    get showFields(): boolean;
+    get showGroupBySection(): boolean;
+    get showSliceBySection(): boolean;
+    get allowColumnRemoval(): boolean;
+    get isColumnDragDropEnabled(): boolean;
+    get menuBaseColumns(): TableColumnProvider<T>[];
+    get menuOptionalColumns(): TableColumnProvider<T>[];
+    get totalColumnCount(): number;
+    get groupByColumns(): TableColumnProvider<T>[];
+    get activeGroupByLabel(): string;
+    get staticSlicesForMenu(): Array<{
+        key: string;
+        title: string;
+        icon?: string;
+    }>;
+    colLabel(col: {
+        key: string;
+        header?: string;
+    }): string;
+    update(panelConfig: ViewPanelConfig): void;
+    setActiveColumns(columns: TableColumnProvider<T>[]): void;
+    setUserCustomized(value: boolean): void;
+    /** Remet la vue dans son état initial : colonnes par défaut, groupBy par défaut, pas de dynamic slices. */
+    resetToDefaults(): void;
+    addColumn(column: TableColumnProvider<T>): void;
+    removeColumn(columnKey: string): boolean;
+    toggleColumnVisibility(column: TableColumnProvider<T>, visible: boolean): void;
+    reorderColumns(fromKey: string, toKey: string): boolean;
+    isColumnVisible(key: string): boolean;
+    setGroupBy(key: string | null): void;
+    /** Appelée quand le SlicePanelComponent émet dynamicSliceKeysChange */
+    onDynamicSliceKeysChange(keys: string[]): void;
+    isDynamicSliceActive(key: string): boolean;
+    /** Retourne un snapshot ViewState (contrat core) de l'état courant. */
+    toViewState(): ViewState;
+    /** Convertit une TableColumnProvider en ViewField (contrat core). */
+    static toViewField(col: TableColumnProvider<any>): ViewField;
+    destroy(): void;
+    private _refreshDefaultColumns;
+    private _refreshDynamicSliceMeta;
+    /** Notifie la facade des slices statiques actuellement cachées (géré par table.component).
+     * Recalcule le label slice afin qu'il reflète uniquement les slices visibles. */
+    updateHiddenStaticKeys(keys: Set<string>): void;
+    private _computeSliceLabel;
+    private _uniqueByKey;
+}