@esfaenza/es-table 11.2.21 → 11.2.22-beta1

package/lib/es_table.component.d.ts

@@ -1,36 +1,38 @@
 import { QueryList, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, TemplateRef } from '@angular/core';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
-import { HashingService, UtilityService, ExportService } from '@esfaenza/extensions';
+import { HashingService, UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
 import { LocalizationService } from '@esfaenza/localizations';
 import { PreferencesService } from '@esfaenza/preferences';
 import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
-import { IAppSearch, 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 { EsTh } from './es_th.component';
 import { EsTdDirective } from './directives/es_td.directive';
 import { EsThDirective } from './directives/es_th.directive';
-import { ItemsSelection } from './domain/classes/ItemsSelection';
+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;
     private utiExts;
     private expExts;
+    private dateExts;
+    private msgExts;
     /** @ignore */
-    constructor(ngControl: NgControl, prefService: PreferencesService, lc: LocalizationService, cdr: ChangeDetectorRef, hashExts: HashingService, utiExts: UtilityService, expExts: ExportService);
+    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;
@@ -79,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;
@@ -90,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;
@@ -100,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: {};
     /**
@@ -130,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;
@@ -162,7 +177,11 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
      */
     CustomCellActionsOn: string;
-    /** Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento */
+    /**
+     * Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento
+     *
+     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+     */
     CellActionPropagates: boolean;
     /**
      * Decide se utilizzare o meno le CustomCells. Impostandolo a **true** l'es-table diventa in grado di gestire nativamente:
@@ -178,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 */
@@ -204,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 */
@@ -217,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;
@@ -260,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 */
@@ -284,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
      *
@@ -297,14 +312,21 @@ 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>;
     /**
      * Evento che viene richiamato quando l'es-table ritiene sia necessario ri-effettuare la ricerca.
-     * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno
+     * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno.
+     *
+     * 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>;
+    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 */
@@ -344,20 +366,98 @@ 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:
+     *
+     *
+     * **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 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 */
+    private ResearchNeeded;
+    /** 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 */
@@ -372,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
      *
@@ -380,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;
     /**
@@ -402,34 +529,86 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      */
     private postBoundSourceCalculation;
     /**
-     * Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML
+     * 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 MoveTemporaryVariablesToRealOnes;
+    private internalPostBoundSource;
     /**
-     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **selection** interno all'AppSearch
+     * Se in modalità array applica gli ordinamenti ASC-DESC delle colonne
      *
-     * @param {any[]} items Oggetti di cui valutare la selezione
-     * @param {ItemsSelection<any>} selectionItem Oggetti di selezione derivante dalla view o dall'oggetto per Array
+     * @todo: INTERNALDB
      */
-    private evaluateSelection;
+    private arrayModeReviewOrderings;
     /**
-     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **arraymodeSelection** dell'es-table
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
      *
-     * @param {any[]} array Lista di oggetti di cui valutare la selezione in modalità array
+     * @param {ths: EsTh[] | EsThDirective[]} ths Header
+     *
+     * @todo: ROW GROUPING
      */
-    private arrayModeEvaluateSelection;
+    private arrayModeReviewGroupings;
     /**
-     * Implementazione agnostica della valutazione delle selezioni degli oggetti. Richiede gli oggetti della vista attuale e l'itemSelector
+     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi
      *
-     * @param {any[]} items Oggetti di cui aggiornare lo stato di selezione
-     * @param {ItemsSelection<any>} selectionItem Oggetto contenente lo stato attuale di selezione
+     * @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 handleSelectionEvaluation;
+    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;
     /**
@@ -444,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
@@ -460,6 +651,9 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     thOrderChanged(id: string, order?: 'DESC' | 'ASC'): void;
     /**
      * Metodo da chiamare ogni volta che si vuole dare evidenza all'esterno del bisogno di rieffettuare la ricerca
+     *
+     * @param {boolean} resetsPage Indica al listener che deve resettare il numero di pagina
+     * @param {AppSearch<any>} viewOverride Override della view da emettere per questa ricerca
      */
     private emitSearchRequest;
     /**
@@ -472,14 +666,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
      */
     private refreshColumnsVisibility;
-    /**
-     *
-     */
-    isEsTd(td: any): td is EsTd;
-    /**
-     *
-     */
-    isEsTh(th: any): th is EsTh;
     /**
      * Allinea gli ordinamenti dati fra le **EsThs** e le informazioni all'interno della View bindata
      *
@@ -508,6 +694,31 @@ 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
+     *
+     * @param {EsThDirective} th Direttiva
+     *
+     * @returns {GroupOrAggregation[]} Lista dei gruppi o aggregazioni relativi alla Direttiva passata
+     */
+    private getGroupAggregations;
+    /**
+     * Data una direttiva con un formato restituisce tutte le coppie Funzione di Aggregazione - Formato
+     *
+     * @param {EsThDirective} th Direttiva EsTh di cui calcolare le funzioni di aggregazione usate
+     *
+     * @returns {{ func: string, format: string }[]} Lista delle funzioni di aggregazione rilevate
+     */
+    private getEsThDirectiveListOfAggregations;
     /**
      * Metodo che genera l'ordine di default delle colonne
      *
@@ -521,10 +732,78 @@ 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;
+    /**
+     * Ottiene un elemento di separazione fra Gruppi che serve per paginare le ricerche all'interno di ogni singolo gruppo
+     *
+     * @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.
+     *
+     * Es. Ho 2 campi di gruppo e ho espanso fino a vedere i valori fino ad un livello qualsiasi.
+     * Clicco l'ordinamento sul secondo gruppo.
+     * Tutte le ricerche relative ai primi gruppi devono essere rieseguite. Quando i risultati arriveranno ci penserà il metodo **bindDisplayToLoadedItemsOrGroups**
+     * a tagliare via gli oggetti non più visualizzati
+     *
+     * @param {string} column Colonna su cui si è effettuata un'operazione di ordinamento
+     * @param {AppOrdering[]} orderings Direttive di ordinamento da applicare alle varie sottoricerche
+     *
+     * @todo: Testare
+     */
+    private emitRowGroupingSearches;
+    /**
+     * Helper che calcola il contenuto di una cella relativa a un gruppo riga, tenendo conto del formato delle eventuali aggregazioni
+     *
+     * @param {Group} grp Gruppo di cui mostrare le celle
+     * @param {string} cell Cella attuale di cui calcolare il testo
+     * @param {EsThDirective} header Header relativo alla cella attuale, utilizzata per identificare le informazioni di aggregazione
+     *
+     * @returns {string} Testo finale calcolato per la **cell** corrente, in base alle aggregazioni di **header**
+     */
+    private getGroupCellDisplay;
+    /**
+     * Gestisce i click sulla tabella solo per le righe a gruppo.
+     * O rimuove gli elementi attualmente presenti o carica il contenuto del gruppo
+     *
+     * @param {any} group Gruppo bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleGroupClick(group: Group): boolean;
+    /**
+     * Funzione che dato un valore lo formatta in base al tipo
+     *
+     * @param {string} value Valore che generalemnte può essere una data o un numero
+     * @param {string} fromat Formato su cui formattare il valore. Può essere ad esempio "small", "long" "verylong" per le date o F{0-9} per i numeri decimali
+     *
+     * @returns {string} Valore dell'aggregazione formattato come si deve
+     */
+    private formatAggregationValue;
     /**
      * All'interno della dialog "Ordinamento e Visibilità Colonne" mette la colonna specificata prima della colonna precedente
      *
@@ -537,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
      *
@@ -600,6 +885,43 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {string} parentKey Chiave del parent di cui collassare i figli
      */
     private collapseChildOfParent;
+    /**
+     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **selection** interno all'AppSearch
+     *
+     * @param {any[]} items Oggetti di cui valutare la selezione
+     * @param {ItemsSelection<any>} selectionItem Oggetti di selezione derivante dalla view o dall'oggetto per Array
+     */
+    private evaluateSelection;
+    /**
+     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **arraymodeSelection** dell'es-table
+     *
+     * @param {any[]} array Lista di oggetti di cui valutare la selezione in modalità array
+     */
+    private arrayModeEvaluateSelection;
+    /**
+     * Implementazione agnostica della valutazione delle selezioni degli oggetti. Richiede gli oggetti della vista attuale e l'itemSelector
+     *
+     * @param {any[]} items Oggetti di cui aggiornare lo stato di selezione
+     * @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**
      *
@@ -617,11 +939,80 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      *
      * @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
      *
@@ -657,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
      *
@@ -763,10 +1158,15 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {string} cornerid Codice dell'operazione selezionata
      */
     cornerActionClicked(cornerid: string): void;
+    /** Helper che identifica se il td attuale è di tipo **EsTd**. In caso contrario è da considerarsi **EsTdDirective** */
+    private isEsTd;
+    /**  Helper che identifica se il th attuale è di tipo **EsTh**. In caso contrario è da considerarsi **EsThDirective** */
+    private isEsTh;
     /** Impostazione modalità dell'EsTable */
     private setMode;
     /**
-     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**, impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
+     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
+     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
      */
     private internalWriteValue;
     /**