@foblex/flow 12.1.1 → 12.2.0

package/f-connection/index.d.ts

@@ -1,5 +1,6 @@
 export * from './common';
 export * from './f-connection-for-create';
 export * from './f-connection';
+export * from './f-connection-builder';
 export * from './f-connection-center';
 export * from './f-marker';

package/f-draggable/connections/find-inputs-under-pointer/find-inputs-under-pointer.handler.d.ts

@@ -1,18 +1,18 @@
 import { IHandler } from '@foblex/core';
 import { FindInputsUnderPointerRequest } from './find-inputs-under-pointer.request';
 import { FComponentsStore } from '../../../f-components-store';
-import { InputsUnderPointerHandler } from './inputs-under-pointer';
 import { FirstNotConnectedInputOfNodeUnderPointerHandler } from './first-not-connected-input-of-node-under-pointer';
 import { FConnectorBase } from '../../../f-connectors';
 import * as i0 from "@angular/core";
 export declare class FindInputsUnderPointerHandler implements IHandler<FindInputsUnderPointerRequest, FConnectorBase[]> {
     private fComponentsStore;
-    private inputsUnderPointerHandler;
     private firstNotConnectedInputOfNodeUnderPointerHandler;
     private get fNodes();
-    constructor(fComponentsStore: FComponentsStore, inputsUnderPointerHandler: InputsUnderPointerHandler, firstNotConnectedInputOfNodeUnderPointerHandler: FirstNotConnectedInputOfNodeUnderPointerHandler);
+    private get fInputs();
+    constructor(fComponentsStore: FComponentsStore, firstNotConnectedInputOfNodeUnderPointerHandler: FirstNotConnectedInputOfNodeUnderPointerHandler);
     handle(payload: FindInputsUnderPointerRequest): FConnectorBase[];
     private getInputsUnderPointer;
+    private inputsUnderPointer;
     static ɵfac: i0.ɵɵFactoryDeclaration<FindInputsUnderPointerHandler, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FindInputsUnderPointerHandler>;
 }

package/f-draggable/connections/find-inputs-under-pointer/index.d.ts

@@ -1,4 +1,3 @@
 export * from './first-not-connected-input-of-node-under-pointer';
-export * from './inputs-under-pointer';
 export * from './find-inputs-under-pointer.request';
 export * from './find-inputs-under-pointer.handler';

package/f-draggable/connections/providers.d.ts

@@ -1,4 +1,4 @@
 import { CreateConnectionOnPointerUp, CreateConnectionPrepareDragSequence, FindFirstCanBeConnectedOutputByOutletHandler } from './create-connection';
-import { FindInputsUnderPointerHandler, FirstNotConnectedInputOfNodeUnderPointerHandler, InputsUnderPointerHandler } from './find-inputs-under-pointer';
+import { FindInputsUnderPointerHandler, FirstNotConnectedInputOfNodeUnderPointerHandler } from './find-inputs-under-pointer';
 import { ReassignConnectionOnPointerUp, ReassignConnectionPrepareDragSequence } from './reassign-connection';
-export declare const CONNECTIONS_PROVIDERS: (typeof FindFirstCanBeConnectedOutputByOutletHandler | typeof FirstNotConnectedInputOfNodeUnderPointerHandler | typeof InputsUnderPointerHandler | typeof ReassignConnectionOnPointerUp | typeof ReassignConnectionPrepareDragSequence | typeof FindInputsUnderPointerHandler | typeof CreateConnectionOnPointerUp | typeof CreateConnectionPrepareDragSequence)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof FindFirstCanBeConnectedOutputByOutletHandler | typeof CreateConnectionOnPointerUp | typeof CreateConnectionPrepareDragSequence | typeof FirstNotConnectedInputOfNodeUnderPointerHandler | typeof FindInputsUnderPointerHandler | typeof ReassignConnectionOnPointerUp | typeof ReassignConnectionPrepareDragSequence)[];

package/f-draggable/external-item/providers.d.ts

@@ -1,3 +1,3 @@
 import { ExternalItemOnPointerUp } from './external-item.on-pointer-up';
 import { ExternalItemPrepareDragSequence } from './external-item.prepare-drag-sequence';
-export declare const EXTERNAL_ITEM_PROVIDERS: (typeof ExternalItemPrepareDragSequence | typeof ExternalItemOnPointerUp)[];
+export declare const EXTERNAL_ITEM_PROVIDERS: (typeof ExternalItemOnPointerUp | typeof ExternalItemPrepareDragSequence)[];

package/f-draggable/node/providers.d.ts

@@ -1,4 +1,4 @@
 import { NodeOnPointerUp } from './node.on-pointer-up';
 import { NodePrepareDragSequence } from './node.prepare-drag-sequence';
 import { IsConnectionUnderNodeHandler } from './domain/is-connection-under-node';
-export declare const NODE_PROVIDERS: (typeof IsConnectionUnderNodeHandler | typeof NodeOnPointerUp | typeof NodePrepareDragSequence)[];
+export declare const NODE_PROVIDERS: (typeof NodeOnPointerUp | typeof NodePrepareDragSequence | typeof IsConnectionUnderNodeHandler)[];

package/fesm2022/foblex-flow.mjs

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Component, ChangeDetectionStrategy, Input, Directive, Injectable, ContentChild, Inject, ViewChild, ContentChildren, Optional, SkipSelf, EventEmitter, Output, NgModule } from '@angular/core';
+import { InjectionToken, Component, ChangeDetectionStrategy, Input, Directive, Injectable, ContentChild, Inject, ViewChild, Optional, ContentChildren, SkipSelf, EventEmitter, Output, NgModule } from '@angular/core';
 import { TransformModelExtensions, DomElementExtensions, PointExtensions, RectExtensions, BooleanExtensions, sanitizeElementId, Point, GuidExtensions, VectorExtensions, EventExtensions, mixinChangePosition, mixinFitToParent, mixinOneToOneCentering, mixinChangeZoom, MouseEventExtensions, IMouseEvent, ITouchDownEvent, ITouchMoveEvent, ITouchUpEvent, SizeExtensions } from '@foblex/core';
 import { Subject, Observable, Subscription, startWith, debounceTime } from 'rxjs';
-import * as i2 from '@angular/common';
+import * as i3 from '@angular/common';
 import { DOCUMENT, CommonModule } from '@angular/common';
 import { __decorate } from 'tslib';
 
@@ -288,9 +288,6 @@ class CalculateConnectionCenterRequest {
     }
 }
 
-class FPathBuilderBase {
-}
-
 var EFConnectableSide;
 (function (EFConnectableSide) {
     EFConnectableSide["LEFT"] = "left";
@@ -656,37 +653,38 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
                 type: Input
             }] } });
 
-class FBezierPathBuilder extends FPathBuilderBase {
-    static getAnglePoint(side, source, target) {
-        let result = PointExtensions.initialize(source.x, 0.5 * (source.y + target.y));
-        if (side === EFConnectableSide.LEFT || side === EFConnectableSide.RIGHT) {
-            result = PointExtensions.initialize(0.5 * (source.x + target.x), source.y);
+class FBezierPathBuilder {
+    static getConnectorOffset(distance, offset) {
+        if (distance >= offset) {
+            return distance;
+        }
+        return offset * Math.sqrt(offset - distance);
+    }
+    static getAnglePoint(side, source, target, offset) {
+        let result = { x: source.x, y: source.y };
+        switch (side) {
+            case EFConnectableSide.LEFT:
+                result.x -= FBezierPathBuilder.getConnectorOffset(source.x - target.x, offset);
+                break;
+            case EFConnectableSide.RIGHT:
+                result.x += FBezierPathBuilder.getConnectorOffset(target.x - source.x, offset);
+                break;
+            case EFConnectableSide.TOP:
+                result.y -= FBezierPathBuilder.getConnectorOffset(source.y - target.y, offset);
+                break;
+            case EFConnectableSide.BOTTOM:
+                result.y += FBezierPathBuilder.getConnectorOffset(target.y - source.y, offset);
+                break;
         }
         return result;
     }
     handle(request) {
-        const { source, sourceSide, target, targetSide } = request;
-        const sourceAnglePoint = FBezierPathBuilder.getAnglePoint(sourceSide, source, target);
-        const targetAnglePoint = FBezierPathBuilder.getAnglePoint(targetSide, source, target);
+        const { source, sourceSide, target, targetSide, offset } = request;
+        const sourceAnglePoint = FBezierPathBuilder.getAnglePoint(sourceSide, source, target, offset);
+        const targetAnglePoint = FBezierPathBuilder.getAnglePoint(targetSide, target, source, offset);
         const path = `M ${source.x} ${source.y} C ${sourceAnglePoint.x} ${sourceAnglePoint.y}, ${targetAnglePoint.x} ${targetAnglePoint.y}, ${target.x + 0.0001} ${target.y + 0.0001}`;
-        const center = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest([source, sourceAnglePoint, targetAnglePoint, target]));
-        return { path, center };
-    }
-}
-
-var EFConnectionType;
-(function (EFConnectionType) {
-    EFConnectionType["SEGMENT"] = "segment";
-    EFConnectionType["STRAIGHT"] = "straight";
-    EFConnectionType["BEZIER"] = "bezier";
-})(EFConnectionType || (EFConnectionType = {}));
-
-class FStraightPathBuilder extends FPathBuilderBase {
-    handle(request) {
-        const { source, target } = request;
-        const path = `M ${source.x} ${source.y} L ${target.x + 0.0001} ${target.y + 0.0001}`;
-        const center = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest([source, target]));
-        return { path, center };
+        const connectionCenter = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest([source, sourceAnglePoint, targetAnglePoint, target]));
+        return { path, connectionCenter };
     }
 }
 
@@ -697,12 +695,12 @@ const CONNECTOR_SIDE_POINT = {
     [EFConnectableSide.BOTTOM]: PointExtensions.initialize(0, 1),
     [EFConnectableSide.AUTO]: PointExtensions.initialize(0, 0),
 };
-class FSegmentPathBuilder extends FPathBuilderBase {
+class FSegmentPathBuilder {
     handle(request) {
         const { source, sourceSide, target, targetSide } = request;
         const { points, center } = this.getPathPoints(source, sourceSide, target, targetSide, request.offset);
         const path = this.buildPath(points, request.radius);
-        return { path, center };
+        return { path, connectionCenter: center };
     }
     getPathPoints(source, sourceSide, target, targetSide, offset) {
         const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];
@@ -827,17 +825,12 @@ class FSegmentPathBuilder extends FPathBuilderBase {
     }
 }
 
-class FPathBuilderSelector extends FPathBuilderBase {
-    constructor() {
-        super(...arguments);
-        this.builders = {
-            [EFConnectionType.STRAIGHT]: new FStraightPathBuilder(),
-            [EFConnectionType.BEZIER]: new FBezierPathBuilder(),
-            [EFConnectionType.SEGMENT]: new FSegmentPathBuilder(),
-        };
-    }
+class FStraightPathBuilder {
     handle(request) {
-        return this.builders[request.type].handle(request);
+        const { source, target } = request;
+        const path = `M ${source.x} ${source.y} L ${target.x + 0.0001} ${target.y + 0.0001}`;
+        const connectionCenter = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest([source, target]));
+        return { path, connectionCenter };
     }
 }
 
@@ -1257,18 +1250,50 @@ function mixinChangeConnectionVisibility(base) {
     };
 }
 
+const F_CONNECTION_BUILDERS = new InjectionToken('F_CONNECTION_BUILDERS');
+
+class FConnectionFactory {
+    constructor(builders) {
+        this.builders = {
+            [EFConnectionType.STRAIGHT]: new FStraightPathBuilder(),
+            [EFConnectionType.BEZIER]: new FBezierPathBuilder(),
+            [EFConnectionType.SEGMENT]: new FSegmentPathBuilder(),
+        };
+        if (builders) {
+            this.builders = { ...this.builders, ...builders };
+        }
+    }
+    handle(request) {
+        const builder = this.builders[request.type];
+        if (!builder) {
+            throw new Error(`FConnectionBuilder not found for type ${request.type}`);
+        }
+        return builder.handle(request.payload);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionFactory, deps: [{ token: F_CONNECTION_BUILDERS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionFactory }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [F_CONNECTION_BUILDERS]
+                }] }] });
+
 const MIXIN_BASE$1 = mixinChangeConnectionSelection(mixinChangeConnectionVisibility(class {
     constructor(hostElement) {
         this.hostElement = hostElement;
     }
 }));
 class FConnectionBase extends MIXIN_BASE$1 {
-    constructor(elementReference) {
+    constructor(elementReference, connectionFactory) {
         super(elementReference.nativeElement);
+        this.connectionFactory = connectionFactory;
         this.path = '';
         this.vector = VectorExtensions.initialize();
         this.stateChanges = new Subject();
-        this.fPathBuilder = new FPathBuilderSelector();
     }
     initialize() {
         this.fPath.initialize();
@@ -1286,24 +1311,26 @@ class FConnectionBase extends MIXIN_BASE$1 {
     }
     setVector(from, fromSide, to, toSide) {
         this.vector = { point1: from, point2: to };
-        const pathResult = this.fPathBuilder.handle({
+        const pathResult = this.connectionFactory.handle({
             type: this.fType,
-            source: from,
-            sourceSide: fromSide,
-            target: to,
-            targetSide: toSide,
-            radius: 8,
-            offset: 32
+            payload: {
+                source: from,
+                sourceSide: fromSide,
+                target: to,
+                targetSide: toSide,
+                radius: 8,
+                offset: 32
+            }
         });
         this.path = pathResult.path;
-        const transform = `position: absolute; pointerEvents: all; transform: translate(-50%, -50%); left: ${pathResult.center.x}px; top: ${pathResult.center.y}px`;
+        const transform = `position: absolute; pointerEvents: all; transform: translate(-50%, -50%); left: ${pathResult.connectionCenter.x}px; top: ${pathResult.connectionCenter.y}px`;
         this.fConnectionCenter?.nativeElement?.setAttribute('style', transform);
     }
     setMarkers() {
         this.fDefs.nativeElement.innerHTML = '';
         this.fMarkers.forEach((marker) => {
             const markerElement = DomElementExtensions.createSvgElement('marker');
-            markerElement.setAttribute('id', getFlowUid() + '-' + marker.type + '-' + this.fConnectionId);
+            markerElement.setAttribute('id', this.getMarkerId(getFlowUid() + '-' + marker.type + '-' + this.fConnectionId));
             markerElement.setAttribute('markerHeight', `${marker.height}`);
             markerElement.setAttribute('markerWidth', `${marker.width}`);
             markerElement.setAttribute('orient', 'auto');
@@ -1321,6 +1348,9 @@ class FConnectionBase extends MIXIN_BASE$1 {
             marker.hostElement.remove();
         });
     }
+    getMarkerId(id) {
+        return sanitizeElementId(id);
+    }
     redraw() {
         this.fPath.setPath(this.path);
         this.fSelection.setPath(this.path);
@@ -1328,12 +1358,12 @@ class FConnectionBase extends MIXIN_BASE$1 {
         this.fDragHandle.redraw(this.vector.point2);
         this.fTextComponent.redraw(this.vector);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionBase, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionBase, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: FConnectionBase, usesInheritance: true, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionBase, decorators: [{
             type: Directive
-        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FConnectionFactory }] });
 
 var EFConnectionBehavior;
 (function (EFConnectionBehavior) {
@@ -1350,6 +1380,13 @@ function castToConnectionBehavior(behavior) {
     return result;
 }
 
+var EFConnectionType;
+(function (EFConnectionType) {
+    EFConnectionType["SEGMENT"] = "segment";
+    EFConnectionType["STRAIGHT"] = "straight";
+    EFConnectionType["BEZIER"] = "bezier";
+})(EFConnectionType || (EFConnectionType = {}));
+
 function castToConnectionType(type) {
     const result = EFConnectionType[type.toUpperCase()];
     if (result === undefined) {
@@ -1378,7 +1415,7 @@ class FConnectionForCreateComponent extends FConnectionBase {
         return this._behavior;
     }
     set fType(value) {
-        this._type = castToConnectionType(value);
+        this._type = value;
     }
     get fType() {
         return this._type;
@@ -1386,8 +1423,8 @@ class FConnectionForCreateComponent extends FConnectionBase {
     get boundingElement() {
         return this.fPath.hostElement;
     }
-    constructor(elementReference, fComponentsStore) {
-        super(elementReference);
+    constructor(elementReference, fConnectionFactory, fComponentsStore) {
+        super(elementReference, fConnectionFactory);
         this.fComponentsStore = fComponentsStore;
         this.fConnectionId = `f-connection-for-create-${uniqueId$4++}`;
         this.fText = '';
@@ -1407,15 +1444,15 @@ class FConnectionForCreateComponent extends FConnectionBase {
     ngOnDestroy() {
         this.fComponentsStore.fTempConnection = undefined;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionForCreateComponent, deps: [{ token: i0.ElementRef }, { token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.1", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { fStartColor: "fStartColor", fEndColor: "fEndColor", fBehavior: "fBehavior", fType: "fType" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], queries: [{ propertyName: "fMarkers", predicate: F_MARKER, descendants: true }, { propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionForCreateComponent, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }, { token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.1", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { fStartColor: "fStartColor", fEndColor: "fEndColor", fBehavior: "fBehavior", fType: "fType" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], queries: [{ propertyName: "fMarkers", predicate: F_MARKER, descendants: true }, { propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionForCreateComponent, decorators: [{
             type: Component,
             args: [{ selector: "f-connection-for-create", changeDetection: ChangeDetectionStrategy.OnPush, host: {
                         class: "f-component f-connection f-connection-for-create"
                     }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FComponentsStore }], propDecorators: { fStartColor: [{
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FConnectionFactory }, { type: FComponentsStore }], propDecorators: { fStartColor: [{
                 type: Input
             }], fEndColor: [{
                 type: Input
@@ -1461,7 +1498,7 @@ class FConnectionComponent extends FConnectionBase {
         return this._behavior;
     }
     set fType(value) {
-        this._type = castToConnectionType(value);
+        this._type = value;
     }
     get fType() {
         return this._type;
@@ -1469,8 +1506,8 @@ class FConnectionComponent extends FConnectionBase {
     get boundingElement() {
         return this.fPath.hostElement;
     }
-    constructor(elementReference, fComponentsStore) {
-        super(elementReference);
+    constructor(elementReference, fConnectionFactory, fComponentsStore) {
+        super(elementReference, fConnectionFactory);
         this.fComponentsStore = fComponentsStore;
         this.fConnectionId = `f-connection-${uniqueId$3++}`;
         this.fText = '';
@@ -1487,8 +1524,8 @@ class FConnectionComponent extends FConnectionBase {
     ngOnDestroy() {
         this.fComponentsStore.removeConnection(this);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionComponent, deps: [{ token: i0.ElementRef }, { token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.1", type: FConnectionComponent, selector: "f-connection", inputs: { fConnectionId: "fConnectionId", fText: "fText", fStartColor: "fStartColor", fEndColor: "fEndColor", fOutputId: "fOutputId", fInputId: "fInputId", fBehavior: "fBehavior", fType: "fType", fDraggingDisabled: ["fReassignDisabled", "fDraggingDisabled"], fSelectionDisabled: "fSelectionDisabled" }, host: { properties: { "attr.id": "fConnectionId", "class.f-connection-selection-disabled": "fSelectionDisabled", "class.f-connection-reassign-disabled": "fDraggingDisabled" }, classAttribute: "f-component f-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionComponent }], queries: [{ propertyName: "fMarkers", predicate: F_MARKER, descendants: true }, { propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"overflow: visible; display: block; vertical-align: middle;\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionComponent, deps: [{ token: i0.ElementRef }, { token: FConnectionFactory }, { token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.1", type: FConnectionComponent, selector: "f-connection", inputs: { fConnectionId: "fConnectionId", fText: "fText", fStartColor: "fStartColor", fEndColor: "fEndColor", fOutputId: "fOutputId", fInputId: "fInputId", fBehavior: "fBehavior", fType: "fType", fDraggingDisabled: ["fReassignDisabled", "fDraggingDisabled"], fSelectionDisabled: "fSelectionDisabled" }, host: { properties: { "attr.id": "fConnectionId", "class.f-connection-selection-disabled": "fSelectionDisabled", "class.f-connection-reassign-disabled": "fDraggingDisabled" }, classAttribute: "f-component f-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionComponent }], queries: [{ propertyName: "fMarkers", predicate: F_MARKER, descendants: true }, { propertyName: "fConnectionCenters", predicate: FConnectionCenterDirective, descendants: true }], viewQueries: [{ propertyName: "fDefs", first: true, predicate: ["defs"], descendants: true, static: true }, { propertyName: "fPath", first: true, predicate: CONNECTION_PATH, descendants: true, static: true }, { propertyName: "fGradient", first: true, predicate: CONNECTION_GRADIENT, descendants: true, static: true }, { propertyName: "fDragHandle", first: true, predicate: FConnectionDragHandleComponent, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: FConnectionSelectionComponent, descendants: true, static: true }, { propertyName: "fTextComponent", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fConnectionCenter", first: true, predicate: ["fConnectionCenter"], descendants: true }], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"overflow: visible; display: block; vertical-align: middle;\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FConnectionComponent, decorators: [{
             type: Component,
@@ -1498,7 +1535,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
                         '[class.f-connection-selection-disabled]': 'fSelectionDisabled',
                         '[class.f-connection-reassign-disabled]': 'fDraggingDisabled',
                     }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\" style=\"overflow: visible; display: block; vertical-align: middle;\">\n    <defs #defs></defs>\n    <g class=\"f-connection-group\">\n        <linearGradient fConnectionGradient></linearGradient>\n        <path fConnectionSelection [attr.d]=\"path\"></path>\n        <g>\n            <path f-connection-path\n                  [attr.d]=\"path\">\n            </path>\n            <circle f-connection-drag-handle r=\"8\"></circle>\n        </g>\n        <text f-connection-text></text>\n    </g>\n    <ng-content></ng-content>\n</svg>\n<div #fConnectionCenter class=\"f-connection-center\" *ngIf=\"fConnectionCenters.length\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n</div>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FComponentsStore }], propDecorators: { fConnectionId: [{
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: FConnectionFactory }, { type: FComponentsStore }], propDecorators: { fConnectionId: [{
                 type: Input
             }], fText: [{
                 type: Input
@@ -2167,27 +2204,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: FComponentsStore }] });
 
-class InputsUnderPointerHandler {
-    get fInputs() {
-        return this.fComponentsStore.fInputs;
-    }
-    constructor(fComponentsStore) {
-        this.fComponentsStore = fComponentsStore;
-    }
-    handle(event) {
-        const position = event.getPosition();
-        const elementsFromPoint = document.elementsFromPoint(position.x, position.y);
-        return elementsFromPoint.filter((x) => isNodeInput(x)).map((element) => {
-            return this.fInputs.find((x) => x.isContains(element));
-        }).filter((x) => !!x);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: InputsUnderPointerHandler, deps: [{ token: FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: InputsUnderPointerHandler }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: InputsUnderPointerHandler, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }] });
-
 class FindInputsUnderPointerRequest {
     constructor(event, dragHandler) {
         this.event = event;
@@ -2232,9 +2248,11 @@ class FindInputsUnderPointerHandler {
     get fNodes() {
         return this.fComponentsStore.fNodes;
     }
-    constructor(fComponentsStore, inputsUnderPointerHandler, firstNotConnectedInputOfNodeUnderPointerHandler) {
+    get fInputs() {
+        return this.fComponentsStore.fInputs;
+    }
+    constructor(fComponentsStore, firstNotConnectedInputOfNodeUnderPointerHandler) {
         this.fComponentsStore = fComponentsStore;
-        this.inputsUnderPointerHandler = inputsUnderPointerHandler;
         this.firstNotConnectedInputOfNodeUnderPointerHandler = firstNotConnectedInputOfNodeUnderPointerHandler;
     }
     handle(payload) {
@@ -2253,7 +2271,7 @@ class FindInputsUnderPointerHandler {
         });
     }
     getInputsUnderPointer(payload) {
-        let inputs = this.inputsUnderPointerHandler.handle(payload.event);
+        let inputs = this.inputsUnderPointer(payload.event.getPosition());
         const input = this.firstNotConnectedInputOfNodeUnderPointerHandler.handle(payload.event);
         if (input) {
             inputs.push(input);
@@ -2261,12 +2279,18 @@ class FindInputsUnderPointerHandler {
         inputs = inputs.filter((x) => x.canBeConnected);
         return inputs;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FindInputsUnderPointerHandler, deps: [{ token: FComponentsStore }, { token: InputsUnderPointerHandler }, { token: FirstNotConnectedInputOfNodeUnderPointerHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    inputsUnderPointer(position) {
+        const elementsFromPoint = document.elementsFromPoint(position.x, position.y);
+        return elementsFromPoint.filter((x) => isNodeInput(x)).map((element) => {
+            return this.fInputs.find((x) => x.isContains(element));
+        }).filter((x) => !!x);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FindInputsUnderPointerHandler, deps: [{ token: FComponentsStore }, { token: FirstNotConnectedInputOfNodeUnderPointerHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FindInputsUnderPointerHandler }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FindInputsUnderPointerHandler, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: FComponentsStore }, { type: InputsUnderPointerHandler }, { type: FirstNotConnectedInputOfNodeUnderPointerHandler }] });
+        }], ctorParameters: () => [{ type: FComponentsStore }, { type: FirstNotConnectedInputOfNodeUnderPointerHandler }] });
 
 class CreateConnectionOnPointerUp {
     constructor(fComponentsStore, fDraggableDataContext, findInputsUnderPointerHandler, findFirstCanBeConnectedOutputByOutletHandler) {
@@ -2501,7 +2525,6 @@ const CONNECTIONS_PROVIDERS = [
     CreateConnectionOnPointerUp,
     CreateConnectionPrepareDragSequence,
     FirstNotConnectedInputOfNodeUnderPointerHandler,
-    InputsUnderPointerHandler,
     FindInputsUnderPointerHandler,
     ReassignConnectionOnPointerUp,
     ReassignConnectionPrepareDragSequence
@@ -3763,8 +3786,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
         }], ctorParameters: () => [{ type: FDraggableDataContext }] });
 
 class RedrawConnectionsRequest {
-    constructor() {
-    }
 }
 
 let RedrawConnectionsHandler = class RedrawConnectionsHandler {
@@ -4461,6 +4482,7 @@ class FFlowComponent extends FFlowBase {
             FFlowMediator,
             FComponentsStore,
             FDraggableDataContext,
+            FConnectionFactory,
             ...SINGLE_SELECT_PROVIDERS,
             ...SELECTION_AREA_PROVIDERS,
             ...NODE_PROVIDERS,
@@ -4480,6 +4502,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
                         FFlowMediator,
                         FComponentsStore,
                         FDraggableDataContext,
+                        FConnectionFactory,
                         ...SINGLE_SELECT_PROVIDERS,
                         ...SELECTION_AREA_PROVIDERS,
                         ...NODE_PROVIDERS,
@@ -4604,5 +4627,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CANVAS_PROVIDERS, COMMON_PROVIDERS, CONNECTIONS_PROVIDERS, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, CalculateCenterBetweenPointsHandler, CalculateCenterBetweenPointsRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest, CanvasDragHandler, CanvasOnPointerUp, CanvasPrepareDragSequence, ClearSelectionHandler, ClearSelectionRequest, ConnectionDragHandler, ConnectionSourceDragHandler, ConnectionTargetDragHandler, CreateConnectionDragHandler, CreateConnectionOnPointerUp, CreateConnectionPrepareDragSequence, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFDraggableType, EFMarkerType, EXTERNAL_ITEM_PROVIDERS, ExternalItemDragHandler, ExternalItemOnPointerUp, ExternalItemPrepareDragSequence, FBackgroundBase, FBackgroundComponent, FBezierPathBuilder, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FCellPatternComponent, FComponentsStore, FConnectionBase, FConnectionCenterDirective, FConnectionComponent, FConnectionDragHandleComponent, FConnectionForCreateComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective, FConnectorBase, FCreateConnectionEvent, FCreateNodeEvent, FDragHandleDirective, FDraggableBase, FDraggableDataContext, FDraggableDirective, FExternalItemBase, FExternalItemDirective, FExternalItemService, FFlowBase, FFlowComponent, FFlowMediator, FFlowModule, FHandlerRegister, FLOW, FLineAlignmentBase, FLineAlignmentComponent, FMarkerBase, FMarkerDirective, FNodeBase, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FPathBuilderBase, FPathBuilderSelector, FReassignConnectionEvent, FResizeObserver, FSegmentPathBuilder, FSelectionAreaBase, FSelectionAreaComponent, FSelectionChangeEvent, FStraightPathBuilder, FZoomBase, FZoomDirective, F_BACKGROUND, F_BACKGROUND_PATTERN, F_CANVAS, F_CONNECTION_DRAG_HANDLE_CLASS, F_CONNECTION_IDENTIFIERS, F_DRAGGABLE, F_DRAG_HANDLE, F_EXTERNAL_ITEM, F_FLOW, F_LINE_ALIGNMENT, F_MARKER, F_NODE, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_SELECTED_CLASS, F_SELECTION_AREA, F_ZOOM, FindFirstCanBeConnectedOutputByOutletHandler, FindInputsUnderPointerHandler, FindInputsUnderPointerRequest, FirstNotConnectedInputOfNodeUnderPointerHandler, GetCanBeSelectedItemsHandler, GetConnectionHandler, GetConnectionVectorHandler, GetConnectionVectorRequest, GetElementRectInFlowHandler, GetElementRectInFlowRequest, GetIncomingConnectionsHandler, GetInputRectInFlowHandler, GetInputRectInFlowRequest, GetInputRectInFlowResponse, GetNodesRectHandler, GetNodesRectRequest, GetOutgoingConnectionsHandler, GetOutputRectInFlowHandler, GetOutputRectInFlowRequest, GetOutputRectInFlowResponse, GetSelectionHandler, GetSelectionRequest, InputsUnderPointerHandler, IsConnectionUnderNodeHandler, LineElement, LineService, MOUSE_EVENT_IGNORE_TIME, NODE_PROVIDERS, NearestCoordinateFinder, NodeDragHandler, NodeOnPointerUp, NodePrepareDragSequence, ReassignConnectionDragHandler, ReassignConnectionOnPointerUp, ReassignConnectionPrepareDragSequence, RedrawConnectionsHandler, RedrawConnectionsRequest, SELECTION_AREA_PROVIDERS, SINGLE_SELECT_PROVIDERS, SelectAllHandler, SelectAllRequest, SelectHandler, SelectRequest, SelectionAreaDragHandle, SelectionAreaOnPointerUp, SelectionAreaPrepareDragSequence, SingleSelectOnPointerDown, UpdateConnectionLayerHandler, UpdateNodeLayerHandler, castToConnectableSide, castToConnectionBehavior, castToConnectionType, getExternalItem, getFlowUid, isExternalItem, isNode, isNodeDragHandle, isNodeInput, isNodeOutlet, isNodeOutput, mixinChangeConnectionSelection, mixinChangeConnectionVisibility };
+export { CANVAS_PROVIDERS, COMMON_PROVIDERS, CONNECTIONS_PROVIDERS, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, CalculateCenterBetweenPointsHandler, CalculateCenterBetweenPointsRequest, CalculateConnectionCenterHandler, CalculateConnectionCenterRequest, CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest, CanvasDragHandler, CanvasOnPointerUp, CanvasPrepareDragSequence, ClearSelectionHandler, ClearSelectionRequest, ConnectionDragHandler, ConnectionSourceDragHandler, ConnectionTargetDragHandler, CreateConnectionDragHandler, CreateConnectionOnPointerUp, CreateConnectionPrepareDragSequence, EFConnectableSide, EFConnectionBehavior, EFConnectionType, EFDraggableType, EFMarkerType, EXTERNAL_ITEM_PROVIDERS, ExternalItemDragHandler, ExternalItemOnPointerUp, ExternalItemPrepareDragSequence, FBackgroundBase, FBackgroundComponent, FBezierPathBuilder, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FCellPatternComponent, FComponentsStore, FConnectionBase, FConnectionCenterDirective, FConnectionComponent, FConnectionDragHandleComponent, FConnectionFactory, FConnectionForCreateComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective, FConnectorBase, FCreateConnectionEvent, FCreateNodeEvent, FDragHandleDirective, FDraggableBase, FDraggableDataContext, FDraggableDirective, FExternalItemBase, FExternalItemDirective, FExternalItemService, FFlowBase, FFlowComponent, FFlowMediator, FFlowModule, FHandlerRegister, FLOW, FLineAlignmentBase, FLineAlignmentComponent, FMarkerBase, FMarkerDirective, FNodeBase, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FReassignConnectionEvent, FResizeObserver, FSegmentPathBuilder, FSelectionAreaBase, FSelectionAreaComponent, FSelectionChangeEvent, FStraightPathBuilder, FZoomBase, FZoomDirective, F_BACKGROUND, F_BACKGROUND_PATTERN, F_CANVAS, F_CONNECTION_BUILDERS, F_CONNECTION_DRAG_HANDLE_CLASS, F_CONNECTION_IDENTIFIERS, F_DRAGGABLE, F_DRAG_HANDLE, F_EXTERNAL_ITEM, F_FLOW, F_LINE_ALIGNMENT, F_MARKER, F_NODE, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_SELECTED_CLASS, F_SELECTION_AREA, F_ZOOM, FindFirstCanBeConnectedOutputByOutletHandler, FindInputsUnderPointerHandler, FindInputsUnderPointerRequest, FirstNotConnectedInputOfNodeUnderPointerHandler, GetCanBeSelectedItemsHandler, GetConnectionHandler, GetConnectionVectorHandler, GetConnectionVectorRequest, GetElementRectInFlowHandler, GetElementRectInFlowRequest, GetIncomingConnectionsHandler, GetInputRectInFlowHandler, GetInputRectInFlowRequest, GetInputRectInFlowResponse, GetNodesRectHandler, GetNodesRectRequest, GetOutgoingConnectionsHandler, GetOutputRectInFlowHandler, GetOutputRectInFlowRequest, GetOutputRectInFlowResponse, GetSelectionHandler, GetSelectionRequest, IsConnectionUnderNodeHandler, LineElement, LineService, MOUSE_EVENT_IGNORE_TIME, NODE_PROVIDERS, NearestCoordinateFinder, NodeDragHandler, NodeOnPointerUp, NodePrepareDragSequence, ReassignConnectionDragHandler, ReassignConnectionOnPointerUp, ReassignConnectionPrepareDragSequence, RedrawConnectionsHandler, RedrawConnectionsRequest, SELECTION_AREA_PROVIDERS, SINGLE_SELECT_PROVIDERS, SelectAllHandler, SelectAllRequest, SelectHandler, SelectRequest, SelectionAreaDragHandle, SelectionAreaOnPointerUp, SelectionAreaPrepareDragSequence, SingleSelectOnPointerDown, UpdateConnectionLayerHandler, UpdateNodeLayerHandler, castToConnectableSide, castToConnectionBehavior, castToConnectionType, getExternalItem, getFlowUid, isExternalItem, isNode, isNodeDragHandle, isNodeInput, isNodeOutlet, isNodeOutput, mixinChangeConnectionSelection, mixinChangeConnectionVisibility };
 //# sourceMappingURL=foblex-flow.mjs.map