@esfaenza/es-diagrams 11.0.2

package/esm2015/lib/services/es-diagram.dispatcher.js

@@ -0,0 +1,86 @@
+import { Injectable, Inject } from '@angular/core';
+import { DIA_DEBUG_MODE } from '../tokens';
+/**
+ * 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.decorators = [
+    { type: Injectable }
+];
+EsDiagramDispatcher.ctorParameters = () => [
+    { type: Boolean, decorators: [{ type: Inject, args: [DIA_DEBUG_MODE,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/es-diagram.loc.js

@@ -0,0 +1,17 @@
+/**
+ * Oggetto statico di localizzazione per i messaggi
+ */
+export const Loc = {
+    "Module": { "en-US": "Module", "it-IT": "Il Modulo" },
+    "Received an undefined module. Make sure you are correctly loading it": { "en-US": "Received an undefined module. Make sure you are correctly loading it", "it-IT": "Ricevuto modulo non definito. Assicurati di caricarlo correttamente" },
+    "Module not available. Loading it now": { "en-US": "Module not available. Loading it now", "it-IT": "Modulo non disponibile. Lo carico ora" },
+    "Module already loaded": { "en-US": "Module already loaded", "it-IT": "Modulo già caricato" },
+    "Diagram container size has changed, redrawing": { "en-US": "Diagram container size has changed, redrawing", "it-IT": "La dimensione del contenitore del diagramma è cambiata, ridisegno" },
+    "Module cannot be loaded": { "en-US": "Module cannot be loaded", "it-IT": "Impossibile caricare il modulo" },
+    "Redraw based on dynamic Input change is supported only for 'Elements' and 'Layout' inputs, please destroy the component and recreate it with the new settings": { "en-US": "Redraw based on dynamic Input change is supported only for 'Elements' and 'Layout' inputs, please destroy the component and recreate it with the new settings", "it-IT": "Il cambio e aggiornamento dinamico degli Input è supportato solo per gli Input 'Elements' e 'Layout', distruggi il componente e ricrealo con le nuove impostazioni", },
+    "is loaded and managed directly by this library. You don't need to import it or use it directly, just be sure to set the relative options": { "en-US": "is loaded and managed directly by this library. You don't need to import it or use it directly, just be sure to set the relative options", "it-IT": "viene caricato e gestito nativamente dalla libreria. Non c'è bisogno di reimportarlo, né di configurarlo (usare le opzioni specifiche)" },
+    "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}": { "en-US": "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}", "it-IT": "Se non è specificata una sorgente e una destinazione per il collegamento è opportuno scriverne l'id nel formato {sorgente}-{destinazione}" },
+    "Elements have been changed after diagram initialization": { "en-US": "Elements have been changed after diagram initialization", "it-IT": "Rilevato un cambio di Elementi dopo l'inizializzazione del Diagramma" },
+    "Layout have been changed after diagram initialization": { "en-US": "Layout have been changed after diagram initialization", "it-IT": "Rilevato un cambio di Layout dopo l'inizializzazione del Diagramma" }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/es-diagram.service.js

@@ -0,0 +1,106 @@
+import { __awaiter } from "tslib";
+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';
+/** @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
+     */
+    importIfNeeded(moduleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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":
+                        yield 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.decorators = [
+    { type: Injectable }
+];
+EsDiagramService.ctorParameters = () => [
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [DIA_LOCALE,] }] },
+    { type: String, 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}"]}

package/esm2015/lib/tokens.js

@@ -0,0 +1,10 @@
+import { InjectionToken } from "@angular/core";
+/**
+ * Token che indica la lingua da utilizzare, sono supportate "it-IT" ed "en-US"
+ */
+export const DIA_LOCALE = new InjectionToken('DIA_LOCALE');
+/**
+ * Token che indica se attivare la modalità di debug (messaggi a console)
+ */
+export const DIA_DEBUG_MODE = new InjectionToken('DIA_DEBUG_MODE');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZXMtZGlhZ3JhbXMvc3JjL2xpYi90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQzs7R0FFRztBQUNGLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBMkIsSUFBSSxjQUFjLENBQVMsWUFBWSxDQUFDLENBQUM7QUFFM0Y7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQTRCLElBQUksY0FBYyxDQUFVLGdCQUFnQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG4vKipcclxuICogVG9rZW4gY2hlIGluZGljYSBsYSBsaW5ndWEgZGEgdXRpbGl6emFyZSwgc29ubyBzdXBwb3J0YXRlIFwiaXQtSVRcIiBlZCBcImVuLVVTXCJcclxuICovXHJcbiBleHBvcnQgY29uc3QgRElBX0xPQ0FMRTogSW5qZWN0aW9uVG9rZW48c3RyaW5nPiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmc+KCdESUFfTE9DQUxFJyk7XHJcblxyXG4gLyoqXHJcbiAgKiBUb2tlbiBjaGUgaW5kaWNhIHNlIGF0dGl2YXJlIGxhIG1vZGFsaXTDoCBkaSBkZWJ1ZyAobWVzc2FnZ2kgYSBjb25zb2xlKVxyXG4gICovXHJcbiBleHBvcnQgY29uc3QgRElBX0RFQlVHX01PREU6IEluamVjdGlvblRva2VuPGJvb2xlYW4+ID0gbmV3IEluamVjdGlvblRva2VuPGJvb2xlYW4+KCdESUFfREVCVUdfTU9ERScpOyJdfQ==

package/esm2015/public-api.js

@@ -0,0 +1,24 @@
+/*
+ * Public API Surface of cytoscape-angular
+ */
+export * from './lib/models/component/contextmenu/ContextMenuCommand';
+export * from './lib/models/component/contextmenu/ContextMenuOptions';
+export * from './lib/models/component/grouping/ExpandCollapseOptions';
+export * from './lib/models/component/nodes/NodeHTMLTemplate';
+export * from './lib/models/component/nodes/NodeTemplate';
+export * from './lib/models/component/nodes/ZoomLevelBasedTemplate';
+export * from './lib/models/layouts/base/BaseLayoutOptionsImpl';
+export * from './lib/models/layouts/BreadthFirstLayoutOptionsImpl';
+export * from './lib/models/layouts/CircleLayoutOptionsImpl';
+export * from './lib/models/layouts/ConcentricLayoutOptionsImpl';
+export * from './lib/models/layouts/CoseLayoutOptionsImpl';
+export * from './lib/models/layouts/DagreLayoutOptionsImpl';
+export * from './lib/models/layouts/GridLayoutOptionsImpl';
+export * from './lib/models/layouts/NullLayoutOptionsImpl';
+export * from './lib/models/layouts/PresetLayoutOptionsImpl';
+export * from './lib/models/layouts/RandomLayoutOptionsImpl';
+export * from './lib/models/layouts/base/ShapedLayoutOptionsImpl';
+export * from './lib/models/EsDiagramModuleConfig';
+export * from './lib/components/es-diagram.component';
+export * from './lib/esdiagram.module';
+//# sourceMappingURL=data:application/json;base64,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