@esfaenza/es-diagrams 12.2.13 → 13.1.3

package/esm2020/lib/esdiagram.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { EsDiagramComponent } from './components/es-diagram.component';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { EsDiagramService } from './services/es-diagram.service';
+import { EsDiagramDispatcher } from './services/es-diagram.dispatcher';
+import { DIA_LOCALE, DIA_DEBUG_MODE } from './tokens';
+import * as i0 from "@angular/core";
+export class EsDiagramModule {
+    static forRoot(config) {
+        return {
+            ngModule: EsDiagramModule,
+            providers: [
+                EsDiagramService,
+                EsDiagramDispatcher,
+                { provide: DIA_LOCALE, useValue: config?.locale || 'it-IT' },
+                { provide: DIA_DEBUG_MODE, useValue: config?.debugMode || false },
+            ]
+        };
+    }
+}
+EsDiagramModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+EsDiagramModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramModule, declarations: [EsDiagramComponent], imports: [CommonModule, FormsModule, ReactiveFormsModule, CommonModule], exports: [EsDiagramComponent] });
+EsDiagramModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramModule, imports: [[CommonModule, FormsModule, ReactiveFormsModule, CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [EsDiagramComponent],
+                    imports: [CommonModule, FormsModule, ReactiveFormsModule, CommonModule],
+                    exports: [EsDiagramComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/extensions/ReactiveExtensions.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * Classe che fornisce metodi reattivi di estensione. Per ora implementato solo uno pseudo-throttle
+ */
+export class ReactiveExtensions {
+    constructor() {
+        /**
+         * Cache di tutti i timer in esecuzione
+         */
+        this.executionTimers = {};
+    }
+    /**
+     * Esecuzione deleyata di una funzione. Se viene richiamata nuovamente prima di venire eseguita dopo il delay, il delay viene resettato
+     *
+     * @param {string} id Id per aiutare il servizio a distinguere funzioni con nome uguale chiamate da componenti diversi
+     * @param {Function} func Funzione da chiamare al termine del throttle
+     * @param {number} throttleTime Tempo di throttling in millisecondi
+     */
+    throttle(id, func, throttleTime = 0) {
+        let key = func.name + "_" + id;
+        //Se ho la funzione che vuole eseguire ripulisco quel timeout
+        if (this.executionTimers[key])
+            clearTimeout(this.executionTimers[key]);
+        //Ricreo il timeout per eseguire quella funzione dopo throttleTime millisecondi
+        var executionTimer = setTimeout(() => { func(); this.executionTimers[key] = null; }, throttleTime);
+        this.executionTimers[key] = executionTimer;
+    }
+}
+ReactiveExtensions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ReactiveExtensions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ReactiveExtensions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ReactiveExtensions, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ReactiveExtensions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/es-diagram.dispatcher.mjs

@@ -0,0 +1,89 @@
+import { Injectable, Inject } from '@angular/core';
+import { DIA_DEBUG_MODE } from '../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Classe che si occupa del dispatch delle operazioni di rendering degli oggetti utilizzando una coda
+ */
+export class EsDiagramDispatcher {
+    /**
+     * @ignore
+     */
+    constructor(logs) {
+        this.logs = logs;
+        /**
+         * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando oggetti
+         */
+        this.Initializations = [];
+        /**
+         * Lista degli oggetti inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo
+         */
+        this.Initialized = [];
+    }
+    /**
+     * Registra un oggetto da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti gli oggetti
+     * precedentemente registati non hanno finito la fase di inizializzazione
+     *
+     * @param {string} name Identificativo dell'oggetto da registrare
+     * @param {Function} creationFunction Funzione che fisicamente dovrà occuparsi della creazione dell'oggetto
+     */
+    register(name, creationFunction) {
+        if (this.Initialized.indexOf(name) != -1)
+            throw "Attempting to register a duplicate object '" + name + "'. Make sure the 'name' properties of your diagram are univoque";
+        this.log("DISPATCHER: Registering diagram creation function execution for " + name);
+        this.Initializations.push({ name: name, function: creationFunction });
+        if (this.Initializations.length == 1) {
+            this.log("DISPATCHER: Initial drain started");
+            this.drainInitQueues();
+        }
+    }
+    /**
+     * Deregistra un oggetto presente. Chiamata generalmente al dispose dell'oggetto in questione quando non dev'essere più mostrato nella pagina corrente
+     *
+     * @param {string} name Identificativo dell'oggetto da deregistrare
+     */
+    deregister(name) {
+        let index = this.Initialized.indexOf(name);
+        if (index == -1) {
+            //Questo succede quando si cerca di distruggere l'oggetto mentre sta venendo graficato
+            this.log("DISPATCHER: Registration missing for object " + name + " it was probably destroyed during load");
+            return;
+        }
+        this.log("DISPATCHER: Object deregistered " + name);
+        this.Initialized.splice(index, 1);
+    }
+    /**
+     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione degli oggetti finché presenti
+     * in modo che nessun oggetto possa essere inizializzato contemporaneamente ad un altro
+     */
+    drainInitQueues() {
+        let toExecute = this.Initializations[0];
+        this.log("DISPATCHER: Executing initialization function for object " + toExecute.name);
+        toExecute.function().then(() => {
+            this.log("DISPATCHER: initialization for object " + toExecute.name + " is done");
+            this.Initialized.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-diagrams: " + text);
+    }
+}
+EsDiagramDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramDispatcher, deps: [{ token: DIA_DEBUG_MODE }], target: i0.ɵɵFactoryTarget.Injectable });
+EsDiagramDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramDispatcher });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramDispatcher, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DIA_DEBUG_MODE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"es-diagram.dispatcher.js","sourceRoot":"","sources":["../../../../../projects/es-diagrams/src/lib/services/es-diagram.dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;;AAE3C;;GAEG;AAEH,MAAM,OAAO,mBAAmB;IAY5B;;OAEG;IACH,YAA4C,IAAa;QAAb,SAAI,GAAJ,IAAI,CAAS;QAbzD;;WAEG;QACK,oBAAe,GAAsC,EAAE,CAAC;QAEhE;;WAEG;QACK,gBAAW,GAAa,EAAE,CAAC;IAK0B,CAAC;IAE9D;;;;;;OAMG;IACI,QAAQ,CAAC,IAAY,EAAE,gBAA0B;QACpD,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,MAAM,6CAA6C,GAAG,IAAI,GAAG,iEAAiE,CAAC;QAEnI,IAAI,CAAC,GAAG,CAAC,kEAAkE,GAAG,IAAI,CAAC,CAAC;QACpF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC,CAAC;QACtE,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,UAAU,CAAC,IAAY;QAC1B,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,KAAK,IAAI,CAAC,CAAC,EACf;YACI,sFAAsF;YACtF,IAAI,CAAC,GAAG,CAAC,8CAA8C,GAAG,IAAI,GAAG,wCAAwC,CAAC,CAAC;YAC3G,OAAO;SACV;QAED,IAAI,CAAC,GAAG,CAAC,kCAAkC,GAAG,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IACrC,CAAC;IAED;;;OAGG;IACK,eAAe;QACnB,IAAI,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,2DAA2D,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAEvF,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,GAAG,CAAC,wCAAwC,GAAG,SAAS,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC;YACjF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACtC,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,yBAAyB,GAAG,IAAI,CAAC,CAAC;IACtD,CAAC;;gHAjFQ,mBAAmB,kBAeR,cAAc;oHAfzB,mBAAmB;2FAAnB,mBAAmB;kBAD/B,UAAU;;0BAgBM,MAAM;2BAAC,cAAc","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\n\r\nimport { DIA_DEBUG_MODE } from '../tokens';\r\n\r\n/**\r\n * Classe che si occupa del dispatch delle operazioni di rendering degli oggetti utilizzando una coda \r\n */\r\n@Injectable()\r\nexport class EsDiagramDispatcher {\r\n\r\n    /**\r\n     * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando oggetti\r\n     */\r\n    private Initializations: { name: string, function: any }[] = [];\r\n\r\n    /**\r\n     * Lista degli oggetti 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 Initialized: string[] = [];\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    constructor(@Inject(DIA_DEBUG_MODE) private logs: boolean) { }\r\n\r\n    /**\r\n     * Registra un oggetto da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti gli oggetti\r\n     * precedentemente registati non hanno finito la fase di inizializzazione\r\n     * \r\n     * @param {string} name Identificativo dell'oggetto da registrare\r\n     * @param {Function} creationFunction Funzione che fisicamente dovrà occuparsi della creazione dell'oggetto\r\n     */\r\n    public register(name: string, creationFunction: Function) {\r\n        if (this.Initialized.indexOf(name) != -1)\r\n            throw \"Attempting to register a duplicate object '\" + name + \"'. Make sure the 'name' properties of your diagram are univoque\";\r\n\r\n        this.log(\"DISPATCHER: Registering diagram creation function execution for \" + name);\r\n        this.Initializations.push({ name: name, function: creationFunction });\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 oggetto presente. Chiamata generalmente al dispose dell'oggetto in questione quando non dev'essere più mostrato nella pagina corrente\r\n     * \r\n     * @param {string} name Identificativo dell'oggetto da deregistrare\r\n     */\r\n    public deregister(name: string) {\r\n        let index = this.Initialized.indexOf(name);\r\n        if (index == -1)\r\n        {\r\n            //Questo succede quando si cerca di distruggere l'oggetto mentre sta venendo graficato\r\n            this.log(\"DISPATCHER: Registration missing for object \" + name + \" it was probably destroyed during load\");\r\n            return;\r\n        }\r\n\r\n        this.log(\"DISPATCHER: Object deregistered \" + name);\r\n        this.Initialized.splice(index, 1)\r\n    }\r\n\r\n    /**\r\n     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione degli oggetti finché presenti \r\n     * in modo che nessun oggetto possa essere inizializzato contemporaneamente ad un altro\r\n     */\r\n    private drainInitQueues() {\r\n        let toExecute = this.Initializations[0];\r\n        this.log(\"DISPATCHER: Executing initialization function for object \" + toExecute.name);\r\n\r\n        toExecute.function().then(() => {\r\n            this.log(\"DISPATCHER: initialization for object \" + toExecute.name + \" is done\");\r\n            this.Initialized.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-diagrams: \" + text);\r\n    }\r\n}"]}

package/esm2020/lib/services/es-diagram.service.mjs

@@ -0,0 +1,112 @@
+import { Inject, Injectable, Optional } from "@angular/core";
+import { DIA_DEBUG_MODE, DIA_LOCALE } from "../tokens";
+import { Loc } from "../services/es-diagram.loc";
+// Questo modulo esporta sia un namespace che si chiama "cytoscape" sia la funzione "cytoscape" (costruttore)
+// Con questi 2 salti si riescono a non avere problemi di typings: https://github.com/jvandemo/generator-angular2-library/issues/221#issuecomment-355945207
+import * as cy_ from 'cytoscape';
+import * as i0 from "@angular/core";
+/** @ignore */ const cytoscape = cy_;
+/**
+ * Loader dei moduli di Cytoscape. Utilizza una cache per tenerseli in memoria a livello di applicazione
+ * in modo da non dover ricaricare nulla dopo avere usato un modulo almeno una volta
+ */
+export class EsDiagramService {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(DIA_LOCALE, DIA_DEBUG_MODE) {
+        this.DIA_LOCALE = DIA_LOCALE;
+        this.DIA_DEBUG_MODE = DIA_DEBUG_MODE;
+        /**
+         * Cache dei moduli caricati
+         */
+        this.modulesCache = {};
+    }
+    /**
+     * Permette di importare, se serve un dato tema o localizzazione
+     *
+     * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Nome del modulo di Cytoscape da importare (dev'essere il nome della cartella in node_modules)
+     *
+     * @returns {Promise<void | cytoscape.Ext>} Funzione di estensione per Cytoscape presa dal modulo richiesto
+     */
+    async importIfNeeded(moduleId) {
+        // Ognuno esporta il modulo un po' come cazzo gli pare quindi ocio. 
+        // Notare che tutti i "moudle" dopo lo then sono castati ad <any> e che l'oggetto recuperato ogni tanto è "default", altre volte è il "register", altre è l'"ext", eccetera...
+        if (!this.modulesCache[moduleId]) {
+            this.log("I", this.loc("Module not available. Loading it now") + ": " + moduleId, false);
+            switch (moduleId) {
+                case "cytoscape-cxtmenu": return import("cytoscape-cxtmenu").then((module) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));
+                case "cytoscape-expand-collapse": return import("cytoscape-expand-collapse").then((module) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));
+                case "cytoscape-html-node": return import("@esfaenza/cytoscape-html-node").then((module) => this.modulesCache[moduleId] = module.register).catch(err => this.handleError(moduleId, err));
+                case "cytoscape-dagre":
+                    await import("dagre").catch(err => this.handleError("dagre", err));
+                    return import("cytoscape-dagre").then((module) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));
+            }
+        }
+        else {
+            // I moduli non devono mai essere ricaricati nel globale, quindi invece che restituire la copia della cache restituisco vuoto
+            this.log("I", this.loc("Module already loaded") + ": " + moduleId, false);
+            return new Promise((resolve) => { resolve(null); });
+        }
+    }
+    /**
+     * Gestione degli errori di caricamento dei moduli qualora qualcuno utilizzasse un modulo non installato
+     *
+     * @param {string} moduleId Nome del modulo che si è cercato di caricare
+     * @param {any} err Errore restituito dalla promise di caricamento
+     */
+    handleError(moduleId, err) {
+        this.log("E", this.loc("Module cannot be loaded") + ": " + moduleId + " - " + err, false);
+    }
+    /**
+     * Scrittore di log a console. Attivo solo quando la libreria è in modalità di Debug
+     *
+     * @param {'E' | 'I' | 'W'} severity Tipo di messaggio (Errore, Info, Warning)
+     * @param {string} text Testo da tradurre
+     * @param {boolean} requiresTranslation Indica se **text** è una frase già tradotta o se è da tradurre
+     */
+    log(severity, text, requiresTranslation = true) {
+        if (!this.DIA_DEBUG_MODE)
+            return;
+        var message = "@esfaenza/diagrams: " + (requiresTranslation ? this.loc(text) : text);
+        switch (severity) {
+            case 'E':
+                console.error(message);
+                break;
+            case 'I':
+                console.info(message);
+                break;
+            case 'W':
+                console.warn(message);
+                break;
+        }
+    }
+    /**
+     * Metodo di localizzazione dei messaggi
+     *
+     * @param {string} text Messaggio da tradurre
+     *
+     * @returns {string} Messaggio tradotto
+     */
+    loc(text) {
+        return Loc[text][this.DIA_LOCALE];
+    }
+}
+EsDiagramService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramService, deps: [{ token: DIA_LOCALE, optional: true }, { token: DIA_DEBUG_MODE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+EsDiagramService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: EsDiagramService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DIA_LOCALE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DIA_DEBUG_MODE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"es-diagram.service.js","sourceRoot":"","sources":["../../../../../projects/es-diagrams/src/lib/services/es-diagram.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from \"@angular/core\";\r\n\r\nimport { DIA_DEBUG_MODE, DIA_LOCALE } from \"../tokens\";\r\nimport { Loc } from \"../services/es-diagram.loc\";\r\n\r\n// Questo modulo esporta sia un namespace che si chiama \"cytoscape\" sia la funzione \"cytoscape\" (costruttore)\r\n// Con questi 2 salti si riescono a non avere problemi di typings: https://github.com/jvandemo/generator-angular2-library/issues/221#issuecomment-355945207\r\nimport * as cy_ from 'cytoscape';\r\n/** @ignore */ const cytoscape = cy_;\r\n\r\n/**\r\n * Loader dei moduli di Cytoscape. Utilizza una cache per tenerseli in memoria a livello di applicazione \r\n * in modo da non dover ricaricare nulla dopo avere usato un modulo almeno una volta\r\n */\r\n@Injectable()\r\nexport class EsDiagramService {\r\n\r\n    /**\r\n     * Cache dei moduli caricati\r\n     */\r\n    private modulesCache: { [index: string]: cytoscape.Ext } = {};\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    constructor(@Optional() @Inject(DIA_LOCALE) private DIA_LOCALE: string, @Optional() @Inject(DIA_DEBUG_MODE) private DIA_DEBUG_MODE: string) { }\r\n\r\n    /**\r\n     * Permette di importare, se serve un dato tema o localizzazione\r\n     * \r\n     * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Nome del modulo di Cytoscape da importare (dev'essere il nome della cartella in node_modules)\r\n     * \r\n     * @returns {Promise<void | cytoscape.Ext>} Funzione di estensione per Cytoscape presa dal modulo richiesto\r\n     */\r\n    public async importIfNeeded(moduleId: 'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'): Promise<void | cytoscape.Ext> {\r\n\r\n        // Ognuno esporta il modulo un po' come cazzo gli pare quindi ocio. \r\n        // Notare che tutti i \"moudle\" dopo lo then sono castati ad <any> e che l'oggetto recuperato ogni tanto è \"default\", altre volte è il \"register\", altre è l'\"ext\", eccetera...\r\n        if (!this.modulesCache[moduleId]) {\r\n            this.log(\"I\", this.loc(\"Module not available. Loading it now\") + \": \" + moduleId, false);\r\n            switch (moduleId) {\r\n                case \"cytoscape-cxtmenu\": return import(\"cytoscape-cxtmenu\").then((module: any) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));\r\n                case \"cytoscape-expand-collapse\": return import(\"cytoscape-expand-collapse\").then((module: any) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));\r\n                case \"cytoscape-html-node\": return import(\"@esfaenza/cytoscape-html-node\").then((module: any) => this.modulesCache[moduleId] = module.register).catch(err => this.handleError(moduleId, err));\r\n                case \"cytoscape-dagre\":\r\n                    await import(\"dagre\").catch(err => this.handleError(\"dagre\", err));\r\n                    return import(\"cytoscape-dagre\").then((module: any) => this.modulesCache[moduleId] = module.default).catch(err => this.handleError(moduleId, err));\r\n            }\r\n        }\r\n        else {\r\n            // I moduli non devono mai essere ricaricati nel globale, quindi invece che restituire la copia della cache restituisco vuoto\r\n            this.log(\"I\", this.loc(\"Module already loaded\") + \": \" + moduleId, false);\r\n            return new Promise((resolve) => { resolve(null) });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gestione degli errori di caricamento dei moduli qualora qualcuno utilizzasse un modulo non installato\r\n     * \r\n     * @param {string} moduleId Nome del modulo che si è cercato di caricare\r\n     * @param {any} err Errore restituito dalla promise di caricamento\r\n     */\r\n    private handleError(moduleId: string, err: any) {\r\n        this.log(\"E\", this.loc(\"Module cannot be loaded\") + \": \" + moduleId + \" - \" + err, false);\r\n    }\r\n\r\n    /**\r\n     * Scrittore di log a console. Attivo solo quando la libreria è in modalità di Debug\r\n     * \r\n     * @param {'E' | 'I' | 'W'} severity Tipo di messaggio (Errore, Info, Warning)\r\n     * @param {string} text Testo da tradurre\r\n     * @param {boolean} requiresTranslation Indica se **text** è una frase già tradotta o se è da tradurre\r\n     */\r\n    public log(severity: 'E' | 'I' | 'W', text: string, requiresTranslation: boolean = true) {\r\n\r\n        if (!this.DIA_DEBUG_MODE)\r\n            return;\r\n\r\n        var message = \"@esfaenza/diagrams: \" + (requiresTranslation ? this.loc(text) : text);\r\n        switch (severity) {\r\n            case 'E': console.error(message);\r\n                break;\r\n            case 'I': console.info(message);\r\n                break;\r\n            case 'W': console.warn(message);\r\n                break;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo di localizzazione dei messaggi\r\n     * \r\n     * @param {string} text Messaggio da tradurre\r\n     * \r\n     * @returns {string} Messaggio tradotto\r\n     */\r\n    public loc(text: string): string {\r\n        return Loc[text][this.DIA_LOCALE];\r\n    }\r\n}"]}