@foblex/flow 12.5.0 → 12.6.0

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

@@ -0,0 +1,9 @@
+import { IPoint, IRect } from '@foblex/core';
+import { EFResizeHandleType } from '../../../f-node';
+export declare class CalculateChangedPositionRequest {
+    originalRect: IRect;
+    changedRect: IRect;
+    difference: IPoint;
+    fResizeHandleType: EFResizeHandleType;
+    constructor(originalRect: IRect, changedRect: IRect, difference: IPoint, fResizeHandleType: EFResizeHandleType);
+}

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

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

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

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

package/f-draggable/node-resize/calculate-changed-size/calculate-changed-size.request.d.ts

@@ -0,0 +1,8 @@
+import { IPoint, IRect } from '@foblex/core';
+import { EFResizeHandleType } from '../../../f-node';
+export declare class CalculateChangedSizeRequest {
+    originalRect: IRect;
+    difference: IPoint;
+    fResizeHandleType: EFResizeHandleType;
+    constructor(originalRect: IRect, difference: IPoint, fResizeHandleType: EFResizeHandleType);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { IRect } from '@foblex/core';
+export interface INodeResizeRestrictions {
+    parentRect: IRect;
+    childRect: IRect | null;
+}

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

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

package/f-draggable/node-resize/get-normalized-children-nodes-rect/get-normalized-children-nodes-rect.execution.d.ts

@@ -0,0 +1,15 @@
+import { GetNormalizedChildrenNodesRectRequest } from './get-normalized-children-nodes-rect.request';
+import { IRect } from '@foblex/core';
+import { FFlowMediator, IExecution } from '../../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class GetNormalizedChildrenNodesRectExecution implements IExecution<GetNormalizedChildrenNodesRectRequest, IRect | null> {
+    private fMediator;
+    constructor(fMediator: FFlowMediator);
+    handle(request: GetNormalizedChildrenNodesRectRequest): IRect | null;
+    private getChildrenNodes;
+    private normalizeRect;
+    private getNodePadding;
+    private concatRectWithParentPadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedChildrenNodesRectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedChildrenNodesRectExecution>;
+}

package/f-draggable/node-resize/get-normalized-children-nodes-rect/get-normalized-children-nodes-rect.request.d.ts

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

package/f-draggable/node-resize/get-normalized-children-nodes-rect/index.d.ts

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

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

@@ -1,4 +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 './node-resize-finalize';
 export * from './node-resize-preparation';
 export * from './node-resize.drag-handler';
 export * from './providers';
+export * from './resize-direction';

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

@@ -1,19 +1,20 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { EFResizeHandleType, FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { FFlowMediator } from '../../infrastructure';
 export declare class NodeResizeDragHandler implements IDraggableItem {
-    private fComponentsStore;
+    private fMediator;
     fNode: FNodeBase;
     fResizeHandleType: EFResizeHandleType;
-    readonly type: EFDraggableType;
-    private readonly onPointerDownPosition;
-    private readonly rect;
-    private get scale();
-    constructor(fComponentsStore: FComponentsStore, fNode: FNodeBase, fResizeHandleType: EFResizeHandleType);
+    private originalRect;
+    private restrictions;
+    private childRestrictions;
+    constructor(fMediator: FFlowMediator, fNode: FNodeBase, fResizeHandleType: EFResizeHandleType);
+    initialize(): void;
     move(difference: IPoint): void;
-    private calculateSize;
-    private calculatePosition;
+    private changeSize;
+    private changePosition;
+    private applyChildRestrictions;
+    private applyParentRestrictions;
     complete(): void;
 }

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

@@ -1 +1,7 @@
-export declare const NODE_RESIZE_PROVIDERS: (typeof import("./node-resize-finalize").NodeResizeFinalizeExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeValidator | typeof import("./node-resize-preparation").NodeResizePreparationExecution | typeof import("./node-resize-preparation").NodeResizePreparationValidator)[];
+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-finalize").NodeResizeFinalizeValidator | typeof import("./node-resize-preparation").NodeResizePreparationExecution | typeof import("./node-resize-preparation").NodeResizePreparationValidator)[];

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

@@ -0,0 +1,18 @@
+export declare const RESIZE_DIRECTIONS: {
+    "left-top": {
+        x: number;
+        y: number;
+    };
+    "right-top": {
+        x: number;
+        y: number;
+    };
+    "right-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").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./external-item").ExternalItemFinalizeExecution | typeof import("./external-item").ExternalItemFinalizeValidator | typeof import("./external-item").ExternalItemPreparationExecution | typeof import("./external-item").ExternalItemPreparationValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./selection-area").SelectionAreaFinalizeExecution | typeof import("./selection-area").SelectionAreaFinalizeValidator | typeof import("./selection-area").SelectionAreaPreparationExecution | typeof import("./selection-area").SelectionAreaPreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("@foblex/flow").ExternalItemFinalizeExecution | typeof import("@foblex/flow").ExternalItemFinalizeValidator | typeof import("@foblex/flow").ExternalItemPreparationExecution | typeof import("@foblex/flow").ExternalItemPreparationValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./domain").ConvertComputedToPixelsExecution | typeof import("./domain").GetNodePaddingExecution | typeof import("./domain").GetNormalizedNodeRectExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").GetParentNodesExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | 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").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator | typeof import("@foblex/flow").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").SelectionAreaFinalizeValidator | typeof import("@foblex/flow").SelectionAreaPreparationExecution | typeof import("@foblex/flow").SelectionAreaPreparationValidator)[];

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

@@ -1,17 +1,18 @@
 import { FFlowMediator, IExecution } from '../../infrastructure';
 import { SingleSelectRequest } from './single-select.request';
-import { GetConnectionHandler } from '../../domain';
+import { PlatformService } from '@foblex/core';
 import { FComponentsStore } from '../../f-storage';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import * as i0 from "@angular/core";
 export declare class SingleSelectExecution implements IExecution<SingleSelectRequest, void> {
+    private platform;
     private fComponentsStore;
     private fDraggableDataContext;
-    private getConnectionHandler;
     private fMediator;
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getConnectionHandler: GetConnectionHandler, fMediator: FFlowMediator);
+    constructor(platform: PlatformService, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
     handle(request: SingleSelectRequest): void;
     private getSelectableItem;
+    private getConnectionHandler;
     private isMultiselectEnabled;
     private singleSelect;
     private multiSelect;

package/{f-draggable/external-item → f-external-item/domain}/external-item-finalize/external-item-finalize.execution.d.ts

@@ -1,7 +1,7 @@
 import { ExternalItemFinalizeRequest } from './external-item-finalize.request';
 import { FFlowMediator, IExecution } from '../../../infrastructure';
 import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class ExternalItemFinalizeExecution implements IExecution<ExternalItemFinalizeRequest, void> {
     private fComponentsStore;

package/{f-draggable/external-item → f-external-item/domain}/external-item-finalize/external-item-finalize.validator.d.ts

@@ -1,6 +1,6 @@
 import { ExternalItemFinalizeRequest } from './external-item-finalize.request';
 import { IValidator } from '../../../infrastructure';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class ExternalItemFinalizeValidator implements IValidator<ExternalItemFinalizeRequest> {
     private fDraggableDataContext;

package/{f-draggable/external-item → f-external-item/domain}/external-item-preparation/external-item-preparation.execution.d.ts

@@ -1,8 +1,8 @@
 import { ExternalItemPreparationRequest } from './external-item-preparation.request';
 import { IExecution } from '../../../infrastructure';
 import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
 import { FExternalItemService } from '../../../f-external-item';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class ExternalItemPreparationExecution implements IExecution<ExternalItemPreparationRequest, void> {
     private fComponentsStore;

package/{f-draggable/external-item → f-external-item/domain}/external-item.drag-handler.d.ts

@@ -1,10 +1,8 @@
 import { IPoint } from '@foblex/core';
-import { IDraggableItem } from '../i-draggable-item';
-import { EFDraggableType } from '../e-f-draggable-type';
 import { FExternalItemBase } from '../../f-external-item';
+import { IDraggableItem } from '../../f-draggable';
 export declare class ExternalItemDragHandler implements IDraggableItem {
     externalItem: FExternalItemBase;
-    readonly type = EFDraggableType.PALETTE_ITEM;
     placeholder: HTMLElement | SVGElement | undefined;
     private onPointerDownRect;
     private difference;

package/f-external-item/domain/providers.d.ts

@@ -0,0 +1 @@
+export declare const F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS: (typeof import("./external-item-finalize").ExternalItemFinalizeExecution | typeof import("./external-item-finalize").ExternalItemFinalizeValidator | typeof import("./external-item-preparation").ExternalItemPreparationExecution | typeof import("./external-item-preparation").ExternalItemPreparationValidator)[];

package/f-external-item/f-external-item.directive.d.ts

@@ -11,6 +11,7 @@ export declare class FExternalItemDirective<TData> extends FExternalItemBase<TDa
     fDisabled: boolean;
     constructor(elementReference: ElementRef<HTMLElement>, fExternalItemService: FExternalItemService);
     ngOnInit(): void;
+    private disablePointerEvents;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": { "alias": "fExternalItemId"; "required": false; }; "fData": { "alias": "fData"; "required": false; }; "fDisabled": { "alias": "fDisabled"; "required": false; }; }, {}, never, never, false, never>;

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

@@ -1,3 +1,4 @@
+export * from './domain';
 export * from './f-external-item-base';
 export * from './is-external-item';
 export * from './f-external-item.directive';

package/f-flow/f-flow.component.d.ts

@@ -17,10 +17,11 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
     ngOnInit(): void;
     ngAfterContentInit(): void;
+    private subscribeOnComponentsCountChanges;
     private subscribeOnElementsChanges;
     redraw(): void;
     reset(): void;
-    getNodesRect(): IRect;
+    getAllNodesRect(): IRect | null;
     getSelection(): FSelectionChangeEvent;
     getPositionInFlow(position: IPoint): IRect;
     selectAll(): void;

package/f-flow.module.d.ts

@@ -24,14 +24,15 @@ import * as i22 from "./f-minimap/f-minimap.component";
 import * as i23 from "./f-minimap/f-minimap-canvas.directive";
 import * as i24 from "./f-minimap/f-minimap-view.directive";
 import * as i25 from "./f-minimap/f-minimap-flow.directive";
-import * as i26 from "./f-node/f-node.directive";
-import * as i27 from "./f-node/f-drag-handle/f-drag-handle.directive";
-import * as i28 from "./f-node/f-resize-handle/f-resize-handle.directive";
-import * as i29 from "./f-selection-area/f-selection-area.component";
-import * as i30 from "./f-draggable/f-draggable.directive";
-import * as i31 from "@angular/common";
+import * as i26 from "./f-node/f-group.directive";
+import * as i27 from "./f-node/f-node.directive";
+import * as i28 from "./f-node/f-drag-handle/f-drag-handle.directive";
+import * as i29 from "./f-node/f-resize-handle/f-resize-handle.directive";
+import * as i30 from "./f-selection-area/f-selection-area.component";
+import * as i31 from "./f-draggable/f-draggable.directive";
+import * as i32 from "@angular/common";
 export declare class FFlowModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FFlowModule, [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FNodeInputDirective, typeof i17.FNodeOutletDirective, typeof i18.FNodeOutputDirective, typeof i19.FExternalItemDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FNodeDirective, typeof i27.FDragHandleDirective, typeof i28.FResizeHandleDirective, typeof i29.FSelectionAreaComponent, typeof i30.FDraggableDirective], [typeof i31.CommonModule], [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FNodeInputDirective, typeof i17.FNodeOutletDirective, typeof i18.FNodeOutputDirective, typeof i19.FExternalItemDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FNodeDirective, typeof i27.FDragHandleDirective, typeof i28.FResizeHandleDirective, typeof i29.FSelectionAreaComponent, typeof i30.FDraggableDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FFlowModule, [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FNodeInputDirective, typeof i17.FNodeOutletDirective, typeof i18.FNodeOutputDirective, typeof i19.FExternalItemDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FGroupDirective, typeof i27.FNodeDirective, typeof i28.FDragHandleDirective, typeof i29.FResizeHandleDirective, typeof i30.FSelectionAreaComponent, typeof i31.FDraggableDirective], [typeof i32.CommonModule], [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FNodeInputDirective, typeof i17.FNodeOutletDirective, typeof i18.FNodeOutputDirective, typeof i19.FExternalItemDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FGroupDirective, typeof i27.FNodeDirective, typeof i28.FDragHandleDirective, typeof i29.FResizeHandleDirective, typeof i30.FSelectionAreaComponent, typeof i31.FDraggableDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FFlowModule>;
 }

package/f-minimap/domain/f-minimap.drag-handler.d.ts

@@ -1,6 +1,6 @@
 import { IPoint, IRect } from '@foblex/core';
 import { FComponentsStore } from '../../f-storage';
-import { EFDraggableType, IDraggableItem } from '../../f-draggable';
+import { IDraggableItem } from '../../f-draggable';
 import { FFlowMediator } from '../../infrastructure';
 import { FMinimapData } from './f-minimap-data';
 export declare class FMinimapDragHandler implements IDraggableItem {
@@ -10,7 +10,6 @@ export declare class FMinimapDragHandler implements IDraggableItem {
     private canvasPosition;
     private eventPoint;
     private minimap;
-    readonly type: EFDraggableType;
     private lastDifference;
     constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
     initialize(): void;

package/f-minimap/f-minimap-canvas.directive.d.ts

@@ -1,15 +1,13 @@
 import { ElementRef } from "@angular/core";
 import { FComponentsStore } from '../f-storage';
-import { FFlowMediator } from '../infrastructure';
 import * as i0 from "@angular/core";
 export declare class FMinimapCanvasDirective {
     private elementReference;
-    private fMediator;
     private fComponentsStore;
     get hostElement(): SVGGElement;
     private get flowHost();
     private get flowScale();
-    constructor(elementReference: ElementRef<SVGGElement>, fMediator: FFlowMediator, fComponentsStore: FComponentsStore);
+    constructor(elementReference: ElementRef<SVGGElement>, fComponentsStore: FComponentsStore);
     redraw(): void;
     private clearCanvas;
     private renderNode;

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

@@ -0,0 +1,2 @@
+export * from './is-group';
+export * from './is-node';

package/f-node/domain/is-group.d.ts

@@ -0,0 +1 @@
+export declare function isGroup(element: HTMLElement | SVGElement): boolean;

package/f-node/f-drag-handle/f-drag-handle.directive.d.ts

@@ -4,11 +4,8 @@ import * as i0 from "@angular/core";
 export declare const F_DRAG_HANDLE: InjectionToken<FDragHandleDirective>;
 export declare class FDragHandleDirective implements IHasHostElement {
     private elementReference;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, { "disabled": { "alias": "fDragHandleDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
 }

package/f-node/f-group.directive.d.ts

@@ -0,0 +1,40 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
+import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/core';
+import { FNodeBase } from './f-node-base';
+import { FComponentsStore } from '../f-storage';
+import { FConnectorBase } from '../f-connectors';
+import { FFlowMediator } from '../infrastructure';
+import * as i0 from "@angular/core";
+export declare class FGroupDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
+    private elementReference;
+    private renderer;
+    private fComponentsStore;
+    private fMediator;
+    private subscriptions$;
+    fId: string;
+    fParentId: string | null | undefined;
+    set position(value: IPoint);
+    get position(): IPoint;
+    positionChange: EventEmitter<IPoint>;
+    set size(value: ISize);
+    get size(): ISize;
+    sizeChange: EventEmitter<IRect>;
+    fDraggingDisabled: boolean;
+    fSelectionDisabled: boolean;
+    fIncludePadding: boolean;
+    fConnectOnNode: boolean;
+    get hostElement(): HTMLElement;
+    connectors: FConnectorBase[];
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    ngOnInit(): void;
+    protected setStyle(styleName: string, value: string): void;
+    redraw(): void;
+    ngAfterViewInit(): void;
+    private subscribeOnResizeChanges;
+    addConnector(connector: FConnectorBase): void;
+    removeConnector(connector: FConnectorBase): void;
+    refresh(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; }; "fParentId": { "alias": "fGroupParentId"; "required": false; }; "position": { "alias": "fGroupPosition"; "required": false; }; "size": { "alias": "fGroupSize"; "required": false; }; "fDraggingDisabled": { "alias": "fGroupDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fGroupSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; }, never, never, false, never>;
+}

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

@@ -7,6 +7,7 @@ import { FConnectorBase } from '../f-connectors';
 export declare const F_NODE: InjectionToken<FNodeBase>;
 export declare abstract class FNodeBase implements IHasStateChanges, ISelectable, IHasHostElement {
     abstract fId: string;
+    abstract fParentId: string | null | undefined;
     abstract hostElement: HTMLElement;
     readonly stateChanges: Subject<void>;
     abstract positionChange: EventEmitter<IPoint>;
@@ -18,6 +19,8 @@ export declare abstract class FNodeBase implements IHasStateChanges, ISelectable
     abstract fDraggingDisabled: boolean;
     abstract fSelectionDisabled: boolean;
     abstract fConnectOnNode: boolean;
+    fCanBeResizedByChild: boolean;
+    abstract fIncludePadding: boolean;
     abstract refresh(): void;
     abstract connectors: FConnectorBase[];
     abstract addConnector(connector: FConnectorBase): void;

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

@@ -1,9 +1,9 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
-import { IHasHostElement, IPoint, IRect, ISize, PointInput } from '@foblex/core';
-import { FNodeBase } from './f-node-base';
+import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/core';
 import { FComponentsStore } from '../f-storage';
 import { FConnectorBase } from '../f-connectors';
 import { FFlowMediator } from '../infrastructure';
+import { FNodeBase } from './f-node-base';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private elementReference;
@@ -12,7 +12,8 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     private fMediator;
     private subscriptions$;
     fId: string;
-    set position(value: PointInput);
+    fParentId: string | null | undefined;
+    set position(value: IPoint);
     get position(): IPoint;
     positionChange: EventEmitter<IPoint>;
     set size(value: ISize);
@@ -20,6 +21,7 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     sizeChange: EventEmitter<IRect>;
     fDraggingDisabled: boolean;
     fSelectionDisabled: boolean;
+    fIncludePadding: boolean;
     fConnectOnNode: boolean;
     get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
@@ -34,5 +36,5 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "size": { "alias": "fNodeSize"; "required": false; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; }; "fParentId": { "alias": "fNodeParentId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "size": { "alias": "fNodeSize"; "required": false; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never, never, false, never>;
 }

package/f-node/f-resize-handle/f-resize-handle.directive.d.ts

@@ -5,9 +5,6 @@ import * as i0 from "@angular/core";
 export declare const F_RESIZE_HANDLE: InjectionToken<FResizeHandleDirective>;
 export declare class FResizeHandleDirective implements IHasHostElement {
     private elementReference;
-    private isDisabled;
-    set disabled(isDisabled: boolean | undefined | string);
-    get disabled(): boolean;
     _type: EFResizeHandleType;
     set type(type: EFResizeHandleType);
     get type(): EFResizeHandleType;
@@ -15,5 +12,5 @@ export declare class FResizeHandleDirective implements IHasHostElement {
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FResizeHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "disabled": { "alias": "fResizeHandleDisabled"; "required": false; }; "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-node/index.d.ts

@@ -1,8 +1,9 @@
+export * from './domain';
 export * from './f-drag-handle';
 export * from './f-resize-handle';
 export * from './f-rotate-handle';
+export * from './f-group.directive';
 export * from './f-node.directive';
 export * from './f-node-base';
 export * from './f-resize-observer';
-export * from './is-node';
 export * from './providers';

package/f-node/providers.d.ts

@@ -1,4 +1,5 @@
 import { FNodeDirective } from './f-node.directive';
 import { FDragHandleDirective } from './f-drag-handle';
 import { FResizeHandleDirective } from './f-resize-handle';
-export declare const F_NODE_PROVIDERS: (typeof FDragHandleDirective | typeof FResizeHandleDirective | typeof FNodeDirective)[];
+import { FGroupDirective } from './f-group.directive';
+export declare const F_NODE_PROVIDERS: (typeof FDragHandleDirective | typeof FResizeHandleDirective | typeof FGroupDirective | typeof FNodeDirective)[];

package/f-selection-area/domain/index.d.ts

@@ -1 +1,4 @@
-export * from './i-selection-area-rect';
+export * from './selection-area-finalize';
+export * from './selection-area-preparation';
+export * from './providers';
+export * from './selection-area.drag-handle';

package/f-selection-area/domain/providers.d.ts

@@ -0,0 +1 @@
+export declare const F_SELECTION_AREA_DRAG_AND_DROP_PROVIDERS: (typeof import("./selection-area-finalize").SelectionAreaFinalizeExecution | typeof import("./selection-area-finalize").SelectionAreaFinalizeValidator | typeof import("./selection-area-preparation").SelectionAreaPreparationExecution | typeof import("./selection-area-preparation").SelectionAreaPreparationValidator)[];

package/{f-draggable/selection-area → f-selection-area/domain}/selection-area-finalize/selection-area-finalize.execution.d.ts

@@ -1,6 +1,6 @@
 import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
 import { IExecution } from '../../../infrastructure';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaFinalizeExecution implements IExecution<SelectionAreaFinalizeRequest, void> {
     private fDraggableDataContext;

package/{f-draggable/selection-area → f-selection-area/domain}/selection-area-finalize/selection-area-finalize.validator.d.ts

@@ -1,6 +1,6 @@
 import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
 import { IValidator } from '../../../infrastructure';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaFinalizeValidator implements IValidator<SelectionAreaFinalizeRequest> {
     private fDraggableDataContext;

package/{f-draggable/selection-area → f-selection-area/domain}/selection-area-preparation/selection-area-preparation.execution.d.ts

@@ -1,7 +1,7 @@
 import { SelectionAreaPreparationRequest } from './selection-area-preparation.request';
 import { FFlowMediator, IExecution } from '../../../infrastructure';
 import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaPreparationExecution implements IExecution<SelectionAreaPreparationRequest, void> {
     private fComponentsStore;

package/f-selection-area/domain/selection-area-preparation/selection-area-preparation.request.d.ts

@@ -0,0 +1,7 @@
+import { IPointerEvent } from '@foblex/core';
+import { FSelectionAreaBase } from '../../f-selection-area-base';
+export declare class SelectionAreaPreparationRequest {
+    event: IPointerEvent;
+    fSelectionArea: FSelectionAreaBase;
+    constructor(event: IPointerEvent, fSelectionArea: FSelectionAreaBase);
+}

package/{f-draggable/selection-area → f-selection-area/domain}/selection-area-preparation/selection-area-preparation.validator.d.ts

@@ -1,6 +1,6 @@
 import { SelectionAreaPreparationRequest } from './selection-area-preparation.request';
 import { IValidator } from '../../../infrastructure';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaPreparationValidator implements IValidator<SelectionAreaPreparationRequest> {
     private fDraggableDataContext;