@foblex/flow 18.0.0 → 18.1.1

package/esm2022/f-draggable/drag-canvas/drag-canvas-preparation/drag-canvas-preparation-request.mjs

@@ -0,0 +1,10 @@
+export class DragCanvasPreparationRequest {
+    event;
+    fTrigger;
+    static fToken = Symbol('DragCanvasPreparationRequest');
+    constructor(event, fTrigger) {
+        this.event = event;
+        this.fTrigger = fTrigger;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1jYW52YXMtcHJlcGFyYXRpb24tcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvZHJhZy1jYW52YXMvZHJhZy1jYW52YXMtcHJlcGFyYXRpb24vZHJhZy1jYW52YXMtcHJlcGFyYXRpb24tcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sNEJBQTRCO0lBR3JCO0lBQ0E7SUFIbEIsTUFBTSxDQUFVLE1BQU0sR0FBRyxNQUFNLENBQUMsOEJBQThCLENBQUMsQ0FBQztJQUNoRSxZQUNrQixLQUFvQixFQUNwQixRQUF1QjtRQUR2QixVQUFLLEdBQUwsS0FBSyxDQUFlO1FBQ3BCLGFBQVEsR0FBUixRQUFRLENBQWU7SUFDdEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZFdmVudFRyaWdnZXIgfSBmcm9tICcuLi8uLi8uLi9kb21haW4nO1xuaW1wb3J0IHsgSVBvaW50ZXJFdmVudCB9IGZyb20gJy4uLy4uLy4uL2RyYWctdG9vbGtpdCc7XG5cbmV4cG9ydCBjbGFzcyBEcmFnQ2FudmFzUHJlcGFyYXRpb25SZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnRHJhZ0NhbnZhc1ByZXBhcmF0aW9uUmVxdWVzdCcpO1xuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgcmVhZG9ubHkgZXZlbnQ6IElQb2ludGVyRXZlbnQsXG4gICAgcHVibGljIHJlYWRvbmx5IGZUcmlnZ2VyOiBGRXZlbnRUcmlnZ2VyLFxuICApIHt9XG59XG4iXX0=

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

@@ -0,0 +1,54 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { DragCanvasPreparationRequest } from './drag-canvas-preparation-request';
+import { Point } from '@foblex/2d';
+import { FExecutionRegister } from '@foblex/mediator';
+import { FComponentsStore, INSTANCES } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { DragCanvasHandler } from '../drag-canvas-handler';
+import { isValidEventTrigger } from '../../../domain';
+import { DragHandlerInjector } from '../../infrastructure';
+import * as i0 from "@angular/core";
+let DragCanvasPreparation = class DragCanvasPreparation {
+    _store = inject(FComponentsStore);
+    _dragContext = inject(FDraggableDataContext);
+    _dragInjector = inject(DragHandlerInjector);
+    handle({ event, fTrigger }) {
+        if (!this._isValid(event) || !this._isValidTrigger(event, fTrigger)) {
+            return;
+        }
+        this._dragContext.onPointerDownScale = 1;
+        this._dragContext.onPointerDownPosition = Point.fromPoint(event.getPosition()).elementTransform(this._store.flowHost);
+        this._dragContext.draggableItems = [this._dragInjector.get(DragCanvasHandler)];
+    }
+    _isValid(event) {
+        return (this._dragContext.isEmpty() &&
+            (this._isBackgroundElement(event.targetElement) || this._isDragOnHost(event.targetElement)));
+    }
+    _isBackgroundElement(targetElement) {
+        return this._store.instances.get(INSTANCES.BACKGROUND)?.hostElement.contains(targetElement);
+    }
+    _isDragOnHost(targetElement) {
+        return this._store.flowHost.contains(targetElement) && !this._getNode(targetElement);
+    }
+    _getNode(targetElement) {
+        let result = this._store.nodes.getAll().find((x) => x.isContains(targetElement));
+        if (result && result.fDraggingDisabled()) {
+            result = undefined;
+        }
+        return result;
+    }
+    _isValidTrigger(event, fTrigger) {
+        return isValidEventTrigger(event.originalEvent, fTrigger);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragCanvasPreparation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragCanvasPreparation });
+};
+DragCanvasPreparation = __decorate([
+    FExecutionRegister(DragCanvasPreparationRequest)
+], DragCanvasPreparation);
+export { DragCanvasPreparation };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragCanvasPreparation, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+export * from './drag-canvas-preparation';
+export * from './drag-canvas-preparation-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctY2FudmFzL2RyYWctY2FudmFzLXByZXBhcmF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFFMUMsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhZy1jYW52YXMtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL2RyYWctY2FudmFzLXByZXBhcmF0aW9uLXJlcXVlc3QnO1xuIl19

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

@@ -0,0 +1,5 @@
+export * from './drag-canvas-finalize';
+export * from './drag-canvas-handler';
+export * from './drag-canvas-preparation';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctY2FudmFzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyx1QkFBdUIsQ0FBQztBQUV0QyxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcmFnLWNhbnZhcy1maW5hbGl6ZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1jYW52YXMtaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1jYW52YXMtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGVycyc7XG4iXX0=

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

@@ -0,0 +1,4 @@
+import { DragCanvasPreparation } from './drag-canvas-preparation';
+import { DragCanvasFinalize } from './drag-canvas-finalize';
+export const DRAG_CANVAS_PROVIDERS = [DragCanvasFinalize, DragCanvasPreparation];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9kcmFnLWNhbnZhcy9wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbEUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFNUQsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxrQkFBa0IsRUFBRSxxQkFBcUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRHJhZ0NhbnZhc1ByZXBhcmF0aW9uIH0gZnJvbSAnLi9kcmFnLWNhbnZhcy1wcmVwYXJhdGlvbic7XG5pbXBvcnQgeyBEcmFnQ2FudmFzRmluYWxpemUgfSBmcm9tICcuL2RyYWctY2FudmFzLWZpbmFsaXplJztcblxuZXhwb3J0IGNvbnN0IERSQUdfQ0FOVkFTX1BST1ZJREVSUyA9IFtEcmFnQ2FudmFzRmluYWxpemUsIERyYWdDYW52YXNQcmVwYXJhdGlvbl07XG4iXX0=

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-drag-node-handler-from-selection-request.mjs

@@ -0,0 +1,8 @@
+export class AttachDragNodeHandlerFromSelectionRequest {
+    nodeOrGroup;
+    static fToken = Symbol('AttachDragNodeHandlerFromSelectionRequest');
+    constructor(nodeOrGroup) {
+        this.nodeOrGroup = nodeOrGroup;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0YWNoLWRyYWctbm9kZS1oYW5kbGVyLWZyb20tc2VsZWN0aW9uLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vYXR0YWNoLWRyYWctbm9kZS1oYW5kbGVyLWZyb20tc2VsZWN0aW9uLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLHlDQUF5QztJQUV4QjtJQUQ1QixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO0lBQzdFLFlBQTRCLFdBQXVCO1FBQXZCLGdCQUFXLEdBQVgsV0FBVyxDQUFZO0lBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZOb2RlQmFzZSB9IGZyb20gJy4uLy4uLy4uL2Ytbm9kZSc7XG5cbmV4cG9ydCBjbGFzcyBBdHRhY2hEcmFnTm9kZUhhbmRsZXJGcm9tU2VsZWN0aW9uUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0F0dGFjaERyYWdOb2RlSGFuZGxlckZyb21TZWxlY3Rpb25SZXF1ZXN0Jyk7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyByZWFkb25seSBub2RlT3JHcm91cD86IEZOb2RlQmFzZSkge31cbn1cbiJdfQ==

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-drag-node-handler-from-selection.mjs

@@ -0,0 +1,84 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { AttachDragNodeHandlerFromSelectionRequest } from './attach-drag-node-handler-from-selection-request';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { AttachSourceConnectionDragHandlersToNodeRequest } from './attach-source-connection-drag-handlers-to-node';
+import { AttachTargetConnectionDragHandlersToNodeRequest } from './attach-target-connection-drag-handlers-to-node';
+import { GetDeepChildrenNodesAndGroupsRequest } from '../../../domain';
+import { flatMap } from '@foblex/utils';
+import { CreateDragNodeHierarchyRequest } from './create-drag-node-hierarchy';
+import { CreateDragNodeHandlerRequest } from './create-drag-node-handler';
+import * as i0 from "@angular/core";
+// This execution is responsible for creating a drag model for moving nodes based on the current selection.
+let AttachDragNodeHandlerFromSelection = class AttachDragNodeHandlerFromSelection {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _dragSession = inject(FDraggableDataContext);
+    handle({ nodeOrGroup }) {
+        const selected = this._collectSelected(nodeOrGroup);
+        const selectedWithChildren = this._withDeepChildren(selected);
+        const hierarchy = this._mediator.execute(new CreateDragNodeHierarchyRequest(selectedWithChildren));
+        const selectedSourceConnectorIds = this._collectSourceConnectorIds(selectedWithChildren);
+        const selectedTargetConnectorIds = this._collectTargetConnectorIds(selectedWithChildren);
+        this._attachConnectionHandlers(hierarchy.participants, selectedSourceConnectorIds, selectedTargetConnectorIds);
+        return this._mediator.execute(new CreateDragNodeHandlerRequest(hierarchy.rootHandlers, hierarchy.participants));
+    }
+    _collectSelected(nodeOrGroup) {
+        const result = [];
+        for (const item of this._dragSession.selectedItems) {
+            const node = this._findNodeByHost(item.hostElement);
+            if (node) {
+                result.push(node);
+            }
+        }
+        if (nodeOrGroup && !result.includes(nodeOrGroup)) {
+            result.push(nodeOrGroup);
+        }
+        return result;
+    }
+    _findNodeByHost(host) {
+        return this._store.nodes.getAll().find((x) => x.isContains(host));
+    }
+    _withDeepChildren(nodes) {
+        const result = [];
+        for (const node of nodes) {
+            result.push(node);
+            const children = this._mediator.execute(new GetDeepChildrenNodesAndGroupsRequest(node.fId()));
+            result.push(...children);
+        }
+        return result;
+    }
+    _collectSourceConnectorIds(nodes) {
+        return flatMap(nodes, (n) => this._store.outputs
+            .getAll()
+            .filter((x) => x.fNodeId === n.fId())
+            .map((x) => x.fId()));
+    }
+    _collectTargetConnectorIds(nodes) {
+        return flatMap(nodes, (n) => this._store.inputs
+            .getAll()
+            .filter((x) => x.fNodeId === n.fId())
+            .map((x) => x.fId()));
+    }
+    _attachConnectionHandlers(participants, selectedSourceConnectorIds, selectedTargetConnectorIds) {
+        const handlerPool = [];
+        for (const handler of participants) {
+            // Source-side dragging depends on whether target side is inside selection
+            this._mediator.execute(new AttachSourceConnectionDragHandlersToNodeRequest(handler, selectedTargetConnectorIds, handlerPool));
+            // Target-side dragging depends on whether source side is inside selection
+            this._mediator.execute(new AttachTargetConnectionDragHandlersToNodeRequest(handler, selectedSourceConnectorIds, handlerPool));
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachDragNodeHandlerFromSelection, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachDragNodeHandlerFromSelection });
+};
+AttachDragNodeHandlerFromSelection = __decorate([
+    FExecutionRegister(AttachDragNodeHandlerFromSelectionRequest)
+], AttachDragNodeHandlerFromSelection);
+export { AttachDragNodeHandlerFromSelection };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachDragNodeHandlerFromSelection, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attach-drag-node-handler-from-selection.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-drag-node-handler-from-selection.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,yCAAyC,EAAE,MAAM,mDAAmD,CAAC;AAC9G,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAc,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,+CAA+C,EAAE,MAAM,kDAAkD,CAAC;AACnH,OAAO,EAAE,+CAA+C,EAAE,MAAM,kDAAkD,CAAC;AACnH,OAAO,EAAE,oCAAoC,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,8BAA8B,EAAqB,MAAM,8BAA8B,CAAC;AACjG,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;;AAE1E,2GAA2G;AAGpG,IAAM,kCAAkC,GAAxC,MAAM,kCAAkC;IAG5B,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAC9B,MAAM,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAClC,YAAY,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAEvD,MAAM,CAAC,EAAE,WAAW,EAA6C;QACtE,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;QACpD,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAE9D,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CACtC,IAAI,8BAA8B,CAAC,oBAAoB,CAAC,CACzD,CAAC;QAEF,MAAM,0BAA0B,GAAG,IAAI,CAAC,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;QACzF,MAAM,0BAA0B,GAAG,IAAI,CAAC,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;QAEzF,IAAI,CAAC,yBAAyB,CAC5B,SAAS,CAAC,YAAY,EACtB,0BAA0B,EAC1B,0BAA0B,CAC3B,CAAC;QAEF,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAC3B,IAAI,4BAA4B,CAAC,SAAS,CAAC,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC,CACjF,CAAC;IACJ,CAAC;IAEO,gBAAgB,CAAC,WAAuB;QAC9C,MAAM,MAAM,GAAgB,EAAE,CAAC;QAE/B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC;YACnD,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACpD,IAAI,IAAI,EAAE,CAAC;gBACT,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAED,IAAI,WAAW,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACjD,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,eAAe,CAAC,IAA8B;QACpD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;IACpE,CAAC;IAEO,iBAAiB,CAAC,KAAkB;QAC1C,MAAM,MAAM,GAAgB,EAAE,CAAC;QAE/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAElB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CACrC,IAAI,oCAAoC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CACrD,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,0BAA0B,CAAC,KAAkB;QACnD,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,MAAM,CAAC,OAAO;aAChB,MAAM,EAAE;aACR,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC;aACpC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CACvB,CAAC;IACJ,CAAC;IAEO,0BAA0B,CAAC,KAAkB;QACnD,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAC1B,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,MAAM,EAAE;aACR,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC;aACpC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CACvB,CAAC;IACJ,CAAC;IAEO,yBAAyB,CAC/B,YAAmC,EACnC,0BAAoC,EACpC,0BAAoC;QAEpC,MAAM,WAAW,GAAoC,EAAE,CAAC;QAExD,KAAK,MAAM,OAAO,IAAI,YAAY,EAAE,CAAC;YACnC,0EAA0E;YAC1E,IAAI,CAAC,SAAS,CAAC,OAAO,CACpB,IAAI,+CAA+C,CACjD,OAAO,EACP,0BAA0B,EAC1B,WAAW,CACZ,CACF,CAAC;YAEF,0EAA0E;YAC1E,IAAI,CAAC,SAAS,CAAC,OAAO,CACpB,IAAI,+CAA+C,CACjD,OAAO,EACP,0BAA0B,EAC1B,WAAW,CACZ,CACF,CAAC;QACJ,CAAC;IACH,CAAC;wGA9GU,kCAAkC;4GAAlC,kCAAkC;;AAAlC,kCAAkC;IAD9C,kBAAkB,CAAC,yCAAyC,CAAC;GACjD,kCAAkC,CA+G9C;;4FA/GY,kCAAkC;kBAF9C,UAAU","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { AttachDragNodeHandlerFromSelectionRequest } from './attach-drag-node-handler-from-selection-request';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { FNodeBase } from '../../../f-node';\nimport { AttachSourceConnectionDragHandlersToNodeRequest } from './attach-source-connection-drag-handlers-to-node';\nimport { AttachTargetConnectionDragHandlersToNodeRequest } from './attach-target-connection-drag-handlers-to-node';\nimport { GetDeepChildrenNodesAndGroupsRequest } from '../../../domain';\nimport { flatMap } from '@foblex/utils';\nimport { DragNodeConnectionHandlerBase } from '../drag-node-dependent-connection-handlers';\nimport { DragNodeHandler, DragNodeItemHandler } from '../drag-node-handler';\nimport { CreateDragNodeHierarchyRequest, DragNodeHierarchy } from './create-drag-node-hierarchy';\nimport { CreateDragNodeHandlerRequest } from './create-drag-node-handler';\n\n// This execution is responsible for creating a drag model for moving nodes based on the current selection.\n@Injectable()\n@FExecutionRegister(AttachDragNodeHandlerFromSelectionRequest)\nexport class AttachDragNodeHandlerFromSelection\n  implements IExecution<AttachDragNodeHandlerFromSelectionRequest, DragNodeHandler>\n{\n  private readonly _mediator = inject(FMediator);\n  private readonly _store = inject(FComponentsStore);\n  private readonly _dragSession = inject(FDraggableDataContext);\n\n  public handle({ nodeOrGroup }: AttachDragNodeHandlerFromSelectionRequest): DragNodeHandler {\n    const selected = this._collectSelected(nodeOrGroup);\n    const selectedWithChildren = this._withDeepChildren(selected);\n\n    const hierarchy = this._mediator.execute<DragNodeHierarchy>(\n      new CreateDragNodeHierarchyRequest(selectedWithChildren),\n    );\n\n    const selectedSourceConnectorIds = this._collectSourceConnectorIds(selectedWithChildren);\n    const selectedTargetConnectorIds = this._collectTargetConnectorIds(selectedWithChildren);\n\n    this._attachConnectionHandlers(\n      hierarchy.participants,\n      selectedSourceConnectorIds,\n      selectedTargetConnectorIds,\n    );\n\n    return this._mediator.execute(\n      new CreateDragNodeHandlerRequest(hierarchy.rootHandlers, hierarchy.participants),\n    );\n  }\n\n  private _collectSelected(nodeOrGroup?: FNodeBase): FNodeBase[] {\n    const result: FNodeBase[] = [];\n\n    for (const item of this._dragSession.selectedItems) {\n      const node = this._findNodeByHost(item.hostElement);\n      if (node) {\n        result.push(node);\n      }\n    }\n\n    if (nodeOrGroup && !result.includes(nodeOrGroup)) {\n      result.push(nodeOrGroup);\n    }\n\n    return result;\n  }\n\n  private _findNodeByHost(host: HTMLElement | SVGElement): FNodeBase | undefined {\n    return this._store.nodes.getAll().find((x) => x.isContains(host));\n  }\n\n  private _withDeepChildren(nodes: FNodeBase[]): FNodeBase[] {\n    const result: FNodeBase[] = [];\n\n    for (const node of nodes) {\n      result.push(node);\n\n      const children = this._mediator.execute<FNodeBase[]>(\n        new GetDeepChildrenNodesAndGroupsRequest(node.fId()),\n      );\n\n      result.push(...children);\n    }\n\n    return result;\n  }\n\n  private _collectSourceConnectorIds(nodes: FNodeBase[]): string[] {\n    return flatMap(nodes, (n) =>\n      this._store.outputs\n        .getAll()\n        .filter((x) => x.fNodeId === n.fId())\n        .map((x) => x.fId()),\n    );\n  }\n\n  private _collectTargetConnectorIds(nodes: FNodeBase[]): string[] {\n    return flatMap(nodes, (n) =>\n      this._store.inputs\n        .getAll()\n        .filter((x) => x.fNodeId === n.fId())\n        .map((x) => x.fId()),\n    );\n  }\n\n  private _attachConnectionHandlers(\n    participants: DragNodeItemHandler[],\n    selectedSourceConnectorIds: string[],\n    selectedTargetConnectorIds: string[],\n  ): void {\n    const handlerPool: DragNodeConnectionHandlerBase[] = [];\n\n    for (const handler of participants) {\n      // Source-side dragging depends on whether target side is inside selection\n      this._mediator.execute(\n        new AttachSourceConnectionDragHandlersToNodeRequest(\n          handler,\n          selectedTargetConnectorIds,\n          handlerPool,\n        ),\n      );\n\n      // Target-side dragging depends on whether source side is inside selection\n      this._mediator.execute(\n        new AttachTargetConnectionDragHandlersToNodeRequest(\n          handler,\n          selectedSourceConnectorIds,\n          handlerPool,\n        ),\n      );\n    }\n  }\n}\n"]}

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/attach-source-connection-drag-handlers-to-node-request.mjs

@@ -0,0 +1,23 @@
+export class AttachSourceConnectionDragHandlersToNodeRequest {
+    dragHandler;
+    targetIds;
+    handlerPool;
+    static fToken = Symbol('AttachSourceConnectionDragHandlersToNodeRequest');
+    constructor(
+    /** Node move handler we attach connection handlers to. */
+    dragHandler, 
+    /**
+     * Connectors considered "target side" for connections (previously: inputIds).
+     * These are target connector ids that are within current drag selection.
+     */
+    targetIds, 
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    handlerPool) {
+        this.dragHandler = dragHandler;
+        this.targetIds = targetIds;
+        this.handlerPool = handlerPool;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0YWNoLXNvdXJjZS1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9kcmFnLW5vZGUvYXR0YWNoLWRyYWctbm9kZS1oYW5kbGVyLWZyb20tc2VsZWN0aW9uL2F0dGFjaC1zb3VyY2UtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUvYXR0YWNoLXNvdXJjZS1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTywrQ0FBK0M7SUFLeEM7SUFNQTtJQUtBO0lBZmxCLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGlEQUFpRCxDQUFDLENBQUM7SUFFbkY7SUFDRSwwREFBMEQ7SUFDMUMsV0FBZ0M7SUFFaEQ7OztPQUdHO0lBQ2EsU0FBbUI7SUFFbkM7O09BRUc7SUFDYSxXQUE0QztRQVg1QyxnQkFBVyxHQUFYLFdBQVcsQ0FBcUI7UUFNaEMsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUtuQixnQkFBVyxHQUFYLFdBQVcsQ0FBaUM7SUFDM0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERyYWdOb2RlQ29ubmVjdGlvbkhhbmRsZXJCYXNlIH0gZnJvbSAnLi4vLi4vZHJhZy1ub2RlLWRlcGVuZGVudC1jb25uZWN0aW9uLWhhbmRsZXJzJztcbmltcG9ydCB7IERyYWdOb2RlSXRlbUhhbmRsZXIgfSBmcm9tICcuLi8uLi9kcmFnLW5vZGUtaGFuZGxlcic7XG5cbmV4cG9ydCBjbGFzcyBBdHRhY2hTb3VyY2VDb25uZWN0aW9uRHJhZ0hhbmRsZXJzVG9Ob2RlUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0F0dGFjaFNvdXJjZUNvbm5lY3Rpb25EcmFnSGFuZGxlcnNUb05vZGVSZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgLyoqIE5vZGUgbW92ZSBoYW5kbGVyIHdlIGF0dGFjaCBjb25uZWN0aW9uIGhhbmRsZXJzIHRvLiAqL1xuICAgIHB1YmxpYyByZWFkb25seSBkcmFnSGFuZGxlcjogRHJhZ05vZGVJdGVtSGFuZGxlcixcblxuICAgIC8qKlxuICAgICAqIENvbm5lY3RvcnMgY29uc2lkZXJlZCBcInRhcmdldCBzaWRlXCIgZm9yIGNvbm5lY3Rpb25zIChwcmV2aW91c2x5OiBpbnB1dElkcykuXG4gICAgICogVGhlc2UgYXJlIHRhcmdldCBjb25uZWN0b3IgaWRzIHRoYXQgYXJlIHdpdGhpbiBjdXJyZW50IGRyYWcgc2VsZWN0aW9uLlxuICAgICAqL1xuICAgIHB1YmxpYyByZWFkb25seSB0YXJnZXRJZHM6IHN0cmluZ1tdLFxuXG4gICAgLyoqXG4gICAgICogU2hhcmVkIHBvb2wgdG8gcmV1c2UgYWxyZWFkeSBjcmVhdGVkIGhhbmRsZXJzIGZvciB0aGUgc2FtZSBjb25uZWN0aW9uLlxuICAgICAqL1xuICAgIHB1YmxpYyByZWFkb25seSBoYW5kbGVyUG9vbDogRHJhZ05vZGVDb25uZWN0aW9uSGFuZGxlckJhc2VbXSxcbiAgKSB7fVxufVxuIl19

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/attach-source-connection-drag-handlers-to-node.mjs

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { AttachSourceConnectionDragHandlersToNodeRequest } from './attach-source-connection-drag-handlers-to-node-request';
+import { FComponentsStore } from '../../../../f-storage';
+import { FExecutionRegister } from '@foblex/mediator';
+import { DragNodeConnectionBothSidesHandler, DragNodeConnectionSourceHandler, } from '../../drag-node-dependent-connection-handlers';
+import { DragHandlerInjector } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+let AttachSourceConnectionDragHandlersToNode = class AttachSourceConnectionDragHandlersToNode {
+    _store = inject(FComponentsStore);
+    _dragInjector = inject(DragHandlerInjector);
+    get _connections() {
+        return this._store.connections.getAll();
+    }
+    handle(request) {
+        this._getOutputConnections(request.dragHandler.nodeOrGroup).forEach((fConnection) => {
+            this._createAndSetConnectionToNodeHandler(fConnection, request);
+        });
+    }
+    _getOutputConnections(nodeOrGroup) {
+        const ids = new Set(this._getNodeOutputIds(nodeOrGroup));
+        return this._connections.filter((x) => ids.has(x.fOutputId()));
+    }
+    _getNodeOutputIds(nodeOrGroup) {
+        return this._store.outputs
+            .getAll()
+            .filter((x) => nodeOrGroup.isContains(x.hostElement))
+            .map((x) => x.fId());
+    }
+    _createAndSetConnectionToNodeHandler(connection, request) {
+        let connectionHandler = this._getExistingConnectionHandler(request.handlerPool, connection);
+        if (!connectionHandler) {
+            connectionHandler = this._createConnectionHandler(request.targetIds, connection);
+            request.handlerPool.push(connectionHandler);
+        }
+        request.dragHandler.sourceConnectionHandlers.push(connectionHandler);
+    }
+    _getExistingConnectionHandler(existingConnectionHandlers, connection) {
+        return existingConnectionHandlers.find((x) => x.connection.fId() === connection.fId());
+    }
+    _createConnectionHandler(inputIds, connection) {
+        let result;
+        if (inputIds.includes(connection.fInputId())) {
+            result = this._dragInjector.createInstance(DragNodeConnectionBothSidesHandler);
+        }
+        else {
+            result = this._dragInjector.createInstance(DragNodeConnectionSourceHandler);
+        }
+        result.initialize(connection);
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachSourceConnectionDragHandlersToNode, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachSourceConnectionDragHandlersToNode });
+};
+AttachSourceConnectionDragHandlersToNode = __decorate([
+    FExecutionRegister(AttachSourceConnectionDragHandlersToNodeRequest)
+], AttachSourceConnectionDragHandlersToNode);
+export { AttachSourceConnectionDragHandlersToNode };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachSourceConnectionDragHandlersToNode, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/index.mjs

@@ -0,0 +1,3 @@
+export * from './attach-source-connection-drag-handlers-to-node';
+export * from './attach-source-connection-drag-handlers-to-node-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vYXR0YWNoLXNvdXJjZS1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtEQUFrRCxDQUFDO0FBRWpFLGNBQWMsMERBQTBELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F0dGFjaC1zb3VyY2UtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2F0dGFjaC1zb3VyY2UtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUtcmVxdWVzdCc7XG4iXX0=

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/attach-target-connection-drag-handlers-to-node-request.mjs

@@ -0,0 +1,23 @@
+export class AttachTargetConnectionDragHandlersToNodeRequest {
+    dragHandler;
+    sourceIds;
+    handlerPool;
+    static fToken = Symbol('AttachTargetConnectionDragHandlersToNodeRequest');
+    constructor(
+    /** Node move handler we attach connection handlers to. */
+    dragHandler, 
+    /**
+     * Connectors considered "source side" for connections (previously: outputIds).
+     * These are source connector ids that are within current drag selection.
+     */
+    sourceIds, 
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    handlerPool) {
+        this.dragHandler = dragHandler;
+        this.sourceIds = sourceIds;
+        this.handlerPool = handlerPool;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0YWNoLXRhcmdldC1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9kcmFnLW5vZGUvYXR0YWNoLWRyYWctbm9kZS1oYW5kbGVyLWZyb20tc2VsZWN0aW9uL2F0dGFjaC10YXJnZXQtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUvYXR0YWNoLXRhcmdldC1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTywrQ0FBK0M7SUFLeEM7SUFNQTtJQUtBO0lBZmxCLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGlEQUFpRCxDQUFDLENBQUM7SUFFbkY7SUFDRSwwREFBMEQ7SUFDMUMsV0FBZ0M7SUFFaEQ7OztPQUdHO0lBQ2EsU0FBbUI7SUFFbkM7O09BRUc7SUFDYSxXQUE0QztRQVg1QyxnQkFBVyxHQUFYLFdBQVcsQ0FBcUI7UUFNaEMsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUtuQixnQkFBVyxHQUFYLFdBQVcsQ0FBaUM7SUFDM0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERyYWdOb2RlQ29ubmVjdGlvbkhhbmRsZXJCYXNlIH0gZnJvbSAnLi4vLi4vZHJhZy1ub2RlLWRlcGVuZGVudC1jb25uZWN0aW9uLWhhbmRsZXJzJztcbmltcG9ydCB7IERyYWdOb2RlSXRlbUhhbmRsZXIgfSBmcm9tICcuLi8uLi9kcmFnLW5vZGUtaGFuZGxlcic7XG5cbmV4cG9ydCBjbGFzcyBBdHRhY2hUYXJnZXRDb25uZWN0aW9uRHJhZ0hhbmRsZXJzVG9Ob2RlUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0F0dGFjaFRhcmdldENvbm5lY3Rpb25EcmFnSGFuZGxlcnNUb05vZGVSZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgLyoqIE5vZGUgbW92ZSBoYW5kbGVyIHdlIGF0dGFjaCBjb25uZWN0aW9uIGhhbmRsZXJzIHRvLiAqL1xuICAgIHB1YmxpYyByZWFkb25seSBkcmFnSGFuZGxlcjogRHJhZ05vZGVJdGVtSGFuZGxlcixcblxuICAgIC8qKlxuICAgICAqIENvbm5lY3RvcnMgY29uc2lkZXJlZCBcInNvdXJjZSBzaWRlXCIgZm9yIGNvbm5lY3Rpb25zIChwcmV2aW91c2x5OiBvdXRwdXRJZHMpLlxuICAgICAqIFRoZXNlIGFyZSBzb3VyY2UgY29ubmVjdG9yIGlkcyB0aGF0IGFyZSB3aXRoaW4gY3VycmVudCBkcmFnIHNlbGVjdGlvbi5cbiAgICAgKi9cbiAgICBwdWJsaWMgcmVhZG9ubHkgc291cmNlSWRzOiBzdHJpbmdbXSxcblxuICAgIC8qKlxuICAgICAqIFNoYXJlZCBwb29sIHRvIHJldXNlIGFscmVhZHkgY3JlYXRlZCBoYW5kbGVycyBmb3IgdGhlIHNhbWUgY29ubmVjdGlvbi5cbiAgICAgKi9cbiAgICBwdWJsaWMgcmVhZG9ubHkgaGFuZGxlclBvb2w6IERyYWdOb2RlQ29ubmVjdGlvbkhhbmRsZXJCYXNlW10sXG4gICkge31cbn1cbiJdfQ==

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/attach-target-connection-drag-handlers-to-node.mjs

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { AttachTargetConnectionDragHandlersToNodeRequest } from './attach-target-connection-drag-handlers-to-node-request';
+import { FComponentsStore } from '../../../../f-storage';
+import { FExecutionRegister } from '@foblex/mediator';
+import { DragNodeConnectionBothSidesHandler, DragNodeConnectionTargetHandler, } from '../../drag-node-dependent-connection-handlers';
+import { DragHandlerInjector } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+let AttachTargetConnectionDragHandlersToNode = class AttachTargetConnectionDragHandlersToNode {
+    _store = inject(FComponentsStore);
+    _dragInjector = inject(DragHandlerInjector);
+    get _connections() {
+        return this._store.connections.getAll();
+    }
+    handle(request) {
+        this._getInputConnections(request.dragHandler.nodeOrGroup).forEach((connection) => {
+            this._createAndSetConnectionToNodeHandler(connection, request);
+        });
+    }
+    _getInputConnections(nodeOrGroup) {
+        const ids = new Set(this._getNodeInputIds(nodeOrGroup));
+        return this._connections.filter((x) => ids.has(x.fInputId()));
+    }
+    _getNodeInputIds(nodeOrGroup) {
+        return this._store.inputs
+            .getAll()
+            .filter((x) => nodeOrGroup.isContains(x.hostElement))
+            .map((x) => x.fId());
+    }
+    _createAndSetConnectionToNodeHandler(connection, request) {
+        let connectionHandler = this._getExistingConnectionHandler(request.handlerPool, connection);
+        if (!connectionHandler) {
+            connectionHandler = this._createConnectionHandler(request.sourceIds, connection);
+            request.handlerPool.push(connectionHandler);
+        }
+        request.dragHandler.targetConnectionHandlers.push(connectionHandler);
+    }
+    _getExistingConnectionHandler(existingConnectionHandlers, connection) {
+        return existingConnectionHandlers.find((x) => x.connection.fId() === connection.fId());
+    }
+    _createConnectionHandler(outputIds, connection) {
+        let result;
+        if (outputIds.includes(connection.fOutputId())) {
+            result = this._dragInjector.createInstance(DragNodeConnectionBothSidesHandler);
+        }
+        else {
+            result = this._dragInjector.createInstance(DragNodeConnectionTargetHandler);
+        }
+        result.initialize(connection);
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachTargetConnectionDragHandlersToNode, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachTargetConnectionDragHandlersToNode });
+};
+AttachTargetConnectionDragHandlersToNode = __decorate([
+    FExecutionRegister(AttachTargetConnectionDragHandlersToNodeRequest)
+], AttachTargetConnectionDragHandlersToNode);
+export { AttachTargetConnectionDragHandlersToNode };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachTargetConnectionDragHandlersToNode, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/index.mjs

@@ -0,0 +1,3 @@
+export * from './attach-target-connection-drag-handlers-to-node';
+export * from './attach-target-connection-drag-handlers-to-node-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vYXR0YWNoLXRhcmdldC1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtEQUFrRCxDQUFDO0FBRWpFLGNBQWMsMERBQTBELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F0dGFjaC10YXJnZXQtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2F0dGFjaC10YXJnZXQtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUtcmVxdWVzdCc7XG4iXX0=

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/build-drag-node-constraints-request.mjs

@@ -0,0 +1,8 @@
+export class BuildDragNodeConstraintsRequest {
+    nodeOrGroup;
+    static fToken = Symbol('BuildDragNodeConstraintsRequest');
+    constructor(nodeOrGroup) {
+        this.nodeOrGroup = nodeOrGroup;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtZHJhZy1ub2RlLWNvbnN0cmFpbnRzLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vYnVpbGQtZHJhZy1ub2RlLWNvbnN0cmFpbnRzL2J1aWxkLWRyYWctbm9kZS1jb25zdHJhaW50cy1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTywrQkFBK0I7SUFHZDtJQUY1QixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO0lBRW5FLFlBQTRCLFdBQXNCO1FBQXRCLGdCQUFXLEdBQVgsV0FBVyxDQUFXO0lBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZOb2RlQmFzZSB9IGZyb20gJy4uLy4uLy4uLy4uL2Ytbm9kZSc7XG5cbmV4cG9ydCBjbGFzcyBCdWlsZERyYWdOb2RlQ29uc3RyYWludHNSZXF1ZXN0IHtcbiAgc3RhdGljIHJlYWRvbmx5IGZUb2tlbiA9IFN5bWJvbCgnQnVpbGREcmFnTm9kZUNvbnN0cmFpbnRzUmVxdWVzdCcpO1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyByZWFkb25seSBub2RlT3JHcm91cDogRk5vZGVCYXNlKSB7fVxufVxuIl19

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/build-drag-node-constraints.mjs

@@ -0,0 +1,72 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { PointExtensions } from '@foblex/2d';
+import { BuildDragNodeConstraintsRequest } from './build-drag-node-constraints-request';
+import { infinityMinMax } from '../../../../utils';
+import { GetNormalizedElementRectRequest, GetParentNodesRequest } from '../../../../domain';
+import { ReadNodeBoundsWithPaddingsRequest, } from '../read-node-bounds-with-paddings';
+import * as i0 from "@angular/core";
+let BuildDragNodeConstraints = class BuildDragNodeConstraints {
+    _mediator = inject(FMediator);
+    handle({ nodeOrGroup }) {
+        const currentRect = this._readCurrentRect(nodeOrGroup);
+        const parents = this._readParentsChain(nodeOrGroup);
+        return this._buildConstraints(parents, currentRect);
+    }
+    _readCurrentRect(nodeOrGroup) {
+        return this._mediator.execute(new GetNormalizedElementRectRequest(nodeOrGroup.hostElement));
+    }
+    _readParentsChain(nodeOrGroup) {
+        return this._mediator.execute(new GetParentNodesRequest(nodeOrGroup)) ?? [];
+    }
+    _buildConstraints(parents, childRect) {
+        const soft = [];
+        let hard = infinityMinMax();
+        let childrenPaddings = [0, 0, 0, 0];
+        for (const parent of parents) {
+            const parentInfo = this._readParentBounds(parent, childrenPaddings);
+            childrenPaddings = parentInfo.paddings;
+            const limits = this._calculateDifference(parentInfo.innerRect, childRect);
+            if (this._isAutoExpand(parent)) {
+                soft.push(this._makeSoftLimit(parent, parentInfo.boundingRect, limits));
+            }
+            else {
+                hard = limits;
+                break;
+            }
+        }
+        return { soft, hard };
+    }
+    _readParentBounds(parent, childrenPaddings) {
+        return this._mediator.execute(new ReadNodeBoundsWithPaddingsRequest(parent, childrenPaddings));
+    }
+    _calculateDifference(parentRect, currentRect) {
+        return {
+            min: this._calculateMinimumDifference(parentRect, currentRect),
+            max: this._calculateMaximumDifference(parentRect, currentRect),
+        };
+    }
+    _calculateMinimumDifference(parentRect, currentRect) {
+        return PointExtensions.initialize(parentRect.x - currentRect.x, parentRect.y - currentRect.y);
+    }
+    _calculateMaximumDifference(parentRect, currentRect) {
+        return PointExtensions.initialize(parentRect.x + parentRect.width - (currentRect.x + currentRect.width), parentRect.y + parentRect.height - (currentRect.y + currentRect.height));
+    }
+    _isAutoExpand(nodeOrGroup) {
+        return nodeOrGroup.fAutoExpandOnChildHit();
+    }
+    _makeSoftLimit(nodeOrGroup, boundingRect, limits) {
+        return { nodeOrGroup, boundingRect, initialSize: nodeOrGroup._size, limits };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BuildDragNodeConstraints, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BuildDragNodeConstraints });
+};
+BuildDragNodeConstraints = __decorate([
+    FExecutionRegister(BuildDragNodeConstraintsRequest)
+], BuildDragNodeConstraints);
+export { BuildDragNodeConstraints };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BuildDragNodeConstraints, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-drag-node-constraints.js","sourceRoot":"","sources":["../../../../../../../projects/f-flow/src/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/build-drag-node-constraints.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { IMinMaxPoint, IPoint, IRect, PointExtensions } from '@foblex/2d';\nimport { BuildDragNodeConstraintsRequest } from './build-drag-node-constraints-request';\nimport { infinityMinMax } from '../../../../utils';\nimport { FNodeBase } from '../../../../f-node';\nimport { GetNormalizedElementRectRequest, GetParentNodesRequest } from '../../../../domain';\nimport {\n  ReadNodeBoundsWithPaddingsRequest,\n  ReadNodeBoundsWithPaddingsResponse,\n} from '../read-node-bounds-with-paddings';\nimport { IDragNodeDeltaConstraints, IDragNodeSoftConstraint } from '../../drag-node-constraint';\n\n@Injectable()\n@FExecutionRegister(BuildDragNodeConstraintsRequest)\nexport class BuildDragNodeConstraints\n  implements IExecution<BuildDragNodeConstraintsRequest, IDragNodeDeltaConstraints>\n{\n  private readonly _mediator = inject(FMediator);\n\n  public handle({ nodeOrGroup }: BuildDragNodeConstraintsRequest): IDragNodeDeltaConstraints {\n    const currentRect = this._readCurrentRect(nodeOrGroup);\n    const parents = this._readParentsChain(nodeOrGroup);\n\n    return this._buildConstraints(parents, currentRect);\n  }\n\n  private _readCurrentRect(nodeOrGroup: FNodeBase): IRect {\n    return this._mediator.execute<IRect>(\n      new GetNormalizedElementRectRequest(nodeOrGroup.hostElement),\n    );\n  }\n\n  private _readParentsChain(nodeOrGroup: FNodeBase): FNodeBase[] {\n    return this._mediator.execute<FNodeBase[]>(new GetParentNodesRequest(nodeOrGroup)) ?? [];\n  }\n\n  private _buildConstraints(parents: FNodeBase[], childRect: IRect): IDragNodeDeltaConstraints {\n    const soft: IDragNodeSoftConstraint[] = [];\n    let hard: IMinMaxPoint = infinityMinMax();\n\n    let childrenPaddings: [number, number, number, number] = [0, 0, 0, 0];\n\n    for (const parent of parents) {\n      const parentInfo = this._readParentBounds(parent, childrenPaddings);\n      childrenPaddings = parentInfo.paddings;\n      const limits = this._calculateDifference(parentInfo.innerRect, childRect);\n\n      if (this._isAutoExpand(parent)) {\n        soft.push(this._makeSoftLimit(parent, parentInfo.boundingRect, limits));\n      } else {\n        hard = limits;\n        break;\n      }\n    }\n\n    return { soft, hard };\n  }\n\n  private _readParentBounds(\n    parent: FNodeBase,\n    childrenPaddings: [number, number, number, number],\n  ): ReadNodeBoundsWithPaddingsResponse {\n    return this._mediator.execute<ReadNodeBoundsWithPaddingsResponse>(\n      new ReadNodeBoundsWithPaddingsRequest(parent, childrenPaddings),\n    );\n  }\n\n  private _calculateDifference(parentRect: IRect, currentRect: IRect): IMinMaxPoint {\n    return {\n      min: this._calculateMinimumDifference(parentRect, currentRect),\n      max: this._calculateMaximumDifference(parentRect, currentRect),\n    };\n  }\n\n  private _calculateMinimumDifference(parentRect: IRect, currentRect: IRect): IPoint {\n    return PointExtensions.initialize(parentRect.x - currentRect.x, parentRect.y - currentRect.y);\n  }\n\n  private _calculateMaximumDifference(parentRect: IRect, currentRect: IRect): IPoint {\n    return PointExtensions.initialize(\n      parentRect.x + parentRect.width - (currentRect.x + currentRect.width),\n      parentRect.y + parentRect.height - (currentRect.y + currentRect.height),\n    );\n  }\n\n  private _isAutoExpand(nodeOrGroup: FNodeBase): boolean {\n    return nodeOrGroup.fAutoExpandOnChildHit();\n  }\n\n  private _makeSoftLimit(\n    nodeOrGroup: FNodeBase,\n    boundingRect: IRect,\n    limits: IMinMaxPoint,\n  ): IDragNodeSoftConstraint {\n    return { nodeOrGroup, boundingRect, initialSize: nodeOrGroup._size, limits };\n  }\n}\n"]}

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/index.mjs

@@ -0,0 +1,3 @@
+export * from './build-drag-node-constraints';
+export * from './build-drag-node-constraints-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vYnVpbGQtZHJhZy1ub2RlLWNvbnN0cmFpbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUM7QUFFOUMsY0FBYyx1Q0FBdUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnVpbGQtZHJhZy1ub2RlLWNvbnN0cmFpbnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9idWlsZC1kcmFnLW5vZGUtY29uc3RyYWludHMtcmVxdWVzdCc7XG4iXX0=

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-handler/create-drag-node-handler-request.mjs

@@ -0,0 +1,14 @@
+export class CreateDragNodeHandlerRequest {
+    rootHandlers;
+    participants;
+    static fToken = Symbol('CreateDragNodeHandlerRequest');
+    constructor(
+    /** Root handlers (handlers without parents in the selection). */
+    rootHandlers, 
+    /** All handlers participating in the drag operation. */
+    participants) {
+        this.rootHandlers = rootHandlers;
+        this.participants = participants;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWRyYWctbm9kZS1oYW5kbGVyLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24vY3JlYXRlLWRyYWctbm9kZS1oYW5kbGVyL2NyZWF0ZS1kcmFnLW5vZGUtaGFuZGxlci1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyw0QkFBNEI7SUFLckI7SUFHQTtJQVBsQixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO0lBRWhFO0lBQ0UsaUVBQWlFO0lBQ2pELFlBQW1DO0lBRW5ELHdEQUF3RDtJQUN4QyxZQUFtQztRQUhuQyxpQkFBWSxHQUFaLFlBQVksQ0FBdUI7UUFHbkMsaUJBQVksR0FBWixZQUFZLENBQXVCO0lBQ2xELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEcmFnTm9kZUl0ZW1IYW5kbGVyIH0gZnJvbSAnLi4vLi4vZHJhZy1ub2RlLWhhbmRsZXInO1xuXG5leHBvcnQgY2xhc3MgQ3JlYXRlRHJhZ05vZGVIYW5kbGVyUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0NyZWF0ZURyYWdOb2RlSGFuZGxlclJlcXVlc3QnKTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICAvKiogUm9vdCBoYW5kbGVycyAoaGFuZGxlcnMgd2l0aG91dCBwYXJlbnRzIGluIHRoZSBzZWxlY3Rpb24pLiAqL1xuICAgIHB1YmxpYyByZWFkb25seSByb290SGFuZGxlcnM6IERyYWdOb2RlSXRlbUhhbmRsZXJbXSxcblxuICAgIC8qKiBBbGwgaGFuZGxlcnMgcGFydGljaXBhdGluZyBpbiB0aGUgZHJhZyBvcGVyYXRpb24uICovXG4gICAgcHVibGljIHJlYWRvbmx5IHBhcnRpY2lwYW50czogRHJhZ05vZGVJdGVtSGFuZGxlcltdLFxuICApIHt9XG59XG4iXX0=

package/esm2022/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-handler/create-drag-node-handler.mjs

@@ -0,0 +1,36 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { CreateDragNodeHandlerRequest } from './create-drag-node-handler-request';
+import { DragNodeHandler } from '../../drag-node-handler';
+import { BuildDragNodeConstraintsRequest } from '../build-drag-node-constraints';
+import { DragHandlerInjector } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+let CreateDragNodeHandler = class CreateDragNodeHandler {
+    _dragInjector = inject(DragHandlerInjector);
+    _mediator = inject(FMediator);
+    handle({ rootHandlers, participants }) {
+        this._applyConstraintsToRoots(rootHandlers);
+        const handler = this._dragInjector.createInstance(DragNodeHandler);
+        handler.initialize(participants, rootHandlers);
+        return handler;
+    }
+    _applyConstraintsToRoots(roots) {
+        for (const handler of roots) {
+            handler.setConstraints(this._calculateConstraints(handler.nodeOrGroup));
+        }
+    }
+    _calculateConstraints(nodeOrGroup) {
+        return this._mediator.execute(new BuildDragNodeConstraintsRequest(nodeOrGroup));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CreateDragNodeHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CreateDragNodeHandler });
+};
+CreateDragNodeHandler = __decorate([
+    FExecutionRegister(CreateDragNodeHandlerRequest)
+], CreateDragNodeHandler);
+export { CreateDragNodeHandler };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CreateDragNodeHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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