@foblex/flow 1.0.6 → 1.0.8

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

@@ -0,0 +1,31 @@
+import { RectExtensions } from '@foblex/core';
+import { getConnectionIntersect } from '../../../../../components/f-connection/get-connection-intersect';
+import { EDraggableType } from '../../../e-draggable-type';
+export class ReassignConnectionOnPointerMove {
+    constructor(connection, canvasTransform, canvasHost) {
+        this.connection = connection;
+        this.canvasTransform = canvasTransform;
+        this.canvasHost = canvasHost;
+        this.type = EDraggableType.REASSIGN_CONNECTION;
+        this.onPointerDownFromConnectorRect = RectExtensions.initialize();
+        this.onPointerDownToConnectorRect = RectExtensions.initialize();
+        this.onPointerDownFromConnectorRect = this.connection.fromTo.output.getElementRectInCanvas(canvasTransform, canvasHost);
+        this.onPointerDownToConnectorRect = RectExtensions.initialize(this.connection.vector.point2.x, this.connection.vector.point2.y, 0, 0);
+    }
+    initialize() {
+    }
+    move(difference) {
+        const toRect = RectExtensions.addPoint(this.onPointerDownToConnectorRect, difference);
+        const vector = getConnectionIntersect(this.onPointerDownFromConnectorRect, toRect);
+        this.connection.setVector(vector);
+        this.connection.redraw();
+    }
+    complete() {
+        const fromConnectorRect = this.connection.fromTo.output.getElementRectInCanvas(this.canvasTransform, this.canvasHost);
+        const toConnectorRect = this.connection.fromTo.input.getElementRectInCanvas(this.canvasTransform, this.canvasHost);
+        const vector = getConnectionIntersect(fromConnectorRect, toConnectorRect);
+        this.connection.setVector(vector);
+        this.connection.completeDrag();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+export * from './reassign-connection.on-pointer-up';
+export * from './reassign-connection-on-pointer-up.request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvY29ubmVjdGlvbnMvcmVhc3NpZ24tY29ubmVjdGlvbi9yZWFzc2lnbi1vbi1wb2ludGVyLXVwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyw2Q0FBNkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcmVhc3NpZ24tY29ubmVjdGlvbi5vbi1wb2ludGVyLXVwJztcbmV4cG9ydCAqIGZyb20gJy4vcmVhc3NpZ24tY29ubmVjdGlvbi1vbi1wb2ludGVyLXVwLnJlcXVlc3QnO1xuIl19

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

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

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

@@ -0,0 +1,26 @@
+import { EDraggableType } from '../../../e-draggable-type';
+import { FindInputsUnderPointerHandler, FindInputsUnderPointerRequest } from '../../find-inputs-under-pointer';
+import { ReassignConnectionEvent } from '../reassign-connection.event';
+export class ReassignConnectionOnPointerUp {
+    constructor(fFlow, onReassignConnection) {
+        this.fFlow = fFlow;
+        this.onReassignConnection = onReassignConnection;
+    }
+    handle(payload) {
+        console.log('ReassignConnectionOnPointerUp', payload);
+        const isReassignConnection = payload.dragHandler.draggableItems.some((x) => x.type === EDraggableType.REASSIGN_CONNECTION);
+        if (isReassignConnection) {
+            console.log('ReassignConnectionOnPointerUp - isReassignConnection');
+            const handler = payload.dragHandler.draggableItems[0];
+            const inputsUnderPointer = new FindInputsUnderPointerHandler(this.fFlow).handle(new FindInputsUnderPointerRequest(payload.event, handler));
+            console.log(inputsUnderPointer);
+            if (inputsUnderPointer.length > 0) {
+                if (handler.connection.fromTo?.input?.id !== inputsUnderPointer[0]?.id) {
+                    this.onReassignConnection.emit(new ReassignConnectionEvent(handler.connection.id, handler.connection.fromTo?.output.id, handler.connection.fromTo?.input?.id, inputsUnderPointer[0]?.id));
+                }
+            }
+            handler.complete();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/default-drag-handler/default-drag.handler.mjs

@@ -0,0 +1,11 @@
+import { Point } from '@foblex/core';
+export class DefaultDragHandler {
+    handle() {
+        return {
+            onPointerDownScale: 1,
+            onPointerDownPosition: new Point(0, 0),
+            draggableItems: []
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1kcmFnLmhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZGVmYXVsdC1kcmFnLWhhbmRsZXIvZGVmYXVsdC1kcmFnLmhhbmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFZLEtBQUssRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUcvQyxNQUFNLE9BQU8sa0JBQWtCO0lBR3RCLE1BQU07UUFFWCxPQUFPO1lBQ0wsa0JBQWtCLEVBQUUsQ0FBQztZQUNyQixxQkFBcUIsRUFBRSxJQUFJLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3RDLGNBQWMsRUFBRSxFQUFFO1NBQ25CLENBQUM7SUFDSixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJSGFuZGxlciwgUG9pbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuaW1wb3J0IHsgSURyYWdIYW5kbGVyIH0gZnJvbSAnLi4vaS1kcmFnLWhhbmRsZXInO1xuXG5leHBvcnQgY2xhc3MgRGVmYXVsdERyYWdIYW5kbGVyXG4gICAgaW1wbGVtZW50cyBJSGFuZGxlcjx2b2lkLCBJRHJhZ0hhbmRsZXI+IHtcblxuICBwdWJsaWMgaGFuZGxlKCk6IElEcmFnSGFuZGxlciB7XG5cbiAgICByZXR1cm4ge1xuICAgICAgb25Qb2ludGVyRG93blNjYWxlOiAxLFxuICAgICAgb25Qb2ludGVyRG93blBvc2l0aW9uOiBuZXcgUG9pbnQoMCwgMCksXG4gICAgICBkcmFnZ2FibGVJdGVtczogW11cbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2022/directives/f-draggable/default-drag-handler/index.mjs

@@ -0,0 +1,2 @@
+export * from './default-drag.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZGVmYXVsdC1kcmFnLWhhbmRsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdC1kcmFnLmhhbmRsZXInO1xuIl19

package/esm2022/directives/f-draggable/e-draggable-type.mjs

@@ -0,0 +1,12 @@
+export var EDraggableType;
+(function (EDraggableType) {
+    EDraggableType["NODE"] = "node";
+    EDraggableType["REASSIGN_CONNECTION"] = "reassign-connection";
+    EDraggableType["TEMP_CONNECTION"] = "temp-connection";
+    EDraggableType["CONNECTION"] = "connection";
+    EDraggableType["CANVAS"] = "canvas";
+    EDraggableType["PALETTE_ITEM"] = "palette-item";
+    EDraggableType["DEFAULT"] = "default";
+    EDraggableType["SELECTION"] = "selection";
+})(EDraggableType || (EDraggableType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZS1kcmFnZ2FibGUtdHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZGlyZWN0aXZlcy9mLWRyYWdnYWJsZS9lLWRyYWdnYWJsZS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGNBaUJYO0FBakJELFdBQVksY0FBYztJQUV4QiwrQkFBYSxDQUFBO0lBRWIsNkRBQTJDLENBQUE7SUFFM0MscURBQW1DLENBQUE7SUFFbkMsMkNBQXlCLENBQUE7SUFFekIsbUNBQWlCLENBQUE7SUFFakIsK0NBQTZCLENBQUE7SUFFN0IscUNBQW1CLENBQUE7SUFFbkIseUNBQXVCLENBQUE7QUFDekIsQ0FBQyxFQWpCVyxjQUFjLEtBQWQsY0FBYyxRQWlCekIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBFRHJhZ2dhYmxlVHlwZSB7XG5cbiAgTk9ERSA9ICdub2RlJyxcblxuICBSRUFTU0lHTl9DT05ORUNUSU9OID0gJ3JlYXNzaWduLWNvbm5lY3Rpb24nLFxuXG4gIFRFTVBfQ09OTkVDVElPTiA9ICd0ZW1wLWNvbm5lY3Rpb24nLFxuXG4gIENPTk5FQ1RJT04gPSAnY29ubmVjdGlvbicsXG5cbiAgQ0FOVkFTID0gJ2NhbnZhcycsXG5cbiAgUEFMRVRURV9JVEVNID0gJ3BhbGV0dGUtaXRlbScsXG5cbiAgREVGQVVMVCA9ICdkZWZhdWx0JyxcblxuICBTRUxFQ1RJT04gPSAnc2VsZWN0aW9uJ1xufVxuIl19

package/esm2022/directives/f-draggable/external-item/create-node.event.mjs

@@ -0,0 +1,7 @@
+export class CreateNodeEvent {
+    constructor(rect, data) {
+        this.rect = rect;
+        this.data = data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW5vZGUuZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9jcmVhdGUtbm9kZS5ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sZUFBZTtJQUUxQixZQUNTLElBQVcsRUFDWCxJQUFXO1FBRFgsU0FBSSxHQUFKLElBQUksQ0FBTztRQUNYLFNBQUksR0FBSixJQUFJLENBQU87SUFFcEIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVJlY3QgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgQ3JlYXRlTm9kZUV2ZW50PFREYXRhID0gYW55PiB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIHJlY3Q6IElSZWN0LFxuICAgIHB1YmxpYyBkYXRhOiBURGF0YSxcbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-down/external-item-on-pointer-down.handler.mjs

@@ -0,0 +1,28 @@
+import { Point } from '@foblex/core';
+import { getExternalItem, isExternalItem } from '../../../f-external-item';
+import { ExternalItemOnPointerMoveHandler } from '../external-item-on-pointer-move';
+export class ExternalItemOnPointerDownHandler {
+    constructor(fExternalItemService, hostElement) {
+        this.fExternalItemService = fExternalItemService;
+        this.hostElement = hostElement;
+    }
+    handle(payload) {
+        let result;
+        if (isExternalItem(payload.event.targetElement)) {
+            const item = this.fExternalItemService.getItem(getExternalItem(payload.event.targetElement));
+            if (!item) {
+                throw new Error('External item not found');
+            }
+            const pointerPositionInCanvas = Point.fromPoint(payload.event.getPosition()).matrixTransform(this.hostElement);
+            result = {
+                onPointerDownScale: 1,
+                onPointerDownPosition: pointerPositionInCanvas.div(1),
+                draggableItems: [
+                    new ExternalItemOnPointerMoveHandler(item)
+                ]
+            };
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-down/external-item-on-pointer-down.request.mjs

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

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-down/index.mjs

@@ -0,0 +1,3 @@
+export * from './external-item-on-pointer-down.request';
+export * from './external-item-on-pointer-down.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V4dGVybmFsLWl0ZW0tb24tcG9pbnRlci1kb3duLnJlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bi5oYW5kbGVyJztcbiJdfQ==

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-move/external-item-on-pointer-move.handler.mjs

@@ -0,0 +1,30 @@
+import { DomElementExtensions, Point, PointExtensions, RectExtensions } from '@foblex/core';
+import { EDraggableType } from '../../e-draggable-type';
+export class ExternalItemOnPointerMoveHandler {
+    constructor(externalItem) {
+        this.externalItem = externalItem;
+        this.type = EDraggableType.PALETTE_ITEM;
+        this.onPointerDownRect = RectExtensions.initialize();
+        this.difference = PointExtensions.initialize();
+    }
+    getStyle(position) {
+        return `position: absolute; left: 0; top: 0; transform: translate(${position.x}px, ${position.y}px)`;
+    }
+    initialize() {
+        this.onPointerDownRect = RectExtensions.fromElement(this.externalItem.hostElement);
+        this.placeholder = DomElementExtensions.deepCloneNode(this.externalItem.hostElement);
+        document.body.appendChild(this.placeholder);
+    }
+    move(difference) {
+        this.difference = difference;
+        const position = Point.fromPoint(this.onPointerDownRect).add(this.difference);
+        this.placeholder.setAttribute('style', this.getStyle(position));
+    }
+    getPlaceholderRect() {
+        return RectExtensions.fromElement(this.placeholder);
+    }
+    complete() {
+        document.body.removeChild(this.placeholder);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-move/index.mjs

@@ -0,0 +1,2 @@
+export * from './external-item-on-pointer-move.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItbW92ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItbW92ZS5oYW5kbGVyJztcbiJdfQ==

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-up/external-item-on-pointer-up.handler.mjs

@@ -0,0 +1,26 @@
+import { Point } from '@foblex/core';
+import { EDraggableType } from '../../e-draggable-type';
+import { getElementRectInCanvas } from '../../../../components';
+import { CreateNodeEvent } from '../create-node.event';
+export class ExternalItemOnPointerUpHandler {
+    constructor(fFlow, onCreateNode) {
+        this.fFlow = fFlow;
+        this.onCreateNode = onCreateNode;
+    }
+    handle(payload) {
+        const pointerPositionInCanvas = Point.fromPoint(payload.event.getPosition()).matrixTransform(this.fFlow.hostElement);
+        let difference = pointerPositionInCanvas.div(payload.dragHandler.onPointerDownScale).sub(payload.dragHandler.onPointerDownPosition);
+        const isDragPaletteItem = payload.dragHandler.draggableItems.some((x) => x.type === EDraggableType.PALETTE_ITEM);
+        if (isDragPaletteItem) {
+            const dragHandler = payload.dragHandler.draggableItems[0];
+            dragHandler.move(difference);
+            const isPointerInCanvasRect = document.elementsFromPoint(payload.event.getPosition().x, payload.event.getPosition().y).some((x) => x === this.fFlow.hostElement);
+            if (isPointerInCanvasRect) {
+                const rectInCanvas = getElementRectInCanvas(dragHandler.placeholder, this.fFlow.transform, this.fFlow.hostElement);
+                this.onCreateNode.emit(new CreateNodeEvent(rectInCanvas, dragHandler.externalItem.data));
+            }
+            dragHandler.complete();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-up/external-item-on-pointer-up.request.mjs

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

package/esm2022/directives/f-draggable/external-item/external-item-on-pointer-up/index.mjs

@@ -0,0 +1,3 @@
+export * from './external-item-on-pointer-up.handler';
+export * from './external-item-on-pointer-up.request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItdXAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItdXAuaGFuZGxlcic7XG5leHBvcnQgKiBmcm9tICcuL2V4dGVybmFsLWl0ZW0tb24tcG9pbnRlci11cC5yZXF1ZXN0JztcbiJdfQ==

package/esm2022/directives/f-draggable/external-item/index.mjs

@@ -0,0 +1,5 @@
+export * from './external-item-on-pointer-down';
+export * from './external-item-on-pointer-move';
+export * from './external-item-on-pointer-up';
+export * from './create-node.event';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bic7XG5leHBvcnQgKiBmcm9tICcuL2V4dGVybmFsLWl0ZW0tb24tcG9pbnRlci1tb3ZlJztcbmV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLXVwJztcbmV4cG9ydCAqIGZyb20gJy4vY3JlYXRlLW5vZGUuZXZlbnQnO1xuIl19

package/esm2022/directives/f-draggable/f-draggable-base.mjs

@@ -0,0 +1,103 @@
+import { IDragAndDropBase, Point } from '@foblex/core';
+import { Subscription } from 'rxjs';
+import { Directive, InjectionToken } from '@angular/core';
+import { CanvasOnPointerDownHandler, CanvasOnPointerDownRequest } from './canvas';
+import { DefaultDragHandler } from './default-drag-handler';
+import { SelectionOnPointerDown, SelectionOnPointerDownRequest, SelectionOnPointerUp, SelectionOnPointerUpRequest } from './selection';
+import { ReassignConnectionOnPointerDown, ReassignConnectionOnPointerDownRequest, ReassignConnectionOnPointerUp, ReassignConnectionOnPointerUpRequest } from './connections';
+import { NodeOnPointerDown, NodeOnPointerDownRequest, NodeOnPointerUp, NodeOnPointerUpRequest } from './node';
+import { CreateConnectionOnPointerDown, CreateConnectionOnPointerDownRequest, CreateConnectionOnPointerUp, CreateConnectionOnPointerUpRequest } from './connections';
+import { EDraggableType } from './e-draggable-type';
+import { ExternalItemOnPointerDownHandler, ExternalItemOnPointerDownRequest, ExternalItemOnPointerUpHandler, ExternalItemOnPointerUpRequest } from './external-item';
+import * as i0 from "@angular/core";
+import * as i1 from "../../components";
+import * as i2 from "./f-draggable.service";
+import * as i3 from "../f-external-item";
+export const F_DND_DIRECTIVE = new InjectionToken('F_DND_DIRECTIVE');
+export class FDraggableBase extends IDragAndDropBase {
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    get transform() {
+        return this.fItemsContainer.transform;
+    }
+    get fItemsContainer() {
+        return this.fFlow.fItemsContainer;
+    }
+    get fBackground() {
+        return this.fFlow.fBackground;
+    }
+    constructor(fFlow, fDNDService, fExternalItemService, elementReference, ngZone) {
+        super(ngZone);
+        this.fFlow = fFlow;
+        this.fDNDService = fDNDService;
+        this.fExternalItemService = fExternalItemService;
+        this.elementReference = elementReference;
+        this.subscriptions$ = new Subscription();
+        this.dragHandler = new DefaultDragHandler().handle();
+        this.selectedItems = [];
+        this.fDNDService.setFlow(this.fFlow);
+    }
+    ngAfterViewInit() {
+        super.subscribe(document);
+        this.dragSelection = new SelectionOnPointerDown(this.fFlow, this.fSelection, this.hostElement);
+        this.reassignConnection = new ReassignConnectionOnPointerDown(this.fFlow, this.hostElement);
+        this.dragCanvas = new CanvasOnPointerDownHandler(this.fBackground, this.fItemsContainer, this.hostElement);
+        this.dragNode = new NodeOnPointerDown(this.fLineAlignment, this.fFlow, this.hostElement);
+        this.createConnection = new CreateConnectionOnPointerDown(this.fFlow, this.hostElement);
+        this.dragExternalItem = new ExternalItemOnPointerDownHandler(this.fExternalItemService, this.hostElement);
+    }
+    onPointerDown(event) {
+        let result = event.isMouseLeftButton();
+        const selection = this.dragSelection.handle(new SelectionOnPointerDownRequest(event, this.transform, this.selectedItems));
+        this.selectedItems = selection.selectedItems || [];
+        const reassignConnection = this.reassignConnection.handle(new ReassignConnectionOnPointerDownRequest(event, this.transform));
+        const createConnection = this.createConnection.handle(new CreateConnectionOnPointerDownRequest(event, this.transform));
+        const dragNode = this.dragNode.handle(new NodeOnPointerDownRequest(event, this.transform, this.selectedItems));
+        const dragCanvas = this.dragCanvas.handle(new CanvasOnPointerDownRequest(event));
+        const dragExternalItem = this.dragExternalItem.handle(new ExternalItemOnPointerDownRequest(event));
+        const dragSelection = selection.draggableItems.length ? selection : undefined;
+        const dragHandle = dragSelection || reassignConnection || createConnection || dragNode || dragCanvas || dragExternalItem;
+        if (!dragHandle) {
+            this.dragHandler = new DefaultDragHandler().handle();
+            result = false;
+        }
+        else {
+            this.dragHandler = dragHandle;
+        }
+        return result;
+    }
+    prepareDragSequence(event) {
+        const isDragNodes = this.dragHandler.draggableItems.some((x) => x.type === EDraggableType.NODE);
+        if (isDragNodes) {
+            this.dragHandler = this.dragNode.handle(new NodeOnPointerDownRequest(event, this.transform, this.selectedItems, true));
+        }
+        this.dragHandler.draggableItems.forEach((item) => {
+            item.initialize();
+        });
+    }
+    onPointerMove(event) {
+        const pointerPositionInCanvas = Point.fromPoint(event.getPosition()).matrixTransform(this.hostElement);
+        const difference = pointerPositionInCanvas.div(this.dragHandler.onPointerDownScale).sub(this.dragHandler.onPointerDownPosition);
+        this.dragHandler.draggableItems.forEach((item) => {
+            item.move(difference);
+        });
+    }
+    onPointerUp(event) {
+        new ReassignConnectionOnPointerUp(this.fFlow, this.onReassignConnection).handle(new ReassignConnectionOnPointerUpRequest(event, this.dragHandler));
+        new CreateConnectionOnPointerUp(this.fFlow, this.onCreateConnection).handle(new CreateConnectionOnPointerUpRequest(event, this.dragHandler));
+        new NodeOnPointerUp(this.fLineAlignment, this.fConnectIfIntersect, this.hostElement).handle(new NodeOnPointerUpRequest(event, this.dragHandler));
+        this.selectedItems = new SelectionOnPointerUp(this.hostElement).handle(new SelectionOnPointerUpRequest(event, this.dragHandler, this.selectedItems));
+        new ExternalItemOnPointerUpHandler(this.fFlow, this.onCreateNode).handle(new ExternalItemOnPointerUpRequest(event, this.dragHandler));
+    }
+    ngOnDestroy() {
+        super.unsubscribe();
+        this.subscriptions$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableBase, deps: [{ token: i1.FFlowBase }, { token: i2.FDraggableService }, { token: i3.FExternalItemService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.5", type: FDraggableBase, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.FFlowBase }, { type: i2.FDraggableService }, { type: i3.FExternalItemService }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-draggable-base.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/directives/f-draggable/f-draggable-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IDragAndDropBase, IHasHostElement, IPointerEvent, ITransformModel, Point\n} from '@foblex/core';\nimport { Subscription } from 'rxjs';\nimport { AfterViewInit, Directive, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy } from '@angular/core';\nimport { FItemsContainerBase } from '../f-containers';\nimport { FBackgroundBase } from '../../internal';\nimport { FFlowBase, FSelectionDirective } from '../../components';\nimport { CanvasOnPointerDownHandler, CanvasOnPointerDownRequest } from './canvas';\nimport { IDragHandler } from './i-drag-handler';\nimport { DefaultDragHandler } from './default-drag-handler';\nimport {\n  SelectionOnPointerDown,\n  SelectionOnPointerDownRequest,\n  SelectionOnPointerUp,\n  SelectionOnPointerUpRequest\n} from './selection';\nimport {\n  ReassignConnectionEvent, ReassignConnectionOnPointerDown,\n  ReassignConnectionOnPointerDownRequest, ReassignConnectionOnPointerUp, ReassignConnectionOnPointerUpRequest\n} from './connections';\nimport { NodeOnPointerDown, NodeOnPointerDownRequest, NodeOnPointerUp, NodeOnPointerUpRequest } from './node';\nimport {\n  CreateConnectionEvent, CreateConnectionOnPointerDown,\n  CreateConnectionOnPointerDownRequest, CreateConnectionOnPointerUp, CreateConnectionOnPointerUpRequest\n} from './connections';\nimport { EDraggableType } from './e-draggable-type';\nimport { FConnectIfIntersectDirective } from '../f-connect-if-intersect';\nimport { FLineAlignmentDirective } from '../f-line-alignment';\nimport { ISelectable } from '../../i-selectable';\nimport { FExternalItemService } from '../f-external-item';\nimport { FDraggableService } from './f-draggable.service';\nimport {\n  CreateNodeEvent,\n  ExternalItemOnPointerDownHandler,\n  ExternalItemOnPointerDownRequest,\n  ExternalItemOnPointerUpHandler, ExternalItemOnPointerUpRequest\n} from './external-item';\n\nexport const F_DND_DIRECTIVE = new InjectionToken<FDraggableBase>('F_DND_DIRECTIVE');\n\n@Directive()\nexport abstract class FDraggableBase extends IDragAndDropBase implements IHasHostElement, AfterViewInit, OnDestroy {\n\n  private subscriptions$: Subscription = new Subscription();\n\n  public get hostElement(): SVGSVGElement {\n    return this.elementReference.nativeElement;\n  }\n\n  private get transform(): ITransformModel {\n    return this.fItemsContainer.transform;\n  }\n\n  private get fItemsContainer(): FItemsContainerBase {\n    return this.fFlow.fItemsContainer;\n  }\n\n  private get fBackground(): FBackgroundBase {\n    return this.fFlow.fBackground;\n  }\n\n  private dragHandler: IDragHandler = new DefaultDragHandler().handle();\n\n  private dragSelection!: SelectionOnPointerDown;\n  private reassignConnection!: ReassignConnectionOnPointerDown;\n  private dragCanvas!: CanvasOnPointerDownHandler;\n  private dragNode!: NodeOnPointerDown;\n  private createConnection!: CreateConnectionOnPointerDown;\n  private dragExternalItem!: ExternalItemOnPointerDownHandler;\n\n  public abstract onCreateConnection: EventEmitter<CreateConnectionEvent>;\n\n  public abstract onReassignConnection: EventEmitter<ReassignConnectionEvent>;\n\n  public abstract onCreateNode: EventEmitter<CreateNodeEvent>;\n\n  public abstract fLineAlignment: FLineAlignmentDirective | undefined;\n  public abstract fConnectIfIntersect: FConnectIfIntersectDirective | undefined;\n  public abstract fSelection: FSelectionDirective | undefined;\n\n  private selectedItems: ISelectable[] = [];\n\n  protected constructor(\n    protected fFlow: FFlowBase,\n    protected fDNDService: FDraggableService,\n    protected fExternalItemService: FExternalItemService,\n    private elementReference: ElementRef<SVGSVGElement>,\n    ngZone: NgZone,\n  ) {\n    super(ngZone);\n    this.fDNDService.setFlow(this.fFlow);\n  }\n\n  public ngAfterViewInit(): void {\n    super.subscribe(document);\n\n    this.dragSelection = new SelectionOnPointerDown(this.fFlow, this.fSelection, this.hostElement);\n    this.reassignConnection = new ReassignConnectionOnPointerDown(this.fFlow, this.hostElement);\n    this.dragCanvas = new CanvasOnPointerDownHandler(this.fBackground, this.fItemsContainer, this.hostElement);\n    this.dragNode = new NodeOnPointerDown(this.fLineAlignment, this.fFlow, this.hostElement);\n    this.createConnection = new CreateConnectionOnPointerDown(this.fFlow, this.hostElement);\n    this.dragExternalItem = new ExternalItemOnPointerDownHandler(this.fExternalItemService, this.hostElement);\n  }\n\n  public override onPointerDown(event: IPointerEvent): boolean {\n    let result: boolean = event.isMouseLeftButton();\n    const selection = this.dragSelection.handle(\n      new SelectionOnPointerDownRequest(event, this.transform, this.selectedItems)\n    );\n    this.selectedItems = selection.selectedItems || [];\n\n    const reassignConnection = this.reassignConnection.handle(\n      new ReassignConnectionOnPointerDownRequest(event, this.transform)\n    );\n\n    const createConnection = this.createConnection.handle(\n      new CreateConnectionOnPointerDownRequest(event, this.transform)\n    );\n\n    const dragNode = this.dragNode.handle(\n      new NodeOnPointerDownRequest(event, this.transform, this.selectedItems)\n    );\n\n    const dragCanvas = this.dragCanvas.handle(\n      new CanvasOnPointerDownRequest(event)\n    );\n\n    const dragExternalItem = this.dragExternalItem.handle(\n      new ExternalItemOnPointerDownRequest(event)\n    );\n\n    const dragSelection = selection.draggableItems.length ? selection : undefined;\n\n    const dragHandle = dragSelection || reassignConnection || createConnection || dragNode || dragCanvas || dragExternalItem;\n    if (!dragHandle) {\n      this.dragHandler = new DefaultDragHandler().handle();\n      result = false;\n    } else {\n      this.dragHandler = dragHandle;\n    }\n\n    return result;\n  }\n\n  protected override prepareDragSequence(event: IPointerEvent) {\n    const isDragNodes = this.dragHandler.draggableItems.some((x) => x.type === EDraggableType.NODE);\n    if (isDragNodes) {\n      this.dragHandler = this.dragNode.handle(\n        new NodeOnPointerDownRequest(event, this.transform, this.selectedItems, true)\n      )!;\n    }\n    this.dragHandler.draggableItems.forEach((item) => {\n      item.initialize();\n    });\n  }\n\n  public override onPointerMove(event: IPointerEvent): void {\n    const pointerPositionInCanvas = Point.fromPoint(event.getPosition()).matrixTransform(this.hostElement);\n    const difference = pointerPositionInCanvas.div(this.dragHandler.onPointerDownScale).sub(this.dragHandler.onPointerDownPosition);\n    this.dragHandler.draggableItems.forEach((item) => {\n      item.move(difference);\n    });\n  }\n\n  public override onPointerUp(event: IPointerEvent): void {\n    new ReassignConnectionOnPointerUp(this.fFlow, this.onReassignConnection).handle(\n      new ReassignConnectionOnPointerUpRequest(event, this.dragHandler)\n    );\n\n    new CreateConnectionOnPointerUp(this.fFlow, this.onCreateConnection).handle(\n      new CreateConnectionOnPointerUpRequest(event, this.dragHandler)\n    );\n\n    new NodeOnPointerUp(this.fLineAlignment, this.fConnectIfIntersect, this.hostElement).handle(\n      new NodeOnPointerUpRequest(event, this.dragHandler)\n    );\n\n    this.selectedItems = new SelectionOnPointerUp(this.hostElement).handle(\n      new SelectionOnPointerUpRequest(event, this.dragHandler, this.selectedItems)\n    );\n\n    new ExternalItemOnPointerUpHandler(this.fFlow, this.onCreateNode).handle(\n      new ExternalItemOnPointerUpRequest(event, this.dragHandler)\n    );\n  }\n\n  public ngOnDestroy(): void {\n    super.unsubscribe();\n    this.subscriptions$.unsubscribe();\n  }\n}\n"]}

package/esm2022/directives/f-draggable/f-draggable.directive.mjs

@@ -0,0 +1,52 @@
+import { ContentChild, Directive, EventEmitter, Inject, Input, Output } from "@angular/core";
+import { F_DND_DIRECTIVE, FDraggableBase } from './f-draggable-base';
+import { F_FLOW_COMPONENT, F_SELECTION } from '../../components';
+import { F_CONNECT_IF_INTERSECT } from '../f-connect-if-intersect';
+import { F_LINE_ALIGNMENT } from '../f-line-alignment';
+import * as i0 from "@angular/core";
+import * as i1 from "./f-draggable.service";
+import * as i2 from "../f-external-item";
+import * as i3 from "../../components";
+export class FDraggableDirective extends FDraggableBase {
+    constructor(fFlow, fDNDService, fExternalItemService, elementReference, ngZone) {
+        super(fFlow, fDNDService, fExternalItemService, elementReference, ngZone);
+        this.disabled = false;
+        this.onCreateConnection = new EventEmitter();
+        this.onReassignConnection = new EventEmitter();
+        this.onCreateNode = new EventEmitter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableDirective, deps: [{ token: F_FLOW_COMPONENT }, { token: i1.FDraggableService }, { token: i2.FExternalItemService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.5", type: FDraggableDirective, selector: "svg[fDraggable]", inputs: { disabled: "disabled" }, outputs: { onCreateConnection: "onCreateConnection", onReassignConnection: "onReassignConnection", onCreateNode: "onCreateNode" }, providers: [
+            { provide: F_DND_DIRECTIVE, useExisting: FDraggableDirective }
+        ], queries: [{ propertyName: "fLineAlignment", first: true, predicate: F_LINE_ALIGNMENT, descendants: true, static: true }, { propertyName: "fConnectIfIntersect", first: true, predicate: F_CONNECT_IF_INTERSECT, descendants: true, static: true }, { propertyName: "fSelection", first: true, predicate: F_SELECTION, descendants: true, static: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "svg[fDraggable]",
+                    providers: [
+                        { provide: F_DND_DIRECTIVE, useExisting: FDraggableDirective }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i3.FFlowBase, decorators: [{
+                    type: Inject,
+                    args: [F_FLOW_COMPONENT]
+                }] }, { type: i1.FDraggableService }, { type: i2.FExternalItemService }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], fLineAlignment: [{
+                type: ContentChild,
+                args: [F_LINE_ALIGNMENT, { static: true }]
+            }], fConnectIfIntersect: [{
+                type: ContentChild,
+                args: [F_CONNECT_IF_INTERSECT, { static: true }]
+            }], fSelection: [{
+                type: ContentChild,
+                args: [F_SELECTION, { static: true }]
+            }], onCreateConnection: [{
+                type: Output
+            }], onReassignConnection: [{
+                type: Output
+            }], onCreateNode: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/f-draggable.module.mjs

@@ -0,0 +1,49 @@
+import { NgModule } from '@angular/core';
+import { FDraggableDirective } from './f-draggable.directive';
+import { FExternalItemDirective, FExternalItemService } from '../f-external-item';
+import { FLineAlignmentDirective } from '../f-line-alignment';
+import { FSelectionDirective } from '../f-selection';
+import { FConnectIfIntersectDirective } from '../f-connect-if-intersect';
+import { FDraggableService } from './f-draggable.service';
+import * as i0 from "@angular/core";
+export class FDraggableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.5", ngImport: i0, type: FDraggableModule, declarations: [FDraggableDirective,
+            FExternalItemDirective,
+            FLineAlignmentDirective,
+            FSelectionDirective,
+            FConnectIfIntersectDirective], exports: [FDraggableDirective,
+            FExternalItemDirective,
+            FLineAlignmentDirective,
+            FSelectionDirective,
+            FConnectIfIntersectDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableModule, providers: [
+            FExternalItemService,
+            FDraggableService
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        FDraggableDirective,
+                        FExternalItemDirective,
+                        FLineAlignmentDirective,
+                        FSelectionDirective,
+                        FConnectIfIntersectDirective
+                    ],
+                    imports: [],
+                    providers: [
+                        FExternalItemService,
+                        FDraggableService
+                    ],
+                    exports: [
+                        FDraggableDirective,
+                        FExternalItemDirective,
+                        FLineAlignmentDirective,
+                        FSelectionDirective,
+                        FConnectIfIntersectDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/f-draggable/f-draggable.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FDraggableService {
+    get hostElement() {
+        return this.fFlow.hostElement;
+    }
+    get transform() {
+        return this.fFlow.transform;
+    }
+    constructor() {
+    }
+    setFlow(fFlow) {
+        this.fFlow = fFlow;
+    }
+    onPointerDown(event) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: FDraggableService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1kcmFnZ2FibGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZGlyZWN0aXZlcy9mLWRyYWdnYWJsZS9mLWRyYWdnYWJsZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxpQkFBaUI7SUFJNUIsSUFBVyxXQUFXO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLEtBQU0sQ0FBQyxXQUFXLENBQUM7SUFDakMsQ0FBQztJQUVELElBQVcsU0FBUztRQUNsQixPQUFPLElBQUksQ0FBQyxLQUFNLENBQUMsU0FBUyxDQUFDO0lBQy9CLENBQUM7SUFFRDtJQUVBLENBQUM7SUFFTSxPQUFPLENBQUMsS0FBZ0I7UUFDN0IsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDckIsQ0FBQztJQUVNLGFBQWEsQ0FBQyxLQUFtQjtJQUV4QyxDQUFDOzhHQXRCVSxpQkFBaUI7a0hBQWpCLGlCQUFpQjs7MkZBQWpCLGlCQUFpQjtrQkFEN0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZGbG93QmFzZSB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMnO1xuaW1wb3J0IHsgSVRyYW5zZm9ybU1vZGVsIH0gZnJvbSAnQGZvYmxleC9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEZEcmFnZ2FibGVTZXJ2aWNlIHtcblxuICBwcml2YXRlIGZGbG93OiBGRmxvd0Jhc2UgfCB1bmRlZmluZWQ7XG5cbiAgcHVibGljIGdldCBob3N0RWxlbWVudCgpOiBTVkdTVkdFbGVtZW50IHtcbiAgICByZXR1cm4gdGhpcy5mRmxvdyEuaG9zdEVsZW1lbnQ7XG4gIH1cblxuICBwdWJsaWMgZ2V0IHRyYW5zZm9ybSgpOiBJVHJhbnNmb3JtTW9kZWwge1xuICAgIHJldHVybiB0aGlzLmZGbG93IS50cmFuc2Zvcm07XG4gIH1cblxuICBjb25zdHJ1Y3RvcihcbiAgKSB7XG4gIH1cblxuICBwdWJsaWMgc2V0RmxvdyhmRmxvdzogRkZsb3dCYXNlKTogdm9pZCB7XG4gICAgdGhpcy5mRmxvdyA9IGZGbG93O1xuICB9XG5cbiAgcHVibGljIG9uUG9pbnRlckRvd24oZXZlbnQ6IFBvaW50ZXJFdmVudCk6IHZvaWQge1xuXG4gIH1cbn1cbiJdfQ==

package/esm2022/directives/f-draggable/i-drag-handler.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS1kcmFnLWhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvaS1kcmFnLWhhbmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvaW50IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IElEcmFnZ2FibGVJdGVtIH0gZnJvbSAnLi9pLWRyYWdnYWJsZS1pdGVtJztcbmltcG9ydCB7IElTZWxlY3RhYmxlIH0gZnJvbSAnLi4vLi4vaS1zZWxlY3RhYmxlJztcblxuZXhwb3J0IGludGVyZmFjZSBJRHJhZ0hhbmRsZXIge1xuXG4gIG9uUG9pbnRlckRvd25TY2FsZTogbnVtYmVyO1xuXG4gIG9uUG9pbnRlckRvd25Qb3NpdGlvbjogUG9pbnQ7XG5cbiAgZHJhZ2dhYmxlSXRlbXM6IElEcmFnZ2FibGVJdGVtW107XG5cbiAgc2VsZWN0ZWRJdGVtcz86IElTZWxlY3RhYmxlW107XG59XG4iXX0=

package/esm2022/directives/f-draggable/i-draggable-item.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS1kcmFnZ2FibGUtaXRlbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZGlyZWN0aXZlcy9mLWRyYWdnYWJsZS9pLWRyYWdnYWJsZS1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuaW1wb3J0IHsgRURyYWdnYWJsZVR5cGUgfSBmcm9tICcuL2UtZHJhZ2dhYmxlLXR5cGUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElEcmFnZ2FibGVJdGVtIHtcblxuICB0eXBlOiBFRHJhZ2dhYmxlVHlwZTtcblxuICBpbml0aWFsaXplKCk6IHZvaWQ7XG5cbiAgbW92ZShkaWZmZXJlbmNlOiBJUG9pbnQpOiB2b2lkO1xuXG4gIGNvbXBsZXRlKCk6IHZvaWQ7XG59XG4iXX0=

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

@@ -0,0 +1,14 @@
+export * from './canvas';
+export * from './connections';
+export * from './default-drag-handler';
+export * from './external-item';
+export * from './node';
+export * from './selection';
+export * from './e-draggable-type';
+export * from './f-draggable.directive';
+export * from './f-draggable.module';
+export * from './f-draggable.service';
+export * from './f-draggable-base';
+export * from './i-draggable-item';
+export * from './i-drag-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFFekIsY0FBYyxlQUFlLENBQUM7QUFFOUIsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLGlCQUFpQixDQUFDO0FBRWhDLGNBQWMsUUFBUSxDQUFDO0FBRXZCLGNBQWMsYUFBYSxDQUFDO0FBRTVCLGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsY0FBYyx5QkFBeUIsQ0FBQztBQUV4QyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUVuQyxjQUFjLG9CQUFvQixDQUFDO0FBRW5DLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NhbnZhcyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vY29ubmVjdGlvbnMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2RlZmF1bHQtZHJhZy1oYW5kbGVyJztcblxuZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtJztcblxuZXhwb3J0ICogZnJvbSAnLi9ub2RlJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3Rpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL2UtZHJhZ2dhYmxlLXR5cGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtZHJhZ2dhYmxlLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1kcmFnZ2FibGUubW9kdWxlJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLWRyYWdnYWJsZS5zZXJ2aWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLWRyYWdnYWJsZS1iYXNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9pLWRyYWdnYWJsZS1pdGVtJztcblxuZXhwb3J0ICogZnJvbSAnLi9pLWRyYWctaGFuZGxlcic7XG5cblxuXG5cbiJdfQ==