@esfaenza/es-table 12.2.17 → 12.2.21

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

@@ -0,0 +1,114 @@
+import { DateService } from "@esfaenza/extensions";
+import { EsTh } from "../../../components/es-th/es_th.component";
+import { EsThDirective } from "../../../directives/es_th.directive";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { AppOrdering, AppSearch, Group, GroupOrAggregation, GroupPager, GroupRouteFragment } from "../../../domain";
+import { UtilitiesHandler } from "./UtilitiesHandler";
+/** Classe che gestisce la modalità Row Grouping dell'es-table */
+export declare class RowGroupingHandler {
+    private est;
+    private utilities;
+    private dateExts;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
+    rgGroupCache: Map<string, Group>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgItemCache: Map<string, any[]>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgChildGroupsCache: Map<string, Group[]>;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler, dateExts: DateService);
+    /**
+     * In modalità rowgrouping quando mi arriva un nuovo blocco di oggetti devo aggiungerlo alla vista attuale:
+     *
+     * 1) Se non viene richiesto il dettaglio di alcun gruppo significa che devo considerare mi siano arrivati tutti i gruppi principali
+     * 2) Se viene richiesto il dettaglio di un gruppo diverso dall'ultimo devo aggiungere dopo al gruppo cliccato la lista dei sottogruppi
+     * 2) Se viene richiesto il dettaglio dell'ultimo gruppo devo aggiungere dopo al gruppo cliccato la lista degli oggetti
+     *
+     * @param {any} view AppSearch<T> da cui sono arrivati gli oggetti
+     * @param {number} groupingKeys Livelli di raggruppamento da aspettarsi sui dati
+     */
+    handleNewDataOnRowGrouping(view: AppSearch<any>, groupingKeys: number): void;
+    /**
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
+     *
+     * @param {ths: EsTh[] | EsThDirective[]} ths Header
+     */
+    arrayModeReviewGroupings(ths: EsTh[] | EsThDirective[]): void;
+    /**
+     * Data una direttiva EsTh restituisce la lista delle aggregazioni richiesta per questa colonna o il gruppo che rappresenta
+     *
+     * @param {EsThDirective} th Direttiva
+     *
+     * @returns {GroupOrAggregation[]} Lista dei gruppi o aggregazioni relativi alla Direttiva passata
+     */
+    getGroupAggregations(th: EsThDirective): GroupOrAggregation[];
+    /**
+    * Data una direttiva con un formato restituisce tutte le coppie Funzione di Aggregazione - Formato
+    *
+    * @param {EsThDirective} th Direttiva EsTh di cui calcolare le funzioni di aggregazione usate
+    *
+    * @returns {{ func: string, format: string }[]} Lista delle funzioni di aggregazione rilevate
+    */
+    private getEsThDirectiveListOfAggregations;
+    /**
+     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi
+     *
+     * @param {Group[]} grps Definizione dei gruppi
+     * @param {number} currentIndex Indice di elaborazione. Al livello 0 ho tutti gli oggetti e devo generare i primi gruppi, a livello 1 ho tutti i gruppi principali e devo
+     * elaborare i sottogruppi, e così via ricorsivamente...
+     * @param {any[]} items Oggetti da raggruppare
+     * @param {GroupOrAggregation[]} aggregations Info di aggregazione
+     * @param {any} parent Riferimento al gruppo padre
+     */
+    private getGroupsRecursive;
+    /**
+     * Data una lista di oggetti genera le aggregazioni specificate. Si considera di avere tutti gli oggetti
+     *
+     * @param {any[]} items Oggetti di cui calcolare le aggregazione
+     * @param {GroupOrAggregation[]} aggregations Aggergazioni da generare
+     */
+    private generateAggregations;
+    /**
+    * Ottiene un elemento di separazione fra Gruppi che serve per paginare le ricerche all'interno di ogni singolo gruppo
+    *
+    * @param {AppSearch<any>} view View utilizzata per la ricerca. Me ne salvo i parametri nel separatore attuale dato che ne ho bisogno per caricare altri elementi
+    * facenti riferimento allo stesso contesto
+    * @param {string} parent Parent path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {GroupRouteFragment[]} route Route path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {number} level Livello del gruppo di cui questo elemento è separatore, viene usato per applicare la classe "est-lvl-{{level}}"
+    *
+    * @returns {any} Elemento di separazione contenente tutti i bind per presentare una paginazione sotto questo gruppo lato interfaccia
+    */
+    getGroupSeparator(view: AppSearch<any>, parent: string, route: GroupRouteFragment[], level: number, searches: 'groups' | 'items'): GroupPager;
+    /**
+     * Data una colonna effettua la riemissione di tutte le ricerche relative.
+     *
+     * Es. Ho 2 campi di gruppo e ho espanso fino a vedere i valori fino ad un livello qualsiasi.
+     * Clicco l'ordinamento sul secondo gruppo.
+     * Tutte le ricerche relative ai primi gruppi devono essere rieseguite. Quando i risultati arriveranno ci penserà il metodo **bindDisplayToLoadedItemsOrGroups**
+     * a tagliare via gli oggetti non più visualizzati
+     *
+     * @param {string} column Colonna su cui si è effettuata un'operazione di ordinamento
+     * @param {AppOrdering[]} orderings Direttive di ordinamento da applicare alle varie sottoricerche
+     */
+    emitRowGroupingSearches(column: string, orderings: AppOrdering[]): void;
+    /**
+     * Helper che calcola il contenuto di una cella relativa a un gruppo riga, tenendo conto del formato delle eventuali aggregazioni
+     *
+     * @param {Group} grp Gruppo di cui mostrare le celle
+     * @param {string} cell Cella attuale di cui calcolare il testo
+     * @param {EsThDirective} header Header relativo alla cella attuale, utilizzata per identificare le informazioni di aggregazione
+     *
+     * @returns {string} Testo finale calcolato per la **cell** corrente, in base alle aggregazioni di **header**
+     */
+    getGroupCellDisplay(grp: Group, cell: string, header: EsThDirective): string;
+    /**
+     * Funzione che dato un valore lo formatta in base al tipo
+     *
+     * @param {string} value Valore che generalemnte può essere una data o un numero
+     * @param {string} fromat Formato su cui formattare il valore. Può essere ad esempio "small", "long" "verylong" per le date o F{0-9} per i numeri decimali
+     *
+     * @returns {string} Valore dell'aggregazione formattato come si deve
+     */
+    private formatAggregationValue;
+}

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

@@ -0,0 +1,149 @@
+import { ItemsSelection } from "../../../domain";
+import { EsTableComponent } from "../../../components/es-table/es_table.component";
+import { RowGroupingHandler } from "../";
+/** Classe che gestisce le selezioni degli oggetti */
+export declare class SelectionHandler {
+    private est;
+    private rgHandler;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via hash*/
+    private itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private group_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via indice*/
+    private i_itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_group_exclusionsCache;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, rgHandler: RowGroupingHandler);
+    /** Ripulisce le cache di selezione */
+    clearSelectionCaches(): void;
+    /**
+     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **selection** interno all'AppSearch
+     *
+     * @param {any[]} items Oggetti di cui valutare la selezione
+     * @param {ItemsSelection<any>} selectionItem Oggetti di selezione derivante dalla view o dall'oggetto per Array
+     */
+    evaluateSelection(items: any[], selectionItem: ItemsSelection<any>): void;
+    /**
+     * Implementazione agnostica della valutazione delle selezioni degli oggetti. Richiede gli oggetti della vista attuale e l'itemSelector
+     *
+     * @param {any[]} items Oggetti di cui aggiornare lo stato di selezione
+     * @param {ItemsSelection<any>} selectionItem Oggetto contenente lo stato attuale di selezione
+     */
+    private handleSelectionEvaluation;
+    /**
+     * Dato un oggetto trova la cella di cache in cui è registrato e aggiorna il contenuto
+     *
+     * @param {any} item Oggetto da aggiornare
+     */
+    private rehidrateCache;
+    /**
+     * Dato un gruppo controlla ricorsivamente l'albero di cui fa parte se c'è stata una inclusione o esclusione diretta
+     *
+     * @param {any} grp Gruppo da controllare
+     *
+     * @returns {'none' | 'excluded' | 'included'}
+     * 'none' se non ci sono informazioni su inclusioni o esclusioni
+     * 'included' se il gruppo controllato è stato incluso in maniera esplicita dall'albero dei gruppi padri
+     * 'excluded' se il gruppo controllato è stato escluso in maniera esplicita dall'albero dei gruppi padri
+     */
+    private parentTreeStatus;
+    /**
+     * Helper per gestire la selezione di N elementi utilizzando la Cache di selezione ed eventualmente aggiornando il concetto di "all selection"
+     *
+     * Vunziona sia in modalità Array che in modalità View Semplice o View Avanzata (con le Custom Cells)
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     * @param {boolean} globalCheck Valore del check globale
+     *
+     * @returns {ItemsSelection<any>} Oggetto di selezione aggiornato con le informazioni sull'ultima operazione effettuata
+     */
+    handleItemsSelection(items: any[], forcedVal?: boolean, globalCheck?: boolean): ItemsSelection<any>;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * Logica semplificata rispetto all'originale **performSelectionOperations** per lavorare in una modalità in cui tutti gli elementi sono caricati (**ArrayGrouping** = true)
+     */
+    private performSimpleSelectionOperations;
+    /**
+     * Helper per selezionare un gruppo e, ricorsivamente, se tutti i gruppi sottostanti al parent sono selezionati, selezionare i gruppi padri
+     *
+     * @param {any} group Gruppo da selezionare
+     */
+    private selectGroup;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * La logica di questa funzione è nata essenzialmente da spam di trial & error ed è stata testata solo fino a due livelli di raggruppamento,
+     * qualsiasi cosa vada oltre non è 100% detto che funzioni...
+     */
+    private performSelectionOperations;
+    /** Helper per evitare di riscrivere ogni santa volta array.splice(array.indexof(item), 1); */
+    private removeItem;
+    /** Helper per evitare di riscrivere ogni santa volta array.push(item); e la gestione della  */
+    private addItem;
+    /**
+     * Ottiene il trittico di selezione, cioè l'array degli oggetti che si vuole manipolare e le due cache collegate ad esso
+     *
+     * @param {'group' | 'item' | 'group_exclusion' | 'exclusion'} subject Oggetto logico desiderato su cui effettuare le operazioni successive
+     * @param {ItemsSelection<any>} base Selettore di base
+     *
+     * @returns {CacheTriptic} Trittico di selezione
+     */
+    private getTriptic;
+    /**
+     * Dato un oggetto restituisce il gruppo di cui fa parte, se esiste
+     *
+     * @param {any} item Oggetto di cui trovare il gruppo
+     */
+    private getItemGroup;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Chiave da cercare
+     * @param {'selected' | 'unselected'} status Stato degli elementi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo gli elementi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_item** facenti capo alla chiave **groupKey**
+     */
+    private getGroupItems;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Gruppo di cui cercare il parent
+     *
+     * @returns {any} Oggetto di tipo **_group** rappresentante il parent del **group** attuale
+     */
+    private getGroupParent;
+    /**
+     * Data la chiave di un gruppo restituisce tutti i gruppi figli
+     *
+     * @param {string} group Gruppo che rappresenta il padre di cui cercare i figli
+     * @param {'selected' | 'unselected'} status Stato dei gruppi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo i gruppi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_group** facenti capo alla chiave **groupKey**
+     */
+    private getGroupChildGroups;
+    /** Finalizza le informazioni di selezione del **ItemsSelection** corrente */
+    private finalizeSelectionInformations;
+    /** Compatta una cache di indici */
+    private compactIndexMap;
+    /**
+     * Valuta la quantità di oggetti che sono stati selezionati al termine di un evento di selezione
+     *
+     * @returns {number} Numero di oggetti selezionati
+     */
+    private evaluateSelected;
+    /** Gestisce il comando di "Seleziona tutto in tutte le pagine" o il suo contrario, cioè "Reimposta selezione" */
+    selectAllOrResetSelection(): void;
+}

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

@@ -0,0 +1,67 @@
+import { HashingService } from "@esfaenza/extensions";
+import { EsTd } from "../../../components/es-td/es_td.component";
+import { EsTh } from "../../../components/es-th/es_th.component";
+/** Classe di utilità per le cose comuni */
+export declare class UtilitiesHandler {
+    private hashExts;
+    /** @ignore Costruttore */
+    constructor(hashExts: HashingService);
+    /**
+     * 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
+     */
+    groupBy(array: any[], field: string): {
+        [id: string]: any[];
+    };
+    /**
+     * Helper per effettuare il caching delle aggregazioni. Le sposta da una lista di **GroupAggregation** a una **<Map<string, Map<string, string>>**
+     *
+     * @param {any} group Gruppo di cui cachare le aggregazioni
+     */
+    cacheAggregations(group: any): void;
+    /** Helper per spostare un oggetto di un array da un indice all'altro, in place */
+    arrayMove(array: any[], oldI: number, newI: number): void;
+    /**
+     * Helper che identifica se il td attuale è di tipo **EsTd**. In caso contrario è da considerarsi **EsTdDirective**
+     *
+     * @param {any} td Cella da valutare
+     * @returns {boolean} Restituisce **true** se il **td** è di tipo **EsTd**, **false** se è di tipo **EsTdDirective**
+     */
+    isEsTd(td: any): td is EsTd;
+    /**
+     * Helper che identifica se il th attuale è di tipo **EsTh**. In caso contrario è da considerarsi **EsThDirective**
+     *
+     * @param {any} td Header da valutare
+     * @returns {boolean} Restituisce **true** se il **th** è di tipo **EsTh**, **false** se è di tipo **EsThDirective**
+     */
+    isEsTh(th: any): th is EsTh;
+    /**
+     * 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
+     */
+    getPagesArray(maxBtns: number, page: number, lastPage: number, actualCount?: number, ipp?: number): any[];
+    /**
+     * Calcola l'hash di un oggetto qualsiasi
+     *
+     * @param {any[]} items Oggetti per cui calcolare l'hash
+     */
+    calculateHash(items: any[]): 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
+    */
+    InputOrDefault<T>(inputValue: T, defaultValue: T, fallbackValue?: T): T;
+}

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

@@ -0,0 +1,9 @@
+export * from "./classes/ColumnMetadataHandler";
+export * from "./classes/DynamicModeHandler";
+export * from "./classes/ExportHandler";
+export * from "./classes/HierarchyModeHandler";
+export * from "./classes/ItemsHandler";
+export * from "./classes/ReportModeHandler";
+export * from "./classes/RowGroupingHandler";
+export * from "./classes/SelectionHandler";
+export * from "./classes/UtilitiesHandler";

package/lib/directives/es_td.directive.d.ts

@@ -1,6 +1,19 @@
 import { TemplateRef } from '@angular/core';
+/** Direttiva per la dichiarazione snella di un EsTd da emettere per ogni elemento, data una colonna */
 export declare class EsTdDirective {
-    template: TemplateRef<any>;
-    EsTdColumn: string;
-    constructor(template: TemplateRef<any>);
+    Template: TemplateRef<any>;
+    /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsTdComponent */
+    _directive: boolean;
+    /** Indica se la cella è visibile o meno di default */
+    tdVisible: boolean;
+    /** Id della colonna, fa riferimento al **th** padre */
+    td: string;
+    /** Equivalente dell'NgIf sul td */
+    tdIf: boolean;
+    /** Eventuali classi da applicare al **td** generato */
+    tdClass: string;
+    /**
+     * @ignore
+     */
+    constructor(Template: TemplateRef<any>);
 }

package/lib/directives/es_th.directive.d.ts

@@ -0,0 +1,46 @@
+import { TemplateRef } from "@angular/core";
+import { ThAggregation } from "../domain";
+/** Direttiva per la dichiarazione snella di un EsTh da emettere come header */
+export declare class EsThDirective {
+    Template: TemplateRef<any>;
+    /** Variabile interna all'interno della quale viene raccolta la cache delle aggregazioni specificate in thAggregation */
+    _thAggregations: ThAggregation[];
+    /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsThComponent */
+    _directive: boolean;
+    /** Variabile interna impostata dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+    _referenced: boolean;
+    /** Id della colonna, dev'essere lo stesso per tutti i **td** relativi */
+    th: string;
+    /** Indica se la colonna è pinnata o no */
+    thPinned: boolean;
+    /** Indica le dimensioni che deve avere questa colonna quando viene pinnata, senza questo tutte le colonne mi collasserebbero l'una sull'altra */
+    thPinnedWidth: number;
+    /** Indicazione sulla visibilità della colonna */
+    thVisible: boolean;
+    /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
+    thFixed: boolean;
+    /** Indica che la colonna è sotto ad un raggruppamento padre, con questo nome nel **th** */
+    thParent: string;
+    /** Ordinamento attuale della colonna */
+    thOrder?: 'DESC' | 'ASC';
+    /** Indica se questa colonna è ordinabile o meno */
+    thOrderable: boolean;
+    /** Indica se il testo presente in questo Header può andare a capo o meno, di default non può */
+    thWrap: boolean;
+    /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
+    thResizable: boolean;
+    /** Classi da applicare all'Header della colonna */
+    thClass: string;
+    /** Classi da applicare alle righe quando rappresentano un Gruppo */
+    thGroupClass: string;
+    /** Equivalente dell'NgIf sul th */
+    thIf: boolean;
+    /** Indica che bisogna fare un raggruppamento su questa colonna */
+    thGroup: boolean;
+    /** Indica che bisogna fare una aggregazione su questa colonna, a fronte di almeno un altra con un raggruppamento */
+    thAggregation: string;
+    /**
+     * @ignore
+     */
+    constructor(Template: TemplateRef<any>);
+}

package/lib/domain/configuration/EsTableDefaultable.d.ts

@@ -0,0 +1,19 @@
+/** Raccolta di tutti gli Input dell'EsTable a cui può essere logicamente sensato assegnare default per progetto */
+export declare class EsTableDefaultable {
+    /**  @ignore Vedi **EsTableComponent** */ ColumnsResizable?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ AutoUpdate?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ AllSearch?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ Export?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePaging?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePagingCount?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePagingButtons?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ContainerClass?: string;
+    /**  @ignore Vedi **EsTableComponent** */ TableClass?: string;
+    /**  @ignore Vedi **EsTableComponent** */ Selection?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ SavePreferences?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ PagingStyle?: 'both' | 'top' | 'bottom';
+    /**  @ignore Vedi **EsTableComponent** */ RowGroupingPagingStyle?: 'left' | 'right';
+    /**  @ignore Vedi **EsTableComponent** */ UseSelectionCache?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ShowItemGroupsColumns?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ArraymodeItemsPerPage?: number;
+}

package/lib/domain/configuration/EsTableModuleConfig.d.ts

@@ -0,0 +1,10 @@
+import { EsTableDefaultable } from "./EsTableDefaultable";
+/** Modello di configurazione per L'EsTable */
+export declare class EsTableModuleConfig {
+    /** Locale da utilizzare per i messaggi, supportati "it-IT" ed "en-US" */
+    locale?: string;
+    /** Indica se scrivere messaggi di log a console */
+    debugMode?: boolean;
+    /** Eventuali proprietà di default per l'EsTable */
+    EsTableDefaults?: EsTableDefaultable;
+}

package/lib/domain/externals/classes/CornerMenuOption.d.ts

@@ -0,0 +1,7 @@
+/** Indica un'opzione cliccabile nel Corner Menù della tabella (il menù richiamabile dai 3 pallini verticli in alto a destra) */
+export declare class CornerMenuOption {
+    /** Id dell'operazione. I callback relativi verranno effettuati con questo */
+    id: string;
+    /** Descrizione dell'operazione da presentare all'utente */
+    description: string;
+}

package/lib/domain/{classes → externals/classes}/EsTableColumnsDefinition.d.ts

@@ -1,6 +1,4 @@
-/**
- * Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche"
- */
+/** Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche" */
 export declare class EsTableColumnsDefinition {
     description: string;
     propertyName: string;
@@ -11,6 +9,7 @@ export declare class EsTableColumnsDefinition {
     visible: boolean;
     clss: string;
     orderable: boolean;
+    headerWraps: boolean;
     /**
      * Costruttore
      *
@@ -24,10 +23,9 @@ export declare class EsTableColumnsDefinition {
      * @param {boolean} visible Visibilità o meno della colonna
      * @param {string} clss Classe da applicare sia ai TD che ai TH relativi a questa colonna
      * @param {boolean} orderable Indica se la colonna è ordinabile o no (nel senso ASC / DESC / NONE)
+     * @param {boolean} headerWraps Indica se il testo dell'header dev'essere wrappato all'interno del th. Di default no.
      */
-    constructor(description: string, propertyName: string, routePath?: string, routeParameterProperties?: string[], dataOrder?: 'ASC' | 'DESC', columnOrder?: number, visible?: boolean, clss?: string, orderable?: boolean);
-    /**
-     * Routerlink che verrà generato a runtime basandosi sulle informazioni di **routePath** e **routeParameterProperties**
-     */
+    constructor(description: string, propertyName: string, routePath?: string, routeParameterProperties?: string[], dataOrder?: 'ASC' | 'DESC', columnOrder?: number, visible?: boolean, clss?: string, orderable?: boolean, headerWraps?: boolean);
+    /** Routerlink che verrà generato a runtime basandosi sulle informazioni di **routePath** e **routeParameterProperties** */
     routerLink: any;
 }

package/lib/domain/{classes → externals/classes}/EsTableOperationDefinition.d.ts

@@ -1,6 +1,4 @@
-/**
- * Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella
- */
+/** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
 export declare class EsTableOperationDefinition {
     id: string;
     title: string;

package/lib/domain/externals/classes/appsearch/AppSearch.d.ts

@@ -0,0 +1,67 @@
+import { AppOrdering } from './AppOrdering';
+import { ItemsSelection } from './ItemsSelection';
+import { Group } from './Group';
+import { GroupFilter } from './GroupFilter';
+import { GroupOrAggregation } from './GroupOrAggregation';
+/**
+ * Classe che identifica una ricerca paginata in tutte le sue sfumature (di grigio)
+ */
+export declare class AppSearch<T> {
+    /**
+     * Costruttore che genera un'istanza coi valori di default e impostando **firstsearch** a **true**
+     */
+    constructor();
+    /** Indica se c'è una ricerca in corso */
+    searchinprogress: boolean;
+    /** Indica il numero totale di pagine trovate dalla ricerca. Ogni pagina è una lista di **itemsperpageoverride** oggetti */
+    pages: number;
+    /** Conteggio totale degli oggetti trovati (inclusi quelli in pagine non attualmente selezionate) */
+    objectcount: number;
+    /** Conteggio totale dei gruppi trovati (inclusi quelli in pagine non attualmente selezionate) */
+    groupcount: number;
+    /** Pagina attualmente in visualizzazione */
+    page: number;
+    /** Numero di oggetti da persentare in ogni pagina. Per convenzione si considera valorizzato a 15 se non fornito */
+    itemsperpageoverride: number;
+    /** Lista degli oggetti nella pagina attualmente in visualizzazione */
+    items: T[];
+    /** Dizionario contenente tutti i gruppi paginati  */
+    groups: Group[];
+    /** Lista di colonne per cui ordinare */
+    orders: AppOrdering[];
+    /** Lista di colonne da visualizzare */
+    columns: string[];
+    /** Lista di colonne nell'ordine corretto */
+    column_ordering: string[];
+    /** Indica se la ricerca era salvata. Qualora fosse questo il caso, al caricamento l'es-table si occuperà di ri-effettuare la ricerca ed aggiornare il modello */
+    savedstate: boolean;
+    /** Indica se bisogna ancora effettuare la prima ricerca */
+    firstsearch: boolean;
+    /**
+     * Oggetto che indica la selezione corrente.
+     *
+     * Se **all** è **true** vuole dire che è tutto selezionato ed eventualmente ci sono delle esclusioni (**exclusions**)
+     * Se **all** è **false** vuol dire che sono selezionati **item** specifici
+     *
+     * In base all'Input **UseSelectionCache** le proprietà **exclusions** e **items** fanno riferimento o alla pagina corrente (se **false**)
+     * o all'intera ricerca (se **true**)
+     */
+    selection: ItemsSelection<T>;
+    /**
+     * Indica che la ricerca è stata richiesta dall'estable. Questa variabile NON deve essere toccata. È gestita al 100% dall'es-table.
+     *
+     * L'unica cosa che serve è che nel modello lato C# sia presente in modo da non perderla durante la serializzazione
+     */
+    internalsearchrequest: boolean;
+    /** Raggruppamenti da fare per questa query. Se impostato e non ci sono **filtergroup** mi aspetto di ricevere oggetti nel campo **groups** */
+    groupings: GroupOrAggregation[];
+    /**
+     * Filtro da applicare ai gruppi. Qualora il numero di filtri qui fosse uguale al numero di raggruppamenti mi inizio ad apettare di ricevere oggetti
+     * sul campo **items**, in caso contrario mi aspetto di ricevere o i gruppi nel campo **groups** o l'N-esimo livello dei gruppi
+     */
+    requestedgroups: GroupFilter[];
+    /**
+     * Permette di resettare questo oggetto ai valori di default
+     */
+    reset(): void;
+}

package/lib/domain/externals/classes/appsearch/GenericItem.d.ts

@@ -0,0 +1,13 @@
+/** Classe che definisce un oggetto generico come lista di proprietà-valore */
+export declare class GenericItem {
+    /** @ignore */
+    constructor();
+    /** Dizionario delle proprietà dell'oggeto con il loro valore */
+    properties: Record<string, string>;
+    /** Indica se l'oggetto in questione è selezionato o meno */
+    _selected: boolean;
+    /** Viene valorizzato da un eventuale **RowClassAssigner** (o automaticamente se in modalità gerarchica) e serve applicare stili particolari alla intera riga */
+    _rowClass: string;
+    /** Hash dell'oggetto per generare i contesti di bind all'interno dell'es-table (vedere eventualmente l'implementazione specifica) */
+    _hash: string;
+}

package/lib/domain/externals/classes/appsearch/Group.d.ts

@@ -0,0 +1,17 @@
+import { GroupAggregation } from "./GroupAggregation";
+/** Classe che rappresenta un Gruppo con le proprie aggregazioni */
+export declare class Group {
+    column: string;
+    count: number;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna raggruppata
+     * @param {number} count Numero di elementi raggruppati sotto questa colonna
+     * @param {string} value Valore del Gruppo
+     */
+    constructor(column: string, count: number, value: string);
+    /** Aggregazioni presenti su questo gruppo, valide per tutte le altre colonne (non a loro volta gruppate) */
+    aggregations: GroupAggregation[];
+}

package/lib/domain/externals/classes/appsearch/GroupAggregation.d.ts

@@ -0,0 +1,14 @@
+/** Classe che rappresenta un'aggregazione */
+export declare class GroupAggregation {
+    column: string;
+    aggregation: 'min' | 'max' | 'sum';
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna aggregata
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione da effettuare su questa colonna
+     * @param {string} value Valore dell'aggregazione
+     */
+    constructor(column: string, aggregation: 'min' | 'max' | 'sum', value: string);
+}

package/lib/domain/externals/classes/appsearch/GroupFilter.d.ts

@@ -0,0 +1,12 @@
+/** Classe che rappresenta un filtro su un gruppo */
+export declare class GroupFilter {
+    column: string;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna gruppata per cui si richiede di filtrare
+     * @param {string} value Valore del gruppo su questa **column** per cui si richiede di filtrare
+     */
+    constructor(column: string, value: string);
+}

package/lib/domain/externals/classes/appsearch/GroupOrAggregation.d.ts

@@ -0,0 +1,14 @@
+/** Classe che rappresenta o un gruppo o una aggregazione su una colonna. Usata solo internamente */
+export declare class GroupOrAggregation {
+    column: string;
+    aggregation?: 'min' | 'max' | 'sum';
+    datatype?: 'string' | 'date' | 'number';
+    /**
+     * Costruttore
+     *
+     * @param {string} column Colonna su cui è presente o un gruppo o un'aggregazione
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione presente sulla **column**. Se questo campo è nullo significa che è un gruppo.
+     * @param {'string' | 'date' | 'number'} datatype Tipo di dati contenuto nella colonna **column** se non c'è alcuna aggregazione è inutile, pertanto non sarà valorizzato
+     */
+    constructor(column: string, aggregation?: 'min' | 'max' | 'sum', datatype?: 'string' | 'date' | 'number');
+}