@foblex/flow 12.2.4 → 12.3.5

package/esm2022/domain/intersections/rounded-rect/rounded-rect.mjs

@@ -0,0 +1,45 @@
+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) {
+        const { x, y, width, height } = element.getBoundingClientRect();
+        return this.setRadiusFromElement(new RoundedRect(x, y, width, height), element);
+    }
+    static setRadiusFromElement(rect, element) {
+        rect.radius1 = parseFloat(element.style.borderTopLeftRadius) || 0;
+        rect.radius2 = parseFloat(element.style.borderTopRightRadius) || 0;
+        rect.radius3 = parseFloat(element.style.borderBottomRightRadius) || 0;
+        rect.radius4 = parseFloat(element.style.borderBottomLeftRadius) || 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/esm2022/domain/is-connection-under-node/index.mjs

@@ -0,0 +1,2 @@
+export * from './is-connection-under-node.execution';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9pcy1jb25uZWN0aW9uLXVuZGVyLW5vZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQ0FBc0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaXMtY29ubmVjdGlvbi11bmRlci1ub2RlLmV4ZWN1dGlvbic7XG4iXX0=

package/esm2022/domain/is-connection-under-node/is-connection-under-node.execution.mjs

@@ -0,0 +1,80 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import { IsConnectionUnderNodeRequest } from './is-connection-under-node.request';
+import { EFDraggableType } 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";
+import * as i4 from "../get-outgoing-connections.handler";
+import * as i5 from "../get-incoming-connections.handler";
+let IsConnectionUnderNodeExecution = class IsConnectionUnderNodeExecution {
+    get transform() {
+        return this.fComponentsStore.fCanvas.transform;
+    }
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    constructor(fComponentsStore, fDraggableDataContext, fMediator, getOutgoingConnectionsHandler, getIncomingConnectionsHandler) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+        this.getOutgoingConnectionsHandler = getOutgoingConnectionsHandler;
+        this.getIncomingConnectionsHandler = getIncomingConnectionsHandler;
+    }
+    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].type === EFDraggableType.NODE;
+        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;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: IsConnectionUnderNodeExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FFlowMediator }, { token: i4.GetOutgoingConnectionsHandler }, { token: i5.GetIncomingConnectionsHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: IsConnectionUnderNodeExecution }); }
+};
+IsConnectionUnderNodeExecution = __decorate([
+    FExecutionRegister(IsConnectionUnderNodeRequest)
+], IsConnectionUnderNodeExecution);
+export { IsConnectionUnderNodeExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: IsConnectionUnderNodeExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FFlowMediator }, { type: i4.GetOutgoingConnectionsHandler }, { type: i5.GetIncomingConnectionsHandler }] });
+//# 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":";AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAA6B,MAAM,sBAAsB,CAAC;AACrF,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAElF,OAAO,EAAE,eAAe,EAA0C,MAAM,mBAAmB,CAAC;AAM5F,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;;;;;;;AAInE,IAAM,8BAA8B,GAApC,MAAM,8BAA8B;IAEzC,IAAY,SAAS;QACnB,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAQ,CAAC,SAAS,CAAC;IAClD,CAAC;IAED,IAAY,QAAQ;QAClB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAM,CAAC,WAAW,CAAC;IAClD,CAAC;IAED,YACY,gBAAkC,EAClC,qBAA4C,EAC5C,SAAwB,EACxB,6BAA4D,EAC5D,6BAA4D;QAJ5D,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,cAAS,GAAT,SAAS,CAAe;QACxB,kCAA6B,GAA7B,6BAA6B,CAA+B;QAC5D,kCAA6B,GAA7B,6BAA6B,CAA+B;IAExE,CAAC;IAEM,MAAM;QAEX,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACtC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QAED,MAAM,KAAK,GAAI,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAE,CAAC,CAAsB,CAAC,KAAK,CAAC;QAExF,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAElD,MAAM,yBAAyB,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;QAE/E,MAAM,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7E,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,wBAAwB,IAAI,aAAa,CAAC,MAAM,IAAI,CAAC,yBAAyB,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;YAC3G,MAAM,MAAM,GAAG,aAAa,CAAE,CAAC,CAAE,CAAC;YAClC,MAAM,KAAK,GAAG,YAAY,CAAE,CAAC,CAAE,CAAC;YAChC,MAAM,mBAAmB,GAAG,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAE,MAAM,CAAE,CAAC,CAAC;YAClF,MAAM,mBAAmB,GAAG,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAE,KAAK,CAAE,CAAC,CAAC;YACjF,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACzE,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;gBACzD,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;oBACvB,yBAAyB;gBAC3B,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,cAAc;QACpB,MAAM,MAAM,GACR,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC;YACtD,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAE,CAAC,CAAE,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI,CAAC;QAEjF,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,iBAAiB,CAAC,IAAe;QACvC,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;IACtF,CAAC;IAEO,gBAAgB,CAAC,IAAe;QACtC,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;IACrF,CAAC;IAEO,wBAAwB,CAAC,IAAe;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAQ,IAAI,2BAA2B,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC/F,OAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;YACtD,wHAAwH;YACvH,OAAO,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAA;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;+GAzEU,8BAA8B;mHAA9B,8BAA8B;;AAA9B,8BAA8B;IAD1C,kBAAkB,CAAC,4BAA4B,CAAC;GACpC,8BAA8B,CA0E1C;;4FA1EY,8BAA8B;kBAF1C,UAAU","sourcesContent":["import { 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 { EFDraggableType, FDraggableDataContext, NodeDragHandler } from '../../f-draggable';\nimport { GetOutgoingConnectionsHandler } from '../get-outgoing-connections.handler';\nimport { GetIncomingConnectionsHandler } from '../get-incoming-connections.handler';\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 ].type === EFDraggableType.NODE;\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"]}

package/esm2022/domain/is-connection-under-node/is-connection-under-node.request.mjs

@@ -0,0 +1,3 @@
+export class IsConnectionUnderNodeRequest {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtY29ubmVjdGlvbi11bmRlci1ub2RlLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9pcy1jb25uZWN0aW9uLXVuZGVyLW5vZGUvaXMtY29ubmVjdGlvbi11bmRlci1ub2RlLnJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLDRCQUE0QjtDQUV4QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBJc0Nvbm5lY3Rpb25VbmRlck5vZGVSZXF1ZXN0IHtcblxufVxuIl19

package/esm2022/domain/is-element-with-class.mjs

@@ -0,0 +1,8 @@
+export function isElementWithClass(element, cls) {
+    const target = getClosestDragHandle(element, cls);
+    return !!target && !target.classList.contains(cls + '-disabled');
+}
+function getClosestDragHandle(element, cls) {
+    return element.closest(cls);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZWxlbWVudC13aXRoLWNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9kb21haW4vaXMtZWxlbWVudC13aXRoLWNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxPQUFpQyxFQUFFLEdBQVc7SUFDL0UsTUFBTSxNQUFNLEdBQUcsb0JBQW9CLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ2xELE9BQU8sQ0FBQyxDQUFDLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLEdBQUcsR0FBRyxXQUFXLENBQUMsQ0FBQztBQUNuRSxDQUFDO0FBRUQsU0FBUyxvQkFBb0IsQ0FBQyxPQUFpQyxFQUFFLEdBQVc7SUFDMUUsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBZ0IsQ0FBQztBQUM3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGlzRWxlbWVudFdpdGhDbGFzcyhlbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQsIGNsczogc3RyaW5nKTogYm9vbGVhbiB7XG4gIGNvbnN0IHRhcmdldCA9IGdldENsb3Nlc3REcmFnSGFuZGxlKGVsZW1lbnQsIGNscyk7XG4gIHJldHVybiAhIXRhcmdldCAmJiAhdGFyZ2V0LmNsYXNzTGlzdC5jb250YWlucyhjbHMgKyAnLWRpc2FibGVkJyk7XG59XG5cbmZ1bmN0aW9uIGdldENsb3Nlc3REcmFnSGFuZGxlKGVsZW1lbnQ6IEhUTUxFbGVtZW50IHwgU1ZHRWxlbWVudCwgY2xzOiBzdHJpbmcpOiBIVE1MRWxlbWVudCB7XG4gIHJldHVybiBlbGVtZW50LmNsb3Nlc3QoY2xzKSBhcyBIVE1MRWxlbWVudDtcbn1cbiJdfQ==

package/esm2022/domain/providers.mjs

@@ -1,35 +1,41 @@
 import { GetIncomingConnectionsHandler } from './get-incoming-connections.handler';
 import { GetOutgoingConnectionsHandler } from './get-outgoing-connections.handler';
 import { GetConnectionHandler } from './get-connection.handler';
-import { GetConnectionVectorHandler } from './get-connection-vector';
-import { RedrawConnectionsHandler } from './redraw-connections';
-import { GetOutputRectInFlowHandler } from './get-output-rect-in-flow';
-import { GetSelectionHandler } from './get-selection';
-import { SelectAllHandler } from './select-all';
-import { ClearSelectionHandler } from './clear-selection';
-import { GetNodesRectHandler } from './get-nodes-rect';
-import { GetElementRectInFlowHandler } from './get-element-rect-in-flow';
-import { GetInputRectInFlowHandler } from './get-input-rect-in-flow';
-import { SelectHandler } from './select';
-import { UpdateItemLayerHandler } from './update-item-layer';
-import { GetPositionInFlowHandler } from './get-position-in-flow';
-import { CreateConnectionMarkersHandler } from './create-connection-markers';
+import { GetConnectionLineExecution } from './get-connection-line';
+import { RedrawConnectionsExecution } from './redraw-connections';
+import { GetOutputRectInFlowExecution } from './get-output-rect-in-flow';
+import { GetSelectionExecution } from './get-selection';
+import { SelectAllExecution } from './select-all';
+import { ClearSelectionExecution } from './clear-selection';
+import { GetNodesRectExecution } from './get-nodes-rect';
+import { GetElementRectInFlowExecution } from './get-element-rect-in-flow';
+import { GetInputRectInFlowExecution } from './get-input-rect-in-flow';
+import { SelectExecution } from './select';
+import { UpdateItemLayerExecution } from './update-item-layer';
+import { GetPositionInFlowExecution } from './get-position-in-flow';
+import { CreateConnectionMarkersExecution } from './create-connection-markers';
+import { GetCanBeSelectedItemsExecution } from './get-can-be-selected-items';
+import { IsConnectionUnderNodeExecution } from './is-connection-under-node';
+import { SelectAndUpdateNodeLayerExecution } from './select-and-update-node-layer';
 export const COMMON_PROVIDERS = [
-    ClearSelectionHandler,
-    CreateConnectionMarkersHandler,
-    GetConnectionVectorHandler,
-    GetElementRectInFlowHandler,
-    GetNodesRectHandler,
-    GetOutputRectInFlowHandler,
-    GetPositionInFlowHandler,
-    GetSelectionHandler,
-    RedrawConnectionsHandler,
-    SelectHandler,
-    SelectAllHandler,
-    UpdateItemLayerHandler,
+    ClearSelectionExecution,
+    CreateConnectionMarkersExecution,
+    GetCanBeSelectedItemsExecution,
+    GetConnectionLineExecution,
+    GetElementRectInFlowExecution,
+    GetNodesRectExecution,
+    GetOutputRectInFlowExecution,
+    GetPositionInFlowExecution,
+    GetSelectionExecution,
+    IsConnectionUnderNodeExecution,
+    RedrawConnectionsExecution,
+    SelectExecution,
+    SelectAllExecution,
+    SelectAndUpdateNodeLayerExecution,
+    UpdateItemLayerExecution,
     GetConnectionHandler,
-    GetInputRectInFlowHandler,
+    GetInputRectInFlowExecution,
     GetIncomingConnectionsHandler,
     GetOutgoingConnectionsHandler,
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/redraw-connections/index.mjs

@@ -1,3 +1,3 @@
-export * from './redraw-connections.handler';
+export * from './redraw-connections.execution';
 export * from './redraw-connections-request';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9yZWRyYXctY29ubmVjdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUU3QyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZWRyYXctY29ubmVjdGlvbnMuaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vcmVkcmF3LWNvbm5lY3Rpb25zLXJlcXVlc3QnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9yZWRyYXctY29ubmVjdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZWRyYXctY29ubmVjdGlvbnMuZXhlY3V0aW9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9yZWRyYXctY29ubmVjdGlvbnMtcmVxdWVzdCc7XG4iXX0=

package/esm2022/domain/redraw-connections/redraw-connections.execution.mjs

@@ -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));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RedrawConnectionsExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RedrawConnectionsExecution }); }
+};
+RedrawConnectionsExecution = __decorate([
+    FExecutionRegister(RedrawConnectionsRequest)
+], RedrawConnectionsExecution);
+export { RedrawConnectionsExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: RedrawConnectionsExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FComponentsStore }, { type: i2.FFlowMediator }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/select/index.mjs

@@ -1,3 +1,3 @@
-export * from './select.handler';
+export * from './select.execution';
 export * from './select.request';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUVqQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZWxlY3QuaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LnJlcXVlc3QnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUVuQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZWxlY3QuZXhlY3V0aW9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3QucmVxdWVzdCc7XG4iXX0=

package/esm2022/domain/select/select.execution.mjs

@@ -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.fConnectionId === key);
+            if (connection) {
+                connection.select();
+                this.fDraggableDataContext.selectedItems.push(connection);
+            }
+        });
+        this.fDraggableDataContext.isSelectedChanged = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectExecution }); }
+};
+SelectExecution = __decorate([
+    FExecutionRegister(SelectRequest)
+], SelectExecution);
+export { SelectExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/select-all/index.mjs

@@ -1,3 +1,3 @@
-export * from './select-all.handler';
+export * from './select-all.execution';
 export * from './select-all.request';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QtYWxsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFFckMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LWFsbC5oYW5kbGVyJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3QtYWxsLnJlcXVlc3QnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QtYWxsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LWFsbC5leGVjdXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdC1hbGwucmVxdWVzdCc7XG4iXX0=

package/esm2022/domain/select-all/select-all.execution.mjs

@@ -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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAllExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAllExecution }); }
+};
+SelectAllExecution = __decorate([
+    FExecutionRegister(SelectAllRequest)
+], SelectAllExecution);
+export { SelectAllExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAllExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWFsbC5leGVjdXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QtYWxsL3NlbGVjdC1hbGwuZXhlY3V0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRzNDLE9BQU8sRUFBRSxrQkFBa0IsRUFBYyxNQUFNLHNCQUFzQixDQUFDOzs7O0FBSS9ELElBQU0sa0JBQWtCLEdBQXhCLE1BQU0sa0JBQWtCO0lBRTdCLFlBQ1UsWUFBOEIsRUFDOUIscUJBQTRDO1FBRDVDLGlCQUFZLEdBQVosWUFBWSxDQUFrQjtRQUM5QiwwQkFBcUIsR0FBckIscUJBQXFCLENBQXVCO0lBRXRELENBQUM7SUFFTSxNQUFNLENBQUMsT0FBeUI7UUFDckMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUNyRCxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDZixDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxhQUFhLEdBQUcsRUFBRSxDQUFDO1FBQzlDLElBQUksQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQ3JDLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNYLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELENBQUMsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7WUFDM0MsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ1gsSUFBSSxDQUFDLHFCQUFxQixDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDbkQsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMscUJBQXFCLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDO0lBQ3RELENBQUM7K0dBdEJVLGtCQUFrQjttSEFBbEIsa0JBQWtCOztBQUFsQixrQkFBa0I7SUFEOUIsa0JBQWtCLENBQUMsZ0JBQWdCLENBQUM7R0FDeEIsa0JBQWtCLENBdUI5Qjs7NEZBdkJZLGtCQUFrQjtrQkFGOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElIYW5kbGVyIH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IFNlbGVjdEFsbFJlcXVlc3QgfSBmcm9tICcuL3NlbGVjdC1hbGwucmVxdWVzdCc7XG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGRHJhZ2dhYmxlRGF0YUNvbnRleHQgfSBmcm9tICcuLi8uLi9mLWRyYWdnYWJsZSc7XG5pbXBvcnQgeyBGQ29tcG9uZW50c1N0b3JlIH0gZnJvbSAnLi4vLi4vZi1zdG9yYWdlJztcbmltcG9ydCB7IEZFeGVjdXRpb25SZWdpc3RlciwgSUV4ZWN1dGlvbiB9IGZyb20gJy4uLy4uL2luZnJhc3RydWN0dXJlJztcblxuQEluamVjdGFibGUoKVxuQEZFeGVjdXRpb25SZWdpc3RlcihTZWxlY3RBbGxSZXF1ZXN0KVxuZXhwb3J0IGNsYXNzIFNlbGVjdEFsbEV4ZWN1dGlvbiBpbXBsZW1lbnRzIElFeGVjdXRpb248U2VsZWN0QWxsUmVxdWVzdCwgdm9pZD4ge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgZkRhdGFDb250ZXh0OiBGQ29tcG9uZW50c1N0b3JlLFxuICAgIHByaXZhdGUgZkRyYWdnYWJsZURhdGFDb250ZXh0OiBGRHJhZ2dhYmxlRGF0YUNvbnRleHQsXG4gICkge1xuICB9XG5cbiAgcHVibGljIGhhbmRsZShyZXF1ZXN0OiBTZWxlY3RBbGxSZXF1ZXN0KTogdm9pZCB7XG4gICAgdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuc2VsZWN0ZWRJdGVtcy5mb3JFYWNoKCh4KSA9PiB7XG4gICAgICB4LmRlc2VsZWN0KCk7XG4gICAgfSk7XG4gICAgdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuc2VsZWN0ZWRJdGVtcyA9IFtdO1xuICAgIHRoaXMuZkRhdGFDb250ZXh0LmZOb2Rlcy5mb3JFYWNoKCh4KSA9PiB7XG4gICAgICB4LnNlbGVjdCgpO1xuICAgICAgdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuc2VsZWN0ZWRJdGVtcy5wdXNoKHgpO1xuICAgIH0pO1xuICAgIHRoaXMuZkRhdGFDb250ZXh0LmZDb25uZWN0aW9ucy5mb3JFYWNoKCh4KSA9PiB7XG4gICAgICB4LnNlbGVjdCgpO1xuICAgICAgdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuc2VsZWN0ZWRJdGVtcy5wdXNoKHgpO1xuICAgIH0pO1xuICAgIHRoaXMuZkRyYWdnYWJsZURhdGFDb250ZXh0LmlzU2VsZWN0ZWRDaGFuZ2VkID0gdHJ1ZTtcbiAgfVxufVxuIl19

package/esm2022/domain/select-and-update-node-layer/index.mjs

@@ -0,0 +1,3 @@
+export * from './select-and-update-node-layer.execution';
+export * from './select-and-update-node-layer.request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9zZWxlY3QtYW5kLXVwZGF0ZS1ub2RlLWxheWVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMENBQTBDLENBQUM7QUFFekQsY0FBYyx3Q0FBd0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LWFuZC11cGRhdGUtbm9kZS1sYXllci5leGVjdXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdC1hbmQtdXBkYXRlLW5vZGUtbGF5ZXIucmVxdWVzdCc7XG4iXX0=

package/esm2022/domain/select-and-update-node-layer/select-and-update-node-layer.execution.mjs

@@ -0,0 +1,37 @@
+import { __decorate } from "tslib";
+import { SelectAndUpdateNodeLayerRequest } from './select-and-update-node-layer.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import { UpdateItemLayerRequest } from '../update-item-layer';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-draggable";
+import * as i2 from "../../f-storage";
+import * as i3 from "../../infrastructure";
+let SelectAndUpdateNodeLayerExecution = class SelectAndUpdateNodeLayerExecution {
+    constructor(fDraggableDataContext, fComponentsStore, fMediator) {
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        this.selectNodeIfNotSelected(request.node);
+        this.fMediator.send(new UpdateItemLayerRequest(request.node, this.fComponentsStore.fCanvas.fNodesContainer.nativeElement));
+    }
+    selectNodeIfNotSelected(node) {
+        if (!this.fDraggableDataContext.selectedItems.includes(node) && !node.fSelectionDisabled) {
+            this.fDraggableDataContext.selectedItems.push(node);
+            node.select();
+            this.fDraggableDataContext.isSelectedChanged = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAndUpdateNodeLayerExecution, deps: [{ token: i1.FDraggableDataContext }, { token: i2.FComponentsStore }, { token: i3.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAndUpdateNodeLayerExecution }); }
+};
+SelectAndUpdateNodeLayerExecution = __decorate([
+    FExecutionRegister(SelectAndUpdateNodeLayerRequest)
+], SelectAndUpdateNodeLayerExecution);
+export { SelectAndUpdateNodeLayerExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SelectAndUpdateNodeLayerExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FDraggableDataContext }, { type: i2.FComponentsStore }, { type: i3.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

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

package/esm2022/domain/update-item-layer/index.mjs

@@ -1,3 +1,3 @@
-export * from './update-item-layer.handler';
+export * from './update-item-layer.execution';
 export * from './update-item-layer.request';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi91cGRhdGUtaXRlbS1sYXllci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3VwZGF0ZS1pdGVtLWxheWVyLmhhbmRsZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL3VwZGF0ZS1pdGVtLWxheWVyLnJlcXVlc3QnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi91cGRhdGUtaXRlbS1sYXllci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBRTlDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3VwZGF0ZS1pdGVtLWxheWVyLmV4ZWN1dGlvbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vdXBkYXRlLWl0ZW0tbGF5ZXIucmVxdWVzdCc7XG4iXX0=

package/esm2022/domain/update-item-layer/update-item-layer.execution.mjs

@@ -0,0 +1,29 @@
+import { __decorate } from "tslib";
+import { UpdateItemLayerRequest } from './update-item-layer.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '../../infrastructure';
+import * as i0 from "@angular/core";
+let UpdateItemLayerExecution = class UpdateItemLayerExecution {
+    handle(request) {
+        const elements = Array.from(request.itemContainer.children);
+        const elementsCount = elements.length;
+        const targetIndex = elements.findIndex((x) => x === request.item.hostElement);
+        if (targetIndex !== elementsCount - 1) {
+            const afterElements = elements.splice(targetIndex + 1);
+            afterElements.forEach((x) => {
+                request.itemContainer.removeChild(x);
+                request.itemContainer.insertBefore(x, request.item.hostElement);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: UpdateItemLayerExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: UpdateItemLayerExecution }); }
+};
+UpdateItemLayerExecution = __decorate([
+    FExecutionRegister(UpdateItemLayerRequest)
+], UpdateItemLayerExecution);
+export { UpdateItemLayerExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: UpdateItemLayerExecution, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/errors/create-error-class.mjs

@@ -1,11 +1,10 @@
 export function createErrorClass(impl) {
     const _super = (instance) => {
         Error.call(instance);
-        // instance.stack = new Error().stack;
     };
     const constructor = impl(_super);
     constructor.prototype = Object.create(Error.prototype);
     constructor.prototype.constructor = constructor;
     return constructor;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWVycm9yLWNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9lcnJvcnMvY3JlYXRlLWVycm9yLWNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBSSxJQUEwQjtJQUM1RCxNQUFNLE1BQU0sR0FBRyxDQUFDLFFBQWEsRUFBRSxFQUFFO1FBQy9CLEtBQUssQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDckIsc0NBQXNDO0lBQ3hDLENBQUMsQ0FBQztJQUVGLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqQyxXQUFXLENBQUMsU0FBUyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3ZELFdBQVcsQ0FBQyxTQUFTLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztJQUNoRCxPQUFPLFdBQVcsQ0FBQztBQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZUVycm9yQ2xhc3M8VD4oaW1wbDogKF9zdXBlcjogYW55KSA9PiBhbnkpOiBUIHtcbiAgY29uc3QgX3N1cGVyID0gKGluc3RhbmNlOiBhbnkpID0+IHtcbiAgICBFcnJvci5jYWxsKGluc3RhbmNlKTtcbiAgICAvLyBpbnN0YW5jZS5zdGFjayA9IG5ldyBFcnJvcigpLnN0YWNrO1xuICB9O1xuXG4gIGNvbnN0IGNvbnN0cnVjdG9yID0gaW1wbChfc3VwZXIpO1xuICBjb25zdHJ1Y3Rvci5wcm90b3R5cGUgPSBPYmplY3QuY3JlYXRlKEVycm9yLnByb3RvdHlwZSk7XG4gIGNvbnN0cnVjdG9yLnByb3RvdHlwZS5jb25zdHJ1Y3RvciA9IGNvbnN0cnVjdG9yO1xuICByZXR1cm4gY29uc3RydWN0b3I7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWVycm9yLWNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9lcnJvcnMvY3JlYXRlLWVycm9yLWNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBSSxJQUEwQjtJQUM1RCxNQUFNLE1BQU0sR0FBRyxDQUFDLFFBQWEsRUFBRSxFQUFFO1FBQy9CLEtBQUssQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdkIsQ0FBQyxDQUFDO0lBRUYsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2pDLFdBQVcsQ0FBQyxTQUFTLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDdkQsV0FBVyxDQUFDLFNBQVMsQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO0lBQ2hELE9BQU8sV0FBVyxDQUFDO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gY3JlYXRlRXJyb3JDbGFzczxUPihpbXBsOiAoX3N1cGVyOiBhbnkpID0+IGFueSk6IFQge1xuICBjb25zdCBfc3VwZXIgPSAoaW5zdGFuY2U6IGFueSkgPT4ge1xuICAgIEVycm9yLmNhbGwoaW5zdGFuY2UpO1xuICB9O1xuXG4gIGNvbnN0IGNvbnN0cnVjdG9yID0gaW1wbChfc3VwZXIpO1xuICBjb25zdHJ1Y3Rvci5wcm90b3R5cGUgPSBPYmplY3QuY3JlYXRlKEVycm9yLnByb3RvdHlwZSk7XG4gIGNvbnN0cnVjdG9yLnByb3RvdHlwZS5jb25zdHJ1Y3RvciA9IGNvbnN0cnVjdG9yO1xuICByZXR1cm4gY29uc3RydWN0b3I7XG59XG4iXX0=

package/esm2022/f-backgroud/f-background-base.mjs

@@ -2,10 +2,10 @@ import { Directive, InjectionToken } from '@angular/core';
 import * as i0 from "@angular/core";
 export const F_BACKGROUND = new InjectionToken('F_BACKGROUND');
 export class FBackgroundBase {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FBackgroundBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.1", type: FBackgroundBase, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: FBackgroundBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.11", type: FBackgroundBase, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FBackgroundBase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: FBackgroundBase, decorators: [{
             type: Directive
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1iYWNrZ3JvdW5kLWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtYmFja2dyb3VkL2YtYmFja2dyb3VuZC1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUcxRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLGNBQWMsQ0FBQyxDQUFDO0FBR2hGLE1BQU0sT0FBZ0IsZUFBZTs4R0FBZixlQUFlO2tHQUFmLGVBQWU7OzJGQUFmLGVBQWU7a0JBRHBDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQsIElUcmFuc2Zvcm1Nb2RlbCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGX0JBQ0tHUk9VTkQgPSBuZXcgSW5qZWN0aW9uVG9rZW48RkJhY2tncm91bmRCYXNlPignRl9CQUNLR1JPVU5EJyk7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZCYWNrZ3JvdW5kQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3QgaXNCYWNrZ3JvdW5kRWxlbWVudChlbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQpOiBib29sZWFuO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBzZXRUcmFuc2Zvcm0odHJhbnNmb3JtOiBJVHJhbnNmb3JtTW9kZWwpOiB2b2lkO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1iYWNrZ3JvdW5kLWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtYmFja2dyb3VkL2YtYmFja2dyb3VuZC1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUcxRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLGNBQWMsQ0FBQyxDQUFDO0FBR2hGLE1BQU0sT0FBZ0IsZUFBZTsrR0FBZixlQUFlO21HQUFmLGVBQWU7OzRGQUFmLGVBQWU7a0JBRHBDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQsIElUcmFuc2Zvcm1Nb2RlbCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGX0JBQ0tHUk9VTkQgPSBuZXcgSW5qZWN0aW9uVG9rZW48RkJhY2tncm91bmRCYXNlPignRl9CQUNLR1JPVU5EJyk7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZCYWNrZ3JvdW5kQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3QgaXNCYWNrZ3JvdW5kRWxlbWVudChlbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQpOiBib29sZWFuO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBzZXRUcmFuc2Zvcm0odHJhbnNmb3JtOiBJVHJhbnNmb3JtTW9kZWwpOiB2b2lkO1xufVxuIl19