@esfaenza/es-diagrams 11.0.2

package/esm2015/lib/components/es-diagram.component.js

@@ -0,0 +1,396 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, Input, Optional, Output, ViewChild } from '@angular/core';
+import { EsDiagramService } from '../services/es-diagram.service';
+import { EsDiagramDispatcher } from '../services/es-diagram.dispatcher';
+import { ResizeSensor } from "../extensions/ResizeSensor";
+import { ReactiveExtensions } from '../extensions/ReactiveExtensions';
+import * as cy_ from 'cytoscape';
+/** @ignore */ const cytoscape = cy_;
+/**
+ * Componente che si occupa di graficare un diagramma e di gestirne il ciclo di vita
+ */
+export class EsDiagramComponent {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(service, dispatcher, exts) {
+        this.service = service;
+        this.dispatcher = dispatcher;
+        this.exts = exts;
+        /**
+         * Nome del diagramma, fondamentale assegnarlo per permettere alla libreria di schedularne la creazione
+         */
+        this.name = "";
+        /**
+         * Indica se utilizzare il menù contestuale a ruota attorno ad ogni nodo
+         */
+        this.UseContextMenu = false;
+        /**
+         * Dice al componente se il diagramma deve utilizzare il sistema di estensione per l'expand e collapse dei gruppi
+         */
+        this.UseExpandCollapse = false;
+        /**
+         * Blocco completo delle opzioni, alternativo all'assegnazione di **Elements**, **NodeStyles**, **EdgeStyles**, e **Layout**.
+         *
+         * Qualora entrambe venissero specificate verrà effettuata un'unione fra queste opzioni e quelle specificate, dando priorità alle specificate
+         */
+        this.NativeOptions = {};
+        /**
+         * Aggiorna automaticamente le dimensioni del diagramma quando cambiano le dimensioni della finestra
+         */
+        this.AutoupdateSize = true;
+        /**
+         * Indica di mantenere la posizione dei nodi qualora venissero cambiati dall'Input **Elements**.
+         *
+         * Se l'ID di un nodo è uguale all'ID di un nodo presente in precedenza, il nuovo nodo ne erediterà la posizione
+         */
+        this.PreserveElementsPosition = true;
+        /**
+         * Qualora venisse modificato l'Input **Elements**, piuttosto che mettere semplicemente il nuovo Elemento in base al Layout precedente, applica anche un'animazione
+         *
+         * Funziona solamente se il **Layout** corrente del diagramma supporta le animazioni
+         */
+        this.AnimateLayoutChanges = true;
+        /**
+         * Periodo di throttle da quando viene effettuato un resize a quando ricalcolare le dimensioni del diagramma.
+         *
+         * Può essere tenuto a 0 (redraw istantaneo) finché non ci sono problemi di prestazioni con eventualmente tanti resize a poca distanza l'uno dall'altro.
+         */
+        this.ResizeThrottleTime = 0;
+        /**
+         * Fornisce il global della libreria (namespace **cytoscape**) e si aspetta che dopo operazioni di importazione
+         * lasciate all'utente vengano aggiunti tutti i moduli desiderati.
+         *
+         * È **fondamentale** che il primo parametro (il nome del modulo) sia uguale a ciò di cui viene fatto il require in modo che la libreria
+         * possa controllare che il modulo importato non sia già stato importato in precedenza
+         *
+         * ## Esempio:
+         *
+         * ```typescript
+         * (global) => {
+         *    return import("cytoscape-extension-library").then(module => global.use("cytoscape-extension-library", module.default));
+         *
+         *    ...
+         * }
+         * ```
+         */
+        this.ExtensionModulesImporter = null;
+        /**
+         * Fornisce l'istanza attuale di Cytoscape da cui è possibile prendere le librerie di estensione caricate in **ExtensionModulesImporter**
+         * e configurarle in base ai comportamenti specifici
+         *
+         * ## Esempio:
+         *
+         * ```typescript
+         * (cytoscapeCore) => {
+         *    // Fare questo lavoro per ogni estensione caricata
+         *    let extensionConfiguration = { ... };
+         *    let extensionInstance = cytoscapeCore.extensionLibrary(extensionConfiguration);
+         *    extensionInstance.doSomethingSpecificToThisExtension();
+         *
+         *    ...
+         * }
+         * ```
+         */
+        this.ExtensionModulesApplyer = null;
+        /**
+         * Evento lanciato al click di un nodo, contiene l'oggetto **data** del nodo in questione
+         */
+        this.onNodeClick = new EventEmitter();
+        /**
+         * Indica se il rendering del diagramma è terminato
+         */
+        this.Rendered = false;
+        /**
+         * Api dell'estensione expand-collapse per permettere di effettuare operazioni dall'esterno del diagramma. Vengono valorizzate se **UseExpandCollapse** è **true**
+         */
+        this.ExpandCollapseApi = null;
+    }
+    /**
+     * @ignore
+     *
+     * Angular Pipeline
+     */
+    ngAfterViewInit() {
+        if (!this.service || !this.dispatcher)
+            throw "Il modulo @esfaenza/diagrams non è stato importato con il forRoot();";
+        this.dispatchLoadChart();
+    }
+    /**
+     * All'onDestroy ripulisco la memoria dal diagramma
+     */
+    ngOnDestroy() {
+        this.resizeObserver.dispose();
+        this.resizeObserver = null;
+        if (this.cy) {
+            this.service.log("I", "Diagram" + " " + this.name + ": Unloading destroyed diagram", false);
+            this.cy.destroy();
+            this.dispatcher.deregister(this.name);
+        }
+        else
+            this.service.log("I", "Chart " + this.name + ": Unloading uncreated chart component. It probably was a duplicated", false);
+    }
+    /**
+     * Registra il diagramma attuale nel Dispatcher in modo che venga caricato appena possibile
+     */
+    dispatchLoadChart() {
+        this.dispatcher.register(this.name, () => { return this.render(); });
+    }
+    /**
+     * @ignore
+     *
+     * Angular Pipeline: Gestione ri-graficazione del diagramma, se possibile
+     */
+    ngOnChanges(changes) {
+        let toCheck = ["Templates", "UseContextMenu", "ContextMenuOptions", "UseExpandCollapse", "ExpandCollapseOptions", "NodeStyles", "EdgeStyles", "NativeOptions"];
+        if (this.Rendered && toCheck.some(t => changes[t]))
+            this.service.log("W", "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");
+        let elementChanges = changes["Elements"];
+        let layoutChanges = changes["Layout"];
+        if (elementChanges && !elementChanges.firstChange) {
+            this.service.log("I", "Elements have been changed after diagram initialization");
+            // Cambiamento agli Elementi: ripulisco gli elementi vecchi, prendo i nuovi, li sistemo e li riassegno. 
+            // Se il nuovo Input Elements è roba strana mi limito a ripulire il diagramma
+            // Se cytoscape aveva già degli elementi precedentemente ne prendo le posizioni in modo da ridisegnarli partendo dallo stesso punto (carino per le animazioni)
+            let elements = elementChanges === null || elementChanges === void 0 ? void 0 : elementChanges.currentValue;
+            let previous_elements = this.PreserveElementsPosition ? this.cy.nodes() : null;
+            this.cy.elements().remove();
+            if (elements && elements.length && elements.length > 0) {
+                this.reviewCytoscapeElements(elements, previous_elements);
+                this.cy.add(elements);
+                // Se solo gli elementi cambiano, riapplico il Layout precedente
+                if (!layoutChanges && this.LastLayout) {
+                    // Se devo animare le modifche al layout forzo il parametro relativo
+                    if (this.AnimateLayoutChanges)
+                        this.LastLayout.animate = true;
+                    this.cy.layout(this.LastLayout).run();
+                }
+            }
+        }
+        // Se il layout cambia lo applico e me lo salvo come layout precedente per il futuro
+        if (layoutChanges && !layoutChanges.firstChange) {
+            this.service.log("I", "Layout have been changed after diagram initialization");
+            this.LastLayout = JSON.parse(JSON.stringify(layoutChanges.currentValue));
+            this.cy.layout(this.LastLayout).run();
+        }
+    }
+    /**
+     * Effettua il rendering del diagramma
+     */
+    render() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Tiro fuori le opzioni con cui generare il diagramma
+            let cyOptions = this.getCompletedOptions();
+            this.NodesHierarchy = cyOptions.elements && cyOptions.elements.some(t => t.data.parent);
+            // Carico eventuali classi di estensione che servono
+            yield this.performModulesLoading();
+            // Genero il diagramma
+            this.cy = cytoscape(cyOptions);
+            // Collego gli eventi al componente
+            this.bindCytoscapeEvents();
+            // Utilizzo le classi di estensione caricate precedentemente per fare il resto delle mie operazioni
+            this.performOperationsWithLoadedModules();
+            // Imposto la variabile Rendered a true in modo che se da adesso vengono fatte modifiche che dovrebbero causare un redraw posso accorgermene
+            // e mandare a cagare lo stronzo di turno
+            this.Rendered = true;
+            // Se devo aggiornare in automatico in base alla dimensione del contenitore collego il ResizeObserver
+            if (this.AutoupdateSize)
+                this.listenOnChanges();
+        });
+    }
+    /**
+     * Registra l'ascolto al contenitore del grafico e in caso di modifiche alla dimensione, al massimo una volta ogni 500 millisecondi, lo ridisegna
+     */
+    listenOnChanges() {
+        this.resizeObserver = new ResizeSensor(this.cyGraph.nativeElement, () => {
+            this.exts.throttle(this.name, this.onContainerSizeChanged.bind(this), this.ResizeThrottleTime);
+        });
+    }
+    /**
+     * Funzione che si occupa di gestire il repaint del diagramma
+     */
+    onContainerSizeChanged() {
+        this.service.log("I", "Diagram container size has changed, redrawing");
+        this.cy.resize();
+        this.cy.fit();
+    }
+    /**
+     * Collega tutti gli eventi che mi possono servire e li espone in output
+     */
+    bindCytoscapeEvents() {
+        this.cy.bind('click', 'node', (event) => {
+            this.onNodeClick.emit({ data: event.target.data() });
+        });
+        // Altri eventi...
+    }
+    /**
+     * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato
+     */
+    performModulesLoading() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.Layout.name == 'dagre')
+                yield this.loadInternal("cytoscape-dagre");
+            if (this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0)
+                yield this.loadInternal("cytoscape-html-node");
+            if (this.UseContextMenu)
+                yield this.loadInternal("cytoscape-cxtmenu");
+            if (this.NodesHierarchy && this.UseExpandCollapse)
+                yield this.loadInternal("cytoscape-expand-collapse");
+            if (this.ExtensionModulesImporter) {
+                // Wrappo il namespace in modo che possa dire la mia sul fatto che l'utente aggiunga un modulo o meno :D
+                var wrappedCytoscape = {
+                    use: (moduleName, module) => {
+                        if (!module)
+                            this.service.log("E", this.service.loc("Received an undefined module. Make sure you are correctly loading it") + ": " + moduleName, false);
+                        if (["cytoscape-dagre", "cytoscape-html-node", "cytoscape-cxtmenu", "cytoscape-expand-collapse"].includes(moduleName))
+                            this.service.log("W", this.service.loc("Module") + " " + moduleName + " " + this.service.loc("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"), false);
+                        else
+                            cytoscape.use(module);
+                    }
+                };
+                yield this.ExtensionModulesImporter(wrappedCytoscape);
+            }
+        });
+    }
+    /**
+     * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato con le opzioni definite dagli Input
+     */
+    performOperationsWithLoadedModules() {
+        let anyCy = this.cy;
+        // Utilizzo del layout, lo salvo per poterlo riutilizzare in futuro
+        if (this.Layout) {
+            this.LastLayout = JSON.parse(JSON.stringify(this.Layout));
+            this.cy.layout(this.LastLayout).run();
+        }
+        // Utilizzo dell'HTML node
+        if (this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0) {
+            let htmlnode = anyCy.htmlnode();
+            htmlnode.createHtmlNode(cytoscape, this.cy, this.NodeHTMLTemplates);
+        }
+        // Utilizzo del Context Menu
+        if (this.UseContextMenu)
+            anyCy.cxtmenu(this.ContextMenuOptions);
+        // Utilizzo dell'expand collapse solo quando c'è una gerarchia di nodi
+        if (this.NodesHierarchy && this.UseExpandCollapse)
+            this.ExpandCollapseApi = anyCy.expandCollapse(this.ExpandCollapseOptions);
+        // Utilizzo di estensioni extra, implementazione affidata al programmatore
+        if (this.ExtensionModulesApplyer)
+            this.ExtensionModulesApplyer(this.cy);
+    }
+    /**
+     * Metodo interno per il caricamento dei moduli di estensione
+     *
+     * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Modulo da caricare
+     */
+    loadInternal(moduleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let toLoad = yield this.service.importIfNeeded(moduleId);
+            if (toLoad)
+                cytoscape.use(toLoad);
+        });
+    }
+    /**
+     * Metodo che basandosi sulle opzioni native eventualmente assegnate le completa con gli Input addizionali
+     *
+     * @returns {cy_.CytoscapeOptions} Opzioni finali unite da Input ed opzioni native
+     */
+    getCompletedOptions() {
+        var opts = this.NativeOptions || {};
+        opts.container = this.cyGraph.nativeElement;
+        opts.style = opts.style || [];
+        // Per tutte le cose per cui gli Input hanno priorità sovrascrivo gli originali delle opzioni
+        if (this.NodeStyles || this.EdgeStyles) {
+            opts.style = [];
+            if (this.NodeStyles)
+                opts.style.push({ selector: 'node', css: this.NodeStyles });
+            if (this.EdgeStyles)
+                opts.style.push({ selector: 'edge', css: this.EdgeStyles });
+        }
+        if (this.Elements)
+            opts.elements = this.Elements;
+        this.reviewCytoscapeElements(opts.elements);
+        if (this.Layout)
+            opts.layout = this.Layout;
+        if (this.Readonly) {
+            // Questo coso fa effetti strani....
+            //opts.autolock = true;
+            opts.autoungrabify = true;
+            opts.autounselectify = true;
+            opts.boxSelectionEnabled = false;
+            opts.userZoomingEnabled = false;
+            opts.userPanningEnabled = false;
+        }
+        return opts;
+    }
+    /**
+     * Aggiustamenti degli elementi di Cytoscape.
+     *
+     * I nodi non vengono toccati.
+     *
+     * Per ogni edge viene controllato se è specificata una sorgente ed una destinazione, in caso contrario si cerca di dedurli dall'ID
+     *
+     * @param {cytoscape.ElementDefinition[]} elements Elementi da sistemare
+     */
+    reviewCytoscapeElements(elements, prevPositions) {
+        let hasPreviousPositions = prevPositions && prevPositions.length > 0;
+        let positionCache = {};
+        if (hasPreviousPositions) {
+            for (let i = 0; i < prevPositions.length; i++) {
+                let item = prevPositions[i];
+                if (!positionCache[item.data().id])
+                    positionCache[item.data().id] = item.position();
+            }
+        }
+        for (let i = 0; i < elements.length; i++) {
+            let el = elements[i];
+            if (el.group == "edges" && (!el.data.source && !el.data.target)) {
+                if (!el.data.id.includes("-"))
+                    this.service.log("E", "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}");
+                else {
+                    var sourceTarget = el.data.id.split('-');
+                    el.data.source = sourceTarget[0].trim();
+                    el.data.target = sourceTarget[1].trim();
+                }
+            }
+            if (hasPreviousPositions && el.group == "nodes")
+                el.position = positionCache[el.data.id];
+        }
+    }
+}
+EsDiagramComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'es-diagram',
+                template: "<div #graph class=\"graph-wrapper {{name}}\"></div>",
+                styles: [".graph-wrapper{height:100%;width:100%}.html-node-notransition{transition:none!important;transform:none!important}\n"]
+            },] }
+];
+EsDiagramComponent.ctorParameters = () => [
+    { type: EsDiagramService, decorators: [{ type: Optional }] },
+    { type: EsDiagramDispatcher, decorators: [{ type: Optional }] },
+    { type: ReactiveExtensions }
+];
+EsDiagramComponent.propDecorators = {
+    cyGraph: [{ type: ViewChild, args: ['graph',] }],
+    name: [{ type: Input }],
+    UseContextMenu: [{ type: Input }],
+    ContextMenuOptions: [{ type: Input }],
+    UseExpandCollapse: [{ type: Input }],
+    ExpandCollapseOptions: [{ type: Input }],
+    NativeOptions: [{ type: Input }],
+    Elements: [{ type: Input }],
+    NodeStyles: [{ type: Input }],
+    EdgeStyles: [{ type: Input }],
+    Readonly: [{ type: Input }],
+    AutoupdateSize: [{ type: Input }],
+    PreserveElementsPosition: [{ type: Input }],
+    AnimateLayoutChanges: [{ type: Input }],
+    ResizeThrottleTime: [{ type: Input }],
+    Layout: [{ type: Input }],
+    NodeHTMLTemplates: [{ type: Input }],
+    ExtensionModulesImporter: [{ type: Input }],
+    ExtensionModulesApplyer: [{ type: Input }],
+    onNodeClick: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"es-diagram.component.js","sourceRoot":"","sources":["../../../../../projects/es-diagrams/src/lib/components/es-diagram.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnChanges, Optional, Output, SimpleChanges, ViewChild } from '@angular/core'\n\nimport { ContextMenuOptions } from '../models/component/contextmenu/ContextMenuOptions';\nimport { ExpandCollapseOptions } from '../models/component/grouping/ExpandCollapseOptions';\nimport { NodeHTMLTemplate } from '../models/component/nodes/NodeHTMLTemplate';\n\nimport { BreadthFirstLayoutOptionsImpl } from '../models/layouts/BreadthFirstLayoutOptionsImpl';\nimport { CircleLayoutOptionsImpl } from '../models/layouts/CircleLayoutOptionsImpl';\nimport { ConcentricLayoutOptionsImpl } from '../models/layouts/ConcentricLayoutOptionsImpl';\nimport { CoseLayoutOptionsImpl } from '../models/layouts/CoseLayoutOptionsImpl';\nimport { DagreLayoutOptionsImpl } from '../models/layouts/DagreLayoutOptionsImpl';\nimport { GridLayoutOptionsImpl } from '../models/layouts/GridLayoutOptionsImpl';\nimport { NullLayoutOptionsImpl } from '../models/layouts/NullLayoutOptionsImpl';\nimport { PresetLayoutOptionsImpl } from '../models/layouts/PresetLayoutOptionsImpl';\nimport { RandomLayoutOptionsImpl } from '../models/layouts/RandomLayoutOptionsImpl';\n\nimport { EsDiagramService } from '../services/es-diagram.service';\nimport { EsDiagramDispatcher } from '../services/es-diagram.dispatcher';\nimport { ResizeSensor } from \"../extensions/ResizeSensor\";\n\nimport { ReactiveExtensions } from '../extensions/ReactiveExtensions';\n\nimport * as cy_ from 'cytoscape';\n/** @ignore */const cytoscape = cy_;\n\n/**\n * Componente che si occupa di graficare un diagramma e di gestirne il ciclo di vita\n */\n@Component({\n  selector: 'es-diagram',\n  templateUrl: './es-diagram.component.html',\n  styleUrls: ['./es-diagram.component.scss']\n})\nexport class EsDiagramComponent implements OnChanges {\n\n  /**\n   * Riferimento all'oggetto HTML su cui creare il diagramma\n   */\n  @ViewChild('graph') cyGraph: ElementRef;\n\n  /**\n   * Nome del diagramma, fondamentale assegnarlo per permettere alla libreria di schedularne la creazione\n   */\n  @Input() name: string = \"\";\n\n  /**\n   * Indica se utilizzare il menù contestuale a ruota attorno ad ogni nodo\n   */\n  @Input() UseContextMenu: boolean = false;\n\n  /**\n   * Indica le opzioni del menù contestuale qualora **UseContextMenu** fosse **true**\n   */\n  @Input() ContextMenuOptions: ContextMenuOptions;\n\n  /**\n   * Dice al componente se il diagramma deve utilizzare il sistema di estensione per l'expand e collapse dei gruppi\n   */\n  @Input() UseExpandCollapse: boolean = false;\n\n  /**\n   * Opzioni native dell'estensione expand-collapse, vengono ovviamente utilizzate solo se **UseExpandCollapse** è **true**\n   */\n  @Input() ExpandCollapseOptions: ExpandCollapseOptions;\n\n  /**\n   * Blocco completo delle opzioni, alternativo all'assegnazione di **Elements**, **NodeStyles**, **EdgeStyles**, e **Layout**.\n   * \n   * Qualora entrambe venissero specificate verrà effettuata un'unione fra queste opzioni e quelle specificate, dando priorità alle specificate\n   */\n  @Input() NativeOptions: cytoscape.CytoscapeOptions = {};\n\n  /**\n   * Definizione degli elementi da mostrare nel diagramma\n   */\n  @Input() Elements: cytoscape.ElementDefinition[];\n\n  /**\n   * Definizione degli stili dei nodi\n   */\n  @Input() NodeStyles: cytoscape.Css.Node;\n\n  /**\n   * Definizione degli stili dei collegamenti fra i nodi\n   */\n  @Input() EdgeStyles: cytoscape.Css.Edge;\n\n  /**\n   * In un diagramma in sola lettura tutte le interazioni utente sono annullate\n   */\n  @Input() Readonly: boolean;\n\n  /**\n   * Aggiorna automaticamente le dimensioni del diagramma quando cambiano le dimensioni della finestra\n   */\n  @Input() AutoupdateSize: boolean = true;\n\n  /**\n   * Indica di mantenere la posizione dei nodi qualora venissero cambiati dall'Input **Elements**.\n   * \n   * Se l'ID di un nodo è uguale all'ID di un nodo presente in precedenza, il nuovo nodo ne erediterà la posizione\n   */\n  @Input() PreserveElementsPosition: boolean = true;\n\n  /**\n   * Qualora venisse modificato l'Input **Elements**, piuttosto che mettere semplicemente il nuovo Elemento in base al Layout precedente, applica anche un'animazione \n   * \n   * Funziona solamente se il **Layout** corrente del diagramma supporta le animazioni\n   */\n  @Input() AnimateLayoutChanges: boolean = true;\n\n  /**\n   * Periodo di throttle da quando viene effettuato un resize a quando ricalcolare le dimensioni del diagramma.\n   * \n   * Può essere tenuto a 0 (redraw istantaneo) finché non ci sono problemi di prestazioni con eventualmente tanti resize a poca distanza l'uno dall'altro.\n   */\n  @Input() ResizeThrottleTime: number = 0;\n\n  /**\n   * Layout di ordinamento dei nodi\n   */\n  @Input() Layout: BreadthFirstLayoutOptionsImpl | CircleLayoutOptionsImpl | ConcentricLayoutOptionsImpl |\n    CoseLayoutOptionsImpl | DagreLayoutOptionsImpl | GridLayoutOptionsImpl | NullLayoutOptionsImpl | PresetLayoutOptionsImpl |\n    RandomLayoutOptionsImpl;\n\n  /**\n   * Template HTML da applicare ai nodi per dargli stili particolari, diversi dalle shape di default\n   */\n  @Input() NodeHTMLTemplates: NodeHTMLTemplate[];\n\n  /**\n   * Fornisce il global della libreria (namespace **cytoscape**) e si aspetta che dopo operazioni di importazione \n   * lasciate all'utente vengano aggiunti tutti i moduli desiderati. \n   * \n   * È **fondamentale** che il primo parametro (il nome del modulo) sia uguale a ciò di cui viene fatto il require in modo che la libreria\n   * possa controllare che il modulo importato non sia già stato importato in precedenza\n   * \n   * ## Esempio:\n   * \n   * ```typescript\n   * (global) => {\n   *    return import(\"cytoscape-extension-library\").then(module => global.use(\"cytoscape-extension-library\", module.default));\n   * \n   *    ...\n   * }\n   * ```\n   */\n  @Input() ExtensionModulesImporter: (global: { use: (moduleName: string, module: void | cytoscape.Ext) => void }) => Promise<any> = null;\n\n  /**\n   * Fornisce l'istanza attuale di Cytoscape da cui è possibile prendere le librerie di estensione caricate in **ExtensionModulesImporter**\n   * e configurarle in base ai comportamenti specifici\n   * \n   * ## Esempio:\n   * \n   * ```typescript\n   * (cytoscapeCore) => {\n   *    // Fare questo lavoro per ogni estensione caricata\n   *    let extensionConfiguration = { ... };\n   *    let extensionInstance = cytoscapeCore.extensionLibrary(extensionConfiguration);\n   *    extensionInstance.doSomethingSpecificToThisExtension();\n   * \n   *    ...\n   * }\n   * ```\n   */\n  @Input() ExtensionModulesApplyer: (cytoscapeCore: cytoscape.Core) => void = null;\n\n  /**\n   * Evento lanciato al click di un nodo, contiene l'oggetto **data** del nodo in questione\n   */\n  @Output() onNodeClick: EventEmitter<{ data: any }> = new EventEmitter<{ data: any }>();\n\n  /**\n   * Variabile su cui salvarsi se i nodi hanno una gerarchia a gruppi o no. Serve per poi caricare l'estensione expand-collapse qualora fosse richiesta\n   */\n  private NodesHierarchy: boolean;\n\n  /**\n   * Indica se il rendering del diagramma è terminato\n   */\n  private Rendered: boolean = false;\n\n  /**\n   * Istanza del diagramma attualmente in uso\n   */\n  public cy: cytoscape.Core\n\n  /**\n   * Api dell'estensione expand-collapse per permettere di effettuare operazioni dall'esterno del diagramma. Vengono valorizzate se **UseExpandCollapse** è **true**\n   */\n  public ExpandCollapseApi: any = null;\n\n  /**\n   * Osservatore delle modifiche al contenitore del diagramma\n   */\n  private resizeObserver: ResizeSensor;\n\n  /**\n   * Riferimento all'ultimo layout utilizzato. Viene riapplicato qualora venisse cambiato l'Input **Elements**.\n   * \n   * Non utilizzo il makeLayouts perché altrimenti rischierei di creare un layout riferito a X elementi, ne aggiungo 1, riapplico il Layout \n   * ma mi viene riapplicato a X elementi invece che X + 1\n   */\n  private LastLayout: cytoscape.LayoutOptions;\n\n  /**\n   * Costruttore\n   * \n   * @ignore\n   */\n  constructor(@Optional() private service: EsDiagramService, @Optional() private dispatcher: EsDiagramDispatcher, private exts: ReactiveExtensions) { }\n\n  /**\n   * @ignore \n   * \n   * Angular Pipeline\n   */\n  public ngAfterViewInit() {\n    if (!this.service || !this.dispatcher)\n      throw \"Il modulo @esfaenza/diagrams non è stato importato con il forRoot();\";\n\n    this.dispatchLoadChart();\n  }\n\n  /**\n   * All'onDestroy ripulisco la memoria dal diagramma\n   */\n  public ngOnDestroy() {\n    this.resizeObserver.dispose();\n    this.resizeObserver = null;\n\n    if (this.cy) {\n      this.service.log(\"I\", \"Diagram\" + \" \" + this.name + \": Unloading destroyed diagram\", false);\n      this.cy.destroy();\n      this.dispatcher.deregister(this.name);\n    }\n    else\n      this.service.log(\"I\", \"Chart \" + this.name + \": Unloading uncreated chart component. It probably was a duplicated\", false);\n  }\n\n  /**\n   * Registra il diagramma attuale nel Dispatcher in modo che venga caricato appena possibile\n   */\n  private dispatchLoadChart(): void {\n    this.dispatcher.register(this.name, () => { return this.render(); });\n  }\n\n  /**\n   * @ignore \n   * \n   * Angular Pipeline: Gestione ri-graficazione del diagramma, se possibile\n   */\n  public ngOnChanges(changes: SimpleChanges): any {\n    let toCheck = [\"Templates\", \"UseContextMenu\", \"ContextMenuOptions\", \"UseExpandCollapse\", \"ExpandCollapseOptions\", \"NodeStyles\", \"EdgeStyles\", \"NativeOptions\"];\n\n    if (this.Rendered && toCheck.some(t => changes[t]))\n      this.service.log(\"W\", \"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\");\n\n    let elementChanges = changes[\"Elements\"];\n    let layoutChanges = changes[\"Layout\"];\n    if (elementChanges && !elementChanges.firstChange) {\n      this.service.log(\"I\", \"Elements have been changed after diagram initialization\");\n\n      // Cambiamento agli Elementi: ripulisco gli elementi vecchi, prendo i nuovi, li sistemo e li riassegno. \n      // Se il nuovo Input Elements è roba strana mi limito a ripulire il diagramma\n      // Se cytoscape aveva già degli elementi precedentemente ne prendo le posizioni in modo da ridisegnarli partendo dallo stesso punto (carino per le animazioni)\n      let elements = elementChanges?.currentValue;\n      let previous_elements = this.PreserveElementsPosition ? <any>this.cy.nodes() : null;\n\n      this.cy.elements().remove();\n      if (elements && elements.length && elements.length > 0) {\n        this.reviewCytoscapeElements(elements, previous_elements);\n        this.cy.add(elements);\n\n        // Se solo gli elementi cambiano, riapplico il Layout precedente\n        if (!layoutChanges && this.LastLayout) {\n\n          // Se devo animare le modifche al layout forzo il parametro relativo\n          if (this.AnimateLayoutChanges)\n            (<any>this.LastLayout).animate = true;\n\n          this.cy.layout(this.LastLayout).run();\n        }\n      }\n    }\n\n    // Se il layout cambia lo applico e me lo salvo come layout precedente per il futuro\n    if (layoutChanges && !layoutChanges.firstChange) {\n      this.service.log(\"I\", \"Layout have been changed after diagram initialization\");\n      this.LastLayout = JSON.parse(JSON.stringify(layoutChanges.currentValue));\n      this.cy.layout(this.LastLayout).run()\n    }\n  }\n\n  /**\n   * Effettua il rendering del diagramma\n   */\n  private async render() {\n\n    // Tiro fuori le opzioni con cui generare il diagramma\n    let cyOptions = this.getCompletedOptions();\n    this.NodesHierarchy = cyOptions.elements && (<cy_.ElementDefinition[]>cyOptions.elements).some(t => t.data.parent);\n\n    // Carico eventuali classi di estensione che servono\n    await this.performModulesLoading();\n\n    // Genero il diagramma\n    this.cy = cytoscape(cyOptions);\n\n    // Collego gli eventi al componente\n    this.bindCytoscapeEvents();\n\n    // Utilizzo le classi di estensione caricate precedentemente per fare il resto delle mie operazioni\n    this.performOperationsWithLoadedModules();\n\n    // Imposto la variabile Rendered a true in modo che se da adesso vengono fatte modifiche che dovrebbero causare un redraw posso accorgermene\n    // e mandare a cagare lo stronzo di turno\n    this.Rendered = true;\n\n    // Se devo aggiornare in automatico in base alla dimensione del contenitore collego il ResizeObserver\n    if (this.AutoupdateSize)\n      this.listenOnChanges();\n  }\n\n  /**\n   * Registra l'ascolto al contenitore del grafico e in caso di modifiche alla dimensione, al massimo una volta ogni 500 millisecondi, lo ridisegna\n   */\n  private listenOnChanges() {\n    this.resizeObserver = new ResizeSensor(this.cyGraph.nativeElement, () => {\n      this.exts.throttle(this.name, this.onContainerSizeChanged.bind(this), this.ResizeThrottleTime);\n    });\n  }\n\n  /**\n   * Funzione che si occupa di gestire il repaint del diagramma\n   */\n  private onContainerSizeChanged() {\n    this.service.log(\"I\", \"Diagram container size has changed, redrawing\");\n    this.cy.resize();\n    this.cy.fit();\n  }\n\n  /**\n   * Collega tutti gli eventi che mi possono servire e li espone in output\n   */\n  private bindCytoscapeEvents() {\n    this.cy.bind('click', 'node', (event) => {\n      this.onNodeClick.emit({ data: event.target.data() });\n    });\n\n    // Altri eventi...\n  }\n\n  /**\n   * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato\n   */\n  private async performModulesLoading() {\n    if (this.Layout.name == 'dagre')\n      await this.loadInternal(\"cytoscape-dagre\");\n\n    if (this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0)\n      await this.loadInternal(\"cytoscape-html-node\");\n\n    if (this.UseContextMenu)\n      await this.loadInternal(\"cytoscape-cxtmenu\");\n\n    if (this.NodesHierarchy && this.UseExpandCollapse)\n      await this.loadInternal(\"cytoscape-expand-collapse\");\n\n    if (this.ExtensionModulesImporter) {\n      // Wrappo il namespace in modo che possa dire la mia sul fatto che l'utente aggiunga un modulo o meno :D\n      var wrappedCytoscape = {\n        use: (moduleName: string, module: cytoscape.Ext) => {\n          if (!module)\n            this.service.log(\"E\", this.service.loc(\"Received an undefined module. Make sure you are correctly loading it\") + \": \" + moduleName, false);\n\n          if ([\"cytoscape-dagre\", \"cytoscape-html-node\", \"cytoscape-cxtmenu\", \"cytoscape-expand-collapse\"].includes(moduleName))\n            this.service.log(\"W\", this.service.loc(\"Module\") + \" \" + moduleName + \" \" + this.service.loc(\"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\"), false);\n          else\n            cytoscape.use(module);\n        }\n      }\n\n      await this.ExtensionModulesImporter(wrappedCytoscape);\n    }\n  }\n\n  /**\n   * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato con le opzioni definite dagli Input\n   */\n  private performOperationsWithLoadedModules() {\n\n    let anyCy = (<any>this.cy);\n\n    // Utilizzo del layout, lo salvo per poterlo riutilizzare in futuro\n    if (this.Layout) {\n      this.LastLayout = JSON.parse(JSON.stringify(this.Layout));\n      this.cy.layout(this.LastLayout).run()\n    }\n\n    // Utilizzo dell'HTML node\n    if (this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0) {\n      let htmlnode = anyCy.htmlnode();\n      htmlnode.createHtmlNode(cytoscape, this.cy, this.NodeHTMLTemplates);\n    }\n\n    // Utilizzo del Context Menu\n    if (this.UseContextMenu)\n      anyCy.cxtmenu(this.ContextMenuOptions);\n\n    // Utilizzo dell'expand collapse solo quando c'è una gerarchia di nodi\n    if (this.NodesHierarchy && this.UseExpandCollapse)\n      this.ExpandCollapseApi = anyCy.expandCollapse(this.ExpandCollapseOptions);\n\n    // Utilizzo di estensioni extra, implementazione affidata al programmatore\n    if (this.ExtensionModulesApplyer)\n      this.ExtensionModulesApplyer(this.cy);\n  }\n\n  /**\n   * Metodo interno per il caricamento dei moduli di estensione\n   * \n   * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Modulo da caricare\n   */\n  private async loadInternal(moduleId: 'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre') {\n    let toLoad = await this.service.importIfNeeded(moduleId);\n    if (toLoad) cytoscape.use(toLoad);\n  }\n\n  /**\n   * Metodo che basandosi sulle opzioni native eventualmente assegnate le completa con gli Input addizionali\n   * \n   * @returns {cy_.CytoscapeOptions} Opzioni finali unite da Input ed opzioni native\n   */\n  private getCompletedOptions(): cy_.CytoscapeOptions {\n    var opts: cy_.CytoscapeOptions = this.NativeOptions || {};\n    opts.container = this.cyGraph.nativeElement;\n    opts.style = opts.style || [];\n\n    // Per tutte le cose per cui gli Input hanno priorità sovrascrivo gli originali delle opzioni\n\n    if (this.NodeStyles || this.EdgeStyles) {\n      opts.style = [];\n      if (this.NodeStyles) opts.style.push({ selector: 'node', css: this.NodeStyles });\n      if (this.EdgeStyles) opts.style.push({ selector: 'edge', css: this.EdgeStyles });\n    }\n\n    if (this.Elements)\n      opts.elements = this.Elements;\n\n    this.reviewCytoscapeElements(<cytoscape.ElementDefinition[]>opts.elements);\n\n    if (this.Layout)\n      opts.layout = this.Layout;\n\n    if (this.Readonly) {\n      // Questo coso fa effetti strani....\n      //opts.autolock = true;\n\n      opts.autoungrabify = true;\n      opts.autounselectify = true;\n      opts.boxSelectionEnabled = false;\n      opts.userZoomingEnabled = false;\n      opts.userPanningEnabled = false;\n    }\n\n    return opts;\n  }\n\n  /**\n   * Aggiustamenti degli elementi di Cytoscape. \n   * \n   * I nodi non vengono toccati.\n   * \n   * Per ogni edge viene controllato se è specificata una sorgente ed una destinazione, in caso contrario si cerca di dedurli dall'ID\n   * \n   * @param {cytoscape.ElementDefinition[]} elements Elementi da sistemare\n   */\n  private reviewCytoscapeElements(elements: cytoscape.ElementDefinition[], prevPositions?: any) {\n    let hasPreviousPositions = prevPositions && prevPositions.length > 0;\n    let positionCache: { [index: string]: cytoscape.Position } = {};\n\n    if (hasPreviousPositions) {\n      for (let i = 0; i < prevPositions.length; i++) {\n        let item = prevPositions[i];\n        if (!positionCache[item.data().id])\n          positionCache[item.data().id] = item.position();\n      }\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      let el = elements[i];\n      if (el.group == \"edges\" && (!el.data.source && !el.data.target)) {\n        if (!el.data.id.includes(\"-\"))\n          this.service.log(\"E\", \"If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}\");\n        else {\n          var sourceTarget = el.data.id.split('-');\n          el.data.source = sourceTarget[0].trim();\n          el.data.target = sourceTarget[1].trim();\n        }\n      }\n\n      if (hasPreviousPositions && el.group == \"nodes\")\n        el.position = positionCache[el.data.id]\n    }\n  }\n}"]}

package/esm2015/lib/esdiagram.module.js

@@ -0,0 +1,28 @@
+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';
+export class EsDiagramModule {
+    static forRoot(config) {
+        return {
+            ngModule: EsDiagramModule,
+            providers: [
+                EsDiagramService,
+                EsDiagramDispatcher,
+                { provide: DIA_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.locale) || 'it-IT' },
+                { provide: DIA_DEBUG_MODE, useValue: (config === null || config === void 0 ? void 0 : config.debugMode) || false },
+            ]
+        };
+    }
+}
+EsDiagramModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [EsDiagramComponent],
+                imports: [CommonModule, FormsModule, ReactiveFormsModule, CommonModule],
+                exports: [EsDiagramComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/extensions/ReactiveExtensions.js

@@ -0,0 +1,34 @@
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function ReactiveExtensions_Factory() { return new ReactiveExtensions(); }, token: ReactiveExtensions, providedIn: "root" });
+ReactiveExtensions.decorators = [
+    { type: Injectable, args: [{ providedIn: "root" },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/extensions/ResizeSensor.js

@@ -0,0 +1,71 @@
+// Grabbata felicemente da amcharts, rimuovendo helper interni, cose strane e instupidendola un po':
+// https://github.com/amcharts/amcharts4/blob/7fbb61e90363a2373e6130800dee06b8a62f3aab/src/.internal/core/utils/ResizeSensor.ts
+/**
+ * Classe di utilità che tiene d'occhio i cambiamenti di dimensione di un elemento. Un **ResizeSensor** può controllare al massimo un elemento
+ */
+export class ResizeSensor {
+    /**
+     * Costruttore
+     *
+     * @param {HTMLElement} element Elemento HTML da controllare
+     * @param {Function} callback Callback da chiamare quando le dimensioni di **element** cambiano
+     */
+    constructor(element, callback) {
+        /**
+         * Riferimento all'observer nativo
+         */
+        this.observer = null;
+        /**
+         * Indica se questo oggetto è stato distrutto o no
+         */
+        this.Disposed = false;
+        /**
+         * Elemento da controllare e callback da chiamare quando le dimensioni dell'elemento cambiano
+         */
+        this.target = null;
+        this.makeSensor();
+        this.addTarget(element, callback);
+    }
+    /**
+     * Distruttore
+     */
+    dispose() {
+        if (!this.Disposed) {
+            this.Disposed = true;
+            this.removeTarget();
+        }
+    }
+    /**
+     * Creazione del sensore che sarà collegato all'elemento da osservare dal metodo **addTarget**
+     */
+    makeSensor() {
+        if (typeof ResizeObserver == "undefined")
+            throw "Resize Observer non è definito. Si prega di utilizzare un browser vero";
+        this.observer = new ResizeObserver((entries) => {
+            for (let i = 0; i < entries.length; ++i) {
+                if (this.target && this.target.targetEl === entries[i].target)
+                    this.target.callback();
+            }
+        });
+    }
+    /**
+     * Dice al sensore di osservare l'elemento **targetEl**, richiamando **callback** qualora le dimensioni cambino
+     *
+     * @param {HTMLElement} targetEl Elemento HTML da controllare
+     * @param {Function} callback Callback da chiamare quando le dimensioni di **element** cambiano
+     */
+    addTarget(targetEl, callback) {
+        this.observer.observe(targetEl, { box: "content-box" });
+        this.target = { targetEl, callback };
+    }
+    /**
+     * Rimuove l'elemento HTML attuale dall'osservazione del **ResizeObserver**
+     */
+    removeTarget() {
+        if (!this.target)
+            return;
+        this.observer.unobserve(this.target.targetEl);
+        this.target = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVzaXplU2Vuc29yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXMtZGlhZ3JhbXMvc3JjL2xpYi9leHRlbnNpb25zL1Jlc2l6ZVNlbnNvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvR0FBb0c7QUFDcEcsK0hBQStIO0FBTy9IOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFlBQVk7SUFpQnJCOzs7OztPQUtHO0lBQ0gsWUFBWSxPQUFvQixFQUFFLFFBQW9CO1FBckJ0RDs7V0FFRztRQUNLLGFBQVEsR0FBUSxJQUFJLENBQUM7UUFFN0I7O1dBRUc7UUFDSSxhQUFRLEdBQVksS0FBSyxDQUFDO1FBRWpDOztXQUVHO1FBQ0ssV0FBTSxHQUFnRCxJQUFJLENBQUM7UUFTL0QsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNJLE9BQU87UUFDVixJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUNoQixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQztZQUNyQixJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7U0FDdkI7SUFDTCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxVQUFVO1FBQ2QsSUFBSSxPQUFPLGNBQWMsSUFBSSxXQUFXO1lBQ3BDLE1BQU0sd0VBQXdFLENBQUM7UUFFbkYsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBQyxDQUFDLE9BQW1CLEVBQUUsRUFBRTtZQUN2RCxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsRUFBRTtnQkFDckMsSUFBSSxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNO29CQUN6RCxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO2FBQzlCO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxTQUFTLENBQUMsUUFBcUIsRUFBRSxRQUFvQjtRQUN4RCxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsRUFBRSxHQUFHLEVBQUUsYUFBYSxFQUFFLENBQUMsQ0FBQztRQUN4RCxJQUFJLENBQUMsTUFBTSxHQUFHLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxDQUFDO0lBQ3pDLENBQUM7SUFFRDs7T0FFRztJQUNJLFlBQVk7UUFDZixJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU07WUFDWixPQUFPO1FBRVgsSUFBSSxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUM5QyxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztJQUN2QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHcmFiYmF0YSBmZWxpY2VtZW50ZSBkYSBhbWNoYXJ0cywgcmltdW92ZW5kbyBoZWxwZXIgaW50ZXJuaSwgY29zZSBzdHJhbmUgZSBpbnN0dXBpZGVuZG9sYSB1biBwbyc6XHJcbi8vIGh0dHBzOi8vZ2l0aHViLmNvbS9hbWNoYXJ0cy9hbWNoYXJ0czQvYmxvYi83ZmJiNjFlOTAzNjNhMjM3M2U2MTMwODAwZGVlMDZiOGE2MmYzYWFiL3NyYy8uaW50ZXJuYWwvY29yZS91dGlscy9SZXNpemVTZW5zb3IudHNcclxuXHJcbi8qKlxyXG4gKiBPZ2dldHRvIG5hdGl2byAqKlJlc2l6ZU9ic2VydmVyKipcclxuICovXHJcbmRlY2xhcmUgY29uc3QgUmVzaXplT2JzZXJ2ZXI6IGFueTtcclxuXHJcbi8qKlxyXG4gKiBDbGFzc2UgZGkgdXRpbGl0w6AgY2hlIHRpZW5lIGQnb2NjaGlvIGkgY2FtYmlhbWVudGkgZGkgZGltZW5zaW9uZSBkaSB1biBlbGVtZW50by4gVW4gKipSZXNpemVTZW5zb3IqKiBwdcOyIGNvbnRyb2xsYXJlIGFsIG1hc3NpbW8gdW4gZWxlbWVudG9cclxuICovXHJcbmV4cG9ydCBjbGFzcyBSZXNpemVTZW5zb3Ige1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogUmlmZXJpbWVudG8gYWxsJ29ic2VydmVyIG5hdGl2b1xyXG4gICAgICovXHJcbiAgICBwcml2YXRlIG9ic2VydmVyOiBhbnkgPSBudWxsO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogSW5kaWNhIHNlIHF1ZXN0byBvZ2dldHRvIMOoIHN0YXRvIGRpc3RydXR0byBvIG5vXHJcbiAgICAgKi9cclxuICAgIHB1YmxpYyBEaXNwb3NlZDogYm9vbGVhbiA9IGZhbHNlO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogRWxlbWVudG8gZGEgY29udHJvbGxhcmUgZSBjYWxsYmFjayBkYSBjaGlhbWFyZSBxdWFuZG8gbGUgZGltZW5zaW9uaSBkZWxsJ2VsZW1lbnRvIGNhbWJpYW5vXHJcbiAgICAgKi9cclxuICAgIHByaXZhdGUgdGFyZ2V0OiB7IHRhcmdldEVsOiBFbGVtZW50LCBjYWxsYmFjazogKCkgPT4gdm9pZCB9ID0gbnVsbDtcclxuXHJcbiAgICAvKipcclxuICAgICAqIENvc3RydXR0b3JlXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7SFRNTEVsZW1lbnR9IGVsZW1lbnQgRWxlbWVudG8gSFRNTCBkYSBjb250cm9sbGFyZVxyXG4gICAgICogQHBhcmFtIHtGdW5jdGlvbn0gY2FsbGJhY2sgQ2FsbGJhY2sgZGEgY2hpYW1hcmUgcXVhbmRvIGxlIGRpbWVuc2lvbmkgZGkgKiplbGVtZW50KiogY2FtYmlhbm9cclxuICAgICAqL1xyXG4gICAgY29uc3RydWN0b3IoZWxlbWVudDogSFRNTEVsZW1lbnQsIGNhbGxiYWNrOiAoKSA9PiB2b2lkKSB7XHJcbiAgICAgICAgdGhpcy5tYWtlU2Vuc29yKCk7XHJcbiAgICAgICAgdGhpcy5hZGRUYXJnZXQoZWxlbWVudCwgY2FsbGJhY2spO1xyXG4gICAgfVxyXG5cclxuICAgIC8qKlxyXG4gICAgICogRGlzdHJ1dHRvcmVcclxuICAgICAqL1xyXG4gICAgcHVibGljIGRpc3Bvc2UoKSB7XHJcbiAgICAgICAgaWYgKCF0aGlzLkRpc3Bvc2VkKSB7XHJcbiAgICAgICAgICAgIHRoaXMuRGlzcG9zZWQgPSB0cnVlO1xyXG4gICAgICAgICAgICB0aGlzLnJlbW92ZVRhcmdldCgpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxuXHJcbiAgICAvKipcclxuICAgICAqIENyZWF6aW9uZSBkZWwgc2Vuc29yZSBjaGUgc2Fyw6AgY29sbGVnYXRvIGFsbCdlbGVtZW50byBkYSBvc3NlcnZhcmUgZGFsIG1ldG9kbyAqKmFkZFRhcmdldCoqXHJcbiAgICAgKi9cclxuICAgIHByaXZhdGUgbWFrZVNlbnNvcigpIHtcclxuICAgICAgICBpZiAodHlwZW9mIFJlc2l6ZU9ic2VydmVyID09IFwidW5kZWZpbmVkXCIpXHJcbiAgICAgICAgICAgIHRocm93IFwiUmVzaXplIE9ic2VydmVyIG5vbiDDqCBkZWZpbml0by4gU2kgcHJlZ2EgZGkgdXRpbGl6emFyZSB1biBicm93c2VyIHZlcm9cIjtcclxuXHJcbiAgICAgICAgdGhpcy5vYnNlcnZlciA9IG5ldyBSZXNpemVPYnNlcnZlcigoZW50cmllczogQXJyYXk8YW55PikgPT4ge1xyXG4gICAgICAgICAgICBmb3IgKGxldCBpID0gMDsgaSA8IGVudHJpZXMubGVuZ3RoOyArK2kpIHtcclxuICAgICAgICAgICAgICAgIGlmICh0aGlzLnRhcmdldCAmJiB0aGlzLnRhcmdldC50YXJnZXRFbCA9PT0gZW50cmllc1tpXS50YXJnZXQpXHJcbiAgICAgICAgICAgICAgICAgICAgdGhpcy50YXJnZXQuY2FsbGJhY2soKTtcclxuICAgICAgICAgICAgfVxyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG5cclxuICAgIC8qKlxyXG4gICAgICogRGljZSBhbCBzZW5zb3JlIGRpIG9zc2VydmFyZSBsJ2VsZW1lbnRvICoqdGFyZ2V0RWwqKiwgcmljaGlhbWFuZG8gKipjYWxsYmFjayoqIHF1YWxvcmEgbGUgZGltZW5zaW9uaSBjYW1iaW5vXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7SFRNTEVsZW1lbnR9IHRhcmdldEVsIEVsZW1lbnRvIEhUTUwgZGEgY29udHJvbGxhcmVcclxuICAgICAqIEBwYXJhbSB7RnVuY3Rpb259IGNhbGxiYWNrIENhbGxiYWNrIGRhIGNoaWFtYXJlIHF1YW5kbyBsZSBkaW1lbnNpb25pIGRpICoqZWxlbWVudCoqIGNhbWJpYW5vXHJcbiAgICAgKi9cclxuICAgIHB1YmxpYyBhZGRUYXJnZXQodGFyZ2V0RWw6IEhUTUxFbGVtZW50LCBjYWxsYmFjazogKCkgPT4gdm9pZCkge1xyXG4gICAgICAgIHRoaXMub2JzZXJ2ZXIub2JzZXJ2ZSh0YXJnZXRFbCwgeyBib3g6IFwiY29udGVudC1ib3hcIiB9KTtcclxuICAgICAgICB0aGlzLnRhcmdldCA9IHsgdGFyZ2V0RWwsIGNhbGxiYWNrIH07XHJcbiAgICB9XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBSaW11b3ZlIGwnZWxlbWVudG8gSFRNTCBhdHR1YWxlIGRhbGwnb3NzZXJ2YXppb25lIGRlbCAqKlJlc2l6ZU9ic2VydmVyKipcclxuICAgICAqL1xyXG4gICAgcHVibGljIHJlbW92ZVRhcmdldCgpIHtcclxuICAgICAgICBpZiAoIXRoaXMudGFyZ2V0KVxyXG4gICAgICAgICAgICByZXR1cm47XHJcblxyXG4gICAgICAgIHRoaXMub2JzZXJ2ZXIudW5vYnNlcnZlKHRoaXMudGFyZ2V0LnRhcmdldEVsKTtcclxuICAgICAgICB0aGlzLnRhcmdldCA9IG51bGw7XHJcbiAgICB9XHJcbn0iXX0=

package/esm2015/lib/models/EsDiagramModuleConfig.js

@@ -0,0 +1,6 @@
+/**
+ * Classe di configurazione per il Modulo
+ */
+export class EsDiagramModuleConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXNEaWFncmFtTW9kdWxlQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXMtZGlhZ3JhbXMvc3JjL2xpYi9tb2RlbHMvRXNEaWFncmFtTW9kdWxlQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHFCQUFxQjtDQVdqQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBDbGFzc2UgZGkgY29uZmlndXJhemlvbmUgcGVyIGlsIE1vZHVsb1xyXG4gKi9cclxuZXhwb3J0IGNsYXNzIEVzRGlhZ3JhbU1vZHVsZUNvbmZpZ3tcclxuXHJcbiAgICAvKipcclxuICAgICAqIExvY2FsZSBkZWwgbW9kdWxvLiBQZXIgb3JhIHNvbm8gc3VwcG9ydGF0aSBzb2xvICdpdC1JVCcgZWQgJ2VuLVVTJ1xyXG4gICAgICovXHJcbiAgICBsb2NhbGU/OiBzdHJpbmc7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBBdHRpdmEgbyBkaXNhdHRpdmEgbGEgbW9kYWxpdMOgIGRpIGRlYnVnIHBlciBzY3JpdmVyZSBpIG1lc3NhZ2dpIGEgY29uc29sZVxyXG4gICAgICovXHJcbiAgICBkZWJ1Z01vZGU/OiBib29sZWFuO1xyXG59Il19