@esfaenza/es-table 12.2.17 → 12.2.21

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

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

package/lib/{es_td.component.d.ts → components/es-td/es_td.component.d.ts}

@@ -1,52 +1,30 @@
 import { Renderer2, ElementRef, ViewContainerRef } from "@angular/core";
 import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
-/**
- * Componente rappresentante una singola cella del body della tabella
- */
+/** Componente rappresentante una singola cella del body della tabella */
 export declare class EsTd {
     private myself;
     private renderer;
     private _viewContainer;
     protected sanitizer: DomSanitizer;
-    /**
-     * Id della cella, dev'essere lo stesso della colonna **EsTh** relativa
-     */
+    /** Id della cella, dev'essere lo stesso della colonna **EsTh** relativa */
     ID: string;
-    /**
-     * Indica se è una cella interna (rigenerata programmaticamente) o no
-     */
+    /** Indica se è una cella interna (rigenerata programmaticamente) o no */
     Internal?: boolean;
-    /**
-     * RouterLink qualora il click su questa cella debba navigare da qualche parte
-     */
+    /** RouterLink qualora il click su questa cella debba navigare da qualche parte */
     RouterLink?: any;
-    /**
-     * Valore da mostrare all'interno della cella. Se omesso verrà proiettato il contenuto dal template in cui è stata usata
-     */
+    /** Valore da mostrare all'interno della cella. Se omesso verrà proiettato il contenuto dal template in cui è stata usata */
     Display?: string;
-    /**
-     * Template Angular da istanziare per questo TD
-     */
+    /** Template Angular da istanziare per questo TD */
     Template?: any;
-    /**
-     * Classi da applicare alla cella
-     */
+    /** Classi da applicare alla cella */
     Class?: string;
-    /**
-     * Contenuto da mostrare proiettato dal componente padre
-     */
+    /** Contenuto da mostrare proiettato dal componente padre */
     Content?: SafeHtml;
-    /**
-     * Contesto dell'oggetto a cui si riferisce il dato visualizzato. Contiene l'hash dell'oggetto in questione
-     */
+    /** Contesto dell'oggetto a cui si riferisce il dato visualizzato. Contiene l'hash dell'oggetto in questione */
     Context: string;
-    /**
-     * Indicazioni sulla visibilità della cella
-     */
+    /** Indicazioni sulla visibilità della cella */
     private _Visible?;
-    /**
-     * @ignore
-     */
+    /** @ignore */
     constructor(myself: ElementRef, renderer: Renderer2, _viewContainer: ViewContainerRef, sanitizer: DomSanitizer);
     /**
      * Imposta la visibilità o meno della cella, si traduce nell'applicazione o rimozione della classe **app-display-none**
@@ -60,8 +38,8 @@ export declare class EsTd {
      * @returns {boolean} **true** se visibile, **false** altrimenti
      */
     get Visible(): boolean;
-    /**
-     * @ignore
-     */
+    /** @ignore */
     ngAfterViewInit(): void;
+    /** Ottiene il contesto della view su cui è istanziato il componente */
+    private getTemplateContext;
 }

package/lib/components/es-th/es_th.component.d.ts

@@ -0,0 +1,89 @@
+import { EventEmitter, ElementRef, Renderer2 } from "@angular/core";
+/** Componente rappresentante una Colonna della tabella */
+export declare class EsTh {
+    private myself;
+    private renderer;
+    /** Dizionario di mappatura con ordinamento attuale e ordinamento successivo per gestire i passaggi di stato */
+    private orderNext;
+    /** Indicazione sulla visibilità della colonna */
+    private _Visible;
+    /** Indica se si sta effettuando un'operazione di resize su questa colonna */
+    private resizingThis;
+    /**
+     * Storicizza l'offset di partenza del resize dell'elemento HTML per poter calcolare la nuova dimensione richiesta durente il resize
+     *
+     * nuova width = startOffset + posizione X del mouse
+     */
+    private startOffset;
+    /** Id della colonna, dev'essere lo stesso per tutti gli **EsTd** relativi */
+    ID: string;
+    /** Ordinamento attuale della colonna */
+    Order?: 'DESC' | 'ASC';
+    /** Indica se questa colonna è ordinabile o meno */
+    Orderable: boolean;
+    /** Valore da mostrare all'interno della colonna. Se omesso verrà proiettato il contenuto dal template in cui è stata usata */
+    Display: string;
+    /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
+    Resizable: boolean;
+    /** Indica se questo header è pinnato. In caso lo fosse presenta il tastino per effettuare lo spinning */
+    Pinned: boolean;
+    /**
+     * Indica se sta venendo eseguita una operazione di ricerca o meno, serve per evitare l'esecuzione di eventuale codice che potrebbe dare fastidio
+     * come ad esempio l'escuzione di un ordinamento durante il caricamento di dati nuovi
+     */
+    SearchInProgress: boolean;
+    /** Impostato dall'**EsTable**, serve per permettere o meno di effettuare ordinamenti dati su questa colonna */
+    OrderBy: boolean;
+    /** Indica se il testo presente in questo Header può andare a capo o meno, di default non può */
+    Wrap: boolean;
+    /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
+    Fixed: boolean;
+    /** Template Angular da istanziare per questo TH */
+    Template?: any;
+    /** Evento emesso al cambio di ordinamento effettuato su questa colonna */
+    onOrderChange: EventEmitter<'DESC' | 'ASC' | null>;
+    /** Evento emesso all'unpinning della colonna */
+    onUnpinning: EventEmitter<string>;
+    /** Proiezione del contenuto di questa colonna */
+    content: ElementRef;
+    /** Classi da applicare alla colonna */
+    Class: string;
+    /** Impostato dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+    _referenced: boolean;
+    /** Variabile finale su cui è bindato il contenuto della cella. Sarà valorizzato a **Display** se specificato, all'**innerHTML** dell'elemento proiettato altrimenti */
+    Description: string;
+    /** @ignore */
+    constructor(myself: ElementRef, renderer: Renderer2);
+    /**
+     * Imposta la visibilità o meno della colonna, si traduce nell'applicazione o rimozione della classe **app-display-none**
+     *
+     * @param {boolean} expression Indicazione della visibilità
+     */
+    set Visible(expression: boolean);
+    /**
+     * Restituisce lo stato di Visibilità della colonna in oggetto
+     *
+     * @returns {boolean} **true** se visibile, **false** altrimenti
+     */
+    get Visible(): boolean;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** Emette l'evento di unpinning */
+    unpin(): void;
+    /** Gestisce la modifica dell'ordinamento qualora venisse cliccato su questa colonna */
+    setupNextOrderAndNotify(): void;
+    /**
+     * Evento di inizio resize della colonna
+     *
+     * @param {any} ev Evento MouseDown
+     */
+    onResizeStart(ev: any): void;
+    /** Listener per la fine dell'operazione di resize */
+    onMouseUp(): void;
+    /**
+     * Listener per gestire il movimento del mouse qualora un'operazione di resize fosse in esecuzione
+     *
+     * @param {$event} ev Evento MouseMove
+     */
+    onMouseMove($event: any): void;
+}

package/lib/components/pager/table_pager.component.d.ts

@@ -0,0 +1,54 @@
+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 */
+export declare class TablePagerComponent {
+    private msgExts;
+    lc: LocalizationService;
+    cdr: ChangeDetectorRef;
+    locale: string;
+    /** Dimensione di pagina attuale */
+    CurrentPageSize: any;
+    /** View gestita, che può essere un IAppSearch o una ReportView */
+    View: any;
+    /** Indica se deve mostrare un warning quando si cercano di solezionare come elementi da visualizzare "Tutti" */
+    WarnOnAll: boolean;
+    /** Indica se dare la possibilità o meno di selezionare "Tutti" nelle opzioni di paginazione */
+    AllSearch: boolean;
+    /** Placeholder che identifica il "Tutti" */
+    DefaultAll: number;
+    /** Indica se attivare la modalità gruppo con stili più snelli per apparire sotto ai raggruppamenti */
+    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 */
+    Hidden: boolean;
+    /** Output invocato quando il numero di elementi per pagina viene modificato da un click utente */
+    pagingSelected: EventEmitter<number>;
+    /** @ignore */
+    constructor(msgExts: MessageService, lc: LocalizationService, cdr: ChangeDetectorRef, locale: string);
+    /** Modello su cui la select effettua operazioni di selezione */
+    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.
+     *
+     * Cliccare 2 volte sullo stesso numero causa comunque un refresh dei dati
+     *
+     * @param {number} pageSize Dimensione selezionata lato UI
+     */
+    choice(pageSize: number): void;
+}

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

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

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;
+}