@esfaenza/es-charts 15.2.7 → 16.2.0

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

@@ -1,91 +1,91 @@
-import { Injectable, Inject } from '@angular/core';
-import { ESC_DEBUG_MODE } from '../../tokens';
-import * as i0 from "@angular/core";
-/**
- * Classe che si occupa del dispatch delle operazioni di rendering dei grafici utilizzando una coda per permettere ad ogni grafico di avere temi e localizzazione custom
- */
-export class ChartDispatcher {
-    /**
-     * @ignore
-     */
-    constructor(logs) {
-        this.logs = logs;
-        /**
-         * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando grafici
-         */
-        this.Initializations = [];
-        /**
-         * Lista dei grafici inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo
-         */
-        this.InitializedGraphs = [];
-    }
-    /**
-     * Registra un grafico da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti i grafici
-     * precedentemente registati non hanno finito la fase di inizializzazione
-     *
-     * @param {string} name Identificativo del grafico da registrare
-     * @param {Function} chartCreationFunction Funzione che fisicamente dovrà occuparsi della creazione del grafico
-     */
-    register(name, chartCreationFunction) {
-        if (this.InitializedGraphs.indexOf(name) != -1)
-            throw "Attempting to register a duplicate chart '" + name + "'. Make sure the 'name' properties of your charts are univoque";
-        this.log("DISPATCHER: Registering chart creation function execution for " + name);
-        this.Initializations.push({ name: name, function: chartCreationFunction });
-        if (this.Initializations.length == 1) {
-            this.log("DISPATCHER: Initial drain started");
-            this.drainInitQueues();
-        }
-    }
-    /**
-     * Deregistra un grafico presente. Chiamata generalmente al dispose del grafico in questione quando non dev'essere più mostrato nella pagina corrente
-     *
-     * @param {string} name Identificativo del grafico da deregistrare
-     */
-    deregisterGraph(name) {
-        let index = this.InitializedGraphs.indexOf(name);
-        if (index == -1) {
-            //Questo succede quando si cerca di distruggere il grafico mentre sta venendo graficato
-            this.log("DISPATCHER: Registration missing for chart " + name + " it was probably destroyed during load");
-            return;
-        }
-        this.log("DISPATCHER: Chart deregistered " + name);
-        this.InitializedGraphs.splice(index, 1);
-    }
-    /**
-     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione dei grafici finché presenti
-     * in modo che nessun grafico possa essere inizializzato contemporaneamente ad un altro.
-     *
-     * Questo è il punto chiave che permette di avere per ogni grafico temi e locale differenti
-     */
-    drainInitQueues() {
-        let toExecute = this.Initializations[0];
-        this.log("DISPATCHER: Executing initialization function for chart " + toExecute.name);
-        toExecute.function().then(() => {
-            this.log("DISPATCHER: initialization for chart " + toExecute.name + " is done");
-            this.InitializedGraphs.push(toExecute.name);
-            this.Initializations.splice(0, 1);
-            if (this.Initializations.length >= 1) {
-                this.log("DISPATCHER: Found queued initializations. Continuing");
-                this.drainInitQueues();
-            }
-            else
-                this.log("DISPATCHER: queue is over, nothing more to do");
-        });
-    }
-    /**
-     * @ignore
-     */
-    log(text) {
-        if (this.logs)
-            console.log("@esfaenza/es-charts: " + text);
-    }
-}
-ChartDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartDispatcher, deps: [{ token: ESC_DEBUG_MODE }], target: i0.ɵɵFactoryTarget.Injectable });
-ChartDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartDispatcher });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ChartDispatcher, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [ESC_DEBUG_MODE]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChartDispatcher.js","sourceRoot":"","sources":["../../../../../../projects/es-charts/src/lib/models/core/ChartDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;;AAE9C;;GAEG;AAEH,MAAM,OAAO,eAAe;IAYxB;;OAEG;IACH,YAA4C,IAAa;QAAb,SAAI,GAAJ,IAAI,CAAS;QAbzD;;WAEG;QACK,oBAAe,GAAsC,EAAE,CAAC;QAEhE;;WAEG;QACK,sBAAiB,GAAa,EAAE,CAAC;IAKoB,CAAC;IAE9D;;;;;;OAMG;IACI,QAAQ,CAAC,IAAY,EAAE,qBAA+B;QACzD,IAAI,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,4CAA4C,GAAG,IAAI,GAAG,gEAAgE,CAAC;QAEjI,IAAI,CAAC,GAAG,CAAC,gEAAgE,GAAG,IAAI,CAAC,CAAC;QAClF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC,CAAC;QAC3E,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,CAAC,EAAE;YAClC,IAAI,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;YAC9C,IAAI,CAAC,eAAe,EAAE,CAAC;SAC1B;IACL,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,IAAY;QAC/B,IAAI,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,KAAK,IAAI,CAAC,CAAC,EACf;YACI,uFAAuF;YACvF,IAAI,CAAC,GAAG,CAAC,6CAA6C,GAAG,IAAI,GAAG,wCAAwC,CAAC,CAAC;YAC1G,OAAO;SACV;QAED,IAAI,CAAC,GAAG,CAAC,iCAAiC,GAAG,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC3C,CAAC;IAED;;;;;OAKG;IACK,eAAe;QACnB,IAAI,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,0DAA0D,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAEtF,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,GAAG,CAAC,uCAAuC,GAAG,SAAS,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC;YAChF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAClC,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,CAAC,EAAE;gBAClC,IAAI,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAC;gBACjE,IAAI,CAAC,eAAe,EAAE,CAAC;aAC1B;;gBAEG,IAAI,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,GAAG,CAAC,IAAY;QACpB,IAAI,IAAI,CAAC,IAAI;YACT,OAAO,CAAC,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IACpD,CAAC;;4GAnFQ,eAAe,kBAeJ,cAAc;gHAfzB,eAAe;2FAAf,eAAe;kBAD3B,UAAU;;0BAgBM,MAAM;2BAAC,cAAc","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\n\r\nimport { ESC_DEBUG_MODE } from '../../tokens';\r\n\r\n/**\r\n * Classe che si occupa del dispatch delle operazioni di rendering dei grafici utilizzando una coda per permettere ad ogni grafico di avere temi e localizzazione custom\r\n */\r\n@Injectable()\r\nexport class ChartDispatcher {\r\n\r\n    /**\r\n     * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando grafici\r\n     */\r\n    private Initializations: { name: string, function: any }[] = [];\r\n\r\n    /**\r\n     * Lista dei grafici inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo\r\n     */\r\n    private InitializedGraphs: string[] = [];\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     * Registra un grafico da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti i grafici\r\n     * precedentemente registati non hanno finito la fase di inizializzazione\r\n     * \r\n     * @param {string} name Identificativo del grafico da registrare\r\n     * @param {Function} chartCreationFunction Funzione che fisicamente dovrà occuparsi della creazione del grafico\r\n     */\r\n    public register(name: string, chartCreationFunction: Function) {\r\n        if (this.InitializedGraphs.indexOf(name) != -1)\r\n            throw \"Attempting to register a duplicate chart '\" + name + \"'. Make sure the 'name' properties of your charts are univoque\";\r\n\r\n        this.log(\"DISPATCHER: Registering chart creation function execution for \" + name);\r\n        this.Initializations.push({ name: name, function: chartCreationFunction });\r\n        if (this.Initializations.length == 1) {\r\n            this.log(\"DISPATCHER: Initial drain started\");\r\n            this.drainInitQueues();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Deregistra un grafico presente. Chiamata generalmente al dispose del grafico in questione quando non dev'essere più mostrato nella pagina corrente\r\n     * \r\n     * @param {string} name Identificativo del grafico da deregistrare\r\n     */\r\n    public deregisterGraph(name: string) {\r\n        let index = this.InitializedGraphs.indexOf(name);\r\n        if (index == -1)\r\n        {\r\n            //Questo succede quando si cerca di distruggere il grafico mentre sta venendo graficato\r\n            this.log(\"DISPATCHER: Registration missing for chart \" + name + \" it was probably destroyed during load\");\r\n            return;\r\n        }\r\n\r\n        this.log(\"DISPATCHER: Chart deregistered \" + name);\r\n        this.InitializedGraphs.splice(index, 1)\r\n    }\r\n\r\n    /**\r\n     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione dei grafici finché presenti \r\n     * in modo che nessun grafico possa essere inizializzato contemporaneamente ad un altro.\r\n     * \r\n     * Questo è il punto chiave che permette di avere per ogni grafico temi e locale differenti\r\n     */\r\n    private drainInitQueues() {\r\n        let toExecute = this.Initializations[0];\r\n        this.log(\"DISPATCHER: Executing initialization function for chart \" + toExecute.name);\r\n\r\n        toExecute.function().then(() => {\r\n            this.log(\"DISPATCHER: initialization for chart \" + toExecute.name + \" is done\");\r\n            this.InitializedGraphs.push(toExecute.name);\r\n            this.Initializations.splice(0, 1);\r\n            if (this.Initializations.length >= 1) {\r\n                this.log(\"DISPATCHER: Found queued initializations. Continuing\");\r\n                this.drainInitQueues();\r\n            }\r\n            else\r\n                this.log(\"DISPATCHER: queue is over, nothing more to do\");\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    private log(text: string) {\r\n        if (this.logs)\r\n            console.log(\"@esfaenza/es-charts: \" + text);\r\n    }\r\n}"]}
+import { Injectable, Inject } from '@angular/core';
+import { ESC_DEBUG_MODE } from '../../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Classe che si occupa del dispatch delle operazioni di rendering dei grafici utilizzando una coda per permettere ad ogni grafico di avere temi e localizzazione custom
+ */
+export class ChartDispatcher {
+    /**
+     * @ignore
+     */
+    constructor(logs) {
+        this.logs = logs;
+        /**
+         * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando grafici
+         */
+        this.Initializations = [];
+        /**
+         * Lista dei grafici inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo
+         */
+        this.InitializedGraphs = [];
+    }
+    /**
+     * Registra un grafico da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti i grafici
+     * precedentemente registati non hanno finito la fase di inizializzazione
+     *
+     * @param {string} name Identificativo del grafico da registrare
+     * @param {Function} chartCreationFunction Funzione che fisicamente dovrà occuparsi della creazione del grafico
+     */
+    register(name, chartCreationFunction) {
+        if (this.InitializedGraphs.indexOf(name) != -1)
+            throw "Attempting to register a duplicate chart '" + name + "'. Make sure the 'name' properties of your charts are univoque";
+        this.log("DISPATCHER: Registering chart creation function execution for " + name);
+        this.Initializations.push({ name: name, function: chartCreationFunction });
+        if (this.Initializations.length == 1) {
+            this.log("DISPATCHER: Initial drain started");
+            this.drainInitQueues();
+        }
+    }
+    /**
+     * Deregistra un grafico presente. Chiamata generalmente al dispose del grafico in questione quando non dev'essere più mostrato nella pagina corrente
+     *
+     * @param {string} name Identificativo del grafico da deregistrare
+     */
+    deregisterGraph(name) {
+        let index = this.InitializedGraphs.indexOf(name);
+        if (index == -1) {
+            //Questo succede quando si cerca di distruggere il grafico mentre sta venendo graficato
+            this.log("DISPATCHER: Registration missing for chart " + name + " it was probably destroyed during load");
+            return;
+        }
+        this.log("DISPATCHER: Chart deregistered " + name);
+        this.InitializedGraphs.splice(index, 1);
+    }
+    /**
+     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione dei grafici finché presenti
+     * in modo che nessun grafico possa essere inizializzato contemporaneamente ad un altro.
+     *
+     * Questo è il punto chiave che permette di avere per ogni grafico temi e locale differenti
+     */
+    drainInitQueues() {
+        let toExecute = this.Initializations[0];
+        this.log("DISPATCHER: Executing initialization function for chart " + toExecute.name);
+        toExecute.function().then(() => {
+            this.log("DISPATCHER: initialization for chart " + toExecute.name + " is done");
+            this.InitializedGraphs.push(toExecute.name);
+            this.Initializations.splice(0, 1);
+            if (this.Initializations.length >= 1) {
+                this.log("DISPATCHER: Found queued initializations. Continuing");
+                this.drainInitQueues();
+            }
+            else
+                this.log("DISPATCHER: queue is over, nothing more to do");
+        });
+    }
+    /**
+     * @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: ChartDispatcher, 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: ChartDispatcher }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChartDispatcher, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ESC_DEBUG_MODE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChartDispatcher.js","sourceRoot":"","sources":["../../../../../../projects/es-charts/src/lib/models/core/ChartDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;;AAE9C;;GAEG;AAEH,MAAM,OAAO,eAAe;IAYxB;;OAEG;IACH,YAA4C,IAAa;QAAb,SAAI,GAAJ,IAAI,CAAS;QAbzD;;WAEG;QACK,oBAAe,GAAsC,EAAE,CAAC;QAEhE;;WAEG;QACK,sBAAiB,GAAa,EAAE,CAAC;IAKoB,CAAC;IAE9D;;;;;;OAMG;IACI,QAAQ,CAAC,IAAY,EAAE,qBAA+B;QACzD,IAAI,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,4CAA4C,GAAG,IAAI,GAAG,gEAAgE,CAAC;QAEjI,IAAI,CAAC,GAAG,CAAC,gEAAgE,GAAG,IAAI,CAAC,CAAC;QAClF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC,CAAC;QAC3E,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,CAAC,EAAE;YAClC,IAAI,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;YAC9C,IAAI,CAAC,eAAe,EAAE,CAAC;SAC1B;IACL,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,IAAY;QAC/B,IAAI,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,KAAK,IAAI,CAAC,CAAC,EACf;YACI,uFAAuF;YACvF,IAAI,CAAC,GAAG,CAAC,6CAA6C,GAAG,IAAI,GAAG,wCAAwC,CAAC,CAAC;YAC1G,OAAO;SACV;QAED,IAAI,CAAC,GAAG,CAAC,iCAAiC,GAAG,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC3C,CAAC;IAED;;;;;OAKG;IACK,eAAe;QACnB,IAAI,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,0DAA0D,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAEtF,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,GAAG,CAAC,uCAAuC,GAAG,SAAS,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC;YAChF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAClC,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,IAAI,CAAC,EAAE;gBAClC,IAAI,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAC;gBACjE,IAAI,CAAC,eAAe,EAAE,CAAC;aAC1B;;gBAEG,IAAI,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,GAAG,CAAC,IAAY;QACpB,IAAI,IAAI,CAAC,IAAI;YACT,OAAO,CAAC,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IACpD,CAAC;+GAnFQ,eAAe,kBAeJ,cAAc;mHAfzB,eAAe;;4FAAf,eAAe;kBAD3B,UAAU;;0BAgBM,MAAM;2BAAC,cAAc","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\n\r\nimport { ESC_DEBUG_MODE } from '../../tokens';\r\n\r\n/**\r\n * Classe che si occupa del dispatch delle operazioni di rendering dei grafici utilizzando una coda per permettere ad ogni grafico di avere temi e localizzazione custom\r\n */\r\n@Injectable()\r\nexport class ChartDispatcher {\r\n\r\n    /**\r\n     * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando grafici\r\n     */\r\n    private Initializations: { name: string, function: any }[] = [];\r\n\r\n    /**\r\n     * Lista dei grafici inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo\r\n     */\r\n    private InitializedGraphs: string[] = [];\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     * Registra un grafico da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti i grafici\r\n     * precedentemente registati non hanno finito la fase di inizializzazione\r\n     * \r\n     * @param {string} name Identificativo del grafico da registrare\r\n     * @param {Function} chartCreationFunction Funzione che fisicamente dovrà occuparsi della creazione del grafico\r\n     */\r\n    public register(name: string, chartCreationFunction: Function) {\r\n        if (this.InitializedGraphs.indexOf(name) != -1)\r\n            throw \"Attempting to register a duplicate chart '\" + name + \"'. Make sure the 'name' properties of your charts are univoque\";\r\n\r\n        this.log(\"DISPATCHER: Registering chart creation function execution for \" + name);\r\n        this.Initializations.push({ name: name, function: chartCreationFunction });\r\n        if (this.Initializations.length == 1) {\r\n            this.log(\"DISPATCHER: Initial drain started\");\r\n            this.drainInitQueues();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Deregistra un grafico presente. Chiamata generalmente al dispose del grafico in questione quando non dev'essere più mostrato nella pagina corrente\r\n     * \r\n     * @param {string} name Identificativo del grafico da deregistrare\r\n     */\r\n    public deregisterGraph(name: string) {\r\n        let index = this.InitializedGraphs.indexOf(name);\r\n        if (index == -1)\r\n        {\r\n            //Questo succede quando si cerca di distruggere il grafico mentre sta venendo graficato\r\n            this.log(\"DISPATCHER: Registration missing for chart \" + name + \" it was probably destroyed during load\");\r\n            return;\r\n        }\r\n\r\n        this.log(\"DISPATCHER: Chart deregistered \" + name);\r\n        this.InitializedGraphs.splice(index, 1)\r\n    }\r\n\r\n    /**\r\n     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione dei grafici finché presenti \r\n     * in modo che nessun grafico possa essere inizializzato contemporaneamente ad un altro.\r\n     * \r\n     * Questo è il punto chiave che permette di avere per ogni grafico temi e locale differenti\r\n     */\r\n    private drainInitQueues() {\r\n        let toExecute = this.Initializations[0];\r\n        this.log(\"DISPATCHER: Executing initialization function for chart \" + toExecute.name);\r\n\r\n        toExecute.function().then(() => {\r\n            this.log(\"DISPATCHER: initialization for chart \" + toExecute.name + \" is done\");\r\n            this.InitializedGraphs.push(toExecute.name);\r\n            this.Initializations.splice(0, 1);\r\n            if (this.Initializations.length >= 1) {\r\n                this.log(\"DISPATCHER: Found queued initializations. Continuing\");\r\n                this.drainInitQueues();\r\n            }\r\n            else\r\n                this.log(\"DISPATCHER: queue is over, nothing more to do\");\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    private log(text: string) {\r\n        if (this.logs)\r\n            console.log(\"@esfaenza/es-charts: \" + text);\r\n    }\r\n}"]}