@foblex/flow 12.6.1 → 12.6.3

package/esm2015/f-connection/common/domain/f-segment.path-builder.js

@@ -0,0 +1,142 @@
+import { PointExtensions } from '@foblex/core';
+import { EFConnectableSide } from '../../../f-connectors';
+import { CalculateCenterBetweenPointsHandler, CalculateCenterBetweenPointsRequest } from './calculate-center-between-points';
+import { CalculateConnectionCenterHandler, CalculateConnectionCenterRequest } from './calculate-connection-center';
+const CONNECTOR_SIDE_POINT = {
+    [EFConnectableSide.LEFT]: PointExtensions.initialize(-1, 0),
+    [EFConnectableSide.RIGHT]: PointExtensions.initialize(1, 0),
+    [EFConnectableSide.TOP]: PointExtensions.initialize(0, -1),
+    [EFConnectableSide.BOTTOM]: PointExtensions.initialize(0, 1),
+    [EFConnectableSide.AUTO]: PointExtensions.initialize(0, 0),
+};
+export 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);
+        const penultimatePoint = points.length > 1 ? points[points.length - 2] : source;
+        return { path, connectionCenter: center, penultimatePoint };
+    }
+    getPathPoints(source, sourceSide, target, targetSide, offset) {
+        const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];
+        const targetDirection = CONNECTOR_SIDE_POINT[targetSide];
+        const sourceGap = { x: source.x + sourceDirection.x * offset, y: source.y + sourceDirection.y * offset };
+        const targetGap = { x: target.x + targetDirection.x * offset, y: target.y + targetDirection.y * offset };
+        const direction = this.getDirection(sourceGap, sourceSide, targetGap);
+        const directionAccessor = direction.x !== 0 ? 'x' : 'y';
+        const currentDirection = direction[directionAccessor];
+        let points = [];
+        const sourceGapOffset = PointExtensions.initialize();
+        const targetGapOffset = PointExtensions.initialize();
+        const centerBetweenPoints = new CalculateCenterBetweenPointsHandler().handle(new CalculateCenterBetweenPointsRequest(source, target));
+        if (sourceDirection[directionAccessor] * targetDirection[directionAccessor] === -1) {
+            const verticalSplit = [
+                { x: centerBetweenPoints.x, y: sourceGap.y },
+                { x: centerBetweenPoints.x, y: targetGap.y },
+            ];
+            const horizontalSplit = [
+                { x: sourceGap.x, y: centerBetweenPoints.y },
+                { x: targetGap.x, y: centerBetweenPoints.y },
+            ];
+            if (sourceDirection[directionAccessor] === currentDirection) {
+                points = directionAccessor === 'x' ? verticalSplit : horizontalSplit;
+            }
+            else {
+                points = directionAccessor === 'x' ? horizontalSplit : verticalSplit;
+            }
+        }
+        else {
+            const sourceTarget = [{ x: sourceGap.x, y: targetGap.y }];
+            const targetSource = [{ x: targetGap.x, y: sourceGap.y }];
+            if (directionAccessor === 'x') {
+                points = sourceDirection.x === currentDirection ? targetSource : sourceTarget;
+            }
+            else {
+                points = sourceDirection.y === currentDirection ? sourceTarget : targetSource;
+            }
+            if (sourceSide === targetSide) {
+                const diff = Math.abs(source[directionAccessor] - target[directionAccessor]);
+                if (diff <= offset) {
+                    const gapOffset = Math.min(offset - 1, offset - diff);
+                    if (sourceDirection[directionAccessor] === currentDirection) {
+                        sourceGapOffset[directionAccessor] = (sourceGap[directionAccessor] > source[directionAccessor] ? -1 : 1) * gapOffset;
+                    }
+                    else {
+                        targetGapOffset[directionAccessor] = (targetGap[directionAccessor] > target[directionAccessor] ? -1 : 1) * gapOffset;
+                    }
+                }
+            }
+            if (sourceSide !== targetSide) {
+                const dirAccessorOpposite = directionAccessor === 'x' ? 'y' : 'x';
+                const isSameDir = sourceDirection[directionAccessor] === targetDirection[dirAccessorOpposite];
+                const sourceGtTargetOppo = sourceGap[dirAccessorOpposite] > targetGap[dirAccessorOpposite];
+                const sourceLtTargetOppo = sourceGap[dirAccessorOpposite] < targetGap[dirAccessorOpposite];
+                const flipSourceTarget = (sourceDirection[directionAccessor] === 1 &&
+                    ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||
+                    (sourceDirection[directionAccessor] !== 1 &&
+                        ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));
+                if (flipSourceTarget) {
+                    points = directionAccessor === 'x' ? sourceTarget : targetSource;
+                }
+            }
+        }
+        const pathPoints = [
+            source,
+            { x: sourceGap.x + sourceGapOffset.x, y: sourceGap.y + sourceGapOffset.y },
+            ...points,
+            { x: targetGap.x + targetGapOffset.x, y: targetGap.y + targetGapOffset.y },
+            target,
+        ];
+        const center = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest(pathPoints));
+        return { points: pathPoints, center: center };
+    }
+    getDirection(source, sourceSide, target) {
+        if (sourceSide === EFConnectableSide.LEFT || sourceSide === EFConnectableSide.RIGHT) {
+            return source.x < target.x ? PointExtensions.initialize(1, 0) : PointExtensions.initialize(-1, 0);
+        }
+        return source.y < target.y ? PointExtensions.initialize(0, 1) : PointExtensions.initialize(0, -1);
+    }
+    distance(a, b) {
+        return Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
+    }
+    buildPath(points, borderRadius) {
+        let path = '';
+        for (let i = 0; i < points.length; i++) {
+            const p = points[i];
+            let segment = '';
+            if (i > 0 && i < points.length - 1) {
+                segment = this.getBend(points[i - 1], p, points[i + 1], borderRadius);
+            }
+            else if (i === points.length - 1) {
+                segment = this.buildLastLineSegment(i, p);
+            }
+            else {
+                segment = this.buildMoveOrLineSegment(i, p);
+            }
+            path += segment;
+        }
+        return path;
+    }
+    getBend(a, b, c, size) {
+        const bendSize = Math.min(this.distance(a, b) / 2, this.distance(b, c) / 2, size);
+        const { x, y } = b;
+        if ((a.x === x && x === c.x) || (a.y === y && y === c.y)) {
+            return `L${x} ${y}`;
+        }
+        if (a.y === y) {
+            const xDir = a.x < c.x ? -1 : 1;
+            const yDir = a.y < c.y ? 1 : -1;
+            return `L ${x + bendSize * xDir},${y}Q ${x},${y} ${x},${y + bendSize * yDir}`;
+        }
+        const xDir = a.x < c.x ? 1 : -1;
+        const yDir = a.y < c.y ? -1 : 1;
+        return `L ${x},${y + bendSize * yDir}Q ${x},${y} ${x + bendSize * xDir},${y}`;
+    }
+    buildMoveOrLineSegment(index, point) {
+        return `${index === 0 ? 'M' : 'L'}${point.x} ${point.y}`;
+    }
+    buildLastLineSegment(index, point) {
+        return `L${point.x + 0.0002} ${point.y + 0.0002}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-segment.path-builder.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-connection/common/domain/f-segment.path-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { IMap, IPoint, PointExtensions } from '@foblex/core';\nimport { EFConnectableSide } from '../../../f-connectors';\nimport {\n  CalculateCenterBetweenPointsHandler,\n  CalculateCenterBetweenPointsRequest\n} from './calculate-center-between-points';\nimport { CalculateConnectionCenterHandler, CalculateConnectionCenterRequest } from './calculate-connection-center';\nimport {\n  IFConnectionBuilder,\n  IFConnectionBuilderRequest,\n  IFConnectionBuilderResponse\n} from '../../f-connection-builder';\n\nconst CONNECTOR_SIDE_POINT: IMap<IPoint> = {\n\n  [ EFConnectableSide.LEFT ]: PointExtensions.initialize(-1, 0),\n\n  [ EFConnectableSide.RIGHT ]: PointExtensions.initialize(1, 0),\n\n  [ EFConnectableSide.TOP ]: PointExtensions.initialize(0, -1),\n\n  [ EFConnectableSide.BOTTOM ]: PointExtensions.initialize(0, 1),\n\n  [ EFConnectableSide.AUTO ]: PointExtensions.initialize(0, 0),\n};\n\nexport class FSegmentPathBuilder implements IFConnectionBuilder {\n\n  public handle(request: IFConnectionBuilderRequest): IFConnectionBuilderResponse {\n    const { source, sourceSide, target, targetSide } = request;\n\n    const { points, center } = this.getPathPoints(\n        source,\n        sourceSide,\n        target,\n        targetSide,\n        request.offset\n    );\n\n    const path = this.buildPath(points, request.radius);\n\n    const penultimatePoint = points.length > 1 ? points[ points.length - 2 ] : source;\n\n    return { path, connectionCenter: center, penultimatePoint };\n  }\n\n  private getPathPoints(\n      source: IPoint, sourceSide: EFConnectableSide, target: IPoint, targetSide: EFConnectableSide, offset: number\n  ): { points: IPoint[], center: IPoint } {\n\n    const sourceDirection = CONNECTOR_SIDE_POINT[ sourceSide ];\n    const targetDirection = CONNECTOR_SIDE_POINT[ targetSide ];\n\n    const sourceGap: IPoint = { x: source.x + sourceDirection.x * offset, y: source.y + sourceDirection.y * offset };\n    const targetGap: IPoint = { x: target.x + targetDirection.x * offset, y: target.y + targetDirection.y * offset };\n\n    const direction = this.getDirection(sourceGap, sourceSide, targetGap);\n    const directionAccessor = direction.x !== 0 ? 'x' : 'y';\n    const currentDirection = direction[ directionAccessor ];\n\n    let points: IPoint[] = [];\n    const sourceGapOffset = PointExtensions.initialize();\n    const targetGapOffset = PointExtensions.initialize();\n\n    const centerBetweenPoints = new CalculateCenterBetweenPointsHandler().handle(\n        new CalculateCenterBetweenPointsRequest(source, target)\n    );\n\n    if (sourceDirection[ directionAccessor ] * targetDirection[ directionAccessor ] === -1) {\n      const verticalSplit: IPoint[] = [\n        { x: centerBetweenPoints.x, y: sourceGap.y },\n        { x: centerBetweenPoints.x, y: targetGap.y },\n      ];\n      const horizontalSplit: IPoint[] = [\n        { x: sourceGap.x, y: centerBetweenPoints.y },\n        { x: targetGap.x, y: centerBetweenPoints.y },\n      ];\n\n      if (sourceDirection[ directionAccessor ] === currentDirection) {\n        points = directionAccessor === 'x' ? verticalSplit : horizontalSplit;\n      } else {\n        points = directionAccessor === 'x' ? horizontalSplit : verticalSplit;\n      }\n    } else {\n      const sourceTarget: IPoint[] = [ { x: sourceGap.x, y: targetGap.y } ];\n      const targetSource: IPoint[] = [ { x: targetGap.x, y: sourceGap.y } ];\n\n      if (directionAccessor === 'x') {\n        points = sourceDirection.x === currentDirection ? targetSource : sourceTarget;\n      } else {\n        points = sourceDirection.y === currentDirection ? sourceTarget : targetSource;\n      }\n\n      if (sourceSide === targetSide) {\n        const diff = Math.abs(source[ directionAccessor ] - target[ directionAccessor ]);\n\n        if (diff <= offset) {\n          const gapOffset = Math.min(offset - 1, offset - diff);\n          if (sourceDirection[ directionAccessor ] === currentDirection) {\n            sourceGapOffset[ directionAccessor ] = (sourceGap[ directionAccessor ] > source[ directionAccessor ] ? -1 : 1) * gapOffset;\n          } else {\n            targetGapOffset[ directionAccessor ] = (targetGap[ directionAccessor ] > target[ directionAccessor ] ? -1 : 1) * gapOffset;\n          }\n        }\n      }\n\n      if (sourceSide !== targetSide) {\n        const dirAccessorOpposite = directionAccessor === 'x' ? 'y' : 'x';\n        const isSameDir = sourceDirection[ directionAccessor ] === targetDirection[ dirAccessorOpposite ];\n        const sourceGtTargetOppo = sourceGap[ dirAccessorOpposite ] > targetGap[ dirAccessorOpposite ];\n        const sourceLtTargetOppo = sourceGap[ dirAccessorOpposite ] < targetGap[ dirAccessorOpposite ];\n        const flipSourceTarget =\n            (sourceDirection[ directionAccessor ] === 1 &&\n                ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||\n            (sourceDirection[ directionAccessor ] !== 1 &&\n                ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));\n\n        if (flipSourceTarget) {\n          points = directionAccessor === 'x' ? sourceTarget : targetSource;\n        }\n      }\n    }\n\n    const pathPoints = [\n      source,\n      { x: sourceGap.x + sourceGapOffset.x, y: sourceGap.y + sourceGapOffset.y },\n      ...points,\n      { x: targetGap.x + targetGapOffset.x, y: targetGap.y + targetGapOffset.y },\n      target,\n    ];\n\n    const center = new CalculateConnectionCenterHandler().handle(\n        new CalculateConnectionCenterRequest(pathPoints)\n    );\n\n    return { points: pathPoints, center: center };\n  }\n\n  private getDirection(source: IPoint, sourceSide: EFConnectableSide, target: IPoint): IPoint {\n    if (sourceSide === EFConnectableSide.LEFT || sourceSide === EFConnectableSide.RIGHT) {\n      return source.x < target.x ? PointExtensions.initialize(1, 0) : PointExtensions.initialize(-1, 0);\n    }\n    return source.y < target.y ? PointExtensions.initialize(0, 1) : PointExtensions.initialize(0, -1);\n  }\n\n  private distance(a: IPoint, b: IPoint): number {\n    return Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));\n  }\n\n  private buildPath(points: IPoint[], borderRadius: number): string {\n    let path = '';\n    for (let i = 0; i < points.length; i++) {\n      const p = points[ i ];\n      let segment = '';\n\n      if (i > 0 && i < points.length - 1) {\n        segment = this.getBend(points[ i - 1 ], p, points[ i + 1 ], borderRadius);\n      } else if (i === points.length - 1) {\n        segment = this.buildLastLineSegment(i, p);\n      } else {\n        segment = this.buildMoveOrLineSegment(i, p);\n      }\n      path += segment;\n    }\n\n    return path;\n  }\n\n  private getBend(a: IPoint, b: IPoint, c: IPoint, size: number): string {\n    const bendSize = Math.min(this.distance(a, b) / 2, this.distance(b, c) / 2, size);\n    const { x, y } = b;\n\n    if ((a.x === x && x === c.x) || (a.y === y && y === c.y)) {\n      return `L${ x } ${ y }`;\n    }\n\n    if (a.y === y) {\n      const xDir = a.x < c.x ? -1 : 1;\n      const yDir = a.y < c.y ? 1 : -1;\n      return `L ${ x + bendSize * xDir },${ y }Q ${ x },${ y } ${ x },${ y + bendSize * yDir }`;\n    }\n\n    const xDir = a.x < c.x ? 1 : -1;\n    const yDir = a.y < c.y ? -1 : 1;\n    return `L ${ x },${ y + bendSize * yDir }Q ${ x },${ y } ${ x + bendSize * xDir },${ y }`;\n  }\n\n  private buildMoveOrLineSegment(index: number, point: IPoint): string {\n    return `${ index === 0 ? 'M' : 'L' }${ point.x } ${ point.y }`;\n  }\n\n  private buildLastLineSegment(index: number, point: IPoint): string {\n    return `L${ point.x + 0.0002 } ${ point.y + 0.0002 }`;\n  }\n}\n"]}

package/esm2015/f-connection/common/f-connection-base.js

@@ -0,0 +1,62 @@
+import { Directive } from '@angular/core';
+import { LineExtensions, PointExtensions, } from '@foblex/core';
+import { Subject } from 'rxjs';
+import { mixinChangeConnectionSelection, mixinChangeConnectionVisibility } from './mixins';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-connection-builder";
+const MIXIN_BASE = mixinChangeConnectionSelection(mixinChangeConnectionVisibility(class {
+    constructor(hostElement) {
+        this.hostElement = hostElement;
+    }
+}));
+export class FConnectionBase extends MIXIN_BASE {
+    constructor(elementReference, cFactory) {
+        super(elementReference.nativeElement);
+        this.cFactory = cFactory;
+        this.path = '';
+        this.line = LineExtensions.initialize();
+        this.stateChanges = new Subject();
+        this.penultimatePoint = PointExtensions.initialize();
+    }
+    initialize() {
+        this.fPath.initialize();
+        this.fGradient.initialize();
+        this.redraw();
+    }
+    isContains(element) {
+        var _a;
+        return ((_a = this.hostElement.firstChild) === null || _a === void 0 ? void 0 : _a.lastChild).contains(element);
+    }
+    setLine(source, sourceSide, target, targetSide) {
+        var _a, _b;
+        this.line = LineExtensions.initialize(source, target);
+        const pathResult = this.getPathResult(source, sourceSide, target, targetSide);
+        this.path = pathResult.path;
+        this.penultimatePoint = pathResult.penultimatePoint || source;
+        (_b = (_a = this.fConnectionCenter) === null || _a === void 0 ? void 0 : _a.nativeElement) === null || _b === void 0 ? void 0 : _b.setAttribute('style', this.getTransform(pathResult.connectionCenter));
+    }
+    getPathResult(source, sourceSide, target, targetSide) {
+        const radius = this.fRadius > 0 ? this.fRadius : 0;
+        const offset = this.fOffset > 0 ? this.fOffset : 1;
+        return this.cFactory.handle({
+            type: this.fType,
+            payload: { source, sourceSide, target, targetSide, radius, offset }
+        });
+    }
+    getTransform(position) {
+        return `position: absolute; pointerEvents: all; transform: translate(-50%, -50%); left: ${position.x}px; top: ${position.y}px`;
+    }
+    redraw() {
+        this.fPath.setPath(this.path);
+        this.fSelection.setPath(this.path);
+        this.fGradient.redraw(this.line);
+        this.fDragHandle.redraw(this.penultimatePoint, this.line.point2);
+        this.fTextComponent.redraw(this.line);
+    }
+}
+FConnectionBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionBase, deps: [{ token: i0.ElementRef }, { token: i1.FConnectionFactory }], target: i0.ɵɵFactoryTarget.Directive });
+FConnectionBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FConnectionBase, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FConnectionFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection-base.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-connection/common/f-connection-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,MAAM,eAAe,CAAC;AACtD,OAAO,EAEG,cAAc,EAAE,eAAe,GACxC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAe/B,OAAO,EAGL,8BAA8B,EAC9B,+BAA+B,EAChC,MAAM,UAAU,CAAC;;;AAElB,MAAM,UAAU,GAAG,8BAA8B,CAC/C,+BAA+B,CAC7B;IACE,YACS,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IAEjC,CAAC;CACF,CAAC,CAAC,CAAC;AAGR,MAAM,OAAgB,eAAgB,SAAQ,UAAU;IAwDtD,YACE,gBAAyC,EACjC,QAA4B;QAEpC,KAAK,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;QAF9B,aAAQ,GAAR,QAAQ,CAAoB;QAtC/B,SAAI,GAAW,EAAE,CAAC;QAElB,SAAI,GAAU,cAAc,CAAC,UAAU,EAAE,CAAC;QAEjC,iBAAY,GAAkB,IAAI,OAAO,EAAQ,CAAC;QA8B1D,qBAAgB,GAAW,eAAe,CAAC,UAAU,EAAE,CAAC;IAOhE,CAAC;IAEM,UAAU;QACf,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;QACxB,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;QAC5B,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,OAAiC;;QACjD,OAAO,CAAC,MAAA,IAAI,CAAC,WAAW,CAAC,UAAU,0CAAE,SAAyB,CAAA,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnF,CAAC;IAEM,OAAO,CAAC,MAAc,EAAE,UAA6B,EAAE,MAAc,EAAE,UAA6B;;QACzG,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC,gBAAgB,IAAI,MAAM,CAAC;QAC9D,MAAA,MAAA,IAAI,CAAC,iBAAiB,0CAAE,aAAa,0CAAE,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC/G,CAAC;IAEO,aAAa,CAAC,MAAc,EAAE,UAA6B,EAAE,MAAc,EAAE,UAA6B;QAChH,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CACzB;YACE,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,OAAO,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE;SACpE,CACF,CAAC;IACJ,CAAC;IAEO,YAAY,CAAC,QAAgB;QACnC,OAAO,mFAAoF,QAAQ,CAAC,CAAE,YAAa,QAAQ,CAAC,CAAE,IAAI,CAAC;IACrI,CAAC;IAEM,MAAM;QACX,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;;6GAtGmB,eAAe;iGAAf,eAAe;4FAAf,eAAe;kBADpC,SAAS","sourcesContent":["import { Directive, ElementRef } from '@angular/core';\nimport {\n  IHasHostElement, ILine,\n  IPoint, LineExtensions, PointExtensions,\n} from '@foblex/core';\nimport { Subject } from 'rxjs';\nimport { EFConnectionBehavior } from './e-f-connection-behavior';\nimport { EFConnectionType } from './e-f-connection-type';\nimport { IHasConnectionColor } from './i-has-connection-color';\nimport { IHasConnectionFromTo } from './i-has-connection-from-to';\nimport { IHasConnectionText } from './i-has-connection-text';\nimport { IConnectionPath } from './f-path';\nimport { IConnectionGradient } from './f-gradient';\nimport { FConnectionDragHandleComponent } from './f-drag-handle';\nimport { FConnectionSelectionComponent } from './f-selection';\nimport { IConnectionText } from './f-connection-text';\nimport { IHasStateChanges } from '../../i-has-state-changes';\nimport { FMarkerBase } from '../f-marker';\nimport { EFConnectableSide } from '../../f-connectors';\nimport { FConnectionFactory } from '../f-connection-builder';\nimport {\n  ICanChangeConnectionVisibility,\n  ISelectable,\n  mixinChangeConnectionSelection,\n  mixinChangeConnectionVisibility\n} from './mixins';\n\nconst MIXIN_BASE = mixinChangeConnectionSelection(\n  mixinChangeConnectionVisibility(\n    class {\n      constructor(\n        public hostElement: HTMLElement\n      ) {\n      }\n    }));\n\n@Directive()\nexport abstract class FConnectionBase extends MIXIN_BASE\n  implements IHasHostElement, ISelectable,\n             ICanChangeConnectionVisibility,\n             IHasStateChanges, IHasConnectionColor,\n             IHasConnectionFromTo, IHasConnectionText {\n\n  public abstract override fId: string;\n\n  public abstract fStartColor: string;\n\n  public abstract fEndColor: string;\n\n  public abstract fOutputId: string;\n\n  public abstract fInputId: string;\n\n  public abstract fRadius: number;\n\n  public abstract fOffset: number;\n\n  public path: string = '';\n\n  public line: ILine = LineExtensions.initialize();\n\n  public readonly stateChanges: Subject<void> = new Subject<void>();\n\n  public abstract fDraggingDisabled: boolean;\n\n  public abstract override fSelectionDisabled: boolean;\n\n  public abstract boundingElement: HTMLElement | SVGElement;\n\n  public abstract fBehavior: EFConnectionBehavior;\n\n  public abstract fType: EFConnectionType;\n\n  public abstract fDefs: ElementRef<SVGDefsElement>;\n\n  public abstract fMarkers: FMarkerBase[];\n\n  public abstract fPath: IConnectionPath;\n\n  public abstract fGradient: IConnectionGradient;\n\n  public abstract fDragHandle: FConnectionDragHandleComponent;\n\n  public abstract fSelection: FConnectionSelectionComponent;\n\n  public abstract fTextComponent: IConnectionText;\n\n  public abstract fText: string;\n\n  public abstract fConnectionCenter: ElementRef<HTMLDivElement>;\n\n  private penultimatePoint: IPoint = PointExtensions.initialize();\n\n  protected constructor(\n    elementReference: ElementRef<HTMLElement>,\n    private cFactory: FConnectionFactory\n  ) {\n    super(elementReference.nativeElement);\n  }\n\n  public initialize(): void {\n    this.fPath.initialize();\n    this.fGradient.initialize();\n    this.redraw();\n  }\n\n  public isContains(element: HTMLElement | SVGElement): boolean {\n    return (this.hostElement.firstChild?.lastChild as HTMLElement).contains(element);\n  }\n\n  public setLine(source: IPoint, sourceSide: EFConnectableSide, target: IPoint, targetSide: EFConnectableSide): void {\n    this.line = LineExtensions.initialize(source, target);\n    const pathResult = this.getPathResult(source, sourceSide, target, targetSide);\n    this.path = pathResult.path;\n    this.penultimatePoint = pathResult.penultimatePoint || source;\n    this.fConnectionCenter?.nativeElement?.setAttribute('style', this.getTransform(pathResult.connectionCenter));\n  }\n\n  private getPathResult(source: IPoint, sourceSide: EFConnectableSide, target: IPoint, targetSide: EFConnectableSide): any {\n    const radius = this.fRadius > 0 ? this.fRadius : 0;\n    const offset = this.fOffset > 0 ? this.fOffset : 1;\n    return this.cFactory.handle(\n      {\n        type: this.fType,\n        payload: { source, sourceSide, target, targetSide, radius, offset }\n      }\n    );\n  }\n\n  private getTransform(position: IPoint): string {\n    return `position: absolute; pointerEvents: all; transform: translate(-50%, -50%); left: ${ position.x }px; top: ${ position.y }px`;\n  }\n\n  public redraw(): void {\n    this.fPath.setPath(this.path);\n    this.fSelection.setPath(this.path);\n    this.fGradient.redraw(this.line);\n    this.fDragHandle.redraw(this.penultimatePoint, this.line.point2);\n    this.fTextComponent.redraw(this.line);\n  }\n}\n"]}

package/esm2015/f-connection/common/f-connection-identifiers.js

@@ -0,0 +1,27 @@
+export const F_CONNECTION_IDENTIFIERS = {
+    textId(connectionId) {
+        return sanitizeElementId('connection_text_' + connectionId);
+    },
+    connectionForSelectionId(connectionId) {
+        return sanitizeElementId('connection_for_selection_' + connectionId);
+    },
+    connectionId(connectionId) {
+        return sanitizeElementId('connection_' + connectionId);
+    },
+    gradientId(connectionId) {
+        return sanitizeElementId('connection_gradient_' + connectionId);
+    },
+    linkToGradient(connectionId) {
+        return `url(#${F_CONNECTION_IDENTIFIERS.gradientId(connectionId)})`;
+    },
+    linkToConnection(connectionId) {
+        return `#${F_CONNECTION_IDENTIFIERS.connectionId(connectionId)}`;
+    }
+};
+function sanitizeElementId(id) {
+    if (!id.match(/^[a-zA-Z_]/)) {
+        id = '_' + id;
+    }
+    return id.replace(/[^a-zA-Z0-9_\-:.]/g, '_');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-connection/common/f-connection-text/f-connection-text-path.directive.js

@@ -0,0 +1,70 @@
+import { Directive, Inject } from '@angular/core';
+import { F_CONNECTION_IDENTIFIERS } from '../f-connection-identifiers';
+import { F_CONNECTION } from '../f-connection.injection-token';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/platform";
+export class FConnectionTextPathDirective {
+    constructor(elementReference, base, fBrowser) {
+        this.elementReference = elementReference;
+        this.base = base;
+        this.fBrowser = fBrowser;
+        this.symbolWidth = 8;
+        this.fontSize = '12px';
+    }
+    get linkToConnection() {
+        return F_CONNECTION_IDENTIFIERS.linkToConnection(this.base.fId + this.base.fOutputId + this.base.fInputId);
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    ngOnInit() {
+        this.hostElement.setAttribute('startOffset', '50%');
+        this.hostElement.setAttribute('text-anchor', `middle`);
+        this.symbolWidth = this.getSymbolWidth(this.base.fText || '');
+    }
+    getBBox() {
+        return this.hostElement.getBBox();
+    }
+    getFontStyles(element) {
+        const computedStyles = this.fBrowser.window.getComputedStyle(element);
+        return {
+            fontSize: computedStyles.fontSize,
+            fontFamily: computedStyles.fontFamily
+        };
+    }
+    getSymbolWidth(name) {
+        const text = name || 'connection';
+        const { fontFamily, fontSize } = this.getFontStyles(this.hostElement);
+        this.fontSize = fontSize;
+        const canvas = this.fBrowser.document.createElement('canvas');
+        let context;
+        try {
+            context = canvas.getContext('2d');
+        }
+        catch (e) {
+            context = null;
+        }
+        if (!context) {
+            return 0;
+        }
+        context.font = `${fontSize} ${fontFamily}`;
+        const metrics = context.measureText(text);
+        const symbolWidth = metrics.width / text.length;
+        return symbolWidth;
+    }
+}
+FConnectionTextPathDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionTextPathDirective, deps: [{ token: i0.ElementRef }, { token: F_CONNECTION }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
+FConnectionTextPathDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FConnectionTextPathDirective, selector: "textPath[f-connection-text-path]", host: { properties: { "attr.href": "linkToConnection" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionTextPathDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'textPath[f-connection-text-path]',
+                    host: {
+                        '[attr.href]': 'linkToConnection'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [F_CONNECTION]
+                }] }, { type: i1.BrowserService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-connection/common/f-connection-text/f-connection-text.component.js

@@ -0,0 +1,72 @@
+import { ChangeDetectionStrategy, Component, Inject, ViewChild } from "@angular/core";
+import { PointExtensions } from '@foblex/core';
+import { FConnectionTextPathDirective } from './f-connection-text-path.directive';
+import { F_CONNECTION_IDENTIFIERS } from '../f-connection-identifiers';
+import { F_CONNECTION } from '../f-connection.injection-token';
+import { CONNECTION_TEXT } from './i-connection-text';
+import * as i0 from "@angular/core";
+import * as i1 from "./f-connection-text-path.directive";
+export class FConnectionTextComponent {
+    constructor(elementReference, base) {
+        this.elementReference = elementReference;
+        this.base = base;
+    }
+    get textId() {
+        return F_CONNECTION_IDENTIFIERS.textId(this.base.fId + this.base.fOutputId + this.base.fInputId);
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    get text() {
+        return this.base.fText || '';
+    }
+    redraw(line) {
+        const isTextReverse = FConnectionTextComponent.isTextReverse(line);
+        const dyValue = this.calculateDy(this.textPathDirective.fontSize, isTextReverse);
+        this.hostElement.setAttribute('dy', dyValue);
+        const textRect = this.textPathDirective.getBBox();
+        const textRectCenter = [textRect.x + textRect.width / 2, textRect.y + textRect.height / 2];
+        this.hostElement.setAttribute('transform', isTextReverse ? `rotate(180, ${textRectCenter})` : '');
+        const startOffset = FConnectionTextComponent.getTextStartOffset(line, this.base.fText || '', this.textPathDirective.symbolWidth);
+        if (startOffset < 0) {
+            this.hostElement.style.display = 'none';
+        }
+        else {
+            this.hostElement.style.display = 'unset';
+        }
+    }
+    calculateDy(fontSize, isTextReverse) {
+        const fontSizeNumber = parseFloat(fontSize);
+        const dyValue = isTextReverse ? fontSizeNumber * 1.5 : fontSizeNumber * -0.8;
+        return dyValue.toString();
+    }
+    static isTextReverse(line) {
+        return line.point1.x > line.point2.x;
+    }
+    static getTextStartOffset(line, name, symbolWidth) {
+        const vectorLength = PointExtensions.hypotenuse(line.point1, line.point2);
+        return vectorLength / 2 - ((name || '').length * symbolWidth) / 2;
+    }
+}
+FConnectionTextComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionTextComponent, deps: [{ token: i0.ElementRef }, { token: F_CONNECTION }], target: i0.ɵɵFactoryTarget.Component });
+FConnectionTextComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FConnectionTextComponent, selector: "text[f-connection-text]", host: { properties: { "attr.id": "textId" }, classAttribute: "f-component f-connection-text" }, providers: [{ provide: CONNECTION_TEXT, useExisting: FConnectionTextComponent }], viewQueries: [{ propertyName: "textPathDirective", first: true, predicate: FConnectionTextPathDirective, descendants: true, static: true }], ngImport: i0, template: "<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n    <svg:textPath f-connection-text-path>\n        {{ text }}\n    </svg:textPath>\n</ng-container>\n", directives: [{ type: i1.FConnectionTextPathDirective, selector: "textPath[f-connection-text-path]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionTextComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "text[f-connection-text]",
+                    templateUrl: "./f-connection-text.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: "f-component f-connection-text",
+                        '[attr.id]': 'textId',
+                    },
+                    providers: [{ provide: CONNECTION_TEXT, useExisting: FConnectionTextComponent }],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [F_CONNECTION]
+                }] }]; }, propDecorators: { textPathDirective: [{
+                type: ViewChild,
+                args: [FConnectionTextPathDirective, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection-text.component.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-connection/common/f-connection-text/f-connection-text.component.ts","../../../../../../projects/f-flow/src/f-connection/common/f-connection-text/f-connection-text.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component, ElementRef, Inject, ViewChild\n} from \"@angular/core\";\nimport { ILine, PointExtensions } from '@foblex/core';\nimport { FConnectionTextPathDirective } from './f-connection-text-path.directive';\nimport { F_CONNECTION_IDENTIFIERS } from '../f-connection-identifiers';\nimport { IHasConnectionText } from '../i-has-connection-text';\nimport { IHasConnectionFromTo } from '../i-has-connection-from-to';\nimport { F_CONNECTION } from '../f-connection.injection-token';\nimport { CONNECTION_TEXT, IConnectionText } from './i-connection-text';\n\n@Component({\n  selector: \"text[f-connection-text]\",\n  templateUrl: \"./f-connection-text.component.html\",\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    class: \"f-component f-connection-text\",\n    '[attr.id]': 'textId',\n  },\n  providers: [ { provide: CONNECTION_TEXT, useExisting: FConnectionTextComponent } ],\n})\nexport class FConnectionTextComponent implements IConnectionText {\n\n  public get textId(): string {\n    return F_CONNECTION_IDENTIFIERS.textId(\n      this.base.fId + this.base.fOutputId + this.base.fInputId\n    );\n  }\n\n  public get hostElement(): SVGTextElement {\n    return this.elementReference.nativeElement;\n  }\n\n  public get text(): string {\n    return this.base.fText || '';\n  }\n\n  @ViewChild(FConnectionTextPathDirective, { static: true })\n  public textPathDirective!: FConnectionTextPathDirective;\n\n  constructor(\n      private elementReference: ElementRef<SVGTextElement>,\n      @Inject(F_CONNECTION) private base: IHasConnectionText & IHasConnectionFromTo,\n  ) {\n  }\n\n  public redraw(line: ILine): void {\n\n    const isTextReverse: boolean = FConnectionTextComponent.isTextReverse(line);\n    const dyValue = this.calculateDy(this.textPathDirective.fontSize, isTextReverse);\n\n    this.hostElement.setAttribute('dy', dyValue);\n\n    const textRect = this.textPathDirective.getBBox();\n    const textRectCenter = [ textRect.x + textRect.width / 2, textRect.y + textRect.height / 2 ];\n    this.hostElement.setAttribute('transform', isTextReverse ? `rotate(180, ${ textRectCenter })` : '');\n    const startOffset = FConnectionTextComponent.getTextStartOffset(line, this.base.fText || '', this.textPathDirective.symbolWidth);\n    if (startOffset < 0) {\n\n      this.hostElement.style.display = 'none';\n    } else {\n\n      this.hostElement.style.display = 'unset';\n    }\n  }\n\n  private calculateDy(fontSize: string, isTextReverse: boolean): string {\n    const fontSizeNumber = parseFloat(fontSize);\n\n    const dyValue = isTextReverse ? fontSizeNumber * 1.5 : fontSizeNumber * -0.8;\n\n    return dyValue.toString();\n  }\n\n  private static isTextReverse(line: ILine): boolean {\n    return line.point1.x > line.point2.x;\n  }\n\n  private static getTextStartOffset(line: ILine, name: string, symbolWidth: number): number {\n    const vectorLength: number = PointExtensions.hypotenuse(line.point1, line.point2);\n    return vectorLength / 2 - ((name || '').length * symbolWidth) / 2;\n  }\n}\n\n","<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n    <svg:textPath f-connection-text-path>\n        {{ text }}\n    </svg:textPath>\n</ng-container>\n"]}

package/esm2015/f-connection/common/f-drag-handle/f-connection-drag-handle.component.js

@@ -0,0 +1,38 @@
+import { ChangeDetectionStrategy, Component } from "@angular/core";
+import * as i0 from "@angular/core";
+export const F_CONNECTION_DRAG_HANDLE_CLASS = 'f-connection-drag-handle';
+export class FConnectionDragHandleComponent {
+    constructor(elementReference) {
+        this.elementReference = elementReference;
+        this.class = F_CONNECTION_DRAG_HANDLE_CLASS;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    redraw(penultimatePoint, endPoint) {
+        const point = this.calculateCircleCenter(penultimatePoint, endPoint, 8);
+        this.hostElement.setAttribute('cx', point.x.toString());
+        this.hostElement.setAttribute('cy', point.y.toString());
+    }
+    calculateCircleCenter(start, end, radius) {
+        const direction = { x: end.x - start.x, y: end.y - start.y };
+        const length = Math.sqrt(direction.x * direction.x + direction.y * direction.y) || 1;
+        const unitDirection = { x: direction.x / length, y: direction.y / length };
+        const scaledDirection = { x: unitDirection.x * radius, y: unitDirection.y * radius };
+        return { x: end.x - scaledDirection.x, y: end.y - scaledDirection.y };
+    }
+}
+FConnectionDragHandleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionDragHandleComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+FConnectionDragHandleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]", host: { properties: { "class": "class" } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionDragHandleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "circle[f-connection-drag-handle]",
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[class]': 'class'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-connection/common/f-gradient/f-connection-gradient.component.js

@@ -0,0 +1,69 @@
+import { ChangeDetectionStrategy, Component, Inject } from "@angular/core";
+import { Point } from '@foblex/core';
+import { F_CONNECTION_IDENTIFIERS } from '../f-connection-identifiers';
+import { F_CONNECTION } from '../f-connection.injection-token';
+import { CONNECTION_GRADIENT } from './i-connection-gradient';
+import * as i0 from "@angular/core";
+export class FConnectionGradientComponent {
+    constructor(elementReference, base) {
+        this.elementReference = elementReference;
+        this.base = base;
+    }
+    get gradientId() {
+        return F_CONNECTION_IDENTIFIERS.gradientId(this.base.fId + this.base.fOutputId + this.base.fInputId);
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    get stop1Element() {
+        return this.elementReference.nativeElement.children.item(0);
+    }
+    get stop2Element() {
+        return this.elementReference.nativeElement.children.item(1);
+    }
+    initialize() {
+        this.stop1Element.setAttribute('offset', '0%');
+        this.stop2Element.setAttribute('offset', '100%');
+    }
+    updateGradient() {
+        this.setFromColor(this.base.fStartColor);
+        this.setToColor(this.base.fEndColor);
+    }
+    setFromColor(color) {
+        this.stop1Element.setAttribute('stop-color', color || 'transparent');
+    }
+    setToColor(color) {
+        this.stop2Element.setAttribute('stop-color', color || 'transparent');
+    }
+    redraw(line) {
+        const x = line.point2.x - line.point1.x;
+        const y = line.point2.y - line.point1.y;
+        const distance = Math.sqrt(x * x + y * y) || 0.01;
+        const from = new Point(0.5 - (0.5 * x) / distance, 0.5 - (0.5 * y) / distance);
+        this.hostElement.setAttribute('x1', from.x.toString());
+        this.hostElement.setAttribute('y1', from.y.toString());
+        const to = new Point(0.5 + (0.5 * x) / distance, 0.5 + (0.5 * y) / distance);
+        this.hostElement.setAttribute('x2', to.x.toString());
+        this.hostElement.setAttribute('y2', to.y.toString());
+        this.updateGradient();
+    }
+}
+FConnectionGradientComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionGradientComponent, deps: [{ token: i0.ElementRef }, { token: F_CONNECTION }], target: i0.ɵɵFactoryTarget.Component });
+FConnectionGradientComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]", host: { properties: { "attr.id": "gradientId" }, classAttribute: "f-component f-connection-gradient" }, providers: [{ provide: CONNECTION_GRADIENT, useExisting: FConnectionGradientComponent }], ngImport: i0, template: "<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n    <svg:stop/>\n    <svg:stop/>\n</ng-container>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FConnectionGradientComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "linearGradient[fConnectionGradient]",
+                    templateUrl: "./f-connection-gradient.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: "f-component f-connection-gradient",
+                        '[attr.id]': 'gradientId'
+                    },
+                    providers: [{ provide: CONNECTION_GRADIENT, useExisting: FConnectionGradientComponent }],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [F_CONNECTION]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection-gradient.component.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-connection/common/f-gradient/f-connection-gradient.component.ts","../../../../../../projects/f-flow/src/f-connection/common/f-gradient/f-connection-gradient.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, ElementRef, Inject } from \"@angular/core\";\nimport { ILine, Point } from '@foblex/core';\nimport { F_CONNECTION_IDENTIFIERS } from '../f-connection-identifiers';\nimport { IHasConnectionFromTo } from '../i-has-connection-from-to';\nimport { IHasConnectionColor } from '../i-has-connection-color';\nimport { F_CONNECTION } from '../f-connection.injection-token';\nimport { CONNECTION_GRADIENT, IConnectionGradient } from './i-connection-gradient';\n\n@Component({\n  selector: \"linearGradient[fConnectionGradient]\",\n  templateUrl: \"./f-connection-gradient.component.html\",\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    class: \"f-component f-connection-gradient\",\n    '[attr.id]': 'gradientId'\n  },\n  providers: [ { provide: CONNECTION_GRADIENT, useExisting: FConnectionGradientComponent } ],\n})\nexport class FConnectionGradientComponent implements IConnectionGradient {\n\n  public get gradientId(): string {\n    return F_CONNECTION_IDENTIFIERS.gradientId(\n      this.base.fId + this.base.fOutputId + this.base.fInputId\n    );\n  }\n\n  public get hostElement(): SVGLinearGradientElement {\n    return this.elementReference.nativeElement;\n  }\n\n  public get stop1Element(): SVGStopElement {\n    return this.elementReference.nativeElement.children.item(0) as SVGStopElement;\n  }\n\n  public get stop2Element(): SVGStopElement {\n    return this.elementReference.nativeElement.children.item(1) as SVGStopElement;\n  }\n\n  constructor(\n    private elementReference: ElementRef<SVGLinearGradientElement>,\n    @Inject(F_CONNECTION) private base: IHasConnectionColor & IHasConnectionFromTo,\n  ) {\n  }\n\n  public initialize(): void {\n    this.stop1Element.setAttribute('offset', '0%');\n    this.stop2Element.setAttribute('offset', '100%');\n  }\n\n  private updateGradient(): void {\n    this.setFromColor(this.base.fStartColor);\n    this.setToColor(this.base.fEndColor);\n  }\n\n  private setFromColor(color: string | undefined): void {\n    this.stop1Element.setAttribute('stop-color', color || 'transparent');\n  }\n\n  private setToColor(color: string | undefined): void {\n    this.stop2Element.setAttribute('stop-color', color || 'transparent');\n  }\n\n  public redraw(line: ILine): void {\n    const x: number = line.point2.x - line.point1.x;\n    const y: number = line.point2.y - line.point1.y;\n    const distance: number = Math.sqrt(x * x + y * y) || 0.01;\n\n    const from = new Point(0.5 - (0.5 * x) / distance, 0.5 - (0.5 * y) / distance);\n\n    this.hostElement.setAttribute('x1', from.x.toString());\n    this.hostElement.setAttribute('y1', from.y.toString());\n\n    const to = new Point(0.5 + (0.5 * x) / distance, 0.5 + (0.5 * y) / distance);\n    this.hostElement.setAttribute('x2', to.x.toString());\n    this.hostElement.setAttribute('y2', to.y.toString());\n    this.updateGradient();\n  }\n}\n\n","<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n    <svg:stop/>\n    <svg:stop/>\n</ng-container>\n"]}