@esfaenza/es-table 11.2.19 → 11.2.22-beta2

package/lib/es_table.component.d.ts

@@ -4,16 +4,19 @@ import { HashingService, UtilityService, ExportService, MessageService, DateServ
 import { LocalizationService } from '@esfaenza/localizations';
 import { PreferencesService } from '@esfaenza/preferences';
 import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
-import { IAppSearch, AppSearch, AppOrdering, GenericItem, EsTableColumnsDefinition, CornerMenuOption, ReportResult, ReportColumn, EsTableOperationDefinition, EsTableColumn } from './domain';
+import { AppSearch, AppOrdering, GenericItem, EsTableColumnsDefinition, CornerMenuOption, ReportResult, ReportColumn, EsTableOperationDefinition, EsTableColumn, GroupPager } from './domain';
 import { EsTd } from './es_td.component';
 import { EsTdDirective } from './directives/es_td.directive';
 import { EsThDirective } from './directives/es_th.directive';
-import { ItemsSelection } from './domain/classes/ItemsSelection';
-import { Group } from './domain/classes/AppSearch';
+import { ItemsSelection } from './domain/externals/classes/appsearch/ItemsSelection';
+import { Group } from "./domain/externals/classes/appsearch/Group";
+import { EsTableDefaultable } from './models/EsTableDefaultable';
 /** Componente che permette di rappresentare una griglia di valori */
 export declare class EsTableComponent implements ControlValueAccessor, OnChanges {
     ngControl: NgControl;
     private prefService;
+    private deafults;
+    locale: string;
     lc: LocalizationService;
     private cdr;
     private hashExts;
@@ -22,17 +25,14 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     private dateExts;
     private msgExts;
     /** @ignore */
-    constructor(ngControl: NgControl, prefService: PreferencesService, lc: LocalizationService, cdr: ChangeDetectorRef, hashExts: HashingService, utiExts: UtilityService, expExts: ExportService, dateExts: DateService, msgExts: MessageService);
+    constructor(ngControl: NgControl, prefService: PreferencesService, deafults: EsTableDefaultable, locale: string, lc: LocalizationService, cdr: ChangeDetectorRef, hashExts: HashingService, utiExts: UtilityService, expExts: ExportService, dateExts: DateService, msgExts: MessageService);
     /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) e ReportDefinition per la **reportMode** */
     View: any;
     /** Modello da cui l'es-table mostra i pulsanti di paginazione in basso a destra */
     arrayPulsanti: any;
     /** Indica se l'es-table deve mostrare il check globale nell'header per fare il "seleziona tutto" */
     globalCheck: boolean;
-    /**
-     * Tiene da conto l'ultimo elemento selezionato in modo da fare ragionamenti del tipo
-     * "Ho selezionato questo, l'ultimo selezionato era **lastSelected**, devo selezionare tutti quelli in mezzo", ad esempio per la selezione multipla
-     */
+    /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */
     private lastSelected;
     /** Conteggio interno per il numero di elementi selezionati */
     selectedObjects: number;
@@ -81,6 +81,8 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     };
     /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
     RowTHs: {
+        Pinned: boolean;
+        Fixed: boolean;
         ID: string;
         Visible: boolean;
         Class: string;
@@ -92,6 +94,7 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     }[];
     /** Modello di appoggio temporaneo per i **RowTHs** */
     TMPRowTHs: {
+        Pinned: boolean;
         Fixed: boolean;
         ID: string;
         Visible: boolean;
@@ -102,6 +105,16 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
         Template: TemplateRef<any>;
         Wrap: boolean;
     }[];
+    /** Modello di appoggio temporaneo per i **RowThGroups** */
+    TMPRowThGroups: {
+        Span: number;
+        Template: TemplateRef<any>;
+    }[][];
+    /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */
+    RowThGroups: {
+        Span: number;
+        Template: TemplateRef<any>;
+    }[][];
     /** Cache per i routerLink generati nelle tabelle dinamiche */
     DynamicTableRouterLinkCache: {};
     /**
@@ -132,13 +145,13 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     EsTdsDirective: QueryList<EsTdDirective>;
     /** Query per recuperare tutti gli es-td assegnati a direttiva (Per la modalità dinamica dell'es-table) */
     EsThsDirective: QueryList<EsThDirective>;
-    /** Query per recuperare tutti gli es-th */
+    /** @deprecated Query per recuperare tutti gli es-th */
     private EsThs;
-    /** Query per recuperare tutti gli es-td */
+    /** @deprecated Query per recuperare tutti gli es-td */
     private EsTds;
-    /** Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */
+    /** @deprecated Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */
     bodyRef: any;
-    /** Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */
+    /** @deprecated Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */
     headerRef: any;
     /** Query per recuperare le informazioni sul raggruppamento degli header */
     headerGroupRef: any;
@@ -184,14 +197,14 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     UseCustomCells: boolean;
     /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */
     MaxHeight: number;
-    /** Classi da applicare alla tabella oltre a quelle gestite autonomamente dalla libreria */
-    Class: string;
+    /** Classi da applicare al contenitore della tabella */
+    ContainerClass: any;
     /** Permette o meno l'export in formato XLSX */
     XLSXExport: boolean;
     /** Permette o meno l'export in formato CSV */
     CSVExport: boolean;
     /** Permette di visualizzare o meno l'opzione di paginazione "Tutti" */
-    AllSearch: boolean;
+    AllSearch: any;
     /** Diminuisce gli spazi fra una cella e l'altra, e internamente il padding del font in modo da presentare molti più dati in un'unica pagina */
     HighCellDensity: boolean;
     /** Abilita o meno la possibilità di selezionare oggetti */
@@ -210,8 +223,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     Export: boolean;
     /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */
     ShiftClick: boolean;
-    /** Mostra o nasconde le informazioni di paginazione, sia i pulsanti, sia il selettore degli oggetti per pagina */
-    ShowPaging: boolean;
     /** Indica se nascondere o mostrare il componente di paginazione */
     HidePaging: boolean;
     /** Indica se nascondere o mostrare il conteggio degli elementi trovati */
@@ -223,18 +234,16 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     /** Nome dell'esportazione generata da questa tabella */
     ExportFileName: string;
     /** Classe (HTML) di default della tabella */
-    TableClass: string;
-    /** Testo da visualizzare nel conteggio. Di default: "Oggetti selezionati" */
-    CountLabel: string;
+    TableClass: any;
     /**
      * Funzione da utilizzare in esportazione. Nel formato "Report" avrà un unico parametro "Formato" e nessun valore di ritorno.
      *
      * Nel formato "View" ha come parametro una callback con i dati completi da esportare (dato che di default la ricerca è paginata)
      */
     ExportFunction: any;
-    /** Indica la presenza di raggruppamenti a livello di header */
+    /** @deprecated Indica la presenza di raggruppamenti a livello di header */
     HasHeaderGroup: boolean;
-    /** Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
+    /** @deprecated Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
     HasSecondaryHeaderGroup: boolean;
     /** Utilizzato per dividere la sorgente in modalità EndlessScroll */
     SliceSize: number;
@@ -266,12 +275,8 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     HiddenColumns: boolean;
     /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */
     ColumnsOrdering: boolean;
-    /**
-     * Eventuale supporto alle ricerche applicate alla modalità Array
-     *
-     * @deprecated Utilizzato solo per un caso particolare del Metering
-     */
-    SearchView: IAppSearch<any>;
+    /** Eventuale supporto alle ricerche applicate alla modalità Array */
+    SearchView: AppSearch<any>;
     /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */
     SelectAll: boolean;
     /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */
@@ -290,6 +295,10 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     StartsExpanded: boolean;
     /** Indica se effettuare il salvataggio delle preferenze di ricerca */
     SavePreferences: boolean;
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    PagingStyle: 'both' | 'top' | 'bottom';
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    RowGroupingPagingStyle: 'left' | 'right';
     /**
      * Sorgente dati secondaria
      *
@@ -303,7 +312,9 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      */
     TertiarySource: boolean;
     /** Indica se utilizzare la cache di selezione che permette di mantenere gli stati di selezione dei vari oggetti navigando da una pagina all'altra */
-    UseSelectionCache: boolean;
+    UseSelectionCache: any;
+    /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */
+    ShowItemGroupsColumns: any;
     /** Evento che viene richiamato al cambio di oridnamento di una colonna */
     onOrderChanged: EventEmitter<AppOrdering>;
     /**
@@ -312,8 +323,10 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      *
      * Solo in caso venga utilizzata la modalità a raggruppamenti di righe può succedere che l'es-table passi un intero AppSearch come parametro di ricerca,
      * in quel caso l'applicazione ricevente dovrà onorare la richiesta spedendo al backand l'oggetto di ricerca AS-IS
+     *
+     * il tipo dell'Emitter invece di essere [boolean | AppSearch<any>] è stato impostato a "any" per evitare problemi di retrocompatibilità
      */
-    onSearchRequest: EventEmitter<boolean | AppSearch<any>>;
+    onSearchRequest: EventEmitter<any>;
     /** Evento che parte ad ogni modifica di "checkaggio" in forma di comodo array. Espone l'oggetto con lo stato di check attuale */
     onSelectionChanged: EventEmitter<ItemsSelection<any>>;
     /** Evento richiamato all'eliminazione di un oggetto */
@@ -353,16 +366,20 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     /** Numero di pagine (durante la paginazione in modalità Array) */
     arraymodePages: number;
     /** Oggetti per ogni pagina (durante la paginazione in modalità Array) */
-    ArraymodeItemsPerPage: number;
+    ArraymodeItemsPerPage: any;
     /** Oggetto di selezione per la modalità Array, che deve comportarsi come la controparte in modalità View */
     arraymodeSelection: ItemsSelection<any>;
+    /** Colonne da visualizzare in modalità array */
+    arrayColumns: string[];
+    /** Ordine delle colonne da visualizzare in modalità array */
+    arrayColumnOrdering: string[];
+    /** Ordinamenti ASC-DESC sulle colonne in modalità array */
+    arrayOrders: AppOrdering[];
     /**
      * Variabile che serve a gestire il momento in cui l'es-table aggiorna la paginazione (pulsanti ecc).
      * Essendo operazioni comunque costose le effettuo solo su binding esterni, non su rewrite generati internamente
      */
     private internalWriteCall;
-    /** Cache di selezione Hash - Oggetto */
-    private selOrDeselCache;
     /**
      * Cache che conterrà tutte le ricerche effettuate su gruppi diversi dal primo e su elementi contenuti nei gruppi.
      * In caso di cambi di ordinamento delle colonne diverse dalla prima tutte le chiamate fatte dal secondo livello in poi devono essere rieseguite secondo la seguente logica:
@@ -370,35 +387,77 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      *
      * **Cambio ordinamento sul primo gruppo**: reload completo, non mi occupo di ripulire gli elementi bindati in alcun modo
      *
-     * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto del gruppo precedente, per quelli aperti, devo precedentemente ripulire
+     * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto dei gruppi precedenti, ripulendo precedentemente
      * tutti gli elementi con **_grouplevel** = N
      *
      * **Cambio ordinamento su una colonna non raggruppata**: reload completo per tutti i gruppi finali aperti, devo precedentemente ripulire tutti gli elementi con **_item** = true
      *
-     *
      * Altri eventi non dovrebbero rappresentare problemi:
      * - Selezione: non cambia nulla
      * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne
-     *
      */
     private groupSearchRequestsCache;
-    /**
-     * Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno
-     */
+    /** Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno */
     private ResearchNeeded;
-    /**
-     * Variabile da usare nei "colspan" quando si vuole dire "Tutte le colonne". 42 è un numero magico che mi serve per non calcolare questa variabile quando mi serve.
-     *
-     * Di base dovrebbe essere la somma dei RowTH con l'aggiunta di tutti gli Header extra in base alle situazioni. Dato che diventa una logica deficiente me la cavo così
-     *
-     * Se in una tabella ci sono meno di 42 colonne il colspan si ferma comunque alla fine, se invece ce ne sono di più... beh bisogna allungare sto numero
-     *
-     */
-    allColumns: string;
+    /** Colonne visibili della vista attuale. Valorizzato di default al numero massimo di colonne supportate dalla tabella per le casistiche in assenza di custom cells */
+    Columns: {
+        Visibile: number;
+        VisibleUnpinned: number;
+        Global: number;
+    };
+    /** In caso di Row Grouping qui viene salvata la vista principale dei gruppi base */
+    MainGroupView: AppSearch<any>;
+    /** Conteggio base degli oggetti. In modalità normale viene resettato ad ogni nuova View inserita, in modalità RowGrouping viene resettato solo ad una nuova View di livello "0" */
+    private BaseItemsCount;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
+    private rgGroupCache;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    private rgItemCache;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    private rgChildGroupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via hash*/
+    private itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private group_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via indice*/
+    private i_itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_group_exclusionsCache;
+    /** Indica se ci sono delle colonne pinnate e visibili. Serve per poter settare tutte le colonne prima che arrivino dati a pinned*/
+    HasPinnedColumns: boolean;
+    /** Larghezza calcolata del container delle colonne pinnate */
+    PinnedContainerWidth: number;
+    /** Indica se nonostante siamo in modalità array sono stati individuati dei gruppi. In tal caso es-table si comporta da pseudo backend ed effettua le aggregazioni e raggruppamenti completamente lato client */
+    ArrayGrouping: boolean;
+    PagerOptions: {
+        PagerCount: number;
+        ShowCount: boolean;
+        ShowPaging: boolean;
+        UsesView: boolean;
+        View: any;
+        Ready: boolean;
+        Searches: 'items' | 'groups';
+    };
     /** @ignore */
     ngOnInit(): void;
     /** @ignore */
     ngAfterViewInit(): void;
+    /**
+     * Se l'Input è null (valore non settato) vede se c'è un default con cui valorizzarlo. Se non c'è utilizza il valore di fallback (qualora fornito)
+     *
+     * @param {T} inputValue Valore dell'Input
+     * @param {T} defaultValue Valore di default impostato da configurazione
+     * @param {T} fallbackValue Valore dell'Input per quando non è stato assegnato dal programmatore e non ha un default
+     */
+    private InputOrDefault;
     /** @ignore */
     ngOnDestroy(): void;
     /** @ignore */
@@ -413,6 +472,19 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     propagateChange: (_: any) => void;
     /** @ignore */
     writeValue(obj: any): void;
+    /**
+     * Successivamente al bind del nuovo input questa funzione si occupa di finalizzare tutti i parametri di funzionamento dell'es-table
+     * in base a Input - Modello, e qualsiasi altra cosa possa servire
+     */
+    private finalizeContext;
+    /** Genera le informzioni di paginazione per la vista globale dell'es-table */
+    private setupPagingInformations;
+    /**
+     * Ripulisce le cache di selezione
+     *
+     * @todo: SELECTION
+     */
+    private clearSelectionCaches;
     /**
      * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia
      *
@@ -421,14 +493,28 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode
      *
      * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia
+     *
+     * @todo: ITEMS
      */
     private getItemsByMode;
-    /** @ignore */
+    /**
+     * @ignore
+     *
+     * @todo: ITEMS
+     */
     private getViewItemsBySource;
+    /**
+     * Helper per effettuare il caching delle aggregazioni. Le sposta da una lista di **GroupAggregation** a una **<Map<string, Map<string, string>>**
+     *
+     * @todo: ROWGROUPING
+     */
+    private cacheAggregations;
     /**
      * Metodo che prende tutti gli oggetti di cui dispone divisi in bucket da 100 elementi
      *
      * @returns {any[][]} Matrice di array Nx100
+     *
+     * @todo: ITEMS
      */
     private getItemSlices;
     /**
@@ -442,11 +528,89 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * all'es-table per renderizzare i valori da mostrare
      */
     private postBoundSourceCalculation;
+    /**
+     * Per poter distinguere le chiamate a questo metodo: Dopo il setTimeout se uso gli EsTd/EsTh vecchi, senza il setTimeout se uso le nuove direttive
+     */
+    private internalPostBoundSource;
+    /**
+     * Se in modalità array applica gli ordinamenti ASC-DESC delle colonne
+     *
+     * @todo: INTERNALDB
+     */
+    private arrayModeReviewOrderings;
+    /**
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
+     *
+     * @param {ths: EsTh[] | EsThDirective[]} ths Header
+     *
+     * @todo: ROW GROUPING
+     */
+    private arrayModeReviewGroupings;
+    /**
+     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi
+     *
+     * @param {Group[]} grps Definizione dei gruppi
+     * @param {number} currentIndex Indice di elaborazione. Al livello 0 ho tutti gli oggetti e devo generare i primi gruppi, a livello 1 ho tutti i gruppi principali e devo
+     * elaborare i sottogruppi, e così via ricorsivamente...
+     * @param {any[]} items Oggetti da raggruppare
+     * @param {GroupOrAggregation[]} aggregations Info di aggregazione
+     * @param {any} parent Riferimento al gruppo padre
+     *
+     * @todo: INTERNALDB
+     */
+    private getGroupsRecursive;
+    /**
+     * Data una lista di oggetti genera le aggregazioni specificate. Si considera di avere tutti gli oggetti
+     *
+     * @param {any[]} items Oggetti di cui calcolare le aggregazione
+     * @param {GroupOrAggregation[]} aggregations Aggergazioni da generare
+     *
+     * @todo: INTERNALDB
+     */
+    private generateAggregations;
+    /**
+     * Data una lista di oggetti effettua dei raggruppamenti in base alla proprietà **field**, restituendo un oggetto del tipo { Gruppo1: oggetti[], Gruppo2: oggetti[], ecc... }
+     *
+     * @param {any[]} array Lista degli oggetti da raggruppare
+     * @param {string} field Campo su cui effettuare i raggruppamenti
+     *
+     * @returns {{ [id: string]: any[] }} Dizionario dei gruppi
+     *
+     * @todo: INTERNALDB
+     */
+    private groupBy;
+    /**
+     * Effettua il binding degli oggetti pervenuti da questa chiamata con gli oggetti effettivamente da graficare
+     *
+     * @param {any} view View da cui sono arrivati gli oggetti. Può essere o un array se sono in **arrayMode** o una AppSearch<T> se sono in **viewMode**
+     */
     private bindDisplayToLoadedItemsOrGroups;
+    /**
+     * In modalità rowgrouping quando mi arriva un nuovo blocco di oggetti devo aggiungerlo alla vista attuale:
+     *
+     * 1) Se non viene richiesto il dettaglio di alcun gruppo significa che devo considerare mi siano arrivati tutti i gruppi principali
+     * 2) Se viene richiesto il dettaglio di un gruppo diverso dall'ultimo devo aggiungere dopo al gruppo cliccato la lista dei sottogruppi
+     * 2) Se viene richiesto il dettaglio dell'ultimo gruppo devo aggiungere dopo al gruppo cliccato la lista degli oggetti
+     *
+     * @param {any} view AppSearch<T> da cui sono arrivati gli oggetti
+     * @param {number} groupingKeys Livelli di raggruppamento da aspettarsi sui dati
+     *
+     * @todo: ROWGROUPING
+     */
+    private handleNewDataOnRowGrouping;
     /**
      * Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML
      */
     private MoveTemporaryVariablesToRealOnes;
+    /**
+     * Permette di selezionare o deselezionare in maniera arbitraria degli oggetti
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} select **true** per selezionarli, **false** per non toccarli
+     *
+     * @todo: SELECTION
+     */
+    setSelectionStatus(items: any[], select: boolean): void;
     /**
      * Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna
      */
@@ -459,6 +623,18 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
      */
     private reviewColumnsList;
+    /**
+     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
+     */
+    private moveFixedColumnsAtTheBeginning;
+    /**
+     * In base alla configurazione delle colonne calcola le dimenioni delle colonne pinnate
+     */
+    private evaluatePinnedColumnsWidth;
+    /**
+     * Helper per spostare un oggetto di un array da un indice all'altro, in place
+     */
+    private arrayMove;
     /**
      * Terminato il binding delle colonne da **reviewColumnsList** e della **View** dal **writeValue** questo metodo si occupa
      * dell'allineamento delle informazioni fra le colonne calcolate internamente e le informazioni sulle colonne che arrivano dall'AppSearch
@@ -518,6 +694,15 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
      */
     private evaluateRowThs;
+    private evaluateHeadersGroupingInfos;
+    /**
+     * Genera gli header groups da una lista di info sui th all'interno della variabile **TMPRowThGroups**
+     */
+    private evaluateHeaderGroups;
+    /**
+     * Calcola il numero di salti da un header foglia all'ultimo parent della catena
+     */
+    private jumpsToFinalParent;
     /**
      * Data una direttiva EsTh restituisce la lista delle aggregazioni richiesta per questa colonna o il gruppo che rappresenta
      *
@@ -547,7 +732,7 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {boolean} finalize Se **true** significa che non mi aspetto di dover effettuare altre operazioni e posso renderizzare la situazione in base ai RowContext
      * Senza finalize significa che mi aspetto altre operazioni che prima o poi richiameranno questa funzione col finalize.
      *
-     * Ad esempio, una volta selezionato ordinamento fisico/logico delle colonne so che parte un altra ricerca che mi rivalorizzera da "writeValue", che già chiama questa funzione.
+     * Ad esempio, una volta selezionato ordinamento fisico/logico delle colonne so che parte un altra ricerca che mi rivalorizzerà da "writeValue", che già chiama questa funzione.
      * Mettendo solo la chiamata da "writeValue" come "finalizzante" mi assicuro che smanattamenti a frontend non causino flickering fino a quando non servono
      */
     private applyOrdering;
@@ -557,11 +742,26 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {AppSearch<any>} view View utilizzata per la ricerca. Me ne salvo i parametri nel separatore attuale dato che ne ho bisogno per caricare altri elementi
      * facenti riferimento allo stesso contesto
      * @param {string} parent Parent path che rappresenta a quale gruppo è affibbiato questo separatore
+     * @param {GroupRouteFragment[]} route Route path che rappresenta a quale gruppo è affibbiato questo separatore
      * @param {number} level Livello del gruppo di cui questo elemento è separatore, viene usato per applicare la classe "est-lvl-{{level}}"
      *
      * @returns {any} Elemento di separazione contenente tutti i bind per presentare una paginazione sotto questo gruppo lato interfaccia
      */
     private getGroupSeparator;
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indietro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    addToPageGroup(page: number, pager: GroupPager): void;
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    goToPageGroup(page: number, pager: GroupPager): void;
     /**
      * Data una colonna effettua la riemissione di tutte le ricerche relative.
      *
@@ -616,6 +816,12 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {EsTableColumn} columnItem Colonna da spostare
      */
     sendDown(columnItem: EsTableColumn): void;
+    /**
+     * All'interno della dialog "Ordinamento e Visibilità Colonne" pinna la colonna specificata
+     *
+     * @param {EsTableColumn} columnItem Colonna da spostare
+     */
+    pinOrUnpinColumn(columnItem: EsTableColumn): void;
     /**
      * All'interno della dialog "Ordinamento e Visibilità Colonne" inverte le impostazioni di visibilità della colonna
      *
@@ -699,6 +905,23 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {ItemsSelection<any>} selectionItem Oggetto contenente lo stato attuale di selezione
      */
     private handleSelectionEvaluation;
+    /**
+     * Dato un oggetto trova la cella di cache in cui è registrato e aggiorna il contenuto
+     *
+     * @param {any} item Oggetto da aggiornare
+     */
+    private rehidrateCache;
+    /**
+     * Dato un gruppo controlla ricorsivamente l'albero di cui fa parte se c'è stata una inclusione o esclusione diretta
+     *
+     * @param {any} grp Gruppo da controllare
+     *
+     * @returns {'none' | 'excluded' | 'included'}
+     * 'none' se non ci sono informazioni su inclusioni o esclusioni
+     * 'included' se il gruppo controllato è stato incluso in maniera esplicita dall'albero dei gruppi padri
+     * 'excluded' se il gruppo controllato è stato escluso in maniera esplicita dall'albero dei gruppi padri
+     */
+    private parentTreeStatus;
     /**
      * Gestisce la selezione globale degli oggetti, sia per pagina che a livello di **SelectAll**
      *
@@ -712,14 +935,84 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      *
      * @param {any[]} items Oggetti da selezionare o deselezionare
      * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     * @param {boolean} globalCheck Valore del check globale
      *
      * @returns {ItemsSelection<any>} Oggetto di selezione aggiornato con le informazioni sull'ultima operazione effettuata
      */
-    private handleItemsSelection;
+    handleItemsSelection(items: any[], forcedVal?: boolean, globalCheck?: boolean): ItemsSelection<any>;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * Logica semplificata rispetto all'originale **performSelectionOperations** per lavorare in una modalità in cui tutti gli elementi sono caricati (**ArrayGrouping** = true)
+     */
+    private performSimpleSelectionOperations;
+    /**
+     * Helper per selezionare un gruppo e, ricorsivamente, se tutti i gruppi sottostanti al parent sono selezionati, selezionare i gruppi padri
+     *
+     * @param {any} group Gruppo da selezionare
+     */
+    private selectGroup;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * La logica di questa funzione è nata essenzialmente da spam di trial & error ed è stata testata solo fino a due livelli di raggruppamento,
+     * qualsiasi cosa vada oltre non è 100% detto che funzioni...
+     */
+    private performSelectionOperations;
+    /**
+     * Helper per evitare di riscrivere ogni santa volta array.splice(array.indexof(item), 1);
+     */
+    private removeItem;
+    /**
+     * Helper per evitare di riscrivere ogni santa volta array.push(item); e la gestione della
+     */
+    private addItem;
+    /**
+     * Ottiene il trittico di selezione: L'array degli oggetti e le due cache
+     */
+    private getTriptic;
+    /**
+     * Dato un oggetto restituisce il gruppo di cui fa parte, se esiste
+     *
+     * @param {any} item Oggetto di cui trovare il gruppo
+     */
+    private getItemGroup;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Chiave da cercare
+     * @param {'selected' | 'unselected'} status Stato degli elementi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo gli elementi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_item** facenti capo alla chiave **groupKey**
+     */
+    private getGroupItems;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Gruppo di cui cercare il parent
+     *
+     * @returns {any} Oggetto di tipo **_group** rappresentante il parent del **group** attuale
+     */
+    private getGroupParent;
+    /**
+     * Data la chiave di un gruppo restituisce tutti i gruppi figli
+     *
+     * @param {string} group Gruppo che rappresenta il padre di cui cercare i figli
+     * @param {'selected' | 'unselected'} status Stato dei gruppi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo i gruppi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_group** facenti capo alla chiave **groupKey**
+     */
+    private getGroupChildGroups;
     /**
      * Finalizza le informazioni di selezione del **ItemsSelection** corrente
      */
     private finalizeSelectionInformations;
+    /**
+     * Compatta una cache di indici
+     */
+    private compactIndexMap;
     /**
      * Gestisce i click sulla tabella, gestendo eventualmente anche gli Shift + Click per selezionare un range di oggetti
      *
@@ -755,7 +1048,11 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest**
      * per comunicare al componente che utilizza questa tabella che i dati sono da aggiornare
      */
-    onItemsPerPageChanged(): void;
+    onItemsPerPageChanged(newIpp: any): void;
+    /**
+     * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest** con la vista del separatore
+     */
+    onGroupItemsPerPageChanged(pager: GroupPager, newIpp: number): void;
     /**
      * Effettua l'esportazione dei dati
      *

package/lib/es_table.component.loc.d.ts

@@ -1,10 +1,6 @@
 import { LocalizationService } from "@esfaenza/localizations";
-/**
- * Classe di localizzazione per il componente **EsTableComponent**
- */
+/** Classe di localizzazione per il componente **EsTableComponent** */
 export declare class EsTableLoc extends LocalizationService {
-    /**
-     * @ignore
-     */
+    /** @ignore */
     constructor(LOC_LOCALE: string);
 }