@foblex/flow 1.2.1 → 1.2.3

package/esm2022/f-draggable/connections/create-connection/create-connection.on-pointer-up.mjs

@@ -0,0 +1,50 @@
+import { EDraggableType } from '../../e-draggable-type';
+import { FindInputsUnderPointerRequest } from '../find-inputs-under-pointer';
+import { Injectable } from '@angular/core';
+import { CreateConnectionEvent } from './create-connection.event';
+import { OutputNotFound, requiredOutput } from '../../../domain';
+import { isNodeOutlet } from '../../../f-node';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-components-store";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../find-inputs-under-pointer";
+import * as i4 from "./find-first-can-be-connected-output-by-outlet";
+export class CreateConnectionOnPointerUp {
+    constructor(fComponentsStore, fDraggableDataContext, findInputsUnderPointerHandler, findFirstCanBeConnectedOutputByOutletHandler) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.findInputsUnderPointerHandler = findInputsUnderPointerHandler;
+        this.findFirstCanBeConnectedOutputByOutletHandler = findFirstCanBeConnectedOutputByOutletHandler;
+    }
+    handle(event) {
+        const isCreateConnection = this.fDraggableDataContext.draggableItems.some((x) => x.type === EDraggableType.CREATE_CONNECTION);
+        if (isCreateConnection) {
+            const handler = this.fDraggableDataContext.draggableItems[0];
+            const inputsUnderPointer = this.findInputsUnderPointerHandler.handle(new FindInputsUnderPointerRequest(event, handler));
+            if (inputsUnderPointer.length > 0) {
+                let output = this.fComponentsStore.fOutputs.find((x) => x.id === handler.connection.outputId);
+                if (!output) {
+                    output = this.fComponentsStore.fOutlets.find((x) => x.id === handler.connection.outputId);
+                }
+                if (!output) {
+                    throw OutputNotFound(handler.connection.outputId);
+                }
+                const isOutlet = isNodeOutlet(output.hostElement);
+                if (isOutlet) {
+                    output = this.findFirstCanBeConnectedOutputByOutletHandler.handle(output);
+                    if (!output) {
+                        throw requiredOutput();
+                    }
+                }
+                this.fComponentsStore.fDraggable?.fCreateConnection.emit(new CreateConnectionEvent(output.id, inputsUnderPointer[0]?.id));
+            }
+            handler.complete();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionOnPointerUp, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FindInputsUnderPointerHandler }, { token: i4.FindFirstCanBeConnectedOutputByOutletHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionOnPointerUp }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionOnPointerUp, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FindInputsUnderPointerHandler }, { type: i4.FindFirstCanBeConnectedOutputByOutletHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/connections/create-connection/create-connection.prepare-drag-sequence.mjs

@@ -0,0 +1,86 @@
+import { Point } from '@foblex/core';
+import { Injectable } from '@angular/core';
+import { CreateConnectionDragHandler } from './create-connection.drag-handler';
+import { isNodeOutlet, isNodeOutput } from '../../../f-node';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-components-store";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../../../domain";
+import * as i4 from "./find-first-can-be-connected-output-by-outlet";
+export class CreateConnectionPrepareDragSequence {
+    get transform() {
+        return this.fComponentsStore.fCanvas.transform;
+    }
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    constructor(fComponentsStore, fDraggableDataContext, getElementRectInFlowHandler, getConnectionVectorHandler, findFirstCanBeConnectedOutputByOutletHandler, getOutputRectInFlowHandler) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.getElementRectInFlowHandler = getElementRectInFlowHandler;
+        this.getConnectionVectorHandler = getConnectionVectorHandler;
+        this.findFirstCanBeConnectedOutputByOutletHandler = findFirstCanBeConnectedOutputByOutletHandler;
+        this.getOutputRectInFlowHandler = getOutputRectInFlowHandler;
+    }
+    handle(event) {
+        const node = this.fComponentsStore.findNode(event.targetElement);
+        const pointerPositionInFlow = Point.fromPoint(event.getPosition()).elementTransform(this.flowHost);
+        if (!node || this.fDraggableDataContext.draggableItems.length || !this.fComponentsStore.fTempConnection) {
+            return;
+        }
+        if (isNodeOutlet(event.targetElement)) {
+            const outlet = this.fComponentsStore.fOutlets.find((x) => {
+                return x.hostElement.contains(event.targetElement);
+            });
+            if (!outlet) {
+                throw new Error('Outlet not found');
+            }
+            const nodeOutputs = this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));
+            outlet.setOutputs(nodeOutputs);
+            if (outlet.canBeConnected) {
+                const outletCenter = this.getElementRectInFlowHandler.handle(outlet.hostElement).gravityCenter;
+                if (outlet.isConnectionFromOutlet) {
+                    this.createConnectionHandler(pointerPositionInFlow, outlet, outletCenter);
+                }
+                else {
+                    const output = this.findFirstCanBeConnectedOutputByOutletHandler.handle(outlet);
+                    if (!output) {
+                        throw new Error('Output not found');
+                    }
+                    this.createConnectionHandler(pointerPositionInFlow, output, outletCenter);
+                }
+            }
+        }
+        else if (this.isNodeOutput(event.targetElement, node)) {
+            const output = this.fComponentsStore.fOutputs.find((x) => {
+                return x.hostElement.contains(event.targetElement);
+            });
+            if (!output) {
+                throw new Error('Output not found');
+            }
+            if (output.canBeConnected) {
+                const outputCenter = this.getElementRectInFlowHandler.handle(output.hostElement).gravityCenter;
+                this.createConnectionHandler(pointerPositionInFlow, output, outputCenter);
+            }
+        }
+    }
+    createConnectionHandler(pointerPositionInCanvas, output, outputCenter) {
+        this.fComponentsStore.fTempConnection.outputId = output.id;
+        this.fComponentsStore.fTempConnection.initialize();
+        this.fDraggableDataContext.onPointerDownScale = this.transform.scale;
+        this.fDraggableDataContext.onPointerDownPosition = pointerPositionInCanvas.div(this.transform.scale);
+        this.fDraggableDataContext.draggableItems = [
+            new CreateConnectionDragHandler(this.getOutputRectInFlowHandler, this.getConnectionVectorHandler, this.fComponentsStore.fTempConnection, outputCenter)
+        ];
+    }
+    isNodeOutput(targetElement, node) {
+        const outlets = this.fComponentsStore.fOutlets.filter((x) => node.isContains(x.hostElement));
+        return isNodeOutput(targetElement) && !outlets.length;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionPrepareDragSequence, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.GetElementRectInFlowHandler }, { token: i3.GetConnectionVectorHandler }, { token: i4.FindFirstCanBeConnectedOutputByOutletHandler }, { token: i3.GetOutputRectInFlowHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionPrepareDragSequence }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: CreateConnectionPrepareDragSequence, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.GetElementRectInFlowHandler }, { type: i3.GetConnectionVectorHandler }, { type: i4.FindFirstCanBeConnectedOutputByOutletHandler }, { type: i3.GetOutputRectInFlowHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-connection.prepare-drag-sequence.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/connections/create-connection/create-connection.prepare-drag-sequence.ts"],"names":[],"mappings":"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","sourcesContent":["import { IHandler, IPoint, IPointerEvent, ITransformModel, Point } from '@foblex/core';\nimport { Injectable } from '@angular/core';\nimport { FComponentsStore } from '../../../f-components-store';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { FindFirstCanBeConnectedOutputByOutletHandler } from './find-first-can-be-connected-output-by-outlet';\nimport { CreateConnectionDragHandler } from './create-connection.drag-handler';\nimport { GetConnectionVectorHandler, GetElementRectInFlowHandler, GetOutputRectInFlowHandler } from '../../../domain';\nimport { FConnectorBase, FNodeBase, FNodeOutletBase, isNodeOutlet, isNodeOutput } from '../../../f-node';\n\n@Injectable()\nexport class CreateConnectionPrepareDragSequence\n    implements IHandler<IPointerEvent, 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 getElementRectInFlowHandler: GetElementRectInFlowHandler,\n      private getConnectionVectorHandler: GetConnectionVectorHandler,\n      private findFirstCanBeConnectedOutputByOutletHandler: FindFirstCanBeConnectedOutputByOutletHandler,\n      private getOutputRectInFlowHandler: GetOutputRectInFlowHandler,\n  ) {\n  }\n\n  public handle(event: IPointerEvent): void {\n\n    const node = this.fComponentsStore.findNode(event.targetElement);\n    const pointerPositionInFlow = Point.fromPoint(event.getPosition()).elementTransform(this.flowHost);\n    if (!node || this.fDraggableDataContext.draggableItems.length || !this.fComponentsStore.fTempConnection) {\n      return;\n    }\n\n    if (isNodeOutlet(event.targetElement)) {\n      const outlet = this.fComponentsStore.fOutlets.find((x) => {\n        return x.hostElement.contains(event.targetElement);\n      });\n      if (!outlet) {\n        throw new Error('Outlet not found');\n      }\n      const nodeOutputs = this.fComponentsStore.fOutputs.filter((x) => node.isContains(x.hostElement));\n      (outlet as FNodeOutletBase).setOutputs(nodeOutputs);\n\n      if (outlet.canBeConnected) {\n\n        const outletCenter = this.getElementRectInFlowHandler.handle(outlet.hostElement).gravityCenter;\n        if ((outlet as FNodeOutletBase).isConnectionFromOutlet) {\n          this.createConnectionHandler(pointerPositionInFlow, outlet, outletCenter);\n        } else {\n          const output = this.findFirstCanBeConnectedOutputByOutletHandler.handle(outlet as FNodeOutletBase);\n          if (!output) {\n            throw new Error('Output not found');\n          }\n          this.createConnectionHandler(pointerPositionInFlow, output, outletCenter);\n        }\n      }\n    } else if (this.isNodeOutput(event.targetElement, node)) {\n      const output = this.fComponentsStore.fOutputs.find((x) => {\n        return x.hostElement.contains(event.targetElement);\n      });\n      if (!output) {\n        throw new Error('Output not found');\n      }\n      if (output.canBeConnected) {\n        const outputCenter = this.getElementRectInFlowHandler.handle(output.hostElement).gravityCenter;\n        this.createConnectionHandler(pointerPositionInFlow, output, outputCenter);\n      }\n    }\n  }\n\n  private createConnectionHandler(\n      pointerPositionInCanvas: Point,\n      output: FConnectorBase,\n      outputCenter: IPoint\n  ): void {\n\n    this.fComponentsStore.fTempConnection!.outputId = output.id;\n    this.fComponentsStore.fTempConnection!.initialize();\n\n    this.fDraggableDataContext.onPointerDownScale = this.transform.scale;\n\n    this.fDraggableDataContext.onPointerDownPosition = pointerPositionInCanvas.div(this.transform.scale);\n\n    this.fDraggableDataContext.draggableItems = [\n      new CreateConnectionDragHandler(this.getOutputRectInFlowHandler, this.getConnectionVectorHandler, this.fComponentsStore.fTempConnection!, outputCenter)\n    ];\n  }\n\n  private isNodeOutput(targetElement: HTMLElement, node: FNodeBase): boolean {\n    const outlets = this.fComponentsStore.fOutlets.filter((x) => node.isContains(x.hostElement));\n    return isNodeOutput(targetElement) && !outlets.length;\n  }\n}\n"]}

package/esm2022/f-draggable/connections/create-connection/find-first-can-be-connected-output-by-outlet/find-first-can-be-connected-output-by-outlet.handler.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../f-components-store";
+export class FindFirstCanBeConnectedOutputByOutletHandler {
+    get fNodes() {
+        return this.fComponentsStore.fNodes;
+    }
+    get fOutputs() {
+        return this.fComponentsStore.fOutputs;
+    }
+    constructor(fComponentsStore) {
+        this.fComponentsStore = fComponentsStore;
+    }
+    handle(outlet) {
+        let result;
+        const node = this.fNodes.find((x) => x.isContains(outlet.hostElement));
+        if (!node) {
+            throw new Error('Node not found');
+        }
+        const outputsOfNode = this.fOutputs.filter((x) => {
+            return node.isContains(x.hostElement) && x.canBeConnected;
+        });
+        if (outputsOfNode.length > 0) {
+            result = outputsOfNode[0];
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindFirstCanBeConnectedOutputByOutletHandler, deps: [{ token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindFirstCanBeConnectedOutputByOutletHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindFirstCanBeConnectedOutputByOutletHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/connections/create-connection/find-first-can-be-connected-output-by-outlet/index.mjs

@@ -0,0 +1,2 @@
+export * from './find-first-can-be-connected-output-by-outlet.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2NyZWF0ZS1jb25uZWN0aW9uL2ZpbmQtZmlyc3QtY2FuLWJlLWNvbm5lY3RlZC1vdXRwdXQtYnktb3V0bGV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0RBQXdELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZpbmQtZmlyc3QtY2FuLWJlLWNvbm5lY3RlZC1vdXRwdXQtYnktb3V0bGV0LmhhbmRsZXInO1xuIl19

package/esm2022/f-draggable/connections/create-connection/index.mjs

@@ -0,0 +1,6 @@
+export * from './find-first-can-be-connected-output-by-outlet';
+export * from './create-connection.drag-handler';
+export * from './create-connection.event';
+export * from './create-connection.on-pointer-up';
+export * from './create-connection.prepare-drag-sequence';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2NyZWF0ZS1jb25uZWN0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0RBQWdELENBQUM7QUFFL0QsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmluZC1maXJzdC1jYW4tYmUtY29ubmVjdGVkLW91dHB1dC1ieS1vdXRsZXQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1jb25uZWN0aW9uLmRyYWctaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vY3JlYXRlLWNvbm5lY3Rpb24uZXZlbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1jb25uZWN0aW9uLm9uLXBvaW50ZXItdXAnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1jb25uZWN0aW9uLnByZXBhcmUtZHJhZy1zZXF1ZW5jZSc7XG5cbiJdfQ==

package/esm2022/f-draggable/connections/create-connection/public-api.mjs

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

package/esm2022/f-draggable/connections/find-inputs-under-pointer/find-inputs-under-pointer.handler.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { OutputNotFound } from '../../../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-components-store";
+import * as i2 from "./inputs-under-pointer";
+import * as i3 from "./first-not-connected-input-of-node-under-pointer";
+export class FindInputsUnderPointerHandler {
+    get fNodes() {
+        return this.fComponentsStore.fNodes;
+    }
+    constructor(fComponentsStore, inputsUnderPointerHandler, firstNotConnectedInputOfNodeUnderPointerHandler) {
+        this.fComponentsStore = fComponentsStore;
+        this.inputsUnderPointerHandler = inputsUnderPointerHandler;
+        this.firstNotConnectedInputOfNodeUnderPointerHandler = firstNotConnectedInputOfNodeUnderPointerHandler;
+    }
+    handle(payload) {
+        const inputsUnderPointer = this.getInputsUnderPointer(payload);
+        const output = this.fComponentsStore.fOutputs.find((x) => x.id === payload.dragHandler.connection.outputId);
+        if (!output) {
+            throw OutputNotFound(payload.dragHandler.connection.outputId);
+        }
+        return inputsUnderPointer.filter((x) => {
+            const targetNode = this.fNodes.find((y) => y.isContains(x.hostElement));
+            const sourceNode = this.fNodes.find((y) => y.isContains(output.hostElement));
+            return sourceNode?.hostElement !== targetNode?.hostElement;
+        });
+    }
+    getInputsUnderPointer(payload) {
+        let inputs = this.inputsUnderPointerHandler.handle(payload.event);
+        const input = this.firstNotConnectedInputOfNodeUnderPointerHandler.handle(payload.event);
+        if (input) {
+            inputs.push(input);
+        }
+        inputs = inputs.filter((x) => x.canBeConnected);
+        return inputs;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindInputsUnderPointerHandler, deps: [{ token: i1.FComponentsStore }, { token: i2.InputsUnderPointerHandler }, { token: i3.FirstNotConnectedInputOfNodeUnderPointerHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindInputsUnderPointerHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FindInputsUnderPointerHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.InputsUnderPointerHandler }, { type: i3.FirstNotConnectedInputOfNodeUnderPointerHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/connections/find-inputs-under-pointer/find-inputs-under-pointer.request.mjs

@@ -0,0 +1,7 @@
+export class FindInputsUnderPointerRequest {
+    constructor(event, dragHandler) {
+        this.event = event;
+        this.dragHandler = dragHandler;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC1pbnB1dHMtdW5kZXItcG9pbnRlci5yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9jb25uZWN0aW9ucy9maW5kLWlucHV0cy11bmRlci1wb2ludGVyL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIucmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sNkJBQTZCO0lBRXhDLFlBQ1MsS0FBb0IsRUFDcEIsV0FBd0U7UUFEeEUsVUFBSyxHQUFMLEtBQUssQ0FBZTtRQUNwQixnQkFBVyxHQUFYLFdBQVcsQ0FBNkQ7SUFFakYsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50ZXJFdmVudCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5pbXBvcnQgeyBDcmVhdGVDb25uZWN0aW9uRHJhZ0hhbmRsZXIgfSBmcm9tICcuLi9jcmVhdGUtY29ubmVjdGlvbic7XG5pbXBvcnQgeyBSZWFzc2lnbkNvbm5lY3Rpb25EcmFnSGFuZGxlciB9IGZyb20gJy4uL3JlYXNzaWduLWNvbm5lY3Rpb24nO1xuXG5leHBvcnQgY2xhc3MgRmluZElucHV0c1VuZGVyUG9pbnRlclJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBldmVudDogSVBvaW50ZXJFdmVudCxcbiAgICBwdWJsaWMgZHJhZ0hhbmRsZXI6IENyZWF0ZUNvbm5lY3Rpb25EcmFnSGFuZGxlciB8IFJlYXNzaWduQ29ubmVjdGlvbkRyYWdIYW5kbGVyXG4gICkge1xuICB9XG59XG4iXX0=

package/esm2022/f-draggable/connections/find-inputs-under-pointer/first-not-connected-input-of-node-under-pointer/first-not-connected-input-of-node-under-pointer.handler.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../f-components-store";
+export class FirstNotConnectedInputOfNodeUnderPointerHandler {
+    get fNodes() {
+        return this.fComponentsStore.fNodes;
+    }
+    get fInputs() {
+        return this.fComponentsStore.fInputs;
+    }
+    constructor(fComponentsStore) {
+        this.fComponentsStore = fComponentsStore;
+    }
+    handle(event) {
+        const position = event.getPosition();
+        const elementsFromPoint = document.elementsFromPoint(position.x, position.y);
+        const nodes = elementsFromPoint.map((element) => {
+            return this.fNodes.find((x) => x.isContains(element));
+        }).filter((x) => !!x);
+        const inputs = nodes.map((x) => {
+            return this.fInputs.filter((i) => x.isContains(i.hostElement)).find((i) => {
+                return !i.isConnected && i.canBeConnected;
+            });
+        });
+        const result = inputs.find((x) => !!x);
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FirstNotConnectedInputOfNodeUnderPointerHandler, deps: [{ token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FirstNotConnectedInputOfNodeUnderPointerHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FirstNotConnectedInputOfNodeUnderPointerHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/connections/find-inputs-under-pointer/first-not-connected-input-of-node-under-pointer/index.mjs

@@ -0,0 +1,2 @@
+export * from './first-not-connected-input-of-node-under-pointer.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIvZmlyc3Qtbm90LWNvbm5lY3RlZC1pbnB1dC1vZi1ub2RlLXVuZGVyLXBvaW50ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyREFBMkQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlyc3Qtbm90LWNvbm5lY3RlZC1pbnB1dC1vZi1ub2RlLXVuZGVyLXBvaW50ZXIuaGFuZGxlcic7XG4iXX0=

package/esm2022/f-draggable/connections/find-inputs-under-pointer/index.mjs

@@ -0,0 +1,5 @@
+export * from './first-not-connected-input-of-node-under-pointer';
+export * from './inputs-under-pointer';
+export * from './find-inputs-under-pointer.request';
+export * from './find-inputs-under-pointer.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlyc3Qtbm90LWNvbm5lY3RlZC1pbnB1dC1vZi1ub2RlLXVuZGVyLXBvaW50ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9pbnB1dHMtdW5kZXItcG9pbnRlcic7XG5leHBvcnQgKiBmcm9tICcuL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIucmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIuaGFuZGxlcic7XG4iXX0=

package/esm2022/f-draggable/connections/find-inputs-under-pointer/inputs-under-pointer/index.mjs

@@ -0,0 +1,2 @@
+export * from './inputs-under-pointer.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2ZpbmQtaW5wdXRzLXVuZGVyLXBvaW50ZXIvaW5wdXRzLXVuZGVyLXBvaW50ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5wdXRzLXVuZGVyLXBvaW50ZXIuaGFuZGxlcic7XG4iXX0=

package/esm2022/f-draggable/connections/find-inputs-under-pointer/inputs-under-pointer/inputs-under-pointer.handler.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { isNodeInput } from '../../../../f-node';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../f-components-store";
+export class InputsUnderPointerHandler {
+    get fInputs() {
+        return this.fComponentsStore.fInputs;
+    }
+    constructor(fComponentsStore) {
+        this.fComponentsStore = fComponentsStore;
+    }
+    handle(event) {
+        const position = event.getPosition();
+        const elementsFromPoint = document.elementsFromPoint(position.x, position.y);
+        return elementsFromPoint.filter((x) => isNodeInput(x)).map((element) => {
+            return this.fInputs.find((x) => x.isContains(element));
+        }).filter((x) => !!x);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: InputsUnderPointerHandler, deps: [{ token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: InputsUnderPointerHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: InputsUnderPointerHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+export * from './create-connection';
+export * from './find-inputs-under-pointer';
+export * from './reassign-connection';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFFcEMsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jcmVhdGUtY29ubmVjdGlvbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZmluZC1pbnB1dHMtdW5kZXItcG9pbnRlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vcmVhc3NpZ24tY29ubmVjdGlvbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbiJdfQ==

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

@@ -0,0 +1,14 @@
+import { CreateConnectionOnPointerUp, CreateConnectionPrepareDragSequence, FindFirstCanBeConnectedOutputByOutletHandler } from './create-connection';
+import { FindInputsUnderPointerHandler, FirstNotConnectedInputOfNodeUnderPointerHandler, InputsUnderPointerHandler } from './find-inputs-under-pointer';
+import { ReassignConnectionOnPointerUp, ReassignConnectionPrepareDragSequence } from './reassign-connection';
+export const CONNECTIONS_PROVIDERS = [
+    FindFirstCanBeConnectedOutputByOutletHandler,
+    CreateConnectionOnPointerUp,
+    CreateConnectionPrepareDragSequence,
+    FirstNotConnectedInputOfNodeUnderPointerHandler,
+    InputsUnderPointerHandler,
+    FindInputsUnderPointerHandler,
+    ReassignConnectionOnPointerUp,
+    ReassignConnectionPrepareDragSequence
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9jb25uZWN0aW9ucy9wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixtQ0FBbUMsRUFDbkMsNENBQTRDLEVBQzdDLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwrQ0FBK0MsRUFDL0MseUJBQXlCLEVBQzFCLE1BQU0sNkJBQTZCLENBQUM7QUFDckMsT0FBTyxFQUFFLDZCQUE2QixFQUFFLHFDQUFxQyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFN0csTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUc7SUFFbkMsNENBQTRDO0lBRTVDLDJCQUEyQjtJQUUzQixtQ0FBbUM7SUFFbkMsK0NBQStDO0lBRS9DLHlCQUF5QjtJQUV6Qiw2QkFBNkI7SUFFN0IsNkJBQTZCO0lBRTdCLHFDQUFxQztDQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ3JlYXRlQ29ubmVjdGlvbk9uUG9pbnRlclVwLFxuICBDcmVhdGVDb25uZWN0aW9uUHJlcGFyZURyYWdTZXF1ZW5jZSxcbiAgRmluZEZpcnN0Q2FuQmVDb25uZWN0ZWRPdXRwdXRCeU91dGxldEhhbmRsZXJcbn0gZnJvbSAnLi9jcmVhdGUtY29ubmVjdGlvbic7XG5pbXBvcnQge1xuICBGaW5kSW5wdXRzVW5kZXJQb2ludGVySGFuZGxlcixcbiAgRmlyc3ROb3RDb25uZWN0ZWRJbnB1dE9mTm9kZVVuZGVyUG9pbnRlckhhbmRsZXIsXG4gIElucHV0c1VuZGVyUG9pbnRlckhhbmRsZXJcbn0gZnJvbSAnLi9maW5kLWlucHV0cy11bmRlci1wb2ludGVyJztcbmltcG9ydCB7IFJlYXNzaWduQ29ubmVjdGlvbk9uUG9pbnRlclVwLCBSZWFzc2lnbkNvbm5lY3Rpb25QcmVwYXJlRHJhZ1NlcXVlbmNlIH0gZnJvbSAnLi9yZWFzc2lnbi1jb25uZWN0aW9uJztcblxuZXhwb3J0IGNvbnN0IENPTk5FQ1RJT05TX1BST1ZJREVSUyA9IFtcblxuICBGaW5kRmlyc3RDYW5CZUNvbm5lY3RlZE91dHB1dEJ5T3V0bGV0SGFuZGxlcixcblxuICBDcmVhdGVDb25uZWN0aW9uT25Qb2ludGVyVXAsXG5cbiAgQ3JlYXRlQ29ubmVjdGlvblByZXBhcmVEcmFnU2VxdWVuY2UsXG5cbiAgRmlyc3ROb3RDb25uZWN0ZWRJbnB1dE9mTm9kZVVuZGVyUG9pbnRlckhhbmRsZXIsXG5cbiAgSW5wdXRzVW5kZXJQb2ludGVySGFuZGxlcixcblxuICBGaW5kSW5wdXRzVW5kZXJQb2ludGVySGFuZGxlcixcblxuICBSZWFzc2lnbkNvbm5lY3Rpb25PblBvaW50ZXJVcCxcblxuICBSZWFzc2lnbkNvbm5lY3Rpb25QcmVwYXJlRHJhZ1NlcXVlbmNlXG5dO1xuIl19

package/esm2022/f-draggable/connections/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './create-connection/public-api';
+export * from './reassign-connection/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvY29ubmVjdGlvbnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLGNBQWMsa0NBQWtDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1jb25uZWN0aW9uL3B1YmxpYy1hcGknO1xuXG5leHBvcnQgKiBmcm9tICcuL3JlYXNzaWduLWNvbm5lY3Rpb24vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/f-draggable/connections/reassign-connection/index.mjs

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

package/esm2022/f-draggable/connections/reassign-connection/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './reassign-connection.event';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvY29ubmVjdGlvbnMvcmVhc3NpZ24tY29ubmVjdGlvbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlYXNzaWduLWNvbm5lY3Rpb24uZXZlbnQnO1xuIl19

package/esm2022/f-draggable/connections/reassign-connection/reassign-connection.drag-handler.mjs

@@ -0,0 +1,37 @@
+import { RectExtensions } from '@foblex/core';
+import { EDraggableType } from '../../e-draggable-type';
+import { EConnectorSide, GetConnectionVectorRequest } from '../../../domain';
+export class ReassignConnectionDragHandler {
+    constructor(getInputRectInFlowHandler, getOutputRectInFlowHandler, getConnectionVectorHandler, connection) {
+        this.getInputRectInFlowHandler = getInputRectInFlowHandler;
+        this.getOutputRectInFlowHandler = getOutputRectInFlowHandler;
+        this.getConnectionVectorHandler = getConnectionVectorHandler;
+        this.connection = connection;
+        this.type = EDraggableType.REASSIGN_CONNECTION;
+        this.onPointerDownFromConnectorRect = RectExtensions.initialize();
+        this.onPointerDownToConnectorRect = RectExtensions.initialize();
+        this.outputSide = EConnectorSide.BOTTOM;
+        this.inputSide = EConnectorSide.TOP;
+    }
+    initialize() {
+        const fromConnector = this.getOutputRectInFlowHandler.handle(this.connection.outputId);
+        this.inputSide = this.getInputRectInFlowHandler.handle(this.connection.inputId).side;
+        this.outputSide = fromConnector.side;
+        this.onPointerDownFromConnectorRect = fromConnector.rect;
+        this.onPointerDownToConnectorRect = RectExtensions.initialize(this.connection.vector.point2.x, this.connection.vector.point2.y, 0, 0);
+    }
+    move(difference) {
+        const toRect = RectExtensions.addPoint(this.onPointerDownToConnectorRect, difference);
+        const vector = this.getConnectionVectorHandler.handle(new GetConnectionVectorRequest(this.onPointerDownFromConnectorRect, toRect, this.connection.behavior, this.outputSide, this.inputSide));
+        this.connection.setVector(vector.point1, this.outputSide, vector.point2, this.inputSide);
+        this.connection.redraw();
+    }
+    complete() {
+        const fromConnector = this.getOutputRectInFlowHandler.handle(this.connection.outputId);
+        const toConnector = this.getInputRectInFlowHandler.handle(this.connection.inputId);
+        const vector = this.getConnectionVectorHandler.handle(new GetConnectionVectorRequest(fromConnector.rect, toConnector.rect, this.connection.behavior, fromConnector.side, toConnector.side));
+        this.connection.setVector(vector.point1, fromConnector.side, vector.point2, toConnector.side);
+        this.connection.redraw();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/connections/reassign-connection/reassign-connection.event.mjs

@@ -0,0 +1,9 @@
+export class ReassignConnectionEvent {
+    constructor(connectionId, outputId, oldInputId, newInputId) {
+        this.connectionId = connectionId;
+        this.outputId = outputId;
+        this.oldInputId = oldInputId;
+        this.newInputId = newInputId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhc3NpZ24tY29ubmVjdGlvbi5ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvY29ubmVjdGlvbnMvcmVhc3NpZ24tY29ubmVjdGlvbi9yZWFzc2lnbi1jb25uZWN0aW9uLmV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyx1QkFBdUI7SUFFbEMsWUFDUyxZQUFlLEVBQ2YsUUFBVyxFQUNYLFVBQWEsRUFDYixVQUFhO1FBSGIsaUJBQVksR0FBWixZQUFZLENBQUc7UUFDZixhQUFRLEdBQVIsUUFBUSxDQUFHO1FBQ1gsZUFBVSxHQUFWLFVBQVUsQ0FBRztRQUNiLGVBQVUsR0FBVixVQUFVLENBQUc7SUFFdEIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFJlYXNzaWduQ29ubmVjdGlvbkV2ZW50PFQgPSBhbnk+IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgY29ubmVjdGlvbklkOiBULFxuICAgIHB1YmxpYyBvdXRwdXRJZDogVCxcbiAgICBwdWJsaWMgb2xkSW5wdXRJZDogVCxcbiAgICBwdWJsaWMgbmV3SW5wdXRJZDogVFxuICApIHtcbiAgfVxufVxuIl19

package/esm2022/f-draggable/connections/reassign-connection/reassign-connection.on-pointer-up.mjs

@@ -0,0 +1,36 @@
+import { EDraggableType } from '../../e-draggable-type';
+import { FindInputsUnderPointerRequest, ReassignConnectionEvent } from '../index';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-components-store";
+import * as i2 from "../../f-draggable-data-context";
+import * as i3 from "../index";
+export class ReassignConnectionOnPointerUp {
+    get fDraggable() {
+        return this.fComponentsStore.fDraggable;
+    }
+    constructor(fComponentsStore, fDraggableDataContext, findInputsUnderPointerHandler) {
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.findInputsUnderPointerHandler = findInputsUnderPointerHandler;
+    }
+    handle(event) {
+        const isReassignConnection = this.fDraggableDataContext.draggableItems.some((x) => x.type === EDraggableType.REASSIGN_CONNECTION);
+        if (isReassignConnection) {
+            const handler = this.fDraggableDataContext.draggableItems[0];
+            const inputsUnderPointer = this.findInputsUnderPointerHandler.handle(new FindInputsUnderPointerRequest(event, handler));
+            if (inputsUnderPointer.length > 0) {
+                if (handler.connection.inputId !== inputsUnderPointer[0]?.id) {
+                    this.fDraggable.fReassignConnection.emit(new ReassignConnectionEvent(handler.connection.id, handler.connection.outputId, handler.connection.inputId, inputsUnderPointer[0]?.id));
+                }
+            }
+            handler.complete();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: ReassignConnectionOnPointerUp, deps: [{ token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FindInputsUnderPointerHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: ReassignConnectionOnPointerUp }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: ReassignConnectionOnPointerUp, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FindInputsUnderPointerHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhc3NpZ24tY29ubmVjdGlvbi5vbi1wb2ludGVyLXVwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9jb25uZWN0aW9ucy9yZWFzc2lnbi1jb25uZWN0aW9uL3JlYXNzaWduLWNvbm5lY3Rpb24ub24tcG9pbnRlci11cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDeEQsT0FBTyxFQUVMLDZCQUE2QixFQUM3Qix1QkFBdUIsRUFDeEIsTUFBTSxVQUFVLENBQUM7QUFDbEIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7Ozs7QUFNM0MsTUFBTSxPQUFPLDZCQUE2QjtJQUd4QyxJQUFZLFVBQVU7UUFDcEIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsVUFBVyxDQUFDO0lBQzNDLENBQUM7SUFFRCxZQUNZLGdCQUFrQyxFQUNsQyxxQkFBNEMsRUFDNUMsNkJBQTREO1FBRjVELHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0I7UUFDbEMsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUF1QjtRQUM1QyxrQ0FBNkIsR0FBN0IsNkJBQTZCLENBQStCO0lBRXhFLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBb0I7UUFDaEMsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLENBQUMscUJBQXFCLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxjQUFjLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUNsSSxJQUFJLG9CQUFvQixFQUFFO1lBQ3hCLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxjQUFjLENBQUUsQ0FBQyxDQUFtQyxDQUFDO1lBRWhHLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLDZCQUE2QixDQUFDLE1BQU0sQ0FDbEUsSUFBSSw2QkFBNkIsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQ2xELENBQUM7WUFFRixJQUFJLGtCQUFrQixDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7Z0JBQ2pDLElBQUksT0FBTyxDQUFDLFVBQVUsQ0FBQyxPQUFPLEtBQUssa0JBQWtCLENBQUUsQ0FBQyxDQUFFLEVBQUUsRUFBRSxFQUFFO29CQUM5RCxJQUFJLENBQUMsVUFBVSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FDdEMsSUFBSSx1QkFBdUIsQ0FDekIsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFLEVBQUUsT0FBTyxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQ2xELE9BQU8sQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUMxQixrQkFBa0IsQ0FBRSxDQUFDLENBQUUsRUFBRSxFQUFFLENBQzVCLENBQ0YsQ0FBQztpQkFDSDthQUNGO1lBQ0QsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDO1NBQ3BCO0lBQ0gsQ0FBQzs4R0FwQ1UsNkJBQTZCO2tIQUE3Qiw2QkFBNkI7OzJGQUE3Qiw2QkFBNkI7a0JBRHpDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJSGFuZGxlciwgSVBvaW50ZXJFdmVudCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5pbXBvcnQgeyBSZWFzc2lnbkNvbm5lY3Rpb25EcmFnSGFuZGxlciB9IGZyb20gJy4vcmVhc3NpZ24tY29ubmVjdGlvbi5kcmFnLWhhbmRsZXInO1xuaW1wb3J0IHsgRURyYWdnYWJsZVR5cGUgfSBmcm9tICcuLi8uLi9lLWRyYWdnYWJsZS10eXBlJztcbmltcG9ydCB7XG4gIEZpbmRJbnB1dHNVbmRlclBvaW50ZXJIYW5kbGVyLFxuICBGaW5kSW5wdXRzVW5kZXJQb2ludGVyUmVxdWVzdCxcbiAgUmVhc3NpZ25Db25uZWN0aW9uRXZlbnRcbn0gZnJvbSAnLi4vaW5kZXgnO1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRkNvbXBvbmVudHNTdG9yZSB9IGZyb20gJy4uLy4uLy4uL2YtY29tcG9uZW50cy1zdG9yZSc7XG5pbXBvcnQgeyBGRHJhZ2dhYmxlRGF0YUNvbnRleHQgfSBmcm9tICcuLi8uLi9mLWRyYWdnYWJsZS1kYXRhLWNvbnRleHQnO1xuaW1wb3J0IHsgRkRyYWdnYWJsZUJhc2UgfSBmcm9tICcuLi8uLi9mLWRyYWdnYWJsZS1iYXNlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFJlYXNzaWduQ29ubmVjdGlvbk9uUG9pbnRlclVwXG4gIGltcGxlbWVudHMgSUhhbmRsZXI8SVBvaW50ZXJFdmVudCwgdm9pZD4ge1xuXG4gIHByaXZhdGUgZ2V0IGZEcmFnZ2FibGUoKTogRkRyYWdnYWJsZUJhc2Uge1xuICAgIHJldHVybiB0aGlzLmZDb21wb25lbnRzU3RvcmUuZkRyYWdnYWJsZSE7XG4gIH1cblxuICBjb25zdHJ1Y3RvcihcbiAgICAgIHByaXZhdGUgZkNvbXBvbmVudHNTdG9yZTogRkNvbXBvbmVudHNTdG9yZSxcbiAgICAgIHByaXZhdGUgZkRyYWdnYWJsZURhdGFDb250ZXh0OiBGRHJhZ2dhYmxlRGF0YUNvbnRleHQsXG4gICAgICBwcml2YXRlIGZpbmRJbnB1dHNVbmRlclBvaW50ZXJIYW5kbGVyOiBGaW5kSW5wdXRzVW5kZXJQb2ludGVySGFuZGxlclxuICApIHtcbiAgfVxuXG4gIHB1YmxpYyBoYW5kbGUoZXZlbnQ6IElQb2ludGVyRXZlbnQpOiB2b2lkIHtcbiAgICBjb25zdCBpc1JlYXNzaWduQ29ubmVjdGlvbiA9IHRoaXMuZkRyYWdnYWJsZURhdGFDb250ZXh0LmRyYWdnYWJsZUl0ZW1zLnNvbWUoKHgpID0+IHgudHlwZSA9PT0gRURyYWdnYWJsZVR5cGUuUkVBU1NJR05fQ09OTkVDVElPTik7XG4gICAgaWYgKGlzUmVhc3NpZ25Db25uZWN0aW9uKSB7XG4gICAgICBjb25zdCBoYW5kbGVyID0gdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuZHJhZ2dhYmxlSXRlbXNbIDAgXSBhcyBSZWFzc2lnbkNvbm5lY3Rpb25EcmFnSGFuZGxlcjtcblxuICAgICAgY29uc3QgaW5wdXRzVW5kZXJQb2ludGVyID0gdGhpcy5maW5kSW5wdXRzVW5kZXJQb2ludGVySGFuZGxlci5oYW5kbGUoXG4gICAgICAgIG5ldyBGaW5kSW5wdXRzVW5kZXJQb2ludGVyUmVxdWVzdChldmVudCwgaGFuZGxlcilcbiAgICAgICk7XG5cbiAgICAgIGlmIChpbnB1dHNVbmRlclBvaW50ZXIubGVuZ3RoID4gMCkge1xuICAgICAgICBpZiAoaGFuZGxlci5jb25uZWN0aW9uLmlucHV0SWQgIT09IGlucHV0c1VuZGVyUG9pbnRlclsgMCBdPy5pZCkge1xuICAgICAgICAgIHRoaXMuZkRyYWdnYWJsZS5mUmVhc3NpZ25Db25uZWN0aW9uLmVtaXQoXG4gICAgICAgICAgICBuZXcgUmVhc3NpZ25Db25uZWN0aW9uRXZlbnQoXG4gICAgICAgICAgICAgIGhhbmRsZXIuY29ubmVjdGlvbi5pZCwgaGFuZGxlci5jb25uZWN0aW9uLm91dHB1dElkLFxuICAgICAgICAgICAgICBoYW5kbGVyLmNvbm5lY3Rpb24uaW5wdXRJZCxcbiAgICAgICAgICAgICAgaW5wdXRzVW5kZXJQb2ludGVyWyAwIF0/LmlkXG4gICAgICAgICAgICApXG4gICAgICAgICAgKTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgICAgaGFuZGxlci5jb21wbGV0ZSgpO1xuICAgIH1cbiAgfVxufVxuIl19