@esfaenza/es-table 12.2.28 → 13.1.2

package/esm2020/lib/core/handlers/classes/UtilitiesHandler.mjs

@@ -0,0 +1,166 @@
+// Angular
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/extensions";
+/** Classe di utilità per le cose comuni */
+export class UtilitiesHandler {
+    /** @ignore Costruttore */
+    constructor(hashExts) {
+        this.hashExts = hashExts;
+    }
+    /**
+     * 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, field) {
+        let ret = {};
+        for (let i = 0; i < array.length; i++) {
+            let x = array[i];
+            (ret[x[field]] = ret[x[field]] || []).push(x);
+        }
+        return ret;
+    }
+    ;
+    /**
+     * 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) {
+        group._aggregationsCache = new Map();
+        let castedAgCache = group._aggregationsCache;
+        for (let i = 0; i < group.aggregations.length; i++) {
+            let agg = group.aggregations[i];
+            if (castedAgCache.has(agg.column))
+                castedAgCache.get(agg.column).set(agg.aggregation, agg.value);
+            else {
+                let tmp = new Map();
+                tmp.set(agg.aggregation, agg.value);
+                castedAgCache.set(agg.column, tmp);
+            }
+        }
+    }
+    /** Helper per spostare un oggetto di un array da un indice all'altro, in place */
+    arrayMove(array, oldI, newI) {
+        if (newI > array.length - 1 || oldI > array.length - 1 || newI < 0 || oldI < 0)
+            throw "Gli indici passati non fanno riferimento a una posizione dell'array. Length: " + array.length + " Old:" + oldI + " New: " + newI;
+        array.splice(newI, 0, array.splice(oldI, 1)[0]);
+    }
+    /**
+     * 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) { return !td._directive; }
+    /**
+     * 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) { return !th._directive; }
+    /**
+     * 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, page, lastPage, actualCount = null, ipp = null) {
+        let result = [];
+        // Se sono in modalità "Numero di pagine ed oggetti sconosciuti" faccio in modo di mostrare la pagina successiva solo se gli items effettivamente pervenuti
+        // sono uguali alla paginazione attuale (cioè questa pagina è di sicuro riempita completamente)
+        if (lastPage == -1 && ((actualCount == null && ipp == null) || (actualCount == ipp)))
+            lastPage = page + 1;
+        // Se sono in modalità "Numero di pagine ed oggetti sconosciuti" e mi arrivano 0 oggetti significa che l'ultima pagina è la precedente e non mostro pagine oltre
+        if (lastPage == -1 && actualCount == 0)
+            lastPage = page;
+        let min, max;
+        if (lastPage <= maxBtns) {
+            min = 1;
+            max = lastPage - 1;
+        }
+        else {
+            // tolgo la pagina selected è l'ultima pagina che è quella delle pagine totali
+            let rangeOutside = (maxBtns - 2) / 2;
+            min = page - rangeOutside;
+            max = page + rangeOutside;
+            if (min < 1) {
+                min = 1;
+                max = maxBtns - 1;
+            }
+            else if (max >= lastPage) {
+                min = lastPage - maxBtns + 1;
+                max = lastPage - 1;
+            }
+        }
+        result.push({ val: 1, cssClass: (1 === page ? 'btn-main app-white-text' : 'app-white-button') });
+        if (max >= min) {
+            for (let i = min; i <= max; i++)
+                if (i !== 1)
+                    result.push({ val: i, cssClass: (i === page ? 'btn-main app-white-text' : 'app-white-button') });
+            result.push({
+                val: lastPage,
+                cssClass: (lastPage === page ? 'btn-main app-white-text' : 'app-white-button')
+            });
+        }
+        return result;
+    }
+    /**
+     * Calcola l'hash di un oggetto qualsiasi
+     *
+     * @param {any[]} items Oggetti per cui calcolare l'hash
+     */
+    calculateHash(items) {
+        if (!items)
+            return;
+        // Supporto a hash duplicati di oggetti uguali
+        let usedHashesCache = {};
+        for (let i = 0; i < items.length; i++) {
+            let item = items[i];
+            // Prima di calcolare l'hash rimuovo le proprietà interne per evitare che mi scompensino i calcoli successivi
+            let tmp = Object.assign({}, items[i]);
+            delete tmp._selected;
+            delete tmp._visible;
+            delete tmp._hash;
+            let hash = this.hashExts.hashObject(tmp);
+            usedHashesCache[hash] = usedHashesCache[hash] ? usedHashesCache[hash] + 1 : 1;
+            item._hash = hash + (usedHashesCache[hash] > 1 ? "_" + usedHashesCache[hash] : "");
+        }
+    }
+    /**
+    * 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(inputValue, defaultValue, fallbackValue) {
+        // Input valorizzato dal programmatore
+        if (inputValue != null && inputValue != undefined)
+            return inputValue;
+        // Input valorizzato da configurazione globale
+        if (defaultValue != null && defaultValue != undefined)
+            return defaultValue;
+        //Input non valorizzato da niente e da nessuno
+        if (fallbackValue != null && fallbackValue != undefined)
+            return fallbackValue;
+        // I casi in cui si arriva qui sono i casi di Input che di default va bene che siano nulli e che nessuno si caga
+        return null;
+    }
+}
+UtilitiesHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: UtilitiesHandler, deps: [{ token: i1.HashingService }], target: i0.ɵɵFactoryTarget.Injectable });
+UtilitiesHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: UtilitiesHandler, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: UtilitiesHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HashingService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UtilitiesHandler.js","sourceRoot":"","sources":["../../../../../../../projects/es-table/src/lib/core/handlers/classes/UtilitiesHandler.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable } from \"@angular/core\";\r\n\r\n// Librerie\r\nimport { HashingService } from \"@esfaenza/extensions\";\r\n\r\n// Componenti\r\nimport { EsTd } from \"../../../components/es-td/es_td.component\";\r\nimport { EsTh } from \"../../../components/es-th/es_th.component\";\r\n\r\n/** Classe di utilità per le cose comuni */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UtilitiesHandler {\r\n\r\n    /** @ignore Costruttore */\r\n    constructor(private hashExts: HashingService) { }\r\n\r\n    /**\r\n     * Data una lista di oggetti effettua dei raggruppamenti in base alla proprietà **field**, \r\n     * restituendo un oggetto del tipo { Gruppo1: oggetti[], Gruppo2: oggetti[], ecc... }\r\n     *\r\n     * @param {any[]} array Lista degli oggetti da raggruppare\r\n     * @param {string} field Campo su cui effettuare i raggruppamenti\r\n     *\r\n     * @returns {{ [id: string]: any[] }} Dizionario dei gruppi\r\n     */\r\n    public groupBy(array: any[], field: string): { [id: string]: any[]; } {\r\n        let ret = {};\r\n        for (let i = 0; i < array.length; i++) {\r\n            let x = array[i];\r\n            (ret[x[field]] = ret[x[field]] || []).push(x);\r\n        }\r\n        return ret;\r\n    };\r\n\r\n    /**\r\n     * Helper per effettuare il caching delle aggregazioni. Le sposta da una lista di **GroupAggregation** a una **<Map<string, Map<string, string>>**\r\n     *\r\n     * @param {any} group Gruppo di cui cachare le aggregazioni\r\n     */\r\n    public cacheAggregations(group: any) {\r\n        (<any>group)._aggregationsCache = new Map();\r\n        let castedAgCache = (<Map<string, Map<string, string>>>(<any>group)._aggregationsCache);\r\n        for (let i = 0; i < group.aggregations.length; i++) {\r\n            let agg = group.aggregations[i];\r\n            if (castedAgCache.has(agg.column))\r\n                castedAgCache.get(agg.column).set(agg.aggregation, agg.value);\r\n            else {\r\n                let tmp: Map<string, string> = new Map();\r\n                tmp.set(agg.aggregation, agg.value);\r\n                castedAgCache.set(agg.column, tmp);\r\n            }\r\n        }\r\n    }\r\n\r\n    /** Helper per spostare un oggetto di un array da un indice all'altro, in place */\r\n    public arrayMove(array: any[], oldI: number, newI: number) {\r\n        if (newI > array.length - 1 || oldI > array.length - 1 || newI < 0 || oldI < 0)\r\n            throw \"Gli indici passati non fanno riferimento a una posizione dell'array. Length: \" + array.length + \" Old:\" + oldI + \" New: \" + newI;\r\n\r\n        array.splice(newI, 0, array.splice(oldI, 1)[0]);\r\n    }\r\n\r\n    /**\r\n     * Helper che identifica se il td attuale è di tipo **EsTd**. In caso contrario è da considerarsi **EsTdDirective**\r\n     *\r\n     * @param {any} td Cella da valutare\r\n     * @returns {boolean} Restituisce **true** se il **td** è di tipo **EsTd**, **false** se è di tipo **EsTdDirective**\r\n     */\r\n    public isEsTd(td: any): td is EsTd { return !td._directive; }\r\n\r\n    /**\r\n     * Helper che identifica se il th attuale è di tipo **EsTh**. In caso contrario è da considerarsi **EsThDirective**\r\n     *\r\n     * @param {any} td Header da valutare\r\n     * @returns {boolean} Restituisce **true** se il **th** è di tipo **EsTh**, **false** se è di tipo **EsThDirective**\r\n     */\r\n    public isEsTh(th: any): th is EsTh { return !th._directive; }\r\n\r\n    /**\r\n     * Date le informazioni di paginazione ottiene l'array dei pulsanti\r\n     *\r\n     * @param {number} maxBtns Numero massimo di pulsanti da visualizzare\r\n     * @param {number} page Pagina corrente\r\n     * @param {number} lastPage Ultima pagina disponibile\r\n     *\r\n     * @returns {any[]} Pseudo-array di pulsanti a cui ci si può bindare lato HTML\r\n     */\r\n    public getPagesArray(maxBtns: number, page: number, lastPage: number, actualCount: number = null, ipp: number = null): any[] {\r\n        let result = [];\r\n\r\n        // Se sono in modalità \"Numero di pagine ed oggetti sconosciuti\" faccio in modo di mostrare la pagina successiva solo se gli items effettivamente pervenuti\r\n        // sono uguali alla paginazione attuale (cioè questa pagina è di sicuro riempita completamente)\r\n        if (lastPage == -1 && ((actualCount == null && ipp == null) || (actualCount == ipp)))\r\n            lastPage = page + 1;\r\n\r\n        // Se sono in modalità \"Numero di pagine ed oggetti sconosciuti\" e mi arrivano 0 oggetti significa che l'ultima pagina è la precedente e non mostro pagine oltre\r\n        if (lastPage == -1 && actualCount == 0)\r\n            lastPage = page;\r\n\r\n        let min, max;\r\n        if (lastPage <= maxBtns) {\r\n            min = 1;\r\n            max = lastPage - 1;\r\n        } else {\r\n            // tolgo la pagina selected è l'ultima pagina che è quella delle pagine totali\r\n            let rangeOutside = (maxBtns - 2) / 2;\r\n\r\n            min = page - rangeOutside;\r\n            max = page + rangeOutside;\r\n\r\n            if (min < 1) {\r\n                min = 1;\r\n                max = maxBtns - 1;\r\n            } else if (max >= lastPage) {\r\n                min = lastPage - maxBtns + 1;\r\n                max = lastPage - 1;\r\n            }\r\n        }\r\n\r\n        result.push({ val: 1, cssClass: (1 === page ? 'btn-main app-white-text' : 'app-white-button') });\r\n\r\n        if (max >= min) {\r\n            for (let i = min; i <= max; i++)\r\n                if (i !== 1)\r\n                    result.push({ val: i, cssClass: (i === page ? 'btn-main app-white-text' : 'app-white-button') });\r\n\r\n            result.push({\r\n                val: lastPage,\r\n                cssClass: (lastPage === page ? 'btn-main app-white-text' : 'app-white-button')\r\n            });\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Calcola l'hash di un oggetto qualsiasi\r\n     *\r\n     * @param {any[]} items Oggetti per cui calcolare l'hash\r\n     */\r\n    public calculateHash(items: any[]) {\r\n        if (!items)\r\n            return;\r\n\r\n        // Supporto a hash duplicati di oggetti uguali\r\n        let usedHashesCache: { [index: string]: number; } = {};\r\n        for (let i = 0; i < items.length; i++) {\r\n            let item = items[i];\r\n\r\n            // Prima di calcolare l'hash rimuovo le proprietà interne per evitare che mi scompensino i calcoli successivi\r\n            let tmp = Object.assign({}, items[i]);\r\n            delete tmp._selected;\r\n            delete tmp._visible;\r\n            delete tmp._hash;\r\n            let hash = this.hashExts.hashObject(tmp);\r\n\r\n            usedHashesCache[hash] = usedHashesCache[hash] ? usedHashesCache[hash] + 1 : 1;\r\n            item._hash = hash + (usedHashesCache[hash] > 1 ? \"_\" + usedHashesCache[hash] : \"\");\r\n        }\r\n    }\r\n\r\n    /**\r\n    * 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)\r\n    * \r\n    * @param {T} inputValue Valore dell'Input\r\n    * @param {T} defaultValue Valore di default impostato da configurazione\r\n    * @param {T} fallbackValue Valore dell'Input per quando non è stato assegnato dal programmatore e non ha un default\r\n    */\r\n    public InputOrDefault<T>(inputValue: T, defaultValue: T, fallbackValue?: T) {\r\n\r\n        // Input valorizzato dal programmatore\r\n        if (inputValue != null && inputValue != undefined)\r\n            return inputValue;\r\n\r\n        // Input valorizzato da configurazione globale\r\n        if (defaultValue != null && defaultValue != undefined)\r\n            return defaultValue;\r\n\r\n        //Input non valorizzato da niente e da nessuno\r\n        if (fallbackValue != null && fallbackValue != undefined)\r\n            return fallbackValue;\r\n\r\n        // I casi in cui si arriva qui sono i casi di Input che di default va bene che siano nulli e che nessuno si caga\r\n        return null;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/directives/es_td.directive.mjs

@@ -0,0 +1,32 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Direttiva per la dichiarazione snella di un EsTd da emettere per ogni elemento, data una colonna */
+export class EsTdDirective {
+    /**
+     * @ignore
+     */
+    constructor(Template) {
+        this.Template = Template;
+        /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsTdComponent */
+        this._directive = true;
+        /** Indica se la cella è visibile o meno di default */
+        this.tdVisible = true;
+        /** Equivalente dell'NgIf sul td */
+        this.tdIf = true;
+    }
+}
+EsTdDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTdDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+EsTdDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: EsTdDirective, selector: "[td]", inputs: { tdVisible: "tdVisible", td: "td", tdIf: "tdIf", tdClass: "tdClass" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTdDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[td]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { tdVisible: [{
+                type: Input
+            }], td: [{
+                type: Input
+            }], tdIf: [{
+                type: Input
+            }], tdClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/es_th.directive.mjs

@@ -0,0 +1,84 @@
+import { Directive, Input } from "@angular/core";
+import * as i0 from "@angular/core";
+/** Direttiva per la dichiarazione snella di un EsTh da emettere come header */
+export class EsThDirective {
+    /**
+     * @ignore
+     */
+    constructor(Template) {
+        this.Template = Template;
+        /** Variabile interna all'interno della quale viene raccolta la cache delle aggregazioni specificate in thAggregation */
+        this._thAggregations = null;
+        /** Variabile interna contenente in maniera ordinata i template dei padri */
+        this._thParents = null;
+        /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsThComponent */
+        this._directive = true;
+        /** Variabile interna impostata dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+        this._referenced = false;
+        /** Id della colonna, dev'essere lo stesso per tutti i **td** relativi */
+        this.th = "";
+        /** Indica se la colonna è pinnata o no */
+        this.thPinned = false;
+        /** Indica le dimensioni che deve avere questa colonna quando viene pinnata, senza questo tutte le colonne mi collasserebbero l'una sull'altra */
+        this.thPinnedWidth = 150;
+        /** Indicazione sulla visibilità della colonna */
+        this.thVisible = true;
+        /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
+        this.thFixed = false;
+        /** Indica che la colonna è sotto ad un raggruppamento padre, con questo nome nel **th** */
+        this.thParent = "";
+        /** Indica se questa colonna è ordinabile o meno */
+        this.thOrderable = true;
+        /** Indica se il testo presente in questo Header può andare a capo o meno, di default non può */
+        this.thWrap = false;
+        /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
+        this.thResizable = false;
+        /** Equivalente dell'NgIf sul th */
+        this.thIf = true;
+        /** Campo particolare che indica che questo header è vuoto. Viene utilizzato solo a livello grafico per ignorare o meno l'emit del template */
+        this.thEmpty = false;
+        /** Indica che bisogna fare un raggruppamento su questa colonna */
+        this.thGroup = false;
+        /** Indica che bisogna fare una aggregazione su questa colonna, a fronte di almeno un altra con un raggruppamento */
+        this.thAggregation = null;
+    }
+}
+EsThDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsThDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+EsThDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: EsThDirective, selector: "[th]", inputs: { th: "th", thPinned: "thPinned", 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" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsThDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[th]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { th: [{
+                type: Input
+            }], thPinned: [{
+                type: Input
+            }], thPinnedWidth: [{
+                type: Input
+            }], thVisible: [{
+                type: Input
+            }], thFixed: [{
+                type: Input
+            }], thParent: [{
+                type: Input
+            }], thOrder: [{
+                type: Input
+            }], thOrderable: [{
+                type: Input
+            }], thWrap: [{
+                type: Input
+            }], thResizable: [{
+                type: Input
+            }], thClass: [{
+                type: Input
+            }], thGroupClass: [{
+                type: Input
+            }], thIf: [{
+                type: Input
+            }], thEmpty: [{
+                type: Input
+            }], thGroup: [{
+                type: Input
+            }], thAggregation: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/es-table.module.mjs

@@ -0,0 +1,79 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { MatSelectModule } from "@angular/material/select";
+import { MatInputModule } from "@angular/material/input";
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { UtilityService, ExportService, HashingService, MessageService } from '@esfaenza/extensions';
+import { LocalizationModule } from '@esfaenza/localizations';
+import { EST_LOCALE, EST_DEBUG } from './tokens';
+import { TablePagerComponent } from './components/pager/table_pager.component';
+import { EsTableComponent } from './components/es-table/es_table.component';
+import { EsTh } from './components/es-th/es_th.component';
+import { EsTd } from './components/es-td/es_td.component';
+import { EsTdDirective } from './directives/es_td.directive';
+import { EsThDirective } from './directives/es_th.directive';
+import { ModalModule } from "ngx-bootstrap/modal";
+import { BsDropdownModule } from "ngx-bootstrap/dropdown";
+import { CsvModule } from "@ctrl/ngx-csv";
+import { ContextMenuModule } from "@esfaenza/ngx-contextmenu";
+import * as i0 from "@angular/core";
+export class EsTableModule {
+    static forRoot(config) {
+        return {
+            ngModule: EsTableModule,
+            providers: [
+                { provide: EST_LOCALE, useValue: config?.locale || 'it-IT' },
+                { provide: EST_DEBUG, useValue: config?.debugMode || false }
+            ]
+        };
+    }
+}
+EsTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+EsTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTableModule, declarations: [EsTh, EsTd, EsTableComponent, EsTdDirective, EsThDirective, TablePagerComponent], imports: [CommonModule,
+        FormsModule,
+        RouterModule,
+        LocalizationModule,
+        ModalModule,
+        BsDropdownModule,
+        CsvModule,
+        ContextMenuModule,
+        MatSelectModule,
+        MatInputModule,
+        DragDropModule], exports: [EsTh, EsTd, EsTableComponent, EsTdDirective, EsThDirective, TablePagerComponent] });
+EsTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTableModule, providers: [UtilityService, ExportService, HashingService, MessageService], imports: [[
+            CommonModule,
+            FormsModule,
+            RouterModule,
+            LocalizationModule,
+            ModalModule,
+            BsDropdownModule,
+            CsvModule,
+            ContextMenuModule,
+            MatSelectModule,
+            MatInputModule,
+            DragDropModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        RouterModule,
+                        LocalizationModule,
+                        ModalModule,
+                        BsDropdownModule,
+                        CsvModule,
+                        ContextMenuModule,
+                        MatSelectModule,
+                        MatInputModule,
+                        DragDropModule
+                    ],
+                    declarations: [EsTh, EsTd, EsTableComponent, EsTdDirective, EsThDirective, TablePagerComponent],
+                    providers: [UtilityService, ExportService, HashingService, MessageService],
+                    exports: [EsTh, EsTd, EsTableComponent, EsTdDirective, EsThDirective, TablePagerComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,14 @@
+/*
+ * Public API Surface of es-table
+ */
+export * from './lib/components/pager/table_pager.component';
+export * from './lib/components/es-table/es_table.component';
+export * from './lib/components/es-th/es_th.component';
+export * from './lib/components/es-td/es_td.component';
+export * from './lib/directives/es_td.directive';
+export * from './lib/directives/es_th.directive';
+export * from './lib/domain/configuration/EsTableModuleConfig';
+export * from './lib/domain/configuration/EsTableDefaultable';
+export * from './lib/es-table.module';
+export * from './lib/domain/externals';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2VzLXRhYmxlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxnREFBZ0QsQ0FBQztBQUMvRCxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBlcy10YWJsZVxyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvcGFnZXIvdGFibGVfcGFnZXIuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9lcy10YWJsZS9lc190YWJsZS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2VzLXRoL2VzX3RoLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXMtdGQvZXNfdGQuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcy9lc190ZC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL2VzX3RoLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RvbWFpbi9jb25maWd1cmF0aW9uL0VzVGFibGVNb2R1bGVDb25maWcnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kb21haW4vY29uZmlndXJhdGlvbi9Fc1RhYmxlRGVmYXVsdGFibGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9lcy10YWJsZS5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kb21haW4vZXh0ZXJuYWxzJzsiXX0=