@esfaenza/es-diagrams 11.0.2

package/lib/models/component/grouping/ExpandCollapseOptions.d.ts

@@ -0,0 +1,22 @@
+/**
+ *  Opzioni native per l'estensione expand-collapse di cytoscape
+ */
+export 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;
+}

package/lib/models/component/nodes/NodeHTMLTemplate.d.ts

@@ -0,0 +1,14 @@
+import { ZoomLevelBasedTemplate } from "./ZoomLevelBasedTemplate";
+/**
+ * Classe che indica per una data query quali template applicare
+ */
+export 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[];
+}

package/lib/models/component/nodes/NodeTemplate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Classe che rappresenta un template HTML applicabile ad un nodo
+ */
+export 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;
+}

package/lib/models/component/nodes/ZoomLevelBasedTemplate.d.ts

@@ -0,0 +1,14 @@
+import { NodeTemplate } from "./NodeTemplate";
+/**
+ * Classe che rappresenta il template HTML di un nodo da utilizzare per un certo livello di zoom
+ */
+export declare class ZoomLevelBasedTemplate {
+    /**
+     * Livello di zoom da minimo a massimo per cui viene utilizzato questo template
+     */
+    zoomRange: [number, number];
+    /**
+     * Template da utilizzare
+     */
+    template: NodeTemplate;
+}

package/lib/models/layouts/BreadthFirstLayoutOptionsImpl.d.ts

@@ -0,0 +1,40 @@
+import { ShapedLayoutOptionsImpl } from './base/ShapedLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Breadth First
+ */
+export 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;
+}

package/lib/models/layouts/CircleLayoutOptionsImpl.d.ts

@@ -0,0 +1,28 @@
+import { ShapedLayoutOptionsImpl } from './base/ShapedLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Circle
+ */
+export 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;
+}

package/lib/models/layouts/ConcentricLayoutOptionsImpl.d.ts

@@ -0,0 +1,74 @@
+import { BoundingBox12, BoundingBoxWH } from "cytoscape";
+/**
+ * Default per l'implementazione dell'algoritmo Concentric
+ */
+export 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;
+}

package/lib/models/layouts/CoseLayoutOptionsImpl.d.ts

@@ -0,0 +1,80 @@
+import { ShapedLayoutOptionsImpl } from './base/ShapedLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Cose
+ */
+export 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;
+}

package/lib/models/layouts/DagreLayoutOptionsImpl.d.ts

@@ -0,0 +1,48 @@
+import { ShapedLayoutOptionsImpl } from './base/ShapedLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Dagre
+ */
+export 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;
+}

package/lib/models/layouts/GridLayoutOptionsImpl.d.ts

@@ -0,0 +1,39 @@
+import { NodeSingular } from 'cytoscape';
+import { ShapedLayoutOptionsImpl } from './base/ShapedLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Grid
+ */
+export 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;
+    };
+}

package/lib/models/layouts/NullLayoutOptionsImpl.d.ts

@@ -0,0 +1,12 @@
+import { BaseLayoutOptionsImpl } from './base/BaseLayoutOptionsImpl';
+/**
+ * Pseudo implementazione di un algoritmo vuoto che non fa nulla
+ */
+export declare class NullLayoutOptionsImpl extends BaseLayoutOptionsImpl {
+    /** @ignore */
+    constructor();
+    /**
+     * Nome dell'algoritmo di layouting
+     */
+    name: string;
+}

package/lib/models/layouts/PresetLayoutOptionsImpl.d.ts

@@ -0,0 +1,37 @@
+import { AnimateLayoutOptionsImpl } from './base/AnimateLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Preset (Posiziona i nodi in base alla loro proprietà **position**)
+ */
+export 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;
+}

package/lib/models/layouts/RandomLayoutOptionsImpl.d.ts

@@ -0,0 +1,33 @@
+import { AnimateLayoutOptionsImpl } from './base/AnimateLayoutOptionsImpl';
+/**
+ * Default per l'implementazione dell'algoritmo Random
+ */
+export 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;
+}

package/lib/models/layouts/base/AnimateLayoutOptionsImpl.d.ts

@@ -0,0 +1,40 @@
+import { AnimatedLayoutOptions } from 'cytoscape';
+import { BaseLayoutOptionsImpl } from './BaseLayoutOptionsImpl';
+/**
+ * Classe base con le opzioni di layout valide per tutti i layout animati
+ */
+export 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;
+}

package/lib/models/layouts/base/BaseLayoutOptionsImpl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Opzioni di layout di base che si collegano al **ready** e allo **stop** eventualmente per aggiungere del log addizionale
+ */
+export 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;
+}

package/lib/models/layouts/base/ShapedLayoutOptionsImpl.d.ts

@@ -0,0 +1,46 @@
+import { BoundingBox12, BoundingBoxWH, SortingFunction } from 'cytoscape';
+import { AnimateLayoutOptionsImpl } from './AnimateLayoutOptionsImpl';
+/**
+ * Classe base per gli algoritmi "Shaped"
+ */
+export 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;
+}

package/lib/services/es-diagram.dispatcher.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Classe che si occupa del dispatch delle operazioni di rendering degli oggetti utilizzando una coda
+ */
+export 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;
+}

package/lib/services/es-diagram.loc.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Oggetto statico di localizzazione per i messaggi
+ */
+export declare const Loc: {
+    Module: {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Received an undefined module. Make sure you are correctly loading it": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Module not available. Loading it now": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Module already loaded": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Diagram container size has changed, redrawing": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Module cannot be loaded": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "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": string;
+        "it-IT": string;
+    };
+    "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": string;
+        "it-IT": string;
+    };
+    "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": string;
+        "it-IT": string;
+    };
+    "Elements have been changed after diagram initialization": {
+        "en-US": string;
+        "it-IT": string;
+    };
+    "Layout have been changed after diagram initialization": {
+        "en-US": string;
+        "it-IT": string;
+    };
+};