ngx-vflow 0.1.0

package/esm2022/lib/vflow/components/vflow/vflow.component.mjs

@@ -0,0 +1,183 @@
+import { ChangeDetectionStrategy, Component, ContentChild, Injector, Input, ViewChild, inject, runInInjectionContext } from '@angular/core';
+import { MapContextDirective } from '../../directives/map-context.directive';
+import { DraggableService } from '../../services/draggable.service';
+import { ViewportService } from '../../services/viewport.service';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { ConnectionTemplateDirective, EdgeLabelHtmlTemplateDirective, EdgeTemplateDirective, HandleTemplateDirective, NodeHtmlTemplateDirective } from '../../directives/template.directive';
+import { addNodesToEdges } from '../../utils/add-nodes-to-edges';
+import { FlowModel } from '../../models/flow.model';
+import { skip } from 'rxjs';
+import { FlowStatusService } from '../../services/flow-status.service';
+import { ConnectionControllerDirective } from '../../directives/connection-controller.directive';
+import { FlowEntitiesService } from '../../services/flow-entities.service';
+import { ConnectionModel } from '../../models/connection.model';
+import { ReferenceKeeper } from '../../utils/reference-keeper';
+import { NodesChangeService } from '../../services/node-changes.service';
+import { EdgeChangesService } from '../../services/edge-changes.service';
+import { ChangesControllerDirective } from '../../directives/changes-controller.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/connection-controller.directive";
+import * as i2 from "../../directives/changes-controller.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "../node/node.component";
+import * as i5 from "../edge/edge.component";
+import * as i6 from "../connection/connection.component";
+import * as i7 from "../defs/defs.component";
+import * as i8 from "../../directives/space-point-context.directive";
+import * as i9 from "../../directives/map-context.directive";
+import * as i10 from "../../directives/reference.directive";
+import * as i11 from "../../directives/root-svg-context.directive";
+const connectionControllerHostDirective = {
+    directive: ConnectionControllerDirective,
+    outputs: ['onConnect']
+};
+const changesControllerHostDirective = {
+    directive: ChangesControllerDirective,
+    outputs: ['onNodesChange', 'onEdgesChange']
+};
+export class VflowComponent {
+    constructor() {
+        // #region DI
+        this.viewportService = inject(ViewportService);
+        this.flowEntitiesService = inject(FlowEntitiesService);
+        this.nodesChangeService = inject(NodesChangeService);
+        this.edgesChangeService = inject(EdgeChangesService);
+        this.injector = inject(Injector);
+        this.minZoom = 0.5;
+        this.maxZoom = 3;
+        this.background = '#FFFFFF';
+        // #endregion
+        // #region SIGNAL_API
+        this.viewport = this.viewportService.readableViewport.asReadonly();
+        this.nodesChange = toSignal(this.nodesChangeService.changes$, { initialValue: [] });
+        this.edgesChange = toSignal(this.edgesChangeService.changes$, { initialValue: [] });
+        // #endregion
+        // #region RX_API
+        this.viewportChanges$ = toObservable(this.viewportService.readableViewport)
+            .pipe(skip(1)); // skip default value that set by signal
+        this.nodesChange$ = this.nodesChangeService.changes$;
+        this.edgesChange$ = this.edgesChangeService.changes$;
+        // #endregion
+        // TODO: probably better to make it injectable
+        this.flowModel = new FlowModel();
+        this.markers = this.flowEntitiesService.markers;
+    }
+    // #endregion
+    // #region SETTINGS
+    /**
+     * Size for flow view
+     *
+     * accepts
+     * - absolute size in format [width, height] or
+     * - 'auto' to compute size based on parent element size
+     */
+    set view(view) {
+        this.flowModel.view.set(view);
+    }
+    set handlePositions(handlePositions) {
+        this.flowModel.handlePositions.set(handlePositions);
+    }
+    set connection(connection) { this.flowEntitiesService.connection.set(connection); }
+    get connection() { return this.flowEntitiesService.connection(); }
+    // #endregion
+    // #region MAIN_INPUTS
+    set nodes(newNodes) {
+        const newModels = runInInjectionContext(this.injector, () => ReferenceKeeper.nodes(newNodes, this.flowEntitiesService.nodes()));
+        // TODO better to solve this by DI
+        bindFlowToNodes(this.flowModel, newModels);
+        // quick and dirty binding nodes to edges
+        addNodesToEdges(newModels, this.flowEntitiesService.edges());
+        this.flowEntitiesService.nodes.set(newModels);
+    }
+    get nodeModels() { return this.flowEntitiesService.nodes(); }
+    set edges(newEdges) {
+        const newModels = ReferenceKeeper.edges(newEdges, this.flowEntitiesService.edges());
+        // quick and dirty binding nodes to edges
+        addNodesToEdges(this.nodeModels, newModels);
+        this.flowEntitiesService.edges.set(newModels);
+    }
+    get edgeModels() { return this.flowEntitiesService.validEdges(); }
+    // #region METHODS_API
+    viewportTo(viewport) {
+        this.viewportService.writableViewport.set({ changeType: 'absolute', state: viewport });
+    }
+    zoomTo(zoom) {
+        this.viewportService.writableViewport.set({ changeType: 'absolute', state: { zoom } });
+    }
+    panTo(point) {
+        this.viewportService.writableViewport.set({ changeType: 'absolute', state: point });
+    }
+    getNode(id) {
+        return this.flowEntitiesService.getNode(id)?.node;
+    }
+    // #endregion
+    trackNodes(idx, { node }) {
+        return node.id;
+    }
+    trackEdges(idx, { edge }) {
+        return edge.id;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: VflowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "16.2.12", type: VflowComponent, selector: "vflow", inputs: { view: "view", minZoom: "minZoom", maxZoom: "maxZoom", handlePositions: "handlePositions", background: "background", connection: ["connection", "connection", (settings) => new ConnectionModel(settings)], nodes: "nodes", edges: "edges" }, providers: [
+            DraggableService,
+            ViewportService,
+            FlowStatusService,
+            FlowEntitiesService,
+            NodesChangeService,
+            EdgeChangesService
+        ], queries: [{ propertyName: "nodeHtmlDirective", first: true, predicate: NodeHtmlTemplateDirective, descendants: true }, { propertyName: "edgeTemplateDirective", first: true, predicate: EdgeTemplateDirective, descendants: true }, { propertyName: "edgeLabelHtmlDirective", first: true, predicate: EdgeLabelHtmlTemplateDirective, descendants: true }, { propertyName: "connectionTemplateDirective", first: true, predicate: ConnectionTemplateDirective, descendants: true }, { propertyName: "handleTemplateDirective", first: true, predicate: HandleTemplateDirective, descendants: true }], viewQueries: [{ propertyName: "mapContext", first: true, predicate: MapContextDirective, descendants: true }], hostDirectives: [{ directive: i1.ConnectionControllerDirective, outputs: ["onConnect", "onConnect"] }, { directive: i2.ChangesControllerDirective, outputs: ["onNodesChange", "onNodesChange", "onEdgesChange", "onEdgesChange"] }], ngImport: i0, template: "<svg:svg\n  rootSvgRef\n  rootSvgContext\n  class=\"root-svg\"\n  #flow\n  [style.backgroundColor]=\"background\"\n  [attr.width]=\"flowModel.flowWidth()\"\n  [attr.height]=\"flowModel.flowHeight()\"\n>\n  <defs [markers]=\"markers()\" flowDefs />\n\n  <svg:g\n    mapContext\n    spacePointContext\n    [minZoom]=\"minZoom\"\n    [maxZoom]=\"maxZoom\"\n  >\n    <!-- Connection -->\n    <svg:g\n      connection\n      [model]=\"connection\"\n      [template]=\"connectionTemplateDirective?.templateRef\"\n    />\n\n    <!-- Edges  -->\n    <svg:g\n      *ngFor=\"let model of edgeModels; trackBy: trackEdges\"\n      edge\n      [model]=\"model\"\n      [edgeTemplate]=\"edgeTemplateDirective?.templateRef\"\n      [edgeLabelHtmlTemplate]=\"edgeLabelHtmlDirective?.templateRef\"\n    />\n\n    <!-- Nodes -->\n    <svg:g\n      *ngFor=\"let model of nodeModels; trackBy: trackNodes\"\n      node\n      [nodeModel]=\"model\"\n      [nodeHtmlTemplate]=\"nodeHtmlDirective?.templateRef\"\n      [handleTemplate]=\"handleTemplateDirective?.templateRef\"\n      [attr.transform]=\"model.pointTransform()\"\n    />\n  </svg:g>\n\n</svg:svg>\n", styles: [":host{display:block;width:100%;height:100%;-webkit-user-select:none;user-select:none}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i4.NodeComponent, selector: "g[node]", inputs: ["nodeModel", "nodeHtmlTemplate", "handleTemplate"] }, { kind: "component", type: i5.EdgeComponent, selector: "g[edge]", inputs: ["model", "edgeTemplate", "edgeLabelHtmlTemplate"] }, { kind: "component", type: i6.ConnectionComponent, selector: "g[connection]", inputs: ["model", "template"] }, { kind: "component", type: i7.DefsComponent, selector: "defs[flowDefs]", inputs: ["markers"] }, { kind: "directive", type: i8.SpacePointContextDirective, selector: "g[spacePointContext]" }, { kind: "directive", type: i9.MapContextDirective, selector: "g[mapContext]", inputs: ["minZoom", "maxZoom"] }, { kind: "directive", type: i10.RootSvgReferenceDirective, selector: "svg[rootSvgRef]" }, { kind: "directive", type: i11.RootSvgContextDirective, selector: "svg[rootSvgContext]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: VflowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vflow', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        DraggableService,
+                        ViewportService,
+                        FlowStatusService,
+                        FlowEntitiesService,
+                        NodesChangeService,
+                        EdgeChangesService
+                    ], hostDirectives: [
+                        connectionControllerHostDirective,
+                        changesControllerHostDirective
+                    ], template: "<svg:svg\n  rootSvgRef\n  rootSvgContext\n  class=\"root-svg\"\n  #flow\n  [style.backgroundColor]=\"background\"\n  [attr.width]=\"flowModel.flowWidth()\"\n  [attr.height]=\"flowModel.flowHeight()\"\n>\n  <defs [markers]=\"markers()\" flowDefs />\n\n  <svg:g\n    mapContext\n    spacePointContext\n    [minZoom]=\"minZoom\"\n    [maxZoom]=\"maxZoom\"\n  >\n    <!-- Connection -->\n    <svg:g\n      connection\n      [model]=\"connection\"\n      [template]=\"connectionTemplateDirective?.templateRef\"\n    />\n\n    <!-- Edges  -->\n    <svg:g\n      *ngFor=\"let model of edgeModels; trackBy: trackEdges\"\n      edge\n      [model]=\"model\"\n      [edgeTemplate]=\"edgeTemplateDirective?.templateRef\"\n      [edgeLabelHtmlTemplate]=\"edgeLabelHtmlDirective?.templateRef\"\n    />\n\n    <!-- Nodes -->\n    <svg:g\n      *ngFor=\"let model of nodeModels; trackBy: trackNodes\"\n      node\n      [nodeModel]=\"model\"\n      [nodeHtmlTemplate]=\"nodeHtmlDirective?.templateRef\"\n      [handleTemplate]=\"handleTemplateDirective?.templateRef\"\n      [attr.transform]=\"model.pointTransform()\"\n    />\n  </svg:g>\n\n</svg:svg>\n", styles: [":host{display:block;width:100%;height:100%;-webkit-user-select:none;user-select:none}\n"] }]
+        }], propDecorators: { view: [{
+                type: Input
+            }], minZoom: [{
+                type: Input
+            }], maxZoom: [{
+                type: Input
+            }], handlePositions: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }], connection: [{
+                type: Input,
+                args: [{ transform: (settings) => new ConnectionModel(settings) }]
+            }], nodes: [{
+                type: Input,
+                args: [{ required: true }]
+            }], edges: [{
+                type: Input
+            }], nodeHtmlDirective: [{
+                type: ContentChild,
+                args: [NodeHtmlTemplateDirective]
+            }], edgeTemplateDirective: [{
+                type: ContentChild,
+                args: [EdgeTemplateDirective]
+            }], edgeLabelHtmlDirective: [{
+                type: ContentChild,
+                args: [EdgeLabelHtmlTemplateDirective]
+            }], connectionTemplateDirective: [{
+                type: ContentChild,
+                args: [ConnectionTemplateDirective]
+            }], handleTemplateDirective: [{
+                type: ContentChild,
+                args: [HandleTemplateDirective]
+            }], mapContext: [{
+                type: ViewChild,
+                args: [MapContextDirective]
+            }] } });
+function bindFlowToNodes(flow, nodes) {
+    nodes.forEach(n => n.bindFlow(flow));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vflow.component.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-vflow-lib/src/lib/vflow/components/vflow/vflow.component.ts","../../../../../../../projects/ngx-vflow-lib/src/lib/vflow/components/vflow/vflow.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Injector, Input, OnChanges, Output, Signal, SimpleChanges, ViewChild, computed, effect, inject, runInInjectionContext } from '@angular/core';\nimport { Node } from '../../interfaces/node.interface';\nimport { MapContextDirective } from '../../directives/map-context.directive';\nimport { DraggableService } from '../../services/draggable.service';\nimport { NodeModel } from '../../models/node.model';\nimport { ViewportService } from '../../services/viewport.service';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { Edge } from '../../interfaces/edge.interface';\nimport { EdgeModel } from '../../models/edge.model';\nimport { ConnectionTemplateDirective, EdgeLabelHtmlTemplateDirective, EdgeTemplateDirective, HandleTemplateDirective, NodeHtmlTemplateDirective } from '../../directives/template.directive';\nimport { HandlePositions } from '../../interfaces/handle-positions.interface';\nimport { addNodesToEdges } from '../../utils/add-nodes-to-edges';\nimport { FlowModel } from '../../models/flow.model';\nimport { skip } from 'rxjs';\nimport { Point } from '../../interfaces/point.interface';\nimport { ViewportState } from '../../interfaces/viewport.interface';\nimport { FlowStatusService } from '../../services/flow-status.service';\nimport { ConnectionControllerDirective } from '../../directives/connection-controller.directive';\nimport { FlowEntitiesService } from '../../services/flow-entities.service';\nimport { ConnectionSettings } from '../../interfaces/connection-settings.interface';\nimport { ConnectionModel } from '../../models/connection.model';\nimport { ReferenceKeeper } from '../../utils/reference-keeper';\nimport { NodesChangeService } from '../../services/node-changes.service';\nimport { EdgeChangesService } from '../../services/edge-changes.service';\nimport { NodeChange } from '../../types/node-change.type';\nimport { ChangesControllerDirective } from '../../directives/changes-controller.directive';\nimport { EdgeChange } from '../../types/edge-change.type';\n\nconst connectionControllerHostDirective = {\n  directive: ConnectionControllerDirective,\n  outputs: ['onConnect']\n}\n\nconst changesControllerHostDirective = {\n  directive: ChangesControllerDirective,\n  outputs: ['onNodesChange', 'onEdgesChange']\n}\n\n@Component({\n  selector: 'vflow',\n  templateUrl: './vflow.component.html',\n  styleUrls: ['./vflow.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    DraggableService,\n    ViewportService,\n    FlowStatusService,\n    FlowEntitiesService,\n    NodesChangeService,\n    EdgeChangesService\n  ],\n  hostDirectives: [\n    connectionControllerHostDirective,\n    changesControllerHostDirective\n  ]\n})\nexport class VflowComponent {\n  // #region DI\n  protected viewportService = inject(ViewportService)\n  protected flowEntitiesService = inject(FlowEntitiesService)\n  protected nodesChangeService = inject(NodesChangeService)\n  protected edgesChangeService = inject(EdgeChangesService)\n  protected injector = inject(Injector)\n  // #endregion\n\n  // #region SETTINGS\n\n  /**\n   * Size for flow view\n   *\n   * accepts\n   * - absolute size in format [width, height] or\n   * - 'auto' to compute size based on parent element size\n   */\n  @Input()\n  public set view(view: [number, number] | 'auto') {\n    this.flowModel.view.set(view)\n  }\n\n  @Input()\n  public minZoom = 0.5\n\n  @Input()\n  public maxZoom = 3\n\n  @Input()\n  public set handlePositions(handlePositions: HandlePositions) {\n    this.flowModel.handlePositions.set(handlePositions)\n  }\n\n  @Input()\n  public background: string = '#FFFFFF'\n\n  @Input({ transform: (settings: ConnectionSettings) => new ConnectionModel(settings) })\n  public set connection(connection: ConnectionModel) { this.flowEntitiesService.connection.set(connection) }\n  public get connection() { return this.flowEntitiesService.connection() }\n  // #endregion\n\n  // #region MAIN_INPUTS\n  @Input({ required: true })\n  public set nodes(newNodes: Node[]) {\n    const newModels = runInInjectionContext(this.injector,\n      () => ReferenceKeeper.nodes(newNodes, this.flowEntitiesService.nodes())\n    )\n\n    // TODO better to solve this by DI\n    bindFlowToNodes(this.flowModel, newModels)\n\n    // quick and dirty binding nodes to edges\n    addNodesToEdges(newModels, this.flowEntitiesService.edges())\n\n    this.flowEntitiesService.nodes.set(newModels)\n  }\n\n  public get nodeModels() { return this.flowEntitiesService.nodes() }\n\n  @Input()\n  public set edges(newEdges: Edge[]) {\n    const newModels = ReferenceKeeper.edges(newEdges, this.flowEntitiesService.edges())\n\n    // quick and dirty binding nodes to edges\n    addNodesToEdges(this.nodeModels, newModels)\n\n    this.flowEntitiesService.edges.set(newModels)\n  }\n\n  public get edgeModels() { return this.flowEntitiesService.validEdges() }\n  // #endregion\n\n  // #region TEMPLATES\n  @ContentChild(NodeHtmlTemplateDirective)\n  protected nodeHtmlDirective?: NodeHtmlTemplateDirective\n\n  @ContentChild(EdgeTemplateDirective)\n  protected edgeTemplateDirective?: EdgeTemplateDirective\n\n  @ContentChild(EdgeLabelHtmlTemplateDirective)\n  protected edgeLabelHtmlDirective?: EdgeLabelHtmlTemplateDirective\n\n  @ContentChild(ConnectionTemplateDirective)\n  protected connectionTemplateDirective?: ConnectionTemplateDirective\n\n  @ContentChild(HandleTemplateDirective)\n  protected handleTemplateDirective?: HandleTemplateDirective\n  // #endregion\n\n  // #region DIRECTIVES\n  @ViewChild(MapContextDirective)\n  protected mapContext!: MapContextDirective\n  // #endregion\n\n  // #region SIGNAL_API\n  public readonly viewport = this.viewportService.readableViewport.asReadonly()\n\n  public readonly nodesChange =\n    toSignal(this.nodesChangeService.changes$, { initialValue: [] as NodeChange[] })\n\n  public readonly edgesChange =\n    toSignal(this.edgesChangeService.changes$, { initialValue: [] as EdgeChange[] })\n  // #endregion\n\n  // #region RX_API\n  public readonly viewportChanges$ = toObservable(this.viewportService.readableViewport)\n    .pipe(skip(1)) // skip default value that set by signal\n\n  public readonly nodesChange$ = this.nodesChangeService.changes$\n\n  public readonly edgesChange$ = this.edgesChangeService.changes$\n  // #endregion\n\n  // TODO: probably better to make it injectable\n  protected flowModel = new FlowModel()\n\n  protected markers = this.flowEntitiesService.markers\n\n  // #region METHODS_API\n  public viewportTo(viewport: ViewportState): void {\n    this.viewportService.writableViewport.set({ changeType: 'absolute', state: viewport })\n  }\n\n  public zoomTo(zoom: number): void {\n    this.viewportService.writableViewport.set({ changeType: 'absolute', state: { zoom } })\n  }\n\n  public panTo(point: Point): void {\n    this.viewportService.writableViewport.set({ changeType: 'absolute', state: point })\n  }\n\n  public getNode<T = unknown>(id: string): Node<T> | undefined {\n    return this.flowEntitiesService.getNode<T>(id)?.node\n  }\n  // #endregion\n\n  protected trackNodes(idx: number, { node }: NodeModel) {\n    return node.id\n  }\n\n  protected trackEdges(idx: number, { edge }: EdgeModel) {\n    return edge.id\n  }\n}\n\nfunction bindFlowToNodes(flow: FlowModel, nodes: NodeModel[]) {\n  nodes.forEach(n => n.bindFlow(flow))\n}\n\n","<svg:svg\n  rootSvgRef\n  rootSvgContext\n  class=\"root-svg\"\n  #flow\n  [style.backgroundColor]=\"background\"\n  [attr.width]=\"flowModel.flowWidth()\"\n  [attr.height]=\"flowModel.flowHeight()\"\n>\n  <defs [markers]=\"markers()\" flowDefs />\n\n  <svg:g\n    mapContext\n    spacePointContext\n    [minZoom]=\"minZoom\"\n    [maxZoom]=\"maxZoom\"\n  >\n    <!-- Connection -->\n    <svg:g\n      connection\n      [model]=\"connection\"\n      [template]=\"connectionTemplateDirective?.templateRef\"\n    />\n\n    <!-- Edges  -->\n    <svg:g\n      *ngFor=\"let model of edgeModels; trackBy: trackEdges\"\n      edge\n      [model]=\"model\"\n      [edgeTemplate]=\"edgeTemplateDirective?.templateRef\"\n      [edgeLabelHtmlTemplate]=\"edgeLabelHtmlDirective?.templateRef\"\n    />\n\n    <!-- Nodes -->\n    <svg:g\n      *ngFor=\"let model of nodeModels; trackBy: trackNodes\"\n      node\n      [nodeModel]=\"model\"\n      [nodeHtmlTemplate]=\"nodeHtmlDirective?.templateRef\"\n      [handleTemplate]=\"handleTemplateDirective?.templateRef\"\n      [attr.transform]=\"model.pointTransform()\"\n    />\n  </svg:g>\n\n</svg:svg>\n"]}

package/esm2022/lib/vflow/directives/changes-controller.directive.mjs

@@ -0,0 +1,34 @@
+import { Directive, EventEmitter, Output, inject } from '@angular/core';
+import { EdgeChangesService } from '../services/edge-changes.service';
+import { NodesChangeService } from '../services/node-changes.service';
+import { tap } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+export class ChangesControllerDirective {
+    constructor() {
+        this.nodesChangeService = inject(NodesChangeService);
+        this.edgesChangeService = inject(EdgeChangesService);
+        this.onNodesChange = new EventEmitter();
+        this.onEdgesChange = new EventEmitter();
+        this.nodesChangeProxySubscription = this.nodesChangeService.changes$
+            .pipe(tap((changes) => this.onNodesChange.emit(changes)), takeUntilDestroyed())
+            .subscribe();
+        this.edgesChangeProxySubscription = this.edgesChangeService.changes$
+            .pipe(tap((changes) => this.onEdgesChange.emit(changes)), takeUntilDestroyed())
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChangesControllerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ChangesControllerDirective, isStandalone: true, selector: "[changesController]", outputs: { onNodesChange: "onNodesChange", onEdgesChange: "onEdgesChange" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChangesControllerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[changesController]',
+                    standalone: true
+                }]
+        }], propDecorators: { onNodesChange: [{
+                type: Output
+            }], onEdgesChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/directives/connection-controller.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, EventEmitter, Output, effect, inject } from '@angular/core';
+import { FlowStatusService } from '../services/flow-status.service';
+import { FlowEntitiesService } from '../services/flow-entities.service';
+import * as i0 from "@angular/core";
+export class ConnectionControllerDirective {
+    constructor() {
+        this.onConnect = new EventEmitter();
+        this.statusService = inject(FlowStatusService);
+        this.flowEntitiesService = inject(FlowEntitiesService);
+        this.connectEffect = effect(() => {
+            const status = this.statusService.status();
+            if (status.state === 'connection-end') {
+                const sourceModel = status.payload.sourceNode;
+                const targetModel = status.payload.targetNode;
+                const source = sourceModel.node.id;
+                const target = targetModel.node.id;
+                const connection = this.flowEntitiesService.connection();
+                if (connection.validator({ source, target })) {
+                    this.onConnect.emit({ source, target });
+                }
+            }
+        }, { allowSignalWrites: true });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectionControllerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ConnectionControllerDirective, isStandalone: true, selector: "[connectionController]", outputs: { onConnect: "onConnect" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectionControllerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[connectionController]',
+                    standalone: true
+                }]
+        }], propDecorators: { onConnect: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/directives/map-context.directive.mjs

@@ -0,0 +1,62 @@
+import { Directive, ElementRef, Input, effect, inject } from '@angular/core';
+import { select } from 'd3-selection';
+import { zoom, zoomIdentity } from 'd3-zoom';
+import { ViewportService } from '../services/viewport.service';
+import { isDefined } from '../utils/is-defined';
+import { RootSvgReferenceDirective } from './reference.directive';
+import * as i0 from "@angular/core";
+export class MapContextDirective {
+    constructor() {
+        this.rootSvg = inject(RootSvgReferenceDirective).element;
+        this.host = inject(ElementRef).nativeElement;
+        this.viewportService = inject(ViewportService);
+        this.rootSvgSelection = select(this.rootSvg);
+        this.zoomableSelection = select(this.host);
+        // under the hood this effect triggers handleZoom, so error throws without this flag
+        // TODO: hack with timer fixes wrong node scaling (handle positions not matched with content size)
+        this.manualViewportChangeEffect = effect(() => setTimeout(() => {
+            const viewport = this.viewportService.writableViewport();
+            const state = viewport.state;
+            if (viewport.changeType === 'initial') {
+                return;
+            }
+            // If only zoom provided
+            if (isDefined(state.zoom) && (!isDefined(state.x) && !isDefined(state.y))) {
+                this.rootSvgSelection.call(this.zoomBehavior.scaleTo, state.zoom);
+                return;
+            }
+            // If only pan provided
+            if ((isDefined(state.x) && isDefined(state.y)) && !isDefined(state.zoom)) {
+                this.rootSvgSelection.call(this.zoomBehavior.translateTo, state.x, state.y);
+                return;
+            }
+            // If whole viewort state provided
+            if (isDefined(state.x) && isDefined(state.y) && isDefined(state.zoom)) {
+                this.rootSvgSelection.call(this.zoomBehavior.transform, zoomIdentity.translate(state.x, state.y).scale(state.zoom));
+                return;
+            }
+        }), { allowSignalWrites: true });
+        this.handleZoom = ({ transform }) => {
+            // update public signal for user to read
+            this.viewportService.readableViewport.set({ zoom: transform.k, x: transform.x, y: transform.y });
+            this.zoomableSelection.attr('transform', transform.toString());
+        };
+    }
+    ngOnInit() {
+        this.zoomBehavior = zoom()
+            .scaleExtent([this.minZoom, this.maxZoom])
+            .on('zoom', this.handleZoom);
+        this.rootSvgSelection.call(this.zoomBehavior);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: MapContextDirective, selector: "g[mapContext]", inputs: { minZoom: "minZoom", maxZoom: "maxZoom" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapContextDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'g[mapContext]' }]
+        }], propDecorators: { minZoom: [{
+                type: Input
+            }], maxZoom: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/directives/reference.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive, ElementRef, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RootSvgReferenceDirective {
+    constructor() {
+        this.element = inject(ElementRef).nativeElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RootSvgReferenceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RootSvgReferenceDirective, selector: "svg[rootSvgRef]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RootSvgReferenceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'svg[rootSvgRef]'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmZXJlbmNlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9kaXJlY3RpdmVzL3JlZmVyZW5jZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUs5RCxNQUFNLE9BQU8seUJBQXlCO0lBSHRDO1FBSWtCLFlBQU8sR0FBRyxNQUFNLENBQTRCLFVBQVUsQ0FBQyxDQUFDLGFBQWEsQ0FBQTtLQUN0RjsrR0FGWSx5QkFBeUI7bUdBQXpCLHlCQUF5Qjs7NEZBQXpCLHlCQUF5QjtrQkFIckMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsaUJBQWlCO2lCQUM1QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ3N2Z1tyb290U3ZnUmVmXSdcbn0pXG5leHBvcnQgY2xhc3MgUm9vdFN2Z1JlZmVyZW5jZURpcmVjdGl2ZSB7XG4gIHB1YmxpYyByZWFkb25seSBlbGVtZW50ID0gaW5qZWN0PEVsZW1lbnRSZWY8U1ZHU1ZHRWxlbWVudD4+KEVsZW1lbnRSZWYpLm5hdGl2ZUVsZW1lbnRcbn1cbiJdfQ==

package/esm2022/lib/vflow/directives/root-svg-context.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, HostListener, inject } from '@angular/core';
+import { FlowStatusService } from '../services/flow-status.service';
+import * as i0 from "@angular/core";
+// TODO: too general purpose nane
+export class RootSvgContextDirective {
+    constructor() {
+        this.flowStatusService = inject(FlowStatusService);
+    }
+    // TODO: check for multiple instances on page
+    resetConnection() {
+        const status = this.flowStatusService.status();
+        if (status.state === 'connection-start') {
+            this.flowStatusService.setIdleStatus();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RootSvgContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RootSvgContextDirective, selector: "svg[rootSvgContext]", host: { listeners: { "document:mouseup": "resetConnection()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RootSvgContextDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'svg[rootSvgContext]' }]
+        }], propDecorators: { resetConnection: [{
+                type: HostListener,
+                args: ['document:mouseup']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9vdC1zdmctY29udGV4dC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvZGlyZWN0aXZlcy9yb290LXN2Zy1jb250ZXh0LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDaEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUNBQWlDLENBQUM7O0FBRXBFLGlDQUFpQztBQUVqQyxNQUFNLE9BQU8sdUJBQXVCO0lBRHBDO1FBRVUsc0JBQWlCLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUE7S0FXdEQ7SUFUQyw2Q0FBNkM7SUFFbkMsZUFBZTtRQUN2QixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsTUFBTSxFQUFFLENBQUE7UUFFOUMsSUFBSSxNQUFNLENBQUMsS0FBSyxLQUFLLGtCQUFrQixFQUFFO1lBQ3ZDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxhQUFhLEVBQUUsQ0FBQTtTQUN2QztJQUNILENBQUM7K0dBWFUsdUJBQXVCO21HQUF2Qix1QkFBdUI7OzRGQUF2Qix1QkFBdUI7a0JBRG5DLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUscUJBQXFCLEVBQUU7OEJBTWxDLGVBQWU7c0JBRHhCLFlBQVk7dUJBQUMsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRmxvd1N0YXR1c1NlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy9mbG93LXN0YXR1cy5zZXJ2aWNlJztcblxuLy8gVE9ETzogdG9vIGdlbmVyYWwgcHVycG9zZSBuYW5lXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICdzdmdbcm9vdFN2Z0NvbnRleHRdJyB9KVxuZXhwb3J0IGNsYXNzIFJvb3RTdmdDb250ZXh0RGlyZWN0aXZlIHtcbiAgcHJpdmF0ZSBmbG93U3RhdHVzU2VydmljZSA9IGluamVjdChGbG93U3RhdHVzU2VydmljZSlcblxuICAvLyBUT0RPOiBjaGVjayBmb3IgbXVsdGlwbGUgaW5zdGFuY2VzIG9uIHBhZ2VcbiAgQEhvc3RMaXN0ZW5lcignZG9jdW1lbnQ6bW91c2V1cCcpXG4gIHByb3RlY3RlZCByZXNldENvbm5lY3Rpb24oKSB7XG4gICAgY29uc3Qgc3RhdHVzID0gdGhpcy5mbG93U3RhdHVzU2VydmljZS5zdGF0dXMoKVxuXG4gICAgaWYgKHN0YXR1cy5zdGF0ZSA9PT0gJ2Nvbm5lY3Rpb24tc3RhcnQnKSB7XG4gICAgICB0aGlzLmZsb3dTdGF0dXNTZXJ2aWNlLnNldElkbGVTdGF0dXMoKVxuICAgIH1cbiAgfVxufVxuIl19

package/esm2022/lib/vflow/directives/space-point-context.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive, ElementRef, computed, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { fromEvent, map } from 'rxjs';
+import { RootSvgReferenceDirective } from './reference.directive';
+import * as i0 from "@angular/core";
+export class SpacePointContextDirective {
+    constructor() {
+        /**
+         * Signal with current mouse position in svg space
+         */
+        this.svgCurrentSpacePoint = computed(() => {
+            const movement = this.mouseMovement();
+            const point = this.rootSvg.createSVGPoint();
+            point.x = movement.x;
+            point.y = movement.y;
+            return point.matrixTransform(this.host.getScreenCTM().inverse());
+        });
+        this.rootSvg = inject(RootSvgReferenceDirective).element;
+        this.host = inject(ElementRef).nativeElement;
+        this.mouseMovement = toSignal(fromEvent(this.rootSvg, 'mousemove').pipe(map(event => ({ x: event.clientX, y: event.clientY }))), { initialValue: { x: 0, y: 0 } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SpacePointContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SpacePointContextDirective, selector: "g[spacePointContext]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SpacePointContextDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'g[spacePointContext]' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/directives/template.directive.mjs

@@ -0,0 +1,58 @@
+import { Directive, TemplateRef, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EdgeTemplateDirective {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: EdgeTemplateDirective, selector: "ng-template[edge]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[edge]' }]
+        }] });
+export class ConnectionTemplateDirective {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectionTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ConnectionTemplateDirective, selector: "ng-template[connection]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConnectionTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[connection]' }]
+        }] });
+export class EdgeLabelHtmlTemplateDirective {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeLabelHtmlTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: EdgeLabelHtmlTemplateDirective, selector: "ng-template[edgeLabelHtml]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EdgeLabelHtmlTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[edgeLabelHtml]' }]
+        }] });
+export class NodeHtmlTemplateDirective {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodeHtmlTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: NodeHtmlTemplateDirective, selector: "ng-template[nodeHtml]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodeHtmlTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[nodeHtml]' }]
+        }] });
+export class HandleTemplateDirective {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HandleTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: HandleTemplateDirective, selector: "ng-template[handle]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HandleTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[handle]' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/vflow/interfaces/connection-settings.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi1zZXR0aW5ncy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9jb25uZWN0aW9uLXNldHRpbmdzLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29ubmVjdGlvbiB9IGZyb20gXCIuL2Nvbm5lY3Rpb24uaW50ZXJmYWNlXCI7XG5pbXBvcnQgeyBDdXJ2ZSwgRWRnZVR5cGUgfSBmcm9tIFwiLi9lZGdlLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgTWFya2VyIH0gZnJvbSBcIi4vbWFya2VyLmludGVyZmFjZVwiO1xuXG5leHBvcnQgdHlwZSBDb25uZWN0aW9uVmFsaWRhdG9yRm4gPSAoY29ubmVjdGlvbjogQ29ubmVjdGlvbikgPT4gYm9vbGVhblxuXG5leHBvcnQgaW50ZXJmYWNlIENvbm5lY3Rpb25TZXR0aW5ncyB7XG4gIGN1cnZlPzogQ3VydmVcbiAgdHlwZT86IEVkZ2VUeXBlXG4gIHZhbGlkYXRvcj86IENvbm5lY3Rpb25WYWxpZGF0b3JGblxuICBtYXJrZXI/OiBNYXJrZXJcbn1cblxuIl19

package/esm2022/lib/vflow/interfaces/connection.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9jb25uZWN0aW9uLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBDb25uZWN0aW9uIHtcbiAgc291cmNlOiBzdHJpbmdcbiAgdGFyZ2V0OiBzdHJpbmdcbn1cbiJdfQ==

package/esm2022/lib/vflow/interfaces/edge-label.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRnZS1sYWJlbC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9lZGdlLWxhYmVsLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgRWRnZUxhYmVsVHlwZSA9ICdodG1sLXRlbXBsYXRlJ1xuZXhwb3J0IHR5cGUgRWRnZUxhYmVsUG9zaXRpb24gPSAnc3RhcnQnIHwgJ2NlbnRlcicgfCAnZW5kJ1xuXG5leHBvcnQgaW50ZXJmYWNlIEVkZ2VMYWJlbDxUID0gdW5rbm93bj4ge1xuICB0eXBlOiBFZGdlTGFiZWxUeXBlXG4gIGRhdGE/OiBUXG59XG4iXX0=

package/esm2022/lib/vflow/interfaces/edge.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRnZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9lZGdlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29ubmVjdGlvbiB9IGZyb20gXCIuL2Nvbm5lY3Rpb24uaW50ZXJmYWNlXCJcbmltcG9ydCB7IEVkZ2VMYWJlbCwgRWRnZUxhYmVsUG9zaXRpb24gfSBmcm9tIFwiLi9lZGdlLWxhYmVsLmludGVyZmFjZVwiXG5pbXBvcnQgeyBNYXJrZXIgfSBmcm9tIFwiLi9tYXJrZXIuaW50ZXJmYWNlXCJcblxuZXhwb3J0IHR5cGUgRWRnZVR5cGUgPSAnZGVmYXVsdCcgfCAndGVtcGxhdGUnXG5leHBvcnQgdHlwZSBDdXJ2ZSA9ICdzdHJhaWdodCcgfCAnYmV6aWVyJ1xuXG5leHBvcnQgaW50ZXJmYWNlIEVkZ2U8VCA9IHVua25vd24+IGV4dGVuZHMgQ29ubmVjdGlvbiB7XG4gIGlkOiBzdHJpbmdcbiAgdHlwZT86IEVkZ2VUeXBlXG4gIGN1cnZlPzogQ3VydmVcbiAgZGF0YT86IFRcbiAgZWRnZUxhYmVscz86IHsgW3Bvc2l0aW9uIGluIEVkZ2VMYWJlbFBvc2l0aW9uXT86IEVkZ2VMYWJlbCB9XG4gIG1hcmtlcnM/OiB7XG4gICAgc3RhcnQ/OiBNYXJrZXJcbiAgICBlbmQ/OiBNYXJrZXJcbiAgfVxufVxuIl19

package/esm2022/lib/vflow/interfaces/handle-positions.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlLXBvc2l0aW9ucy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9oYW5kbGUtcG9zaXRpb25zLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9zaXRpb24gfSBmcm9tIFwiLi4vdHlwZXMvcG9zaXRpb24udHlwZVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEhhbmRsZVBvc2l0aW9ucyB7XG4gIHNvdXJjZTogUG9zaXRpb25cbiAgdGFyZ2V0OiBQb3NpdGlvblxufVxuIl19

package/esm2022/lib/vflow/interfaces/marker.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFya2VyLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9pbnRlcmZhY2VzL21hcmtlci5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgTWFya2VyIHtcbiAgdHlwZT86ICdhcnJvdycgfCAnYXJyb3ctY2xvc2VkJ1xuICB3aWR0aD86IG51bWJlclxuICBoZWlnaHQ/OiBudW1iZXJcbiAgY29sb3I/OiBzdHJpbmdcbiAgb3JpZW50Pzogc3RyaW5nXG4gIG1hcmtlclVuaXRzPzogJ3VzZXJTcGFjZU9uVXNlJyB8ICdzdHJva2VXaWR0aCdcbiAgc3Ryb2tlV2lkdGg/OiBudW1iZXJcbn1cbiJdfQ==

package/esm2022/lib/vflow/interfaces/node.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy9ub2RlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9pbnQgfSBmcm9tIFwiLi9wb2ludC5pbnRlcmZhY2VcIlxuXG5leHBvcnQgdHlwZSBOb2RlPFQgPSB1bmtub3duPiA9IFNoYXJlZE5vZGUgJiAoXG4gIERlZmF1bHROb2RlIHxcbiAgSHRtbFRlbXBsYXRlTm9kZTxUPlxuKVxuaW50ZXJmYWNlIFNoYXJlZE5vZGUge1xuICBpZDogc3RyaW5nXG4gIHBvaW50OiBQb2ludFxuICBkcmFnZ2FibGU/OiBib29sZWFuXG59XG5cbmludGVyZmFjZSBEZWZhdWx0Tm9kZSB7XG4gIHR5cGU6ICdkZWZhdWx0J1xuICB0ZXh0Pzogc3RyaW5nXG59XG5cbmludGVyZmFjZSBIdG1sVGVtcGxhdGVOb2RlPFQgPSB1bmtub3duPiB7XG4gIHR5cGU6ICdodG1sLXRlbXBsYXRlJ1xuICBkYXRhPzogVFxufVxuIl19

package/esm2022/lib/vflow/interfaces/path-data.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC1kYXRhLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC12Zmxvdy1saWIvc3JjL2xpYi92Zmxvdy9pbnRlcmZhY2VzL3BhdGgtZGF0YS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkZ2VMYWJlbFBvc2l0aW9uIH0gZnJvbSBcIi4vZWRnZS1sYWJlbC5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFBvaW50IH0gZnJvbSBcIi4vcG9pbnQuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGF0aERhdGEge1xuICBwYXRoOiBzdHJpbmc7XG4gIHBvaW50czogeyBba2V5IGluIEVkZ2VMYWJlbFBvc2l0aW9uXTogUG9pbnQgfVxufVxuIl19

package/esm2022/lib/vflow/interfaces/point.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi9zcmMvbGliL3ZmbG93L2ludGVyZmFjZXMvcG9pbnQuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFBvaW50IHtcbiAgeDogbnVtYmVyXG4gIHk6IG51bWJlclxufVxuIl19

package/esm2022/lib/vflow/interfaces/template-context.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUtY29udGV4dC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdmZsb3ctbGliL3NyYy9saWIvdmZsb3cvaW50ZXJmYWNlcy90ZW1wbGF0ZS1jb250ZXh0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2lnbmFsIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIlxuaW1wb3J0IHsgRWRnZSB9IGZyb20gXCIuL2VkZ2UuaW50ZXJmYWNlXCJcblxuZXhwb3J0IGludGVyZmFjZSBFZGdlQ29udGV4dCB7XG4gICRpbXBsaWNpdDoge1xuICAgIGVkZ2U6IEVkZ2VcbiAgICBwYXRoOiBTaWduYWw8c3RyaW5nPlxuICAgIG1hcmtlclN0YXJ0OiBTaWduYWw8c3RyaW5nPlxuICAgIG1hcmtlckVuZDogU2lnbmFsPHN0cmluZz5cbiAgfVxufVxuIl19

package/esm2022/lib/vflow/interfaces/viewport.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlld3BvcnQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXZmbG93LWxpYi9zcmMvbGliL3ZmbG93L2ludGVyZmFjZXMvdmlld3BvcnQuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWaWV3cG9ydENoYW5nZVR5cGUgfSBmcm9tIFwiLi4vdHlwZXMvdmlld3BvcnQtY2hhbmdlLXR5cGUudHlwZVwiO1xuaW1wb3J0IHsgUG9pbnQgfSBmcm9tIFwiLi9wb2ludC5pbnRlcmZhY2VcIjtcblxuZXhwb3J0IGludGVyZmFjZSBWaWV3cG9ydFN0YXRlIGV4dGVuZHMgUG9pbnQge1xuICB6b29tOiBudW1iZXJcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXcml0YWJsZVZpZXdwb3J0IHtcbiAgY2hhbmdlVHlwZTogVmlld3BvcnRDaGFuZ2VUeXBlXG4gIHN0YXRlOiBQYXJ0aWFsPFZpZXdwb3J0U3RhdGU+XG59XG4iXX0=