@esfaenza/es-table 16.2.29 → 17.3.0

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

@@ -1,189 +1,189 @@
-import { CdkDrag, CdkDragDrop } from "@angular/cdk/drag-drop";
-import { UtilityService } from "@esfaenza/extensions";
-import { PreferencesService } from "@esfaenza/preferences";
-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 } from "./UtilitiesHandler";
-import { RowGroupingHandler } from "./RowGroupingHandler";
-import { AppSearch } from "../../domain/externals/appsearch/AppSearch";
-import { EsTableColumn } from "../../domain/internals/EsTableColumn";
-/** 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;
-    /**
-     * Registra le preference relative alla view passata come parametro
-     *
-     * @param {any} castedView View di cui salvare colonne e ordinamento colonne
-     */
-    registerViewPreferences(castedView: AppSearch<any>): boolean;
-    /**
-     * Partendo dagli **EsThs** estrappolo la lista di **EsTableColumn** che questa tabella dovrà eventualmente gestire per Visibilità e Ordine
-     *
-     * Costo: 1 scan EsThs
-     *
-     * @param {EsThDirective[]} ths Colonne della tabella
-     */
-    reviewColumnsList(ths: EsThDirective[]): void;
-    /** In caso siano configurati dei th "Multi" (vedere la descrizione del campo **thMulti** di **EsThDirective**) questo metodo li "srotola" in tutti i th/td che devono effettivamente diventare */
-    expandMultiThsAndTds(ths: EsThDirective[], tds: EsTdDirective[], items: any[]): {
-        expThs: EsThDirective[];
-        expTds: EsTdDirective[];
-    };
-    /**
-     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
-     */
-    moveFixedColumnsAtTheBeginning(ths: EsThDirective[], tds: 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
-     * @param {boolean} useLocalVisibility Indica di utilizzare le impostazioni di visibilità locali senza allinearle alla view
-     */
-    alignColumnsIfLoadedView(view: AppSearch<any>): void;
-    /**
-     * In base alla visibilità registrata nelle **ColumnsList** questo metodo si occupa di prendere tutti i **EsThDirective** ed **EsTdDirective** relativi e nasonderli/mostrarli
-     *
-     * Costo: 1 scan ColumnsList, 1 scan EsThDirectives, 1 scan EsTdDirectives
-     *
-     * @param {EsThDirective[]} ths Header della tabella
-     * @param {EsTdDirective[]} tds Celle della tabella
-     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
-     */
-    refreshColumnsVisibility(ths: EsThDirective[], tds: 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 {EsThDirective[]} ths Colonne della tabella
-     */
-    alignHeadersOrdering(ths: EsThDirective[], view: AppSearch<any>): void;
-    /**
-     * Genera tutte le informazioni che servono per gestire il raggruppamento degli header
-     *
-     * @param {EsThDirective[]} ths Colonne della tabella
-     *
-     * @returns {{ leafs: 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: EsThDirective[]): {
-        leafs: 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: EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} infos Informazioni di raggruppamento valutate precedentemente
-     */
-    evaluateHeaderGroups(infos: {
-        leafs: EsThDirective[];
-        groupingLevel: number;
-        parentsCache: any;
-        thsCache: {
-            [index: string]: EsThDirective;
-        };
-    }): 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: 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;
-    /**
-     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
-     *
-     * @param {CdkDragDrop<EsTableColumn[]>} event Evento di drop della lista
-     */
-    columnReordered(event: CdkDragDrop<EsTableColumn[]>): void;
-    /**
-     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
-     *
-     * @param {number} index Indice in cui voglio droppare l'elemento draggato
-     * @param {CdkDrag<EsTableColumn>} item Oggetto che sto draggando
-     *
-     * @returns {boolean} **true** se la colonna può essere spostata sull'indice **index**, **false** altrimenti
-     */
-    sortPredicate(index: number, item: CdkDrag<EsTableColumn>): boolean;
-    /**
-     * 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;
-}
+import { CdkDrag, CdkDragDrop } from "@angular/cdk/drag-drop";
+import { UtilityService } from "@esfaenza/extensions";
+import { PreferencesService } from "@esfaenza/preferences";
+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 } from "./UtilitiesHandler";
+import { RowGroupingHandler } from "./RowGroupingHandler";
+import { AppSearch } from "../../domain/externals/appsearch/AppSearch";
+import { EsTableColumn } from "../../domain/internals/EsTableColumn";
+/** 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;
+    /**
+     * Registra le preference relative alla view passata come parametro
+     *
+     * @param {any} castedView View di cui salvare colonne e ordinamento colonne
+     */
+    registerViewPreferences(castedView: AppSearch<any>): boolean;
+    /**
+     * Partendo dagli **EsThs** estrappolo la lista di **EsTableColumn** che questa tabella dovrà eventualmente gestire per Visibilità e Ordine
+     *
+     * Costo: 1 scan EsThs
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     */
+    reviewColumnsList(ths: EsThDirective[]): void;
+    /** In caso siano configurati dei th "Multi" (vedere la descrizione del campo **thMulti** di **EsThDirective**) questo metodo li "srotola" in tutti i th/td che devono effettivamente diventare */
+    expandMultiThsAndTds(ths: EsThDirective[], tds: EsTdDirective[], items: any[]): {
+        expThs: EsThDirective[];
+        expTds: EsTdDirective[];
+    };
+    /**
+     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
+     */
+    moveFixedColumnsAtTheBeginning(ths: EsThDirective[], tds: 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
+     * @param {boolean} useLocalVisibility Indica di utilizzare le impostazioni di visibilità locali senza allinearle alla view
+     */
+    alignColumnsIfLoadedView(view: AppSearch<any>): void;
+    /**
+     * In base alla visibilità registrata nelle **ColumnsList** questo metodo si occupa di prendere tutti i **EsThDirective** ed **EsTdDirective** relativi e nasonderli/mostrarli
+     *
+     * Costo: 1 scan ColumnsList, 1 scan EsThDirectives, 1 scan EsTdDirectives
+     *
+     * @param {EsThDirective[]} ths Header della tabella
+     * @param {EsTdDirective[]} tds Celle della tabella
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    refreshColumnsVisibility(ths: EsThDirective[], tds: 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 {EsThDirective[]} ths Colonne della tabella
+     */
+    alignHeadersOrdering(ths: EsThDirective[], view: AppSearch<any>): void;
+    /**
+     * Genera tutte le informazioni che servono per gestire il raggruppamento degli header
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     *
+     * @returns {{ leafs: 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: EsThDirective[]): {
+        leafs: 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: EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} infos Informazioni di raggruppamento valutate precedentemente
+     */
+    evaluateHeaderGroups(infos: {
+        leafs: EsThDirective[];
+        groupingLevel: number;
+        parentsCache: any;
+        thsCache: {
+            [index: string]: EsThDirective;
+        };
+    }): 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: 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;
+    /**
+     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
+     *
+     * @param {CdkDragDrop<EsTableColumn[]>} event Evento di drop della lista
+     */
+    columnReordered(event: CdkDragDrop<EsTableColumn[]>): void;
+    /**
+     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
+     *
+     * @param {number} index Indice in cui voglio droppare l'elemento draggato
+     * @param {CdkDrag<EsTableColumn>} item Oggetto che sto draggando
+     *
+     * @returns {boolean} **true** se la colonna può essere spostata sull'indice **index**, **false** altrimenti
+     */
+    sortPredicate(index: number, item: CdkDrag<EsTableColumn>): boolean;
+    /**
+     * 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/DynamicModeHandler.d.ts

@@ -1,22 +1,22 @@
-import { EsTableComponent } from "../../components/es-table/es_table.component";
-import { EsTdDirective } from "../../directives/es_td.directive";
-import { EsThDirective } from "../../directives/es_th.directive";
-/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
-export declare class DynamicModeHandler {
-    private est;
-    /** @ignore Costruttore*/
-    constructor(est: EsTableComponent);
-    /** Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna */
-    eventuallyReviewDynamicColumns(): void;
-    /** Genera partendo dalle **DynamicRowColumnsDefinition** la lista di **EsThDirective** e **EsTdDirective** che servono per la tabella */
-    emitThsAndTdsBasedOnDynamicDefinition(): {
-        ths: EsThDirective[];
-        tds: EsTdDirective[];
-    };
-    /** @ignore Helper */
-    private getThFromOperation;
-    private getTdFromOperation;
-    private getThFromColumnDef;
-    /** @ignore Helper */
-    private getTdFromColumnDef;
-}
+import { EsTableComponent } from "../../components/es-table/es_table.component";
+import { EsTdDirective } from "../../directives/es_td.directive";
+import { EsThDirective } from "../../directives/es_th.directive";
+/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
+export declare class DynamicModeHandler {
+    private est;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent);
+    /** Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna */
+    eventuallyReviewDynamicColumns(): void;
+    /** Genera partendo dalle **DynamicRowColumnsDefinition** la lista di **EsThDirective** e **EsTdDirective** che servono per la tabella */
+    emitThsAndTdsBasedOnDynamicDefinition(): {
+        ths: EsThDirective[];
+        tds: EsTdDirective[];
+    };
+    /** @ignore Helper */
+    private getThFromOperation;
+    private getTdFromOperation;
+    private getThFromColumnDef;
+    /** @ignore Helper */
+    private getTdFromColumnDef;
+}

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

@@ -1,18 +1,18 @@
-import { DateService, ExportService, MessageService, UtilityService } 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;
-    private utiExts;
-    private dateExts;
-    /** @ignore Costruttore*/
-    constructor(est: EsTableComponent, expExts: ExportService, msgExts: MessageService, utiExts: UtilityService, dateExts: DateService);
-    /**
-     * Effettua l'esportazione dei dati
-     *
-     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
-     */
-    tryExport(format?: 'CSV' | 'XLSX'): void;
-}
+import { DateService, ExportService, MessageService, UtilityService } 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;
+    private utiExts;
+    private dateExts;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent, expExts: ExportService, msgExts: MessageService, utiExts: UtilityService, dateExts: DateService);
+    /**
+     * Effettua l'esportazione dei dati
+     *
+     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
+     */
+    tryExport(format?: 'CSV' | 'XLSX'): void;
+}

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

@@ -1,40 +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;
-}
+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/ItemsHandler.d.ts

@@ -1,35 +1,35 @@
-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;
-    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
-    arrayModeReviewOrderings(items: any[]): any[];
-}
+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;
+    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
+    arrayModeReviewOrderings(items: any[]): any[];
+}