@foblex/flow 17.7.0 → 17.8.0

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

@@ -0,0 +1,6 @@
+import { IMinMaxPoint } from "@foblex/2d";
+import { ISoftLimit } from "./i-soft-limit";
+export interface IDragLimits {
+    hard: IMinMaxPoint;
+    soft: ISoftLimit[];
+}

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

@@ -0,0 +1,8 @@
+import { IMinMaxPoint, IRect, ISize } from "@foblex/2d";
+import { FNodeBase } from "../../../../f-node";
+export interface ISoftLimit {
+    nodeOrGroup: FNodeBase;
+    boundingRect: IRect;
+    initialSize: ISize | undefined;
+    limits: IMinMaxPoint;
+}

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

@@ -0,0 +1,4 @@
+export * from './calculate-drag-limits';
+export * from './calculate-drag-limits-request';
+export * from './i-drag-limits';
+export * from './i-soft-limit';

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

@@ -1,5 +1,5 @@
 import { FNodeBase } from '../../../f-node';
-export declare class CreateMoveNodesDragModelFromSelectionRequest {
+export declare class CreateDragModelFromSelectionRequest {
     nodeWithDisabledSelection?: FNodeBase | undefined;
     static readonly fToken: unique symbol;
     constructor(nodeWithDisabledSelection?: FNodeBase | undefined);

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

@@ -0,0 +1,24 @@
+import { CreateDragModelFromSelectionRequest } from './create-drag-model-from-selection-request';
+import { IExecution } from '@foblex/mediator';
+import { MoveSummaryDragHandler } from '../move-summary-drag-handler';
+import * as i0 from "@angular/core";
+export declare class CreateDragModelFromSelection implements IExecution<CreateDragModelFromSelectionRequest, MoveSummaryDragHandler> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    handle(request: CreateDragModelFromSelectionRequest): MoveSummaryDragHandler;
+    private _collectSelectedNodesAndGroups;
+    private _getNodesFromSelection;
+    private _findNode;
+    private _collectSelectedAndAllChildren;
+    private _buildDragHierarchy;
+    private _getChildrenNodes;
+    private _getAllOutputIds;
+    private _getNodeOutputIds;
+    private _getAllInputIds;
+    private _getNodeInputIds;
+    private _setConnectionsHandlersToNodes;
+    private _createSummaryDragHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDragModelFromSelection, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDragModelFromSelection>;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-input-connection-handler-and-set-to-node-handler/create-input-connection-handler-and-set-to-node-handler-request.d.ts

@@ -0,0 +1,9 @@
+import { MoveDragHandler } from '../../move-drag-handler';
+import { BaseConnectionDragHandler } from '../../connection-drag-handlers';
+export declare class CreateInputConnectionHandlerAndSetToNodeHandlerRequest {
+    dragHandler: MoveDragHandler;
+    outputIds: string[];
+    existingConnectionHandlers: BaseConnectionDragHandler[];
+    static readonly fToken: unique symbol;
+    constructor(dragHandler: MoveDragHandler, outputIds: string[], existingConnectionHandlers: BaseConnectionDragHandler[]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-input-connection-handler-and-set-to-node-handler/create-input-connection-handler-and-set-to-node-handler.d.ts

@@ -0,0 +1,16 @@
+import { CreateInputConnectionHandlerAndSetToNodeHandlerRequest } from './create-input-connection-handler-and-set-to-node-handler-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CreateInputConnectionHandlerAndSetToNodeHandler implements IExecution<CreateInputConnectionHandlerAndSetToNodeHandlerRequest, void> {
+    private readonly _store;
+    private readonly _injector;
+    private get _connections();
+    handle(request: CreateInputConnectionHandlerAndSetToNodeHandlerRequest): void;
+    private _getInputConnections;
+    private _getNodeInputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateInputConnectionHandlerAndSetToNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateInputConnectionHandlerAndSetToNodeHandler>;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-input-connection-handler-and-set-to-node-handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-input-connection-handler-and-set-to-node-handler';
+export * from './create-input-connection-handler-and-set-to-node-handler-request';

package/f-draggable/f-node-move/create-drag-model-from-selection/create-output-connection-handler-and-set-to-node-handler/create-output-connection-handler-and-set-to-node-handler-request.d.ts

@@ -0,0 +1,9 @@
+import { MoveDragHandler } from '../../move-drag-handler';
+import { BaseConnectionDragHandler } from "../../connection-drag-handlers";
+export declare class CreateOutputConnectionHandlerAndSetToNodeHandlerRequest {
+    fDragHandler: MoveDragHandler;
+    inputIds: string[];
+    existingConnectionHandlers: BaseConnectionDragHandler[];
+    static readonly fToken: unique symbol;
+    constructor(fDragHandler: MoveDragHandler, inputIds: string[], existingConnectionHandlers: BaseConnectionDragHandler[]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-output-connection-handler-and-set-to-node-handler/create-output-connection-handler-and-set-to-node-handler.d.ts

@@ -0,0 +1,18 @@
+import { CreateOutputConnectionHandlerAndSetToNodeHandlerRequest } from './create-output-connection-handler-and-set-to-node-handler-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 CreateOutputConnectionHandlerAndSetToNodeHandler implements IExecution<CreateOutputConnectionHandlerAndSetToNodeHandlerRequest, void> {
+    private readonly _store;
+    private readonly _injector;
+    private get _connections();
+    handle(request: CreateOutputConnectionHandlerAndSetToNodeHandlerRequest): void;
+    _getOutputConnections(nodeOrGroup: FNodeBase): FConnectionBase[];
+    private _getNodeOutputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateOutputConnectionHandlerAndSetToNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateOutputConnectionHandlerAndSetToNodeHandler>;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-output-connection-handler-and-set-to-node-handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-output-connection-handler-and-set-to-node-handler';
+export * from './create-output-connection-handler-and-set-to-node-handler-request';

package/f-draggable/f-node-move/create-drag-model-from-selection/create-summary-drag-handler/create-summary-drag-handler-request.d.ts

@@ -0,0 +1,7 @@
+import { MoveDragHandler } from "../../move-drag-handler";
+export declare class CreateSummaryDragHandlerRequest {
+    readonly roots: MoveDragHandler[];
+    readonly list: MoveDragHandler[];
+    static readonly fToken: unique symbol;
+    constructor(roots: MoveDragHandler[], list: MoveDragHandler[]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/create-summary-drag-handler/create-summary-drag-handler.d.ts

@@ -0,0 +1,13 @@
+import { IExecution } from '@foblex/mediator';
+import { CreateSummaryDragHandlerRequest } from "./create-summary-drag-handler-request";
+import { MoveSummaryDragHandler } from "../../move-summary-drag-handler";
+import * as i0 from "@angular/core";
+export declare class CreateSummaryDragHandler implements IExecution<CreateSummaryDragHandlerRequest, MoveSummaryDragHandler> {
+    private readonly _injector;
+    private readonly _mediator;
+    handle({ roots, list }: CreateSummaryDragHandlerRequest): MoveSummaryDragHandler;
+    private _setLimitsToTheRootHandlers;
+    private _calculateDragLimits;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateSummaryDragHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateSummaryDragHandler>;
+}

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

@@ -0,0 +1,2 @@
+export * from './create-summary-drag-handler';
+export * from './create-summary-drag-handler-request';

package/f-draggable/f-node-move/create-drag-model-from-selection/get-node-bounding-include-paddings/get-node-bounding-include-paddings-request.d.ts

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

package/f-draggable/f-node-move/create-drag-model-from-selection/get-node-bounding-include-paddings/get-node-bounding-include-paddings-response.d.ts

@@ -0,0 +1,9 @@
+import { FNodeBase } from "../../../../f-node";
+import { IRect } from "@foblex/2d";
+export declare class GetNodeBoundingIncludePaddingsResponse {
+    nodeOrGroup: FNodeBase;
+    boundingRect: IRect;
+    innerRect: IRect;
+    paddings: [number, number, number, number];
+    constructor(nodeOrGroup: FNodeBase, boundingRect: IRect, innerRect: IRect, paddings: [number, number, number, number]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/get-node-bounding-include-paddings/get-node-bounding-include-paddings.d.ts

@@ -0,0 +1,13 @@
+import { GetNodeBoundingIncludePaddingsRequest } from './get-node-bounding-include-paddings-request';
+import { IExecution } from '@foblex/mediator';
+import { GetNodeBoundingIncludePaddingsResponse } from "./get-node-bounding-include-paddings-response";
+import * as i0 from "@angular/core";
+export declare class GetNodeBoundingIncludePaddings implements IExecution<GetNodeBoundingIncludePaddingsRequest, GetNodeBoundingIncludePaddingsResponse> {
+    private readonly _mediator;
+    handle({ nodeOrGroup, childrenPaddings }: GetNodeBoundingIncludePaddingsRequest): GetNodeBoundingIncludePaddingsResponse;
+    private _rect;
+    private _boundingRect;
+    private _paddings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNodeBoundingIncludePaddings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNodeBoundingIncludePaddings>;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/get-node-bounding-include-paddings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get-node-bounding-include-paddings';
+export * from './get-node-bounding-include-paddings-request';
+export * from './get-node-bounding-include-paddings-response';

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

@@ -0,0 +1,11 @@
+export * from './build-drag-hierarchy';
+export * from './calculate-drag-limits';
+export * from './create-summary-drag-handler';
+export * from './get-node-bounding-include-paddings';
+export * from './create-input-connection-handler-and-set-to-node-handler';
+export * from './create-output-connection-handler-and-set-to-node-handler';
+export * from './providers';
+export * from './create-drag-model-from-selection';
+export * from './create-drag-model-from-selection-request';
+export * from './i-node-move-limits';
+export * from './i-node-move-limits-and-position';

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

@@ -0,0 +1,8 @@
+import { CreateDragModelFromSelection } from './create-drag-model-from-selection';
+import { CreateInputConnectionHandlerAndSetToNodeHandler } from './create-input-connection-handler-and-set-to-node-handler';
+import { CreateOutputConnectionHandlerAndSetToNodeHandler } from './create-output-connection-handler-and-set-to-node-handler';
+import { BuildDragHierarchy } from "./build-drag-hierarchy";
+import { CalculateDragLimits } from "./calculate-drag-limits";
+import { CreateSummaryDragHandler } from "./create-summary-drag-handler";
+import { GetNodeBoundingIncludePaddings } from "./get-node-bounding-include-paddings";
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof BuildDragHierarchy | typeof GetNodeBoundingIncludePaddings | typeof CalculateDragLimits | typeof CreateSummaryDragHandler | typeof CreateInputConnectionHandlerAndSetToNodeHandler | typeof CreateOutputConnectionHandlerAndSetToNodeHandler | typeof CreateDragModelFromSelection)[];

package/f-draggable/f-node-move/create-snap-lines/create-snap-lines-request.d.ts

@@ -0,0 +1,6 @@
+import { MoveSummaryDragHandler } from "../move-summary-drag-handler";
+export declare class CreateSnapLinesRequest {
+    readonly summaryHandler: MoveSummaryDragHandler;
+    static readonly fToken: unique symbol;
+    constructor(summaryHandler: MoveSummaryDragHandler);
+}

package/f-draggable/f-node-move/create-snap-lines/create-snap-lines.d.ts

@@ -0,0 +1,19 @@
+import { CreateSnapLinesRequest } from './create-snap-lines-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CreateSnapLines implements IExecution<CreateSnapLinesRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _browser;
+    private readonly _injector;
+    private _lineService;
+    handle({ summaryHandler }: CreateSnapLinesRequest): void;
+    private _addLineAlignmentDragHandler;
+    private _allDraggedNodes;
+    private _getFlowHostSize;
+    private _createLineService;
+    private _collectNotDraggedNodeRects;
+    private _calculateNotDraggedNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateSnapLines, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateSnapLines>;
+}

package/f-draggable/f-node-move/create-snap-lines/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-snap-lines';
+export * from './create-snap-lines-request';

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

@@ -0,0 +1,16 @@
+import { IRect, ISize } from '@foblex/2d';
+import { ISnapResult, SnapLineService } from '../../../f-line-alignment';
+import { Injector } from '@angular/core';
+export declare class SnapLinesDragHandler {
+    private _lineService;
+    private _size;
+    private _rects;
+    private _debounceTimer;
+    private readonly _canvasTransform;
+    private readonly _alignThreshold;
+    constructor(injector: Injector, _lineService: SnapLineService, _size: ISize, _rects: IRect[]);
+    drawGuidesFor(_draggedRect: IRect): void;
+    private _renderGuides;
+    findClosestAlignment(_draggedRect: IRect): ISnapResult;
+    clearGuides(): void;
+}

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").GetNodeBoundingIncludePaddings | 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").CreateDragModelFromSelection | typeof CreateSnapLines | typeof FNodeMovePreparationExecution | typeof FNodeMoveFinalizeExecution)[];

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;
+}