@esfaenza/es-diagrams 19.2.28 → 20.3.0

package/index.d.ts

@@ -1,5 +1,1090 @@
+import { AnimatedLayoutOptions, BoundingBox12, BoundingBoxWH, SortingFunction, NodeSingular } from 'cytoscape';
+import * as i0 from '@angular/core';
+import { OnChanges, ElementRef, EventEmitter, SimpleChanges, ModuleWithProviders } from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+
 /**
- * Generated bundle index. Do not edit.
+ * Definizione di un comando del Context menù
  */
-/// <amd-module name="@esfaenza/es-diagrams" />
-export * from './public-api';
+declare class ContextMenuCommand {
+    /**
+     * Background delo spicchio
+     */
+    fillColor?: string;
+    /**
+     * Contenuto del comando, html o testo
+     */
+    content: string;
+    /**
+     * Dizionario di stili da applicare all'html in cui viene wrappato il **content**
+     */
+    contentStyle?: {
+        [key: string]: string;
+    };
+    /**
+     * Funzione da eseguire quando questo comando viene cliccato
+     */
+    select: (ele: any) => void;
+    /**
+     * Indica se il comando è abilitato o no
+     */
+    enabled?: boolean;
+}
+
+/**
+ * Opzioni che gestiscono il context menu. Quando una di queste opzioni non viene assegnata viene mantenuto il default, assicurarsi quindi di modificare solo
+ * le proprietà che si vogliono effettivamente cambiare rispetto ai default
+ */
+declare class ContextMenuOptions {
+    /**
+     * Raggio esterno del Menù, aggiunto alla dimensione renderizzata del nodo
+     */
+    menuRadius?: (ele: any) => number;
+    /**
+     * Selettore di tutti gli elementi a cui verrà applicato il context menu. Di default sono tutti i nodi
+     */
+    selector?: string;
+    /**
+     * Lista di comandi da mostrare nel menù
+     */
+    commands?: ContextMenuCommand[];
+    /**
+     * Colore di background del menu
+     */
+    fillColor?: string;
+    /**
+     * Colore di background del menù quando c'è il mouse in selezione sopra
+     */
+    activeFillColor?: string;
+    /**
+     * Dimensione aggiuntiva per l'operazione selezionata in modo da evidenziarla dalle altre
+     */
+    activePadding?: number;
+    /**
+     * Dimensione in pixel dell'indicatore sul comando attuale
+     */
+    indicatorSize?: number;
+    /**
+     * Distanza in pixel da un comando e l'altro
+     */
+    separatorWidth?: number;
+    /**
+     * Dimensione extra fra l'elemento e il centro del menù
+     */
+    spotlightPadding?: number;
+    /**
+     * Raggio minimo del centro del menù
+     */
+    minSpotlightRadius?: number;
+    /**
+     * Raggio massimo del centro del menù
+     */
+    maxSpotlightRadius?: number;
+    /**
+     * Eventi per il quale il menù deve aprirsi
+     */
+    openMenuEvents?: 'cxttapstart' | 'taphold';
+    /**
+     * Colore del testo del menù
+     */
+    itemColor?: string;
+    /**
+     * Colore dell'ombreggiatura del testo del menù
+     */
+    itemTextShadowColor?: string;
+    /**
+     * zIndex del div in cui viene renderizzato il menù
+     */
+    zIndex?: number;
+    /**
+     * Indica se mostrare il menù alla posizione del mouse
+     */
+    atMouse?: boolean;
+    /**
+     * Indica se adattarsi alla dimensione del nodo. Se impostato le proprietà **minSpotlightRadius** e **maxSpotlightRadius** vengono ignorate
+     */
+    adaptativeNodeSpotlightRadius?: boolean;
+    /**
+     * Se settato a number indica dopo quanti pixel fuori dal menu il click viene annullato, altrimenti va settato a **false**
+     */
+    outsideMenuCancel?: boolean | number;
+}
+
+/**
+ *  Opzioni native per l'estensione expand-collapse di cytoscape
+ */
+declare class ExpandCollapseOptions {
+    /** @ignore */ layoutBy?: any;
+    /** @ignore */ fisheye?: boolean;
+    /** @ignore */ animate?: boolean;
+    /** @ignore */ animationDuration?: number;
+    /** @ignore */ ready?: () => void;
+    /** @ignore */ undoable?: boolean;
+    /** @ignore */ cueEnabled?: boolean;
+    /** @ignore */ expandCollapseCuePosition?: string | ((node: any) => string);
+    /** @ignore */ expandCollapseCueSize?: number;
+    /** @ignore */ expandCollapseCueLineSize?: number;
+    /** @ignore */ expandCueImage?: string;
+    /** @ignore */ collapseCueImage?: string;
+    /** @ignore */ expandCollapseCueSensitivity?: number;
+    /** @ignore */ edgeTypeInfo?: string | Function;
+    /** @ignore */ groupEdgesOfSameTypeOnCollapse?: boolean;
+    /** @ignore */ allowNestedEdgeCollapse?: boolean;
+    /** @ignore */ zIndex?: number;
+}
+
+/**
+ * Classe che rappresenta un template HTML applicabile ad un nodo
+ */
+declare class NodeTemplate {
+    /**
+     * Template del nodo. È possibile prendere direttamente i valori del nodo utilizzando la convenzione **#{data.nodeproperty}**
+     */
+    html: string;
+    /**
+     * Classe da applicare al template
+     */
+    cssClass?: string;
+}
+
+/**
+ * Classe che rappresenta il template HTML di un nodo da utilizzare per un certo livello di zoom
+ */
+declare class ZoomLevelBasedTemplate {
+    /**
+     * Livello di zoom da minimo a massimo per cui viene utilizzato questo template
+     */
+    zoomRange: [number, number];
+    /**
+     * Template da utilizzare
+     */
+    template: NodeTemplate;
+}
+
+/**
+ * Classe che indica per una data query quali template applicare
+ */
+declare class NodeHTMLTemplate {
+    /**
+     * Query Cytoscape. Esempio **"[type = 'node']"** per prendere tutti i nodi la cui proprietà **type** all'interno dell'oggetto **data** è uguale a **node**
+     */
+    query: string;
+    /**
+     * Lista dei template da applicare in base al livello di zoom del diagramma
+     */
+    template: ZoomLevelBasedTemplate[];
+}
+
+/**
+ * Opzioni di layout di base che si collegano al **ready** e allo **stop** eventualmente per aggiungere del log addizionale
+ */
+declare class BaseLayoutOptionsImpl {
+    /**
+     * Per ora ignoro lato documentale dato che sono placholder
+     * @ignore
+     */
+    ready(e: cytoscape.LayoutEventObject): void;
+    /**
+     * Per ora ignoro lato documentale dato che sono placholder
+     * @ignore
+     */
+    stop(e: cytoscape.LayoutEventObject): void;
+}
+
+/**
+ * Classe base con le opzioni di layout valide per tutti i layout animati
+ */
+declare class AnimateLayoutOptionsImpl extends BaseLayoutOptionsImpl implements AnimatedLayoutOptions {
+    /** @ignore */
+    constructor();
+    /**
+     * Livello di zoom da impostare (si consiglia fit = **false** se viene impostato)
+     */
+    zoom: number;
+    /**
+     * Livello di pan da impostare (si consiglia fit = **false** se viene impostato)
+     */
+    pan: number;
+    /**
+     * Indica se animare il cambio di posizione dei nodi
+     */
+    animate: boolean;
+    /**
+     * Con **animate** a true indica la durata dell'animazione
+     */
+    animationDuration: number;
+    /**
+     * Abilita o no l'easing dell'animazione, può essere una stringa come ad esempio "ease-in-out-cubic" o altre funzioni scritte allo stesso modo prese da https://easings.net/
+     */
+    animationEasing: any;
+    /**
+     * Funzione che indica se un nodo dev'essere animato o no.
+     * Tutti i nodi sono animati di default.
+     * Tutti i nodi che non vengono animati verranno posizionati appena inizia l'animazione
+     *
+     * @param {any} node Nodo per cui decidere se abilitare l'animazione o no
+     * @param {number} i Indice del nodo corrente
+     *
+     * @returns {boolean} **true** se il nodo dev'essere animato, **false** altrimenti
+     */
+    animateFilter: (node: any, i: number) => boolean;
+}
+
+/**
+ * Classe base per gli algoritmi "Shaped"
+ */
+declare class ShapedLayoutOptionsImpl extends AnimateLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Indica se adattare al contenitore
+     */
+    fit: boolean;
+    /**
+     * Padding rispetto al contenitore
+     */
+    padding: number;
+    /**
+     * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+     */
+    boundingBox?: BoundingBox12 | BoundingBoxWH | undefined;
+    /**
+     * Fa in modo che i nodi non si accavallino, ma se il contenitore non ha abbastanza spazio potrebbero andare in overflow
+     */
+    avoidOverlap: boolean;
+    /**
+     * Include o esclude le dimensioni delle label dei nodi nel calcolo delle posizioni
+     */
+    nodeDimensionsIncludeLabels: boolean;
+    /**
+     * Moltiplicatore delle dimensioni per espandere/restringere le dimensioni globali del diagramma
+     */
+    spacingFactor: number;
+    /**
+     * Funzione di ordinamento per ordinare i nodi
+     */
+    sort?: SortingFunction;
+    /**
+     * Funzione per la trasformazione delle posizioni dei nodi
+     *
+     * @param {any} node Nodo
+     * @param {any} position Posizione iniziale
+     *
+     * @returns {any} Posizione finale
+     */
+    transform: (node: any, position: any) => any;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Breadth First
+ */
+declare class BreadthFirstLayoutOptionsImpl extends ShapedLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Indica se l'albero è diretto in basso. Se false i collegamenti fra i nodi possono andare in qualsiasi direzione
+     */
+    directed: boolean;
+    /**
+     * Se **true** i livelli vengono ordinati in cerchi concentrici, se **false** vengono oridnati dall'alto al basso
+     */
+    circle: boolean;
+    /**
+     * Radici degli alberi
+     */
+    roots?: string;
+    /**
+     * Numero massimo di tentativi di posizionamento dei nodi in maniera massimale (senza backtracking)
+     */
+    maximalAdjustments: number;
+    /**
+     * Indica che i nodi verranno shiftati in base al proprio livello in modo da evitare collegamenti inversi (solo per i DAG)
+     */
+    maximal: boolean;
+    /**
+     * Indica se creare una griglia in cui ordinare i nodi del DAG (Solo quando la proprietà **circle** è a **false**)
+     */
+    grid: boolean;
+    /**
+     * Indica se escludere le label dei nodi quando vengono calcolati i limiti del layout
+     */
+    nodeDimensionsIncludeLabels: boolean;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Circle
+ */
+declare class CircleLayoutOptionsImpl extends ShapedLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Raggio del cercho
+     */
+    radius: number;
+    /**
+     * Angolo da cui i nodi partono, in radianti (Default: **3 / 2 * Math.PI**)
+     */
+    startAngle: number;
+    /**
+     * Numero di radianti fra il primo e l'ultimo nodo. Di default viene utilizzata l'intera circonferenza
+     */
+    sweep: number;
+    /**
+     * Indica se andare in senso orario (**true**) o antiorario (**false**)
+     */
+    clockwise: boolean;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Concentric
+ */
+declare class ConcentricLayoutOptionsImpl {
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Numero di radianti fra il primo e l'ultimo nodo. Di default viene utilizzata l'intera circonferenza
+     */
+    sweep?: number;
+    /**
+     * Indica se andare in senso orario (**true**) o antiorario (**false**)
+     */
+    clockwise?: boolean;
+    /**
+     * Angolo da cui i nodi partono, in radianti (Default: **3 / 2 * Math.PI**)
+     */
+    startAngle: number;
+    /**
+     * Indica se adattare al contenitore
+     */
+    fit: boolean;
+    /**
+     * Include o esclude le dimensioni delle label dei nodi nel calcolo delle posizioni
+     */
+    nodeDimensionsIncludeLabels: boolean;
+    /**
+     * Indica se i livelli devono essere o non essere equidistanti, potrebbe causare overflow dal contenitore
+     */
+    equidistant: boolean;
+    /**
+     * Distanza minima dall'esterno dei nodi, utilizzato per aggiustare il raggio
+     */
+    minNodeSpacingnumber: number;
+    /**
+     * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+     */
+    boundingBox: BoundingBox12 | BoundingBoxWH | undefined;
+    /**
+     * Altezza dell'area di layout (sovrascrive quella del contenitore)
+     */
+    height: number;
+    /**
+     * Larghezza dell'area di layout (sovrascrive quella del contenitore)
+     */
+    width: number;
+    /**
+     * Moltiplicatore delle dimensioni per espandere/restringere le dimensioni globali del diagramma
+     */
+    spacingFactor: number;
+    /**
+     * Funzione di cui si può fare override per assegnare un valore ad ogni nodo. I nodi con valore più alto saranno piazzati verso il centro
+     *
+     * @param {any} node Nodo
+     *
+     * @returns {number} Valore su cui ordinare i nodi verso il centro
+     */
+    concentric(node: {
+        degree(): number;
+    }): number;
+    /**
+     * Funzione di cui si può fare override per calcolare la variazione dei valori concentrici per ogni livello
+     *
+     * @param {any} nodes Gruppo di nodi del livello
+     *
+     * @returns {number} Variazione dei valori concentrici
+     */
+    levelWidth(nodes: {
+        maxDegree(): number;
+    }): number;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Cose
+ */
+declare class CoseLayoutOptionsImpl extends ShapedLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Se **animate** è **true**, l'animazione parte solo dopo questo numero di millisecondi (Evita flickering su animazioni veloci)
+     */
+    animationThreshold: number;
+    /**
+     * Numero di iterazioni fra aggiornamenti consecutivi della posizione a schermo
+     */
+    refresh: number;
+    /**
+     * Se **true** la posizione iniziale dei nodi è casuale, se **false** utilizza la posizione originale
+     */
+    randomize: boolean;
+    /**
+     * Spazio extra fra i componenti di un grafo non-compound
+     */
+    componentSpacing: number;
+    /**
+     * Moltiplicatore della repulsione fra nodi in caso di overlap
+     */
+    nodeOverlap: number;
+    /**
+     * Moltiplicatore di nesting per il calcolo della lunghezza ideale dei collegamenti nested
+     */
+    nestingFactor: number;
+    /**
+     * Costante di gravità
+     */
+    gravity: number;
+    /**
+     * Numero massimo di iterazioni da eseguire
+     */
+    numIter: number;
+    /**
+     * Temperatura iniziale (massima distanza fra i nodi)
+     */
+    initialTemp: number;
+    /**
+     * Fattore di raffreddamento. Ad ogni iterazione verrà sottratto ad **initialTemp**
+     */
+    coolingFactor: number;
+    /**
+     * Soglia minima di temperatura. Una volta raggiunta il layout si considera terminato
+     */
+    minTemp: number;
+    /**
+     * Moltiplicatore della repulsione fra nodi in caso di assenza di overlap. Funzione overrideabile per ogni node
+     *
+     * @param {any} node Nodo
+     *
+     * @returns {number} Moltiplicazione di repulsione
+     */
+    nodeRepulsion: (node: any) => number;
+    /**
+     * Lunghezza ideale dei collegamenti non nested. Funzione overrideabile per ogni collegamento
+     *
+     * @param {any} edge Collegamento
+     *
+     * @returns {number} Lunghezza ideale
+     */
+    idealEdgeLength: (edge: any) => number;
+    /**
+     * Divisore per calcolare le forze applicate ad un collegamento. Funzione overrideabile per ogni collegamento
+     *
+     * @param {any} edge Collegamento
+     *
+     * @returns {number} Indice di elasticità
+     */
+    edgeElasticity: (edge: any) => number;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Dagre
+ */
+declare class DagreLayoutOptionsImpl extends ShapedLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Distanza fra nodi adiacenti dello stesso rango
+     */
+    nodeSep: number;
+    /**
+     * Distanza fra collegamenti adiacenti nello stesso rango
+     */
+    edgeSep: number;
+    /**
+     * Distanza fra ogni rango
+     */
+    rankSep: number;
+    /**
+     * Direzione di disegno: LR = Sinistra a Destra, TB = Sopra a Sotto
+     */
+    rankDir: 'LR' | 'TB';
+    /**
+     * Algoritmo che si occupa di assegnare un rango ad ogni nodo
+     */
+    ranker: 'network-simplex' | 'tight-tree' | 'longest-path';
+    /**
+     * Numero di ranghi fra la sorgente e la destinazione di un collegamento
+     *
+     * @param {any} edge Collegamento di cui calcolare la differenza di rango
+     *
+     * @returns {number} Differenza di rango
+     */
+    minLen: (edge: any) => number;
+    /**
+     * Peso del collegamento, più è alto più generalmente risulterà corto
+     *
+     * @param {any} edge Collegamento di cui calcolare il peso
+     *
+     * @returns {number} Peso
+     */
+    edgeWeight: (edge: any) => number;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Grid
+ */
+declare class GridLayoutOptionsImpl extends ShapedLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Spazio extra attorno ai nodi quando **avoidOverlap** è **true**
+     */
+    avoidOverlapPadding: number;
+    /**
+     * Se **true** cerca di utilizzare il minor spazio possibile, se **false** usa tutto lo spazio che ha a disposizione
+     */
+    condense: boolean;
+    /**
+     * Forzatura del numero di righe della griglia
+     */
+    rows?: number | undefined;
+    /**
+     * Forzatura del numero di colonne della griglia
+     */
+    cols?: number | undefined;
+    /**
+     * Dato un nodo restituisce un indice di riga e di colonna della griglia in cui metterlo
+     *
+     * @param {NodeSingular} node Nodo
+     * @returns {{ row: number, col: number }} Oggetto che identifica una posizione della griglia
+     */
+    position: (node: NodeSingular) => {
+        row: number;
+        col: number;
+    };
+}
+
+/**
+ * Pseudo implementazione di un algoritmo vuoto che non fa nulla
+ */
+declare class NullLayoutOptionsImpl extends BaseLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Preset (Posiziona i nodi in base alla loro proprietà **position**)
+ */
+declare class PresetLayoutOptionsImpl extends AnimateLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Indica se adattare al contenitore
+     */
+    fit?: boolean;
+    /**
+     * Padding rispetto al contenitore
+     */
+    padding?: number;
+    /**
+     * Mappatura da un nodo ad una posizione
+     *
+     * @param {any} node Nodo
+     *
+     * @returns {any} Posizione iniziale
+     */
+    positions: (node: any) => any;
+    /**
+     * Funzione per la trasformazione delle posizioni dei nodi
+     *
+     * @param {any} node Nodo
+     * @param {any} position Posizione iniziale
+     *
+     * @returns {any} Posizione finale
+     */
+    transform: (node: any, position: any) => any;
+}
+
+/**
+ * Default per l'implementazione dell'algoritmo Random
+ */
+declare class RandomLayoutOptionsImpl extends AnimateLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+    /**
+     * Indica se adattare al contenitore
+     */
+    fit: boolean;
+    /**
+     * Padding rispetto al contenitore
+     */
+    padding: number;
+    /**
+     * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+     */
+    boundingBox: cytoscape.BoundingBox12 | cytoscape.BoundingBoxWH | undefined;
+    /**
+     * Funzione per la trasformazione delle posizioni dei nodi
+     *
+     * @param {any} node Nodo
+     * @param {any} position Posizione iniziale
+     *
+     * @returns {any} Posizione finale
+     */
+    transform: (node: any, position: any) => any;
+}
+
+/**
+ * Classe di configurazione per il Modulo
+ */
+declare class EsDiagramModuleConfig {
+    /**
+     * Attiva o disattiva la modalità di debug per scrivere i messaggi a console
+     */
+    debugMode?: boolean;
+}
+
+/**
+ * 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
+ */
+declare class EsDiagramService {
+    private DIA_DEBUG_MODE;
+    /**
+     * Cache dei moduli caricati
+     */
+    private modulesCache;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(DIA_DEBUG_MODE: string);
+    /**
+     * 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: 'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'): Promise<void | cytoscape.Ext>;
+    /**
+     * 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
+     */
+    private handleError;
+    /**
+     * 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: 'E' | 'I' | 'W', text: string, requiresTranslation?: boolean): void;
+    /**
+     * Metodo di localizzazione dei messaggi
+     *
+     * @param {string} text Messaggio da tradurre
+     *
+     * @returns {string} Messaggio tradotto
+     */
+    loc(text: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsDiagramService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsDiagramService>;
+}
+
+/**
+ * Classe che si occupa del dispatch delle operazioni di rendering degli oggetti utilizzando una coda
+ */
+declare class EsDiagramDispatcher {
+    private logs;
+    /**
+     * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando oggetti
+     */
+    private 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
+     */
+    private Initialized;
+    /**
+     * @ignore
+     */
+    constructor(logs: boolean);
+    /**
+     * 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: string, creationFunction: Function): void;
+    /**
+     * 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: string): void;
+    /**
+     * 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
+     */
+    private drainInitQueues;
+    /**
+     * @ignore
+     */
+    private log;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsDiagramDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsDiagramDispatcher>;
+}
+
+/**
+ * Classe che fornisce metodi reattivi di estensione. Per ora implementato solo uno pseudo-throttle
+ */
+declare class ReactiveExtensions {
+    /**
+     * Cache di tutti i timer in esecuzione
+     */
+    private 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: string, func: Function, throttleTime?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReactiveExtensions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReactiveExtensions>;
+}
+
+/**
+ * Componente che si occupa di graficare un diagramma e di gestirne il ciclo di vita
+ */
+declare class EsDiagramComponent implements OnChanges {
+    private service;
+    private dispatcher;
+    private exts;
+    /**
+     * Riferimento all'oggetto HTML su cui creare il diagramma
+     */
+    cyGraph: ElementRef;
+    /**
+     * Nome del diagramma, fondamentale assegnarlo per permettere alla libreria di schedularne la creazione
+     */
+    name: string;
+    /**
+     * Indica se utilizzare il menù contestuale a ruota attorno ad ogni nodo
+     */
+    UseContextMenu: boolean;
+    /**
+     * Indica le opzioni del menù contestuale qualora **UseContextMenu** fosse **true**.
+     *
+     * Ogni elemento di questo array è un selettore con il menu da mostrare per quella casistica
+     */
+    ContextMenuOptions: ContextMenuOptions[];
+    /**
+     * Dice al componente se il diagramma deve utilizzare il sistema di estensione per l'expand e collapse dei gruppi
+     */
+    UseExpandCollapse: boolean;
+    /**
+     * Opzioni native dell'estensione expand-collapse, vengono ovviamente utilizzate solo se **UseExpandCollapse** è **true**
+     */
+    ExpandCollapseOptions: ExpandCollapseOptions;
+    /**
+     * 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
+     */
+    NativeOptions: cytoscape.CytoscapeOptions;
+    /**
+     * Definizione degli elementi da mostrare nel diagramma
+     */
+    Elements: cytoscape.ElementDefinition[];
+    /**
+     * Definizione degli stili dei nodi
+     */
+    NodeStyles: cytoscape.Css.Node;
+    /**
+     * Definizione degli stili dei collegamenti fra i nodi
+     */
+    EdgeStyles: cytoscape.Css.Edge;
+    /**
+     * In un diagramma in sola lettura tutte le interazioni utente sono annullate
+     */
+    Readonly: boolean;
+    /**
+     * Aggiorna automaticamente le dimensioni del diagramma quando cambiano le dimensioni della finestra
+     */
+    AutoupdateSize: boolean;
+    /**
+     * 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
+     */
+    PreserveElementsPosition: boolean;
+    /**
+     * 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
+     */
+    AnimateLayoutChanges: boolean;
+    /**
+     * Attiva una modalità di selezione "smart"... o perlomeno "smarter" del default di Cytoscape.
+     *
+     * - Il click di un elemento non selezionato lo seleziona
+     * - Il click di un elemento selezionato lo deseleziona
+     * - Lo stato di selezione viene persistito sull'oggetto originale invece di rimanere in un internal
+     * - All'assegnazione di oggetti selezionati, questi vengono marcati correttamente con l'overlay di selezione
+     *
+     * N.B: la chiamata all'evento **onNodeClick** avviene **DOPO** la gestione della selezione
+     */
+    SmartSelection: boolean;
+    /**
+     * Indica di selezionare un elemento per volta qualora **SmartSelection** fosse attivo
+     */
+    SingleSelection: boolean;
+    /**
+     * CSS per la graficazione della selezione dei nodi. Quando un nodo verrà selezionato avrà sopra di se un overlay che 'sborda' di **overlay-padding** pixel,
+     * di colore **overlay-color** e con un opacità **overlay-opacity**
+     *
+     * Assegnando "{}" a questo input, la Smart selection viene gestita ma la gestione grafica è affidata all'utente,
+     * ad esempio usando dei **NodeHTMLTemplates** che definiscano selettori su nodi ":selected"
+     *
+     * @default {'overlay-color':'blue','overlay-opacity':0.5,'overlay-padding':7}
+     */
+    SmartSelectionStyles: {
+        'overlay-color': string;
+        'overlay-opacity': number;
+        'overlay-padding': number;
+    };
+    /**
+     * 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.
+     */
+    ResizeThrottleTime: number;
+    /**
+     * Layout di ordinamento dei nodi
+     */
+    Layout: BreadthFirstLayoutOptionsImpl | CircleLayoutOptionsImpl | ConcentricLayoutOptionsImpl | CoseLayoutOptionsImpl | DagreLayoutOptionsImpl | GridLayoutOptionsImpl | NullLayoutOptionsImpl | PresetLayoutOptionsImpl | RandomLayoutOptionsImpl;
+    /**
+     * Template HTML da applicare ai nodi per dargli stili particolari, diversi dalle shape di default
+     */
+    NodeHTMLTemplates: NodeHTMLTemplate[];
+    /**
+     * 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));
+     *
+     *    ...
+     * }
+     * ```
+     */
+    ExtensionModulesImporter: (global: {
+        use: (moduleName: string, module: void | cytoscape.Ext) => void;
+    }) => Promise<any>;
+    /**
+     * 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();
+     *
+     *    ...
+     * }
+     * ```
+     */
+    ExtensionModulesApplyer: (cytoscapeCore: cytoscape.Core) => void;
+    /**
+     * Evento lanciato al click di un nodo, contiene l'oggetto **data** del nodo in questione
+     */
+    onNodeClick: EventEmitter<{
+        data: any;
+    }>;
+    /**
+     * Evento lanciato alla selezione o deselezione di un nodo, contiene l'oggetto **data** del nodo in questione e informazioni sul suo stato di selezione
+     */
+    onNodeSelection: EventEmitter<{
+        data: any;
+        selected: boolean;
+    }>;
+    /**
+     * Evento lanciato al termine del Layouting. Se si vuole eseguire codice dopo che il Layout è fatto e completamente graficato, questo è il punto
+     */
+    onLayoutDone: EventEmitter<void>;
+    /**
+     * Evento lanciato al termine del caricamento del diagramma
+     */
+    onLoaded: EventEmitter<void>;
+    /**
+     * 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
+     */
+    private NodesHierarchy;
+    /**
+     * Indica se il rendering del diagramma è terminato
+     */
+    private Rendered;
+    /**
+     * Istanza del diagramma attualmente in uso
+     */
+    cy: cytoscape.Core;
+    /**
+     * Api dell'estensione expand-collapse per permettere di effettuare operazioni dall'esterno del diagramma. Vengono valorizzate se **UseExpandCollapse** è **true**
+     */
+    ExpandCollapseApi: any;
+    /**
+     * Api dell'estensione html-node per permettere di effettuare operazioni dall'esterno del diagramma. Vengono valorizzate se sono impostati dei **NodeHTMLTemplates**
+     */
+    private HtmlNodeApi;
+    /**
+     * Osservatore delle modifiche al contenitore del diagramma
+     */
+    private resizeObserver;
+    /**
+     * Riferimento all'ultimo layout utilizzato. Viene riapplicato qualora venisse cambiato l'Input **Elements**.
+     *
+     * Non utilizzo il makeLayouts perché altrimenti rischierei di creare un layout riferito a X elementi, ne aggiungo 1, riapplico il Layout
+     * ma mi viene riapplicato a X elementi invece che X + 1
+     */
+    private LastLayout;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(service: EsDiagramService, dispatcher: EsDiagramDispatcher, exts: ReactiveExtensions);
+    /**
+     * @ignore
+     *
+     * Angular Pipeline
+     */
+    ngAfterViewInit(): void;
+    /**
+     * All'onDestroy ripulisco la memoria dal diagramma
+     */
+    ngOnDestroy(): void;
+    /**
+     * Registra il diagramma attuale nel Dispatcher in modo che venga caricato appena possibile
+     */
+    private dispatchLoadChart;
+    /**
+     * @ignore
+     *
+     * Angular Pipeline: Gestione ri-graficazione del diagramma, se possibile
+     */
+    ngOnChanges(changes: SimpleChanges): any;
+    /**
+     * Effettua il rendering del diagramma
+     */
+    private render;
+    /**
+     * Prende tutti gli elementi appena assegnati, e se qualcuno era selezionato la situazione viene persistita su cytoscape
+     */
+    private setupElementsSelectionIfNeeded;
+    /**
+     * Carica gli stili per mostrare carina la selezione dei nodi
+     */
+    private setupSelectionStyles;
+    /**
+     * Registra l'ascolto al contenitore del grafico e in caso di modifiche alla dimensione, al massimo una volta ogni 500 millisecondi, lo ridisegna
+     */
+    private listenOnChanges;
+    /**
+     * Funzione che si occupa di gestire il repaint del diagramma
+     */
+    private onContainerSizeChanged;
+    /**
+     * Collega tutti gli eventi che mi possono servire e li espone in output
+     */
+    private bindCytoscapeEvents;
+    /**
+     * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato
+     */
+    private performModulesLoading;
+    /**
+     * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato con le opzioni definite dagli Input
+     */
+    private performOperationsWithLoadedModules;
+    updateCardData(): void;
+    /**
+     * Metodo interno per il caricamento dei moduli di estensione
+     *
+     * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Modulo da caricare
+     */
+    private loadInternal;
+    /**
+     * 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
+     */
+    private getCompletedOptions;
+    /**
+     * 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
+     */
+    private reviewCytoscapeElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsDiagramComponent, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsDiagramComponent, "es-diagram", never, { "name": { "alias": "name"; "required": false; }; "UseContextMenu": { "alias": "UseContextMenu"; "required": false; }; "ContextMenuOptions": { "alias": "ContextMenuOptions"; "required": false; }; "UseExpandCollapse": { "alias": "UseExpandCollapse"; "required": false; }; "ExpandCollapseOptions": { "alias": "ExpandCollapseOptions"; "required": false; }; "NativeOptions": { "alias": "NativeOptions"; "required": false; }; "Elements": { "alias": "Elements"; "required": false; }; "NodeStyles": { "alias": "NodeStyles"; "required": false; }; "EdgeStyles": { "alias": "EdgeStyles"; "required": false; }; "Readonly": { "alias": "Readonly"; "required": false; }; "AutoupdateSize": { "alias": "AutoupdateSize"; "required": false; }; "PreserveElementsPosition": { "alias": "PreserveElementsPosition"; "required": false; }; "AnimateLayoutChanges": { "alias": "AnimateLayoutChanges"; "required": false; }; "SmartSelection": { "alias": "SmartSelection"; "required": false; }; "SingleSelection": { "alias": "SingleSelection"; "required": false; }; "SmartSelectionStyles": { "alias": "SmartSelectionStyles"; "required": false; }; "ResizeThrottleTime": { "alias": "ResizeThrottleTime"; "required": false; }; "Layout": { "alias": "Layout"; "required": false; }; "NodeHTMLTemplates": { "alias": "NodeHTMLTemplates"; "required": false; }; "ExtensionModulesImporter": { "alias": "ExtensionModulesImporter"; "required": false; }; "ExtensionModulesApplyer": { "alias": "ExtensionModulesApplyer"; "required": false; }; }, { "onNodeClick": "onNodeClick"; "onNodeSelection": "onNodeSelection"; "onLayoutDone": "onLayoutDone"; "onLoaded": "onLoaded"; }, never, never, false, never>;
+}
+
+declare class EsDiagramModule {
+    static forRoot(config?: EsDiagramModuleConfig): ModuleWithProviders<EsDiagramModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsDiagramModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EsDiagramModule, [typeof EsDiagramComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i2.CommonModule], [typeof EsDiagramComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EsDiagramModule>;
+}
+
+export { BaseLayoutOptionsImpl, BreadthFirstLayoutOptionsImpl, CircleLayoutOptionsImpl, ConcentricLayoutOptionsImpl, ContextMenuCommand, ContextMenuOptions, CoseLayoutOptionsImpl, DagreLayoutOptionsImpl, EsDiagramComponent, EsDiagramModule, EsDiagramModuleConfig, ExpandCollapseOptions, GridLayoutOptionsImpl, NodeHTMLTemplate, NodeTemplate, NullLayoutOptionsImpl, PresetLayoutOptionsImpl, RandomLayoutOptionsImpl, ShapedLayoutOptionsImpl, ZoomLevelBasedTemplate };