@foblex/flow 12.6.2 → 12.6.3

package/esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/create-move-nodes-drag-model-from-selection.execution.js

@@ -0,0 +1,90 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { CreateMoveNodesDragModelFromSelectionRequest } from './create-move-nodes-drag-model-from-selection.request';
+import { FExecutionRegister } from '../../../infrastructure';
+import { NodeDragHandler } from '../node.drag-handler';
+import { GetNodeMoveRestrictionsRequest } from './domain/get-node-move-restrictions';
+import { PutOutputConnectionHandlersToArrayRequest } from './domain/put-output-connection-handlers-to-array';
+import { PutInputConnectionHandlersToArrayRequest } from './domain/put-input-connection-handlers-to-array';
+import { NodeResizeByChildDragHandler } from '../node-resize-by-child.drag-handler';
+import { GetParentNodesRequest, IsArrayHasParentNodeRequest } from '../../domain';
+import { GetDeepChildrenNodesAndGroupsRequest } from '../../../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-storage";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../../../infrastructure";
+let CreateMoveNodesDragModelFromSelectionExecution = class CreateMoveNodesDragModelFromSelectionExecution {
+    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        const itemsToDrag = this.getNodesWithRestrictions(this.getSelectedNodes());
+        return this.getDragHandlersWithConnections(this.getDragHandlersFromNodes(itemsToDrag), this.getAllOutputIds(itemsToDrag), this.getAllInputIds(itemsToDrag));
+    }
+    getSelectedNodes() {
+        return this.fDraggableDataContext.selectedItems
+            .map((x) => this.fComponentsStore.findNode(x.hostElement))
+            .filter((x) => !!x);
+    }
+    getNodesWithRestrictions(selectedNodes) {
+        const result = [];
+        selectedNodes.forEach((x) => {
+            const hasParentNodeInSelected = this.fMediator.send(new IsArrayHasParentNodeRequest(x, selectedNodes));
+            const restrictions = this.fMediator.send(new GetNodeMoveRestrictionsRequest(x, hasParentNodeInSelected));
+            const parentNodes = this.fMediator.send(new GetParentNodesRequest(x));
+            result.push(Object.assign({ node: x, parentNodes }, restrictions), ...this.getChildrenItemsToDrag(x, restrictions));
+        });
+        return result;
+    }
+    getChildrenItemsToDrag(node, restrictions) {
+        return this.getChildrenNodes(node.fId).map((x) => (Object.assign({ node: x }, restrictions)));
+    }
+    getChildrenNodes(fId) {
+        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId));
+    }
+    getAllOutputIds(items) {
+        return items.reduce((result, item) => {
+            const ids = this.getOutputsForNode(item.node).map((x) => x.id);
+            return [...result, ...ids];
+        }, []);
+    }
+    getOutputsForNode(node) {
+        return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
+    }
+    getAllInputIds(items) {
+        return items.reduce((result, item) => {
+            const ids = this.getInputsForNode(item.node).map((x) => x.id);
+            return [...result, ...ids];
+        }, []);
+    }
+    getInputsForNode(node) {
+        return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
+    }
+    getDragHandlersFromNodes(items) {
+        let result = [];
+        items.forEach((node) => {
+            result.push(new NodeDragHandler(this.fDraggableDataContext, node.node, node.min, node.max), ...(node.parentNodes || []).map((parent) => new NodeResizeByChildDragHandler(this.fDraggableDataContext)));
+        });
+        return result;
+    }
+    getDragHandlersWithConnections(handlers, outputIds, inputIds) {
+        let result = handlers;
+        handlers.filter((x) => x instanceof NodeDragHandler).forEach((dragHandler) => {
+            this.fMediator.send(new PutOutputConnectionHandlersToArrayRequest(dragHandler, inputIds, result));
+            this.fMediator.send(new PutInputConnectionHandlersToArrayRequest(dragHandler, outputIds, result));
+        });
+        return result;
+    }
+};
+CreateMoveNodesDragModelFromSelectionExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CreateMoveNodesDragModelFromSelectionExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+CreateMoveNodesDragModelFromSelectionExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CreateMoveNodesDragModelFromSelectionExecution });
+CreateMoveNodesDragModelFromSelectionExecution = __decorate([
+    FExecutionRegister(CreateMoveNodesDragModelFromSelectionRequest)
+], CreateMoveNodesDragModelFromSelectionExecution);
+export { CreateMoveNodesDragModelFromSelectionExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CreateMoveNodesDragModelFromSelectionExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-move-nodes-drag-model-from-selection.execution.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/node/create-move-nodes-drag-model-from-selection/create-move-nodes-drag-model-from-selection.execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { CreateMoveNodesDragModelFromSelectionRequest } from './create-move-nodes-drag-model-from-selection.request';\nimport { FExecutionRegister, FFlowMediator, IExecution } from '../../../infrastructure';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { IDraggableItem } from '../../i-draggable-item';\nimport { NodeDragHandler } from '../node.drag-handler';\nimport { FNodeBase } from '../../../f-node';\nimport { FConnectorBase } from '../../../f-connectors';\nimport { INodeWithDistanceRestrictions } from './i-node-with-distance-restrictions';\nimport { GetNodeMoveRestrictionsRequest, INodeMoveRestrictions } from './domain/get-node-move-restrictions';\nimport { PutOutputConnectionHandlersToArrayRequest } from './domain/put-output-connection-handlers-to-array';\nimport {\n  PutInputConnectionHandlersToArrayRequest\n} from './domain/put-input-connection-handlers-to-array';\nimport { NodeResizeByChildDragHandler } from '../node-resize-by-child.drag-handler';\nimport { GetParentNodesRequest, IsArrayHasParentNodeRequest } from '../../domain';\nimport { GetDeepChildrenNodesAndGroupsRequest } from '../../../domain';\n\n@Injectable()\n@FExecutionRegister(CreateMoveNodesDragModelFromSelectionRequest)\nexport class CreateMoveNodesDragModelFromSelectionExecution\n  implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, IDraggableItem[]> {\n\n  constructor(\n    private fComponentsStore: FComponentsStore,\n    private fDraggableDataContext: FDraggableDataContext,\n    private fMediator: FFlowMediator\n  ) {\n  }\n\n  public handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[] {\n    const itemsToDrag = this.getNodesWithRestrictions(this.getSelectedNodes());\n    return this.getDragHandlersWithConnections(\n      this.getDragHandlersFromNodes(itemsToDrag),\n      this.getAllOutputIds(itemsToDrag),\n      this.getAllInputIds(itemsToDrag)\n    );\n  }\n\n  private getSelectedNodes(): FNodeBase[] {\n    return this.fDraggableDataContext.selectedItems\n      .map((x) => this.fComponentsStore.findNode(x.hostElement))\n      .filter((x): x is FNodeBase => !!x);\n  }\n\n  private getNodesWithRestrictions(selectedNodes: FNodeBase[]): INodeWithDistanceRestrictions[] {\n    const result: INodeWithDistanceRestrictions[] = [];\n\n    selectedNodes.forEach((x) => {\n      const hasParentNodeInSelected = this.fMediator.send<boolean>(new IsArrayHasParentNodeRequest(x, selectedNodes));\n      const restrictions = this.fMediator.send<INodeMoveRestrictions>(new GetNodeMoveRestrictionsRequest(x, hasParentNodeInSelected));\n      const parentNodes = this.fMediator.send<FNodeBase[]>(new GetParentNodesRequest(x));\n      result.push({ node: x, parentNodes, ...restrictions }, ...this.getChildrenItemsToDrag(x, restrictions));\n    });\n\n    return result;\n  }\n\n  private getChildrenItemsToDrag(node: FNodeBase, restrictions: INodeMoveRestrictions): INodeWithDistanceRestrictions[] {\n    return this.getChildrenNodes(node.fId).map((x) => ({ node: x, ...restrictions }));\n  }\n\n  private getChildrenNodes(fId: string): FNodeBase[] {\n    return this.fMediator.send<FNodeBase[]>(new GetDeepChildrenNodesAndGroupsRequest(fId));\n  }\n\n  private getAllOutputIds(items: INodeWithDistanceRestrictions[]): string[] {\n    return items.reduce((result: string[], item: INodeWithDistanceRestrictions) => {\n      const ids = this.getOutputsForNode(item.node).map((x) => x.id);\n      return [...result, ...ids];\n    }, []);\n  }\n\n  private getOutputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private getAllInputIds(items: INodeWithDistanceRestrictions[]): string[] {\n    return items.reduce((result: string[], item: INodeWithDistanceRestrictions) => {\n      const ids = this.getInputsForNode(item.node).map((x) => x.id);\n      return [...result, ...ids];\n    }, []);\n  }\n\n  private getInputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private getDragHandlersFromNodes(items: INodeWithDistanceRestrictions[]): IDraggableItem[] {\n    let result: IDraggableItem[] = [];\n\n    items.forEach((node) => {\n      result.push(\n        new NodeDragHandler(this.fDraggableDataContext, node.node, node.min, node.max),\n        ...(node.parentNodes || []).map((parent) => new NodeResizeByChildDragHandler(this.fDraggableDataContext))\n      );\n    });\n    return result;\n  }\n\n  private getDragHandlersWithConnections(\n    handlers: IDraggableItem[], outputIds: string[], inputIds: string[]\n  ): IDraggableItem[] {\n    let result: IDraggableItem[] = handlers;\n    handlers.filter((x) => x instanceof NodeDragHandler).forEach((dragHandler) => {\n      this.fMediator.send(new PutOutputConnectionHandlersToArrayRequest(dragHandler as NodeDragHandler, inputIds, result));\n      this.fMediator.send(new PutInputConnectionHandlersToArrayRequest(dragHandler as NodeDragHandler, outputIds, result));\n    });\n    return result;\n  }\n}\n"]}

package/esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/get-node-move-restrictions/get-node-move-restrictions.execution.js

@@ -0,0 +1,44 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { GetNodeMoveRestrictionsRequest } from './get-node-move-restrictions.request';
+import { PointExtensions } from '@foblex/core';
+import { FExecutionRegister } from '../../../../../infrastructure';
+import { GetNormalizedNodeRectRequest, GetNormalizedParentNodeRectRequest } from '../../../../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../infrastructure";
+let GetNodeMoveRestrictionsExecution = class GetNodeMoveRestrictionsExecution {
+    constructor(fMediator) {
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        if (request.fNode.fParentId && !request.hasParentNodeInSelected) {
+            const fParentNodeRect = this.getParentNodeRect(request.fNode);
+            const fCurrentNodeRect = this.getCurrentNodeRect(request.fNode);
+            return {
+                min: PointExtensions.initialize(fParentNodeRect.x - fCurrentNodeRect.x, fParentNodeRect.y - fCurrentNodeRect.y),
+                max: PointExtensions.initialize((fParentNodeRect.x + fParentNodeRect.width) - (fCurrentNodeRect.x + fCurrentNodeRect.width), (fParentNodeRect.y + fParentNodeRect.height) - (fCurrentNodeRect.y + fCurrentNodeRect.height))
+            };
+        }
+        return Object.assign({}, DEFAULT_RESTRICTIONS);
+    }
+    getCurrentNodeRect(fNode) {
+        return this.fMediator.send(new GetNormalizedNodeRectRequest(fNode));
+    }
+    getParentNodeRect(fNode) {
+        return this.fMediator.send(new GetNormalizedParentNodeRectRequest(fNode));
+    }
+};
+GetNodeMoveRestrictionsExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GetNodeMoveRestrictionsExecution, deps: [{ token: i1.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+GetNodeMoveRestrictionsExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GetNodeMoveRestrictionsExecution });
+GetNodeMoveRestrictionsExecution = __decorate([
+    FExecutionRegister(GetNodeMoveRestrictionsRequest)
+], GetNodeMoveRestrictionsExecution);
+export { GetNodeMoveRestrictionsExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GetNodeMoveRestrictionsExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FFlowMediator }]; } });
+const DEFAULT_RESTRICTIONS = {
+    min: PointExtensions.initialize(-Infinity, -Infinity),
+    max: PointExtensions.initialize(Infinity, Infinity)
+};
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/get-node-move-restrictions/get-node-move-restrictions.request.mjs → esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/get-node-move-restrictions/get-node-move-restrictions.request.js}

@@ -1,9 +1,7 @@
 export class GetNodeMoveRestrictionsRequest {
-    fNode;
-    hasParentNodeInSelected;
     constructor(fNode, hasParentNodeInSelected) {
         this.fNode = fNode;
         this.hasParentNodeInSelected = hasParentNodeInSelected;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW5vZGUtbW92ZS1yZXN0cmljdGlvbnMucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvbm9kZS9jcmVhdGUtbW92ZS1ub2Rlcy1kcmFnLW1vZGVsLWZyb20tc2VsZWN0aW9uL2RvbWFpbi9nZXQtbm9kZS1tb3ZlLXJlc3RyaWN0aW9ucy9nZXQtbm9kZS1tb3ZlLXJlc3RyaWN0aW9ucy5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyw4QkFBOEI7SUFHaEM7SUFDQTtJQUZULFlBQ1MsS0FBZ0IsRUFDaEIsdUJBQWdDO1FBRGhDLFVBQUssR0FBTCxLQUFLLENBQVc7UUFDaEIsNEJBQXVCLEdBQXZCLHVCQUF1QixDQUFTO0lBRXpDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZOb2RlQmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL2Ytbm9kZSc7XG5cbmV4cG9ydCBjbGFzcyBHZXROb2RlTW92ZVJlc3RyaWN0aW9uc1JlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBmTm9kZTogRk5vZGVCYXNlLFxuICAgIHB1YmxpYyBoYXNQYXJlbnROb2RlSW5TZWxlY3RlZDogYm9vbGVhblxuICApIHtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW5vZGUtbW92ZS1yZXN0cmljdGlvbnMucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvbm9kZS9jcmVhdGUtbW92ZS1ub2Rlcy1kcmFnLW1vZGVsLWZyb20tc2VsZWN0aW9uL2RvbWFpbi9nZXQtbm9kZS1tb3ZlLXJlc3RyaWN0aW9ucy9nZXQtbm9kZS1tb3ZlLXJlc3RyaWN0aW9ucy5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyw4QkFBOEI7SUFFekMsWUFDUyxLQUFnQixFQUNoQix1QkFBZ0M7UUFEaEMsVUFBSyxHQUFMLEtBQUssQ0FBVztRQUNoQiw0QkFBdUIsR0FBdkIsdUJBQXVCLENBQVM7SUFFekMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRk5vZGVCYXNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vZi1ub2RlJztcblxuZXhwb3J0IGNsYXNzIEdldE5vZGVNb3ZlUmVzdHJpY3Rpb25zUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGZOb2RlOiBGTm9kZUJhc2UsXG4gICAgcHVibGljIGhhc1BhcmVudE5vZGVJblNlbGVjdGVkOiBib29sZWFuXG4gICkge1xuICB9XG59XG4iXX0=

package/esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.execution.js

@@ -0,0 +1,70 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';
+import { FExecutionRegister } from '../../../../../infrastructure';
+import { ConnectionDragHandler } from '../../../connection.drag-handler';
+import { ConnectionTargetDragHandler } from '../../../connection-target.drag-handler';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../f-storage";
+import * as i2 from "../../../../../infrastructure";
+let PutInputConnectionHandlersToArrayExecution = class PutInputConnectionHandlersToArrayExecution {
+    constructor(fComponentsStore, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    get fConnections() {
+        return this.fComponentsStore.fConnections;
+    }
+    handle(request) {
+        this.getInputConnections(request.nodeDragHandler.fNode).forEach((connection) => {
+            const index = this.getExistingConnectionHandlerIndex(request.result, connection);
+            if (index !== -1) {
+                this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);
+            }
+            else {
+                request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.outputIds, connection));
+            }
+        });
+    }
+    getInputConnections(node) {
+        const inputIds = new Set(this.getInputsForNode(node).map((x) => x.id));
+        return this.fConnections.filter((x) => inputIds.has(x.fInputId));
+    }
+    getInputsForNode(node) {
+        return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));
+    }
+    getExistingConnectionHandlerIndex(result, connection) {
+        return result.findIndex((x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId);
+    }
+    createNewConnectionHandler(nodeDragHandler, outputIds, connection) {
+        let result;
+        if (outputIds.includes(connection.fOutputId)) {
+            result = this.getNewConnectionHandler(connection, nodeDragHandler);
+        }
+        else {
+            result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);
+        }
+        return result;
+    }
+    getNewConnectionHandler(connection, nodeDragHandler) {
+        const handler = new ConnectionDragHandler(this.fMediator, connection);
+        handler.setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        return handler;
+    }
+    updateExistingConnectionHandler(result, index, nodeDragHandler) {
+        result[index].setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+    }
+    getNewSourceConnectionHandler(connection, nodeDragHandler) {
+        return new ConnectionTargetDragHandler(this.fMediator, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+    }
+};
+PutInputConnectionHandlersToArrayExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+PutInputConnectionHandlersToArrayExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution });
+PutInputConnectionHandlersToArrayExecution = __decorate([
+    FExecutionRegister(PutInputConnectionHandlersToArrayRequest)
+], PutInputConnectionHandlersToArrayExecution);
+export { PutInputConnectionHandlersToArrayExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutInputConnectionHandlersToArrayExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"put-input-connection-handlers-to-array.execution.js","sourceRoot":"","sources":["../../../../../../../../projects/f-flow/src/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';\nimport { FComponentsStore } from '../../../../../f-storage';\nimport { FExecutionRegister, FFlowMediator, IExecution } from '../../../../../infrastructure';\nimport { FNodeBase } from '../../../../../f-node';\nimport { NodeDragHandler } from '../../../node.drag-handler';\nimport { IDraggableItem } from '../../../../i-draggable-item';\nimport { ConnectionDragHandler } from '../../../connection.drag-handler';\nimport { FConnectorBase } from '../../../../../f-connectors';\nimport { FConnectionBase } from '../../../../../f-connection';\nimport { ConnectionTargetDragHandler } from '../../../connection-target.drag-handler';\n\n@Injectable()\n@FExecutionRegister(PutInputConnectionHandlersToArrayRequest)\nexport class PutInputConnectionHandlersToArrayExecution\n  implements IExecution<PutInputConnectionHandlersToArrayRequest, void> {\n\n  private get fConnections(): FConnectionBase[] {\n    return this.fComponentsStore.fConnections;\n  }\n\n  constructor(\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FFlowMediator\n  ) {\n  }\n\n  public handle(request: PutInputConnectionHandlersToArrayRequest): void {\n    this.getInputConnections(request.nodeDragHandler.fNode).forEach((connection) => {\n      const index = this.getExistingConnectionHandlerIndex(request.result, connection);\n      if (index !== -1) {\n        this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);\n      } else {\n        request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.outputIds, connection));\n      }\n    });\n  }\n\n  public getInputConnections(node: FNodeBase): FConnectionBase[] {\n    const inputIds = new Set(this.getInputsForNode(node).map((x) => x.id));\n    return this.fConnections.filter((x) => inputIds.has(x.fInputId));\n  }\n\n  private getInputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fInputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private getExistingConnectionHandlerIndex(result: IDraggableItem[], connection: FConnectionBase): number {\n    return result.findIndex(\n      (x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId\n    );\n  }\n\n  private createNewConnectionHandler(nodeDragHandler: NodeDragHandler, outputIds: string[], connection: FConnectionBase): IDraggableItem {\n    let result: IDraggableItem;\n    if (outputIds.includes(connection.fOutputId)) {\n      result = this.getNewConnectionHandler(connection, nodeDragHandler);\n    } else {\n      result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);\n    }\n    return result;\n  }\n\n  private getNewConnectionHandler(connection: FConnectionBase, nodeDragHandler: NodeDragHandler): ConnectionDragHandler {\n    const handler = new ConnectionDragHandler(this.fMediator, connection);\n    handler.setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n    return handler;\n  }\n\n  private updateExistingConnectionHandler(result: IDraggableItem[], index: number, nodeDragHandler: NodeDragHandler): void {\n    (result[ index ] as ConnectionDragHandler).setInputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n  }\n\n  private getNewSourceConnectionHandler(connection: FConnectionBase, nodeDragHandler: NodeDragHandler): ConnectionTargetDragHandler {\n    return new ConnectionTargetDragHandler(this.fMediator, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n  }\n}\n\n"]}

package/{esm2022/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.request.mjs → esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.request.js}

@@ -1,11 +1,8 @@
 export class PutInputConnectionHandlersToArrayRequest {
-    nodeDragHandler;
-    outputIds;
-    result;
     constructor(nodeDragHandler, outputIds, result) {
         this.nodeDragHandler = nodeDragHandler;
         this.outputIds = outputIds;
         this.result = result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHV0LWlucHV0LWNvbm5lY3Rpb24taGFuZGxlcnMtdG8tYXJyYXkucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvbm9kZS9jcmVhdGUtbW92ZS1ub2Rlcy1kcmFnLW1vZGVsLWZyb20tc2VsZWN0aW9uL2RvbWFpbi9wdXQtaW5wdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS9wdXQtaW5wdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx3Q0FBd0M7SUFHMUM7SUFDQTtJQUNBO0lBSFQsWUFDUyxlQUFnQyxFQUNoQyxTQUFtQixFQUNuQixNQUF3QjtRQUZ4QixvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFDaEMsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUNuQixXQUFNLEdBQU4sTUFBTSxDQUFrQjtJQUVqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlRHJhZ0hhbmRsZXIgfSBmcm9tICcuLi8uLi8uLi9ub2RlLmRyYWctaGFuZGxlcic7XG5pbXBvcnQgeyBJRHJhZ2dhYmxlSXRlbSB9IGZyb20gJy4uLy4uLy4uLy4uL2ktZHJhZ2dhYmxlLWl0ZW0nO1xuXG5leHBvcnQgY2xhc3MgUHV0SW5wdXRDb25uZWN0aW9uSGFuZGxlcnNUb0FycmF5UmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIG5vZGVEcmFnSGFuZGxlcjogTm9kZURyYWdIYW5kbGVyLFxuICAgIHB1YmxpYyBvdXRwdXRJZHM6IHN0cmluZ1tdLFxuICAgIHB1YmxpYyByZXN1bHQ6IElEcmFnZ2FibGVJdGVtW11cbiAgKSB7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHV0LWlucHV0LWNvbm5lY3Rpb24taGFuZGxlcnMtdG8tYXJyYXkucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvbm9kZS9jcmVhdGUtbW92ZS1ub2Rlcy1kcmFnLW1vZGVsLWZyb20tc2VsZWN0aW9uL2RvbWFpbi9wdXQtaW5wdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS9wdXQtaW5wdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx3Q0FBd0M7SUFFbkQsWUFDUyxlQUFnQyxFQUNoQyxTQUFtQixFQUNuQixNQUF3QjtRQUZ4QixvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFDaEMsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUNuQixXQUFNLEdBQU4sTUFBTSxDQUFrQjtJQUVqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlRHJhZ0hhbmRsZXIgfSBmcm9tICcuLi8uLi8uLi9ub2RlLmRyYWctaGFuZGxlcic7XG5pbXBvcnQgeyBJRHJhZ2dhYmxlSXRlbSB9IGZyb20gJy4uLy4uLy4uLy4uL2ktZHJhZ2dhYmxlLWl0ZW0nO1xuXG5leHBvcnQgY2xhc3MgUHV0SW5wdXRDb25uZWN0aW9uSGFuZGxlcnNUb0FycmF5UmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIG5vZGVEcmFnSGFuZGxlcjogTm9kZURyYWdIYW5kbGVyLFxuICAgIHB1YmxpYyBvdXRwdXRJZHM6IHN0cmluZ1tdLFxuICAgIHB1YmxpYyByZXN1bHQ6IElEcmFnZ2FibGVJdGVtW11cbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.execution.js

@@ -0,0 +1,70 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { PutOutputConnectionHandlersToArrayRequest } from './put-output-connection-handlers-to-array.request';
+import { FExecutionRegister } from '../../../../../infrastructure';
+import { ConnectionDragHandler } from '../../../connection.drag-handler';
+import { ConnectionSourceDragHandler } from '../../../connection-source.drag-handler';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../f-storage";
+import * as i2 from "../../../../../infrastructure";
+let PutOutputConnectionHandlersToArrayExecution = class PutOutputConnectionHandlersToArrayExecution {
+    constructor(fComponentsStore, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    get fConnections() {
+        return this.fComponentsStore.fConnections;
+    }
+    handle(request) {
+        this.getOutputConnections(request.nodeDragHandler.fNode).forEach((connection) => {
+            const index = this.getExistingConnectionHandlerIndex(request.result, connection);
+            if (index !== -1) {
+                this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);
+            }
+            else {
+                request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.inputIds, connection));
+            }
+        });
+    }
+    getOutputConnections(node) {
+        const outputsIds = new Set(this.getOutputsForNode(node).map((x) => x.id));
+        return this.fConnections.filter((x) => outputsIds.has(x.fOutputId));
+    }
+    getOutputsForNode(node) {
+        return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
+    }
+    getExistingConnectionHandlerIndex(result, connection) {
+        return result.findIndex((x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId);
+    }
+    createNewConnectionHandler(nodeDragHandler, inputIds, connection) {
+        let result;
+        if (inputIds.includes(connection.fInputId)) {
+            result = this.getNewConnectionHandler(connection, nodeDragHandler);
+        }
+        else {
+            result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);
+        }
+        return result;
+    }
+    getNewConnectionHandler(connection, nodeDragHandler) {
+        const handler = new ConnectionDragHandler(this.fMediator, connection);
+        handler.setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+        return handler;
+    }
+    updateExistingConnectionHandler(result, index, nodeDragHandler) {
+        result[index].setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+    }
+    getNewSourceConnectionHandler(connection, nodeDragHandler) {
+        return new ConnectionSourceDragHandler(this.fMediator, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);
+    }
+};
+PutOutputConnectionHandlersToArrayExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+PutOutputConnectionHandlersToArrayExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution });
+PutOutputConnectionHandlersToArrayExecution = __decorate([
+    FExecutionRegister(PutOutputConnectionHandlersToArrayRequest)
+], PutOutputConnectionHandlersToArrayExecution);
+export { PutOutputConnectionHandlersToArrayExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PutOutputConnectionHandlersToArrayExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"put-output-connection-handlers-to-array.execution.js","sourceRoot":"","sources":["../../../../../../../../projects/f-flow/src/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { PutOutputConnectionHandlersToArrayRequest } from './put-output-connection-handlers-to-array.request';\nimport { FComponentsStore } from '../../../../../f-storage';\nimport { FExecutionRegister, FFlowMediator, IExecution } from '../../../../../infrastructure';\nimport { FNodeBase } from '../../../../../f-node';\nimport { NodeDragHandler } from '../../../node.drag-handler';\nimport { IDraggableItem } from '../../../../i-draggable-item';\nimport { ConnectionDragHandler } from '../../../connection.drag-handler';\nimport { ConnectionSourceDragHandler } from '../../../connection-source.drag-handler';\nimport { FConnectorBase } from '../../../../../f-connectors';\nimport { FConnectionBase } from '../../../../../f-connection';\n\n@Injectable()\n@FExecutionRegister(PutOutputConnectionHandlersToArrayRequest)\nexport class PutOutputConnectionHandlersToArrayExecution\n  implements IExecution<PutOutputConnectionHandlersToArrayRequest, void> {\n\n  private get fConnections(): FConnectionBase[] {\n    return this.fComponentsStore.fConnections;\n  }\n\n  constructor(\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FFlowMediator\n  ) {\n  }\n\n  public handle(request: PutOutputConnectionHandlersToArrayRequest): void {\n    this.getOutputConnections(request.nodeDragHandler.fNode).forEach((connection) => {\n      const index = this.getExistingConnectionHandlerIndex(request.result, connection);\n      if (index !== -1) {\n        this.updateExistingConnectionHandler(request.result, index, request.nodeDragHandler);\n      } else {\n        request.result.push(this.createNewConnectionHandler(request.nodeDragHandler, request.inputIds, connection));\n      }\n    });\n  }\n\n  public getOutputConnections(node: FNodeBase): FConnectionBase[] {\n    const outputsIds = new Set(this.getOutputsForNode(node).map((x) => x.id));\n    return this.fConnections.filter((x) => outputsIds.has(x.fOutputId));\n  }\n\n  private getOutputsForNode(node: FNodeBase): FConnectorBase[] {\n    return this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));\n  }\n\n  private getExistingConnectionHandlerIndex(result: IDraggableItem[], connection: FConnectionBase): number {\n    return result.findIndex(\n      (x) => x instanceof ConnectionDragHandler && x.connection.fId === connection.fId\n    );\n  }\n\n  private createNewConnectionHandler(nodeDragHandler: NodeDragHandler, inputIds: string[], connection: FConnectionBase): IDraggableItem {\n    let result: IDraggableItem;\n    if (inputIds.includes(connection.fInputId)) {\n      result = this.getNewConnectionHandler(connection, nodeDragHandler);\n    } else {\n      result = this.getNewSourceConnectionHandler(connection, nodeDragHandler);\n    }\n    return result;\n  }\n\n  private getNewConnectionHandler(connection: FConnectionBase, nodeDragHandler: NodeDragHandler): ConnectionDragHandler {\n    const handler = new ConnectionDragHandler(this.fMediator, connection);\n    handler.setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n    return handler;\n  }\n\n  private updateExistingConnectionHandler(result: IDraggableItem[], index: number, nodeDragHandler: NodeDragHandler): void {\n    (result[ index ] as ConnectionDragHandler).setOutputRestrictions(nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n  }\n\n  private getNewSourceConnectionHandler(connection: FConnectionBase, nodeDragHandler: NodeDragHandler): ConnectionSourceDragHandler {\n    return new ConnectionSourceDragHandler(this.fMediator, connection, nodeDragHandler.minDistance, nodeDragHandler.maxDistance);\n  }\n}\n\n"]}

package/{esm2022/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.request.mjs → esm2015/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.request.js}

@@ -1,11 +1,8 @@
 export class PutOutputConnectionHandlersToArrayRequest {
-    nodeDragHandler;
-    inputIds;
-    result;
     constructor(nodeDragHandler, inputIds, result) {
         this.nodeDragHandler = nodeDragHandler;
         this.inputIds = inputIds;
         this.result = result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHV0LW91dHB1dC1jb25uZWN0aW9uLWhhbmRsZXJzLXRvLWFycmF5LnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvY3JlYXRlLW1vdmUtbm9kZXMtZHJhZy1tb2RlbC1mcm9tLXNlbGVjdGlvbi9kb21haW4vcHV0LW91dHB1dC1jb25uZWN0aW9uLWhhbmRsZXJzLXRvLWFycmF5L3B1dC1vdXRwdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx5Q0FBeUM7SUFHM0M7SUFDQTtJQUNBO0lBSFQsWUFDUyxlQUFnQyxFQUNoQyxRQUFrQixFQUNsQixNQUF3QjtRQUZ4QixvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFDaEMsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQUNsQixXQUFNLEdBQU4sTUFBTSxDQUFrQjtJQUVqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlRHJhZ0hhbmRsZXIgfSBmcm9tICcuLi8uLi8uLi9ub2RlLmRyYWctaGFuZGxlcic7XG5pbXBvcnQgeyBJRHJhZ2dhYmxlSXRlbSB9IGZyb20gJy4uLy4uLy4uLy4uL2ktZHJhZ2dhYmxlLWl0ZW0nO1xuXG5leHBvcnQgY2xhc3MgUHV0T3V0cHV0Q29ubmVjdGlvbkhhbmRsZXJzVG9BcnJheVJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBub2RlRHJhZ0hhbmRsZXI6IE5vZGVEcmFnSGFuZGxlcixcbiAgICBwdWJsaWMgaW5wdXRJZHM6IHN0cmluZ1tdLFxuICAgIHB1YmxpYyByZXN1bHQ6IElEcmFnZ2FibGVJdGVtW11cbiAgKSB7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHV0LW91dHB1dC1jb25uZWN0aW9uLWhhbmRsZXJzLXRvLWFycmF5LnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvY3JlYXRlLW1vdmUtbm9kZXMtZHJhZy1tb2RlbC1mcm9tLXNlbGVjdGlvbi9kb21haW4vcHV0LW91dHB1dC1jb25uZWN0aW9uLWhhbmRsZXJzLXRvLWFycmF5L3B1dC1vdXRwdXQtY29ubmVjdGlvbi1oYW5kbGVycy10by1hcnJheS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx5Q0FBeUM7SUFFcEQsWUFDUyxlQUFnQyxFQUNoQyxRQUFrQixFQUNsQixNQUF3QjtRQUZ4QixvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFDaEMsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQUNsQixXQUFNLEdBQU4sTUFBTSxDQUFrQjtJQUVqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb2RlRHJhZ0hhbmRsZXIgfSBmcm9tICcuLi8uLi8uLi9ub2RlLmRyYWctaGFuZGxlcic7XG5pbXBvcnQgeyBJRHJhZ2dhYmxlSXRlbSB9IGZyb20gJy4uLy4uLy4uLy4uL2ktZHJhZ2dhYmxlLWl0ZW0nO1xuXG5leHBvcnQgY2xhc3MgUHV0T3V0cHV0Q29ubmVjdGlvbkhhbmRsZXJzVG9BcnJheVJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBub2RlRHJhZ0hhbmRsZXI6IE5vZGVEcmFnSGFuZGxlcixcbiAgICBwdWJsaWMgaW5wdXRJZHM6IHN0cmluZ1tdLFxuICAgIHB1YmxpYyByZXN1bHQ6IElEcmFnZ2FibGVJdGVtW11cbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2015/f-draggable/node/node-move-finalize/node-move-finalize.execution.js

@@ -0,0 +1,54 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { NodeMoveFinalizeRequest } from './node-move-finalize.request';
+import { Point } from '@foblex/core';
+import { FExecutionRegister } from '../../../infrastructure';
+import { IsConnectionUnderNodeRequest } from '../../../domain/is-connection-under-node/is-connection-under-node.request';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-storage";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../../../infrastructure";
+let NodeMoveFinalizeExecution = class NodeMoveFinalizeExecution {
+    constructor(fComponentsStore, fDraggableDataContext, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+    }
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    handle(request) {
+        var _a;
+        const difference = this.getDifferenceWithLineAlignment(this.getDifferenceBetweenPreparationAndFinalize(request.event.getPosition()));
+        this.fDraggableDataContext.draggableItems.forEach((x) => {
+            var _a;
+            x.move(Object.assign({}, difference));
+            (_a = x.complete) === null || _a === void 0 ? void 0 : _a.call(x);
+        });
+        this.fMediator.send(new IsConnectionUnderNodeRequest());
+        (_a = this.fDraggableDataContext.fLineAlignment) === null || _a === void 0 ? void 0 : _a.complete();
+    }
+    getDifferenceBetweenPreparationAndFinalize(position) {
+        return Point.fromPoint(position).elementTransform(this.flowHost)
+            .div(this.fDraggableDataContext.onPointerDownScale).sub(this.fDraggableDataContext.onPointerDownPosition);
+    }
+    getDifferenceWithLineAlignment(difference) {
+        var _a;
+        const intersection = (_a = this.fDraggableDataContext.fLineAlignment) === null || _a === void 0 ? void 0 : _a.findNearestCoordinate(difference);
+        if (intersection) {
+            difference.x = intersection.xResult.value ? (difference.x - intersection.xResult.distance) : difference.x;
+            difference.y = intersection.yResult.value ? (difference.y - intersection.yResult.distance) : difference.y;
+        }
+        return difference;
+    }
+};
+NodeMoveFinalizeExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeMoveFinalizeExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeExecution });
+NodeMoveFinalizeExecution = __decorate([
+    FExecutionRegister(NodeMoveFinalizeRequest)
+], NodeMoveFinalizeExecution);
+export { NodeMoveFinalizeExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022/f-draggable/node/node-move-finalize/node-move-finalize.request.mjs → esm2015/f-draggable/node/node-move-finalize/node-move-finalize.request.js}

@@ -1,7 +1,6 @@
 export class NodeMoveFinalizeRequest {
-    event;
     constructor(event) {
         this.event = event;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1tb3ZlLWZpbmFsaXplLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvbm9kZS1tb3ZlLWZpbmFsaXplL25vZGUtbW92ZS1maW5hbGl6ZS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyx1QkFBdUI7SUFHekI7SUFEVCxZQUNTLEtBQW9CO1FBQXBCLFVBQUssR0FBTCxLQUFLLENBQWU7SUFFN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50ZXJFdmVudCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5cbmV4cG9ydCBjbGFzcyBOb2RlTW92ZUZpbmFsaXplUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGV2ZW50OiBJUG9pbnRlckV2ZW50XG4gICkge1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1tb3ZlLWZpbmFsaXplLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvbm9kZS1tb3ZlLWZpbmFsaXplL25vZGUtbW92ZS1maW5hbGl6ZS5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyx1QkFBdUI7SUFFbEMsWUFDUyxLQUFvQjtRQUFwQixVQUFLLEdBQUwsS0FBSyxDQUFlO0lBRTdCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludGVyRXZlbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgTm9kZU1vdmVGaW5hbGl6ZVJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBldmVudDogSVBvaW50ZXJFdmVudFxuICApIHtcbiAgfVxufVxuIl19

package/esm2015/f-draggable/node/node-move-finalize/node-move-finalize.validator.js

@@ -0,0 +1,25 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { NodeMoveFinalizeRequest } from './node-move-finalize.request';
+import { FValidatorRegister } from '../../../infrastructure';
+import { NodeDragHandler } from '../node.drag-handler';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-draggable-data-context";
+let NodeMoveFinalizeValidator = class NodeMoveFinalizeValidator {
+    constructor(fDraggableDataContext) {
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(request) {
+        return this.fDraggableDataContext.draggableItems.some((x) => x instanceof NodeDragHandler);
+    }
+};
+NodeMoveFinalizeValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeValidator, deps: [{ token: i1.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeMoveFinalizeValidator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeValidator });
+NodeMoveFinalizeValidator = __decorate([
+    FValidatorRegister(NodeMoveFinalizeRequest)
+], NodeMoveFinalizeValidator);
+export { NodeMoveFinalizeValidator };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMoveFinalizeValidator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-draggable/node/node-move-preparation/node-move-preparation.execution.js

@@ -0,0 +1,60 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { NodeMovePreparationRequest } from './node-move-preparation.request';
+import { Point } from '@foblex/core';
+import { FExecutionRegister } from '../../../infrastructure';
+import { SelectAndUpdateNodeLayerRequest, } from '../../../domain';
+import { NodeDragHandler } from '../node.drag-handler';
+import { CreateMoveNodesDragModelFromSelectionRequest } from '../create-move-nodes-drag-model-from-selection';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-storage";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../../../infrastructure";
+let NodeMovePreparationExecution = class NodeMovePreparationExecution {
+    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(request) {
+        this.selectAndUpdateNodeLayer(request.event.targetElement);
+        const itemsToDrag = this.createDragModelFromSelection();
+        this.initializeLineAlignment(this.filterNodesFromDraggableItems(itemsToDrag));
+        this.fDraggableDataContext.onPointerDownScale = this.transform.scale;
+        this.fDraggableDataContext.onPointerDownPosition = Point.fromPoint(request.event.getPosition())
+            .elementTransform(this.flowHost).div(this.transform.scale);
+        this.fDraggableDataContext.draggableItems = itemsToDrag;
+    }
+    selectAndUpdateNodeLayer(targetElement) {
+        this.fMediator.send(new SelectAndUpdateNodeLayerRequest(this.getNode(targetElement)));
+    }
+    getNode(targetElement) {
+        return this.fComponentsStore.findNode(targetElement);
+    }
+    createDragModelFromSelection() {
+        return this.fMediator.send(new CreateMoveNodesDragModelFromSelectionRequest());
+    }
+    initializeLineAlignment(nodesToDrag) {
+        var _a;
+        (_a = this.fDraggableDataContext.fLineAlignment) === null || _a === void 0 ? void 0 : _a.initialize(this.fComponentsStore.fNodes, nodesToDrag);
+    }
+    filterNodesFromDraggableItems(items) {
+        return items.filter((x) => x instanceof NodeDragHandler).map(x => x.fNode);
+    }
+};
+NodeMovePreparationExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMovePreparationExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FFlowMediator }], target: i0.ɵɵFactoryTarget.Injectable });
+NodeMovePreparationExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMovePreparationExecution });
+NodeMovePreparationExecution = __decorate([
+    FExecutionRegister(NodeMovePreparationRequest)
+], NodeMovePreparationExecution);
+export { NodeMovePreparationExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NodeMovePreparationExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FFlowMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022/f-draggable/node/node-move-preparation/node-move-preparation.request.mjs → esm2015/f-draggable/node/node-move-preparation/node-move-preparation.request.js}

@@ -1,7 +1,6 @@
 export class NodeMovePreparationRequest {
-    event;
     constructor(event) {
         this.event = event;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1tb3ZlLXByZXBhcmF0aW9uLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvbm9kZS1tb3ZlLXByZXBhcmF0aW9uL25vZGUtbW92ZS1wcmVwYXJhdGlvbi5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTywwQkFBMEI7SUFHNUI7SUFEVCxZQUNTLEtBQW9CO1FBQXBCLFVBQUssR0FBTCxLQUFLLENBQWU7SUFFN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50ZXJFdmVudCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5cbmV4cG9ydCBjbGFzcyBOb2RlTW92ZVByZXBhcmF0aW9uUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGV2ZW50OiBJUG9pbnRlckV2ZW50XG4gICkge1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1tb3ZlLXByZXBhcmF0aW9uLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL25vZGUvbm9kZS1tb3ZlLXByZXBhcmF0aW9uL25vZGUtbW92ZS1wcmVwYXJhdGlvbi5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTywwQkFBMEI7SUFFckMsWUFDUyxLQUFvQjtRQUFwQixVQUFLLEdBQUwsS0FBSyxDQUFlO0lBRTdCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludGVyRXZlbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgTm9kZU1vdmVQcmVwYXJhdGlvblJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBldmVudDogSVBvaW50ZXJFdmVudFxuICApIHtcbiAgfVxufVxuIl19