@foblex/flow 0.0.1

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhc3NpZ24tY29ubmVjdGlvbi1vbi1wb2ludGVyLXVwLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2Nvbm5lY3Rpb25zL3JlYXNzaWduLWNvbm5lY3Rpb24vcmVhc3NpZ24tb24tcG9pbnRlci11cC9yZWFzc2lnbi1jb25uZWN0aW9uLW9uLXBvaW50ZXItdXAucmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sb0NBQW9DO0lBRS9DLFlBQ1csS0FBb0IsRUFDcEIsV0FBeUI7UUFEekIsVUFBSyxHQUFMLEtBQUssQ0FBZTtRQUNwQixnQkFBVyxHQUFYLFdBQVcsQ0FBYztJQUVwQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnRlckV2ZW50IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IElEcmFnSGFuZGxlciB9IGZyb20gJy4uLy4uLy4uL2ktZHJhZy1oYW5kbGVyJztcblxuZXhwb3J0IGNsYXNzIFJlYXNzaWduQ29ubmVjdGlvbk9uUG9pbnRlclVwUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgICBwdWJsaWMgZXZlbnQ6IElQb2ludGVyRXZlbnQsXG4gICAgICBwdWJsaWMgZHJhZ0hhbmRsZXI6IElEcmFnSGFuZGxlclxuICApIHtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,23 @@
+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) {
+        const isReassignConnection = payload.dragHandler.draggableItems.some((x) => x.type === EDraggableType.REASSIGN_CONNECTION);
+        if (isReassignConnection) {
+            const handler = payload.dragHandler.draggableItems[0];
+            const inputsUnderPointer = new FindInputsUnderPointerHandler(this.fFlow).handle(new FindInputsUnderPointerRequest(payload.event, handler));
+            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/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1kcmFnLmhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2RlZmF1bHQtZHJhZy1oYW5kbGVyL2RlZmF1bHQtZHJhZy5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBWSxLQUFLLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFHL0MsTUFBTSxPQUFPLGtCQUFrQjtJQUd0QixNQUFNO1FBRVgsT0FBTztZQUNMLGtCQUFrQixFQUFFLENBQUM7WUFDckIscUJBQXFCLEVBQUUsSUFBSSxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUN0QyxjQUFjLEVBQUUsRUFBRTtTQUNuQixDQUFDO0lBQ0osQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUhhbmRsZXIsIFBvaW50IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IElEcmFnSGFuZGxlciB9IGZyb20gJy4uL2ktZHJhZy1oYW5kbGVyJztcblxuZXhwb3J0IGNsYXNzIERlZmF1bHREcmFnSGFuZGxlclxuICAgIGltcGxlbWVudHMgSUhhbmRsZXI8dm9pZCwgSURyYWdIYW5kbGVyPiB7XG5cbiAgcHVibGljIGhhbmRsZSgpOiBJRHJhZ0hhbmRsZXIge1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIG9uUG9pbnRlckRvd25TY2FsZTogMSxcbiAgICAgIG9uUG9pbnRlckRvd25Qb3NpdGlvbjogbmV3IFBvaW50KDAsIDApLFxuICAgICAgZHJhZ2dhYmxlSXRlbXM6IFtdXG4gICAgfTtcbiAgfVxufVxuIl19

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

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

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZS1kcmFnZ2FibGUtdHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvbGliL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZS1kcmFnZ2FibGUtdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxjQWlCWDtBQWpCRCxXQUFZLGNBQWM7SUFFeEIsK0JBQWEsQ0FBQTtJQUViLDZEQUEyQyxDQUFBO0lBRTNDLHFEQUFtQyxDQUFBO0lBRW5DLDJDQUF5QixDQUFBO0lBRXpCLG1DQUFpQixDQUFBO0lBRWpCLCtDQUE2QixDQUFBO0lBRTdCLHFDQUFtQixDQUFBO0lBRW5CLHlDQUF1QixDQUFBO0FBQ3pCLENBQUMsRUFqQlcsY0FBYyxLQUFkLGNBQWMsUUFpQnpCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRURyYWdnYWJsZVR5cGUge1xuXG4gIE5PREUgPSAnbm9kZScsXG5cbiAgUkVBU1NJR05fQ09OTkVDVElPTiA9ICdyZWFzc2lnbi1jb25uZWN0aW9uJyxcblxuICBURU1QX0NPTk5FQ1RJT04gPSAndGVtcC1jb25uZWN0aW9uJyxcblxuICBDT05ORUNUSU9OID0gJ2Nvbm5lY3Rpb24nLFxuXG4gIENBTlZBUyA9ICdjYW52YXMnLFxuXG4gIFBBTEVUVEVfSVRFTSA9ICdwYWxldHRlLWl0ZW0nLFxuXG4gIERFRkFVTFQgPSAnZGVmYXVsdCcsXG5cbiAgU0VMRUNUSU9OID0gJ3NlbGVjdGlvbidcbn1cbiJdfQ==

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW5vZGUuZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vY3JlYXRlLW5vZGUuZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLGVBQWU7SUFFMUIsWUFDUyxJQUFXLEVBQ1gsSUFBVztRQURYLFNBQUksR0FBSixJQUFJLENBQU87UUFDWCxTQUFJLEdBQUosSUFBSSxDQUFPO0lBRXBCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElSZWN0IH0gZnJvbSAnQGZvYmxleC9jb3JlJztcblxuZXhwb3J0IGNsYXNzIENyZWF0ZU5vZGVFdmVudDxURGF0YSA9IGFueT4ge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyByZWN0OiBJUmVjdCxcbiAgICBwdWJsaWMgZGF0YTogVERhdGEsXG4gICkge1xuICB9XG59XG4iXX0=

package/esm2022/lib/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/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLWRvd24ucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvbGliL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZXh0ZXJuYWwtaXRlbS9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bi5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxnQ0FBZ0M7SUFFM0MsWUFDUyxLQUFvQjtRQUFwQixVQUFLLEdBQUwsS0FBSyxDQUFlO0lBRTdCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludGVyRXZlbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgRXh0ZXJuYWxJdGVtT25Qb2ludGVyRG93blJlcXVlc3Qge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBldmVudDogSVBvaW50ZXJFdmVudFxuICApIHtcbiAgfVxufVxuIl19

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLWRvd24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItZG93bi5yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLWRvd24uaGFuZGxlcic7XG4iXX0=

package/esm2022/lib/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/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLW1vdmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLW1vdmUuaGFuZGxlcic7XG4iXX0=

package/esm2022/lib/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/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLXVwLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLXVwL2V4dGVybmFsLWl0ZW0tb24tcG9pbnRlci11cC5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyw4QkFBOEI7SUFFekMsWUFDUyxLQUFvQixFQUNwQixXQUF5QjtRQUR6QixVQUFLLEdBQUwsS0FBSyxDQUFlO1FBQ3BCLGdCQUFXLEdBQVgsV0FBVyxDQUFjO0lBRWxDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludGVyRXZlbnQgfSBmcm9tICdAZm9ibGV4L2NvcmUnO1xuaW1wb3J0IHsgSURyYWdIYW5kbGVyIH0gZnJvbSAnLi4vLi4vaS1kcmFnLWhhbmRsZXInO1xuXG5leHBvcnQgY2xhc3MgRXh0ZXJuYWxJdGVtT25Qb2ludGVyVXBSZXF1ZXN0IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgZXZlbnQ6IElQb2ludGVyRXZlbnQsXG4gICAgcHVibGljIGRyYWdIYW5kbGVyOiBJRHJhZ0hhbmRsZXJcbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLXVwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyx1Q0FBdUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLXVwLmhhbmRsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItdXAucmVxdWVzdCc7XG4iXX0=

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2V4dGVybmFsLWl0ZW0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbS1vbi1wb2ludGVyLWRvd24nO1xuZXhwb3J0ICogZnJvbSAnLi9leHRlcm5hbC1pdGVtLW9uLXBvaW50ZXItbW92ZSc7XG5leHBvcnQgKiBmcm9tICcuL2V4dGVybmFsLWl0ZW0tb24tcG9pbnRlci11cCc7XG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1ub2RlLmV2ZW50JztcbiJdfQ==

package/esm2022/lib/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.4", 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.4", type: FDraggableBase, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.4", 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/lib/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/lib/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.4", 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.4", 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.4", 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/lib/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.4", ngImport: i0, type: FDraggableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.4", 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.4", ngImport: i0, type: FDraggableModule, providers: [
+            FExternalItemService,
+            FDraggableService
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.4", 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/lib/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.4", ngImport: i0, type: FDraggableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.4", ngImport: i0, type: FDraggableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.4", ngImport: i0, type: FDraggableService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1kcmFnZ2FibGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvbGliL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvZi1kcmFnZ2FibGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8saUJBQWlCO0lBSTVCLElBQVcsV0FBVztRQUNwQixPQUFPLElBQUksQ0FBQyxLQUFNLENBQUMsV0FBVyxDQUFDO0lBQ2pDLENBQUM7SUFFRCxJQUFXLFNBQVM7UUFDbEIsT0FBTyxJQUFJLENBQUMsS0FBTSxDQUFDLFNBQVMsQ0FBQztJQUMvQixDQUFDO0lBRUQ7SUFFQSxDQUFDO0lBRU0sT0FBTyxDQUFDLEtBQWdCO1FBQzdCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQ3JCLENBQUM7SUFFTSxhQUFhLENBQUMsS0FBbUI7SUFFeEMsQ0FBQzs4R0F0QlUsaUJBQWlCO2tIQUFqQixpQkFBaUI7OzJGQUFqQixpQkFBaUI7a0JBRDdCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGRmxvd0Jhc2UgfSBmcm9tICcuLi8uLi9jb21wb25lbnRzJztcbmltcG9ydCB7IElUcmFuc2Zvcm1Nb2RlbCB9IGZyb20gJ0Bmb2JsZXgvY29yZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGRHJhZ2dhYmxlU2VydmljZSB7XG5cbiAgcHJpdmF0ZSBmRmxvdzogRkZsb3dCYXNlIHwgdW5kZWZpbmVkO1xuXG4gIHB1YmxpYyBnZXQgaG9zdEVsZW1lbnQoKTogU1ZHU1ZHRWxlbWVudCB7XG4gICAgcmV0dXJuIHRoaXMuZkZsb3chLmhvc3RFbGVtZW50O1xuICB9XG5cbiAgcHVibGljIGdldCB0cmFuc2Zvcm0oKTogSVRyYW5zZm9ybU1vZGVsIHtcbiAgICByZXR1cm4gdGhpcy5mRmxvdyEudHJhbnNmb3JtO1xuICB9XG5cbiAgY29uc3RydWN0b3IoXG4gICkge1xuICB9XG5cbiAgcHVibGljIHNldEZsb3coZkZsb3c6IEZGbG93QmFzZSk6IHZvaWQge1xuICAgIHRoaXMuZkZsb3cgPSBmRmxvdztcbiAgfVxuXG4gIHB1YmxpYyBvblBvaW50ZXJEb3duKGV2ZW50OiBQb2ludGVyRXZlbnQpOiB2b2lkIHtcblxuICB9XG59XG4iXX0=

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

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

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

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

package/esm2022/lib/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBRXpCLGNBQWMsZUFBZSxDQUFDO0FBRTlCLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyxpQkFBaUIsQ0FBQztBQUVoQyxjQUFjLFFBQVEsQ0FBQztBQUV2QixjQUFjLGFBQWEsQ0FBQztBQUU1QixjQUFjLG9CQUFvQixDQUFDO0FBRW5DLGNBQWMseUJBQXlCLENBQUM7QUFFeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUVyQyxjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUVuQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jYW52YXMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Nvbm5lY3Rpb25zJztcblxuZXhwb3J0ICogZnJvbSAnLi9kZWZhdWx0LWRyYWctaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZXh0ZXJuYWwtaXRlbSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbm9kZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc2VsZWN0aW9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9lLWRyYWdnYWJsZS10eXBlJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLWRyYWdnYWJsZS5kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtZHJhZ2dhYmxlLm1vZHVsZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1kcmFnZ2FibGUuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1kcmFnZ2FibGUtYmFzZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaS1kcmFnZ2FibGUtaXRlbSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaS1kcmFnLWhhbmRsZXInO1xuXG5cblxuXG4iXX0=

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

@@ -0,0 +1,4 @@
+export * from './node-on-pointer-down';
+export * from './node-on-pointer-move';
+export * from './node-on-pointer-up';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2xpYi9kaXJlY3RpdmVzL2YtZHJhZ2dhYmxlL25vZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25vZGUtb24tcG9pbnRlci1kb3duJztcbmV4cG9ydCAqIGZyb20gJy4vbm9kZS1vbi1wb2ludGVyLW1vdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlLW9uLXBvaW50ZXItdXAnO1xuIl19

package/esm2022/lib/directives/f-draggable/node/node-on-pointer-down/index.mjs

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

package/esm2022/lib/directives/f-draggable/node/node-on-pointer-down/node-on-pointer-down.request.mjs

@@ -0,0 +1,9 @@
+export class NodeOnPointerDownRequest {
+    constructor(event, transform, selectedItems, isMoveCurrentNode = false) {
+        this.event = event;
+        this.transform = transform;
+        this.selectedItems = selectedItems;
+        this.isMoveCurrentNode = isMoveCurrentNode;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1vbi1wb2ludGVyLWRvd24ucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvbGliL2RpcmVjdGl2ZXMvZi1kcmFnZ2FibGUvbm9kZS9ub2RlLW9uLXBvaW50ZXItZG93bi9ub2RlLW9uLXBvaW50ZXItZG93bi5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx3QkFBd0I7SUFFbkMsWUFDUyxLQUFvQixFQUNwQixTQUEwQixFQUMxQixhQUE0QixFQUM1QixvQkFBNkIsS0FBSztRQUhsQyxVQUFLLEdBQUwsS0FBSyxDQUFlO1FBQ3BCLGNBQVMsR0FBVCxTQUFTLENBQWlCO1FBQzFCLGtCQUFhLEdBQWIsYUFBYSxDQUFlO1FBQzVCLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBaUI7SUFFM0MsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50ZXJFdmVudCwgSVRyYW5zZm9ybU1vZGVsIH0gZnJvbSAnQGZvYmxleC9jb3JlJztcbmltcG9ydCB7IElTZWxlY3RhYmxlIH0gZnJvbSAnLi4vLi4vLi4vLi4vaS1zZWxlY3RhYmxlJztcblxuZXhwb3J0IGNsYXNzIE5vZGVPblBvaW50ZXJEb3duUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGV2ZW50OiBJUG9pbnRlckV2ZW50LFxuICAgIHB1YmxpYyB0cmFuc2Zvcm06IElUcmFuc2Zvcm1Nb2RlbCxcbiAgICBwdWJsaWMgc2VsZWN0ZWRJdGVtczogSVNlbGVjdGFibGVbXSxcbiAgICBwdWJsaWMgaXNNb3ZlQ3VycmVudE5vZGU6IGJvb2xlYW4gPSBmYWxzZVxuICApIHtcbiAgfVxufVxuIl19