@foblex/flow 17.7.0 → 17.7.1

package/f-draggable/f-node-move/f-move-nodes.event.d.ts

@@ -1,4 +1,8 @@
 import { IPoint } from '@foblex/2d';
+/**
+ * Event that is emitted when nodes and groups are moved.
+ * It contains the moved nodes and groups and their new positions.
+ */
 export declare class FMoveNodesEvent {
     fNodes: {
         id: string;

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

@@ -1,11 +1,12 @@
 export * from './connection-drag-handlers';
-export * from './create-move-nodes-drag-model-from-selection';
-export * from './line-alignment-preparation';
+export * from './constraint';
+export * from './create-drag-model-from-selection';
+export * from './create-snap-lines';
 export * from './move-preparation';
 export * from './move-finalize';
-export * from './f-line-alignment.drag-handler';
+export * from './create-snap-lines/snap-lines.drag-handler';
 export * from './f-move-nodes.event';
-export * from './f-node-move.drag-handler';
-export * from './point-bounds-limiter';
+export * from './move-drag-handler';
 export * from './providers';
-export * from './f-summary-node-move.drag-handler';
+export * from './move-summary-drag-handler';
+export * from './constraint/snap-to-grid';

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

@@ -0,0 +1,33 @@
+import { IPoint, IRect } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
+import { FNodeBase } from '../../f-node';
+import { BaseConnectionDragHandler } from './connection-drag-handlers';
+import { Injector } from "@angular/core";
+import { IDragLimits } from "./create-drag-model-from-selection";
+export declare class MoveDragHandler implements IFDragHandler {
+    private readonly _injector;
+    nodeOrGroup: FNodeBase;
+    childrenNodeAndGroups: MoveDragHandler[];
+    fSourceHandlers: BaseConnectionDragHandler[];
+    fTargetHandlers: BaseConnectionDragHandler[];
+    readonly fEventType = "move-node";
+    private readonly _startPosition;
+    private readonly _startRect;
+    private _applyConstraints;
+    private _lastSoftResults;
+    private _pipeline;
+    private _limits;
+    private _lastPosition;
+    constructor(_injector: Injector, nodeOrGroup: FNodeBase, childrenNodeAndGroups?: MoveDragHandler[], fSourceHandlers?: BaseConnectionDragHandler[], fTargetHandlers?: BaseConnectionDragHandler[]);
+    setLimits(limits: IDragLimits): void;
+    private _applySoftExpansions;
+    private _commitParentRect;
+    getLastRect(): IRect;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    assignFinalConstraints(): void;
+    private _nodeOrGroupNewPosition;
+    private _redraw;
+    onPointerUp(): void;
+    private _emitEventIfNodeExpanded;
+}

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

@@ -2,22 +2,22 @@ import { FNodeMoveFinalizeRequest } from './f-node-move-finalize.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeMoveFinalizeExecution implements IExecution<FNodeMoveFinalizeRequest, void> {
-    private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private _summaryHandler;
     private get _fHost();
-    handle(request: FNodeMoveFinalizeRequest): void;
+    handle({ event }: FNodeMoveFinalizeRequest): void;
     private _isValid;
-    private _finalizeMove;
-    private _getItems;
     private _getDifferenceBetweenPreparationAndFinalize;
-    private _getDifferenceWithLineAlignment;
-    private _getLineAlignmentDifference;
-    private _applyLineAlignmentDifference;
+    private _getSnapLinesResult;
+    private _applySnapLinesDifference;
     private _isIntersectValue;
+    private _finalizeMove;
+    private _createMoveNodesEvent;
     private _applyConnectionUnderDroppedNode;
     private _isDraggedJustOneNode;
-    private _getFirstNodeOrGroup;
+    private _firstNodeOrGroup;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeMoveFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FNodeMoveFinalizeExecution>;
 }

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

@@ -2,13 +2,13 @@ import { FNodeMovePreparationRequest } from './f-node-move-preparation.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeMovePreparationExecution implements IExecution<FNodeMovePreparationRequest, void> {
-    private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
     private get _transform();
     private get _fHost();
     private _fNode;
-    handle(request: FNodeMovePreparationRequest): void;
+    handle({ event, fTrigger }: FNodeMovePreparationRequest): void;
     private _isValid;
     private _isDragHandleElement;
     private _getNode;

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

@@ -0,0 +1,22 @@
+import { IPoint } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
+import { MoveDragHandler } from './move-drag-handler';
+import { Injector } from "@angular/core";
+import { SnapLinesDragHandler } from "./create-snap-lines/snap-lines.drag-handler";
+import { ISnapResult } from "../../f-line-alignment";
+export declare class MoveSummaryDragHandler implements IFDragHandler {
+    allDraggedNodeHandlers: MoveDragHandler[];
+    rootHandlers: MoveDragHandler[];
+    readonly fEventType = "move-node";
+    readonly fData: any;
+    private _lineAlignment;
+    constructor(_injector: Injector, allDraggedNodeHandlers: MoveDragHandler[], rootHandlers: MoveDragHandler[]);
+    setLineAlignment(handler: SnapLinesDragHandler): void;
+    findClosestAlignment(difference: IPoint): ISnapResult | undefined;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    private _unionRect;
+    private _getRootRects;
+    private _refreshDraggedNodes;
+}

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

@@ -1,4 +1,4 @@
 import { FNodeMoveFinalizeExecution } from './move-finalize';
 import { FNodeMovePreparationExecution } from './move-preparation';
-import { LineAlignmentPreparationExecution } from './line-alignment-preparation';
-export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveLimitsExecution | 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").CalculateNodeMoveLimitsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof LineAlignmentPreparationExecution | typeof FNodeMovePreparationExecution | typeof FNodeMoveFinalizeExecution)[];
+import { CreateSnapLines } from './create-snap-lines';
+export declare const NODE_PROVIDERS: (typeof import("./create-drag-model-from-selection").BuildDragHierarchy | typeof import("./create-drag-model-from-selection").CalculateDragLimits | typeof import("./create-drag-model-from-selection").CreateSummaryDragHandler | typeof import("./create-drag-model-from-selection").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").GetNodeBoundingIncludePaddings | typeof import("./create-drag-model-from-selection").CreateDragModelFromSelection | typeof CreateSnapLines | typeof FNodeMoveFinalizeExecution | typeof FNodeMovePreparationExecution)[];

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

@@ -0,0 +1,7 @@
+import { IRect } from '@foblex/2d';
+export declare class ApplyChildResizeConstraintsRequest {
+    readonly rect: IRect;
+    readonly childrenBounds: IRect | null;
+    static readonly fToken: unique symbol;
+    constructor(rect: IRect, childrenBounds: IRect | null);
+}

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

@@ -0,0 +1,13 @@
+import { ApplyChildResizeConstraintsRequest } from './apply-child-resize-constraints-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ApplyChildResizeConstraints implements IExecution<ApplyChildResizeConstraintsRequest, void> {
+    handle({ rect, childrenBounds }: ApplyChildResizeConstraintsRequest): void;
+    private _apply;
+    private _restrictLeft;
+    private _restrictTop;
+    private _restrictRight;
+    private _restrictBottom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyChildResizeConstraints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyChildResizeConstraints>;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { IRect } from '@foblex/2d';
+import { IResizeLimits } from "../constraint";
+export declare class ApplyParentResizeConstraintsRequest {
+    rect: IRect;
+    limits: IResizeLimits;
+    static readonly fToken: unique symbol;
+    constructor(rect: IRect, limits: IResizeLimits);
+}

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

@@ -0,0 +1,36 @@
+import { ApplyParentResizeConstraintsRequest } from './apply-parent-resize-constraints-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+/**
+ * Resize constraints behavior:
+ * - SOFT (parents): if the child hits the innerRect, a NEW parent rect is calculated
+ *   from the original boundingRect and applied via updatePosition/Size/redraw.
+ *   The original boundingRect/innerRect are never mutated.
+ * - HARD (child): the child rect is clamped to stay within the hard.innerRect.
+ */
+export declare class ApplyParentResizeConstraints implements IExecution<ApplyParentResizeConstraintsRequest, void> {
+    /** Entry point: applies soft and hard resize constraints. */
+    handle({ rect, limits }: ApplyParentResizeConstraintsRequest): void;
+    private _applyResizeConstraints;
+    /** Returns a copy of the child rect pre-clamped to the hard innerRect if it exists. */
+    private _clampedCopyForCalculation;
+    /** Clamps the rect inside the given innerRect. Mutates the rect directly. */
+    private _clampRectToInner;
+    /** Iterates over all soft limits and applies expansion if overflow is detected. */
+    private applySoftParentExpansions;
+    /**
+     * If the child overflows the parent's innerRect, calculate a new parent rect
+     * based on the original boundingRect and apply it. Otherwise, reset to original.
+     */
+    private expandParentFromOriginalIfOverflow;
+    /** Returns true if any overflow exists. */
+    private _hasOverflow;
+    /** Computes overflow values for each side relative to innerRect. */
+    private _computeOverflow;
+    /** Builds new parent rect from original rect and overflow values. */
+    private _buildExpandedParentRect;
+    /** Applies the calculated parent rect to the node/group. */
+    private _applyParentRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyParentResizeConstraints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyParentResizeConstraints>;
+}

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

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

package/f-draggable/f-node-resize/calculate-changed-rect-from-difference/calculate-changed-rect-from-difference-request.d.ts

@@ -0,0 +1,10 @@
+import { IPoint, IRect, ISize } from '@foblex/2d';
+import { EFResizeHandleType } from '../../../f-node';
+export declare class CalculateChangedRectFromDifferenceRequest {
+    readonly originalRect: IRect;
+    readonly difference: IPoint;
+    readonly handleType: EFResizeHandleType;
+    readonly minimumSize: ISize;
+    static readonly fToken: unique symbol;
+    constructor(originalRect: IRect, difference: IPoint, handleType: EFResizeHandleType, minimumSize: ISize);
+}

package/f-draggable/f-node-resize/calculate-changed-rect-from-difference/calculate-changed-rect-from-difference.d.ts

@@ -0,0 +1,11 @@
+import { CalculateChangedRectFromDifferenceRequest } from './calculate-changed-rect-from-difference-request';
+import { IRect } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateChangedRectFromDifference implements IExecution<CalculateChangedRectFromDifferenceRequest, IRect> {
+    handle({ originalRect, difference, handleType, minimumSize }: CalculateChangedRectFromDifferenceRequest): IRect;
+    private _changeSizeInRect;
+    private _changePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateChangedRectFromDifference, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateChangedRectFromDifference>;
+}

package/f-draggable/f-node-resize/calculate-changed-rect-from-difference/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-changed-rect-from-difference';
+export * from './calculate-changed-rect-from-difference-request';

package/f-draggable/f-node-resize/calculate-direct-children-union-rect/calculate-direct-children-union-rect-request.d.ts

@@ -0,0 +1,7 @@
+import { FNodeBase } from '../../../f-node';
+export declare class CalculateDirectChildrenUnionRectRequest {
+    nodeOrGroup: FNodeBase;
+    paddings: [number, number, number, number];
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup: FNodeBase, paddings: [number, number, number, number]);
+}

package/f-draggable/f-node-resize/calculate-direct-children-union-rect/calculate-direct-children-union-rect.d.ts

@@ -0,0 +1,15 @@
+import { CalculateDirectChildrenUnionRectRequest } from './calculate-direct-children-union-rect-request';
+import { IRect } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateDirectChildrenUnionRect implements IExecution<CalculateDirectChildrenUnionRectRequest, IRect | null> {
+    private readonly _mediator;
+    private readonly _store;
+    private get _allNodesAndGroups();
+    handle({ nodeOrGroup, paddings }: CalculateDirectChildrenUnionRectRequest): IRect | null;
+    private _calculateDirectChildren;
+    private _normalizeRect;
+    private _concatRectWithParentPadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateDirectChildrenUnionRect, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateDirectChildrenUnionRect>;
+}

package/f-draggable/f-node-resize/calculate-direct-children-union-rect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-direct-children-union-rect';
+export * from './calculate-direct-children-union-rect-request';

package/f-draggable/f-node-resize/{get-node-resize-restrictions/get-node-resize-restrictions.request.d.ts → calculate-resize-limits/calculate-resize-limits-request.d.ts}

@@ -1,8 +1,8 @@
 import { FNodeBase } from '../../../f-node';
 import { IRect } from '@foblex/2d';
-export declare class GetNodeResizeRestrictionsRequest {
-    fNode: FNodeBase;
+export declare class CalculateResizeLimitsRequest {
+    nodeOrGroup: FNodeBase;
     rect: IRect;
     static readonly fToken: unique symbol;
-    constructor(fNode: FNodeBase, rect: IRect);
+    constructor(nodeOrGroup: FNodeBase, rect: IRect);
 }

package/f-draggable/f-node-resize/calculate-resize-limits/calculate-resize-limits.d.ts

@@ -0,0 +1,17 @@
+import { CalculateResizeLimitsRequest } from './calculate-resize-limits-request';
+import { IResizeConstraint } from '../constraint';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateResizeLimits implements IExecution<CalculateResizeLimitsRequest, IResizeConstraint> {
+    private readonly _mediator;
+    handle({ nodeOrGroup, rect }: CalculateResizeLimitsRequest): IResizeConstraint;
+    private _calculateNodePaddings;
+    private _getNormalizedChildrenBounds;
+    private _getParentsChain;
+    private _buildSoftHardLimits;
+    private _getParentInfo;
+    private _isAutoExpand;
+    private _makeLimit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateResizeLimits, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateResizeLimits>;
+}

package/f-draggable/f-node-resize/calculate-resize-limits/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-resize-limits';
+export * from './calculate-resize-limits-request';

package/f-draggable/f-node-resize/constraint/i-resize-constraint.d.ts

@@ -0,0 +1,7 @@
+import { IRect, ISize } from '@foblex/2d';
+import { IResizeLimits } from "./i-resize-limits";
+export interface IResizeConstraint {
+    limits: IResizeLimits;
+    childrenBounds: IRect | null;
+    minimumSize: ISize;
+}

package/f-draggable/f-node-resize/constraint/i-resize-limit.d.ts

@@ -0,0 +1,7 @@
+import { IRect } from "@foblex/2d";
+import { FNodeBase } from "../../../f-node";
+export interface IResizeLimit {
+    boundingRect: IRect;
+    innerRect: IRect;
+    nodeOrGroup: FNodeBase;
+}

package/f-draggable/f-node-resize/constraint/i-resize-limits.d.ts

@@ -0,0 +1,5 @@
+import { IResizeLimit } from "./i-resize-limit";
+export interface IResizeLimits {
+    softLimits: IResizeLimit[];
+    hardLimit: IResizeLimit | undefined;
+}

package/f-draggable/f-node-resize/constraint/i-resize-overflow.d.ts

@@ -0,0 +1,6 @@
+export interface IResizeOverflow {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}

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

@@ -0,0 +1,4 @@
+export * from './i-resize-constraint';
+export * from './i-resize-limit';
+export * from './i-resize-limits';
+export * from './i-resize-overflow';

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

@@ -1,11 +1,11 @@
-export * from './apply-child-resize-restrictions';
-export * from './apply-parent-resize-restrictions';
-export * from './calculate-changed-position';
-export * from './calculate-changed-size';
-export * from './get-normalized-children-nodes-rect';
-export * from './get-node-resize-restrictions';
+export * from './apply-child-resize-constraints';
+export * from './apply-parent-resize-constraints';
+export * from './calculate-changed-rect-from-difference';
+export * from './calculate-direct-children-union-rect';
+export * from './calculate-resize-limits';
+export * from './constraint';
 export * from './resize-finalize';
 export * from './resize-preparation';
-export * from './f-node-resize.drag-handler';
+export * from './node-resize.drag-handler';
 export * from './providers';
 export * from './resize-direction';

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

@@ -0,0 +1,25 @@
+import { IPoint } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
+import { EFResizeHandleType, FNodeBase } from '../../f-node';
+import { Injector } from '@angular/core';
+export declare class NodeResizeDragHandler implements IFDragHandler {
+    private _nodeOrGroup;
+    private _handleType;
+    readonly fEventType = "node-resize";
+    readonly fData: any;
+    private readonly _mediator;
+    private _originalRect;
+    private _constraints;
+    constructor(injector: Injector, _nodeOrGroup: FNodeBase, _handleType: EFResizeHandleType);
+    prepareDragSequence(): void;
+    private _getOriginalNodeRect;
+    private _calculateResizeLimits;
+    onPointerMove(difference: IPoint): void;
+    private _newRect;
+    private _applyResizeChanges;
+    private _redraw;
+    private _applyChildConstraints;
+    private _applyParentConstraints;
+    onPointerUp(): void;
+    private _getNewRect;
+}

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

@@ -1,9 +1,8 @@
-import { FNodeResizeFinalizeExecution } from './resize-finalize';
-import { FNodeResizePreparationExecution } from './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 GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof FNodeResizeFinalizeExecution | typeof FNodeResizePreparationExecution)[];
+import { NodeResizeFinalize } from './resize-finalize';
+import { NodeResizePreparation } from './resize-preparation';
+import { CalculateResizeLimits } from './calculate-resize-limits';
+import { ApplyChildResizeConstraints } from './apply-child-resize-constraints';
+import { ApplyParentResizeConstraints } from './apply-parent-resize-constraints';
+import { CalculateChangedRectFromDifference } from './calculate-changed-rect-from-difference';
+import { CalculateDirectChildrenUnionRect } from './calculate-direct-children-union-rect';
+export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeConstraints | typeof ApplyParentResizeConstraints | typeof CalculateChangedRectFromDifference | typeof CalculateDirectChildrenUnionRect | typeof CalculateResizeLimits | typeof NodeResizeFinalize | typeof NodeResizePreparation)[];

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

@@ -1,2 +1,2 @@
-export * from './f-node-resize-finalize.execution';
-export * from './f-node-resize-finalize.request';
+export * from './node-resize-finalize';
+export * from './node-resize-finalize-request';

package/f-draggable/{f-drop-to-group/drop-to-group-preparation/f-node-drop-to-group-preparation.request.d.ts → f-node-resize/resize-finalize/node-resize-finalize-request.d.ts}

@@ -1,6 +1,6 @@
 import { IPointerEvent } from "../../../drag-toolkit";
-export declare class FNodeDropToGroupPreparationRequest {
-    event: IPointerEvent;
+export declare class NodeResizeFinalizeRequest {
+    readonly event: IPointerEvent;
     static readonly fToken: unique symbol;
     constructor(event: IPointerEvent);
 }

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

@@ -0,0 +1,10 @@
+import { NodeResizeFinalizeRequest } from './node-resize-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class NodeResizeFinalize implements IExecution<NodeResizeFinalizeRequest, void> {
+    private readonly _dragContext;
+    handle(request: NodeResizeFinalizeRequest): void;
+    private _isNodeResizeHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizeFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizeFinalize>;
+}

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

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

package/f-draggable/f-node-resize/resize-preparation/{f-node-resize-preparation.request.d.ts → node-resize-preparation-request.d.ts}

@@ -1,6 +1,6 @@
 import { FEventTrigger } from '../../../domain';
 import { IPointerEvent } from "../../../drag-toolkit";
-export declare class FNodeResizePreparationRequest {
+export declare class NodeResizePreparationRequest {
     event: IPointerEvent;
     fTrigger: FEventTrigger;
     static readonly fToken: unique symbol;

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

@@ -0,0 +1,22 @@
+import { NodeResizePreparationRequest } from './node-resize-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class NodeResizePreparation implements IExecution<NodeResizePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _injector;
+    private get _transform();
+    private get _fHost();
+    private _nodeOrGroup;
+    handle(request: NodeResizePreparationRequest): void;
+    private _isValid;
+    private _isResizeHandleElement;
+    private _isNodeCanBeDragged;
+    private _getNode;
+    private _isValidTrigger;
+    private _selectAndUpdateNodeLayer;
+    private _getHandleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizePreparation>;
+}

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

@@ -7,9 +7,9 @@ export declare class FNodeRotateDragHandler implements IFDragHandler {
     private _fNode;
     private _fSourceHandlers;
     private _fTargetHandlers;
-    private readonly _fComponentsStore;
+    private readonly _store;
     private readonly _fMediator;
-    private readonly _fDraggableDataContext;
+    private readonly _dragContext;
     fEventType: string;
     fData: any;
     private _initialRotationToX;

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

@@ -1,3 +1,3 @@
 import { FNodeRotateFinalizeExecution } from './rotate-finalize';
 import { FNodeRotatePreparationExecution } from './rotate-preparation';
-export declare const NODE_ROTATE_PROVIDERS: (typeof FNodeRotateFinalizeExecution | typeof FNodeRotatePreparationExecution)[];
+export declare const NODE_ROTATE_PROVIDERS: (typeof FNodeRotatePreparationExecution | typeof FNodeRotateFinalizeExecution)[];

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

@@ -2,7 +2,7 @@ import { FNodeRotateFinalizeRequest } from './f-node-rotate-finalize.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeRotateFinalizeExecution implements IExecution<FNodeRotateFinalizeRequest, void> {
-    private readonly _fDraggableDataContext;
+    private readonly _dragContext;
     handle(request: FNodeRotateFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeRotateFinalizeExecution, never>;

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

@@ -3,8 +3,8 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeRotatePreparationExecution implements IExecution<FNodeRotatePreparationRequest, void> {
     private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     private readonly _injector;
     private get _transform();
     private get _fHost();

package/f-draggable/f-single-select/f-single-select.execution.d.ts

@@ -40,8 +40,8 @@ import * as i0 from "@angular/core";
  */
 export declare class FSingleSelectExecution implements IExecution<FSingleSelectRequest, void> {
     private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     handle(request: FSingleSelectRequest): void;
     private _isValid;
     private _isEventInFlowBounds;

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | 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("./f-node-move").CalculateCommonNodeMoveLimitsExecution | typeof import("./f-node-move").PutInputConnectionHandlersToArrayExecution | typeof import("./f-node-move").PutOutputConnectionHandlersToArrayExecution | typeof import("./f-node-move").CalculateNodeMoveLimitsExecution | typeof import("./f-node-move").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./f-node-move").LineAlignmentPreparationExecution | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-drop-to-group").FNodeDropToGroupFinalizeExecution | typeof import("./f-drop-to-group").FNodeDropToGroupPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./f-node-resize").GetNodeResizeRestrictionsExecution | typeof import("./f-node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./f-node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./f-node-resize").CalculateChangedPositionExecution | typeof import("./f-node-resize").CalculateChangedSizeExecution | typeof import("./f-node-resize").FNodeResizeFinalizeExecution | typeof import("./f-node-resize").FNodeResizePreparationExecution | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-node-resize").ApplyChildResizeConstraints | typeof import("./f-node-resize").ApplyParentResizeConstraints | typeof import("./f-node-resize").CalculateChangedRectFromDifference | typeof import("./f-node-resize").CalculateDirectChildrenUnionRect | typeof import("./f-node-resize").CalculateResizeLimits | typeof import("./f-node-resize").NodeResizeFinalize | typeof import("./f-node-resize").NodeResizePreparation | typeof import("./f-drop-to-group").SortContainersForDropByLayer | typeof import("./f-drop-to-group").DropToGroupPreparation | typeof import("./f-drop-to-group").DropToGroupFinalize | typeof import("./f-node-move").BuildDragHierarchy | typeof import("./f-node-move").CalculateDragLimits | typeof import("./f-node-move").CreateSummaryDragHandler | typeof import("./f-node-move").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").GetNodeBoundingIncludePaddings | typeof import("./f-node-move").CreateDragModelFromSelection | typeof import("./f-node-move").CreateSnapLines | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | 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").IsArrayHasParentNodeExecution | 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("../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-draggable/f-node-move/point-bounds-limiter.d.ts → f-external-item/domain/constraint/external-rect-constraint.d.ts}

@@ -1,13 +1,13 @@
 import { IMinMaxPoint, IPoint } from '@foblex/2d';
 import { Injector } from '@angular/core';
-export declare class PointBoundsLimiter {
+export declare class ExternalRectConstraint {
     private _onPointerDown;
     private readonly _limit;
-    private readonly _fComponentsStore;
     private readonly _vCellSize;
     private readonly _hCellSize;
-    constructor(_injector: Injector, _onPointerDown: IPoint, _limit: IMinMaxPoint);
-    limit(difference: IPoint, adjustCellSize: boolean): IPoint;
+    private readonly _adjustCellSize;
+    constructor(injector: Injector, _onPointerDown: IPoint, _limit: IMinMaxPoint);
+    limit(difference: IPoint): IPoint;
     private _cellSizeStrategies;
     private _applyCellSize;
     private _skipCellSize;

package/f-external-item/domain/constraint/index.d.ts

@@ -0,0 +1 @@
+export * from './external-rect-constraint';