@foblex/flow 17.1.1 → 17.2.0

package/f-draggable/f-draggable.directive.d.ts

@@ -3,6 +3,7 @@ import { FDraggableBase } from './f-draggable-base';
 import { FDropToGroupEvent } from './node';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import { FSelectionChangeEvent } from './f-selection-change-event';
+import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
 import { BrowserService } from '@foblex/platform';
 import { ICanRunOutsideAngular, IPointerEvent } from '@foblex/drag-toolkit';
@@ -12,17 +13,25 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     private _fBrowser;
     private _elementReference;
     private _fMediator;
+    private _fPlatform;
+    private _injector;
     disabled: boolean;
     get hostElement(): HTMLElement;
+    fMultiSelectTrigger: FEventTrigger;
+    fReassignConnectionTrigger: FEventTrigger;
+    fCreateConnectionTrigger: FEventTrigger;
     fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
-    emitWhenNodeIntersectedWithConnection: boolean;
+    fEmitOnNodeIntersect: boolean;
     fCreateNode: EventEmitter<FCreateNodeEvent<any>>;
     fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     fDropToGroup: EventEmitter<FDropToGroupEvent>;
     vCellSize: number;
     hCellSize: number;
+    fCellSizeWhileDragging: boolean;
+    fDragStarted: EventEmitter<void>;
+    fDragEnded: EventEmitter<void>;
     private plugins;
     constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
     ngOnInit(): void;
@@ -35,6 +44,10 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "emitWhenNodeIntersectedWithConnection": { "alias": "emitWhenNodeIntersectedWithConnection"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; }, ["plugins"], never, false, never>;
-    static ngAcceptInputType_emitWhenNodeIntersectedWithConnection: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["plugins"], never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_fEmitOnNodeIntersect: unknown;
+    static ngAcceptInputType_vCellSize: unknown;
+    static ngAcceptInputType_hCellSize: unknown;
+    static ngAcceptInputType_fCellSizeWhileDragging: unknown;
 }

package/f-draggable/f-injector.d.ts

@@ -0,0 +1,8 @@
+import { Injector, Type } from "@angular/core";
+export declare class FInjector {
+    private static _injector;
+    static set(injector: Injector): void;
+    static clear(): void;
+    static get(): Injector;
+}
+export declare function fInject<T>(token: Type<T>): T;

package/f-draggable/index.d.ts

@@ -8,6 +8,7 @@ export * from './single-select';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';
+export * from './f-injector';
 export * from './f-selection-change-event';
 export * from './i-f-drag-and-drop-plugin';
 export * from './i-draggable-item';

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

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection';
+export declare class BaseConnectionDragHandler {
+    fConnection: FConnectionBase;
+    private _fMediator;
+    private _fComponentStore;
+    private _fOutputWithRect;
+    private _fInputWithRect;
+    private get _fOutput();
+    private get _fInput();
+    private _sourceDifference;
+    private _targetDifference;
+    constructor(fConnection: FConnectionBase);
+    private _initialize;
+    setSourceDifference(difference: IPoint): void;
+    setTargetDifference(difference: IPoint): void;
+    protected redraw(): void;
+    private _recalculateConnection;
+    private _redrawConnection;
+    private _connectorNotFoundPrefix;
+}

package/f-draggable/node/connection-drag-handlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base-connection.drag-handler';
+export * from './source-connection.drag-handler';
+export * from './source-target-connection.drag-handler';
+export * from './target-connection.drag-handler';

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

@@ -0,0 +1,7 @@
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { FConnectionBase } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+export declare class SourceConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection: FConnectionBase);
+    setSourceDifference(difference: IPoint): void;
+}

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

@@ -0,0 +1,10 @@
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { FConnectionBase } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+export declare class SourceTargetConnectionDragHandler extends BaseConnectionDragHandler {
+    private _callTracker;
+    constructor(fConnection: FConnectionBase);
+    setSourceDifference(difference: IPoint): void;
+    setTargetDifference(difference: IPoint): void;
+    private _checkAndTriggerAction;
+}

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

@@ -0,0 +1,7 @@
+import { FConnectionBase } from '../../../f-connection';
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { IPoint } from '@foblex/2d';
+export declare class TargetConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection: FConnectionBase);
+    setTargetDifference(difference: IPoint): void;
+}

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

@@ -1,27 +1,28 @@
 import { CreateMoveNodesDragModelFromSelectionRequest } from './create-move-nodes-drag-model-from-selection.request';
 import { IExecution } from '@foblex/mediator';
-import { IDraggableItem } from '../../i-draggable-item';
+import { SummaryNodeDragHandler } from '../summary-node.drag-handler';
 import * as i0 from "@angular/core";
-export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, IDraggableItem[]> {
+export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, SummaryNodeDragHandler> {
     private _fMediator;
     private _fComponentsStore;
     private _fDraggableDataContext;
-    handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[];
+    handle(request: CreateMoveNodesDragModelFromSelectionRequest): SummaryNodeDragHandler;
     private _getDraggedNodes;
     private _getNodesFromSelection;
     private _findNode;
-    private _getNodesWithRestrictions;
-    private _getNodeMoveRestrictions;
+    private _getNodesToDragWithCommonLimits;
+    private _getNodesMoveLimits;
+    private _getNodeMoveLimits;
     private _isParentNodeInArray;
-    private _getChildrenItemsToDrag;
     private _getChildrenNodes;
-    private _applyCommonRestrictions;
-    private getAllOutputIds;
-    private getOutputsForNode;
-    private getAllInputIds;
-    private getInputsForNode;
-    private getDragHandlersFromNodes;
-    private getDragHandlersWithConnections;
+    private _calculateCommonLimits;
+    private _getAllOutputIds;
+    private _getNodeOutputIds;
+    private _getAllInputIds;
+    private _getNodeInputIds;
+    private _mapToNodeDragHandlers;
+    private _setConnectionsHandlersToNodes;
+    private _getDraggedNodesBoundingRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<CreateMoveNodesDragModelFromSelectionExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CreateMoveNodesDragModelFromSelectionExecution>;
 }

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

@@ -0,0 +1,19 @@
+import { CalculateCommonNodeMoveLimitsRequest } from './calculate-common-node-move-limits.request';
+import { IExecution } from '@foblex/mediator';
+import { INodeMoveLimits } from '../../i-node-move-limits';
+import * as i0 from "@angular/core";
+export declare class CalculateCommonNodeMoveLimitsExecution implements IExecution<CalculateCommonNodeMoveLimitsRequest, INodeMoveLimits> {
+    private _fComponentsStore;
+    private get _vCellSize();
+    private get _hCellSize();
+    handle(request: CalculateCommonNodeMoveLimitsRequest): INodeMoveLimits;
+    private _calculateCommonLimits;
+    private _clampRestrictions;
+    private _clampMinRestrictions;
+    private _clampMaxRestrictions;
+    private _snapLimitToGrid;
+    private _snapLimitToGridMinimum;
+    private _snapLimitToGridMaximum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateCommonNodeMoveLimitsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateCommonNodeMoveLimitsExecution>;
+}

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

@@ -0,0 +1,5 @@
+import { INodeMoveLimitsAndPosition } from '../../i-node-move-limits-and-position';
+export declare class CalculateCommonNodeMoveLimitsRequest {
+    limits: INodeMoveLimitsAndPosition[];
+    constructor(limits: INodeMoveLimitsAndPosition[]);
+}

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

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

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

@@ -0,0 +1,15 @@
+import { CalculateNodeMoveLimitsRequest } from './calculate-node-move-limits.request';
+import { IExecution } from '@foblex/mediator';
+import { INodeMoveLimits } from '../../i-node-move-limits';
+import * as i0 from "@angular/core";
+export declare class CalculateNodeMoveLimitsExecution implements IExecution<CalculateNodeMoveLimitsRequest, INodeMoveLimits> {
+    private _fMediator;
+    handle(request: CalculateNodeMoveLimitsRequest): INodeMoveLimits;
+    private _fNodeRect;
+    private _fParentRect;
+    private _calculateDifference;
+    private _calculateMinimumDifference;
+    private _calculateMaximumDifference;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodeMoveLimitsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodeMoveLimitsExecution>;
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './calculate-node-move-limits.execution';
+export * from './calculate-node-move-limits.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,20 +1,15 @@
 import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';
 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 _fMediator;
     private _fComponentsStore;
     private get _fConnections();
     handle(request: PutInputConnectionHandlersToArrayRequest): void;
-    getInputConnections(node: FNodeBase): FConnectionBase[];
-    private getInputsForNode;
-    private getExistingConnectionHandlerIndex;
-    private createNewConnectionHandler;
-    private getNewConnectionHandler;
-    private updateExistingConnectionHandler;
-    private getNewSourceConnectionHandler;
+    private _getInputConnections;
+    private _getNodeInputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<PutInputConnectionHandlersToArrayExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PutInputConnectionHandlersToArrayExecution>;
 }

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

@@ -1,8 +1,8 @@
 import { NodeDragHandler } from '../../../node.drag-handler';
-import { IDraggableItem } from '../../../../i-draggable-item';
+import { BaseConnectionDragHandler } from '../../../connection-drag-handlers/base-connection.drag-handler';
 export declare class PutInputConnectionHandlersToArrayRequest {
-    nodeDragHandler: NodeDragHandler;
+    fDragHandler: NodeDragHandler;
     outputIds: string[];
-    result: IDraggableItem[];
-    constructor(nodeDragHandler: NodeDragHandler, outputIds: string[], result: IDraggableItem[]);
+    result: BaseConnectionDragHandler[];
+    constructor(fDragHandler: NodeDragHandler, outputIds: string[], result: BaseConnectionDragHandler[]);
 }

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

@@ -1,22 +1,17 @@
 import { PutOutputConnectionHandlersToArrayRequest } from './put-output-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 PutOutputConnectionHandlersToArrayExecution implements IExecution<PutOutputConnectionHandlersToArrayRequest, void> {
-    private fComponentsStore;
-    private fMediator;
-    private get fConnections();
-    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator);
+    private _fComponentsStore;
+    private get _fConnections();
     handle(request: PutOutputConnectionHandlersToArrayRequest): void;
-    getOutputConnections(node: FNodeBase): FConnectionBase[];
-    private getOutputsForNode;
-    private getExistingConnectionHandlerIndex;
-    private createNewConnectionHandler;
-    private getNewConnectionHandler;
-    private updateExistingConnectionHandler;
-    private getNewSourceConnectionHandler;
+    _getOutputConnections(node: FNodeBase): FConnectionBase[];
+    private _getNodeOutputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<PutOutputConnectionHandlersToArrayExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PutOutputConnectionHandlersToArrayExecution>;
 }

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

@@ -1,8 +1,8 @@
 import { NodeDragHandler } from '../../../node.drag-handler';
-import { IDraggableItem } from '../../../../i-draggable-item';
+import { BaseConnectionDragHandler } from '../../../connection-drag-handlers/base-connection.drag-handler';
 export declare class PutOutputConnectionHandlersToArrayRequest {
-    nodeDragHandler: NodeDragHandler;
+    fDragHandler: NodeDragHandler;
     inputIds: string[];
-    result: IDraggableItem[];
-    constructor(nodeDragHandler: NodeDragHandler, inputIds: string[], result: IDraggableItem[]);
+    result: BaseConnectionDragHandler[];
+    constructor(fDragHandler: NodeDragHandler, inputIds: string[], result: BaseConnectionDragHandler[]);
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/i-node-move-limits-and-position.d.ts

@@ -0,0 +1,5 @@
+import { IPoint } from '@foblex/2d';
+import { INodeMoveLimits } from './i-node-move-limits';
+export interface INodeMoveLimitsAndPosition extends INodeMoveLimits {
+    position: IPoint;
+}

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

@@ -0,0 +1,3 @@
+import { IMinMaxPoint } from '@foblex/2d';
+export interface INodeMoveLimits extends IMinMaxPoint {
+}

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

@@ -1,8 +1,9 @@
-export * from './domain/calculate-common-node-move-restrictions';
+export * from './domain/calculate-common-node-move-limits';
 export * from './domain/put-input-connection-handlers-to-array';
 export * from './domain/put-output-connection-handlers-to-array';
-export * from './domain/calculate-node-move-restrictions';
+export * from './domain/calculate-node-move-limits';
 export * from './providers';
 export * from './create-move-nodes-drag-model-from-selection.execution';
 export * from './create-move-nodes-drag-model-from-selection.request';
-export * from './i-node-with-distance-restrictions';
+export * from './i-node-move-limits';
+export * from './i-node-move-limits-and-position';

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

@@ -1,6 +1,6 @@
 import { CreateMoveNodesDragModelFromSelectionExecution } from './create-move-nodes-drag-model-from-selection.execution';
-import { CalculateNodeMoveRestrictionsExecution } from './domain/calculate-node-move-restrictions';
+import { CalculateNodeMoveLimitsExecution } from './domain/calculate-node-move-limits';
 import { PutInputConnectionHandlersToArrayExecution } from './domain/put-input-connection-handlers-to-array';
 import { PutOutputConnectionHandlersToArrayExecution } from './domain/put-output-connection-handlers-to-array';
-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)[];
+import { CalculateCommonNodeMoveLimitsExecution } from './domain/calculate-common-node-move-limits';
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateCommonNodeMoveLimitsExecution | typeof CalculateNodeMoveLimitsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];

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

@@ -1,16 +1,14 @@
+export * from './connection-drag-handlers';
 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';
 export * from './node-move-finalize';
-export * from './connection.drag-handler';
-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';
+export * from './point-bounds-limiter';
 export * from './providers';
+export * from './summary-node.drag-handler';

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

@@ -8,11 +8,9 @@ export declare class LineAlignmentPreparationExecution implements IExecution<Lin
     private _fBrowser;
     private _lineService;
     handle(request: LineAlignmentPreparationRequest): void;
-    private _getDraggedNodes;
     private _addLineAlignmentDragHandler;
     private _getFlowHostSize;
     private _createLineService;
-    private _getDraggedNodesBoundingRect;
     private _getStaticNodeRects;
     private _getStaticNodes;
     private _getCommonRestrictions;

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

@@ -1,2 +1,7 @@
+import { IRect } from '@foblex/2d';
+import { FNodeBase } from '../../../f-node';
 export declare class LineAlignmentPreparationRequest {
+    fNodes: FNodeBase[];
+    commonRect: IRect;
+    constructor(fNodes: FNodeBase[], commonRect: IRect);
 }

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

@@ -1,17 +1,16 @@
 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 _fComponentsStore;
     private _debounceTimer;
     private readonly _transform;
-    constructor(_fComponentsStore: FComponentsStore, _lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
+    constructor(_lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private _drawIntersectingLines;
     private _getDifference;

package/f-draggable/node/node-drag-to-parent-preparation/index.d.ts

@@ -1,4 +1,2 @@
-export * from './providers';
 export * from './node-drag-to-parent-preparation.execution';
 export * from './node-drag-to-parent-preparation.request';
-export * from './node-drag-to-parent-preparation.validator';

package/f-draggable/node/node-drag-to-parent-preparation/node-drag-to-parent-preparation.execution.d.ts

@@ -12,6 +12,7 @@ export declare class NodeDragToParentPreparationExecution implements IExecution<
     private get fCanvasPosition();
     constructor(fMediator: FMediator, fDraggableDataContext: FDraggableDataContext, fComponentsStore: FComponentsStore);
     handle(request: NodeDragToParentPreparationRequest): void;
+    private _isValid;
     private _getNotDraggedNodesRects;
     private _getNodesBeingDragged;
     private _addParentNodes;

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

@@ -15,6 +15,8 @@ export declare class NodeMoveFinalizeExecution implements IExecution<NodeMoveFin
     private _getLineAlignmentDifference;
     private _applyLineAlignmentDifference;
     private _applyConnectionUnderDroppedNode;
+    private _isDraggedJustOneNode;
+    private _getFirstNodeOrGroup;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeMoveFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeMoveFinalizeExecution>;
 }

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

@@ -1,18 +1,15 @@
-import { IMinMaxPoint, IPoint } from '@foblex/2d';
+import { IPoint } from '@foblex/2d';
 import { IDraggableItem } from '../i-draggable-item';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { BaseConnectionDragHandler } from './connection-drag-handlers';
 export declare class NodeDragHandler implements IDraggableItem {
-    private _fComponentsStore;
     fNode: FNodeBase;
-    restrictions: IMinMaxPoint;
+    fSourceHandlers: BaseConnectionDragHandler[];
+    fTargetHandlers: BaseConnectionDragHandler[];
     private readonly _onPointerDownPosition;
-    constructor(_fComponentsStore: FComponentsStore, fNode: FNodeBase, restrictions: IMinMaxPoint);
+    constructor(fNode: FNodeBase, fSourceHandlers?: BaseConnectionDragHandler[], fTargetHandlers?: BaseConnectionDragHandler[]);
     onPointerMove(difference: IPoint): void;
-    private _getPosition;
-    private _getDifference;
+    private _calculateNewPosition;
     private _redraw;
     onPointerUp(): void;
-    getDifferenceWithCellSize(difference: IPoint): IPoint;
-    private _applyCellSize;
 }

package/f-draggable/node/point-bounds-limiter.d.ts

@@ -0,0 +1,15 @@
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
+export declare class PointBoundsLimiter {
+    private _onPointerDown;
+    private readonly _limit;
+    private _fComponentsStore;
+    private _vCellSize;
+    private _hCellSize;
+    constructor(_onPointerDown: IPoint, _limit: IMinMaxPoint);
+    limit(difference: IPoint, adjustCellSize: boolean): IPoint;
+    private _cellSizeStrategies;
+    private _applyCellSize;
+    private _skipCellSize;
+    private _clamp;
+    private _snapToGrid;
+}

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

@@ -1,3 +1,4 @@
 import { NodeMoveFinalizeExecution } from './node-move-finalize';
+import { NodeDragToParentPreparationExecution } from './node-drag-to-parent-preparation';
 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)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveLimitsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateNodeMoveLimitsExecution | 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 NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution)[];

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

@@ -0,0 +1,14 @@
+import { IMinMaxPoint, IPoint, IRect } from '@foblex/2d';
+import { IDraggableItem } from '../i-draggable-item';
+import { NodeDragHandler } from './node.drag-handler';
+export declare class SummaryNodeDragHandler implements IDraggableItem {
+    limits: IMinMaxPoint;
+    fHandlers: NodeDragHandler[];
+    commonRect: IRect;
+    private _fComponentStore;
+    private readonly _fBoundsLimiter;
+    constructor(limits: IMinMaxPoint, fHandlers: NodeDragHandler[], commonRect: IRect);
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    calculateRestrictedDifference(difference: IPoint): IPoint;
+}

package/f-draggable/node-resize/apply-child-resize-restrictions/apply-child-resize-restrictions.execution.d.ts

@@ -3,11 +3,11 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class ApplyChildResizeRestrictionsExecution implements IExecution<ApplyChildResizeRestrictionsRequest, void> {
     handle(request: ApplyChildResizeRestrictionsRequest): void;
-    private applyRestrictions;
-    private left;
-    private top;
-    private right;
-    private bottom;
+    private _apply;
+    private _restrictLeft;
+    private _restrictTop;
+    private _restrictRight;
+    private _restrictBottom;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApplyChildResizeRestrictionsExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplyChildResizeRestrictionsExecution>;
 }

package/f-draggable/node-resize/get-node-resize-restrictions/get-node-resize-restrictions.execution.d.ts

@@ -1,12 +1,13 @@
 import { GetNodeResizeRestrictionsRequest } from './get-node-resize-restrictions.request';
 import { INodeResizeRestrictions } from './i-node-resize-restrictions';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class GetNodeResizeRestrictionsExecution implements IExecution<GetNodeResizeRestrictionsRequest, INodeResizeRestrictions> {
-    private fMediator;
-    constructor(fMediator: FMediator);
+    private _fMediator;
     handle(request: GetNodeResizeRestrictionsRequest): INodeResizeRestrictions;
-    private getNodePaddings;
+    private _calculateNodePaddings;
+    private _getNormalizedParentBounds;
+    private _getNormalizedChildrenBounds;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetNodeResizeRestrictionsExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetNodeResizeRestrictionsExecution>;
 }

package/f-draggable/node-resize/get-node-resize-restrictions/i-node-resize-restrictions.d.ts

@@ -1,6 +1,6 @@
 import { IRect, ISize } from '@foblex/2d';
 export interface INodeResizeRestrictions {
-    parentRect: IRect;
-    childRect: IRect | null;
-    minSize: ISize;
+    parentBounds: IRect;
+    childrenBounds: IRect | null;
+    minimumSize: ISize;
 }

package/f-draggable/node-resize/node-resize-finalize/node-resize-finalize.execution.d.ts

@@ -1,10 +1,8 @@
 import { NodeResizeFinalizeRequest } from './node-resize-finalize.request';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
 import * as i0 from "@angular/core";
 export declare class NodeResizeFinalizeExecution implements IExecution<NodeResizeFinalizeRequest, void> {
-    private fDraggableDataContext;
-    constructor(fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
     handle(request: NodeResizeFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizeFinalizeExecution, never>;

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

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

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

@@ -1,18 +1,20 @@
 import { NodeResizePreparationRequest } from './node-resize-preparation.request';
-import { FMediator, IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class NodeResizePreparationExecution implements IExecution<NodeResizePreparationRequest, void> {
-    private fComponentsStore;
-    private fDraggableDataContext;
-    private fMediator;
-    private get transform();
-    private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private get _transform();
+    private get _fHost();
+    private _fNode;
     handle(request: NodeResizePreparationRequest): void;
-    private selectAndUpdateNodeLayer;
-    private getNode;
+    private _isValid;
+    private _isDragHandleElement;
+    private _isNodeCanBeDragged;
+    private _getNode;
+    private _selectAndUpdateNodeLayer;
+    private _getHandleType;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizePreparationExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizePreparationExecution>;
 }