@foblex/flow 17.0.9 → 17.1.1

package/f-draggable/connections/providers.d.ts

@@ -1,4 +1,3 @@
 import { CreateConnectionDragHandlerExecution, CreateConnectionFinalizeExecution, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationValidator, CreateConnectionPreparationExecution, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletValidator } from './create-connection';
 import { ReassignConnectionFinalizeExecution, ReassignConnectionPreparationExecution } from './reassign-connection';
-import { GetInputUnderPointerExecution, GetInputUnderPointerValidator } from './get-input-under-pointer';
-export declare const CONNECTIONS_PROVIDERS: (typeof ReassignConnectionFinalizeExecution | typeof ReassignConnectionPreparationExecution | typeof CreateConnectionPreparationExecution | typeof GetInputUnderPointerExecution | typeof GetInputUnderPointerValidator | typeof CreateConnectionFinalizeExecution | typeof CreateConnectionDragHandlerExecution | typeof CreateConnectionFromOutletPreparationExecution | typeof GetCanBeConnectedOutputByOutletExecution | typeof GetCanBeConnectedOutputByOutletValidator | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionFromOutputPreparationValidator)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof CreateConnectionFinalizeExecution | typeof CreateConnectionDragHandlerExecution | typeof CreateConnectionFromOutletPreparationExecution | typeof GetCanBeConnectedOutputByOutletExecution | typeof GetCanBeConnectedOutputByOutletValidator | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionFromOutputPreparationValidator | typeof CreateConnectionPreparationExecution | typeof ReassignConnectionFinalizeExecution | typeof ReassignConnectionPreparationExecution)[];

package/f-draggable/connections/reassign-connection/reassign-connection-finalize/reassign-connection-finalize.execution.d.ts

@@ -1,20 +1,20 @@
 import { ReassignConnectionFinalizeRequest } from './reassign-connection-finalize.request';
-import { FComponentsStore } from '../../../../f-storage';
-import { FDraggableDataContext } from '../../../f-draggable-data-context';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class ReassignConnectionFinalizeExecution implements IExecution<ReassignConnectionFinalizeRequest, void> {
-    private fComponentsStore;
-    private fDraggableDataContext;
-    private fMediator;
-    private get fDraggable();
-    private get dragHandler();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private get _fDraggable();
+    private get _fDragHandler();
     handle(request: ReassignConnectionFinalizeRequest): void;
-    private _isValid;
-    private emitEvent;
-    private getInputUnderPointer;
-    private isReassignToDifferentInput;
+    private _isDroppedConnectionReassignEvent;
+    private _applyReassignEvent;
+    private _getInputUnderPointer;
+    private _isReassignToDifferentInput;
+    private _emitReassignConnectionEvent;
+    private _getEventData;
+    private _getDragHandlerData;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionFinalizeExecution>;
 }

package/f-draggable/connections/reassign-connection/reassign-connection.drag-handler.d.ts

@@ -1,28 +1,32 @@
 import { IDraggableItem } from '../../i-draggable-item';
-import { IClosestInput } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
 import { FMediator } from '@foblex/mediator';
-import { IPoint, RoundedRect } from '@foblex/2d';
+import { IPoint } from '@foblex/2d';
 import { FComponentsStore } from '../../../f-storage';
-export declare class ReassignConnectionDragHandler implements IDraggableItem {
-    private fMediator;
-    private fComponentsStore;
-    fConnection: FConnectionBase;
-    toConnectorRect: RoundedRect;
-    private get fSnapConnection();
-    private fOutputWithRect;
-    private fInputWithRect;
-    private canBeConnectedInputs;
-    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, fConnection: FConnectionBase);
+import { ICreateReassignConnectionDragData } from '../i-create-reassign-connection-drag-data';
+export declare class ReassignConnectionDragHandler implements IDraggableItem<ICreateReassignConnectionDragData> {
+    private _fMediator;
+    private _fComponentsStore;
+    private _fConnection;
+    private readonly _toConnectorRect;
+    private get _fSnapConnection();
+    private _fOutputWithRect;
+    private _fInputWithRect;
+    private _canBeConnectedInputs;
+    private get _fOutput();
+    private get _fInput();
+    constructor(_fMediator: FMediator, _fComponentsStore: FComponentsStore, _fConnection: FConnectionBase);
     prepareDragSequence(): void;
+    private _getAndMarkCanBeConnectedInputs;
     private _initializeSnapConnection;
-    private getOutput;
-    private getInput;
     onPointerMove(difference: IPoint): void;
     private _drawConnection;
+    private _getLineToPointer;
     private _drawSnapConnection;
-    getClosetInput(difference: IPoint): IClosestInput | undefined;
+    private _getLineToClosestInput;
     private _findClosestInput;
     private _getClosestInputForSnapConnection;
     onPointerUp(): void;
+    getData(): ICreateReassignConnectionDragData;
+    getConnection(): FConnectionBase;
 }

package/f-draggable/domain/is-array-has-parent-node/is-array-has-parent-node.execution.d.ts

@@ -1,13 +1,10 @@
 import { IsArrayHasParentNodeRequest } from './is-array-has-parent-node.request';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class IsArrayHasParentNodeExecution implements IExecution<IsArrayHasParentNodeRequest, boolean> {
-    private fMediator;
-    constructor(fMediator: FMediator);
     handle(request: IsArrayHasParentNodeRequest): boolean;
-    private getParentNodeIds;
-    private getParentNodes;
-    private isParentNodeInArray;
+    private _getParentNodeIds;
+    private _isParentNodeInArray;
     static ɵfac: i0.ɵɵFactoryDeclaration<IsArrayHasParentNodeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<IsArrayHasParentNodeExecution>;
 }

package/f-draggable/domain/is-array-has-parent-node/is-array-has-parent-node.request.d.ts

@@ -1,6 +1,6 @@
 import { FNodeBase } from '../../../f-node';
 export declare class IsArrayHasParentNodeRequest {
-    fNode: FNodeBase;
-    fNodes: FNodeBase[];
-    constructor(fNode: FNodeBase, fNodes: FNodeBase[]);
+    fParentNodes: FNodeBase[];
+    fDraggedNodes: FNodeBase[];
+    constructor(fParentNodes: FNodeBase[], fDraggedNodes: FNodeBase[]);
 }

package/f-draggable/domain/is-connection-under-node/is-connection-under-node.execution.d.ts

@@ -5,13 +5,14 @@ export declare class IsConnectionUnderNodeExecution implements IExecution<IsConn
     private _fMediator;
     private _fComponentsStore;
     handle(request: IsConnectionUnderNodeRequest): void;
-    private _getNodeOutputConnectors;
-    private _getNodeInputConnectors;
+    private _getOutputConnectors;
+    private _getInputConnectors;
     private _getOutputConnectionsId;
     private _getInputConnectionsId;
     private _getConnectorsId;
     private _calculateConnectionsUnderNode;
     private _isConnectionHasIntersectionsWithNode;
+    private _emitNodeIntersectedWithConnections;
     static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionUnderNodeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionUnderNodeExecution>;
 }

package/f-draggable/domain/providers.d.ts

@@ -1,4 +1,4 @@
 import { IsArrayHasParentNodeExecution } from './is-array-has-parent-node';
 import { GetNormalizedParentNodeRectExecution } from './get-normalized-parent-node-rect';
 import { IsConnectionUnderNodeExecution } from './is-connection-under-node';
-export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof IsConnectionUnderNodeExecution | typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution)[];
+export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution | typeof IsConnectionUnderNodeExecution)[];

package/f-draggable/f-draggable-data-context.d.ts

@@ -1,6 +1,5 @@
 import { Point } from '@foblex/2d';
 import { IDraggableItem } from './i-draggable-item';
-import { FLineAlignmentBase } from '../f-line-alignment';
 import { ICanChangeSelection } from '../mixins';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
@@ -9,9 +8,9 @@ export declare class FDraggableDataContext {
     onPointerDownScale: number;
     onPointerDownPosition: Point;
     draggableItems: IDraggableItem[];
-    fLineAlignment: FLineAlignmentBase | undefined;
     reset(): void;
     markSelectionAsChanged(): void;
+    isEmpty(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDataContext, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FDraggableDataContext>;
 }

package/f-draggable/i-draggable-item.d.ts

@@ -1,6 +1,7 @@
 import { IPoint } from '@foblex/2d';
-export interface IDraggableItem {
+export interface IDraggableItem<TData = any> {
     prepareDragSequence?(): void;
     onPointerMove(difference: IPoint): void;
     onPointerUp?(): void;
+    getData?(): TData;
 }

package/f-draggable/node/connection-base-drag-handler.d.ts

@@ -1,24 +1,23 @@
 import { IDraggableItem } from '../i-draggable-item';
 import { FConnectionBase } from '../../f-connection';
 import { FMediator } from '@foblex/mediator';
-import { INodeMoveRestrictions } from './create-move-nodes-drag-model-from-selection';
-import { ILine, IPoint } from '@foblex/2d';
+import { ILine, IMinMaxPoint, IPoint } from '@foblex/2d';
 import { FComponentsStore } from '../../f-storage';
-import { IConnectorWithRect } from '../../domain';
+import { IConnectorAndRect } from '../../domain';
 import * as i0 from "@angular/core";
 export declare abstract class ConnectionBaseDragHandler implements IDraggableItem {
     protected fMediator: FMediator;
     protected fComponentsStore: FComponentsStore;
     connection: FConnectionBase;
-    protected fOutputWithRect: IConnectorWithRect;
-    protected fInputWithRect: IConnectorWithRect;
+    protected fOutputWithRect: IConnectorAndRect;
+    protected fInputWithRect: IConnectorAndRect;
     protected constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase);
     prepareDragSequence(): void;
     private getOutput;
     private getInput;
     private connectorNotFoundPrefix;
     abstract onPointerMove(difference: IPoint): void;
-    protected getRestrictedDifference(difference: IPoint, restrictions: INodeMoveRestrictions): IPoint;
+    protected getRestrictedDifference(difference: IPoint, restrictions: IMinMaxPoint): IPoint;
     protected redrawConnection(line: ILine): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBaseDragHandler, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectionBaseDragHandler, never, never, {}, {}, never, never, false, never>;

package/f-draggable/node/connection-source.drag-handler.d.ts

@@ -1,12 +1,11 @@
-import { IPoint } from '@foblex/2d';
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
 import { FConnectionBase } from '../../f-connection';
 import { FMediator } from '@foblex/mediator';
 import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
 import { FComponentsStore } from '../../f-storage';
 export declare class ConnectionSourceDragHandler extends ConnectionBaseDragHandler {
-    minDistance: IPoint;
-    maxDistance: IPoint;
-    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
+    restrictions: IMinMaxPoint;
+    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

package/f-draggable/node/connection-target.drag-handler.d.ts

@@ -1,12 +1,11 @@
-import { IPoint } from '@foblex/2d';
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
 import { FConnectionBase } from '../../f-connection';
 import { FMediator } from '@foblex/mediator';
 import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
 import { FComponentsStore } from '../../f-storage';
 export declare class ConnectionTargetDragHandler extends ConnectionBaseDragHandler {
-    minDistance: IPoint;
-    maxDistance: IPoint;
-    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
+    restrictions: IMinMaxPoint;
+    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

package/f-draggable/node/connection.drag-handler.d.ts

@@ -1,4 +1,4 @@
-import { IPoint } from '@foblex/2d';
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
 import { FConnectionBase } from '../../f-connection';
 import { FMediator } from '@foblex/mediator';
 import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
@@ -7,8 +7,8 @@ export declare class ConnectionDragHandler extends ConnectionBaseDragHandler {
     private sourceRestrictions;
     private targetRestrictions;
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase);
-    setOutputRestrictions(min: IPoint, max: IPoint): void;
-    setInputRestrictions(min: IPoint, max: IPoint): void;
+    setOutputRestrictions(restrictions: IMinMaxPoint): void;
+    setInputRestrictions(restrictions: IMinMaxPoint): void;
     onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/create-move-nodes-drag-model-from-selection.execution.d.ts

@@ -7,12 +7,15 @@ export declare class CreateMoveNodesDragModelFromSelectionExecution implements I
     private _fComponentsStore;
     private _fDraggableDataContext;
     handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[];
-    private _getSelectedNodes;
+    private _getDraggedNodes;
     private _getNodesFromSelection;
     private _findNode;
     private _getNodesWithRestrictions;
-    private getChildrenItemsToDrag;
-    private getChildrenNodes;
+    private _getNodeMoveRestrictions;
+    private _isParentNodeInArray;
+    private _getChildrenItemsToDrag;
+    private _getChildrenNodes;
+    private _applyCommonRestrictions;
     private getAllOutputIds;
     private getOutputsForNode;
     private getAllInputIds;

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/calculate-common-node-move-restrictions/calculate-common-node-move-restrictions.execution.d.ts

@@ -0,0 +1,13 @@
+import { CalculateCommonNodeMoveRestrictionsRequest } from './calculate-common-node-move-restrictions.request';
+import { IMinMaxPoint } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateCommonNodeMoveRestrictionsExecution implements IExecution<CalculateCommonNodeMoveRestrictionsRequest, IMinMaxPoint> {
+    handle(request: CalculateCommonNodeMoveRestrictionsRequest): IMinMaxPoint;
+    private _calculateCommonRestrictions;
+    private _clampRestrictions;
+    private _clampMinRestrictions;
+    private _clampMaxRestrictions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateCommonNodeMoveRestrictionsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateCommonNodeMoveRestrictionsExecution>;
+}

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/calculate-common-node-move-restrictions/calculate-common-node-move-restrictions.request.d.ts

@@ -0,0 +1,5 @@
+import { INodeWithDistanceRestrictions } from '../../i-node-with-distance-restrictions';
+export declare class CalculateCommonNodeMoveRestrictionsRequest {
+    restrictions: INodeWithDistanceRestrictions[];
+    constructor(restrictions: INodeWithDistanceRestrictions[]);
+}

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/calculate-common-node-move-restrictions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-common-node-move-restrictions.execution';
+export * from './calculate-common-node-move-restrictions.request';

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/calculate-node-move-restrictions/calculate-node-move-restrictions.execution.d.ts

@@ -0,0 +1,12 @@
+import { CalculateNodeMoveRestrictionsRequest } from './calculate-node-move-restrictions.request';
+import { IMinMaxPoint } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateNodeMoveRestrictionsExecution implements IExecution<CalculateNodeMoveRestrictionsRequest, IMinMaxPoint> {
+    private _fMediator;
+    handle(request: CalculateNodeMoveRestrictionsRequest): IMinMaxPoint;
+    private _getNodeRect;
+    private _getParentNodeRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodeMoveRestrictionsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodeMoveRestrictionsExecution>;
+}

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/{get-node-move-restrictions/get-node-move-restrictions.request.d.ts → calculate-node-move-restrictions/calculate-node-move-restrictions.request.d.ts}

@@ -1,5 +1,5 @@
 import { FNodeBase } from '../../../../../f-node';
-export declare class GetNodeMoveRestrictionsRequest {
+export declare class CalculateNodeMoveRestrictionsRequest {
     fNode: FNodeBase;
     hasParentNodeInSelected: boolean;
     constructor(fNode: FNodeBase, hasParentNodeInSelected: boolean);

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/calculate-node-move-restrictions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-node-move-restrictions.execution';
+export * from './calculate-node-move-restrictions.request';

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.execution.d.ts

@@ -1,14 +1,12 @@
 import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';
-import { FComponentsStore } from '../../../../../f-storage';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import { FNodeBase } from '../../../../../f-node';
 import { FConnectionBase } from '../../../../../f-connection';
 import * as i0 from "@angular/core";
 export declare class PutInputConnectionHandlersToArrayExecution implements IExecution<PutInputConnectionHandlersToArrayRequest, void> {
-    private fComponentsStore;
-    private fMediator;
-    private get fConnections();
-    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator);
+    private _fMediator;
+    private _fComponentsStore;
+    private get _fConnections();
     handle(request: PutInputConnectionHandlersToArrayRequest): void;
     getInputConnections(node: FNodeBase): FConnectionBase[];
     private getInputsForNode;

package/f-draggable/node/create-move-nodes-drag-model-from-selection/i-node-with-distance-restrictions.d.ts

@@ -1,6 +1,6 @@
 import { FNodeBase } from '../../../f-node';
-import { INodeMoveRestrictions } from './domain/get-node-move-restrictions';
-export interface INodeWithDistanceRestrictions extends INodeMoveRestrictions {
-    node: FNodeBase;
-    parentNodes?: FNodeBase[];
+import { IMinMaxPoint } from '@foblex/2d';
+export interface INodeWithDistanceRestrictions extends IMinMaxPoint {
+    fDraggedNode: FNodeBase;
+    fParentNodes?: FNodeBase[];
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/index.d.ts

@@ -1,6 +1,7 @@
+export * from './domain/calculate-common-node-move-restrictions';
 export * from './domain/put-input-connection-handlers-to-array';
 export * from './domain/put-output-connection-handlers-to-array';
-export * from './domain/get-node-move-restrictions';
+export * from './domain/calculate-node-move-restrictions';
 export * from './providers';
 export * from './create-move-nodes-drag-model-from-selection.execution';
 export * from './create-move-nodes-drag-model-from-selection.request';

package/f-draggable/node/create-move-nodes-drag-model-from-selection/providers.d.ts

@@ -1,5 +1,6 @@
 import { CreateMoveNodesDragModelFromSelectionExecution } from './create-move-nodes-drag-model-from-selection.execution';
-import { GetNodeMoveRestrictionsExecution } from './domain/get-node-move-restrictions';
+import { CalculateNodeMoveRestrictionsExecution } from './domain/calculate-node-move-restrictions';
 import { PutInputConnectionHandlersToArrayExecution } from './domain/put-input-connection-handlers-to-array';
 import { PutOutputConnectionHandlersToArrayExecution } from './domain/put-output-connection-handlers-to-array';
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof GetNodeMoveRestrictionsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];
+import { CalculateCommonNodeMoveRestrictionsExecution } from './domain/calculate-common-node-move-restrictions';
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateCommonNodeMoveRestrictionsExecution | typeof CalculateNodeMoveRestrictionsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];

package/f-draggable/node/index.d.ts

@@ -1,4 +1,5 @@
 export * from './create-move-nodes-drag-model-from-selection';
+export * from './line-alignment-preparation';
 export * from './node-drag-to-parent-finalize';
 export * from './node-drag-to-parent-preparation';
 export * from './node-move-preparation';
@@ -8,6 +9,7 @@ export * from './connection-base-drag-handler';
 export * from './connection-source.drag-handler';
 export * from './connection-target.drag-handler';
 export * from './f-drop-to-group.event';
+export * from './line-alignment.drag-handler';
 export * from './node.drag-handler';
 export * from './node-drag-to-parent.drag-handler';
 export * from './node-resize-by-child.drag-handler';

package/f-draggable/node/line-alignment-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './line-alignment-preparation.execution';
+export * from './line-alignment-preparation.request';

package/f-draggable/node/line-alignment-preparation/line-alignment-preparation.execution.d.ts

@@ -0,0 +1,21 @@
+import { LineAlignmentPreparationRequest } from './line-alignment-preparation.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class LineAlignmentPreparationExecution implements IExecution<LineAlignmentPreparationRequest, void> {
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private _fBrowser;
+    private _lineService;
+    handle(request: LineAlignmentPreparationRequest): void;
+    private _getDraggedNodes;
+    private _addLineAlignmentDragHandler;
+    private _getFlowHostSize;
+    private _createLineService;
+    private _getDraggedNodesBoundingRect;
+    private _getStaticNodeRects;
+    private _getStaticNodes;
+    private _getCommonRestrictions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineAlignmentPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LineAlignmentPreparationExecution>;
+}

package/f-draggable/node/line-alignment-preparation/line-alignment-preparation.request.d.ts

@@ -0,0 +1,2 @@
+export declare class LineAlignmentPreparationRequest {
+}

package/f-draggable/node/line-alignment.drag-handler.d.ts

@@ -0,0 +1,20 @@
+import { IMinMaxPoint, IPoint, IRect, ISize } from '@foblex/2d';
+import { IDraggableItem } from '../index';
+import { FComponentsStore } from '../../f-storage';
+import { ILineAlignmentResult, LineService } from '../../f-line-alignment';
+export declare class LineAlignmentDragHandler implements IDraggableItem {
+    private _fComponentsStore;
+    private _lineService;
+    private _size;
+    private _draggedNodeRect;
+    private _rects;
+    private _restrictions;
+    private _debounceTimer;
+    private readonly _transform;
+    constructor(_fComponentsStore: FComponentsStore, _lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
+    onPointerMove(difference: IPoint): void;
+    private _drawIntersectingLines;
+    private _getDifference;
+    findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
+    onPointerUp(): void;
+}

package/f-draggable/node/node-move-preparation/index.d.ts

@@ -1,4 +1,3 @@
 export * from './providers';
 export * from './node-move-preparation.execution';
 export * from './node-move-preparation.request';
-export * from './node-move-preparation.validator';

package/f-draggable/node/node-move-preparation/node-move-preparation.execution.d.ts

@@ -7,12 +7,13 @@ export declare class NodeMovePreparationExecution implements IExecution<NodeMove
     private _fDraggableDataContext;
     private get _transform();
     private get _fHost();
+    private _fNode;
     handle(request: NodeMovePreparationRequest): void;
+    private _isValid;
+    private _isDragHandleElement;
     private _getNode;
-    private _calculateDraggableItems;
+    private _calculateDraggedItems;
     private _dragModelFromSelection;
-    private _initializeLineAlignment;
-    private _filterNodesFromDraggableItems;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeMovePreparationExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeMovePreparationExecution>;
 }

package/f-draggable/node/node-move-preparation/providers.d.ts

@@ -1,3 +1,2 @@
 import { NodeMovePreparationExecution } from './node-move-preparation.execution';
-import { NodeMovePreparationValidator } from './node-move-preparation.validator';
-export declare const NODE_MOVE_PREPARATION_PROVIDERS: (typeof NodeMovePreparationExecution | typeof NodeMovePreparationValidator)[];
+export declare const NODE_MOVE_PREPARATION_PROVIDERS: (typeof NodeMovePreparationExecution)[];

package/f-draggable/node/node.drag-handler.d.ts

@@ -1,16 +1,13 @@
-import { IPoint } from '@foblex/2d';
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
 import { IDraggableItem } from '../i-draggable-item';
-import { FDraggableDataContext } from '../f-draggable-data-context';
 import { FNodeBase } from '../../f-node';
 import { FComponentsStore } from '../../f-storage';
 export declare class NodeDragHandler implements IDraggableItem {
-    private fDraggableDataContext;
-    private fComponentsStore;
+    private _fComponentsStore;
     fNode: FNodeBase;
-    minDistance: IPoint;
-    maxDistance: IPoint;
+    restrictions: IMinMaxPoint;
     private readonly _onPointerDownPosition;
-    constructor(fDraggableDataContext: FDraggableDataContext, fComponentsStore: FComponentsStore, fNode: FNodeBase, minDistance: IPoint, maxDistance: IPoint);
+    constructor(_fComponentsStore: FComponentsStore, fNode: FNodeBase, restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private _getPosition;
     private _getDifference;

package/f-draggable/node/providers.d.ts

@@ -1,2 +1,3 @@
 import { NodeMoveFinalizeExecution } from './node-move-finalize';
-export declare const NODE_PROVIDERS: (typeof NodeMoveFinalizeExecution | typeof import("./create-move-nodes-drag-model-from-selection").GetNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-move-preparation").NodeMovePreparationValidator | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationValidator | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution)[];
+import { LineAlignmentPreparationExecution } from './line-alignment-preparation';
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof LineAlignmentPreparationExecution | typeof NodeMoveFinalizeExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationValidator | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution)[];

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentPreparationValidator | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./single-select").SingleSelectExecution | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node").CalculateCommonNodeMoveRestrictionsExecution | typeof import("./node").CalculateNodeMoveRestrictionsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").LineAlignmentPreparationExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentPreparationValidator | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];

package/f-line-alignment/f-line-alignment-base.d.ts

@@ -1,16 +1,10 @@
-import { IPoint } from '@foblex/2d';
 import { InjectionToken } from '@angular/core';
-import { ILineAlignmentResult } from './domain';
-import { FNodeBase } from '../f-node';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_LINE_ALIGNMENT: InjectionToken<FLineAlignmentBase>;
 export declare abstract class FLineAlignmentBase implements IHasHostElement {
-    abstract hostElement: HTMLElement | SVGElement;
-    abstract initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
-    abstract findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
-    abstract handle(difference: IPoint): void;
-    abstract complete(): void;
+    abstract hostElement: HTMLElement;
+    abstract fAlignThreshold: number;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-line-alignment/f-line-alignment.component.d.ts

@@ -1,32 +1,13 @@
-import { AfterViewInit, ElementRef } from '@angular/core';
-import { IPoint } from '@foblex/2d';
-import { ILineAlignmentResult } from './domain';
+import { OnDestroy, OnInit } from '@angular/core';
 import { FLineAlignmentBase } from './f-line-alignment-base';
-import { FDraggableDataContext } from '../f-draggable';
-import { FNodeBase } from '../f-node';
-import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
-export declare class FLineAlignmentComponent extends FLineAlignmentBase implements AfterViewInit {
-    private elementReference;
-    private fDraggableDataContext;
-    private DEBOUNCE_TIME;
+export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit, OnDestroy {
     fAlignThreshold: number;
-    get hostElement(): HTMLElement;
-    private lineService;
-    private size;
-    private draggedNodeRect;
-    private rects;
     private _fMediator;
-    private _fCanvas;
-    private _debounceTimer;
-    private get _transform();
-    constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext, fBrowser: BrowserService);
-    ngAfterViewInit(): void;
-    initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
-    handle(difference: IPoint): void;
-    private drawIntersectingLines;
-    findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
-    complete(): void;
+    private _elementReference;
+    get hostElement(): HTMLElement;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "fAlignThreshold": { "alias": "fAlignThreshold"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-minimap/providers.d.ts

@@ -2,4 +2,4 @@ import { FMinimapComponent } from './f-minimap.component';
 import { FMinimapViewDirective } from './f-minimap-view.directive';
 import { FMinimapFlowDirective } from './f-minimap-flow.directive';
 import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
-export declare const F_MINIMAP_PROVIDERS: (typeof FMinimapFlowDirective | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapComponent)[];
+export declare const F_MINIMAP_PROVIDERS: (typeof FMinimapComponent | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapFlowDirective)[];