@esfaenza/es-table 11.2.22-beta6 → 11.2.23

package/lib/{pager → components/pager}/table_pager.component.d.ts

@@ -1,4 +1,4 @@
-import { ChangeDetectorRef, EventEmitter } from "@angular/core";
+import { ChangeDetectorRef, EventEmitter, SimpleChanges } from "@angular/core";
 import { LocalizationService } from "@esfaenza/localizations";
 import { MessageService } from "@esfaenza/extensions";
 /** Componente che si occupa della paginazione di una tabella */
@@ -21,8 +21,12 @@ export declare class TablePagerComponent {
     GroupMode: boolean;
     /** Indica se utilizzare il conteggio dei gruppi o degli oggetti */
     GroupCount: boolean;
+    /** Indica il testo che va a sostituire "Oggetti Visualizzati" in caso si stia facendo qualcosa di custom, Ignorato in caso di gruppi */
+    CountLabel: string;
     /** Indica se visualizzare il numero totale di oggeti presenti */
     ShowCount: boolean;
+    /** Indica se visualizzare il numero totale di oggeti presenti */
+    ShowPaging: boolean;
     /** Indica il numero totale di oggeti presenti */
     PagerCount: number;
     /** Indica se mostrare o meno il contenuto @deprecated usata solo da MatrixValuesComponent nella lib relativa */
@@ -35,7 +39,10 @@ export declare class TablePagerComponent {
     Model: number;
     /** Opzioni di paginazione */
     PagingOptions: number[];
+    /** @ignore */
     ngOnInit(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
     /**
      * Funzione richiamata dal template quando un utente clicca su un numero di paginazione.
      *

package/lib/core/handlers/classes/ColumnMetadataHandler.d.ts

@@ -0,0 +1,159 @@
+import { UtilityService } from "@esfaenza/extensions";
+import { PreferencesService } from "@esfaenza/preferences";
+import { EsTd } from "../../../components/es-td/es_td.component";
+import { EsTh } from "../../../components/es-th/es_th.component";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { EsTdDirective } from "../../../directives/es_td.directive";
+import { EsThDirective } from "../../../directives/es_th.directive";
+import { UtilitiesHandler, RowGroupingHandler } from "..";
+import { AppSearch, EsTableColumn } from "../../../domain";
+/** Classe che gestisce tutte le informaizoni relative alle colonne: visibilità, posizione, stato di pin/unpin, ecc ecc... */
+export declare class ColumnMetadataHandler {
+    private est;
+    private utilities;
+    private utiExts;
+    private prefService;
+    private rgH;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler, utiExts: UtilityService, prefService: PreferencesService, rgH: RowGroupingHandler);
+    /**
+     * Metodo che gestisce il cambio di Ordinamento di una colonna
+     *
+     * @param {string} id ID della colonna il cui oridnamento è cambiato
+     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna
+     */
+    handleTHOrderChange(id: string, order: 'DESC' | 'ASC'): void;
+    /**
+     * Partendo dagli **EsThs** estrappolo la lista di **EsTableColumn** che questa tabella dovrà eventualmente gestire per Visibilità e Ordine
+     *
+     * Costo: 1 scan EsThs
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     */
+    reviewColumnsList(ths: EsTh[] | EsThDirective[]): void;
+    /**
+     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
+     */
+    moveFixedColumnsAtTheBeginning(ths: EsTh[] | EsThDirective[], tds: EsTd[] | EsTdDirective[]): void;
+    /** In base alla configurazione delle colonne calcola le dimenioni delle colonne pinnate */
+    evaluatePinnedColumnsWidth(): void;
+    /**
+     * 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
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    alignColumnsIfLoadedView(view: AppSearch<any>): void;
+    /**
+     * In base alla visibilità registrata nelle **ColumnsList** questo metodo si occupa di prendere tutti i **EsThs** ed **EsTds** relativi e nasonderli/mostrarli
+     *
+     * Costo: 1 scan ColumnsList, 1 scan EsThs, 1 scan EsTds
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Header della tabella
+     * @param {EsTd[] | EsTdDirective[]} tds Celle della tabella
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    refreshColumnsVisibility(ths: EsTh[] | EsThDirective[], tds: EsTd[] | EsTdDirective[], view: AppSearch<any>): void;
+    /**
+     * Allinea gli ordinamenti dati fra le **EsThs** e le informazioni all'interno della View bindata
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     */
+    alignHeadersOrdering(ths: EsTh[] | EsThDirective[], view: AppSearch<any>): void;
+    /**
+     * Genera tutte le informazioni che servono per gestire il raggruppamento degli header
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     *
+     * @returns {{ leafs: EsTh[] | EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} Oggetto contenente la lista delle foglie (header base), il livello
+     * massimo di raggruppamento raggiunto, una cache in cui vengono indicati tutti i gruppi che sono "parent" (quindi che raggruppano almeno 1 header) e la cache degli header
+     */
+    evaluateHeadersGroupingInfos(ths: EsTh[] | EsThDirective[]): {
+        leafs: EsTh[] | EsThDirective[];
+        groupingLevel: number;
+        parentsCache: any;
+        thsCache: any;
+    };
+    /**
+     * Genera gli header groups da una lista di info sui th all'interno della variabile **TMPRowThGroups**
+     *
+     * @param {{ leafs: EsTh[] | EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} infos Informazioni di raggruppamento valutate precedentemente
+     */
+    evaluateHeaderGroups(infos: {
+        leafs: EsTh[] | EsThDirective[];
+        groupingLevel: number;
+        parentsCache: any;
+        thsCache: any;
+    }): void;
+    /**
+     * Calcola il numero di salti da un header foglia all'ultimo parent della catena
+     *
+     * @param {EsThDirective} th Header da cui scorrere i padri per capire quanti livelli ci sono sopra
+     * @param {{ [index: string]: EsThDirective }} thsCache Cache degli header
+     */
+    private jumpsToFinalParent;
+    /**
+     * Metodo che genera l'ordine di default delle colonne
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    generateDefaultOrder(ths: EsTh[] | EsThDirective[], view: AppSearch<any>): void;
+    /**
+     * Applica l'ordine specificato alle varie colonne
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     * @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 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
+     */
+    applyOrdering(view: AppSearch<any>, finalize: boolean): void;
+    /**
+  * All'interno della dialog "Ordinamento e Visibilità Colonne" mette la colonna specificata prima della colonna precedente
+  *
+  * @param {EsTableColumn} columnItem Colonna da spostare
+  */
+    sendUp(columnItem: EsTableColumn): void;
+    /**
+     * All'interno della dialog "Ordinamento e Visibilità Colonne" mette la colonna specificata dopo la colonna successiva
+     *
+     * @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
+     *
+     * @param {EsTableColumn} columnItem Colonna da spostare
+     */
+    columnClicked(item: EsTableColumn): void;
+    /** All'apertura della dialog "Ordinamento e Visibilità Colonne" ricarica le informazioni attuali per permettere la modifica */
+    resetColumnVisSelection(): void;
+    /** Riaggiorna le **OrderDirectives** con le informazioni in  **ColumnsList** */
+    private refreshColumnOrdering;
+    /** Effettua la selezione o meno del check globale (**globalColVisCheck**) di visibilità in base a se tutte le **TMPColumnsList** sono visibili o no */
+    updateGlobalColVisCheck(): void;
+    /**
+     * Funzione che effettua la conferma della visibilità e dell'ordine delle colonne.
+     *
+     * Questa selezione viene inoltre salvata nelle preferenze (**@esfaenza/preferences**), qualora l'Input **SavePreferences** fosse valorizzato
+     *
+     * @returns {boolean} **true** se non ci sono problemi, **false** altrimenti
+     */
+    confirmColumnVisibilitySelection(): boolean;
+    /**
+     * Effettuo l'unpinning di una colonna in maniera programmatica semplicemente eseguendo una per una le operazioni che verrebbero eseguite altrimenti
+     *
+     * @param {string} id Codice della colonna da spinnare
+     */
+    unpinColumn(id: string): void;
+    /** Sul click nella checkbox di selezione globale si scorrono tutte le colonne e si impostano al valore della check globale */
+    globalColVisCheckChanged(): void;
+}

package/lib/core/handlers/classes/DynamicModeHandler.d.ts

@@ -0,0 +1,32 @@
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { GenericItem } from "../../../domain";
+/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
+export declare class DynamicModeHandler {
+    private est;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent);
+    /**
+     * Metodo di supporto alla creazione di un router link parametrizzato all'oggetto corrente utilizzato nella modalità dinamica
+     *
+     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
+     * @param {string[]} parameterProps Lista posizionale delle proprietà a cui bindare i riferimenti del parametro **path**
+     * Es. Il valore dela proprietà all'indice 0 di questo array verrà sostituita al valore {0} del parametro **path**
+     * @param {GenericItem} item Oggetto generico collegato a questo contesto
+     *
+     * @returns {any} Router link generato in base al parametri
+     */
+    generateRouterLink(path: string, parameterProps: string[], item: GenericItem): any;
+    /**
+     * Crea un router link
+     *
+     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
+     * @param {string[]} pars Lista posizionale delle proprietà a cui bindare i riferimenti del parametro **path**
+     * Es. Il valore dela proprietà all'indice 0 di questo array verrà sostituita al valore {0} del parametro **path**
+     * @param {GenericItem} item Oggetto generico collegato a questo contesto
+     *
+     * @returns {any} Router link generato in base al parametri
+     */
+    private getRouterLink;
+    /** Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna */
+    eventuallyReviewDynamicColumns(): void;
+}

package/lib/core/handlers/classes/ExportHandler.d.ts

@@ -0,0 +1,22 @@
+import { ExportService, MessageService } from "@esfaenza/extensions";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+/** Classe contenente la gestione delle importazioni */
+export declare class ExportHandler {
+    private est;
+    private expExts;
+    private msgExts;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent, expExts: ExportService, msgExts: MessageService);
+    /**
+     * Effettua l'esportazione dei dati
+     *
+     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
+     */
+    tryExport(format?: string): void;
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    private setupExport;
+}

package/lib/core/handlers/classes/HierarchyModeHandler.d.ts

@@ -0,0 +1,40 @@
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+/** Classe contenente la gestione della modalità gerarchica */
+export declare class HierarchyModeHandler {
+    private est;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent);
+    /**
+     * Data una lista di oggetti assegno il livello gerarchico rispetto alla lista di oggetti passata
+     *
+     * @param {any[]} objs Lista di oggetti a cui aggiungere l'informazione del livello gerarchico
+     */
+    assignHierarchyLevels(objs: any[]): void;
+    /**
+     * Per ognuno degli oggetti passati gli assegna un livello di gerarchia in base a **ParentKey** e **OwnKey**
+     *
+     * @param {any[]} objs Oggetti a cui assegnare il livello di gerarchia
+     * @param {number} levelToAssign Livello che sta assegnando attualmente questa iterazione (dato che è ricorsiva)
+     *
+     * @returns {number} Numero di oggetti a cui è stato assegnato un livello gerarchico
+     */
+    private assignLevel;
+    /**
+     * Funzione che permette di effettuare l'espansione di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da espandere
+     */
+    expandParent(key: string): void;
+    /**
+     * Funzione che permette di effettuare il collapse di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da collassare
+     */
+    collapseParent(key: string): void;
+    /**
+     * Collassa ricorsivamente tutti i figli di un parent identificato dalla **parentKey**
+     *
+     * @param {string} parentKey Chiave del parent di cui collassare i figli
+     */
+    private collapseChildOfParent;
+}

package/lib/core/handlers/classes/ItemsHandler.d.ts

@@ -0,0 +1,41 @@
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { UtilitiesHandler } from "./UtilitiesHandler";
+/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */
+export declare class ItemsHandler {
+    private est;
+    private utilities;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler);
+    /**
+     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia
+     *
+     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati
+     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno
+     * @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
+     */
+    getItemsByMode(onlyselected?: boolean, refreshPaging?: boolean, allIfPossible?: boolean): any[];
+    /**
+     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.
+     *
+     * Vale solo per la modalità Array
+     *
+     * @param {number} pageSize Dimensione della pagina
+     */
+    refreshPaging(pageSize: number): void;
+    /**
+     * Ottiene gli oggetti in base alla sorgente
+     */
+    private getViewItemsBySource;
+    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */
+    private adaptViewToPaging;
+    /**
+     * Metodo che prende tutti gli oggetti di cui dispone divisi in bucket da 100 elementi
+     *
+     * @returns {any[][]} Matrice di array Nx100
+     */
+    getItemSlices(): any[][];
+    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
+    arrayModeReviewOrderings(): void;
+}

package/lib/core/handlers/classes/ReportModeHandler.d.ts

@@ -0,0 +1,21 @@
+import { UtilitiesHandler } from "./UtilitiesHandler";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { ReportColumn } from "../../../domain";
+/** Classe che gestisce la modalità Report dell'es-table utilizzata nel Metering */
+export declare class ReportModeHandler {
+    private est;
+    private utilities;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler);
+    /**
+     * Sul click dell'Header di una colonna questo metodo si occupa di applicare l'ordinamento successivo e di notificare con **emitSearchRequest**
+     * il bisogno di aggiornare i dati da parte del componente che utilizza la tabella
+     *
+     * Utilizzato solo in modalità REport
+     *
+     * @param {ReportColumn} clm Colonna del report per cui ordinare
+     */
+    setupNextOrderAndSearch(clm: ReportColumn): void;
+    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
+    reviewReportBindings(): void;
+}

package/lib/core/handlers/classes/RowGroupingHandler.d.ts

@@ -0,0 +1,114 @@
+import { DateService } from "@esfaenza/extensions";
+import { EsTh } from "../../../components/es-th/es_th.component";
+import { EsThDirective } from "../../../directives/es_th.directive";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { AppOrdering, AppSearch, Group, GroupOrAggregation, GroupPager, GroupRouteFragment } from "../../../domain";
+import { UtilitiesHandler } from "./UtilitiesHandler";
+/** Classe che gestisce la modalità Row Grouping dell'es-table */
+export declare class RowGroupingHandler {
+    private est;
+    private utilities;
+    private dateExts;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
+    rgGroupCache: Map<string, Group>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgItemCache: Map<string, any[]>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgChildGroupsCache: Map<string, Group[]>;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler, dateExts: DateService);
+    /**
+     * 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
+     */
+    handleNewDataOnRowGrouping(view: AppSearch<any>, groupingKeys: number): void;
+    /**
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
+     *
+     * @param {ths: EsTh[] | EsThDirective[]} ths Header
+     */
+    arrayModeReviewGroupings(ths: EsTh[] | EsThDirective[]): void;
+    /**
+     * 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
+     */
+    getGroupAggregations(th: EsThDirective): GroupOrAggregation[];
+    /**
+    * 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;
+    /**
+     * 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
+     */
+    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
+     */
+    private generateAggregations;
+    /**
+    * 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
+    */
+    getGroupSeparator(view: AppSearch<any>, parent: string, route: GroupRouteFragment[], level: number, searches: 'groups' | 'items'): GroupPager;
+    /**
+     * 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
+     */
+    emitRowGroupingSearches(column: string, orderings: AppOrdering[]): void;
+    /**
+     * 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**
+     */
+    getGroupCellDisplay(grp: Group, cell: string, header: EsThDirective): string;
+    /**
+     * 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;
+}

package/lib/core/handlers/classes/SelectionHandler.d.ts

@@ -0,0 +1,149 @@
+import { ItemsSelection } from "../../../domain";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { RowGroupingHandler } from "../";
+/** Classe che gestisce le selezioni degli oggetti */
+export declare class SelectionHandler {
+    private est;
+    private rgHandler;
+    /** 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;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, rgHandler: RowGroupingHandler);
+    /** Ripulisce le cache di selezione */
+    clearSelectionCaches(): void;
+    /**
+     * 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
+     */
+    evaluateSelection(items: any[], selectionItem: ItemsSelection<any>): void;
+    /**
+     * 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;
+    /**
+     * Helper per gestire la selezione di N elementi utilizzando la Cache di selezione ed eventualmente aggiornando il concetto di "all selection"
+     *
+     * Vunziona sia in modalità Array che in modalità View Semplice o View Avanzata (con le Custom Cells)
+     *
+     * @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
+     */
+    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, cioè l'array degli oggetti che si vuole manipolare e le due cache collegate ad esso
+     *
+     * @param {'group' | 'item' | 'group_exclusion' | 'exclusion'} subject Oggetto logico desiderato su cui effettuare le operazioni successive
+     * @param {ItemsSelection<any>} base Selettore di base
+     *
+     * @returns {CacheTriptic} Trittico di selezione
+     */
+    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;
+    /**
+     * Valuta la quantità di oggetti che sono stati selezionati al termine di un evento di selezione
+     *
+     * @returns {number} Numero di oggetti selezionati
+     */
+    private evaluateSelected;
+    /** Gestisce il comando di "Seleziona tutto in tutte le pagine" o il suo contrario, cioè "Reimposta selezione" */
+    selectAllOrResetSelection(): void;
+}