@foblex/flow 1.2.2 → 1.2.3

package/esm2022/f-connection/common/path-constructor/segment-path/segment-path.mjs

@@ -0,0 +1,123 @@
+import { CONNECTOR_SIDE_POINT } from './connector-side-point';
+import { PointUtils } from './point-utils';
+import { EdgeCenterCalculator } from './edge-center-calculator';
+import { PathBend } from './path-bend';
+export class SegmentPath {
+    handle(from, fromSide, to, toSide, borderRadius = 8, offset = 32) {
+        const [points, labelX, labelY, offsetX, offsetY] = SegmentPath.getPoints(from, fromSide, to, toSide, { x: undefined, y: undefined }, offset);
+        const path = SegmentPath.buildPath(points, borderRadius);
+        return { path, labelX, labelY, offsetX, offsetY };
+    }
+    static getPoints(source, sourcePosition, target, targetPosition, center, offset) {
+        const sourceDir = CONNECTOR_SIDE_POINT[sourcePosition];
+        const targetDir = CONNECTOR_SIDE_POINT[targetPosition];
+        const sourceGapped = { x: source.x + sourceDir.x * offset, y: source.y + sourceDir.y * offset };
+        const targetGapped = { x: target.x + targetDir.x * offset, y: target.y + targetDir.y * offset };
+        const dir = PointUtils.getDirection(sourceGapped, sourcePosition, targetGapped);
+        const dirAccessor = dir.x !== 0 ? 'x' : 'y';
+        const currDir = dir[dirAccessor];
+        let points = [];
+        let centerX, centerY;
+        const sourceGapOffset = { x: 0, y: 0 };
+        const targetGapOffset = { x: 0, y: 0 };
+        const [defaultCenterX, defaultCenterY, defaultOffsetX, defaultOffsetY] = EdgeCenterCalculator.getEdgeCenter(source.x, source.y, target.x, target.y);
+        if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {
+            centerX = center.x || defaultCenterX;
+            centerY = center.y || defaultCenterY;
+            const verticalSplit = [
+                { x: centerX, y: sourceGapped.y },
+                { x: centerX, y: targetGapped.y },
+            ];
+            const horizontalSplit = [
+                { x: sourceGapped.x, y: centerY },
+                { x: targetGapped.x, y: centerY },
+            ];
+            if (sourceDir[dirAccessor] === currDir) {
+                points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;
+            }
+            else {
+                points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;
+            }
+        }
+        else {
+            const sourceTarget = [{ x: sourceGapped.x, y: targetGapped.y }];
+            const targetSource = [{ x: targetGapped.x, y: sourceGapped.y }];
+            if (dirAccessor === 'x') {
+                points = sourceDir.x === currDir ? targetSource : sourceTarget;
+            }
+            else {
+                points = sourceDir.y === currDir ? sourceTarget : targetSource;
+            }
+            if (sourcePosition === targetPosition) {
+                const diff = Math.abs(source[dirAccessor] - target[dirAccessor]);
+                if (diff <= offset) {
+                    const gapOffset = Math.min(offset - 1, offset - diff);
+                    if (sourceDir[dirAccessor] === currDir) {
+                        sourceGapOffset[dirAccessor] = (sourceGapped[dirAccessor] > source[dirAccessor] ? -1 : 1) * gapOffset;
+                    }
+                    else {
+                        targetGapOffset[dirAccessor] = (targetGapped[dirAccessor] > target[dirAccessor] ? -1 : 1) * gapOffset;
+                    }
+                }
+            }
+            if (sourcePosition !== targetPosition) {
+                const dirAccessorOpposite = dirAccessor === 'x' ? 'y' : 'x';
+                const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessorOpposite];
+                const sourceGtTargetOppo = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];
+                const sourceLtTargetOppo = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];
+                const flipSourceTarget = (sourceDir[dirAccessor] === 1 &&
+                    ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||
+                    (sourceDir[dirAccessor] !== 1 &&
+                        ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));
+                if (flipSourceTarget) {
+                    points = dirAccessor === 'x' ? sourceTarget : targetSource;
+                }
+            }
+            const sourceGapPoint = { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y };
+            const targetGapPoint = { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y };
+            const maxXDistance = Math.max(Math.abs(sourceGapPoint.x - points[0].x), Math.abs(targetGapPoint.x - points[0].x));
+            const maxYDistance = Math.max(Math.abs(sourceGapPoint.y - points[0].y), Math.abs(targetGapPoint.y - points[0].y));
+            if (maxXDistance >= maxYDistance) {
+                centerX = (sourceGapPoint.x + targetGapPoint.x) / 2;
+                centerY = points[0].y;
+            }
+            else {
+                centerX = points[0].x;
+                centerY = (sourceGapPoint.y + targetGapPoint.y) / 2;
+            }
+        }
+        const pathPoints = [
+            source,
+            { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y },
+            ...points,
+            { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y },
+            target,
+        ];
+        return [pathPoints, centerX, centerY, defaultOffsetX, defaultOffsetY];
+    }
+    static 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 = PathBend.getBend(points[i - 1], p, points[i + 1], borderRadius);
+            }
+            else if (i === points.length - 1) {
+                segment = SegmentPath.buildLastLineSegment(i, p);
+            }
+            else {
+                segment = SegmentPath.buildMoveOrLineSegment(i, p);
+            }
+            path += segment;
+        }
+        return path;
+    }
+    static buildMoveOrLineSegment(index, point) {
+        return `${index === 0 ? 'M' : 'L'}${point.x} ${point.y}`;
+    }
+    static buildLastLineSegment(index, point) {
+        return `L${point.x + 0.0001} ${point.y + 0.0001}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"segment-path.js","sourceRoot":"","sources":["../../../../../../../projects/f-flow/src/f-connection/common/path-constructor/segment-path/segment-path.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint } from '@foblex/core';\nimport { CONNECTOR_SIDE_POINT } from './connector-side-point';\nimport { PointUtils } from './point-utils';\nimport { EdgeCenterCalculator } from './edge-center-calculator';\nimport { PathBend } from './path-bend';\nimport { IPathConstructor, IPathConstructorResult } from '../i-path-constructor';\nimport { EConnectorSide } from '../../../../domain';\n\nexport class SegmentPath implements IPathConstructor {\n\n  public handle(from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide, borderRadius: number = 8, offset = 32): IPathConstructorResult {\n    const [ points, labelX, labelY, offsetX, offsetY ] = SegmentPath.getPoints(\n        from,\n        fromSide,\n        to,\n        toSide,\n        { x: undefined, y: undefined },\n        offset\n    );\n\n    const path = SegmentPath.buildPath(points, borderRadius);\n\n    return { path, labelX, labelY, offsetX, offsetY };\n  }\n\n  public static getPoints(\n      source: IPoint,\n      sourcePosition: EConnectorSide,\n      target: IPoint,\n      targetPosition: EConnectorSide,\n      center: Partial<IPoint>,\n      offset: number\n  ): [ IPoint[], number, number, number, number ] {\n    const sourceDir = CONNECTOR_SIDE_POINT[ sourcePosition ];\n    const targetDir = CONNECTOR_SIDE_POINT[ targetPosition ];\n    const sourceGapped: IPoint = { x: source.x + sourceDir.x * offset, y: source.y + sourceDir.y * offset };\n    const targetGapped: IPoint = { x: target.x + targetDir.x * offset, y: target.y + targetDir.y * offset };\n    const dir = PointUtils.getDirection(sourceGapped, sourcePosition, targetGapped);\n    const dirAccessor = dir.x !== 0 ? 'x' : 'y';\n    const currDir = dir[ dirAccessor ];\n\n    let points: IPoint[] = [];\n    let centerX, centerY;\n    const sourceGapOffset = { x: 0, y: 0 };\n    const targetGapOffset = { x: 0, y: 0 };\n\n    const [ defaultCenterX, defaultCenterY, defaultOffsetX, defaultOffsetY ] = EdgeCenterCalculator.getEdgeCenter(\n        source.x,\n        source.y,\n        target.x,\n        target.y\n    );\n\n    if (sourceDir[ dirAccessor ] * targetDir[ dirAccessor ] === -1) {\n      centerX = center.x || defaultCenterX;\n      centerY = center.y || defaultCenterY;\n      const verticalSplit: IPoint[] = [\n        { x: centerX, y: sourceGapped.y },\n        { x: centerX, y: targetGapped.y },\n      ];\n      const horizontalSplit: IPoint[] = [\n        { x: sourceGapped.x, y: centerY },\n        { x: targetGapped.x, y: centerY },\n      ];\n\n      if (sourceDir[ dirAccessor ] === currDir) {\n        points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;\n      } else {\n        points = dirAccessor === 'x' ? horizontalSplit : verticalSplit;\n      }\n    } else {\n      const sourceTarget: IPoint[] = [ { x: sourceGapped.x, y: targetGapped.y } ];\n      const targetSource: IPoint[] = [ { x: targetGapped.x, y: sourceGapped.y } ];\n\n      if (dirAccessor === 'x') {\n        points = sourceDir.x === currDir ? targetSource : sourceTarget;\n      } else {\n        points = sourceDir.y === currDir ? sourceTarget : targetSource;\n      }\n\n      if (sourcePosition === targetPosition) {\n        const diff = Math.abs(source[ dirAccessor ] - target[ dirAccessor ]);\n\n        if (diff <= offset) {\n          const gapOffset = Math.min(offset - 1, offset - diff);\n          if (sourceDir[ dirAccessor ] === currDir) {\n            sourceGapOffset[ dirAccessor ] = (sourceGapped[ dirAccessor ] > source[ dirAccessor ] ? -1 : 1) * gapOffset;\n          } else {\n            targetGapOffset[ dirAccessor ] = (targetGapped[ dirAccessor ] > target[ dirAccessor ] ? -1 : 1) * gapOffset;\n          }\n        }\n      }\n\n      if (sourcePosition !== targetPosition) {\n        const dirAccessorOpposite = dirAccessor === 'x' ? 'y' : 'x';\n        const isSameDir = sourceDir[ dirAccessor ] === targetDir[ dirAccessorOpposite ];\n        const sourceGtTargetOppo = sourceGapped[ dirAccessorOpposite ] > targetGapped[ dirAccessorOpposite ];\n        const sourceLtTargetOppo = sourceGapped[ dirAccessorOpposite ] < targetGapped[ dirAccessorOpposite ];\n        const flipSourceTarget =\n            (sourceDir[ dirAccessor ] === 1 &&\n                ((!isSameDir && sourceGtTargetOppo) || (isSameDir && sourceLtTargetOppo))) ||\n            (sourceDir[ dirAccessor ] !== 1 &&\n                ((!isSameDir && sourceLtTargetOppo) || (isSameDir && sourceGtTargetOppo)));\n\n        if (flipSourceTarget) {\n          points = dirAccessor === 'x' ? sourceTarget : targetSource;\n        }\n      }\n\n      const sourceGapPoint = { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y };\n      const targetGapPoint = { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y };\n      const maxXDistance = Math.max(\n          Math.abs(sourceGapPoint.x - points[ 0 ].x),\n          Math.abs(targetGapPoint.x - points[ 0 ].x)\n      );\n      const maxYDistance = Math.max(\n          Math.abs(sourceGapPoint.y - points[ 0 ].y),\n          Math.abs(targetGapPoint.y - points[ 0 ].y)\n      );\n\n      if (maxXDistance >= maxYDistance) {\n        centerX = (sourceGapPoint.x + targetGapPoint.x) / 2;\n        centerY = points[ 0 ].y;\n      } else {\n        centerX = points[ 0 ].x;\n        centerY = (sourceGapPoint.y + targetGapPoint.y) / 2;\n      }\n    }\n\n    const pathPoints = [\n      source,\n      { x: sourceGapped.x + sourceGapOffset.x, y: sourceGapped.y + sourceGapOffset.y },\n      ...points,\n      { x: targetGapped.x + targetGapOffset.x, y: targetGapped.y + targetGapOffset.y },\n      target,\n    ];\n\n    return [ pathPoints, centerX, centerY, defaultOffsetX, defaultOffsetY ];\n  }\n\n  private static 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 = PathBend.getBend(points[ i - 1 ], p, points[ i + 1 ], borderRadius);\n      } else if (i === points.length - 1) {\n        segment = SegmentPath.buildLastLineSegment(i, p);\n      } else {\n        segment = SegmentPath.buildMoveOrLineSegment(i, p);\n      }\n      path += segment;\n    }\n\n    return path;\n  }\n\n  private static buildMoveOrLineSegment(index: number, point: IPoint): string {\n    return `${ index === 0 ? 'M' : 'L' }${ point.x } ${ point.y }`;\n  }\n\n\n  private static buildLastLineSegment(index: number, point: IPoint): string {\n    return `L${ point.x + 0.0001 } ${ point.y + 0.0001 }`;\n  }\n}\n"]}

package/esm2022/f-connection/common/path-constructor/straight-path/index.mjs

@@ -0,0 +1,2 @@
+export * from './straight-path';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi9jb21tb24vcGF0aC1jb25zdHJ1Y3Rvci9zdHJhaWdodC1wYXRoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N0cmFpZ2h0LXBhdGgnO1xuIl19

package/esm2022/f-connection/common/path-constructor/straight-path/straight-path.mjs

@@ -0,0 +1,9 @@
+import { EdgeCenterCalculator } from '../segment-path';
+export class StraightPath {
+    handle(from, fromSide, to, toSide, borderRadius = 8, offset = 32) {
+        const [labelX, labelY, offsetX, offsetY] = EdgeCenterCalculator.getEdgeCenter(from.x, from.y, to.x, to.y);
+        const path = `M ${from.x} ${from.y} L ${to.x + 0.0001} ${to.y + 0.0001}`;
+        return { path, labelX, labelY, offsetX, offsetY };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection/f-connection/f-connection.component.mjs

@@ -0,0 +1,96 @@
+import { ChangeDetectionStrategy, Component, Input, ViewChild } from "@angular/core";
+import { castToConnectionBehavior, castToConnectionType, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, FConnectionBase, FConnectionDragHandleComponent, FConnectionSelectionComponent, } from '../common';
+import { EConnectionBehavior } from '../common';
+import { EConnectionType } from '../common';
+import { F_CONNECTION } from '../common/f-connection.injection-token';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-components-store";
+import * as i2 from "../common/f-drag-handle/f-connection-drag-handle.component";
+import * as i3 from "../common/f-gradient/f-connection-gradient.component";
+import * as i4 from "../common/f-path/f-connection-path.component";
+import * as i5 from "../common/f-connection-text/f-connection-text.component";
+import * as i6 from "../common/f-selection/f-connection-selection.component";
+let uniqueId = 0;
+export class FConnectionComponent extends FConnectionBase {
+    set behavior(value) {
+        this._behavior = castToConnectionBehavior(value);
+    }
+    get behavior() {
+        return this._behavior;
+    }
+    set type(value) {
+        this._type = castToConnectionType(value);
+    }
+    get type() {
+        return this._type;
+    }
+    get boundingElement() {
+        return this.fPath.hostElement;
+    }
+    constructor(elementReference, fComponentsStore) {
+        super(elementReference);
+        this.fComponentsStore = fComponentsStore;
+        this.id = `f-connection-${uniqueId++}`;
+        this.text = '';
+        this.startColor = 'black';
+        this.endColor = 'black';
+        this._behavior = EConnectionBehavior.FIXED;
+        this._type = EConnectionType.STRAIGHT;
+        this.disabled = false;
+    }
+    ngOnInit() {
+        this.fComponentsStore.addConnection(this);
+    }
+    ngOnDestroy() {
+        this.fComponentsStore.removeConnection(this);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FConnectionComponent, deps: [{ token: i0.ElementRef }, { token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.5", type: FConnectionComponent, selector: "f-connection", inputs: { id: "id", text: "text", startColor: "startColor", endColor: "endColor", outputId: "outputId", inputId: "inputId", behavior: "behavior", type: "type", disabled: "disabled" }, host: { properties: { "attr.id": "id" }, classAttribute: "f-component f-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionComponent }], 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: "fText", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fLabel", first: true, predicate: ["rect"], descendants: true, static: true }], 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<!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n\n</svg>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i2.FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: i3.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i4.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i5.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i6.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FConnectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "f-connection", changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '[attr.id]': 'id',
+                        class: "f-component f-connection"
+                    }, 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<!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n\n</svg>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FComponentsStore }]; }, propDecorators: { id: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], startColor: [{
+                type: Input
+            }], endColor: [{
+                type: Input
+            }], outputId: [{
+                type: Input
+            }], inputId: [{
+                type: Input
+            }], behavior: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], fDefs: [{
+                type: ViewChild,
+                args: ['defs', { static: true }]
+            }], fPath: [{
+                type: ViewChild,
+                args: [CONNECTION_PATH, { static: true }]
+            }], fGradient: [{
+                type: ViewChild,
+                args: [CONNECTION_GRADIENT, { static: true }]
+            }], fDragHandle: [{
+                type: ViewChild,
+                args: [FConnectionDragHandleComponent, { static: true }]
+            }], fSelection: [{
+                type: ViewChild,
+                args: [FConnectionSelectionComponent, { static: true }]
+            }], fText: [{
+                type: ViewChild,
+                args: [CONNECTION_TEXT, { static: true }]
+            }], fLabel: [{
+                type: ViewChild,
+                args: ['rect', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection.component.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-connection/f-connection/f-connection.component.ts","../../../../../projects/f-flow/src/f-connection/f-connection/f-connection.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild\n} from \"@angular/core\";\nimport {\n  castToConnectionBehavior, castToConnectionType,\n  CONNECTION_GRADIENT,\n  CONNECTION_PATH,\n  CONNECTION_TEXT,\n  FConnectionBase,\n  FConnectionDragHandleComponent,\n  FConnectionSelectionComponent,\n  IConnectionGradient,\n  IConnectionPath, IConnectionText,\n} from '../common';\nimport { EConnectionBehavior } from '../common';\nimport { EConnectionType } from '../common';\nimport { F_CONNECTION } from '../common/f-connection.injection-token';\nimport { FComponentsStore } from '../../f-components-store';\n\nlet uniqueId: number = 0;\n\n@Component({\n  selector: \"f-connection\",\n  templateUrl: \"./f-connection.component.html\",\n  styleUrls: [ \"./f-connection.component.scss\" ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[attr.id]': 'id',\n    class: \"f-component f-connection\"\n  },\n  providers: [ { provide: F_CONNECTION, useExisting: FConnectionComponent } ],\n})\nexport class FConnectionComponent extends FConnectionBase implements OnInit, OnDestroy {\n\n  @Input()\n  public override id: string = `f-connection-${ uniqueId++ }`;\n\n  @Input()\n  public override text: string = '';\n\n  @Input()\n  public override startColor: string = 'black';\n\n  @Input()\n  public override endColor: string = 'black';\n\n  @Input()\n  public override outputId: any;\n\n  @Input()\n  public override inputId: any;\n\n  @Input()\n  public override set behavior(value: 'fixed' | 'floating') {\n    this._behavior = castToConnectionBehavior(value);\n  }\n\n  public override get behavior(): EConnectionBehavior {\n    return this._behavior;\n  }\n\n  private _behavior: EConnectionBehavior = EConnectionBehavior.FIXED;\n\n\n  @Input()\n  public override set type(value: 'segment' | 'straight' | 'bezier') {\n    this._type = castToConnectionType(value);\n  }\n\n  public override get type(): EConnectionType {\n    return this._type;\n  }\n\n  private _type: EConnectionType = EConnectionType.STRAIGHT;\n\n  @Input()\n  public override disabled: boolean = false;\n\n  @ViewChild('defs', { static: true })\n  public override fDefs!: ElementRef<SVGDefsElement>;\n\n  @ViewChild(CONNECTION_PATH, { static: true })\n  public override fPath!: IConnectionPath;\n\n  @ViewChild(CONNECTION_GRADIENT, { static: true })\n  public override fGradient!: IConnectionGradient;\n\n  @ViewChild(FConnectionDragHandleComponent, { static: true })\n  public override fDragHandle!: FConnectionDragHandleComponent;\n\n  @ViewChild(FConnectionSelectionComponent, { static: true })\n  public override fSelection!: FConnectionSelectionComponent;\n\n  @ViewChild(CONNECTION_TEXT, { static: true })\n  public override fText!: IConnectionText;\n\n  @ViewChild('rect', { static: true })\n  public override fLabel!: ElementRef<SVGRectElement>;\n\n  public override get boundingElement(): HTMLElement | SVGElement {\n    return this.fPath.hostElement;\n  }\n\n  constructor(\n      elementReference: ElementRef<HTMLElement>,\n      private fComponentsStore: FComponentsStore\n  ) {\n    super(elementReference);\n  }\n\n  public ngOnInit(): void {\n    this.fComponentsStore.addConnection(this);\n  }\n\n  public ngOnDestroy(): void {\n    this.fComponentsStore.removeConnection(this);\n  }\n}\n","<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<!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n\n</svg>\n"]}

package/esm2022/f-connection/f-connection/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-connection.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi9mLWNvbm5lY3Rpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZi1jb25uZWN0aW9uLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/f-connection/f-connection-for-create/f-connection-for-create.component.mjs

@@ -0,0 +1,90 @@
+import { ChangeDetectionStrategy, Component, Input, ViewChild } from "@angular/core";
+import { castToConnectionBehavior, castToConnectionType, CONNECTION_GRADIENT, CONNECTION_PATH, CONNECTION_TEXT, FConnectionBase, FConnectionDragHandleComponent, FConnectionSelectionComponent, } from '../common';
+import { EConnectionBehavior } from '../common';
+import { EConnectionType } from '../common';
+import { F_CONNECTION } from '../common/f-connection.injection-token';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-components-store";
+import * as i2 from "../common/f-drag-handle/f-connection-drag-handle.component";
+import * as i3 from "../common/f-gradient/f-connection-gradient.component";
+import * as i4 from "../common/f-path/f-connection-path.component";
+import * as i5 from "../common/f-connection-text/f-connection-text.component";
+import * as i6 from "../common/f-selection/f-connection-selection.component";
+let uniqueId = 0;
+export class FConnectionForCreateComponent extends FConnectionBase {
+    set behavior(value) {
+        this._behavior = castToConnectionBehavior(value);
+    }
+    get behavior() {
+        return this._behavior;
+    }
+    set type(value) {
+        this._type = castToConnectionType(value);
+    }
+    get type() {
+        return this._type;
+    }
+    get boundingElement() {
+        return this.fPath.hostElement;
+    }
+    constructor(elementReference, fComponentsStore) {
+        super(elementReference);
+        this.fComponentsStore = fComponentsStore;
+        this.id = `f-connection-for-create-${uniqueId++}`;
+        this.text = '';
+        this.startColor = 'black';
+        this.endColor = 'black';
+        this._behavior = EConnectionBehavior.FIXED;
+        this._type = EConnectionType.STRAIGHT;
+        this.disabled = false;
+    }
+    ngOnInit() {
+        this.fComponentsStore.fTempConnection = this;
+    }
+    ngAfterViewInit() {
+        this.hide();
+    }
+    ngOnDestroy() {
+        this.fComponentsStore.fTempConnection = undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FConnectionForCreateComponent, deps: [{ token: i0.ElementRef }, { token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.5", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { startColor: "startColor", endColor: "endColor", behavior: "behavior", type: "type", disabled: "disabled" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], 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: "fText", first: true, predicate: CONNECTION_TEXT, descendants: true, static: true }, { propertyName: "fLabel", first: true, predicate: ["rect"], descendants: true, static: 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            <!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n</svg>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i2.FConnectionDragHandleComponent, selector: "circle[f-connection-drag-handle]" }, { kind: "component", type: i3.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i4.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i5.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i6.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", 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            <!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n</svg>\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FComponentsStore }]; }, propDecorators: { startColor: [{
+                type: Input
+            }], endColor: [{
+                type: Input
+            }], behavior: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], fDefs: [{
+                type: ViewChild,
+                args: ['defs', { static: true }]
+            }], fPath: [{
+                type: ViewChild,
+                args: [CONNECTION_PATH, { static: true }]
+            }], fGradient: [{
+                type: ViewChild,
+                args: [CONNECTION_GRADIENT, { static: true }]
+            }], fDragHandle: [{
+                type: ViewChild,
+                args: [FConnectionDragHandleComponent, { static: true }]
+            }], fSelection: [{
+                type: ViewChild,
+                args: [FConnectionSelectionComponent, { static: true }]
+            }], fText: [{
+                type: ViewChild,
+                args: [CONNECTION_TEXT, { static: true }]
+            }], fLabel: [{
+                type: ViewChild,
+                args: ['rect', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection-for-create.component.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-connection/f-connection-for-create/f-connection-for-create.component.ts","../../../../../projects/f-flow/src/f-connection/f-connection-for-create/f-connection-for-create.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EACvB,SAAS,EAAc,KAAK,EAAqB,SAAS,EAC3D,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,wBAAwB,EAAE,oBAAoB,EAAE,mBAAmB,EACnE,eAAe,EAAE,eAAe,EAChC,eAAe,EAAE,8BAA8B,EAAE,6BAA6B,GAE/E,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;;;;;;;;AAGtE,IAAI,QAAQ,GAAW,CAAC,CAAC;AAYzB,MAAM,OAAO,6BACT,SAAQ,eAAe;IAgBzB,IACoB,QAAQ,CAAC,KAA2B;QACtD,IAAI,CAAC,SAAS,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;IAED,IAAoB,QAAQ;QAC1B,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAID,IACoB,IAAI,CAAC,KAAwC;QAC/D,IAAI,CAAC,KAAK,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,IAAoB,IAAI;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IA4BD,IAAoB,eAAe;QACjC,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;IAChC,CAAC;IAED,YACI,gBAAyC,EACjC,gBAAkC;QAE5C,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAFd,qBAAgB,GAAhB,gBAAgB,CAAkB;QAlE9B,OAAE,GAAW,2BAA4B,QAAQ,EAAG,EAAE,CAAC;QAEvD,SAAI,GAAW,EAAE,CAAC;QAGlB,eAAU,GAAW,OAAO,CAAC;QAG7B,aAAQ,GAAW,OAAO,CAAC;QAenC,cAAS,GAAwB,mBAAmB,CAAC,KAAK,CAAC;QAW3D,UAAK,GAAoB,eAAe,CAAC,QAAQ,CAAC;QAG1C,aAAQ,GAAY,KAAK,CAAC;IAgC1C,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,gBAAgB,CAAC,eAAe,GAAG,IAAI,CAAC;IAC/C,CAAC;IAEM,eAAe;QACpB,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,gBAAgB,CAAC,eAAe,GAAG,SAAS,CAAC;IACpD,CAAC;8GApFU,6BAA6B;kGAA7B,6BAA6B,sPAF7B,CAAE,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,6BAA6B,EAAE,CAAE,+JA+CzE,eAAe,0FAGf,mBAAmB,4FAGnB,8BAA8B,2FAG9B,6BAA6B,sFAG7B,eAAe,oLCrF5B,6jBAeA;;2FDaa,6BAA6B;kBAVzC,SAAS;+BACE,yBAAyB,mBAGlB,uBAAuB,CAAC,MAAM,QACzC;wBACJ,KAAK,EAAE,kDAAkD;qBAC1D,aACU,CAAE,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,+BAA+B,EAAE,CAAE;gIAUpE,UAAU;sBADzB,KAAK;gBAIU,QAAQ;sBADvB,KAAK;gBAQc,QAAQ;sBAD3B,KAAK;gBAYc,IAAI;sBADvB,KAAK;gBAYU,QAAQ;sBADvB,KAAK;gBAIU,KAAK;sBADpB,SAAS;uBAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAInB,KAAK;sBADpB,SAAS;uBAAC,eAAe,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAI5B,SAAS;sBADxB,SAAS;uBAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAIhC,WAAW;sBAD1B,SAAS;uBAAC,8BAA8B,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAI3C,UAAU;sBADzB,SAAS;uBAAC,6BAA6B,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAI1C,KAAK;sBADpB,SAAS;uBAAC,eAAe,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAI5B,MAAM;sBADrB,SAAS;uBAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component, ElementRef, Input, OnDestroy, OnInit, ViewChild\n} from \"@angular/core\";\nimport {\n  castToConnectionBehavior, castToConnectionType, CONNECTION_GRADIENT,\n  CONNECTION_PATH, CONNECTION_TEXT,\n  FConnectionBase, FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient,\n  IConnectionPath, IConnectionText,\n} from '../common';\nimport { EConnectionBehavior } from '../common';\nimport { EConnectionType } from '../common';\nimport { F_CONNECTION } from '../common/f-connection.injection-token';\nimport { FComponentsStore } from '../../f-components-store';\n\nlet uniqueId: number = 0;\n\n@Component({\n  selector: \"f-connection-for-create\",\n  templateUrl: \"./f-connection-for-create.component.html\",\n  styleUrls: [ \"./f-connection-for-create.component.scss\" ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    class: \"f-component f-connection f-connection-for-create\"\n  },\n  providers: [ { provide: F_CONNECTION, useExisting: FConnectionForCreateComponent } ],\n})\nexport class FConnectionForCreateComponent\n    extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {\n\n  public override id: string = `f-connection-for-create-${ uniqueId++ }`;\n\n  public override text: string = '';\n\n  @Input()\n  public override startColor: string = 'black';\n\n  @Input()\n  public override endColor: string = 'black';\n\n  public override outputId: string | undefined;\n\n  public override inputId: string | undefined;\n\n  @Input()\n  public override set behavior(value: 'fixed' | 'floating') {\n    this._behavior = castToConnectionBehavior(value);\n  }\n\n  public override get behavior(): EConnectionBehavior {\n    return this._behavior;\n  }\n\n  private _behavior: EConnectionBehavior = EConnectionBehavior.FIXED;\n\n  @Input()\n  public override set type(value: 'segment' | 'straight' | 'bezier') {\n    this._type = castToConnectionType(value);\n  }\n\n  public override get type(): EConnectionType {\n    return this._type;\n  }\n\n  private _type: EConnectionType = EConnectionType.STRAIGHT;\n\n  @Input()\n  public override disabled: boolean = false;\n\n  @ViewChild('defs', { static: true })\n  public override fDefs!: ElementRef<SVGDefsElement>;\n\n  @ViewChild(CONNECTION_PATH, { static: true })\n  public override fPath!: IConnectionPath;\n\n  @ViewChild(CONNECTION_GRADIENT, { static: true })\n  public override fGradient!: IConnectionGradient;\n\n  @ViewChild(FConnectionDragHandleComponent, { static: true })\n  public override fDragHandle!: FConnectionDragHandleComponent;\n\n  @ViewChild(FConnectionSelectionComponent, { static: true })\n  public override fSelection!: FConnectionSelectionComponent;\n\n  @ViewChild(CONNECTION_TEXT, { static: true })\n  public override fText!: IConnectionText;\n\n  @ViewChild('rect', { static: true })\n  public override fLabel!: ElementRef<SVGRectElement>;\n\n  public override get boundingElement(): HTMLElement | SVGElement {\n    return this.fPath.hostElement;\n  }\n\n  constructor(\n      elementReference: ElementRef<HTMLElement>,\n      private fComponentsStore: FComponentsStore,\n  ) {\n    super(elementReference);\n  }\n\n  public ngOnInit(): void {\n    this.fComponentsStore.fTempConnection = this;\n  }\n\n  public ngAfterViewInit(): void {\n    this.hide();\n  }\n\n  public ngOnDestroy(): void {\n    this.fComponentsStore.fTempConnection = undefined;\n  }\n}\n","<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            <!--            <rect #rect height=\"20\" width=\"100\" fill=\"red\"></rect>-->\n        </g>\n        <text f-connection-text></text>\n    </g>\n</svg>\n"]}

package/esm2022/f-connection/f-connection-for-create/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-connection-for-create.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi9mLWNvbm5lY3Rpb24tZm9yLWNyZWF0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFDQUFxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWNvbm5lY3Rpb24tZm9yLWNyZWF0ZS5jb21wb25lbnQnO1xuIl19

package/esm2022/f-connection/index.mjs

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './f-connection-for-create';
+export * from './f-connection';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUV6QixjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbW1vbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1jb25uZWN0aW9uLWZvci1jcmVhdGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtY29ubmVjdGlvbic7XG5cblxuXG5cbiJdfQ==

package/esm2022/f-connection/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './f-connection-for-create/f-connection-for-create.component';
+export * from './f-connection/f-connection.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2REFBNkQsQ0FBQztBQUU1RSxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWNvbm5lY3Rpb24tZm9yLWNyZWF0ZS9mLWNvbm5lY3Rpb24tZm9yLWNyZWF0ZS5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtY29ubmVjdGlvbi9mLWNvbm5lY3Rpb24uY29tcG9uZW50JztcbiJdfQ==

package/esm2022/f-draggable/canvas/canvas.drag-handler.mjs

@@ -0,0 +1,20 @@
+import { Point, PointExtensions } from '@foblex/core';
+import { EDraggableType } from '../e-draggable-type';
+export class CanvasDragHandler {
+    constructor(fComponentsStore) {
+        this.fComponentsStore = fComponentsStore;
+        this.type = EDraggableType.CANVAS;
+        this.onPointerDownPosition = PointExtensions.initialize();
+    }
+    initialize() {
+        this.onPointerDownPosition = this.fComponentsStore.fCanvas.transform.position;
+    }
+    move(difference) {
+        this.fComponentsStore.fCanvas.setPosition(Point.fromPoint(this.onPointerDownPosition).add(difference));
+        this.fComponentsStore.fCanvas.redraw();
+    }
+    complete() {
+        this.fComponentsStore.fCanvas.completeDrag();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/canvas/canvas.on-pointer-up.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { EDraggableType } from '../e-draggable-type';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-draggable-data-context";
+export class CanvasOnPointerUp {
+    constructor(fDraggableDataContext) {
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(event) {
+        const isDragCanvas = this.fDraggableDataContext.draggableItems.some((x) => x.type === EDraggableType.CANVAS);
+        if (isDragCanvas) {
+            this.fDraggableDataContext.draggableItems.forEach((x) => {
+                x.complete?.();
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasOnPointerUp, deps: [{ token: i1.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasOnPointerUp }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasOnPointerUp, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FudmFzLm9uLXBvaW50ZXItdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2NhbnZhcy9jYW52YXMub24tcG9pbnRlci11cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7O0FBR3JELE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsWUFDWSxxQkFBNEM7UUFBNUMsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUF1QjtJQUV4RCxDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQW9CO1FBQ2hDLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUU3RyxJQUFJLFlBQVksRUFBRTtZQUNoQixJQUFJLENBQUMscUJBQXFCLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO2dCQUN0RCxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQztZQUNqQixDQUFDLENBQUMsQ0FBQztTQUNKO0lBQ0gsQ0FBQzs4R0FmVSxpQkFBaUI7a0hBQWpCLGlCQUFpQjs7MkZBQWpCLGlCQUFpQjtrQkFEN0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElIYW5kbGVyLCBJUG9pbnRlckV2ZW50IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZEcmFnZ2FibGVEYXRhQ29udGV4dCB9IGZyb20gJy4uL2YtZHJhZ2dhYmxlLWRhdGEtY29udGV4dCc7XG5pbXBvcnQgeyBFRHJhZ2dhYmxlVHlwZSB9IGZyb20gJy4uL2UtZHJhZ2dhYmxlLXR5cGUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ2FudmFzT25Qb2ludGVyVXAgaW1wbGVtZW50cyBJSGFuZGxlcjxJUG9pbnRlckV2ZW50LCB2b2lkPiB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgICBwcml2YXRlIGZEcmFnZ2FibGVEYXRhQ29udGV4dDogRkRyYWdnYWJsZURhdGFDb250ZXh0LFxuICApIHtcbiAgfVxuXG4gIHB1YmxpYyBoYW5kbGUoZXZlbnQ6IElQb2ludGVyRXZlbnQpOiB2b2lkIHtcbiAgICBjb25zdCBpc0RyYWdDYW52YXMgPSB0aGlzLmZEcmFnZ2FibGVEYXRhQ29udGV4dC5kcmFnZ2FibGVJdGVtcy5zb21lKCh4KSA9PiB4LnR5cGUgPT09IEVEcmFnZ2FibGVUeXBlLkNBTlZBUyk7XG5cbiAgICBpZiAoaXNEcmFnQ2FudmFzKSB7XG4gICAgICB0aGlzLmZEcmFnZ2FibGVEYXRhQ29udGV4dC5kcmFnZ2FibGVJdGVtcy5mb3JFYWNoKCh4KSA9PiB7XG4gICAgICAgIHguY29tcGxldGU/LigpO1xuICAgICAgfSk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2022/f-draggable/canvas/canvas.prepare-drag-sequence.mjs

@@ -0,0 +1,37 @@
+import { Point } from '@foblex/core';
+import { Injectable } from '@angular/core';
+import { CanvasDragHandler } from './canvas.drag-handler';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-components-store";
+import * as i2 from "../f-draggable-data-context";
+export class CanvasPrepareDragSequence {
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    constructor(fComponentsStore, fDraggableDataContext) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(event) {
+        const pointerPositionInFlow = Point.fromPoint(event.getPosition()).elementTransform(this.flowHost);
+        const isBackgroundElement = this.fComponentsStore.fBackground?.isBackgroundElement(event.targetElement);
+        const isFlowHost = this.flowHost.contains(event.targetElement);
+        let node = this.fComponentsStore.findNode(event.targetElement);
+        if (node && node.disabled) {
+            node = undefined;
+        }
+        if ((isBackgroundElement || (isFlowHost && !node)) && !this.fDraggableDataContext.draggableItems.length) {
+            this.fDraggableDataContext.onPointerDownScale = 1;
+            this.fDraggableDataContext.onPointerDownPosition = pointerPositionInFlow.div(1);
+            this.fDraggableDataContext.draggableItems = [
+                new CanvasDragHandler(this.fComponentsStore)
+            ];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasPrepareDragSequence, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasPrepareDragSequence }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CanvasPrepareDragSequence, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/canvas/index.mjs

@@ -0,0 +1,5 @@
+export * from './canvas.drag-handler';
+export * from './canvas.on-pointer-up';
+export * from './canvas.prepare-drag-sequence';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2NhbnZhcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2FudmFzLmRyYWctaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vY2FudmFzLm9uLXBvaW50ZXItdXAnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NhbnZhcy5wcmVwYXJlLWRyYWctc2VxdWVuY2UnO1xuXG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGVycyc7XG4iXX0=

package/esm2022/f-draggable/canvas/providers.mjs

@@ -0,0 +1,7 @@
+import { CanvasOnPointerUp } from './canvas.on-pointer-up';
+import { CanvasPrepareDragSequence } from './canvas.prepare-drag-sequence';
+export const CANVAS_PROVIDERS = [
+    CanvasOnPointerUp,
+    CanvasPrepareDragSequence
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9jYW52YXMvcHJvdmlkZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzNELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRTNFLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBRTlCLGlCQUFpQjtJQUVqQix5QkFBeUI7Q0FDMUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhbnZhc09uUG9pbnRlclVwIH0gZnJvbSAnLi9jYW52YXMub24tcG9pbnRlci11cCc7XG5pbXBvcnQgeyBDYW52YXNQcmVwYXJlRHJhZ1NlcXVlbmNlIH0gZnJvbSAnLi9jYW52YXMucHJlcGFyZS1kcmFnLXNlcXVlbmNlJztcblxuZXhwb3J0IGNvbnN0IENBTlZBU19QUk9WSURFUlMgPSBbXG5cbiAgQ2FudmFzT25Qb2ludGVyVXAsXG5cbiAgQ2FudmFzUHJlcGFyZURyYWdTZXF1ZW5jZVxuXTtcbiJdfQ==

package/esm2022/f-draggable/components/f-external-item/f-external-item-base.mjs

@@ -0,0 +1,11 @@
+import { Directive, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const F_EXTERNAL_ITEM = new InjectionToken('F_EXTERNAL_ITEM');
+export class FExternalItemBase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FExternalItemBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.5", type: FExternalItemBase, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FExternalItemBase, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1leHRlcm5hbC1pdGVtLWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2NvbXBvbmVudHMvZi1leHRlcm5hbC1pdGVtL2YtZXh0ZXJuYWwtaXRlbS1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUxRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxjQUFjLENBQW9CLGlCQUFpQixDQUFDLENBQUM7QUFHeEYsTUFBTSxPQUFnQixpQkFBaUI7OEdBQWpCLGlCQUFpQjtrR0FBakIsaUJBQWlCOzsyRkFBakIsaUJBQWlCO2tCQUR0QyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUhhc0hvc3RFbGVtZW50IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IERpcmVjdGl2ZSwgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IEZfRVhURVJOQUxfSVRFTSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGRXh0ZXJuYWxJdGVtQmFzZT4oJ0ZfRVhURVJOQUxfSVRFTScpO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGRXh0ZXJuYWxJdGVtQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGlkOiBhbnk7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQ7XG5cbiAgcHVibGljIGFic3RyYWN0IGRhdGE6IGFueTtcbn1cbiJdfQ==

package/esm2022/f-draggable/components/f-external-item/f-external-item.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive, Input } from '@angular/core';
+import { FExternalItemBase, F_EXTERNAL_ITEM } from './f-external-item-base';
+import * as i0 from "@angular/core";
+import * as i1 from "./f-external-item.service";
+let uniqueId = 0;
+export class FExternalItemDirective extends FExternalItemBase {
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    constructor(elementReference, fExternalItemService) {
+        super();
+        this.elementReference = elementReference;
+        this.fExternalItemService = fExternalItemService;
+        this.id = `f-external-item-${uniqueId++}`;
+    }
+    ngOnInit() {
+        this.fExternalItemService.registerItem(this);
+    }
+    ngOnDestroy() {
+        this.fExternalItemService.removeItem(this);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FExternalItemDirective, deps: [{ token: i0.ElementRef }, { token: i1.FExternalItemService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.5", type: FExternalItemDirective, selector: "[fExternalItem]", inputs: { id: "id", data: "data" }, host: { properties: { "attr.id": "id" }, classAttribute: "f-component f-external-item" }, providers: [
+            { provide: F_EXTERNAL_ITEM, useExisting: FExternalItemDirective }
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FExternalItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fExternalItem]",
+                    host: {
+                        '[attr.id]': 'id',
+                        class: "f-component f-external-item",
+                    },
+                    providers: [
+                        { provide: F_EXTERNAL_ITEM, useExisting: FExternalItemDirective }
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FExternalItemService }]; }, propDecorators: { id: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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