@esfaenza/es-table 11.2.22-beta3 → 11.2.22-beta7

package/lib/{es_table.component.d.ts → components/es-table/es_table.component.d.ts}

@@ -1,16 +1,17 @@
 import { QueryList, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, TemplateRef } from '@angular/core';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
-import { HashingService, UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
+import { UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
 import { LocalizationService } from '@esfaenza/localizations';
 import { PreferencesService } from '@esfaenza/preferences';
 import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
-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/externals/classes/appsearch/ItemsSelection';
-import { Group } from "./domain/externals/classes/appsearch/Group";
-import { EsTableDefaultable } from './models/EsTableDefaultable';
+import { AppSearch, AppOrdering, EsTableColumnsDefinition, CornerMenuOption, ReportResult, EsTableOperationDefinition, EsTableColumn, GroupPager, GroupRouteFragment } from '../../domain';
+import { EsTd } from '../es-td/es_td.component';
+import { EsTdDirective } from '../../directives/es_td.directive';
+import { EsThDirective } from '../../directives/es_th.directive';
+import { ItemsSelection } from '../../domain/externals/classes/appsearch/ItemsSelection';
+import { Group } from "../../domain/externals/classes/appsearch/Group";
+import { EsTableDefaultable } from '../../domain/configuration/EsTableDefaultable';
+import { ExportHandler, ColumnMetadataHandler, DynamicModeHandler, HierarchyModeHandler, ItemsHandler, ReportModeHandler, RowGroupingHandler, SelectionHandler, UtilitiesHandler } from '../../core/handlers';
 /** Componente che permette di rappresentare una griglia di valori */
 export declare class EsTableComponent implements ControlValueAccessor, OnChanges {
     ngControl: NgControl;
@@ -18,14 +19,22 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     private deafults;
     locale: string;
     lc: LocalizationService;
-    private cdr;
-    private hashExts;
+    cdr: ChangeDetectorRef;
+    private utilities_H;
     private utiExts;
     private expExts;
     private dateExts;
     private msgExts;
+    export_H: ExportHandler;
+    columnMetadata_H: ColumnMetadataHandler;
+    dynamicMode_H: DynamicModeHandler;
+    hierarchyMode_H: HierarchyModeHandler;
+    items_H: ItemsHandler;
+    reportMode_H: ReportModeHandler;
+    rowGrouping_H: RowGroupingHandler;
+    selection_H: SelectionHandler;
     /** @ignore */
-    constructor(ngControl: NgControl, prefService: PreferencesService, deafults: EsTableDefaultable, locale: string, 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, utilities_H: UtilitiesHandler, 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 */
@@ -396,7 +405,12 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * - Selezione: non cambia nulla
      * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne
      */
-    private groupSearchRequestsCache;
+    groupSearchRequestsCache: {
+        path: string;
+        route: GroupRouteFragment[];
+        view: AppSearch<any>;
+        group_column: string;
+    }[];
     /** 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 */
@@ -408,35 +422,14 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     /** 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;
+    BaseItemsCount: any;
     /** 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;
+    /** Opzioni di paginazione */
     PagerOptions: {
         PagerCount: number;
         ShowCount: boolean;
@@ -450,14 +443,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     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 */
@@ -479,44 +464,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
     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
-     *
-     * @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
-     *
-     * @todo: ITEMS
-     */
-    private getItemsByMode;
-    /**
-     * @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;
     /**
      * Metodo che gestisce l'endless scroll e in base a quanto la tabella è stata scrollata aggiunge degli elementi extra a **TMPBoundSource**
      *
@@ -532,72 +479,12 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * 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
      */
@@ -607,41 +494,8 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      *
      * @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
-     */
-    private eventuallyReviewDynamicColumns;
-    /**
-     * 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
-     */
-    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
-     *
-     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
-     */
-    private alignColumnsIfLoadedView;
     /**
      * Metodo che gestisce il cambio di Ordinamento di una colonna
      *
@@ -655,24 +509,7 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @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;
-    /**
-     * 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
-     */
-    private refreshColumnsVisibility;
-    /**
-     * 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
-     */
-    private alignHeadersOrdering;
+    emitSearchRequest(resetsPage: boolean, viewOverride?: AppSearch<any>): void;
     /**
      * Partendo dagli **EsTds** bindati genera, all'interno del dizionario **TMPRowTDs** tutti i contesti dei vari oggetti.
      *
@@ -694,60 +531,6 @@ 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
-     *
-     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
-     */
-    private generateDefaultOrder;
-    /**
-     * 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
-     */
-    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)
      *
@@ -762,30 +545,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @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
@@ -795,224 +554,12 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @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
-     *
-     * @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;
-    /**
-     * Sul click nella checkbox di selezione globale si scorrono tutte le colonne e si impostano al valore della check globale
-     */
-    globalColVisCheckChanged(): void;
-    /**
-     * 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
-     */
-    private assignHierarchyLevels;
-    /**
-     * 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;
-    /**
-     * 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**
      *
      * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
      */
     globalCheckChanged(forcedVal?: boolean): void;
-    /**
-     * 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: 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
      *
@@ -1022,16 +569,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
      */
     handleClick(event: any, item: any): boolean;
-    /**
-     * 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;
     /**
      * Sposta la ricerca di una pagina in avanti (o indeitro)
      *
@@ -1053,31 +590,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * 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
-     *
-     * @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;
-    /**
-     * 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
-     */
-    private reviewReportBindings;
     /**
      * Metodo che gestisce la modifica del tempo specificato per l'aggiornamento automatico
      */
@@ -1097,28 +609,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @returns {TemplateRef<any>} Template da usare per la colonna
      */
     findEsTd(column: string): TemplateRef<any>;
-    /**
-     * 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;
     /**
      * Equivalente del metodo **addToPage** riadattato per la modalità array
      *
@@ -1131,18 +621,6 @@ export declare class EsTableComponent implements ControlValueAccessor, OnChanges
      * @param {number} page Pagina a cui navigare
      */
     arrayGoToPage(page: number): void;
-    /**
-     * 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;
-    /**
-     * Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata
-     */
-    private adaptViewToPaging;
     /**
      * Gestore dei click sulle celle per le quali era impostata una azione custom da **CustomCellActionsOn**
      *
@@ -1158,33 +636,17 @@ 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 */
+    /**
+     * Impostazione modalità dell'EsTable
+     *
+     * @param {'array' | 'view' | 'report'} mode Modalità da impostare
+     **/
     private setMode;
     /**
      * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
      * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
      */
-    private internalWriteValue;
-    /**
-     * Date le informazioni di paginazione ottiene l'array dei pulsanti
-     *
-     * @param {number} maxBtns Numero massimo di pulsanti da visualizzare
-     * @param {number} page Pagina corrente
-     * @param {number} lastPage Ultima pagina disponibile
-     *
-     * @returns {any[]} Pseudo-array di pulsanti a cui ci si può bindare lato HTML
-     */
-    private getPagesArray;
-    /**
-     * Calcola l'hash di un oggetto qualsiasi
-     *
-     * @param {any[]} items Oggetti per cui calcolare l'hash
-     */
-    private calculateHash;
+    internalWriteValue(): void;
     /**
      * Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella
      */