@foblex/flow 18.0.0 → 18.1.1

package/esm2022/f-draggable/drag-node/drag-node-finalize/drag-node-finalize.mjs

@@ -0,0 +1,104 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { DragNodeFinalizeRequest } from './drag-node-finalize-request';
+import { Point } from '@foblex/2d';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { DetectConnectionsUnderDragNodeRequest } from '../../domain';
+import { DragNodeHandler } from '../drag-node-handler';
+import { FMoveNodesEvent } from '../f-move-nodes-event';
+import * as i0 from "@angular/core";
+let DragNodeFinalize = class DragNodeFinalize {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _dragSession = inject(FDraggableDataContext);
+    _dragHandler;
+    handle({ event }) {
+        this._dragHandler = this._getDragHandler();
+        if (!this._dragHandler) {
+            return;
+        }
+        const delta = this._buildDragDelta(event.getPosition());
+        const snaps = this._dragHandler.calculateMagneticSnaps(delta);
+        const snappedDelta = this._applySnapToDelta(delta, snaps.lines, snaps.rects);
+        this._finalizeMove(this._dragHandler, snappedDelta);
+        this._emitNodeIntersectIfNeeded(this._dragHandler);
+    }
+    _getDragHandler() {
+        return this._dragSession.draggableItems.find((x) => x instanceof DragNodeHandler);
+    }
+    _buildDragDelta(pointerPosition) {
+        return Point.fromPoint(pointerPosition)
+            .elementTransform(this._store.flowHost)
+            .div(this._dragSession.onPointerDownScale)
+            .sub(this._dragSession.onPointerDownPosition);
+    }
+    _applySnapToDelta(delta, lineSnap, rectSnap) {
+        let x = delta.x;
+        let y = delta.y;
+        if (lineSnap) {
+            x = this._hasLineSnapValue(lineSnap.x) ? delta.x - (lineSnap.x.delta || 0) : x;
+            y = this._hasLineSnapValue(lineSnap.y) ? delta.y - (lineSnap.y.delta || 0) : y;
+        }
+        if (this._hasRectSnapValue(rectSnap)) {
+            if (rectSnap.axis === 'x') {
+                x = delta.x - rectSnap.delta;
+                y = delta.y - (rectSnap.crossDelta ?? 0);
+            }
+            else {
+                y = delta.y - rectSnap.delta;
+                x = delta.x - (rectSnap.crossDelta ?? 0);
+            }
+        }
+        return { x, y };
+    }
+    _hasLineSnapValue(result) {
+        // distance is assumed to exist when value is defined (as in your current logic)
+        return result.guide !== undefined && result.guide !== null;
+    }
+    _hasRectSnapValue(result) {
+        return !!result && result.axis !== undefined && result.delta !== undefined;
+    }
+    _finalizeMove(handler, delta) {
+        // finalize constraints for roots
+        for (const root of handler.roots) {
+            root.finalizeConstraints();
+        }
+        handler.onPointerMove(delta);
+        handler.onPointerUp?.();
+        this._store.fDraggable?.fMoveNodes.emit(this._buildMoveNodesEvent(handler));
+    }
+    _buildMoveNodesEvent(handler) {
+        // Prefer new event shape: kind/data
+        // but keep backward compat: fData
+        const dragEvent = handler.getEvent();
+        const data = dragEvent.data ?? dragEvent.fData;
+        const ids = data?.fNodeIds ?? [];
+        const nodes = ids.map((id) => ({
+            id,
+            position: this._store.nodes.get(id)?._position,
+        }));
+        return new FMoveNodesEvent(nodes);
+    }
+    _emitNodeIntersectIfNeeded(handler) {
+        if (!this._isDraggedJustOneNode(handler) || !this._store.fDraggable?.fEmitOnNodeIntersect) {
+            return;
+        }
+        const nodeOrGroup = handler.roots[0].nodeOrGroup;
+        queueMicrotask(() => this._mediator.execute(new DetectConnectionsUnderDragNodeRequest(nodeOrGroup)));
+    }
+    _isDraggedJustOneNode(handler) {
+        return handler.roots.length === 1;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeFinalize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeFinalize });
+};
+DragNodeFinalize = __decorate([
+    FExecutionRegister(DragNodeFinalizeRequest)
+], DragNodeFinalize);
+export { DragNodeFinalize };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeFinalize, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-node-finalize.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-node/drag-node-finalize/drag-node-finalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { DragNodeFinalizeRequest } from './drag-node-finalize-request';\nimport { IPoint, Point } from '@foblex/2d';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { DetectConnectionsUnderDragNodeRequest } from '../../domain';\nimport { DragNodeHandler } from '../drag-node-handler';\nimport { FNodeBase } from '../../../f-node';\nimport { FMoveNodesEvent } from '../f-move-nodes-event';\nimport { IMagneticAxisGuide, IMagneticGuidesResult } from '../magnetic-lines';\nimport { IMagneticRectsResult } from '../magnetic-rects';\n\n@Injectable()\n@FExecutionRegister(DragNodeFinalizeRequest)\nexport class DragNodeFinalize implements IExecution<DragNodeFinalizeRequest, void> {\n  private readonly _mediator = inject(FMediator);\n  private readonly _store = inject(FComponentsStore);\n  private readonly _dragSession = inject(FDraggableDataContext);\n\n  private _dragHandler?: DragNodeHandler | undefined;\n\n  public handle({ event }: DragNodeFinalizeRequest): void {\n    this._dragHandler = this._getDragHandler();\n    if (!this._dragHandler) {\n      return;\n    }\n\n    const delta = this._buildDragDelta(event.getPosition());\n    const snaps = this._dragHandler.calculateMagneticSnaps(delta);\n    const snappedDelta = this._applySnapToDelta(delta, snaps.lines, snaps.rects);\n\n    this._finalizeMove(this._dragHandler, snappedDelta);\n    this._emitNodeIntersectIfNeeded(this._dragHandler);\n  }\n\n  private _getDragHandler(): DragNodeHandler | undefined {\n    return this._dragSession.draggableItems.find((x) => x instanceof DragNodeHandler);\n  }\n\n  private _buildDragDelta(pointerPosition: IPoint): Point {\n    return Point.fromPoint(pointerPosition)\n      .elementTransform(this._store.flowHost)\n      .div(this._dragSession.onPointerDownScale)\n      .sub(this._dragSession.onPointerDownPosition);\n  }\n\n  private _applySnapToDelta(\n    delta: IPoint,\n    lineSnap?: IMagneticGuidesResult,\n    rectSnap?: IMagneticRectsResult,\n  ): IPoint {\n    let x = delta.x;\n    let y = delta.y;\n\n    if (lineSnap) {\n      x = this._hasLineSnapValue(lineSnap.x) ? delta.x - (lineSnap.x.delta || 0) : x;\n      y = this._hasLineSnapValue(lineSnap.y) ? delta.y - (lineSnap.y.delta || 0) : y;\n    }\n\n    if (this._hasRectSnapValue(rectSnap)) {\n      if (rectSnap.axis === 'x') {\n        x = delta.x - rectSnap.delta;\n        y = delta.y - (rectSnap.crossDelta ?? 0);\n      } else {\n        y = delta.y - rectSnap.delta;\n        x = delta.x - (rectSnap.crossDelta ?? 0);\n      }\n    }\n\n    return { x, y };\n  }\n\n  private _hasLineSnapValue(result: IMagneticAxisGuide): boolean {\n    // distance is assumed to exist when value is defined (as in your current logic)\n    return result.guide !== undefined && result.guide !== null;\n  }\n\n  private _hasRectSnapValue(\n    result?: IMagneticRectsResult,\n  ): result is IMagneticRectsResult & { axis: 'x' | 'y'; delta: number } {\n    return !!result && result.axis !== undefined && result.delta !== undefined;\n  }\n\n  private _finalizeMove(handler: DragNodeHandler, delta: IPoint): void {\n    // finalize constraints for roots\n    for (const root of handler.roots) {\n      root.finalizeConstraints();\n    }\n\n    handler.onPointerMove(delta);\n    handler.onPointerUp?.();\n\n    this._store.fDraggable?.fMoveNodes.emit(this._buildMoveNodesEvent(handler));\n  }\n\n  private _buildMoveNodesEvent(handler: DragNodeHandler): FMoveNodesEvent {\n    // Prefer new event shape: kind/data\n    // but keep backward compat: fData\n    const dragEvent = handler.getEvent();\n    const data = dragEvent.data ?? dragEvent.fData;\n\n    const ids: string[] = data?.fNodeIds ?? [];\n\n    const nodes = ids.map((id) => ({\n      id,\n      position: this._store.nodes.get(id)?._position as IPoint,\n    }));\n\n    return new FMoveNodesEvent(nodes);\n  }\n\n  private _emitNodeIntersectIfNeeded(handler: DragNodeHandler): void {\n    if (!this._isDraggedJustOneNode(handler) || !this._store.fDraggable?.fEmitOnNodeIntersect) {\n      return;\n    }\n\n    const nodeOrGroup = handler.roots[0].nodeOrGroup as FNodeBase;\n\n    queueMicrotask(() =>\n      this._mediator.execute(new DetectConnectionsUnderDragNodeRequest(nodeOrGroup)),\n    );\n  }\n\n  private _isDraggedJustOneNode(handler: DragNodeHandler): boolean {\n    return handler.roots.length === 1;\n  }\n}\n"]}

package/esm2022/f-draggable/drag-node/drag-node-finalize/index.mjs

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

package/esm2022/f-draggable/drag-node/drag-node-handler/drag-node-handler.mjs

@@ -0,0 +1,92 @@
+import { RectExtensions } from '@foblex/2d';
+import { Injectable } from '@angular/core';
+import { DragHandlerBase } from '../../infrastructure';
+import { FDragNodeStartEventData } from '../f-drag-node-start-event-data';
+import * as i0 from "@angular/core";
+export class DragNodeHandler extends DragHandlerBase {
+    type = 'move-node';
+    kind = 'drag-node';
+    data() {
+        return new FDragNodeStartEventData(this.items.map((x) => x.nodeOrGroup.fId()));
+    }
+    _magneticLines = null;
+    _magneticRects = null;
+    /** Every dragged item (nodes + groups including deep children) */
+    items;
+    /** Roots of drag hierarchy (top-level items without selected parents) */
+    roots;
+    initialize(
+    /** Every dragged item (nodes + groups including deep children) */
+    items, 
+    /** Roots of drag hierarchy (top-level items without selected parents) */
+    roots) {
+        this.items = items;
+        this.roots = roots;
+    }
+    setMagneticLines(handler) {
+        this._magneticLines = handler;
+    }
+    setMagneticRects(handler) {
+        this._magneticRects = handler;
+    }
+    calculateMagneticLinesGuides(delta) {
+        return this.calculateMagneticSnaps(delta).lines;
+    }
+    calculateMagneticSnaps(delta) {
+        // preview move roots to update their last rects
+        this._previewRoots(delta);
+        const draggedRect = this._rootsUnionRect();
+        return {
+            lines: this._magneticLines?._computeGuides(draggedRect),
+            rects: this._magneticRects?._computeRects(draggedRect),
+        };
+    }
+    prepareDragSequence() {
+        for (const root of this.roots) {
+            root.prepareDragSequence();
+        }
+    }
+    onPointerMove(delta) {
+        this._previewRoots(delta);
+        const draggedRect = this._rootsUnionRect();
+        this._magneticLines?.scheduleRender(draggedRect);
+        this._magneticRects?.scheduleRender(draggedRect);
+    }
+    onPointerUp() {
+        for (const root of this.roots) {
+            root.onPointerUp();
+        }
+        this._magneticLines?.clearGuides();
+        this._magneticRects?.clearGuides();
+        requestAnimationFrame(() => this._refreshDraggedNodes());
+    }
+    _previewRoots(delta) {
+        for (const root of this.roots) {
+            root.onPointerMove(delta);
+        }
+    }
+    _rootsUnionRect() {
+        let result = null;
+        for (const root of this.roots) {
+            const rect = root.getLastRect();
+            result = result ? RectExtensions.union([result, rect]) : rect;
+        }
+        return result ?? RectExtensions.initialize();
+    }
+    _refreshDraggedNodes() {
+        for (const { nodeOrGroup } of this.roots) {
+            nodeOrGroup.refresh();
+        }
+    }
+    destroy() {
+        for (const root of this.roots) {
+            root.destroy?.();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeHandler, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeHandler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodeHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-node-handler.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-node/drag-node-handler/drag-node-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, IRect, RectExtensions } from '@foblex/2d';\nimport { DragNodeItemHandler } from './drag-node-item-handler';\nimport { Injectable } from '@angular/core';\nimport { DragHandlerBase } from '../../infrastructure';\nimport { FDragNodeStartEventData } from '../f-drag-node-start-event-data';\nimport { IMagneticGuidesResult, MagneticLinesHandler } from '../magnetic-lines';\nimport { IMagneticRectsResult, MagneticRectsHandler } from '../magnetic-rects';\n\n@Injectable()\nexport class DragNodeHandler extends DragHandlerBase<FDragNodeStartEventData> {\n  protected readonly type = 'move-node';\n  protected readonly kind = 'drag-node';\n\n  protected override data(): FDragNodeStartEventData {\n    return new FDragNodeStartEventData(this.items.map((x) => x.nodeOrGroup.fId()));\n  }\n\n  private _magneticLines: MagneticLinesHandler | null = null;\n  private _magneticRects: MagneticRectsHandler | null = null;\n\n  /** Every dragged item (nodes + groups including deep children) */\n  public items!: DragNodeItemHandler[];\n  /** Roots of drag hierarchy (top-level items without selected parents) */\n  public roots!: DragNodeItemHandler[];\n\n  public initialize(\n    /** Every dragged item (nodes + groups including deep children) */\n    items: DragNodeItemHandler[],\n    /** Roots of drag hierarchy (top-level items without selected parents) */\n    roots: DragNodeItemHandler[],\n  ): void {\n    this.items = items;\n    this.roots = roots;\n  }\n\n  public setMagneticLines(handler: MagneticLinesHandler): void {\n    this._magneticLines = handler;\n  }\n\n  public setMagneticRects(handler: MagneticRectsHandler): void {\n    this._magneticRects = handler;\n  }\n\n  public calculateMagneticLinesGuides(delta: IPoint): IMagneticGuidesResult | undefined {\n    return this.calculateMagneticSnaps(delta).lines;\n  }\n\n  public calculateMagneticSnaps(delta: IPoint): {\n    lines?: IMagneticGuidesResult;\n    rects?: IMagneticRectsResult;\n  } {\n    // preview move roots to update their last rects\n    this._previewRoots(delta);\n\n    const draggedRect = this._rootsUnionRect();\n\n    return {\n      lines: this._magneticLines?._computeGuides(draggedRect),\n      rects: this._magneticRects?._computeRects(draggedRect),\n    };\n  }\n\n  public override prepareDragSequence(): void {\n    for (const root of this.roots) {\n      root.prepareDragSequence();\n    }\n  }\n\n  public override onPointerMove(delta: IPoint): void {\n    this._previewRoots(delta);\n\n    const draggedRect = this._rootsUnionRect();\n    this._magneticLines?.scheduleRender(draggedRect);\n    this._magneticRects?.scheduleRender(draggedRect);\n  }\n\n  public override onPointerUp(): void {\n    for (const root of this.roots) {\n      root.onPointerUp();\n    }\n\n    this._magneticLines?.clearGuides();\n    this._magneticRects?.clearGuides();\n    requestAnimationFrame(() => this._refreshDraggedNodes());\n  }\n\n  private _previewRoots(delta: IPoint): void {\n    for (const root of this.roots) {\n      root.onPointerMove(delta);\n    }\n  }\n\n  private _rootsUnionRect(): IRect {\n    let result: IRect | null = null;\n\n    for (const root of this.roots) {\n      const rect = root.getLastRect();\n      result = result ? RectExtensions.union([result, rect]) : rect;\n    }\n\n    return result ?? RectExtensions.initialize();\n  }\n\n  private _refreshDraggedNodes(): void {\n    for (const { nodeOrGroup } of this.roots) {\n      nodeOrGroup.refresh();\n    }\n  }\n\n  public override destroy(): void {\n    for (const root of this.roots) {\n      root.destroy?.();\n    }\n  }\n}\n"]}

package/esm2022/f-draggable/drag-node/drag-node-handler/drag-node-item-handler.mjs

@@ -0,0 +1,125 @@
+import { PointExtensions, RectExtensions } from '@foblex/2d';
+import { FMediator } from '@foblex/mediator';
+import { DragHandlerBase } from '../../infrastructure';
+import { DragNodeDeltaConstraints, expandRectByOverflow, } from '../drag-node-constraint';
+import { F_CSS_CLASS, GetNormalizedElementRectRequest } from '../../../domain';
+export class DragNodeItemHandler extends DragHandlerBase {
+    _injector;
+    nodeOrGroup;
+    children;
+    sourceConnectionHandlers;
+    targetConnectionHandlers;
+    type = 'move-node';
+    kind = 'drag-node';
+    _startPosition = PointExtensions.initialize();
+    _startRect = RectExtensions.initialize();
+    _applyConstraints = (delta) => delta;
+    _lastSoftResults = [];
+    _deltaConstraints;
+    _constraints;
+    _lastPosition = PointExtensions.initialize();
+    _mediator;
+    constructor(_injector, nodeOrGroup, children = [], sourceConnectionHandlers = [], targetConnectionHandlers = []) {
+        super();
+        this._injector = _injector;
+        this.nodeOrGroup = nodeOrGroup;
+        this.children = children;
+        this.sourceConnectionHandlers = sourceConnectionHandlers;
+        this.targetConnectionHandlers = targetConnectionHandlers;
+        this._mediator = _injector.get(FMediator);
+        this._startRect = this._mediator.execute(new GetNormalizedElementRectRequest(nodeOrGroup.hostElement));
+        this._startPosition = { ...nodeOrGroup._position };
+    }
+    setConstraints(constraints) {
+        this._constraints = constraints;
+        this._deltaConstraints = new DragNodeDeltaConstraints(this._injector, this._startPosition, constraints);
+        this._applyConstraints = (difference) => {
+            const summary = this._deltaConstraints.apply(difference);
+            this._applySoftExpansions(summary.soft);
+            return summary.hardDelta;
+        };
+    }
+    finalizeConstraints() {
+        // in finalize we force snap and commit expansions based on finalized delta
+        this._applyConstraints = (delta) => {
+            const summary = this._deltaConstraints.finalize(delta);
+            this._applySoftExpansions(summary.soft);
+            return summary.hardDelta;
+        };
+    }
+    getLastRect() {
+        return RectExtensions.initialize(this._lastPosition.x, this._lastPosition.y, this._startRect.width, this._startRect.height);
+    }
+    prepareDragSequence() {
+        for (const child of this.children) {
+            child.prepareDragSequence();
+        }
+        this.nodeOrGroup.hostElement.classList.add(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);
+    }
+    onPointerMove(delta) {
+        const constrained = this._applyConstraints(delta);
+        for (const child of this.children) {
+            child.onPointerMove(constrained);
+        }
+        this._redraw(this._startPlus(constrained));
+        for (const h of this.sourceConnectionHandlers) {
+            h.setSourceDelta(constrained);
+        }
+        for (const h of this.targetConnectionHandlers) {
+            h.setTargetDelta(constrained);
+        }
+    }
+    onPointerUp() {
+        for (const child of this.children) {
+            child.onPointerUp();
+        }
+        this.nodeOrGroup.position.set(this.nodeOrGroup._position);
+        this.nodeOrGroup.hostElement.classList.remove(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);
+        this._emitExpandedEvent();
+    }
+    _startPlus(delta) {
+        return PointExtensions.sum(this._startPosition, delta);
+    }
+    _redraw(position) {
+        this._lastPosition = position;
+        this.nodeOrGroup.updatePosition(position);
+        this.nodeOrGroup.redraw();
+    }
+    _applySoftExpansions(results) {
+        this._lastSoftResults = results;
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const soft = this._constraints.soft[i];
+            const expandedRect = expandRectByOverflow(soft.boundingRect, r.overflow, r.edges);
+            this._commitParentRect(soft.nodeOrGroup, expandedRect);
+        }
+    }
+    _commitParentRect(parent, rect) {
+        parent.updateSize({ width: rect.width, height: rect.height });
+        parent.updatePosition({ x: rect.x, y: rect.y });
+        parent.redraw();
+    }
+    _emitExpandedEvent() {
+        for (let i = 0; i < this._lastSoftResults.length; i++) {
+            const r = this._lastSoftResults[i];
+            if (!r.overflow.x && !r.overflow.y) {
+                continue;
+            }
+            const soft = this._constraints.soft[i];
+            const expandedRect = expandRectByOverflow(soft.boundingRect, r.overflow, r.edges);
+            soft.nodeOrGroup.sizeChange.emit(expandedRect);
+        }
+    }
+    destroy() {
+        for (const child of this.children) {
+            child.destroy?.();
+        }
+        this.children = [];
+        this.sourceConnectionHandlers = [];
+        this.targetConnectionHandlers = [];
+        // this._constraints = null;
+        this._lastSoftResults = [];
+        this._applyConstraints = (d) => d;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-node-item-handler.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-node/drag-node-handler/drag-node-item-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, IRect, PointExtensions, RectExtensions } from '@foblex/2d';\nimport { Injector } from '@angular/core';\nimport { FMediator } from '@foblex/mediator';\nimport { DragHandlerBase } from '../../infrastructure';\nimport {\n  DragNodeDeltaConstraints,\n  expandRectByOverflow,\n  IDeltaClampResult,\n  IDragNodeDeltaConstraints,\n} from '../drag-node-constraint';\nimport { FNodeBase } from '../../../f-node';\nimport { DragNodeConnectionHandlerBase } from '../drag-node-dependent-connection-handlers';\nimport { F_CSS_CLASS, GetNormalizedElementRectRequest } from '../../../domain';\n\nexport class DragNodeItemHandler extends DragHandlerBase<unknown> {\n  protected readonly type = 'move-node';\n  protected readonly kind = 'drag-node';\n\n  private readonly _startPosition = PointExtensions.initialize();\n  private readonly _startRect = RectExtensions.initialize();\n\n  private _applyConstraints: (delta: IPoint) => IPoint = (delta) => delta;\n\n  private _lastSoftResults: IDeltaClampResult[] = [];\n  private _deltaConstraints!: DragNodeDeltaConstraints;\n\n  private _constraints!: IDragNodeDeltaConstraints;\n  private _lastPosition = PointExtensions.initialize();\n\n  private readonly _mediator: FMediator;\n\n  constructor(\n    private readonly _injector: Injector,\n    public readonly nodeOrGroup: FNodeBase,\n\n    public children: DragNodeItemHandler[] = [],\n    public sourceConnectionHandlers: DragNodeConnectionHandlerBase[] = [],\n    public targetConnectionHandlers: DragNodeConnectionHandlerBase[] = [],\n  ) {\n    super();\n\n    this._mediator = _injector.get(FMediator);\n\n    this._startRect = this._mediator.execute(\n      new GetNormalizedElementRectRequest(nodeOrGroup.hostElement),\n    );\n    this._startPosition = { ...nodeOrGroup._position };\n  }\n\n  public setConstraints(constraints: IDragNodeDeltaConstraints): void {\n    this._constraints = constraints;\n    this._deltaConstraints = new DragNodeDeltaConstraints(\n      this._injector,\n      this._startPosition,\n      constraints,\n    );\n\n    this._applyConstraints = (difference) => {\n      const summary = this._deltaConstraints.apply(difference);\n      this._applySoftExpansions(summary.soft);\n\n      return summary.hardDelta;\n    };\n  }\n\n  public finalizeConstraints(): void {\n    // in finalize we force snap and commit expansions based on finalized delta\n    this._applyConstraints = (delta) => {\n      const summary = this._deltaConstraints.finalize(delta);\n      this._applySoftExpansions(summary.soft);\n\n      return summary.hardDelta;\n    };\n  }\n\n  public getLastRect(): IRect {\n    return RectExtensions.initialize(\n      this._lastPosition.x,\n      this._lastPosition.y,\n      this._startRect.width,\n      this._startRect.height,\n    );\n  }\n\n  public override prepareDragSequence(): void {\n    for (const child of this.children) {\n      child.prepareDragSequence();\n    }\n\n    this.nodeOrGroup.hostElement.classList.add(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);\n  }\n\n  public override onPointerMove(delta: IPoint): void {\n    const constrained = this._applyConstraints(delta);\n\n    for (const child of this.children) {\n      child.onPointerMove(constrained);\n    }\n\n    this._redraw(this._startPlus(constrained));\n\n    for (const h of this.sourceConnectionHandlers) {\n      h.setSourceDelta(constrained);\n    }\n    for (const h of this.targetConnectionHandlers) {\n      h.setTargetDelta(constrained);\n    }\n  }\n\n  public override onPointerUp(): void {\n    for (const child of this.children) {\n      child.onPointerUp();\n    }\n\n    this.nodeOrGroup.position.set(this.nodeOrGroup._position);\n    this.nodeOrGroup.hostElement.classList.remove(F_CSS_CLASS.DRAG_AND_DROP.DRAGGING);\n\n    this._emitExpandedEvent();\n  }\n\n  private _startPlus(delta: IPoint): IPoint {\n    return PointExtensions.sum(this._startPosition, delta);\n  }\n\n  private _redraw(position: IPoint): void {\n    this._lastPosition = position;\n    this.nodeOrGroup.updatePosition(position);\n    this.nodeOrGroup.redraw();\n  }\n\n  private _applySoftExpansions(results: IDeltaClampResult[]): void {\n    this._lastSoftResults = results;\n\n    for (let i = 0; i < results.length; i++) {\n      const r = results[i];\n      const soft = this._constraints.soft[i];\n\n      const expandedRect = expandRectByOverflow(soft.boundingRect, r.overflow, r.edges);\n\n      this._commitParentRect(soft.nodeOrGroup, expandedRect);\n    }\n  }\n\n  private _commitParentRect(parent: FNodeBase, rect: IRect): void {\n    parent.updateSize({ width: rect.width, height: rect.height });\n    parent.updatePosition({ x: rect.x, y: rect.y });\n    parent.redraw();\n  }\n\n  private _emitExpandedEvent(): void {\n    for (let i = 0; i < this._lastSoftResults.length; i++) {\n      const r = this._lastSoftResults[i];\n      if (!r.overflow.x && !r.overflow.y) {\n        continue;\n      }\n\n      const soft = this._constraints.soft[i];\n      const expandedRect = expandRectByOverflow(soft.boundingRect, r.overflow, r.edges);\n\n      soft.nodeOrGroup.sizeChange.emit(expandedRect);\n    }\n  }\n\n  public override destroy(): void {\n    for (const child of this.children) {\n      child.destroy?.();\n    }\n\n    this.children = [];\n    this.sourceConnectionHandlers = [];\n    this.targetConnectionHandlers = [];\n\n    // this._constraints = null;\n    this._lastSoftResults = [];\n    this._applyConstraints = (d) => d;\n  }\n}\n"]}

package/esm2022/f-draggable/drag-node/drag-node-handler/index.mjs

@@ -0,0 +1,3 @@
+export * from './drag-node-handler';
+export * from './drag-node-item-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9kcmFnLW5vZGUtaGFuZGxlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYWctbm9kZS1oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1ub2RlLWl0ZW0taGFuZGxlcic7XG4iXX0=

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

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

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

@@ -0,0 +1,76 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { DragNodePreparationRequest } from './drag-node-preparation-request';
+import { Point } from '@foblex/2d';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { AttachDragNodeHandlerFromSelectionRequest } from '../attach-drag-node-handler-from-selection';
+import { isValidEventTrigger, SelectAndUpdateNodeLayerRequest, } from '../../../domain';
+import { isClosestElementHasClass } from '@foblex/utils';
+import { MagneticLinesPreparationRequest } from '../magnetic-lines';
+import { MagneticRectsPreparationRequest } from '../magnetic-rects';
+import * as i0 from "@angular/core";
+let DragNodePreparation = class DragNodePreparation {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _dragSession = inject(FDraggableDataContext);
+    handle({ event, trigger }) {
+        if (!this._canStartDrag(event, trigger)) {
+            return;
+        }
+        const node = this._findDraggableNode(event.targetElement);
+        if (!node) {
+            return;
+        }
+        this._storePointerDownContext(event);
+        // Store pointer-down context for other handlers
+        this._dragSession.draggableItems = [this._buildDragNodeHandler(node)];
+        this._mediator.execute(new MagneticLinesPreparationRequest());
+        this._mediator.execute(new MagneticRectsPreparationRequest());
+    }
+    _canStartDrag(event, trigger) {
+        return (this._dragSession.isEmpty() &&
+            this._isDragHandle(event.targetElement) &&
+            isValidEventTrigger(event.originalEvent, trigger));
+    }
+    _isDragHandle(element) {
+        return isClosestElementHasClass(element, '.f-drag-handle');
+    }
+    _findDraggableNode(target) {
+        const nodes = this._store.nodes.getAll();
+        for (const node of nodes) {
+            if (node.fDraggingDisabled()) {
+                continue;
+            }
+            if (node.isContains(target)) {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    _storePointerDownContext(event) {
+        this._dragSession.onPointerDownScale = this._store.transform.scale;
+        this._dragSession.onPointerDownPosition = Point.fromPoint(event.getPosition())
+            .elementTransform(this._store.flowHost)
+            .div(this._store.transform.scale);
+    }
+    _buildDragNodeHandler(node) {
+        if (node.fSelectionDisabled() || !node.isSelected()) {
+            queueMicrotask(() => {
+                this._mediator.execute(new SelectAndUpdateNodeLayerRequest(node));
+            });
+        }
+        return this._mediator.execute(new AttachDragNodeHandlerFromSelectionRequest(node));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodePreparation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodePreparation });
+};
+DragNodePreparation = __decorate([
+    FExecutionRegister(DragNodePreparationRequest)
+], DragNodePreparation);
+export { DragNodePreparation };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragNodePreparation, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-node-preparation.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-node/drag-node-preparation/drag-node-preparation.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { DragNodePreparationRequest } from './drag-node-preparation-request';\nimport { Point } from '@foblex/2d';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { FNodeBase } from '../../../f-node';\nimport { AttachDragNodeHandlerFromSelectionRequest } from '../attach-drag-node-handler-from-selection';\nimport {\n  FEventTrigger,\n  isValidEventTrigger,\n  SelectAndUpdateNodeLayerRequest,\n} from '../../../domain';\nimport { isClosestElementHasClass } from '@foblex/utils';\nimport { DragNodeHandler } from '../drag-node-handler';\nimport { IPointerEvent } from '../../../drag-toolkit';\nimport { MagneticLinesPreparationRequest } from '../magnetic-lines';\nimport { MagneticRectsPreparationRequest } from '../magnetic-rects';\n\n@Injectable()\n@FExecutionRegister(DragNodePreparationRequest)\nexport class DragNodePreparation implements IExecution<DragNodePreparationRequest, void> {\n  private readonly _mediator = inject(FMediator);\n  private readonly _store = inject(FComponentsStore);\n  private readonly _dragSession = inject(FDraggableDataContext);\n\n  public handle({ event, trigger }: DragNodePreparationRequest): void {\n    if (!this._canStartDrag(event, trigger)) {\n      return;\n    }\n\n    const node = this._findDraggableNode(event.targetElement);\n    if (!node) {\n      return;\n    }\n\n    this._storePointerDownContext(event);\n\n    // Store pointer-down context for other handlers\n    this._dragSession.draggableItems = [this._buildDragNodeHandler(node)];\n\n    this._mediator.execute<void>(new MagneticLinesPreparationRequest());\n    this._mediator.execute<void>(new MagneticRectsPreparationRequest());\n  }\n\n  private _canStartDrag(event: IPointerEvent, trigger: FEventTrigger): boolean {\n    return (\n      this._dragSession.isEmpty() &&\n      this._isDragHandle(event.targetElement) &&\n      isValidEventTrigger(event.originalEvent, trigger)\n    );\n  }\n\n  private _isDragHandle(element: HTMLElement): boolean {\n    return isClosestElementHasClass(element, '.f-drag-handle');\n  }\n\n  private _findDraggableNode(target: HTMLElement): FNodeBase | undefined {\n    const nodes = this._store.nodes.getAll();\n\n    for (const node of nodes) {\n      if (node.fDraggingDisabled()) {\n        continue;\n      }\n\n      if (node.isContains(target)) {\n        return node;\n      }\n    }\n\n    return undefined;\n  }\n\n  private _storePointerDownContext(event: IPointerEvent): void {\n    this._dragSession.onPointerDownScale = this._store.transform.scale;\n    this._dragSession.onPointerDownPosition = Point.fromPoint(event.getPosition())\n      .elementTransform(this._store.flowHost)\n      .div(this._store.transform.scale);\n  }\n\n  private _buildDragNodeHandler(node: FNodeBase): DragNodeHandler {\n    if (node.fSelectionDisabled() || !node.isSelected()) {\n      queueMicrotask(() => {\n        this._mediator.execute<void>(new SelectAndUpdateNodeLayerRequest(node));\n      });\n    }\n\n    return this._mediator.execute(new AttachDragNodeHandlerFromSelectionRequest(node));\n  }\n}\n"]}

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

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

package/esm2022/f-draggable/drag-node/f-drag-node-start-event-data.mjs

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

package/esm2022/f-draggable/drag-node/f-move-nodes-event.mjs

@@ -0,0 +1,16 @@
+/**
+ * Event that is emitted when nodes and groups are moved.
+ * It contains the moved nodes and groups and their new positions.
+ */
+export class FMoveNodesEvent {
+    /** Preferred name */
+    nodes;
+    /** @deprecated Use `nodes` */
+    fNodes;
+    constructor(nodes) {
+        // single source of truth, same reference
+        this.nodes = nodes;
+        this.fNodes = nodes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1tb3ZlLW5vZGVzLWV2ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9kcmFnLW5vZGUvZi1tb3ZlLW5vZGVzLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBOzs7R0FHRztBQUNILE1BQU0sT0FBTyxlQUFlO0lBQzFCLHFCQUFxQjtJQUNMLEtBQUssQ0FBc0I7SUFFM0MsOEJBQThCO0lBQ2QsTUFBTSxDQUFzQjtJQUU1QyxZQUFZLEtBQTBCO1FBQ3BDLHlDQUF5QztRQUN6QyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztJQUN0QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcblxuZXhwb3J0IHR5cGUgRk1vdmVOb2RlUG9zaXRpb24gPSB7IGlkOiBzdHJpbmc7IHBvc2l0aW9uOiBJUG9pbnQgfTtcblxuLyoqXG4gKiBFdmVudCB0aGF0IGlzIGVtaXR0ZWQgd2hlbiBub2RlcyBhbmQgZ3JvdXBzIGFyZSBtb3ZlZC5cbiAqIEl0IGNvbnRhaW5zIHRoZSBtb3ZlZCBub2RlcyBhbmQgZ3JvdXBzIGFuZCB0aGVpciBuZXcgcG9zaXRpb25zLlxuICovXG5leHBvcnQgY2xhc3MgRk1vdmVOb2Rlc0V2ZW50IHtcbiAgLyoqIFByZWZlcnJlZCBuYW1lICovXG4gIHB1YmxpYyByZWFkb25seSBub2RlczogRk1vdmVOb2RlUG9zaXRpb25bXTtcblxuICAvKiogQGRlcHJlY2F0ZWQgVXNlIGBub2Rlc2AgKi9cbiAgcHVibGljIHJlYWRvbmx5IGZOb2RlczogRk1vdmVOb2RlUG9zaXRpb25bXTtcblxuICBjb25zdHJ1Y3Rvcihub2RlczogRk1vdmVOb2RlUG9zaXRpb25bXSkge1xuICAgIC8vIHNpbmdsZSBzb3VyY2Ugb2YgdHJ1dGgsIHNhbWUgcmVmZXJlbmNlXG4gICAgdGhpcy5ub2RlcyA9IG5vZGVzO1xuICAgIHRoaXMuZk5vZGVzID0gbm9kZXM7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,12 @@
+export * from './attach-drag-node-handler-from-selection';
+export * from './magnetic-lines';
+export * from './magnetic-rects';
+export * from './drag-node-constraint';
+export * from './drag-node-dependent-connection-handlers';
+export * from './drag-node-finalize';
+export * from './drag-node-handler';
+export * from './drag-node-preparation';
+export * from './f-move-nodes-event';
+export * from './f-drag-node-start-event-data';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJDQUEyQyxDQUFDO0FBRTFELGNBQWMsa0JBQWtCLENBQUM7QUFFakMsY0FBYyxrQkFBa0IsQ0FBQztBQUVqQyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGNBQWMsMkNBQTJDLENBQUM7QUFFMUQsY0FBYyxzQkFBc0IsQ0FBQztBQUVyQyxjQUFjLHFCQUFxQixDQUFDO0FBRXBDLGNBQWMseUJBQXlCLENBQUM7QUFFeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUVyQyxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdHRhY2gtZHJhZy1ub2RlLWhhbmRsZXItZnJvbS1zZWxlY3Rpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL21hZ25ldGljLWxpbmVzJztcblxuZXhwb3J0ICogZnJvbSAnLi9tYWduZXRpYy1yZWN0cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1ub2RlLWNvbnN0cmFpbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2RyYWctbm9kZS1kZXBlbmRlbnQtY29ubmVjdGlvbi1oYW5kbGVycyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1ub2RlLWZpbmFsaXplJztcblxuZXhwb3J0ICogZnJvbSAnLi9kcmFnLW5vZGUtaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1ub2RlLXByZXBhcmF0aW9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLW1vdmUtbm9kZXMtZXZlbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtZHJhZy1ub2RlLXN0YXJ0LWV2ZW50LWRhdGEnO1xuXG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGVycyc7XG4iXX0=

package/esm2022/f-draggable/drag-node/magnetic-lines/domain/calculate-magnetic-guides.mjs

@@ -0,0 +1,59 @@
+export function calculateMagneticGuides(elements, target, alignThreshold = 10) {
+    const tx = target.x;
+    const ty = target.y;
+    const tr = tx + target.width;
+    const tb = ty + target.height;
+    const tcx = target.gravityCenter.x;
+    const tcy = target.gravityCenter.y;
+    // Best candidates
+    let bestXGuide;
+    let bestXDelta;
+    let bestXAbs = Infinity;
+    let bestYGuide;
+    let bestYDelta;
+    let bestYAbs = Infinity;
+    // Small helpers: readable + avoids repeated Math.abs calls.
+    const considerX = (guide, delta) => {
+        const abs = delta < 0 ? -delta : delta;
+        if (abs <= alignThreshold && abs < bestXAbs) {
+            bestXAbs = abs;
+            bestXGuide = guide;
+            bestXDelta = delta;
+        }
+    };
+    const considerY = (guide, delta) => {
+        const abs = delta < 0 ? -delta : delta;
+        if (abs <= alignThreshold && abs < bestYAbs) {
+            bestYAbs = abs;
+            bestYGuide = guide;
+            bestYDelta = delta;
+        }
+    };
+    for (let i = 0; i < elements.length; i++) {
+        const el = elements[i];
+        // Precompute element anchors once per element
+        const ex = el.x;
+        const ey = el.y;
+        const er = ex + el.width; // element right
+        const eb = ey + el.height; // element bottom
+        const ecx = el.gravityCenter.x;
+        const ecy = el.gravityCenter.y;
+        // X candidates
+        considerX(ex, tx - ex); // target.left - element.left
+        considerX(er, tx - er); // target.left - element.right
+        considerX(ecx, tcx - ecx); // target.center - element.center
+        considerX(ex, tr - ex); // target.right - element.left
+        considerX(er, tr - er); // target.right - element.right
+        // Y candidates
+        considerY(ey, ty - ey); // target.top - element.top
+        considerY(eb, ty - eb); // target.top - element.bottom
+        considerY(ecy, tcy - ecy); // target.center - element.center
+        considerY(ey, tb - ey); // target.bottom - element.top
+        considerY(eb, tb - eb); // target.bottom - element.bottom
+    }
+    return {
+        x: { guide: bestXGuide, delta: bestXDelta },
+        y: { guide: bestYGuide, delta: bestYDelta },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-node/magnetic-lines/domain/i-magnetic-axis-guide.mjs

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

package/esm2022/f-draggable/drag-node/magnetic-lines/domain/i-magnetic-guides-result.mjs

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