@foblex/flow 17.1.1 → 17.2.1

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,17 @@
 import { IMinMaxPoint, IPoint, IRect, ISize } from '@foblex/2d';
-import { IDraggableItem } from '../index';
-import { FComponentsStore } from '../../f-storage';
+import { IFDragHandler } from '../index';
 import { ILineAlignmentResult, LineService } from '../../f-line-alignment';
-export declare class LineAlignmentDragHandler implements IDraggableItem {
-    private _fComponentsStore;
+export declare class LineAlignmentDragHandler implements IFDragHandler {
     private _lineService;
     private _size;
     private _draggedNodeRect;
     private _rects;
     private _restrictions;
+    fEventType: string;
+    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-drag-to-parent.drag-handler.d.ts

@@ -1,13 +1,14 @@
 import { IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler';
 import { FComponentsStore } from '../../f-storage';
 import { INodeWithRect } from '../domain';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import * as i0 from "@angular/core";
-export declare class NodeDragToParentDragHandler implements IDraggableItem {
+export declare class NodeDragToParentDragHandler implements IFDragHandler {
     private fComponentsStore;
     private fDraggableDataContext;
     private notDraggedNodesRects;
+    fEventType: string;
     private DEBOUNCE_TIME;
     private get _transform();
     private _onPointerDownPosition;

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,16 @@
-import { IMinMaxPoint, IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IPoint } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
-export declare class NodeDragHandler implements IDraggableItem {
-    private _fComponentsStore;
+import { BaseConnectionDragHandler } from './connection-drag-handlers';
+export declare class NodeDragHandler implements IFDragHandler {
     fNode: FNodeBase;
-    restrictions: IMinMaxPoint;
+    fSourceHandlers: BaseConnectionDragHandler[];
+    fTargetHandlers: BaseConnectionDragHandler[];
+    fEventType: string;
     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,16 @@
+import { IMinMaxPoint, IPoint, IRect } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
+import { NodeDragHandler } from './node.drag-handler';
+export declare class SummaryNodeDragHandler implements IFDragHandler {
+    limits: IMinMaxPoint;
+    fHandlers: NodeDragHandler[];
+    commonRect: IRect;
+    fEventType: string;
+    fData: any;
+    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>;
 }

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

@@ -1,20 +1,26 @@
 import { IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler/i-f-drag-handler';
 import { EFResizeHandleType, FNodeBase } from '../../f-node';
-import { FMediator } from '@foblex/mediator';
-export declare class NodeResizeDragHandler implements IDraggableItem {
-    private fMediator;
-    fNode: FNodeBase;
-    fResizeHandleType: EFResizeHandleType;
-    private originalRect;
-    private restrictions;
-    private childRestrictions;
-    constructor(fMediator: FMediator, fNode: FNodeBase, fResizeHandleType: EFResizeHandleType);
+export declare class NodeResizeDragHandler implements IFDragHandler {
+    private _fNode;
+    private _fResizeHandleType;
+    fEventType: string;
+    fData: any;
+    private _fMediator;
+    private _originalRect;
+    private _resizeRestrictions;
+    constructor(_fNode: FNodeBase, _fResizeHandleType: EFResizeHandleType);
     prepareDragSequence(): void;
+    private _getOriginalNodeRect;
+    private _getNodeResizeRestrictions;
     onPointerMove(difference: IPoint): void;
-    private changeSize;
-    private changePosition;
-    private applyChildRestrictions;
-    private applyParentRestrictions;
+    private _calculateChangedRect;
+    private _calculateSize;
+    private _calculatePosition;
+    private _applyResizeChanges;
+    private _updateNodeRendering;
+    private _applyChildRestrictions;
+    private _applyParentRestrictions;
     onPointerUp(): void;
+    private _getNewRect;
 }

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

@@ -1,7 +1,8 @@
+import { NodeResizePreparationExecution } from './node-resize-preparation';
 import { GetNodeResizeRestrictionsExecution } from './get-node-resize-restrictions';
 import { ApplyChildResizeRestrictionsExecution } from './apply-child-resize-restrictions';
 import { ApplyParentResizeRestrictionsExecution } from './apply-parent-resize-restrictions';
 import { CalculateChangedSizeExecution } from './calculate-changed-size';
 import { CalculateChangedPositionExecution } from './calculate-changed-position';
 import { GetNormalizedChildrenNodesRectExecution } from './get-normalized-children-nodes-rect';
-export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeExecution | typeof import("./node-resize-preparation").NodeResizePreparationExecution | typeof import("./node-resize-preparation").NodeResizePreparationValidator)[];
+export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeExecution | typeof NodeResizePreparationExecution)[];

package/f-draggable/node-resize/resize-direction.d.ts

@@ -1,16 +1,32 @@
 export declare const RESIZE_DIRECTIONS: {
+    left: {
+        x: number;
+        y: number;
+    };
     "left-top": {
         x: number;
         y: number;
     };
+    top: {
+        x: number;
+        y: number;
+    };
     "right-top": {
         x: number;
         y: number;
     };
+    right: {
+        x: number;
+        y: number;
+    };
     "right-bottom": {
         x: number;
         y: number;
     };
+    bottom: {
+        x: number;
+        y: number;
+    };
     "left-bottom": {
         x: number;
         y: number;

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-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)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node").CalculateCommonNodeMoveLimitsExecution | typeof import("./node").CalculateNodeMoveLimitsExecution | 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").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("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];

package/f-external-item/domain/create-placeholder/f-external-item-create-placeholder.execution.d.ts

@@ -0,0 +1,13 @@
+import { FExternalItemCreatePlaceholderRequest } from './f-external-item-create-placeholder.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FExternalItemCreatePlaceholderExecution implements IExecution<FExternalItemCreatePlaceholderRequest, HTMLElement | SVGElement> {
+    private _fBrowser;
+    private _containerRef;
+    handle(request: FExternalItemCreatePlaceholderRequest): HTMLElement | SVGElement;
+    private _fromTemplate;
+    private _fromHost;
+    private _createViewRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemCreatePlaceholderExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemCreatePlaceholderExecution>;
+}

package/f-external-item/domain/create-placeholder/f-external-item-create-placeholder.request.d.ts

@@ -0,0 +1,5 @@
+import { FExternalItemBase } from '../../f-external-item-base';
+export declare class FExternalItemCreatePlaceholderRequest {
+    fExternalItem: FExternalItemBase;
+    constructor(fExternalItem: FExternalItemBase);
+}

package/f-external-item/domain/create-placeholder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-external-item-create-placeholder.execution';
+export * from './f-external-item-create-placeholder.request';