@foblex/flow 17.9.81 → 18.1.0

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

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

@@ -0,0 +1,6 @@
+export * from './calculate-magnetic-guides';
+export * from './i-magnetic-axis-guide';
+export * from './i-magnetic-guides-result';
+export * from './magnetic-line-element';
+export * from './magnetic-line-renderer';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9tYWduZXRpYy1saW5lcy9kb21haW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLHlCQUF5QixDQUFDO0FBRXhDLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsY0FBYyx5QkFBeUIsQ0FBQztBQUV4QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jYWxjdWxhdGUtbWFnbmV0aWMtZ3VpZGVzJztcblxuZXhwb3J0ICogZnJvbSAnLi9pLW1hZ25ldGljLWF4aXMtZ3VpZGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2ktbWFnbmV0aWMtZ3VpZGVzLXJlc3VsdCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbWFnbmV0aWMtbGluZS1lbGVtZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9tYWduZXRpYy1saW5lLXJlbmRlcmVyJztcbiJdfQ==

package/esm2022/f-draggable/drag-node/magnetic-lines/domain/magnetic-line-element.mjs

@@ -0,0 +1,34 @@
+const MAGNETIC_LINE_RECT_KEYS = ['left', 'top', 'width', 'height'];
+export class MagneticLineElement {
+    _element;
+    constructor(browser, hostElement, className = 'f-line') {
+        this._element = browser.document.createElement('div');
+        this._element.classList.add(className);
+        this._element.style.position = 'absolute';
+        this._element.style.display = 'none';
+        hostElement.appendChild(this._element);
+    }
+    show() {
+        this._element.style.display = 'block';
+    }
+    hide() {
+        this._element.style.display = 'none';
+    }
+    render(rect) {
+        for (const key of MAGNETIC_LINE_RECT_KEYS) {
+            const value = rect[key];
+            if (value != null) {
+                this._element.style[key] = `${value}px`;
+            }
+        }
+    }
+    clearRect() {
+        for (const key of MAGNETIC_LINE_RECT_KEYS) {
+            this._element.style.removeProperty(key);
+        }
+    }
+    destroy() {
+        this._element.remove();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-node/magnetic-lines/domain/magnetic-line-renderer.mjs

@@ -0,0 +1,44 @@
+import { MagneticLineElement } from './magnetic-line-element';
+export class MagneticLineRenderer {
+    _horizontal;
+    _vertical;
+    constructor(browser, hostElement) {
+        this._horizontal = new MagneticLineElement(browser, hostElement);
+        this._vertical = new MagneticLineElement(browser, hostElement);
+        this._horizontal.hide();
+        this._vertical.hide();
+    }
+    drawVerticalLine(x, size, transform) {
+        this._vertical.show();
+        this._vertical.render({
+            left: x * transform.scale + transform.position.x + transform.scaledPosition.x,
+            top: 0,
+            width: 1,
+            height: size.height,
+        });
+    }
+    drawHorizontalLine(y, size, transform) {
+        this._horizontal.show();
+        this._horizontal.render({
+            left: 0,
+            top: y * transform.scale + transform.position.y + transform.scaledPosition.y,
+            width: size.width,
+            height: 1,
+        });
+    }
+    hideVertical() {
+        this._vertical.hide();
+    }
+    hideHorizontal() {
+        this._horizontal.hide();
+    }
+    hideAll() {
+        this._vertical.hide();
+        this._horizontal.hide();
+    }
+    destroy() {
+        this._vertical.destroy();
+        this._horizontal.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+export * from './domain';
+export * from './magnetic-lines-preparation';
+export * from './magnetic-lines-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9tYWduZXRpYy1saW5lcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUV6QixjQUFjLDhCQUE4QixDQUFDO0FBRTdDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RvbWFpbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vbWFnbmV0aWMtbGluZXMtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL21hZ25ldGljLWxpbmVzLWhhbmRsZXInO1xuIl19

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

@@ -0,0 +1,2 @@
+export * from './magnetic-lines-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctbm9kZS9tYWduZXRpYy1saW5lcy9tYWduZXRpYy1saW5lcy1oYW5kbGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21hZ25ldGljLWxpbmVzLWhhbmRsZXInO1xuIl19

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

@@ -0,0 +1,55 @@
+import { FComponentsStore, INSTANCES } from '../../../../f-storage';
+import { calculateMagneticGuides } from '../domain';
+export class MagneticLinesHandler {
+    _renderer;
+    _size;
+    _rects;
+    _timerId = null;
+    _canvasTransform;
+    _alignThreshold = 10;
+    constructor(injector, _renderer, _size, _rects) {
+        this._renderer = _renderer;
+        this._size = _size;
+        this._rects = _rects;
+        const store = injector.get(FComponentsStore);
+        this._alignThreshold = store.instances.require(INSTANCES.MAGNETIC_LINES).threshold();
+        this._canvasTransform = store.transform;
+    }
+    scheduleRender(_draggedRect) {
+        if (this._timerId) {
+            clearTimeout(this._timerId);
+        }
+        this._timerId = setTimeout(() => this._renderGuides(this._computeGuides(_draggedRect)), 15);
+    }
+    _renderGuides(guides) {
+        this._renderVertical(guides);
+        this._renderHorizontal(guides);
+    }
+    _renderVertical(guides) {
+        if (guides.x.guide !== undefined) {
+            this._renderer.drawVerticalLine(guides.x.guide, this._size, this._canvasTransform);
+        }
+        else {
+            this._renderer.hideVertical();
+        }
+    }
+    _renderHorizontal(guides) {
+        if (guides.y.guide !== undefined) {
+            this._renderer.drawHorizontalLine(guides.y.guide, this._size, this._canvasTransform);
+        }
+        else {
+            this._renderer.hideHorizontal();
+        }
+    }
+    _computeGuides(_draggedRect) {
+        return calculateMagneticGuides(this._rects, _draggedRect, this._alignThreshold);
+    }
+    clearGuides() {
+        this._renderer.hideAll();
+        if (this._timerId) {
+            clearTimeout(this._timerId);
+            this._timerId = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,4 @@
+export class MagneticLinesPreparationRequest {
+    static fToken = Symbol('MagneticLinesPreparationRequest');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFnbmV0aWMtbGluZXMtcHJlcGFyYXRpb24tcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvZHJhZy1ub2RlL21hZ25ldGljLWxpbmVzL21hZ25ldGljLWxpbmVzLXByZXBhcmF0aW9uL21hZ25ldGljLWxpbmVzLXByZXBhcmF0aW9uLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLCtCQUErQjtJQUMxQyxNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIE1hZ25ldGljTGluZXNQcmVwYXJhdGlvblJlcXVlc3Qge1xuICBzdGF0aWMgcmVhZG9ubHkgZlRva2VuID0gU3ltYm9sKCdNYWduZXRpY0xpbmVzUHJlcGFyYXRpb25SZXF1ZXN0Jyk7XG59XG4iXX0=