@esfaenza/es-charts 15.2.7 → 16.2.0

package/{esm2020 → esm2022}/lib/models/core/ChartLoader.mjs

@@ -1,212 +1,212 @@
-import { Inject, Injectable } from '@angular/core';
-import { ChartThemes } from './ChartThemes';
-import { ESC_DEBUG_MODE } from '../../tokens';
-import * as i0 from "@angular/core";
-/**
- * Classe di supporto al caricamento dinamico dei vari pezzi di amcharts che mi servono per il grafico (temi, locali, ecc...)
- *
- * Essenzialmente ogni volta che viene creato un grafico, questo acquisisce il tema e il locale applicato IN QUEL MOMENTO,
- * questo significa che per creare due grafici con temi diversi bisogna fare:
- *
- * 1) Caricamento tema 1
- *
- * 2) Creazione grafico 1
- *
- * 3) Scaricamento tema 1
- *
- * 3) Caricamento tema 2
- *
- * 4) Creazione grafico 2
- *
- */
-export class ChartLoader {
-    /**
-     * @ignore
-     */
-    constructor(logs) {
-        this.logs = logs;
-        /**
-         * Indica se attualmente ho le animazioni caricate in modo da non ricaricarle inutilmente
-         */
-        this.AnimationsAreLoaded = false;
-        /**
-         * Indica l'ultimo tema caricato in modo da non ricaricarlo inutilmente qualora il prossimo grafico da creare richieda lo stesso tema
-         */
-        this.LastLoadedTheme = "";
-        /**
-         * Cache dei temi (moduli caricati dinamicamente)
-         */
-        this.themeCache = {};
-        /**
-         * Cache delle localizzazioni (moduli caricati dinamicamente)
-         */
-        this.localizationCache = {};
-    }
-    /**
-     * Applica il tema con le animazioni all'istanza globale di amCharts
-     *
-     * @param {Object} chartsCore Istanza globale di amCharts
-     * @returns {Promise} Promise che identifica la fine del caricamento
-     */
-    applyAnimations(chartsCore) {
-        if (!this.AnimationsAreLoaded) {
-            return this.importIfNeeded('themes', ChartThemes.animated).then(() => {
-                this.log("CORE: Applying theme " + ChartThemes.animated);
-                chartsCore.useTheme(this.themeCache[ChartThemes.animated]);
-                this.AnimationsAreLoaded = true;
-            });
-        }
-        else {
-            this.log("CORE: theme already applyed " + ChartThemes.animated);
-            return new Promise((resolve) => { resolve(true); });
-        }
-    }
-    /**
-     * De-applica il tema con le animazioni dall'istanza globale di amCharts
-     *
-     * @param {Object} chartsCore Istanza globale di amCharts
-     * @returns {Promise} Promise che identifica la fine dello scarico
-     */
-    unapplyAnimations(chartsCore) {
-        if (this.AnimationsAreLoaded) {
-            this.log("CORE: Animations in use, unapplying theme " + ChartThemes.animated);
-            chartsCore.unuseTheme(this.themeCache[ChartThemes.animated]);
-            this.AnimationsAreLoaded = false;
-        }
-        else
-            this.log("CORE: Animations already unused, no need to unapply them");
-        return new Promise((resolve) => { resolve(true); });
-    }
-    /**
-     * Applica il tema specificato all'istanza globale di amCharts
-     *
-     * @param {Object} chartsCore Istanza globale di amCharts
-     * @param {'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'} theme Tema da applicare
-     * @returns {Promise} Promise che identifica la fine del caricamento
-     */
-    applyTheme(chartsCore, theme) {
-        // Ultimo tema applicato è lo stesso che mi è stato richiesto di applicare --> NO-OP
-        if (this.LastLoadedTheme == theme) {
-            this.log("CORE: theme already applied " + theme);
-            return new Promise((resolve) => { resolve(true); });
-        }
-        // Scarico il tema precedente a prescindere, ormai non mi serve più
-        this.unapplyPreviousTheme(chartsCore);
-        // Il tema è il none --> registro la cosa e basta, il tema precedente è stato rimosso subito qui sopra ^
-        if (theme == ChartThemes.none) {
-            this.LastLoadedTheme = ChartThemes.none;
-            return new Promise((resolve) => { resolve(true); });
-        }
-        // Il tema è diverso dal precedente e non è il tema vuoto --> Importo il tema specificato se non presente in memoria e lo applico al grafico attuale
-        return this.importIfNeeded('themes', theme).then(() => {
-            this.log("CORE: Applying theme " + theme);
-            chartsCore.useTheme(this.themeCache[theme]);
-            this.LastLoadedTheme = theme;
-        });
-    }
-    /**
-     * De-applica il tema precedente dall'istanza globale di amCharts
-     *
-     * @param {Object} chartsCore Istanza globale di amCharts
-     */
-    unapplyPreviousTheme(chartsCore) {
-        if (!this.LastLoadedTheme || this.LastLoadedTheme == ChartThemes.none)
-            return;
-        this.log("CORE: Unapplying previously used theme " + this.LastLoadedTheme);
-        chartsCore.unuseTheme(this.themeCache[this.LastLoadedTheme]);
-    }
-    /**
-     * Applica il locale specificato all'istanza specifica del grafico
-     *
-     * @param {amCharts.Chart} chart Istanza specifica del grafico a cui applicare il locale
-     * @param {string} locale Locale da applicare
-     * @returns {Promise} Promise che identifica la fine del caricamento
-     */
-    applyLocale(chart, locale) {
-        return this.importIfNeeded('lang', locale).then(() => {
-            this.log("Chart " + chart.htmlContainer.id + ": applying locale " + locale);
-            chart.language.locale = this.localizationCache[locale];
-        });
-    }
-    /**
-     * Permette di importare, se serve un dato tema o localizzazione
-     *
-     * @param {'lang' | 'themes'} what Oggetto da importare, se localizzazione o tema
-     * @param {string} item Chiave dell'oggetto da importare
-     *
-     * @returns {Promise} Promise che identifica la fine del caricamento
-     */
-    importIfNeeded(what, item) {
-        // Se sto cercando di caricare qualcosa di già caricato non faccio nulla
-        if (!(what == 'themes' && !this.themeCache[item]) && !(what == 'lang' && !this.localizationCache[item])) {
-            this.log("CORE: " + (what == 'lang' ? "Language " : "Theme ") + item + " already loaded");
-            return new Promise((resolve) => { resolve(true); });
-        }
-        this.log("CORE: Loading " + (what == 'lang' ? "language " : "theme ") + item);
-        /*
-         *                               ****************************
-         *                               ******** ATTENZIONE ********
-         *                               ****************************
-         *
-         *  Se stai vedendo questo codice di import e stai valutando di riscriverlo come:
-         *
-         *                                     V       V
-         *      import(`@amcharts/amcharts4/${what}/${item}`).then(module => {
-         *        if (what == 'themes') this.themeCache[item] = module.default;
-         *        else if (what == 'lang') this.localizationCache[item] = module.default;
-         *      });
-         *
-         *  Sappi che è una pessima idea. Gli import sono valutati da webpack in compiletime per generare i chunk,
-         *  mettere la navigazione agli import con la concatenazione viene preso malissimo ed essenzialmente dice a webpack
-         *  di tirare su e bundlare l'intera node_modules. Divertente, no?
-         *
-         */
-        switch (what) {
-            case 'themes':
-                switch (item) {
-                    case ChartThemes.spiritedaway:
-                        return import("@amcharts/amcharts4/themes/spiritedaway").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.moonrisekingdom:
-                        return import("@amcharts/amcharts4/themes/moonrisekingdom").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.frozen:
-                        return import("@amcharts/amcharts4/themes/frozen").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.dark:
-                        return import("@amcharts/amcharts4/themes/dark").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.kelly:
-                        return import("@amcharts/amcharts4/themes/kelly").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.material:
-                        return import("@amcharts/amcharts4/themes/material").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.dataviz:
-                        return import("@amcharts/amcharts4/themes/dataviz").then(theme => this.themeCache[item] = theme.default);
-                    case ChartThemes.animated:
-                        return import("@amcharts/amcharts4/themes/animated").then(theme => this.themeCache[item] = theme.default);
-                }
-                break;
-            case 'lang':
-                switch (item) {
-                    case 'it-IT':
-                        return import("@amcharts/amcharts4/lang/it_IT").then(lang => this.localizationCache[item] = lang.default);
-                    case 'en-US':
-                        return import("@amcharts/amcharts4/lang/en_US").then(lang => this.localizationCache[item] = lang.default);
-                }
-        }
-        this.log("CORE: Loading Failed. " + (what == 'lang' ? "Language " : "Theme") + " not recognized: " + item);
-        return new Promise((resolve) => { resolve(true); });
-    }
-    /**
-     * @ignore
-     */
-    log(text) {
-        if (this.logs)
-            console.log("@esfaenza/es-charts: " + text);
-    }
-}
-ChartLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartLoader, deps: [{ token: ESC_DEBUG_MODE }], target: i0.ɵɵFactoryTarget.Injectable });
-ChartLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartLoader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartLoader, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [ESC_DEBUG_MODE]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChartLoader.js","sourceRoot":"","sources":["../../../../../../projects/es-charts/src/lib/models/core/ChartLoader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;;AAG9C;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,OAAO,WAAW;IAsBtB;;OAEG;IACH,YAA4C,IAAa;QAAb,SAAI,GAAJ,IAAI,CAAS;QAvBzD;;WAEG;QACK,wBAAmB,GAAY,KAAK,CAAC;QAE7C;;WAEG;QACK,oBAAe,GAAW,EAAE,CAAC;QAErC;;WAEG;QACK,eAAU,GAAO,EAAE,CAAC;QAE5B;;WAEG;QACK,sBAAiB,GAAO,EAAE,CAAC;IAK0B,CAAC;IAE9D;;;;;OAKG;IACI,eAAe,CAAC,UAAe;QACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC7B,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBACnE,IAAI,CAAC,GAAG,CAAC,uBAAuB,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;gBACzD,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC3D,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAClC,CAAC,CAAC,CAAC;SACJ;aACI;YACH,IAAI,CAAC,GAAG,CAAC,8BAA8B,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;YAChE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;SACpD;IACH,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,UAAe;QAC/B,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,GAAG,CAAC,4CAA4C,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;YAC9E,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC7D,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;SAClC;;YAEC,IAAI,CAAC,GAAG,CAAC,0DAA0D,CAAC,CAAC;QACvE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,UAAe,EAAE,KAAyG;QACnI,oFAAoF;QACpF,IAAI,IAAI,CAAC,eAAe,IAAI,KAAK,EAAE;YACjC,IAAI,CAAC,GAAG,CAAC,8BAA8B,GAAG,KAAK,CAAC,CAAC;YACjD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;SACpD;QAED,mEAAmE;QACnE,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAA;QAErC,wGAAwG;QACxG,IAAI,KAAK,IAAI,WAAW,CAAC,IAAI,EAAE;YAC7B,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC;YACxC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;SACpD;QAED,oJAAoJ;QACpJ,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YACpD,IAAI,CAAC,GAAG,CAAC,uBAAuB,GAAG,KAAK,CAAC,CAAC;YAC1C,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,UAAe;QAClC,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,IAAI,WAAW,CAAC,IAAI;YACnE,OAAO;QAET,IAAI,CAAC,GAAG,CAAC,yCAAyC,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC;QAC3E,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAA;IAC9D,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,KAAU,EAAE,MAAc;QACpC,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YACnD,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,KAAK,CAAC,aAAa,CAAC,EAAE,GAAG,oBAAoB,GAAG,MAAM,CAAC,CAAC;YAC5E,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,IAAuB,EAAE,IAAY;QAElD,wEAAwE;QACxE,IAAI,CAAC,CAAC,IAAI,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE;YACvG,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,iBAAiB,CAAC,CAAC;YAC1F,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;SACpD;QAED,IAAI,CAAC,GAAG,CAAC,gBAAgB,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QAE9E;;;;;;;;;;;;;;;;;WAiBG;QAEH,QAAQ,IAAI,EAAE;YACZ,KAAK,QAAQ;gBACX,QAAQ,IAAI,EAAE;oBACZ,KAAK,WAAW,CAAC,YAAY;wBAC3B,OAAO,MAAM,CAAC,yCAAyC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBAChH,KAAK,WAAW,CAAC,eAAe;wBAC9B,OAAO,MAAM,CAAC,4CAA4C,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBACnH,KAAK,WAAW,CAAC,MAAM;wBACrB,OAAO,MAAM,CAAC,mCAAmC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC1G,KAAK,WAAW,CAAC,IAAI;wBACnB,OAAO,MAAM,CAAC,iCAAiC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBACxG,KAAK,WAAW,CAAC,KAAK;wBACpB,OAAO,MAAM,CAAC,kCAAkC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBACzG,KAAK,WAAW,CAAC,QAAQ;wBACvB,OAAO,MAAM,CAAC,qCAAqC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC5G,KAAK,WAAW,CAAC,OAAO;wBACtB,OAAO,MAAM,CAAC,oCAAoC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC3G,KAAK,WAAW,CAAC,QAAQ;wBACvB,OAAO,MAAM,CAAC,qCAAqC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;iBAC7G;gBACD,MAAM;YACR,KAAK,MAAM;gBACT,QAAQ,IAAI,EAAE;oBACZ,KAAK,OAAO;wBACV,OAAO,MAAM,CAAC,gCAAgC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;oBAC5G,KAAK,OAAO;wBACV,OAAO,MAAM,CAAC,gCAAgC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;iBAC7G;SACJ;QAED,IAAI,CAAC,GAAG,CAAC,wBAAwB,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,mBAAmB,GAAG,IAAI,CAAC,CAAC;QAC3G,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAAY;QACd,IAAI,IAAI,CAAC,IAAI;YACX,OAAO,CAAC,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IAChD,CAAC;;wGAvMU,WAAW,kBAyBF,cAAc;4GAzBvB,WAAW;2FAAX,WAAW;kBADvB,UAAU;;0BA0BI,MAAM;2BAAC,cAAc","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { ChartThemes } from './ChartThemes'\r\nimport { ESC_DEBUG_MODE } from '../../tokens';\r\nimport { EsChartsModule } from '../../es-charts.module';\r\n\r\n/**\r\n * Classe di supporto al caricamento dinamico dei vari pezzi di amcharts che mi servono per il grafico (temi, locali, ecc...)\r\n * \r\n * Essenzialmente ogni volta che viene creato un grafico, questo acquisisce il tema e il locale applicato IN QUEL MOMENTO,\r\n * questo significa che per creare due grafici con temi diversi bisogna fare:\r\n * \r\n * 1) Caricamento tema 1\r\n * \r\n * 2) Creazione grafico 1\r\n * \r\n * 3) Scaricamento tema 1\r\n * \r\n * 3) Caricamento tema 2\r\n * \r\n * 4) Creazione grafico 2\r\n * \r\n */\r\n@Injectable()\r\nexport class ChartLoader {\r\n\r\n  /**\r\n   * Indica se attualmente ho le animazioni caricate in modo da non ricaricarle inutilmente\r\n   */\r\n  private AnimationsAreLoaded: boolean = false;\r\n\r\n  /**\r\n   * Indica l'ultimo tema caricato in modo da non ricaricarlo inutilmente qualora il prossimo grafico da creare richieda lo stesso tema\r\n   */\r\n  private LastLoadedTheme: string = \"\";\r\n\r\n  /**\r\n   * Cache dei temi (moduli caricati dinamicamente)\r\n   */\r\n  private themeCache: {} = {};\r\n\r\n  /**\r\n   * Cache delle localizzazioni (moduli caricati dinamicamente)\r\n   */\r\n  private localizationCache: {} = {};\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  constructor(@Inject(ESC_DEBUG_MODE) private logs: boolean) { }\r\n\r\n  /**\r\n   * Applica il tema con le animazioni all'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  public applyAnimations(chartsCore: any): Promise<any> {\r\n    if (!this.AnimationsAreLoaded) {\r\n      return this.importIfNeeded('themes', ChartThemes.animated).then(() => {\r\n        this.log(\"CORE: Applying theme \" + ChartThemes.animated);\r\n        chartsCore.useTheme(this.themeCache[ChartThemes.animated]);\r\n        this.AnimationsAreLoaded = true;\r\n      });\r\n    }\r\n    else {\r\n      this.log(\"CORE: theme already applyed \" + ChartThemes.animated);\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * De-applica il tema con le animazioni dall'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @returns {Promise} Promise che identifica la fine dello scarico\r\n   */\r\n  unapplyAnimations(chartsCore: any): Promise<any> {\r\n    if (this.AnimationsAreLoaded) {\r\n      this.log(\"CORE: Animations in use, unapplying theme \" + ChartThemes.animated);\r\n      chartsCore.unuseTheme(this.themeCache[ChartThemes.animated]);\r\n      this.AnimationsAreLoaded = false;\r\n    }\r\n    else\r\n      this.log(\"CORE: Animations already unused, no need to unapply them\");\r\n    return new Promise((resolve) => { resolve(true) });\r\n  }\r\n\r\n  /**\r\n   * Applica il tema specificato all'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @param {'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'} theme Tema da applicare\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  applyTheme(chartsCore: any, theme: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'): Promise<any> {\r\n    // Ultimo tema applicato è lo stesso che mi è stato richiesto di applicare --> NO-OP\r\n    if (this.LastLoadedTheme == theme) {\r\n      this.log(\"CORE: theme already applied \" + theme);\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    // Scarico il tema precedente a prescindere, ormai non mi serve più\r\n    this.unapplyPreviousTheme(chartsCore)\r\n\r\n    // Il tema è il none --> registro la cosa e basta, il tema precedente è stato rimosso subito qui sopra ^\r\n    if (theme == ChartThemes.none) {\r\n      this.LastLoadedTheme = ChartThemes.none;\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    // Il tema è diverso dal precedente e non è il tema vuoto --> Importo il tema specificato se non presente in memoria e lo applico al grafico attuale\r\n    return this.importIfNeeded('themes', theme).then(() => {\r\n      this.log(\"CORE: Applying theme \" + theme);\r\n      chartsCore.useTheme(this.themeCache[theme]);\r\n      this.LastLoadedTheme = theme;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * De-applica il tema precedente dall'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   */\r\n  unapplyPreviousTheme(chartsCore: any) {\r\n    if (!this.LastLoadedTheme || this.LastLoadedTheme == ChartThemes.none)\r\n      return;\r\n\r\n    this.log(\"CORE: Unapplying previously used theme \" + this.LastLoadedTheme);\r\n    chartsCore.unuseTheme(this.themeCache[this.LastLoadedTheme])\r\n  }\r\n\r\n  /**\r\n   * Applica il locale specificato all'istanza specifica del grafico\r\n   * \r\n   * @param {amCharts.Chart} chart Istanza specifica del grafico a cui applicare il locale\r\n   * @param {string} locale Locale da applicare\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  applyLocale(chart: any, locale: string): Promise<any> {\r\n    return this.importIfNeeded('lang', locale).then(() => {\r\n      this.log(\"Chart \" + chart.htmlContainer.id + \": applying locale \" + locale);\r\n      chart.language.locale = this.localizationCache[locale];\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Permette di importare, se serve un dato tema o localizzazione\r\n   * \r\n   * @param {'lang' | 'themes'} what Oggetto da importare, se localizzazione o tema\r\n   * @param {string} item Chiave dell'oggetto da importare\r\n   * \r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  importIfNeeded(what: 'lang' | 'themes', item: string): Promise<any> {\r\n\r\n    // Se sto cercando di caricare qualcosa di già caricato non faccio nulla\r\n    if (!(what == 'themes' && !this.themeCache[item]) && !(what == 'lang' && !this.localizationCache[item])) {\r\n      this.log(\"CORE: \" + (what == 'lang' ? \"Language \" : \"Theme \") + item + \" already loaded\");\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    this.log(\"CORE: Loading \" + (what == 'lang' ? \"language \" : \"theme \") + item);\r\n\r\n    /*\r\n     *                               ****************************\r\n     *                               ******** ATTENZIONE ********\r\n     *                               ****************************\r\n     * \r\n     *  Se stai vedendo questo codice di import e stai valutando di riscriverlo come:\r\n     * \r\n     *                                     V       V   \r\n     *      import(`@amcharts/amcharts4/${what}/${item}`).then(module => {\r\n     *        if (what == 'themes') this.themeCache[item] = module.default;\r\n     *        else if (what == 'lang') this.localizationCache[item] = module.default;\r\n     *      });\r\n     * \r\n     *  Sappi che è una pessima idea. Gli import sono valutati da webpack in compiletime per generare i chunk,\r\n     *  mettere la navigazione agli import con la concatenazione viene preso malissimo ed essenzialmente dice a webpack\r\n     *  di tirare su e bundlare l'intera node_modules. Divertente, no?\r\n     *\r\n     */\r\n\r\n    switch (what) {\r\n      case 'themes':\r\n        switch (item) {\r\n          case ChartThemes.spiritedaway:\r\n            return import(\"@amcharts/amcharts4/themes/spiritedaway\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.moonrisekingdom:\r\n            return import(\"@amcharts/amcharts4/themes/moonrisekingdom\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.frozen:\r\n            return import(\"@amcharts/amcharts4/themes/frozen\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.dark:\r\n            return import(\"@amcharts/amcharts4/themes/dark\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.kelly:\r\n            return import(\"@amcharts/amcharts4/themes/kelly\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.material:\r\n            return import(\"@amcharts/amcharts4/themes/material\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.dataviz:\r\n            return import(\"@amcharts/amcharts4/themes/dataviz\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.animated:\r\n            return import(\"@amcharts/amcharts4/themes/animated\").then(theme => this.themeCache[item] = theme.default);\r\n        }\r\n        break;\r\n      case 'lang':\r\n        switch (item) {\r\n          case 'it-IT':\r\n            return import(\"@amcharts/amcharts4/lang/it_IT\").then(lang => this.localizationCache[item] = lang.default);\r\n          case 'en-US':\r\n            return import(\"@amcharts/amcharts4/lang/en_US\").then(lang => this.localizationCache[item] = lang.default);\r\n        }\r\n    }\r\n\r\n    this.log(\"CORE: Loading Failed. \" + (what == 'lang' ? \"Language \" : \"Theme\") + \" not recognized: \" + item);\r\n    return new Promise((resolve) => { resolve(true) });\r\n  }\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  log(text: string) {\r\n    if (this.logs)\r\n      console.log(\"@esfaenza/es-charts: \" + text);\r\n  }\r\n}"]}
+import { Inject, Injectable } from '@angular/core';
+import { ChartThemes } from './ChartThemes';
+import { ESC_DEBUG_MODE } from '../../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Classe di supporto al caricamento dinamico dei vari pezzi di amcharts che mi servono per il grafico (temi, locali, ecc...)
+ *
+ * Essenzialmente ogni volta che viene creato un grafico, questo acquisisce il tema e il locale applicato IN QUEL MOMENTO,
+ * questo significa che per creare due grafici con temi diversi bisogna fare:
+ *
+ * 1) Caricamento tema 1
+ *
+ * 2) Creazione grafico 1
+ *
+ * 3) Scaricamento tema 1
+ *
+ * 3) Caricamento tema 2
+ *
+ * 4) Creazione grafico 2
+ *
+ */
+export class ChartLoader {
+    /**
+     * @ignore
+     */
+    constructor(logs) {
+        this.logs = logs;
+        /**
+         * Indica se attualmente ho le animazioni caricate in modo da non ricaricarle inutilmente
+         */
+        this.AnimationsAreLoaded = false;
+        /**
+         * Indica l'ultimo tema caricato in modo da non ricaricarlo inutilmente qualora il prossimo grafico da creare richieda lo stesso tema
+         */
+        this.LastLoadedTheme = "";
+        /**
+         * Cache dei temi (moduli caricati dinamicamente)
+         */
+        this.themeCache = {};
+        /**
+         * Cache delle localizzazioni (moduli caricati dinamicamente)
+         */
+        this.localizationCache = {};
+    }
+    /**
+     * Applica il tema con le animazioni all'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyAnimations(chartsCore) {
+        if (!this.AnimationsAreLoaded) {
+            return this.importIfNeeded('themes', ChartThemes.animated).then(() => {
+                this.log("CORE: Applying theme " + ChartThemes.animated);
+                chartsCore.useTheme(this.themeCache[ChartThemes.animated]);
+                this.AnimationsAreLoaded = true;
+            });
+        }
+        else {
+            this.log("CORE: theme already applyed " + ChartThemes.animated);
+            return new Promise((resolve) => { resolve(true); });
+        }
+    }
+    /**
+     * De-applica il tema con le animazioni dall'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @returns {Promise} Promise che identifica la fine dello scarico
+     */
+    unapplyAnimations(chartsCore) {
+        if (this.AnimationsAreLoaded) {
+            this.log("CORE: Animations in use, unapplying theme " + ChartThemes.animated);
+            chartsCore.unuseTheme(this.themeCache[ChartThemes.animated]);
+            this.AnimationsAreLoaded = false;
+        }
+        else
+            this.log("CORE: Animations already unused, no need to unapply them");
+        return new Promise((resolve) => { resolve(true); });
+    }
+    /**
+     * Applica il tema specificato all'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @param {'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'} theme Tema da applicare
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyTheme(chartsCore, theme) {
+        // Ultimo tema applicato è lo stesso che mi è stato richiesto di applicare --> NO-OP
+        if (this.LastLoadedTheme == theme) {
+            this.log("CORE: theme already applied " + theme);
+            return new Promise((resolve) => { resolve(true); });
+        }
+        // Scarico il tema precedente a prescindere, ormai non mi serve più
+        this.unapplyPreviousTheme(chartsCore);
+        // Il tema è il none --> registro la cosa e basta, il tema precedente è stato rimosso subito qui sopra ^
+        if (theme == ChartThemes.none) {
+            this.LastLoadedTheme = ChartThemes.none;
+            return new Promise((resolve) => { resolve(true); });
+        }
+        // Il tema è diverso dal precedente e non è il tema vuoto --> Importo il tema specificato se non presente in memoria e lo applico al grafico attuale
+        return this.importIfNeeded('themes', theme).then(() => {
+            this.log("CORE: Applying theme " + theme);
+            chartsCore.useTheme(this.themeCache[theme]);
+            this.LastLoadedTheme = theme;
+        });
+    }
+    /**
+     * De-applica il tema precedente dall'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     */
+    unapplyPreviousTheme(chartsCore) {
+        if (!this.LastLoadedTheme || this.LastLoadedTheme == ChartThemes.none)
+            return;
+        this.log("CORE: Unapplying previously used theme " + this.LastLoadedTheme);
+        chartsCore.unuseTheme(this.themeCache[this.LastLoadedTheme]);
+    }
+    /**
+     * Applica il locale specificato all'istanza specifica del grafico
+     *
+     * @param {amCharts.Chart} chart Istanza specifica del grafico a cui applicare il locale
+     * @param {string} locale Locale da applicare
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyLocale(chart, locale) {
+        return this.importIfNeeded('lang', locale).then(() => {
+            this.log("Chart " + chart.htmlContainer.id + ": applying locale " + locale);
+            chart.language.locale = this.localizationCache[locale];
+        });
+    }
+    /**
+     * Permette di importare, se serve un dato tema o localizzazione
+     *
+     * @param {'lang' | 'themes'} what Oggetto da importare, se localizzazione o tema
+     * @param {string} item Chiave dell'oggetto da importare
+     *
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    importIfNeeded(what, item) {
+        // Se sto cercando di caricare qualcosa di già caricato non faccio nulla
+        if (!(what == 'themes' && !this.themeCache[item]) && !(what == 'lang' && !this.localizationCache[item])) {
+            this.log("CORE: " + (what == 'lang' ? "Language " : "Theme ") + item + " already loaded");
+            return new Promise((resolve) => { resolve(true); });
+        }
+        this.log("CORE: Loading " + (what == 'lang' ? "language " : "theme ") + item);
+        /*
+         *                               ****************************
+         *                               ******** ATTENZIONE ********
+         *                               ****************************
+         *
+         *  Se stai vedendo questo codice di import e stai valutando di riscriverlo come:
+         *
+         *                                     V       V
+         *      import(`@amcharts/amcharts4/${what}/${item}`).then(module => {
+         *        if (what == 'themes') this.themeCache[item] = module.default;
+         *        else if (what == 'lang') this.localizationCache[item] = module.default;
+         *      });
+         *
+         *  Sappi che è una pessima idea. Gli import sono valutati da webpack in compiletime per generare i chunk,
+         *  mettere la navigazione agli import con la concatenazione viene preso malissimo ed essenzialmente dice a webpack
+         *  di tirare su e bundlare l'intera node_modules. Divertente, no?
+         *
+         */
+        switch (what) {
+            case 'themes':
+                switch (item) {
+                    case ChartThemes.spiritedaway:
+                        return import("@amcharts/amcharts4/themes/spiritedaway").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.moonrisekingdom:
+                        return import("@amcharts/amcharts4/themes/moonrisekingdom").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.frozen:
+                        return import("@amcharts/amcharts4/themes/frozen").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.dark:
+                        return import("@amcharts/amcharts4/themes/dark").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.kelly:
+                        return import("@amcharts/amcharts4/themes/kelly").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.material:
+                        return import("@amcharts/amcharts4/themes/material").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.dataviz:
+                        return import("@amcharts/amcharts4/themes/dataviz").then(theme => this.themeCache[item] = theme.default);
+                    case ChartThemes.animated:
+                        return import("@amcharts/amcharts4/themes/animated").then(theme => this.themeCache[item] = theme.default);
+                }
+                break;
+            case 'lang':
+                switch (item) {
+                    case 'it-IT':
+                        return import("@amcharts/amcharts4/lang/it_IT").then(lang => this.localizationCache[item] = lang.default);
+                    case 'en-US':
+                        return import("@amcharts/amcharts4/lang/en_US").then(lang => this.localizationCache[item] = lang.default);
+                }
+        }
+        this.log("CORE: Loading Failed. " + (what == 'lang' ? "Language " : "Theme") + " not recognized: " + item);
+        return new Promise((resolve) => { resolve(true); });
+    }
+    /**
+     * @ignore
+     */
+    log(text) {
+        if (this.logs)
+            console.log("@esfaenza/es-charts: " + text);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChartLoader, deps: [{ token: ESC_DEBUG_MODE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChartLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChartLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ESC_DEBUG_MODE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChartLoader.js","sourceRoot":"","sources":["../../../../../../projects/es-charts/src/lib/models/core/ChartLoader.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { ChartThemes } from './ChartThemes'\r\nimport { ESC_DEBUG_MODE } from '../../tokens';\r\nimport { EsChartsModule } from '../../es-charts.module';\r\n\r\n/**\r\n * Classe di supporto al caricamento dinamico dei vari pezzi di amcharts che mi servono per il grafico (temi, locali, ecc...)\r\n * \r\n * Essenzialmente ogni volta che viene creato un grafico, questo acquisisce il tema e il locale applicato IN QUEL MOMENTO,\r\n * questo significa che per creare due grafici con temi diversi bisogna fare:\r\n * \r\n * 1) Caricamento tema 1\r\n * \r\n * 2) Creazione grafico 1\r\n * \r\n * 3) Scaricamento tema 1\r\n * \r\n * 3) Caricamento tema 2\r\n * \r\n * 4) Creazione grafico 2\r\n * \r\n */\r\n@Injectable()\r\nexport class ChartLoader {\r\n\r\n  /**\r\n   * Indica se attualmente ho le animazioni caricate in modo da non ricaricarle inutilmente\r\n   */\r\n  private AnimationsAreLoaded: boolean = false;\r\n\r\n  /**\r\n   * Indica l'ultimo tema caricato in modo da non ricaricarlo inutilmente qualora il prossimo grafico da creare richieda lo stesso tema\r\n   */\r\n  private LastLoadedTheme: string = \"\";\r\n\r\n  /**\r\n   * Cache dei temi (moduli caricati dinamicamente)\r\n   */\r\n  private themeCache: {} = {};\r\n\r\n  /**\r\n   * Cache delle localizzazioni (moduli caricati dinamicamente)\r\n   */\r\n  private localizationCache: {} = {};\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  constructor(@Inject(ESC_DEBUG_MODE) private logs: boolean) { }\r\n\r\n  /**\r\n   * Applica il tema con le animazioni all'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  public applyAnimations(chartsCore: any): Promise<any> {\r\n    if (!this.AnimationsAreLoaded) {\r\n      return this.importIfNeeded('themes', ChartThemes.animated).then(() => {\r\n        this.log(\"CORE: Applying theme \" + ChartThemes.animated);\r\n        chartsCore.useTheme(this.themeCache[ChartThemes.animated]);\r\n        this.AnimationsAreLoaded = true;\r\n      });\r\n    }\r\n    else {\r\n      this.log(\"CORE: theme already applyed \" + ChartThemes.animated);\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * De-applica il tema con le animazioni dall'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @returns {Promise} Promise che identifica la fine dello scarico\r\n   */\r\n  unapplyAnimations(chartsCore: any): Promise<any> {\r\n    if (this.AnimationsAreLoaded) {\r\n      this.log(\"CORE: Animations in use, unapplying theme \" + ChartThemes.animated);\r\n      chartsCore.unuseTheme(this.themeCache[ChartThemes.animated]);\r\n      this.AnimationsAreLoaded = false;\r\n    }\r\n    else\r\n      this.log(\"CORE: Animations already unused, no need to unapply them\");\r\n    return new Promise((resolve) => { resolve(true) });\r\n  }\r\n\r\n  /**\r\n   * Applica il tema specificato all'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   * @param {'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'} theme Tema da applicare\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  applyTheme(chartsCore: any, theme: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'): Promise<any> {\r\n    // Ultimo tema applicato è lo stesso che mi è stato richiesto di applicare --> NO-OP\r\n    if (this.LastLoadedTheme == theme) {\r\n      this.log(\"CORE: theme already applied \" + theme);\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    // Scarico il tema precedente a prescindere, ormai non mi serve più\r\n    this.unapplyPreviousTheme(chartsCore)\r\n\r\n    // Il tema è il none --> registro la cosa e basta, il tema precedente è stato rimosso subito qui sopra ^\r\n    if (theme == ChartThemes.none) {\r\n      this.LastLoadedTheme = ChartThemes.none;\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    // Il tema è diverso dal precedente e non è il tema vuoto --> Importo il tema specificato se non presente in memoria e lo applico al grafico attuale\r\n    return this.importIfNeeded('themes', theme).then(() => {\r\n      this.log(\"CORE: Applying theme \" + theme);\r\n      chartsCore.useTheme(this.themeCache[theme]);\r\n      this.LastLoadedTheme = theme;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * De-applica il tema precedente dall'istanza globale di amCharts\r\n   * \r\n   * @param {Object} chartsCore Istanza globale di amCharts\r\n   */\r\n  unapplyPreviousTheme(chartsCore: any) {\r\n    if (!this.LastLoadedTheme || this.LastLoadedTheme == ChartThemes.none)\r\n      return;\r\n\r\n    this.log(\"CORE: Unapplying previously used theme \" + this.LastLoadedTheme);\r\n    chartsCore.unuseTheme(this.themeCache[this.LastLoadedTheme])\r\n  }\r\n\r\n  /**\r\n   * Applica il locale specificato all'istanza specifica del grafico\r\n   * \r\n   * @param {amCharts.Chart} chart Istanza specifica del grafico a cui applicare il locale\r\n   * @param {string} locale Locale da applicare\r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  applyLocale(chart: any, locale: string): Promise<any> {\r\n    return this.importIfNeeded('lang', locale).then(() => {\r\n      this.log(\"Chart \" + chart.htmlContainer.id + \": applying locale \" + locale);\r\n      chart.language.locale = this.localizationCache[locale];\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Permette di importare, se serve un dato tema o localizzazione\r\n   * \r\n   * @param {'lang' | 'themes'} what Oggetto da importare, se localizzazione o tema\r\n   * @param {string} item Chiave dell'oggetto da importare\r\n   * \r\n   * @returns {Promise} Promise che identifica la fine del caricamento\r\n   */\r\n  importIfNeeded(what: 'lang' | 'themes', item: string): Promise<any> {\r\n\r\n    // Se sto cercando di caricare qualcosa di già caricato non faccio nulla\r\n    if (!(what == 'themes' && !this.themeCache[item]) && !(what == 'lang' && !this.localizationCache[item])) {\r\n      this.log(\"CORE: \" + (what == 'lang' ? \"Language \" : \"Theme \") + item + \" already loaded\");\r\n      return new Promise((resolve) => { resolve(true) });\r\n    }\r\n\r\n    this.log(\"CORE: Loading \" + (what == 'lang' ? \"language \" : \"theme \") + item);\r\n\r\n    /*\r\n     *                               ****************************\r\n     *                               ******** ATTENZIONE ********\r\n     *                               ****************************\r\n     * \r\n     *  Se stai vedendo questo codice di import e stai valutando di riscriverlo come:\r\n     * \r\n     *                                     V       V   \r\n     *      import(`@amcharts/amcharts4/${what}/${item}`).then(module => {\r\n     *        if (what == 'themes') this.themeCache[item] = module.default;\r\n     *        else if (what == 'lang') this.localizationCache[item] = module.default;\r\n     *      });\r\n     * \r\n     *  Sappi che è una pessima idea. Gli import sono valutati da webpack in compiletime per generare i chunk,\r\n     *  mettere la navigazione agli import con la concatenazione viene preso malissimo ed essenzialmente dice a webpack\r\n     *  di tirare su e bundlare l'intera node_modules. Divertente, no?\r\n     *\r\n     */\r\n\r\n    switch (what) {\r\n      case 'themes':\r\n        switch (item) {\r\n          case ChartThemes.spiritedaway:\r\n            return import(\"@amcharts/amcharts4/themes/spiritedaway\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.moonrisekingdom:\r\n            return import(\"@amcharts/amcharts4/themes/moonrisekingdom\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.frozen:\r\n            return import(\"@amcharts/amcharts4/themes/frozen\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.dark:\r\n            return import(\"@amcharts/amcharts4/themes/dark\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.kelly:\r\n            return import(\"@amcharts/amcharts4/themes/kelly\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.material:\r\n            return import(\"@amcharts/amcharts4/themes/material\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.dataviz:\r\n            return import(\"@amcharts/amcharts4/themes/dataviz\").then(theme => this.themeCache[item] = theme.default);\r\n          case ChartThemes.animated:\r\n            return import(\"@amcharts/amcharts4/themes/animated\").then(theme => this.themeCache[item] = theme.default);\r\n        }\r\n        break;\r\n      case 'lang':\r\n        switch (item) {\r\n          case 'it-IT':\r\n            return import(\"@amcharts/amcharts4/lang/it_IT\").then(lang => this.localizationCache[item] = lang.default);\r\n          case 'en-US':\r\n            return import(\"@amcharts/amcharts4/lang/en_US\").then(lang => this.localizationCache[item] = lang.default);\r\n        }\r\n    }\r\n\r\n    this.log(\"CORE: Loading Failed. \" + (what == 'lang' ? \"Language \" : \"Theme\") + \" not recognized: \" + item);\r\n    return new Promise((resolve) => { resolve(true) });\r\n  }\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  log(text: string) {\r\n    if (this.logs)\r\n      console.log(\"@esfaenza/es-charts: \" + text);\r\n  }\r\n}"]}