ngx-vflow 0.1.0

package/lib/vflow/directives/template.directive.d.ts

@@ -0,0 +1,28 @@
+import { TemplateRef } from '@angular/core';
+import { EdgeContext } from '../interfaces/template-context.interface';
+import * as i0 from "@angular/core";
+export declare class EdgeTemplateDirective {
+    templateRef: TemplateRef<EdgeContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EdgeTemplateDirective, "ng-template[edge]", never, {}, {}, never, never, false, never>;
+}
+export declare class ConnectionTemplateDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectionTemplateDirective, "ng-template[connection]", never, {}, {}, never, never, false, never>;
+}
+export declare class EdgeLabelHtmlTemplateDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeLabelHtmlTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EdgeLabelHtmlTemplateDirective, "ng-template[edgeLabelHtml]", never, {}, {}, never, never, false, never>;
+}
+export declare class NodeHtmlTemplateDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeHtmlTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NodeHtmlTemplateDirective, "ng-template[nodeHtml]", never, {}, {}, never, never, false, never>;
+}
+export declare class HandleTemplateDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HandleTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HandleTemplateDirective, "ng-template[handle]", never, {}, {}, never, never, false, never>;
+}

package/lib/vflow/interfaces/connection-settings.interface.d.ts

@@ -0,0 +1,10 @@
+import { Connection } from "./connection.interface";
+import { Curve, EdgeType } from "./edge.interface";
+import { Marker } from "./marker.interface";
+export type ConnectionValidatorFn = (connection: Connection) => boolean;
+export interface ConnectionSettings {
+    curve?: Curve;
+    type?: EdgeType;
+    validator?: ConnectionValidatorFn;
+    marker?: Marker;
+}

package/lib/vflow/interfaces/connection.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Connection {
+    source: string;
+    target: string;
+}

package/lib/vflow/interfaces/edge-label.interface.d.ts

@@ -0,0 +1,6 @@
+export type EdgeLabelType = 'html-template';
+export type EdgeLabelPosition = 'start' | 'center' | 'end';
+export interface EdgeLabel<T = unknown> {
+    type: EdgeLabelType;
+    data?: T;
+}

package/lib/vflow/interfaces/edge.interface.d.ts

@@ -0,0 +1,18 @@
+import { Connection } from "./connection.interface";
+import { EdgeLabel, EdgeLabelPosition } from "./edge-label.interface";
+import { Marker } from "./marker.interface";
+export type EdgeType = 'default' | 'template';
+export type Curve = 'straight' | 'bezier';
+export interface Edge<T = unknown> extends Connection {
+    id: string;
+    type?: EdgeType;
+    curve?: Curve;
+    data?: T;
+    edgeLabels?: {
+        [position in EdgeLabelPosition]?: EdgeLabel;
+    };
+    markers?: {
+        start?: Marker;
+        end?: Marker;
+    };
+}

package/lib/vflow/interfaces/handle-positions.interface.d.ts

@@ -0,0 +1,5 @@
+import { Position } from "../types/position.type";
+export interface HandlePositions {
+    source: Position;
+    target: Position;
+}

package/lib/vflow/interfaces/marker.interface.d.ts

@@ -0,0 +1,9 @@
+export interface Marker {
+    type?: 'arrow' | 'arrow-closed';
+    width?: number;
+    height?: number;
+    color?: string;
+    orient?: string;
+    markerUnits?: 'userSpaceOnUse' | 'strokeWidth';
+    strokeWidth?: number;
+}

package/lib/vflow/interfaces/node.interface.d.ts

@@ -0,0 +1,16 @@
+import { Point } from "./point.interface";
+export type Node<T = unknown> = SharedNode & (DefaultNode | HtmlTemplateNode<T>);
+interface SharedNode {
+    id: string;
+    point: Point;
+    draggable?: boolean;
+}
+interface DefaultNode {
+    type: 'default';
+    text?: string;
+}
+interface HtmlTemplateNode<T = unknown> {
+    type: 'html-template';
+    data?: T;
+}
+export {};

package/lib/vflow/interfaces/path-data.interface.d.ts

@@ -0,0 +1,8 @@
+import { EdgeLabelPosition } from "./edge-label.interface";
+import { Point } from "./point.interface";
+export interface PathData {
+    path: string;
+    points: {
+        [key in EdgeLabelPosition]: Point;
+    };
+}

package/lib/vflow/interfaces/point.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Point {
+    x: number;
+    y: number;
+}

package/lib/vflow/interfaces/template-context.interface.d.ts

@@ -0,0 +1,10 @@
+import { Signal } from "@angular/core";
+import { Edge } from "./edge.interface";
+export interface EdgeContext {
+    $implicit: {
+        edge: Edge;
+        path: Signal<string>;
+        markerStart: Signal<string>;
+        markerEnd: Signal<string>;
+    };
+}

package/lib/vflow/interfaces/viewport.interface.d.ts

@@ -0,0 +1,9 @@
+import { ViewportChangeType } from "../types/viewport-change-type.type";
+import { Point } from "./point.interface";
+export interface ViewportState extends Point {
+    zoom: number;
+}
+export interface WritableViewport {
+    changeType: ViewportChangeType;
+    state: Partial<ViewportState>;
+}

package/lib/vflow/math/edge-path/bezier-path.d.ts

@@ -0,0 +1,5 @@
+import { PathData } from '../../interfaces/path-data.interface';
+import { Point } from '../../interfaces/point.interface';
+import { UsingPoints } from '../../types/using-points.type';
+import { Position } from '../../types/position.type';
+export declare function bezierPath(source: Point, target: Point, sourcePosition: Position, targetPosition: Position, usingPoints?: UsingPoints): PathData;

package/lib/vflow/math/edge-path/straigh-path.d.ts

@@ -0,0 +1,4 @@
+import { PathData } from "../../interfaces/path-data.interface";
+import { Point } from "../../interfaces/point.interface";
+import { UsingPoints } from "../../types/using-points.type";
+export declare function straightPath(source: Point, target: Point, usingPoints?: UsingPoints): PathData;

package/lib/vflow/math/point-on-line-by-ratio.d.ts

@@ -0,0 +1,7 @@
+import { Point } from "../interfaces/point.interface";
+/**
+ * Get point on line
+ *
+ * https://math.stackexchange.com/questions/563566/how-do-i-find-the-middle1-2-1-3-1-4-etc-of-a-line
+ */
+export declare function getPointOnLineByRatio(start: Point, end: Point, ratio: number): Point;

package/lib/vflow/models/connection.model.d.ts

@@ -0,0 +1,9 @@
+import { ConnectionSettings, ConnectionValidatorFn } from "../interfaces/connection-settings.interface";
+import { Curve, EdgeType } from "../interfaces/edge.interface";
+export declare class ConnectionModel {
+    connection: ConnectionSettings;
+    curve: Curve;
+    type: EdgeType;
+    validator: ConnectionValidatorFn;
+    constructor(connection: ConnectionSettings);
+}

package/lib/vflow/models/edge-label.model.d.ts

@@ -0,0 +1,9 @@
+import { EdgeLabel } from "../interfaces/edge-label.interface";
+export declare class EdgeLabelModel {
+    edgeLabel: EdgeLabel;
+    size: import("@angular/core").WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    constructor(edgeLabel: EdgeLabel);
+}

package/lib/vflow/models/edge.model.d.ts

@@ -0,0 +1,17 @@
+import { EdgeLabelPosition } from "../interfaces/edge-label.interface";
+import { Edge, Curve, EdgeType } from "../interfaces/edge.interface";
+import { EdgeLabelModel } from "./edge-label.model";
+import { NodeModel } from "./node.model";
+export declare class EdgeModel {
+    edge: Edge;
+    source: NodeModel;
+    target: NodeModel;
+    curve: Curve;
+    type: EdgeType;
+    path: import("@angular/core").Signal<import("../interfaces/path-data.interface").PathData>;
+    edgeLabels: {
+        [position in EdgeLabelPosition]?: EdgeLabelModel;
+    };
+    private usingPoints;
+    constructor(edge: Edge);
+}

package/lib/vflow/models/flow.model.d.ts

@@ -0,0 +1,14 @@
+import { Signal, WritableSignal } from "@angular/core";
+import { HandlePositions } from "../interfaces/handle-positions.interface";
+export declare class FlowModel {
+    /**
+     * Global setting with handle positions. Nodes derive this value
+     */
+    handlePositions: WritableSignal<HandlePositions>;
+    /**
+     * @see {VflowComponent.view}
+     */
+    view: WritableSignal<[number, number] | 'auto'>;
+    flowWidth: Signal<string | number>;
+    flowHeight: Signal<string | number>;
+}

package/lib/vflow/models/node.model.d.ts

@@ -0,0 +1,70 @@
+import { Node } from '../interfaces/node.interface';
+import { FlowModel } from './flow.model';
+export declare class NodeModel<T = unknown> {
+    node: Node<T>;
+    point: import("@angular/core").WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    point$: import("rxjs").Observable<{
+        x: number;
+        y: number;
+    }>;
+    size: import("@angular/core").WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    pointTransform: import("@angular/core").Signal<string>;
+    sourceOffset: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    targetOffset: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    sourcePointAbsolute: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    targetPointAbsolute: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    sourcePosition: import("@angular/core").Signal<import("ngx-vflow").Position>;
+    targetPosition: import("@angular/core").Signal<import("ngx-vflow").Position>;
+    sourceHandleSize: import("@angular/core").WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    targetHandleSize: import("@angular/core").WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    sourceHandleOffset: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    targetHandleOffset: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    sourceOffsetAligned: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    targetOffsetAligned: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+    }>;
+    draggable: boolean;
+    readonly magnetRadius = 20;
+    private flow;
+    constructor(node: Node<T>);
+    /**
+     * Bind parent flow model to node
+     *
+     * @param flow parent flow
+     */
+    bindFlow(flow: FlowModel): void;
+}

package/lib/vflow/services/draggable.service.d.ts

@@ -0,0 +1,32 @@
+import { NodeModel } from '../models/node.model';
+import * as i0 from "@angular/core";
+export declare class DraggableService {
+    /**
+     * Enable or disable draggable behavior for element.
+     * model contains draggable flag which declares if draggable should be enabled or not
+     *
+     * @param element target element for toggling draggable
+     * @param model model with data for this element
+     */
+    toggleDraggable(element: Element, model: NodeModel): void;
+    /**
+     * TODO: not shure if this work, need to check
+     *
+     * @param element
+     */
+    destroy(element: Element): void;
+    /**
+     * Node drag behavior. Updated node's coordinate according to dragging
+     *
+     * @param model
+     * @returns
+     */
+    private getDragBehavior;
+    /**
+     * Specify ignoring drag behavior. It's responsible for not moving the map when user tries to drag node
+     * with disabled drag behavior
+     */
+    private getIgnoreDragBehavior;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DraggableService>;
+}

package/lib/vflow/services/edge-changes.service.d.ts

@@ -0,0 +1,22 @@
+import { FlowEntitiesService } from './flow-entities.service';
+import { Observable } from 'rxjs';
+import { EdgeChange } from '../types/edge-change.type';
+import * as i0 from "@angular/core";
+export declare class EdgeChangesService {
+    protected entitiesService: FlowEntitiesService;
+    protected edgeDetachedChange$: Observable<{
+        type: "detached";
+        id: string;
+    }[]>;
+    protected edgeAddChange$: Observable<{
+        type: "add";
+        id: string;
+    }[]>;
+    protected edgeRemoveChange$: Observable<{
+        type: "remove";
+        id: string;
+    }[]>;
+    readonly changes$: Observable<EdgeChange[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeChangesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EdgeChangesService>;
+}

package/lib/vflow/services/flow-entities.service.d.ts

@@ -0,0 +1,15 @@
+import { NodeModel } from '../models/node.model';
+import { EdgeModel } from '../models/edge.model';
+import { ConnectionModel } from '../models/connection.model';
+import { Marker } from '../interfaces/marker.interface';
+import * as i0 from "@angular/core";
+export declare class FlowEntitiesService {
+    readonly nodes: import("@angular/core").WritableSignal<NodeModel<unknown>[]>;
+    readonly edges: import("@angular/core").WritableSignal<EdgeModel[]>;
+    readonly connection: import("@angular/core").WritableSignal<ConnectionModel>;
+    readonly markers: import("@angular/core").Signal<Map<number, Marker>>;
+    readonly validEdges: import("@angular/core").Signal<EdgeModel[]>;
+    getNode<T>(id: string): NodeModel<T> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowEntitiesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowEntitiesService>;
+}

package/lib/vflow/services/flow-status.service.d.ts

@@ -0,0 +1,43 @@
+import { NodeModel } from '../models/node.model';
+import * as i0 from "@angular/core";
+export interface FlowStatusIdle {
+    state: 'idle';
+    payload: null;
+}
+export interface FlowStatusConnectionStart {
+    state: 'connection-start';
+    payload: {
+        sourceNode: NodeModel;
+    };
+}
+export interface FlowStatusConnectionValidation {
+    state: 'connection-validation';
+    payload: {
+        sourceNode: NodeModel;
+        targetNode: NodeModel;
+        valid: boolean;
+    };
+}
+export interface FlowStatusConnectionEnd {
+    state: 'connection-end';
+    payload: {
+        sourceNode: NodeModel;
+        targetNode: NodeModel;
+    };
+}
+export type FlowStatus = FlowStatusIdle | FlowStatusConnectionStart | FlowStatusConnectionValidation | FlowStatusConnectionEnd;
+export declare class FlowStatusService {
+    readonly status: import("@angular/core").WritableSignal<FlowStatus>;
+    setIdleStatus(): void;
+    setConnectionStartStatus(sourceNode: NodeModel): void;
+    setConnectionValidationStatus(sourceNode: NodeModel, targetNode: NodeModel, valid: boolean): void;
+    setConnectionEndStatus(sourceNode: NodeModel, targetNode: NodeModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlowStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlowStatusService>;
+}
+/**
+ * Batch status changes together to call them one after another
+ *
+ * @param changes list of set[FlowStatus.state]Status() calls
+ */
+export declare function batchStatusChanges(...changes: Function[]): void;

package/lib/vflow/services/node-changes.service.d.ts

@@ -0,0 +1,26 @@
+import { FlowEntitiesService } from './flow-entities.service';
+import { Observable } from 'rxjs';
+import { NodeChange } from '../types/node-change.type';
+import * as i0 from "@angular/core";
+export declare class NodesChangeService {
+    protected entitiesService: FlowEntitiesService;
+    protected nodesPositionChange$: Observable<{
+        type: "position";
+        id: string;
+        point: {
+            x: number;
+            y: number;
+        };
+    }[]>;
+    protected nodeAddChange$: Observable<{
+        type: "add";
+        id: string;
+    }[]>;
+    protected nodeRemoveChange$: Observable<{
+        type: "remove";
+        id: string;
+    }[]>;
+    readonly changes$: Observable<NodeChange[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodesChangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodesChangeService>;
+}

package/lib/vflow/services/viewport.service.d.ts

@@ -0,0 +1,24 @@
+import { WritableSignal } from '@angular/core';
+import { ViewportState, WritableViewport } from '../interfaces/viewport.interface';
+import * as i0 from "@angular/core";
+export declare class ViewportService {
+    /**
+     * The default value used by d3, just copy it here
+     *
+     * @returns default viewport value
+     */
+    private static getDefaultViewport;
+    /**
+     * Internal signal that accepts value from user by lib api
+     * When this signal changes, lib sets new view state and update readableViewport signal
+     */
+    readonly writableViewport: WritableSignal<WritableViewport>;
+    /**
+     * Public signal with viewport state. User can directly read from this signal. It's updated by:
+     * - user events on flow
+     * - writableViewport signal
+     */
+    readonly readableViewport: WritableSignal<ViewportState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportService>;
+}

package/lib/vflow/types/edge-change.type.d.ts

@@ -0,0 +1,14 @@
+export type EdgeChange = EdgeDetachedChange | EdgeAddChange | EdgeRemoveChange;
+export interface EdgeDetachedChange extends EdgeChangeShared {
+    type: 'detached';
+}
+export interface EdgeAddChange extends EdgeChangeShared {
+    type: 'add';
+}
+export interface EdgeRemoveChange extends EdgeChangeShared {
+    type: 'remove';
+}
+interface EdgeChangeShared {
+    id: string;
+}
+export {};

package/lib/vflow/types/node-change.type.d.ts

@@ -0,0 +1,16 @@
+import { Point } from "../interfaces/point.interface";
+export type NodeChange = NodePositionChange | NodeAddChange | NodeRemoveChange;
+export interface NodePositionChange extends NodeChangeShared {
+    type: 'position';
+    point: Point;
+}
+export interface NodeAddChange extends NodeChangeShared {
+    type: 'add';
+}
+export interface NodeRemoveChange extends NodeChangeShared {
+    type: 'remove';
+}
+interface NodeChangeShared {
+    id: string;
+}
+export {};

package/lib/vflow/types/position.type.d.ts

@@ -0,0 +1 @@
+export type Position = 'top' | 'bottom' | 'right' | 'left';

package/lib/vflow/types/using-points.type.d.ts

@@ -0,0 +1,5 @@
+export type UsingPoints = [
+    start: boolean,
+    center: boolean,
+    end: boolean
+];

package/lib/vflow/types/viewport-change-type.type.d.ts

@@ -0,0 +1,3 @@
+export type ViewportChangeType = 'initial' | // first change, set by library
+'absolute' | // later absolue value changes, set by user
+'relative';

package/lib/vflow/utils/add-nodes-to-edges.d.ts

@@ -0,0 +1,3 @@
+import { EdgeModel } from "../models/edge.model";
+import { NodeModel } from "../models/node.model";
+export declare function addNodesToEdges(nodes: NodeModel[], edges: EdgeModel[]): void;

package/lib/vflow/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashCode(str: string): number;

package/lib/vflow/utils/is-defined.d.ts

@@ -0,0 +1 @@
+export declare function isDefined<T>(data: T | undefined): data is T;

package/lib/vflow/utils/reference-keeper.d.ts

@@ -0,0 +1,14 @@
+import { NodeModel } from "../models/node.model";
+import { Node } from '../interfaces/node.interface';
+import { EdgeModel } from "../models/edge.model";
+import { Edge } from "../interfaces/edge.interface";
+export declare class ReferenceKeeper {
+    /**
+     * Create new models for new node references and keep old models for old node references
+     */
+    static nodes(newNodes: Node[], oldNodeModels: NodeModel[]): NodeModel<unknown>[];
+    /**
+     * Create new models for new edge references and keep old models for old edge references
+     */
+    static edges(newEdges: Edge[], oldEdgeModels: EdgeModel[]): EdgeModel[];
+}

package/lib/vflow/utils/round.d.ts

@@ -0,0 +1 @@
+export declare const round: (num: number) => number;

package/lib/vflow/vflow.module.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/vflow/vflow.component";
+import * as i2 from "./components/node/node.component";
+import * as i3 from "./components/edge/edge.component";
+import * as i4 from "./components/edge-label/edge-label.component";
+import * as i5 from "./components/connection/connection.component";
+import * as i6 from "./components/defs/defs.component";
+import * as i7 from "./directives/space-point-context.directive";
+import * as i8 from "./directives/map-context.directive";
+import * as i9 from "./directives/reference.directive";
+import * as i10 from "./directives/root-svg-context.directive";
+import * as i11 from "./directives/template.directive";
+import * as i12 from "@angular/common";
+export declare class VflowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VflowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VflowModule, [typeof i1.VflowComponent, typeof i2.NodeComponent, typeof i3.EdgeComponent, typeof i4.EdgeLabelComponent, typeof i5.ConnectionComponent, typeof i6.DefsComponent, typeof i7.SpacePointContextDirective, typeof i8.MapContextDirective, typeof i9.RootSvgReferenceDirective, typeof i10.RootSvgContextDirective, typeof i11.NodeHtmlTemplateDirective, typeof i11.EdgeLabelHtmlTemplateDirective, typeof i11.EdgeTemplateDirective, typeof i11.ConnectionTemplateDirective, typeof i11.HandleTemplateDirective], [typeof i12.CommonModule], [typeof i1.VflowComponent, typeof i11.NodeHtmlTemplateDirective, typeof i11.EdgeLabelHtmlTemplateDirective, typeof i11.EdgeTemplateDirective, typeof i11.ConnectionTemplateDirective, typeof i11.HandleTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VflowModule>;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "ngx-vflow",
+  "version": "0.1.0",
+  "peerDependencies": {
+    "@angular/common": "^16.2.0",
+    "@angular/core": "^16.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ngx-vflow.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/ngx-vflow.mjs",
+      "esm": "./esm2022/ngx-vflow.mjs",
+      "default": "./fesm2022/ngx-vflow.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,18 @@
+export * from './lib/vflow/vflow.module';
+export * from './lib/vflow/interfaces/node.interface';
+export * from './lib/vflow/interfaces/point.interface';
+export * from './lib/vflow/interfaces/edge.interface';
+export * from './lib/vflow/interfaces/edge-label.interface';
+export * from './lib/vflow/interfaces/connection.interface';
+export * from './lib/vflow/interfaces/connection.interface';
+export * from './lib/vflow/interfaces/connection-settings.interface';
+export * from './lib/vflow/interfaces/handle-positions.interface';
+export * from './lib/vflow/interfaces/marker.interface';
+export { ViewportState } from './lib/vflow/interfaces/viewport.interface';
+export * from './lib/vflow/types/node-change.type';
+export * from './lib/vflow/types/edge-change.type';
+export * from './lib/vflow/types/position.type';
+export * from './lib/vflow/components/vflow/vflow.component';
+export * from './lib/vflow/directives/template.directive';
+export * from './lib/vflow/directives/connection-controller.directive';
+export * from './lib/vflow/directives/changes-controller.directive';