@foblex/flow 12.6.1 → 12.6.3

package/esm2015/domain/intersections/intersection-finder.js

@@ -0,0 +1,156 @@
+import { Arc, Line, PointExtensions, VectorExtensions } from '@foblex/core';
+import { FConnectorShapeExtensions } from './f-connector-shape.extensions';
+/**
+ * The IntersectionFinder class is designed to find intersection points between
+ * line segments and various geometric shapes. Currently, it supports rectangles,
+ * circles, and ellipses. In the future, support for additional shapes will be added.
+ */
+export class IntersectionFinder {
+    /**
+     * Finds the guaranteed intersection points between a line segment and a rounded rectangle.
+     * @param from - Starting point of the line segment.
+     * @param to - Ending point of the line segment.
+     * @param shape - The shape to check for intersections.
+     * @returns An array of intersection points.
+     */
+    static getIntersections(from, to, shape) {
+        const segments = FConnectorShapeExtensions.getSegments(shape);
+        for (const segment of segments) {
+            if (segment instanceof Arc) {
+                const intersections = this.intersectArcWithLine(segment, from, to);
+                if (intersections.length > 0) {
+                    return intersections;
+                }
+            }
+            else if (segment instanceof Line) {
+                const intersection = this.intersectLineSegments(from, to, segment.point1, segment.point2);
+                if (intersection) {
+                    return [intersection];
+                }
+            }
+        }
+        return [];
+    }
+    /**
+     * Finds the intersection points between an arc and a line segment.
+     * @param arc - The arc to check for intersections.
+     * @param from - Starting point of the line segment.
+     * @param to - Ending point of the line segment.
+     * @returns An array of intersection points.
+     */
+    static intersectArcWithLine(arc, from, to) {
+        return this.filterPointsWithinArc(this.findEllipseLineIntersections(arc.center, arc.radiusX, arc.radiusY, from, to), arc);
+    }
+    /**
+     * Finds the intersection point between two line segments.
+     * @param p1 - Starting point of the first line segment.
+     * @param p2 - Ending point of the first line segment.
+     * @param p3 - Starting point of the second line segment.
+     * @param p4 - Ending point of the second line segment.
+     * @returns The intersection point or null if there is no intersection.
+     */
+    static intersectLineSegments(p1, p2, p3, p4) {
+        const s1_x = p2.x - p1.x;
+        const s1_y = p2.y - p1.y;
+        const s2_x = p4.x - p3.x;
+        const s2_y = p4.y - p3.y;
+        const s = (-s1_y * (p1.x - p3.x) + s1_x * (p1.y - p3.y)) / (-s2_x * s1_y + s1_x * s2_y);
+        const t = (s2_x * (p1.y - p3.y) - s2_y * (p1.x - p3.x)) / (-s2_x * s1_y + s1_x * s2_y);
+        if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+            return { x: p1.x + (t * s1_x), y: p1.y + (t * s1_y) };
+        }
+        return null;
+    }
+    /**
+     * Filters intersection points to retain only those within the given arc.
+     * @param points - The points to filter.
+     * @param arc - The arc to check against.
+     * @returns An array of points within the arc.
+     */
+    static filterPointsWithinArc(points, arc) {
+        let { center, startAngle, endAngle } = arc;
+        if (points.length === 0) {
+            return points;
+        }
+        if (endAngle < startAngle) {
+            [startAngle, endAngle] = [endAngle, startAngle];
+        }
+        if (startAngle < 0 || endAngle < 0) {
+            startAngle += 2.0 * Math.PI;
+            endAngle += 2.0 * Math.PI;
+        }
+        const filteredPoints = [];
+        for (const point of points) {
+            let angle = this.normalizeAngle(VectorExtensions.angle(VectorExtensions.initialize(1, 0), VectorExtensions.initialize(point.x - center.x, point.y - center.y)));
+            if (angle < startAngle) {
+                angle += 2.0 * Math.PI;
+            }
+            if (startAngle <= angle && angle <= endAngle) {
+                filteredPoints.push(point);
+            }
+        }
+        return filteredPoints;
+    }
+    /**
+     * Normalizes an angle to be within the range 0 to 2π.
+     * @param radians - The angle in radians.
+     * @returns The normalized angle.
+     */
+    static normalizeAngle(radians) {
+        const normal = radians % (2.0 * Math.PI);
+        return normal < 0.0 ? (normal + (2.0 * Math.PI)) : normal;
+    }
+    /**
+     * Finds the intersection points between an ellipse and a line segment.
+     * @param center - Center of the ellipse.
+     * @param radiusX - X radius of the ellipse.
+     * @param radiusY - Y radius of the ellipse.
+     * @param pointA - Starting point of the line segment.
+     * @param pointB - Ending point of the line segment.
+     * @returns An array of intersection points.
+     */
+    static findEllipseLineIntersections(center, radiusX, radiusY, pointA, pointB) {
+        const origin = VectorExtensions.initialize(pointA.x, pointA.y);
+        const direction = VectorExtensions.fromPoints(pointA, pointB);
+        const ellipseCenter = VectorExtensions.initialize(center.x, center.y);
+        const diff = VectorExtensions.subtract(origin, ellipseCenter);
+        const scaledDir = VectorExtensions.initialize(direction.x / (radiusX * radiusX), direction.y / (radiusY * radiusY));
+        const scaledDiff = VectorExtensions.initialize(diff.x / (radiusX * radiusX), diff.y / (radiusY * radiusY));
+        const a = VectorExtensions.dotProduct(direction, scaledDir);
+        const b = VectorExtensions.dotProduct(direction, scaledDiff);
+        const c = VectorExtensions.dotProduct(diff, scaledDiff) - 1.0;
+        const discriminant = b * b - a * c;
+        return discriminant < 0 ? [] : this.calculateIntersectionPoints(discriminant, a, b, pointA, pointB);
+    }
+    /**
+     * Calculates the intersection points based on the discriminant.
+     * @param discriminant - The discriminant value.
+     * @param a - Coefficient 'a' in the quadratic equation.
+     * @param b - Coefficient 'b' in the quadratic equation.
+     * @param pointA - Starting point of the line segment.
+     * @param pointB - Ending point of the line segment.
+     * @returns An array of intersection points.
+     */
+    static calculateIntersectionPoints(discriminant, a, b, pointA, pointB) {
+        const points = [];
+        if (discriminant > 0) {
+            const root = Math.sqrt(discriminant);
+            const t1 = (-b - root) / a;
+            const t2 = (-b + root) / a;
+            if (t1 >= 0 && t1 <= 1) {
+                points.push(PointExtensions.interpolatePoints(pointA, pointB, t1));
+            }
+            if (t2 >= 0 && t2 <= 1) {
+                points.push(PointExtensions.interpolatePoints(pointA, pointB, t2));
+            }
+        }
+        else {
+            const t = -b / a;
+            if (t >= 0 && t <= 1) {
+                points.push(PointExtensions.interpolatePoints(pointA, pointB, t));
+            }
+        }
+        return points;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intersection-finder.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/domain/intersections/intersection-finder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Arc, IArc, IPoint, Line, PointExtensions, VectorExtensions } from '@foblex/core';\nimport { IConnectorShape } from './i-connector-shape';\nimport { FConnectorShapeExtensions } from './f-connector-shape.extensions';\n\n/**\n * The IntersectionFinder class is designed to find intersection points between\n * line segments and various geometric shapes. Currently, it supports rectangles,\n * circles, and ellipses. In the future, support for additional shapes will be added.\n */\nexport class IntersectionFinder {\n\n  /**\n   * Finds the guaranteed intersection points between a line segment and a rounded rectangle.\n   * @param from - Starting point of the line segment.\n   * @param to - Ending point of the line segment.\n   * @param shape - The shape to check for intersections.\n   * @returns An array of intersection points.\n   */\n  public static getIntersections(from: IPoint, to: IPoint, shape: IConnectorShape): IPoint[] {\n    const segments: (Arc | Line)[] = FConnectorShapeExtensions.getSegments(shape);\n\n    for (const segment of segments) {\n      if (segment instanceof Arc) {\n        const intersections = this.intersectArcWithLine(segment, from, to);\n        if (intersections.length > 0) {\n          return intersections;\n        }\n      } else if (segment instanceof Line) {\n        const intersection = this.intersectLineSegments(from, to, segment.point1, segment.point2);\n        if (intersection) {\n          return [ intersection ];\n        }\n      }\n    }\n\n    return [];\n  }\n\n  /**\n   * Finds the intersection points between an arc and a line segment.\n   * @param arc - The arc to check for intersections.\n   * @param from - Starting point of the line segment.\n   * @param to - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static intersectArcWithLine(arc: IArc, from: IPoint, to: IPoint): IPoint[] {\n    return this.filterPointsWithinArc(\n      this.findEllipseLineIntersections(arc.center, arc.radiusX, arc.radiusY, from, to),\n      arc\n    );\n  }\n\n  /**\n   * Finds the intersection point between two line segments.\n   * @param p1 - Starting point of the first line segment.\n   * @param p2 - Ending point of the first line segment.\n   * @param p3 - Starting point of the second line segment.\n   * @param p4 - Ending point of the second line segment.\n   * @returns The intersection point or null if there is no intersection.\n   */\n  private static intersectLineSegments(p1: IPoint, p2: IPoint, p3: IPoint, p4: IPoint): IPoint | null {\n    const s1_x = p2.x - p1.x;\n    const s1_y = p2.y - p1.y;\n    const s2_x = p4.x - p3.x;\n    const s2_y = p4.y - p3.y;\n\n    const s = (-s1_y * (p1.x - p3.x) + s1_x * (p1.y - p3.y)) / (-s2_x * s1_y + s1_x * s2_y);\n    const t = (s2_x * (p1.y - p3.y) - s2_y * (p1.x - p3.x)) / (-s2_x * s1_y + s1_x * s2_y);\n\n    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\n      return { x: p1.x + (t * s1_x), y: p1.y + (t * s1_y) };\n    }\n\n    return null;\n  }\n\n  /**\n   * Filters intersection points to retain only those within the given arc.\n   * @param points - The points to filter.\n   * @param arc - The arc to check against.\n   * @returns An array of points within the arc.\n   */\n  private static filterPointsWithinArc(points: IPoint[], arc: IArc): IPoint[] {\n    let { center, startAngle, endAngle } = arc;\n\n    if (points.length === 0) {\n      return points;\n    }\n\n    if (endAngle < startAngle) {\n      [ startAngle, endAngle ] = [ endAngle, startAngle ];\n    }\n\n    if (startAngle < 0 || endAngle < 0) {\n      startAngle += 2.0 * Math.PI;\n      endAngle += 2.0 * Math.PI;\n    }\n\n    const filteredPoints: IPoint[] = [];\n\n    for (const point of points) {\n      let angle = this.normalizeAngle(\n        VectorExtensions.angle(\n          VectorExtensions.initialize(1, 0),\n          VectorExtensions.initialize(point.x - center.x, point.y - center.y)\n        )\n      );\n\n      if (angle < startAngle) {\n        angle += 2.0 * Math.PI;\n      }\n\n      if (startAngle <= angle && angle <= endAngle) {\n        filteredPoints.push(point);\n      }\n    }\n\n    return filteredPoints;\n  }\n\n  /**\n   * Normalizes an angle to be within the range 0 to 2π.\n   * @param radians - The angle in radians.\n   * @returns The normalized angle.\n   */\n  private static normalizeAngle(radians: number): number {\n    const normal = radians % (2.0 * Math.PI);\n    return normal < 0.0 ? (normal + (2.0 * Math.PI)) : normal;\n  }\n\n  /**\n   * Finds the intersection points between an ellipse and a line segment.\n   * @param center - Center of the ellipse.\n   * @param radiusX - X radius of the ellipse.\n   * @param radiusY - Y radius of the ellipse.\n   * @param pointA - Starting point of the line segment.\n   * @param pointB - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static findEllipseLineIntersections(center: IPoint, radiusX: number, radiusY: number, pointA: IPoint, pointB: IPoint): IPoint[] {\n    const origin = VectorExtensions.initialize(pointA.x, pointA.y);\n    const direction = VectorExtensions.fromPoints(pointA, pointB);\n    const ellipseCenter = VectorExtensions.initialize(center.x, center.y);\n    const diff = VectorExtensions.subtract(origin, ellipseCenter);\n    const scaledDir = VectorExtensions.initialize(direction.x / (radiusX * radiusX), direction.y / (radiusY * radiusY));\n    const scaledDiff = VectorExtensions.initialize(diff.x / (radiusX * radiusX), diff.y / (radiusY * radiusY));\n\n    const a = VectorExtensions.dotProduct(direction, scaledDir);\n    const b = VectorExtensions.dotProduct(direction, scaledDiff);\n    const c = VectorExtensions.dotProduct(diff, scaledDiff) - 1.0;\n    const discriminant = b * b - a * c;\n\n    return discriminant < 0 ? [] : this.calculateIntersectionPoints(discriminant, a, b, pointA, pointB);\n  }\n\n  /**\n   * Calculates the intersection points based on the discriminant.\n   * @param discriminant - The discriminant value.\n   * @param a - Coefficient 'a' in the quadratic equation.\n   * @param b - Coefficient 'b' in the quadratic equation.\n   * @param pointA - Starting point of the line segment.\n   * @param pointB - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static calculateIntersectionPoints(discriminant: number, a: number, b: number, pointA: IPoint, pointB: IPoint): IPoint[] {\n    const points: IPoint[] = [];\n\n    if (discriminant > 0) {\n      const root = Math.sqrt(discriminant);\n      const t1 = (-b - root) / a;\n      const t2 = (-b + root) / a;\n\n      if (t1 >= 0 && t1 <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t1));\n      }\n      if (t2 >= 0 && t2 <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t2));\n      }\n    } else {\n      const t = -b / a;\n      if (t >= 0 && t <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t));\n      }\n    }\n\n    return points;\n  }\n}\n"]}

package/esm2015/domain/intersections/rounded-rect/rounded-rect.js

@@ -0,0 +1,46 @@
+import { Point } from '@foblex/core';
+import { EFConnectorShape } from '../e-f-connector-shape';
+export class RoundedRect {
+    constructor(x = 0, y = 0, width = 0, height = 0, radius1 = 0, radius2 = 0, radius3 = 0, radius4 = 0) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.radius1 = radius1;
+        this.radius2 = radius2;
+        this.radius3 = radius3;
+        this.radius4 = radius4;
+        this.type = EFConnectorShape.ROUNDED_RECT;
+        this.gravityCenter = { x: 0, y: 0 };
+        this.gravityCenter = this.calculateGravityCenter(this);
+    }
+    calculateGravityCenter(rect) {
+        return new Point(rect.x + rect.width / 2, rect.y + rect.height / 2);
+    }
+    static fromRect(rect) {
+        return new RoundedRect(rect.x, rect.y, rect.width, rect.height);
+    }
+    static fromRoundedRect(rect) {
+        return new RoundedRect(rect.x, rect.y, rect.width, rect.height, rect.radius1, rect.radius2, rect.radius3, rect.radius4);
+    }
+    static fromElement(element, fBrowser) {
+        const { x, y, width, height } = element.getBoundingClientRect();
+        return this.setRadiusFromElement(new RoundedRect(x, y, width, height), element, fBrowser);
+    }
+    static setRadiusFromElement(rect, element, fBrowser) {
+        const data = fBrowser.window.getComputedStyle(element);
+        rect.radius1 = fBrowser.toPixels(data.borderTopLeftRadius, element.clientWidth, element.clientHeight, data.fontSize) || 0;
+        rect.radius2 = fBrowser.toPixels(data.borderTopRightRadius, element.clientWidth, element.clientHeight, data.fontSize) || 0;
+        rect.radius3 = fBrowser.toPixels(data.borderBottomRightRadius, element.clientWidth, element.clientHeight, data.fontSize) || 0;
+        rect.radius4 = fBrowser.toPixels(data.borderBottomLeftRadius, element.clientWidth, element.clientHeight, data.fontSize) || 0;
+        return rect;
+    }
+    addPoint(point) {
+        const copy = RoundedRect.fromRoundedRect(this);
+        copy.x += point.x;
+        copy.y += point.y;
+        copy.gravityCenter = this.calculateGravityCenter(copy);
+        return copy;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/domain/is-connection-under-node/is-connection-under-node.execution.js

@@ -0,0 +1,76 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import { IsConnectionUnderNodeRequest } from './is-connection-under-node.request';
+import { NodeDragHandler } from '../../f-draggable';
+import { GetElementRectInFlowRequest } from '../get-element-rect-in-flow';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+import * as i2 from "../../f-draggable";
+import * as i3 from "../../infrastructure";
+let IsConnectionUnderNodeExecution = class IsConnectionUnderNodeExecution {
+    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+    }
+    get transform() {
+        return this.fComponentsStore.fCanvas.transform;
+    }
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    handle() {
+        const isValid = this.isValidRequest();
+        if (!isValid) {
+            return;
+        }
+        const fNode = this.fDraggableDataContext.draggableItems[0].fNode;
+        const outputsOfNode = this.getOutputsForNode(fNode);
+        const inputsOfNode = this.getInputsForNode(fNode);
+        const isCantBeConnectedByOutput = outputsOfNode.some((x) => !x.canBeConnected);
+        const isCantBeConnectedByInput = this.fComponentsStore.fConnections.some((x) => {
+            return inputsOfNode.find((input) => input.id === x.fInputId);
+        });
+        if (!isCantBeConnectedByInput && outputsOfNode.length && !isCantBeConnectedByOutput && inputsOfNode.length) {
+            const output = outputsOfNode[0];
+            const input = inputsOfNode[0];
+            // const outgoingConnections = this.getOutgoingConnectionsHandler.handle([ output ]);
+            // const incomingConnections = this.getIncomingConnectionsHandler.handle([ input ]);
+            // if (outgoingConnections.length === 0 && incomingConnections.length === 0) {
+            //   const connections = this.findConnectionsUnderNode(fNode);
+            //   if (connections.length) {
+            //     //TODO: need to implement
+            //   }
+            // }
+        }
+    }
+    isValidRequest() {
+        const result = this.fDraggableDataContext.draggableItems.length === 1 &&
+            this.fDraggableDataContext.draggableItems[0] instanceof NodeDragHandler;
+        return result;
+    }
+    getOutputsForNode(node) {
+        return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
+    }
+    getInputsForNode(node) {
+        return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
+    }
+    findConnectionsUnderNode(node) {
+        const nodeRect = this.fMediator.send(new GetElementRectInFlowRequest(node.hostElement));
+        return this.fComponentsStore.fConnections.filter((x) => {
+            // const intersection = [];// RectExtensions.intersectionWithVector(nodeRect, x.line.point1, x.line.point2, 0, 0, 0, 0);
+            return ([]).length > 0;
+        });
+    }
+};
+IsConnectionUnderNodeExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IsConnectionUnderNodeExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+IsConnectionUnderNodeExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IsConnectionUnderNodeExecution });
+IsConnectionUnderNodeExecution = __decorate([
+    FExecutionRegister(IsConnectionUnderNodeRequest)
+], IsConnectionUnderNodeExecution);
+export { IsConnectionUnderNodeExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IsConnectionUnderNodeExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"is-connection-under-node.execution.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/domain/is-connection-under-node/is-connection-under-node.execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { IHandler, IRect, ITransformModel } from '@foblex/core';\nimport { Injectable } from '@angular/core';\nimport { FExecutionRegister, FFlowMediator, IExecution } from '../../infrastructure';\nimport { IsConnectionUnderNodeRequest } from './is-connection-under-node.request';\nimport { FComponentsStore } from '../../f-storage';\nimport { FDraggableDataContext, NodeDragHandler } from '../../f-draggable';\nimport { FNodeBase } from '../../f-node';\nimport { FConnectorBase } from '../../f-connectors';\nimport { FConnectionBase } from '../../f-connection';\nimport { GetElementRectInFlowRequest } from '../get-element-rect-in-flow';\n\n@Injectable()\n@FExecutionRegister(IsConnectionUnderNodeRequest)\nexport class IsConnectionUnderNodeExecution implements IExecution<IsConnectionUnderNodeRequest, void> {\n\n  private get transform(): ITransformModel {\n    return this.fComponentsStore.fCanvas!.transform;\n  }\n\n  private get flowHost(): HTMLElement {\n    return this.fComponentsStore.fFlow!.hostElement;\n  }\n\n  constructor(\n      private fComponentsStore: FComponentsStore,\n      private fDraggableDataContext: FDraggableDataContext,\n      private fMediator: FFlowMediator,\n      // private getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler,\n      // private getIncomingConnectionsHandler: GetIncomingConnectionsHandler\n  ) {\n  }\n\n  public handle(): void {\n\n    const isValid = this.isValidRequest();\n    if (!isValid) {\n      return;\n    }\n\n    const fNode = (this.fDraggableDataContext.draggableItems[ 0 ] as NodeDragHandler).fNode;\n\n    const outputsOfNode = this.getOutputsForNode(fNode);\n    const inputsOfNode = this.getInputsForNode(fNode);\n\n    const isCantBeConnectedByOutput = outputsOfNode.some((x) => !x.canBeConnected);\n\n    const isCantBeConnectedByInput = this.fComponentsStore.fConnections.some((x) => {\n      return inputsOfNode.find((input) => input.id === x.fInputId);\n    });\n\n    if (!isCantBeConnectedByInput && outputsOfNode.length && !isCantBeConnectedByOutput && inputsOfNode.length) {\n      const output = outputsOfNode[ 0 ];\n      const input = inputsOfNode[ 0 ];\n      // const outgoingConnections = this.getOutgoingConnectionsHandler.handle([ output ]);\n      // const incomingConnections = this.getIncomingConnectionsHandler.handle([ input ]);\n      // if (outgoingConnections.length === 0 && incomingConnections.length === 0) {\n      //   const connections = this.findConnectionsUnderNode(fNode);\n      //   if (connections.length) {\n      //     //TODO: need to implement\n      //   }\n      // }\n    }\n  }\n\n  private isValidRequest(): boolean {\n    const result =\n        this.fDraggableDataContext.draggableItems.length === 1 &&\n        this.fDraggableDataContext.draggableItems[ 0 ] instanceof NodeDragHandler;\n\n    return result;\n  }\n\n  private getOutputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private getInputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private findConnectionsUnderNode(node: FNodeBase): FConnectionBase[] {\n    const nodeRect = this.fMediator.send<IRect>(new GetElementRectInFlowRequest(node.hostElement));\n    return this.fComponentsStore.fConnections.filter((x) => {\n     // const intersection = [];// RectExtensions.intersectionWithVector(nodeRect, x.line.point1, x.line.point2, 0, 0, 0, 0);\n      return ([]).length > 0\n    });\n  }\n}\n// @Injectable()\n// export class GetIncomingConnectionsHandler implements IHandler<FConnectorBase[], FConnectionBase[]> {\n//\n//   private get fConnections(): FConnectionBase[] {\n//     return this.fComponentsStore.fConnections;\n//   }\n//\n//   constructor(\n//     private fComponentsStore: FComponentsStore,\n//   ) {\n//   }\n//\n//   public handle(inputs: FConnectorBase[]): FConnectionBase[] {\n//     const inputsIds = inputs.map((x) => x.id);\n//     return this.fConnections.filter((x) => {\n//       return inputsIds.includes(x.fInputId);\n//     })!;\n//   }\n// }\n// @Injectable()\n// export class GetOutgoingConnectionsHandler implements IHandler<FConnectorBase[], FConnectionBase[]> {\n//\n//   private get fConnections(): FConnectionBase[] {\n//     return this.fComponentsStore.fConnections;\n//   }\n//\n//   constructor(\n//     private fComponentsStore: FComponentsStore,\n//   ) {\n//   }\n//\n//   public handle(outputs: FConnectorBase[]): FConnectionBase[] {\n//     const outputsIds = outputs.map((x) => x.id);\n//     return this.fConnections.filter((x) => {\n//       return outputsIds.includes(x.fOutputId);\n//     })!;\n//   }\n// }\n"]}

package/esm2015/domain/redraw-connections/redraw-connections.execution.js

@@ -0,0 +1,60 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { RedrawConnectionsRequest } from './redraw-connections-request';
+import { GetConnectionLineRequest } from '../get-connection-line';
+import { FExecutionRegister } from '../../infrastructure';
+import { GetElementRectInFlowRequest } from '../get-element-rect-in-flow';
+import { CreateConnectionMarkersRequest } from '../create-connection-markers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+import * as i2 from "../../infrastructure";
+let RedrawConnectionsExecution = class RedrawConnectionsExecution {
+    constructor(fComponentsStore, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        this.resetConnectors();
+        if (this.fComponentsStore.fTempConnection) {
+            this.setMarkers(this.fComponentsStore.fTempConnection);
+        }
+        this.fComponentsStore.fConnections.forEach((connection) => {
+            const output = this.fComponentsStore.fOutputs.find((x) => x.id === connection.fOutputId);
+            const input = this.fComponentsStore.fInputs.find((x) => x.id === connection.fInputId);
+            if (output && input) {
+                this.setupConnection(output, input, connection);
+            }
+        });
+    }
+    resetConnectors() {
+        this.fComponentsStore.fOutputs.forEach((output) => output.setConnected(false));
+        this.fComponentsStore.fInputs.forEach((input) => input.setConnected(false));
+    }
+    setupConnection(output, input, connection) {
+        output.setConnected(true);
+        input.setConnected(true);
+        const line = this.getLine(output, input, connection);
+        this.setMarkers(connection);
+        connection.setLine(line.point1, output.fConnectableSide, line.point2, input.fConnectableSide);
+        connection.initialize();
+        connection.isSelected() ? connection.select() : null;
+    }
+    getLine(output, input, connection) {
+        const outputRect = this.fMediator.send(new GetElementRectInFlowRequest(output.hostElement));
+        const inputRect = this.fMediator.send(new GetElementRectInFlowRequest(input.hostElement));
+        return this.fMediator.send(new GetConnectionLineRequest(outputRect, inputRect, connection.fBehavior, output.fConnectableSide, input.fConnectableSide));
+    }
+    setMarkers(connection) {
+        this.fMediator.send(new CreateConnectionMarkersRequest(connection));
+    }
+};
+RedrawConnectionsExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RedrawConnectionsExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+RedrawConnectionsExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RedrawConnectionsExecution });
+RedrawConnectionsExecution = __decorate([
+    FExecutionRegister(RedrawConnectionsRequest)
+], RedrawConnectionsExecution);
+export { RedrawConnectionsExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RedrawConnectionsExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/domain/select/select.execution.js

@@ -0,0 +1,44 @@
+import { __decorate } from "tslib";
+import { SelectRequest } from './select.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+import * as i2 from "../../f-draggable";
+let SelectExecution = class SelectExecution {
+    constructor(fDataContext, fDraggableDataContext) {
+        this.fDataContext = fDataContext;
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(request) {
+        this.fDraggableDataContext.selectedItems.forEach((x) => {
+            x.deselect();
+        });
+        this.fDraggableDataContext.selectedItems = [];
+        request.nodes.forEach((key) => {
+            const node = this.fDataContext.fNodes.find((x) => x.fId === key);
+            if (node) {
+                node.select();
+                this.fDraggableDataContext.selectedItems.push(node);
+            }
+        });
+        request.connections.forEach((key) => {
+            const connection = this.fDataContext.fConnections.find((x) => x.fId === key);
+            if (connection) {
+                connection.select();
+                this.fDraggableDataContext.selectedItems.push(connection);
+            }
+        });
+        this.fDraggableDataContext.isSelectedChanged = true;
+    }
+};
+SelectExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectExecution });
+SelectExecution = __decorate([
+    FExecutionRegister(SelectRequest)
+], SelectExecution);
+export { SelectExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/domain/select/select.request.js

@@ -0,0 +1,7 @@
+export class SelectRequest {
+    constructor(nodes, connections) {
+        this.nodes = nodes;
+        this.connections = connections;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3Qvc2VsZWN0LnJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGFBQWE7SUFFeEIsWUFDUyxLQUFlLEVBQ2YsV0FBcUI7UUFEckIsVUFBSyxHQUFMLEtBQUssQ0FBVTtRQUNmLGdCQUFXLEdBQVgsV0FBVyxDQUFVO0lBRTlCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBTZWxlY3RSZXF1ZXN0IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgbm9kZXM6IHN0cmluZ1tdLFxuICAgIHB1YmxpYyBjb25uZWN0aW9uczogc3RyaW5nW11cbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2015/domain/select-all/select-all.execution.js

@@ -0,0 +1,38 @@
+import { __decorate } from "tslib";
+import { SelectAllRequest } from './select-all.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+import * as i2 from "../../f-draggable";
+let SelectAllExecution = class SelectAllExecution {
+    constructor(fDataContext, fDraggableDataContext) {
+        this.fDataContext = fDataContext;
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(request) {
+        this.fDraggableDataContext.selectedItems.forEach((x) => {
+            x.deselect();
+        });
+        this.fDraggableDataContext.selectedItems = [];
+        this.fDataContext.fNodes.forEach((x) => {
+            x.select();
+            this.fDraggableDataContext.selectedItems.push(x);
+        });
+        this.fDataContext.fConnections.forEach((x) => {
+            x.select();
+            this.fDraggableDataContext.selectedItems.push(x);
+        });
+        this.fDraggableDataContext.isSelectedChanged = true;
+    }
+};
+SelectAllExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAllExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectAllExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAllExecution });
+SelectAllExecution = __decorate([
+    FExecutionRegister(SelectAllRequest)
+], SelectAllExecution);
+export { SelectAllExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAllExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/domain/select-and-update-node-layer/select-and-update-node-layer.execution.js

@@ -0,0 +1,35 @@
+import { __decorate } from "tslib";
+import { SelectAndUpdateNodeLayerRequest } from './select-and-update-node-layer.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import { UpdateItemAndChildrenLayersRequest } from '../update-item-and-children-layers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-draggable";
+import * as i2 from "../../infrastructure";
+let SelectAndUpdateNodeLayerExecution = class SelectAndUpdateNodeLayerExecution {
+    constructor(fDraggableDataContext, fMediator) {
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        this.selectNodeIfNotSelected(request.node);
+        this.fMediator.send(new UpdateItemAndChildrenLayersRequest(request.node, request.node.hostElement.parentElement));
+    }
+    selectNodeIfNotSelected(node) {
+        if (!this.fDraggableDataContext.selectedItems.includes(node) && !node.fSelectionDisabled) {
+            this.fDraggableDataContext.selectedItems.push(node);
+            node.select();
+            this.fDraggableDataContext.isSelectedChanged = true;
+        }
+    }
+};
+SelectAndUpdateNodeLayerExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAndUpdateNodeLayerExecution, deps: [{ token: i1.FDraggableDataContext }, { token: i2.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectAndUpdateNodeLayerExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAndUpdateNodeLayerExecution });
+SelectAndUpdateNodeLayerExecution = __decorate([
+    FExecutionRegister(SelectAndUpdateNodeLayerRequest)
+], SelectAndUpdateNodeLayerExecution);
+export { SelectAndUpdateNodeLayerExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectAndUpdateNodeLayerExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FDraggableDataContext }, { type: i2.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022/domain/select-and-update-node-layer/select-and-update-node-layer.request.mjs → esm2015/domain/select-and-update-node-layer/select-and-update-node-layer.request.js}

@@ -1,7 +1,6 @@
 export class SelectAndUpdateNodeLayerRequest {
-    node;
     constructor(node) {
         this.node = node;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWFuZC11cGRhdGUtbm9kZS1sYXllci5yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9kb21haW4vc2VsZWN0LWFuZC11cGRhdGUtbm9kZS1sYXllci9zZWxlY3QtYW5kLXVwZGF0ZS1ub2RlLWxheWVyLnJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLCtCQUErQjtJQUdqQztJQURULFlBQ1MsSUFBZTtRQUFmLFNBQUksR0FBSixJQUFJLENBQVc7SUFFeEIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRk5vZGVCYXNlIH0gZnJvbSAnLi4vLi4vZi1ub2RlJztcblxuZXhwb3J0IGNsYXNzIFNlbGVjdEFuZFVwZGF0ZU5vZGVMYXllclJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBub2RlOiBGTm9kZUJhc2VcbiAgKSB7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWFuZC11cGRhdGUtbm9kZS1sYXllci5yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9kb21haW4vc2VsZWN0LWFuZC11cGRhdGUtbm9kZS1sYXllci9zZWxlY3QtYW5kLXVwZGF0ZS1ub2RlLWxheWVyLnJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLCtCQUErQjtJQUUxQyxZQUNTLElBQWU7UUFBZixTQUFJLEdBQUosSUFBSSxDQUFXO0lBRXhCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZOb2RlQmFzZSB9IGZyb20gJy4uLy4uL2Ytbm9kZSc7XG5cbmV4cG9ydCBjbGFzcyBTZWxlY3RBbmRVcGRhdGVOb2RlTGF5ZXJSZXF1ZXN0IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgbm9kZTogRk5vZGVCYXNlXG4gICkge1xuICB9XG59XG4iXX0=

package/esm2015/domain/sort-item-layers/sort-item-layers.execution.js

@@ -0,0 +1,30 @@
+import { __decorate } from "tslib";
+import { SortItemLayersRequest } from './sort-item-layers.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import { SortNodeLayersRequest } from './sort-node-layers-by-groups';
+import { SortItemsByParentRequest } from './sort-items-by-parent';
+import * as i0 from "@angular/core";
+import * as i1 from "../../infrastructure";
+import * as i2 from "../../f-storage";
+let SortItemLayersExecution = class SortItemLayersExecution {
+    constructor(fMediator, fComponentsStore) {
+        this.fMediator = fMediator;
+        this.fComponentsStore = fComponentsStore;
+    }
+    handle(request) {
+        this.fMediator.send(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fGroupsContainer.nativeElement));
+        this.fMediator.send(new SortNodeLayersRequest());
+        this.fMediator.send(new SortItemsByParentRequest(this.fComponentsStore.fCanvas.fNodesContainer.nativeElement));
+    }
+};
+SortItemLayersExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SortItemLayersExecution, deps: [{ token: i1.FFlowMediator }, { token: i2.FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable });
+SortItemLayersExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SortItemLayersExecution });
+SortItemLayersExecution = __decorate([
+    FExecutionRegister(SortItemLayersRequest)
+], SortItemLayersExecution);
+export { SortItemLayersExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SortItemLayersExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FFlowMediator }, { type: i2.FComponentsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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