@esfaenza/es-table 13.3.2 → 13.4.0

package/lib/core/CopyPasteDetector.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+/** Classe che fornisce dei metodi di estensione in grado di riconoscere e dispatchare l'evento copia e incolla lanciato su una pagina web */
+export declare class CopyPasteDetector {
+    /** Dispatcher del Copia */
+    OnCopy: Subject<void>;
+    /** Dispatcher dell' Incolla */
+    OnPaste: Subject<void>;
+    /** Riferimento all'estable attiva per evitare di spammare copia incolla dove non servono */
+    ActiveEstReference: any;
+    /** @ignore */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyPasteDetector, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CopyPasteDetector>;
+}

package/lib/core/Logger.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+/** Classe che fornisce dei metodi di estensione in grado di riconoscere e dispatchare l'evento copia e incolla lanciato su una pagina web */
+export declare class Logger {
+    debugMode: boolean;
+    /** @ignore */
+    constructor(debugMode: boolean);
+    log(text: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Logger, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Logger>;
+}

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

@@ -24,6 +24,12 @@ export declare class ColumnMetadataHandler {
      * @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
      *
@@ -32,6 +38,7 @@ export declare class ColumnMetadataHandler {
      * @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[];
@@ -47,6 +54,7 @@ export declare class ColumnMetadataHandler {
      * 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;
     /**

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

@@ -1,32 +1,22 @@
 import { EsTableComponent } from "../../components/es-table/es_table.component";
-import { GenericItem } from "../../domain/externals/appsearch/GenericItem";
+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);
-    /**
-     * 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;
+    /** 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

@@ -17,6 +17,10 @@ export declare class ExportHandler {
      * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
      */
     tryExport(format?: string): void;
+    /** Effettua l'esportazione in file CSV, va a sostituire quel coso inutile di @ctrl/ngx-csv */
+    private exportCSV;
+    /** Generazione specifica del CSV */
+    private convertToCSV;
     /** Effettua l'esportazione del file Excel basandosi sul modulo **ExcelJS**, sugli header **this.est.headers** e sui dati **this.est.data** */
     private exportExcel;
     /**

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

@@ -31,5 +31,5 @@ export declare class ItemsHandler {
     /** 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(): void;
+    arrayModeReviewOrderings(items: any[]): any[];
 }

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

@@ -11,6 +11,15 @@ export declare class ReportModeHandler {
     constructor(est: EsTableComponent, utilities: UtilitiesHandler);
     /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
     reviewReportBindings(): void;
+    /**
+     * Data una AppSearch questo metodo genera la lista di th e td che si possono collegare al giro standard.
+     * Se non ci fosse questo passaggio intermedio la gestione della modalità report sarebbe 100% custom,
+     * come poi lo era prima che la facessi passare dal giro che fanno tutte le altre modalità
+     *
+     * @param {AppSearch<any>} view View in modalità report contenente le informazioni sulle colonne
+     *
+     * @returns {{ ths: EsThDirective[], tds: EsTdDirective[] }} Lista di direttive per gli header e per il body
+     */
     generateThsAndTdsFromView(view: AppSearch<any>): {
         ths: EsThDirective[];
         tds: EsTdDirective[];

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

@@ -1,5 +1,9 @@
 import { ItemsSelection } from "../../domain/externals/appsearch/ItemsSelection";
+import { ItemPropEditableReference } from "../../domain/externals/ItemPropEditableReference";
+import { EsTableColumnsDefinition } from "../../domain/externals/EsTableColumnsDefinition";
+import { InputType } from '../../domain/types';
 import { EsTableComponent } from "../../components/es-table/es_table.component";
+import { EsThDirective } from "../../directives/es_th.directive";
 import { RowGroupingHandler } from "./RowGroupingHandler";
 /** Classe che gestisce le selezioni degli oggetti */
 export declare class SelectionHandler {
@@ -21,6 +25,8 @@ export declare class SelectionHandler {
     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;
+    /** Ultima cella selezionata singolarmente */
+    private lastSingleSelection;
     /** @ignore Costruttore */
     constructor(est: EsTableComponent, rgHandler: RowGroupingHandler);
     /** Ripulisce le cache di selezione */
@@ -32,6 +38,17 @@ export declare class SelectionHandler {
      * @param {ItemsSelection<any>} selectionItem Oggetti di selezione derivante dalla view o dall'oggetto per Array
      */
     evaluateSelection(items: any[], selectionItem: ItemsSelection<any>): void;
+    /**
+     * Precompila le informazioni sullo stato di selezione tutto a false per le celle della tabella
+     *
+     * @param {any[]} items Oggetti attualmente bindati sulla tabella
+     * @param {EsThDirective[]} ths Colonne su cui gli oggetti sono bindati
+     */
+    evaluateSingleCellSelection(items: any[], ths: EsThDirective[], dyn: EsTableColumnsDefinition[]): void;
+    /** @ignore */
+    private fillSelectionStatusByDynamicColumns;
+    /** @ignore */
+    private fillSelectionStatusByEsThs;
     /**
      * Implementazione agnostica della valutazione delle selezioni degli oggetti. Richiede gli oggetti della vista attuale e l'itemSelector
      *
@@ -146,4 +163,77 @@ export declare class SelectionHandler {
     private evaluateSelected;
     /** Gestisce il comando di "Seleziona tutto in tutte le pagine" o il suo contrario, cioè "Reimposta selezione" */
     selectAllOrResetSelection(): void;
+    /**
+     * @TODO Spostare in SelectionHandler
+     *
+     * Registra la selezione singola su una cella sulla combo di comandi "CTRL + Click".
+     * Se viene premuto anche il tasto Shift viene creato un range di selezione il cui status di "selezionato" viene salvato nella
+     * matrice virtuale **selectionStatus**
+     *
+     * @param {any} event Evento Javascript di Click
+     * @param {number} row Indice della riga. Non è l'indice vero e proprio ma è l'ordinale (.ordinal) dell'oggetto bindato su quella riga
+     * @param {number} column Indice della colonna preso banalmente dall'ngIf sui thElement
+     * @param {{ row: number, column: number }} firstSelectionOverride Permette di overridare il primo elemento selezionato
+     */
+    singleCellSelection(event: {
+        view: any;
+        range: boolean;
+    }, row: number, column: number, firstSelectionOverride?: {
+        row: number;
+        column: number;
+    }): void;
+    setSelectionStatusBorders(from: {
+        row: number;
+        column: number;
+    }, to: {
+        row: number;
+        column: number;
+    }): void;
+    /**
+     * Helper per ripulire lo stato di selezione delle singole celle della tabella, ad esclusione di una singola coordinata
+     *
+     * @param {{row: number, column: number}} exclusion Coordinata da escludere nella pulizia
+     */
+    clearSelectionStatusExcluding(exclusion?: {
+        row: number;
+        column: number;
+    }): void;
+    /**
+     * Helper che esamina la matrice **selectionStatus** e ne estrappola gli elementi selezionati in una comoda matrice
+     *
+     * @returns {{ value: string, type: InputType, val_setter: Function }[][]} Matrice di elementi selezionati con la loro informazione sul tipo
+     */
+    getSelectionStatusSelection(): ItemPropEditableReference[][];
+    /**
+     * Helper per ripulire la selezione lato HTML
+     *
+     * @param {any} event Evento nativo Javascript
+     */
+    clearTextSelection(event: {
+        view: any;
+        range: boolean;
+    }): boolean;
+    /**
+     * Data la matrice di selezione generata dal metodo **getSelectionStatusSelection** genera la strigna vera e propria da copiare nella Clipboard
+     *
+     * @param {{ value: string, type: InputType }[][]} sel Matrice di selezione con valori e tipi dei dati selezionati
+     *
+     * @returns {string} Stringa da copiare nella clipboard, le stringhe vengono wrappate fra doppi apici e fra un valore e l'altro viene messo un tab
+     * in modo che siano compatibili anche con la copia su Excel
+     */
+    getClipbardTextFromSelection(sel: {
+        value: string;
+        type: InputType | string;
+    }[][]): string;
+    /**
+     * Ottiene la rappresentazione stringa di un valore dato un tipo
+     *
+     * @param {{ value: string, type: InputType }} valType Oggetto Valore - Tipo da cui estrapolare la rappresentazione del dato in stringa
+     *
+     * @returns {string} Valore convertito in stringa in base al tipo
+     */
+    getValueByType(valType: {
+        value: string;
+        type: InputType | string;
+    }): string;
 }

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

@@ -34,7 +34,10 @@ export declare class UtilitiesHandler {
      *
      * @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[];
+    getPagesArray(maxBtns: number, page: number, lastPage: number, actualCount?: number, ipp?: number): {
+        val: number;
+        cssClass: string;
+    }[];
     /**
      * Calcola l'hash di un oggetto qualsiasi
      *

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

@@ -11,16 +11,32 @@ export declare class EsTdDirective {
     tdVisible: boolean;
     /** Id della colonna, fa riferimento al **th** padre */
     td: string;
+    /** Se questo td viene usato come renderer in questa proprietà è scritto il nome della proprietà dell'oggetto bindato per cui fare apparire il **Template** */
+    tdForProperty: string;
     /** Equivalente dell'NgIf sul td */
     tdIf: boolean;
     /** Eventuali classi da applicare al **td** generato */
     tdClass: string;
     /** In mancanza di **Template** indica qual è la proprietà dell'oggetto contenente le informazioni da mostrare */
     tdPropertyAccessor: string;
+    /** Allineamento dei valori della tabella */
+    tdAlignment: "Center" | "Left" | "Right";
+    /** Formato da applicare al valore se applicabile, utilizzabile solo se **tdPropertyAccessor** è valorizzato */
+    tdFormat: string;
+    /** Se il contenuto di questo td dev'essere un'immagine cliccabile, questa è la classe che la identifica */
+    tdIconClass: string;
+    /** Campo da controllare per fare apparire/sparire il contenuto di questa cella qualora fosse diverso da **tdConditionValue** */
+    tdConditionField: string;
+    /** Valore che deve assumere **tdConditionField** per mostrare il contenuto di questa cella */
+    tdConditionValue: string;
+    /** Titolo HTML di questa cella */
+    tdTitle: string;
+    /** Contenuto statico di questa cella */
+    tdContent: string;
     /**
      * @ignore
      */
     constructor(Template: TemplateRef<any>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<EsTdDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<EsTdDirective, "[td]", never, { "tdVisible": "tdVisible"; "td": "td"; "tdIf": "tdIf"; "tdClass": "tdClass"; "tdPropertyAccessor": "tdPropertyAccessor"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsTdDirective, [{ self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EsTdDirective, "[td]", never, { "tdVisible": "tdVisible"; "td": "td"; "tdForProperty": "tdForProperty"; "tdIf": "tdIf"; "tdClass": "tdClass"; "tdPropertyAccessor": "tdPropertyAccessor"; "tdAlignment": "tdAlignment"; "tdFormat": "tdFormat"; "tdIconClass": "tdIconClass"; "tdConditionField": "tdConditionField"; "tdConditionValue": "tdConditionValue"; "tdTitle": "tdTitle"; "tdContent": "tdContent"; }, {}, never>;
 }

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

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Direttiva che rappresenta il template dell'editor di una cella all'interno della tabella */
+export declare class EsTdEditorDirective {
+    Template: TemplateRef<any>;
+    /** Id dell'Editor */
+    editor: string;
+    /** In questa proprietà è scritto il nome della proprietà dell'oggetto bindato per cui fare apparire il **Template** */
+    editorForProperty: string;
+    /** @ignore */
+    constructor(Template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsTdEditorDirective, [{ optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EsTdEditorDirective, "[editor]", never, { "editor": "editor"; "editorForProperty": "editorForProperty"; }, {}, never>;
+}

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

@@ -1,5 +1,7 @@
 import { TemplateRef } from "@angular/core";
+import { AvailableOptions } from "@esfaenza/forms-and-validations";
 import { ThAggregation } from "../domain/internals/ThAggregation";
+import { InputType } from "../domain/types";
 import * as i0 from "@angular/core";
 /** Direttiva per la dichiarazione snella di un EsTh da emettere come header */
 export declare class EsThDirective {
@@ -8,6 +10,7 @@ export declare class EsThDirective {
     _thAggregations: ThAggregation[];
     /** Variabile interna contenente in maniera ordinata i template dei padri */
     _thParents: {
+        id: string;
         tmpl?: TemplateRef<any>;
         content?: string;
     }[];
@@ -43,6 +46,8 @@ export declare class EsThDirective {
     thResizable: boolean;
     /** Classi da applicare all'Header della colonna */
     thClass: string;
+    /** Classi da applicare all'Header della colonna */
+    thShrink: boolean;
     /** Classi da applicare alle righe quando rappresentano un Gruppo */
     thGroupClass: string;
     /** Equivalente dell'NgIf sul th */
@@ -53,23 +58,50 @@ export declare class EsThDirective {
     thGroup: boolean;
     /** Indica che bisogna fare una aggregazione su questa colonna, a fronte di almeno un altra con un raggruppamento */
     thAggregation: string;
-    /** Impostazioni per la modifica inline di questo campo: la **Property** di riferimento e il **Type** (a scelta fra quelli supportati dal form-adaptive) */
-    thUserEdits: {
-        Property: string;
-        Type: 'string' | 'float' | 'date' | 'number' | 'int' | 'boolean' | 'enum' | 'autocomplete' | 'datetime' | 'time' | 'file' | 'currency';
-        Source: {
-            id: string;
-            description: string;
-        }[];
-    };
+    /** Proprietà JS a cui si riferisce questa cella */
+    thProperty: string;
+    /** Tipo della proprietà JS a cui si riferisce questa cella. Se valorizzato l'utente la potrà modificare facendo doppio click */
+    thType: InputType | string;
+    /** Sorgente dei valori disponibili per questa cella se il **Type** è di tipo 'enum' */
+    thSource: {
+        id: string;
+        description: string;
+    }[];
     /** Indica che questo header deve essere emesso una volta per ogni valore presente nella lista di **EsTableMultiValue** alla proprietà **th** dell'oggetto corrente */
     thMulti: boolean;
     /** Indica un contenuto statico da mostrare piuttosto che utilizzare il **Template**. Serve in caso questo oggetto venga generato programmaticamente */
     thStaticContent: string;
     /** Colore del background della cella */
     thBackgroundColor: string;
+    /** Allineamento dei valori della tabella */
+    thAlignment: "Center" | "Left" | "Right";
+    /** Formato da applicare al valore se applicabile */
+    thFormat: string;
+    /** Nome dell'editor da utilizzare per la modifica di questo campo, ordine di priorità:
+     *
+     * 1. Editor con nome **thEditorName**
+     *
+     * 2. Editor riferito alla proprietà **thProperty**
+     *
+     * 3. Editor di default per **thType**
+     */
+    thEditorName: string;
+    /** Opzioni da applicare all'editor di questa colonna */
+    thEditorOptions: {
+        [id in AvailableOptions]?: any;
+    };
+    /** Nome del renderer da utilizzare per visualizzare questo campo. Utilizzato solo per le tabelle dinamiche */
+    thRendererName: string;
+    /** Route di navigazione. Es. "['/pages/mod/mod_detail', { 'idItem': '{0}', 'idItem2' : '{1}' }]" */
+    thRoutePath: string;
+    /**
+     * Proprietà da bindare a **routePath** per generare la route completa.
+     *
+     * L'indice scritto in **routePath** è l'indice di accesso a questo array. Es. ["idItem", "idItem2"]
+     */
+    thRouteParameterProperties: string[];
     /** @ignore */
     constructor(Template: TemplateRef<any>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<EsThDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<EsThDirective, "[th]", never, { "th": "th"; "thPinned": "thPinned"; "thPinnable": "thPinnable"; "thPinnedWidth": "thPinnedWidth"; "thVisible": "thVisible"; "thFixed": "thFixed"; "thParent": "thParent"; "thOrder": "thOrder"; "thOrderable": "thOrderable"; "thWrap": "thWrap"; "thResizable": "thResizable"; "thClass": "thClass"; "thGroupClass": "thGroupClass"; "thIf": "thIf"; "thEmpty": "thEmpty"; "thGroup": "thGroup"; "thAggregation": "thAggregation"; "thUserEdits": "thUserEdits"; "thMulti": "thMulti"; "thStaticContent": "thStaticContent"; "thBackgroundColor": "thBackgroundColor"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsThDirective, [{ self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EsThDirective, "[th]", never, { "th": "th"; "thPinned": "thPinned"; "thPinnable": "thPinnable"; "thPinnedWidth": "thPinnedWidth"; "thVisible": "thVisible"; "thFixed": "thFixed"; "thParent": "thParent"; "thOrder": "thOrder"; "thOrderable": "thOrderable"; "thWrap": "thWrap"; "thResizable": "thResizable"; "thClass": "thClass"; "thShrink": "thShrink"; "thGroupClass": "thGroupClass"; "thIf": "thIf"; "thEmpty": "thEmpty"; "thGroup": "thGroup"; "thAggregation": "thAggregation"; "thProperty": "thProperty"; "thType": "thType"; "thSource": "thSource"; "thMulti": "thMulti"; "thStaticContent": "thStaticContent"; "thBackgroundColor": "thBackgroundColor"; "thAlignment": "thAlignment"; "thFormat": "thFormat"; "thEditorName": "thEditorName"; "thEditorOptions": "thEditorOptions"; "thRendererName": "thRendererName"; "thRoutePath": "thRoutePath"; "thRouteParameterProperties": "thRouteParameterProperties"; }, {}, never>;
 }

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

@@ -17,4 +17,5 @@ export declare class EsTableDefaultable {
     /**  @ignore Vedi **EsTableComponent** */ ShowItemGroupsColumns?: boolean;
     /**  @ignore Vedi **EsTableComponent** */ ArraymodeItemsPerPage?: number;
     /**  @ignore Vedi **EsTableComponent** */ ColumnsPinnable?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ DefaultAlignment?: 'Left' | 'Center' | 'Right';
 }

package/lib/domain/externals/EsTableColumnsDefinition.d.ts

@@ -1,31 +1,56 @@
+import { InputType } from "../types";
+import { AvailableOptions } from "@esfaenza/forms-and-validations";
 /** Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche" */
 export declare class EsTableColumnsDefinition {
-    description: string;
-    propertyName: string;
-    routePath: string;
-    routeParameterProperties: string[];
-    dataOrder: 'ASC' | 'DESC';
-    columnOrder: number;
-    visible: boolean;
-    clss: string;
-    orderable: boolean;
-    headerWraps: boolean;
+    Description: string;
+    PropertyName: string;
+    RoutePath: string;
+    RouteParameterProperties: string[];
+    DataOrder: 'ASC' | 'DESC';
+    ColumnOrder: number;
+    Visible: boolean;
+    Clss: string;
+    Orderable: boolean;
+    HeaderWraps: boolean;
+    PropertyType: InputType | string;
+    PropertySource: {
+        id: string;
+        description: string;
+    }[];
+    EditorName: string;
+    RendererName: string;
+    EditorOptions: {
+        [id in AvailableOptions]?: any;
+    };
+    Pinned: boolean;
+    PinnedWidth: number;
+    Pinnable: boolean;
+    Grouping: string;
+    Shrink: boolean;
     /**
      * Costruttore
      *
-     * @param {string} description Descrizione della colonna
-     * @param {string} propertyName Nome della proprietà del modello in cui sono contenuti i dati da visualizzare per questa colonna
-     * @param {string} routePath Route di navigazione. Es. "['/pages/mod/mod_detail', { 'idItem': '{0}', 'idItem2' : '{1}' }]"
-     * @param {string[]} routeParameterProperties Proprietà da bindare a **routePath** per generare la route completa.
+     * @param {string} Description Descrizione della colonna
+     * @param {string} PropertyName Nome della proprietà del modello in cui sono contenuti i dati da visualizzare per questa colonna
+     * @param {string} RoutePath Route di navigazione. Es. "['/pages/mod/mod_detail', { 'idItem': '{0}', 'idItem2' : '{1}' }]"
+     * @param {string[]} RouteParameterProperties Proprietà da bindare a **routePath** per generare la route completa.
      * L'indice scritto in **routePath** è l'indice di accesso a questo array. Es. ["iditem", "iditem2"]
-     * @param {'ASC' | 'DESC' } dataOrder Ordinamento dei dati presentati in questa colonna
-     * @param {number} columnOrder Ordinamento di questa colonna
-     * @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.
+     * @param {'ASC' | 'DESC' } DataOrder Ordinamento dei dati presentati in questa colonna
+     * @param {number} ColumnOrder Ordinamento di questa colonna
+     * @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.
+     * @param {InputType | string} PropertyType Indica il tipo della proprietà identificata da **propertyName**.
+     * @param {{id: string, description: string}[]} PropertySource Sorgente dati su cui autocompletare/scegliere il valore per la proprietà **propertyName**, ha senso solo per **propType** enum o autocomplete.
+     * @param {string} EditorName Nome dell'editor da utilizzare per la modifica di questo campo
+     * @param {string} RendererName Nome del renderer da utilizzare per visualizzare questo campo
      */
-    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;
+    constructor(Description: string, PropertyName: string, RoutePath?: string, RouteParameterProperties?: string[], DataOrder?: 'ASC' | 'DESC', ColumnOrder?: number, Visible?: boolean, Clss?: string, Orderable?: boolean, HeaderWraps?: boolean, PropertyType?: InputType | string, PropertySource?: {
+        id: string;
+        description: string;
+    }[], EditorName?: string, RendererName?: string, EditorOptions?: {
+        [id in AvailableOptions]?: any;
+    }, Pinned?: boolean, PinnedWidth?: number, Pinnable?: boolean, Grouping?: string, Shrink?: boolean);
+    static build(parsObj: any): EsTableColumnsDefinition;
 }

package/lib/domain/externals/EsTableModelChange.d.ts

@@ -0,0 +1,17 @@
+/** Classe che rappresenta la modifica ad un singolo oggetto in una singola proprietà */
+export declare class EsTableModelChange {
+    item: any;
+    header: string;
+    property: string;
+    old_value: string;
+    new_value: string;
+    /**
+     * Costruttore
+     * @param {any} item Oggetto modificato
+     * @param {string} header Nome dell'Header che è stato modificato
+     * @param {string} property Nome della proprietà modificata
+     * @param {string} old_value Vecchio valore della proprietà **property** dell'oggetto **item**
+     * @param {string} new_value Nuovo valore della proprietà **property** dell'oggetto **item**
+     */
+    constructor(item: any, header: string, property: string, old_value: string, new_value: string);
+}

package/lib/domain/externals/ItemPropEditableReference.d.ts

@@ -0,0 +1,34 @@
+import { InputType } from "../types";
+/** Classe che rappresenta il riferimento ad una proprietà di un oggetto bindato sulla tabella */
+export declare class ItemPropEditableReference {
+    /** Stato di selezione della cella relativa */
+    selected: boolean;
+    /** Oggetto relativo su cui si modificano le proprietà */
+    item: any;
+    /** ID dell'header in modifica (riferimento al TH relativo) */
+    header: string;
+    /** Proprietà Javascript effettivamente in modifica */
+    property: string;
+    /** Tipo dell'input */
+    type: InputType | string;
+    /** Valore attuale della proprietà **property** dell'oggetto **item** */
+    value: string;
+    /** Indica se la cella deve avere il bordino a sinistra */
+    lborder?: boolean;
+    /** Indica se la cella deve avere il bordino in alto */
+    tborder?: boolean;
+    /** Indica se la cella deve avere il bordino a destra */
+    rborder?: boolean;
+    /** Indica se la cella deve avere il bordino in basso */
+    bborder?: boolean;
+    /** Indica se il bordo a sinistra overlappa su un bordo di selezione destro della cella precedente */
+    loverlaps?: boolean;
+    /** Indica se il bordo a destra overlappa su un bordo di selezione sinistro della cella successiva */
+    roverlaps?: boolean;
+    /** Indica se il bordo in alto overlappa su un bordo di selezione basso della cella precedente */
+    toverlaps?: boolean;
+    /** Indica se il bordo in basso overlappa su un bordo di selezione in alto della cella successiva */
+    boverlaps?: boolean;
+    /** Funzione che imposta il nuovo valore della proprietà **property** dell'oggetto **item** ed aggiorna il **value** di questo oggetto */
+    val_setter?: (value: string) => any;
+}

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

@@ -51,6 +51,8 @@ export declare class AppSearch<T> {
     savedstate: boolean;
     /** Indica se bisogna ancora effettuare la prima ricerca */
     firstsearch: boolean;
+    /** Indica se sto effettuando la ricerca post bind */
+    selfsearch: boolean;
     /**
      * Oggetto che indica la selezione corrente.
      *
@@ -75,7 +77,18 @@ export declare class AppSearch<T> {
      */
     requestedgroups: GroupFilter[];
     /**
-     * Permette di resettare questo oggetto ai valori di default
+     * Permette di resettare un AppSearch ai valori di default.
+     * Reso statico perché fra una deserializzazione e l'altra si potrebbe perdere il prototype del costruttore
+     *
+     * @param {AppSearch<any>} aps AppSearch da resettare
+     */
+    static reset(aps: AppSearch<any>): void;
+    /**
+     * Permette di ottenere un nuovo riferimento all'AppSearch passata come parametro.
+     * Internamente utilizza il JSON.parse(JSON.stringify(X)) con la differenza che prima stacca il riferimento agli items per evitare di
+     * reserializzare potenzialmente centinaia di elementi. Il riferimento viene poi ricollegato alla nuova appsearch generata
+     *
+     * @param {AppSearch<any>} aps AppSearch di cui estrarre un nuovo riferimento equivalente
      */
-    reset(): void;
+    static newref(aps: AppSearch<any>): any;
 }

package/lib/domain/externals/report/ReportColumn.d.ts

@@ -12,4 +12,8 @@ export declare class ReportColumn {
     seq: number;
     /** Ordinamento dei dati presentati */
     order?: string;
+    /** Allineamento da tenere per questa colonna: **Center**, **Left** o **Right** */
+    alignment?: string;
+    /** Formato dei dati da presentare in questa colonna */
+    format?: string;
 }

package/lib/domain/externals/report/ReportRow.d.ts

@@ -2,4 +2,8 @@
 export declare class ReportRow {
     /** Valori dell'oggetto in ordine sequenziale */
     values: string[];
+    /** Colore di foreground per ogni cella */
+    forecolors?: string[];
+    /** Colore di background per ogni cella */
+    backcolors?: string[];
 }

package/lib/domain/internals/EsTableColumn.d.ts

@@ -10,6 +10,7 @@ export declare class EsTableColumn {
     pinnedWidth?: number;
     template?: TemplateRef<any>;
     parentTemplates?: {
+        id: string;
         tmpl?: TemplateRef<any>;
         content?: string;
     }[];
@@ -22,14 +23,16 @@ export declare class EsTableColumn {
      * @param {string} description Descrizione (Header)
      * @param {boolean} visible Indica se di default mostrarla o meno
      * @param {boolean} fixed Indica se è una colonna fixed
+     * @param {boolean} pinnable Indica se una colonna può essere pinnata
      * @param {boolean} pinned Indica se è una colonna pinnata
      * @param {number} pinnedWidth Indica la dimensione da assegnare a questa colonna quando è pinnata
      * @param {TemplateRef<any>} template Indica il template da usare per mostrare il testo dell'Header
-     * @param {{ tmpl: TemplateRef<any>, content: string }[]} parentTemplates Indica la lista di template padri collegata a questo header, rappresentati come Template o come stringa qualora fosse generato automaticamente (caso **Multi**)
+     * @param {{ id: string, tmpl: TemplateRef<any>, content: string }[]} parentTemplates Indica la lista di template padri collegata a questo header, rappresentati come Template o come stringa qualora fosse generato automaticamente (caso **Multi**)
      * @param {boolean} multi Indica che la colonna deriva da una direttiva **Multi**
      * @param {string} multiContent Indica il contenuto della direttiva **Multi** per questa colonna
      */
     constructor(id: string, description: string, visible?: boolean, fixed?: boolean, pinned?: boolean, pinnable?: boolean, pinnedWidth?: number, template?: TemplateRef<any>, parentTemplates?: {
+        id: string;
         tmpl?: TemplateRef<any>;
         content?: string;
     }[], multi?: boolean, multiContent?: string);