@foblex/flow 12.5.0 → 12.6.0

package/f-draggable/domain/get-node-padding/get-node-padding.execution.d.ts

@@ -0,0 +1,12 @@
+import { GetNodePaddingRequest } from './get-node-padding.request';
+import { FFlowMediator, IExecution } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class GetNodePaddingExecution implements IExecution<GetNodePaddingRequest, [number, number, number, number]> {
+    private fMediator;
+    constructor(fMediator: FFlowMediator);
+    handle(request: GetNodePaddingRequest): [number, number, number, number];
+    private getPaddingData;
+    private convertToPixels;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNodePaddingExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNodePaddingExecution>;
+}

package/f-draggable/domain/get-node-padding/get-node-padding.request.d.ts

@@ -0,0 +1,7 @@
+import { FNodeBase } from '../../../f-node';
+import { IRect } from '@foblex/core';
+export declare class GetNodePaddingRequest {
+    fNode: FNodeBase;
+    rect: IRect;
+    constructor(fNode: FNodeBase, rect: IRect);
+}

package/f-draggable/domain/get-node-padding/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-node-padding.execution';
+export * from './get-node-padding.request';

package/f-draggable/domain/get-normalized-node-rect/get-normalized-node-rect.execution.d.ts

@@ -0,0 +1,13 @@
+import { GetNormalizedNodeRectRequest } from './get-normalized-node-rect.request';
+import { IRect } from '@foblex/core';
+import { IExecution } from '../../../infrastructure';
+import { FComponentsStore } from '../../../f-storage';
+import * as i0 from "@angular/core";
+export declare class GetNormalizedNodeRectExecution implements IExecution<GetNormalizedNodeRectRequest, IRect> {
+    private fComponentsStore;
+    constructor(fComponentsStore: FComponentsStore);
+    handle(request: GetNormalizedNodeRectRequest): IRect;
+    private normalizeRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedNodeRectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedNodeRectExecution>;
+}

package/f-draggable/domain/get-normalized-node-rect/get-normalized-node-rect.request.d.ts

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

package/f-draggable/domain/get-normalized-node-rect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-normalized-node-rect.execution';
+export * from './get-normalized-node-rect.request';

package/f-draggable/domain/get-normalized-parent-node-rect/get-normalized-parent-node-rect.execution.d.ts

@@ -0,0 +1,17 @@
+import { GetNormalizedParentNodeRectRequest } from './get-normalized-parent-node-rect.request';
+import { IRect } from '@foblex/core';
+import { FFlowMediator, IExecution } from '../../../infrastructure';
+import { FComponentsStore } from '../../../f-storage';
+import * as i0 from "@angular/core";
+export declare class GetNormalizedParentNodeRectExecution implements IExecution<GetNormalizedParentNodeRectRequest, IRect> {
+    private fComponentsStore;
+    private fMediator;
+    constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    handle(request: GetNormalizedParentNodeRectRequest): IRect;
+    private getNode;
+    private getParentRect;
+    private getNormalizedNodeRect;
+    private getNodePadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedParentNodeRectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedParentNodeRectExecution>;
+}

package/f-draggable/domain/get-normalized-parent-node-rect/get-normalized-parent-node-rect.request.d.ts

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

package/f-draggable/domain/get-normalized-parent-node-rect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-normalized-parent-node-rect.execution';
+export * from './get-normalized-parent-node-rect.request';

package/f-draggable/domain/get-parent-nodes/get-parent-nodes.execution.d.ts

@@ -0,0 +1,13 @@
+import { GetParentNodesRequest } from './get-parent-nodes.request';
+import { IExecution } from '../../../infrastructure';
+import { FNodeBase } from '../../../f-node';
+import { FComponentsStore } from '../../../f-storage';
+import * as i0 from "@angular/core";
+export declare class GetParentNodesExecution implements IExecution<GetParentNodesRequest, FNodeBase[]> {
+    private fComponentsStore;
+    constructor(fComponentsStore: FComponentsStore);
+    handle(request: GetParentNodesRequest): FNodeBase[];
+    private getParentNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetParentNodesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetParentNodesExecution>;
+}

package/f-draggable/domain/get-parent-nodes/get-parent-nodes.request.d.ts

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

package/f-draggable/domain/get-parent-nodes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-parent-nodes.execution';
+export * from './get-parent-nodes.request';

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

@@ -0,0 +1,7 @@
+export * from './convert-computed-to-pixels';
+export * from './get-node-padding';
+export * from './get-normalized-node-rect';
+export * from './get-normalized-parent-node-rect';
+export * from './get-parent-nodes';
+export * from './is-array-has-parent-node';
+export * from './providers';

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

@@ -0,0 +1,2 @@
+export * from './is-array-has-parent-node.execution';
+export * from './is-array-has-parent-node.request';

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

@@ -0,0 +1,13 @@
+import { IsArrayHasParentNodeRequest } from './is-array-has-parent-node.request';
+import { FFlowMediator, IExecution } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class IsArrayHasParentNodeExecution implements IExecution<IsArrayHasParentNodeRequest, boolean> {
+    private fMediator;
+    constructor(fMediator: FFlowMediator);
+    handle(request: IsArrayHasParentNodeRequest): boolean;
+    private getParentNodeIds;
+    private getParentNodes;
+    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

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

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

@@ -0,0 +1,7 @@
+import { GetNormalizedNodeRectExecution } from './get-normalized-node-rect';
+import { ConvertComputedToPixelsExecution } from './convert-computed-to-pixels';
+import { GetParentNodesExecution } from './get-parent-nodes';
+import { IsArrayHasParentNodeExecution } from './is-array-has-parent-node';
+import { GetNormalizedParentNodeRectExecution } from './get-normalized-parent-node-rect';
+import { GetNodePaddingExecution } from './get-node-padding';
+export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof ConvertComputedToPixelsExecution | typeof GetNodePaddingExecution | typeof GetNormalizedNodeRectExecution | typeof GetNormalizedParentNodeRectExecution | typeof GetParentNodesExecution | typeof IsArrayHasParentNodeExecution)[];

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

@@ -1,9 +1,9 @@
 import { IHasHostElement, IPointerEvent } from '@foblex/core';
 import { EventEmitter, InjectionToken } from '@angular/core';
-import { FCreateNodeEvent } from './external-item';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { ICanRunOutsideAngular } from './i-can-run-outside-angular';
+import { FCreateNodeEvent } from '../f-external-item';
 import * as i0 from "@angular/core";
 export declare const F_DRAGGABLE: InjectionToken<FDraggableBase>;
 export declare const MOUSE_EVENT_IGNORE_TIME = 800;
@@ -27,6 +27,7 @@ export declare abstract class FDraggableBase implements IHasHostElement {
     private dragStartPosition;
     abstract disabled: boolean;
     private moveHandler;
+    private pointerDownElement;
     protected constructor(ngZone: ICanRunOutsideAngular | undefined);
     private onMouseDown;
     private onTouchDown;

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

@@ -2,7 +2,6 @@ import { Point } from '@foblex/core';
 import { IDraggableItem } from './i-draggable-item';
 import { ISelectable } from '../f-connection';
 import { FLineAlignmentBase } from '../f-line-alignment';
-import { FSelectionAreaBase } from '../f-selection-area';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
     selectedItems: ISelectable[];
@@ -10,7 +9,6 @@ export declare class FDraggableDataContext {
     onPointerDownScale: number;
     onPointerDownPosition: Point;
     draggableItems: IDraggableItem[];
-    fSelectionArea: FSelectionAreaBase | undefined;
     fLineAlignment: FLineAlignmentBase | undefined;
     reset(): void;
     markSelectionAsChanged(): void;

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

@@ -2,11 +2,11 @@ import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit } from "@ang
 import { FDraggableBase } from './f-draggable-base';
 import { FComponentsStore } from '../f-storage';
 import { FDraggableDataContext } from './f-draggable-data-context';
-import { FCreateNodeEvent } from './external-item';
 import { IPointerEvent } from '@foblex/core';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FFlowMediator } from '../infrastructure';
+import { FCreateNodeEvent } from '../f-external-item';
 import { ICanRunOutsideAngular } from './i-can-run-outside-angular';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {

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

@@ -1,7 +1,5 @@
 import { IPoint } from '@foblex/core';
-import { EFDraggableType } from './e-f-draggable-type';
 export interface IDraggableItem {
-    type: EFDraggableType;
     initialize?(): void;
     move(difference: IPoint): void;
     complete?(): void;

package/f-draggable/index.d.ts

@@ -1,11 +1,9 @@
 export * from './canvas';
 export * from './connections';
-export * from './external-item';
+export * from './domain';
 export * from './node';
 export * from './node-resize';
-export * from './selection-area';
 export * from './single-select';
-export * from './e-f-draggable-type';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';

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

@@ -0,0 +1,23 @@
+import { ILine, IPoint } from '@foblex/core';
+import { IDraggableItem } from '../i-draggable-item';
+import { RoundedRect } from '../../domain';
+import { FConnectionBase } from '../../f-connection';
+import { EFConnectableSide } from '../../f-connectors';
+import { FFlowMediator } from '../../infrastructure';
+import { INodeMoveRestrictions } from './create-move-nodes-drag-model-from-selection';
+import * as i0 from "@angular/core";
+export declare abstract class ConnectionBaseDragHandler implements IDraggableItem {
+    protected fMediator: FFlowMediator;
+    connection: FConnectionBase;
+    protected fromConnectorRect: RoundedRect;
+    protected fromConnectorSide: EFConnectableSide;
+    protected toConnectorRect: RoundedRect;
+    protected toConnectorSide: EFConnectableSide;
+    protected constructor(fMediator: FFlowMediator, connection: FConnectionBase);
+    initialize(): void;
+    abstract move(difference: IPoint): void;
+    protected getDifference(difference: IPoint, restrictions: INodeMoveRestrictions): 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,17 +1,11 @@
 import { IPoint } from '@foblex/core';
-import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { FConnectionBase } from '../../f-connection';
 import { FFlowMediator } from '../../infrastructure';
-export declare class ConnectionSourceDragHandler implements IDraggableItem {
-    private fMediator;
-    private connection;
-    readonly type: EFDraggableType;
-    private fromConnectorRect;
-    private fromConnectorSide;
-    private toConnectorRect;
-    private toConnectorSide;
-    constructor(fMediator: FFlowMediator, connection: FConnectionBase);
-    initialize(): void;
+import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
+export declare class ConnectionSourceDragHandler extends ConnectionBaseDragHandler {
+    minDistance: IPoint;
+    maxDistance: IPoint;
+    constructor(fMediator: FFlowMediator, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
     move(difference: IPoint): void;
+    private getNewLineValue;
 }

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

@@ -1,17 +1,11 @@
 import { IPoint } from '@foblex/core';
-import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { FConnectionBase } from '../../f-connection';
 import { FFlowMediator } from '../../infrastructure';
-export declare class ConnectionTargetDragHandler implements IDraggableItem {
-    private fMediator;
-    private connection;
-    readonly type: EFDraggableType;
-    private fromConnectorRect;
-    private fromConnectorSide;
-    private toConnectorRect;
-    private toConnectorSide;
-    constructor(fMediator: FFlowMediator, connection: FConnectionBase);
-    initialize(): void;
+import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
+export declare class ConnectionTargetDragHandler extends ConnectionBaseDragHandler {
+    minDistance: IPoint;
+    maxDistance: IPoint;
+    constructor(fMediator: FFlowMediator, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
     move(difference: IPoint): void;
+    private getNewLineValue;
 }

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

@@ -1,16 +1,13 @@
 import { IPoint } from '@foblex/core';
-import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { FConnectionBase } from '../../f-connection';
 import { FFlowMediator } from '../../infrastructure';
-export declare class ConnectionDragHandler implements IDraggableItem {
-    private fMediator;
-    connection: FConnectionBase;
-    readonly type = EFDraggableType.CONNECTION;
-    private onPointerDownLine;
-    private fromConnectorSide;
-    private toConnectorSide;
+import { ConnectionBaseDragHandler } from './connection-base-drag-handler';
+export declare class ConnectionDragHandler extends ConnectionBaseDragHandler {
+    private sourceRestrictions;
+    private targetRestrictions;
     constructor(fMediator: FFlowMediator, connection: FConnectionBase);
-    initialize(): void;
+    setOutputRestrictions(min: IPoint, max: IPoint): void;
+    setInputRestrictions(min: IPoint, max: IPoint): void;
     move(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

@@ -2,26 +2,24 @@ import { CreateMoveNodesDragModelFromSelectionRequest } from './create-move-node
 import { FFlowMediator, IExecution } from '../../../infrastructure';
 import { FComponentsStore } from '../../../f-storage';
 import { FDraggableDataContext } from '../../f-draggable-data-context';
-import { GetIncomingConnectionsHandler, GetOutgoingConnectionsHandler } from '../../../domain';
 import { IDraggableItem } from '../../i-draggable-item';
 import * as i0 from "@angular/core";
 export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, IDraggableItem[]> {
     private fComponentsStore;
     private fDraggableDataContext;
-    private getOutgoingConnectionsHandler;
-    private getIncomingConnectionsHandler;
     private fMediator;
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler, fMediator: FFlowMediator);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
     handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[];
     private getSelectedNodes;
+    private getNodesWithRestrictions;
+    private getChildrenItemsToDrag;
+    private getChildrenNodes;
     private getAllOutputIds;
     private getOutputsForNode;
     private getAllInputIds;
     private getInputsForNode;
     private getDragHandlersFromNodes;
     private getDragHandlersWithConnections;
-    private getDragHandlersForOutputConnections;
-    private getDragHandlersForInputConnections;
     static ɵfac: i0.ɵɵFactoryDeclaration<CreateMoveNodesDragModelFromSelectionExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CreateMoveNodesDragModelFromSelectionExecution>;
 }

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

@@ -0,0 +1,13 @@
+import { GetNodeMoveRestrictionsRequest } from './get-node-move-restrictions.request';
+import { INodeMoveRestrictions } from './i-node-move-restrictions';
+import { FFlowMediator, IExecution } from '../../../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class GetNodeMoveRestrictionsExecution implements IExecution<GetNodeMoveRestrictionsRequest, INodeMoveRestrictions> {
+    private fMediator;
+    constructor(fMediator: FFlowMediator);
+    handle(request: GetNodeMoveRestrictionsRequest): INodeMoveRestrictions;
+    private getCurrentNodeRect;
+    private getParentNodeRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNodeMoveRestrictionsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNodeMoveRestrictionsExecution>;
+}

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

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

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

@@ -0,0 +1,5 @@
+import { IPoint } from '@foblex/core';
+export interface INodeMoveRestrictions {
+    min: IPoint;
+    max: IPoint;
+}

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

@@ -0,0 +1,3 @@
+export * from './get-node-move-restrictions.execution';
+export * from './get-node-move-restrictions.request';
+export * from './i-node-move-restrictions';

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

@@ -0,0 +1,2 @@
+export * from './put-input-connection-handlers-to-array.execution';
+export * from './put-input-connection-handlers-to-array.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

@@ -0,0 +1,22 @@
+import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';
+import { FComponentsStore } from '../../../../../f-storage';
+import { FFlowMediator, IExecution } from '../../../../../infrastructure';
+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: FFlowMediator);
+    handle(request: PutInputConnectionHandlersToArrayRequest): void;
+    getInputConnections(node: FNodeBase): FConnectionBase[];
+    private getInputsForNode;
+    private getExistingConnectionHandlerIndex;
+    private createNewConnectionHandler;
+    private getNewConnectionHandler;
+    private updateExistingConnectionHandler;
+    private getNewSourceConnectionHandler;
+    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

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

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

@@ -0,0 +1,2 @@
+export * from './put-output-connection-handlers-to-array.execution';
+export * from './put-output-connection-handlers-to-array.request';

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

@@ -0,0 +1,22 @@
+import { PutOutputConnectionHandlersToArrayRequest } from './put-output-connection-handlers-to-array.request';
+import { FComponentsStore } from '../../../../../f-storage';
+import { FFlowMediator, IExecution } from '../../../../../infrastructure';
+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: FFlowMediator);
+    handle(request: PutOutputConnectionHandlersToArrayRequest): void;
+    getOutputConnections(node: FNodeBase): FConnectionBase[];
+    private getOutputsForNode;
+    private getExistingConnectionHandlerIndex;
+    private createNewConnectionHandler;
+    private getNewConnectionHandler;
+    private updateExistingConnectionHandler;
+    private getNewSourceConnectionHandler;
+    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

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

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

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

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

@@ -1,3 +1,7 @@
+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 './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';

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

@@ -1,2 +1,5 @@
 import { CreateMoveNodesDragModelFromSelectionExecution } from './create-move-nodes-drag-model-from-selection.execution';
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CreateMoveNodesDragModelFromSelectionExecution)[];
+import { GetNodeMoveRestrictionsExecution } from './domain/get-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 PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof GetNodeMoveRestrictionsExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];

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

@@ -2,7 +2,9 @@ export * from './create-move-nodes-drag-model-from-selection';
 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 './node.drag-handler';
+export * from './node-resize-by-child.drag-handler';
 export * from './providers';

package/f-draggable/node/node-resize-by-child.drag-handler.d.ts

@@ -0,0 +1,10 @@
+import { IPoint } from '@foblex/core';
+import { IDraggableItem } from '../i-draggable-item';
+import { FDraggableDataContext } from '../f-draggable-data-context';
+export declare class NodeResizeByChildDragHandler implements IDraggableItem {
+    private fDraggableDataContext;
+    private onPointerDownPosition;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    move(difference: IPoint): void;
+    complete(): void;
+}

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

@@ -1,14 +1,17 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import { FNodeBase } from '../../f-node';
 export declare class NodeDragHandler implements IDraggableItem {
     private fDraggableDataContext;
     fNode: FNodeBase;
-    readonly type: EFDraggableType;
+    minDistance: IPoint;
+    maxDistance: IPoint;
     private onPointerDownPosition;
-    constructor(fDraggableDataContext: FDraggableDataContext, fNode: FNodeBase);
+    constructor(fDraggableDataContext: FDraggableDataContext, fNode: FNodeBase, minDistance: IPoint, maxDistance: IPoint);
     move(difference: IPoint): void;
+    private getNewPosition;
+    private getDifference;
+    private redrawNode;
     complete(): void;
 }

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

@@ -1 +1 @@
-export declare const NODE_PROVIDERS: (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-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator)[];
+export declare const NODE_PROVIDERS: (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").GetNodeMoveRestrictionsExecution | 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-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator)[];

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

@@ -0,0 +1,13 @@
+import { ApplyChildResizeRestrictionsRequest } from './apply-child-resize-restrictions.request';
+import { IExecution } from '../../../infrastructure';
+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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyChildResizeRestrictionsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyChildResizeRestrictionsExecution>;
+}

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

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/core';
+export declare class ApplyChildResizeRestrictionsRequest {
+    rect: IRect;
+    restrictionsRect: IRect;
+    constructor(rect: IRect, restrictionsRect: IRect);
+}

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

@@ -0,0 +1,2 @@
+export * from './apply-child-resize-restrictions.execution';
+export * from './apply-child-resize-restrictions.request';

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

@@ -0,0 +1,13 @@
+import { ApplyParentResizeRestrictionsRequest } from './apply-parent-resize-restrictions.request';
+import { IExecution } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class ApplyParentResizeRestrictionsExecution implements IExecution<ApplyParentResizeRestrictionsRequest, void> {
+    handle(request: ApplyParentResizeRestrictionsRequest): void;
+    private applyRestrictions;
+    private left;
+    private top;
+    private right;
+    private bottom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyParentResizeRestrictionsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyParentResizeRestrictionsExecution>;
+}

package/f-draggable/node-resize/apply-parent-resize-restrictions/apply-parent-resize-restrictions.request.d.ts

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/core';
+export declare class ApplyParentResizeRestrictionsRequest {
+    rect: IRect;
+    restrictionsRect: IRect;
+    constructor(rect: IRect, restrictionsRect: IRect);
+}

package/f-draggable/node-resize/apply-parent-resize-restrictions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './apply-parent-resize-restrictions.execution';
+export * from './apply-parent-resize-restrictions.request';

package/f-draggable/node-resize/calculate-changed-position/calculate-changed-position.execution.d.ts

@@ -0,0 +1,10 @@
+import { CalculateChangedPositionRequest } from './calculate-changed-position.request';
+import { IRect } from '@foblex/core';
+import { IExecution } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class CalculateChangedPositionExecution implements IExecution<CalculateChangedPositionRequest, IRect> {
+    handle(request: CalculateChangedPositionRequest): IRect;
+    private change;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateChangedPositionExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateChangedPositionExecution>;
+}