@foblex/flow 17.1.0 → 17.2.0

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

@@ -15,6 +15,8 @@ export declare class NodeMoveFinalizeExecution implements IExecution<NodeMoveFin
     private _getLineAlignmentDifference;
     private _applyLineAlignmentDifference;
     private _applyConnectionUnderDroppedNode;
+    private _isDraggedJustOneNode;
+    private _getFirstNodeOrGroup;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeMoveFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeMoveFinalizeExecution>;
 }

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

@@ -1,18 +1,15 @@
-import { IMinMaxPoint, IPoint } from '@foblex/2d';
+import { IPoint } from '@foblex/2d';
 import { IDraggableItem } from '../i-draggable-item';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { BaseConnectionDragHandler } from './connection-drag-handlers';
 export declare class NodeDragHandler implements IDraggableItem {
-    private _fComponentsStore;
     fNode: FNodeBase;
-    restrictions: IMinMaxPoint;
+    fSourceHandlers: BaseConnectionDragHandler[];
+    fTargetHandlers: BaseConnectionDragHandler[];
     private readonly _onPointerDownPosition;
-    constructor(_fComponentsStore: FComponentsStore, fNode: FNodeBase, restrictions: IMinMaxPoint);
+    constructor(fNode: FNodeBase, fSourceHandlers?: BaseConnectionDragHandler[], fTargetHandlers?: BaseConnectionDragHandler[]);
     onPointerMove(difference: IPoint): void;
-    private _getPosition;
-    private _getDifference;
+    private _calculateNewPosition;
     private _redraw;
     onPointerUp(): void;
-    getDifferenceWithCellSize(difference: IPoint): IPoint;
-    private _applyCellSize;
 }

package/f-draggable/node/point-bounds-limiter.d.ts

@@ -0,0 +1,15 @@
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
+export declare class PointBoundsLimiter {
+    private _onPointerDown;
+    private readonly _limit;
+    private _fComponentsStore;
+    private _vCellSize;
+    private _hCellSize;
+    constructor(_onPointerDown: IPoint, _limit: IMinMaxPoint);
+    limit(difference: IPoint, adjustCellSize: boolean): IPoint;
+    private _cellSizeStrategies;
+    private _applyCellSize;
+    private _skipCellSize;
+    private _clamp;
+    private _snapToGrid;
+}

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

@@ -1,3 +1,4 @@
 import { NodeMoveFinalizeExecution } from './node-move-finalize';
+import { NodeDragToParentPreparationExecution } from './node-drag-to-parent-preparation';
 import { LineAlignmentPreparationExecution } from './line-alignment-preparation';
-export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof LineAlignmentPreparationExecution | typeof NodeMoveFinalizeExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationValidator | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveLimitsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateNodeMoveLimitsExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof LineAlignmentPreparationExecution | typeof NodeMoveFinalizeExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution)[];

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

@@ -0,0 +1,14 @@
+import { IMinMaxPoint, IPoint, IRect } from '@foblex/2d';
+import { IDraggableItem } from '../i-draggable-item';
+import { NodeDragHandler } from './node.drag-handler';
+export declare class SummaryNodeDragHandler implements IDraggableItem {
+    limits: IMinMaxPoint;
+    fHandlers: NodeDragHandler[];
+    commonRect: IRect;
+    private _fComponentStore;
+    private readonly _fBoundsLimiter;
+    constructor(limits: IMinMaxPoint, fHandlers: NodeDragHandler[], commonRect: IRect);
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    calculateRestrictedDifference(difference: IPoint): IPoint;
+}

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

@@ -3,11 +3,11 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class ApplyChildResizeRestrictionsExecution implements IExecution<ApplyChildResizeRestrictionsRequest, void> {
     handle(request: ApplyChildResizeRestrictionsRequest): void;
-    private applyRestrictions;
-    private left;
-    private top;
-    private right;
-    private bottom;
+    private _apply;
+    private _restrictLeft;
+    private _restrictTop;
+    private _restrictRight;
+    private _restrictBottom;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApplyChildResizeRestrictionsExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplyChildResizeRestrictionsExecution>;
 }

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

@@ -1,12 +1,13 @@
 import { GetNodeResizeRestrictionsRequest } from './get-node-resize-restrictions.request';
 import { INodeResizeRestrictions } from './i-node-resize-restrictions';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class GetNodeResizeRestrictionsExecution implements IExecution<GetNodeResizeRestrictionsRequest, INodeResizeRestrictions> {
-    private fMediator;
-    constructor(fMediator: FMediator);
+    private _fMediator;
     handle(request: GetNodeResizeRestrictionsRequest): INodeResizeRestrictions;
-    private getNodePaddings;
+    private _calculateNodePaddings;
+    private _getNormalizedParentBounds;
+    private _getNormalizedChildrenBounds;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetNodeResizeRestrictionsExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetNodeResizeRestrictionsExecution>;
 }

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

@@ -1,6 +1,6 @@
 import { IRect, ISize } from '@foblex/2d';
 export interface INodeResizeRestrictions {
-    parentRect: IRect;
-    childRect: IRect | null;
-    minSize: ISize;
+    parentBounds: IRect;
+    childrenBounds: IRect | null;
+    minimumSize: ISize;
 }

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

@@ -1,10 +1,8 @@
 import { NodeResizeFinalizeRequest } from './node-resize-finalize.request';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
 import * as i0 from "@angular/core";
 export declare class NodeResizeFinalizeExecution implements IExecution<NodeResizeFinalizeRequest, void> {
-    private fDraggableDataContext;
-    constructor(fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
     handle(request: NodeResizeFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizeFinalizeExecution, never>;

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

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

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

@@ -1,18 +1,20 @@
 import { NodeResizePreparationRequest } from './node-resize-preparation.request';
-import { FMediator, IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class NodeResizePreparationExecution implements IExecution<NodeResizePreparationRequest, void> {
-    private fComponentsStore;
-    private fDraggableDataContext;
-    private fMediator;
-    private get transform();
-    private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private get _transform();
+    private get _fHost();
+    private _fNode;
     handle(request: NodeResizePreparationRequest): void;
-    private selectAndUpdateNodeLayer;
-    private getNode;
+    private _isValid;
+    private _isDragHandleElement;
+    private _isNodeCanBeDragged;
+    private _getNode;
+    private _selectAndUpdateNodeLayer;
+    private _getHandleType;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizePreparationExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizePreparationExecution>;
 }

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

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

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

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

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

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

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./node").CalculateCommonNodeMoveRestrictionsExecution | typeof import("./node").CalculateNodeMoveRestrictionsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").LineAlignmentPreparationExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentPreparationValidator | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./single-select").SingleSelectExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node-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("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node").CalculateCommonNodeMoveLimitsExecution | typeof import("./node").CalculateNodeMoveLimitsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").LineAlignmentPreparationExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionDragHandlerPreparationExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./single-select").SingleSelectExecution | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];

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

@@ -1,28 +1,62 @@
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import { SingleSelectRequest } from './single-select.request';
-import { FComponentsStore } from '../../f-storage';
-import { FDraggableDataContext } from '../f-draggable-data-context';
-import { PlatformService } from '@foblex/platform';
 import * as i0 from "@angular/core";
+/**
+ * Implements the functionality for selecting elements in a graphical interface.
+ * This class handles both single and multi-selection, updating the selection state
+ * of elements and managing related data.
+ *
+ * Logic flow:
+ * 1. **Validate the selection event**:
+ *    - The event is considered valid if it occurs within the flow boundaries
+ *      and there are no active draggable data operations.
+ *
+ * 2. **Determine the target element to select**:
+ *    - The target element is determined based on the event’s target.
+ *      It can be a node, a group of nodes, or a connection.
+ *    - If no element is found, the current selection state is cleared.
+ *
+ * 3. **Update element layers**:
+ *    - If an element is found, its visual layer and the layers of its child elements are updated.
+ *
+ * 4. **Single or multi-selection**:
+ *    - If the event meets the criteria for multi-selection (e.g., a modifier key is pressed),
+ *      multi-selection logic is applied.
+ *    - Otherwise, single-selection logic is used.
+ *
+ * 5. **Single-selection logic**:
+ *    - If the element is not selected and can be selected:
+ *      - Clear the selection of all other elements.
+ *      - Mark the current element as selected.
+ *    - If the element cannot be selected, the current selection is cleared.
+ *
+ * 6. **Multi-selection logic**:
+ *    - If the element is already selected, it is removed from the selection.
+ *    - If the element is not selected and can be selected, it is added to the selection.
+ *
+ * 7. **Manage selection state**:
+ *    - Adding or removing an element from the selection triggers the corresponding methods.
+ *    - Selection state is tracked in the shared context for future use.
+ */
 export declare class SingleSelectExecution implements IExecution<SingleSelectRequest, void> {
-    private fPlatform;
-    private fComponentsStore;
-    private fDraggableDataContext;
-    private fMediator;
-    constructor(fPlatform: PlatformService, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
     handle(request: SingleSelectRequest): void;
     private _isValid;
-    private getSelectableItem;
-    private _findNode;
-    private getConnectionHandler;
-    private isMultiselectEnabled;
-    private isShiftPressed;
-    private isCommandButton;
-    private singleSelect;
-    private multiSelect;
-    private deselectItem;
-    private selectItem;
-    private clearSelection;
+    private _isEventInFlowBounds;
+    private _getItemToSelect;
+    private _getNodeOrGroup;
+    private _getConnection;
+    private _updateItemAndChildrenLayers;
+    private _isMultiSelect;
+    private _singleSelect;
+    private _isItemNotSelectedAndSelectable;
+    private _clearSelection;
+    private _multiSelect;
+    private _deselectItem;
+    private _removeItemFromSelectedItems;
+    private _selectItem;
     static ɵfac: i0.ɵɵFactoryDeclaration<SingleSelectExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SingleSelectExecution>;
 }

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

@@ -1,5 +1,7 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
+import { FEventTrigger } from '../../domain';
 export declare class SingleSelectRequest {
     event: IPointerEvent;
-    constructor(event: IPointerEvent);
+    fMultiSelectTrigger: FEventTrigger;
+    constructor(event: IPointerEvent, fMultiSelectTrigger: FEventTrigger);
 }

package/f-external-item/domain/external-item-preparation/external-item-preparation.execution.d.ts

@@ -1,19 +1,15 @@
 import { ExternalItemPreparationRequest } from './external-item-preparation.request';
 import { IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FExternalItemService } from '../../../f-external-item';
-import { FDraggableDataContext } from '../../../f-draggable';
-import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class ExternalItemPreparationExecution implements IExecution<ExternalItemPreparationRequest, void> {
-    private fComponentsStore;
-    private fDraggableDataContext;
-    private fExternalItemService;
-    private fBrowser;
-    private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fExternalItemService: FExternalItemService, fBrowser: BrowserService);
+    private _fExternalItemService;
+    private _fDraggableDataContext;
+    private _fComponentsStore;
+    private get _fHost();
     handle(request: ExternalItemPreparationRequest): void;
-    private getExternalItem;
+    private _isValid;
+    private _isValidExternalItem;
+    private _getExternalItem;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExternalItemPreparationExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ExternalItemPreparationExecution>;
 }

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

@@ -1,4 +1,3 @@
 export * from './providers';
 export * from './external-item-preparation.execution';
 export * from './external-item-preparation.request';
-export * from './external-item-preparation.validator';

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

@@ -1,3 +1,2 @@
 import { ExternalItemPreparationExecution } from './external-item-preparation.execution';
-import { ExternalItemPreparationValidator } from './external-item-preparation.validator';
-export declare const EXTERNAL_ITEM_PREPARATION_PROVIDERS: (typeof ExternalItemPreparationExecution | typeof ExternalItemPreparationValidator)[];
+export declare const EXTERNAL_ITEM_PREPARATION_PROVIDERS: (typeof ExternalItemPreparationExecution)[];

package/f-external-item/domain/external-item.drag-handler.d.ts

@@ -1,14 +1,13 @@
 import { IPoint } from '@foblex/2d';
 import { FExternalItemBase } from '../../f-external-item';
 import { IDraggableItem } from '../../f-draggable';
-import { BrowserService } from '@foblex/platform';
 export declare class ExternalItemDragHandler implements IDraggableItem {
     externalItem: FExternalItemBase;
-    private fBrowser;
+    private _fBrowser;
     placeholder: HTMLElement | SVGElement | undefined;
     private onPointerDownRect;
     private difference;
-    constructor(externalItem: FExternalItemBase, fBrowser: BrowserService);
+    constructor(externalItem: FExternalItemBase);
     private getStyle;
     prepareDragSequence(): void;
     private getExternalItemRect;

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

@@ -1,2 +1,2 @@
 import { PreventDefaultIsExternalItemExecution } from './prevent-default-is-external-item';
-export declare const F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS: (typeof import("./external-item-finalize").ExternalItemFinalizeExecution | typeof import("./external-item-preparation").ExternalItemPreparationExecution | typeof import("./external-item-preparation").ExternalItemPreparationValidator | typeof PreventDefaultIsExternalItemExecution)[];
+export declare const F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS: (typeof import("./external-item-preparation").ExternalItemPreparationExecution | typeof import("./external-item-finalize").ExternalItemFinalizeExecution | typeof PreventDefaultIsExternalItemExecution)[];

package/f-minimap/domain/minimap-drag-finalize/index.d.ts

@@ -1,4 +1,3 @@
 export * from './providers';
 export * from './minimap-drag-finalize.execution';
 export * from './minimap-drag-finalize.request';
-export * from './minimap-drag-finalize.validator';

package/f-minimap/domain/minimap-drag-finalize/minimap-drag-finalize.execution.d.ts

@@ -6,6 +6,7 @@ export declare class MinimapDragFinalizeExecution implements IExecution<MinimapD
     private fDraggableDataContext;
     constructor(fDraggableDataContext: FDraggableDataContext);
     handle(request: MinimapDragFinalizeRequest): void;
+    private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragFinalizeExecution>;
 }

package/f-minimap/domain/minimap-drag-finalize/providers.d.ts

@@ -1,3 +1,2 @@
 import { MinimapDragFinalizeExecution } from './minimap-drag-finalize.execution';
-import { MinimapDragFinalizeValidator } from './minimap-drag-finalize.validator';
-export declare const MINIMAP_DRAG_FINALIZE_PROVIDERS: (typeof MinimapDragFinalizeExecution | typeof MinimapDragFinalizeValidator)[];
+export declare const MINIMAP_DRAG_FINALIZE_PROVIDERS: (typeof MinimapDragFinalizeExecution)[];

package/f-minimap/domain/minimap-drag-preparation/index.d.ts

@@ -1,4 +1,3 @@
 export * from './providers';
 export * from './minimap-drag-preparation.execution';
 export * from './minimap-drag-preparation.request';
-export * from './minimap-drag-preparation.validator';

package/f-minimap/domain/minimap-drag-preparation/minimap-drag-preparation.execution.d.ts

@@ -10,6 +10,7 @@ export declare class MinimapDragPreparationExecution implements IExecution<Minim
     private get flowHost();
     constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, fDraggableDataContext: FDraggableDataContext);
     handle(request: MinimapDragPreparationRequest): void;
+    private _isValid;
     private getNewPosition;
     private getFlowRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragPreparationExecution, never>;

package/f-minimap/domain/minimap-drag-preparation/providers.d.ts

@@ -1,3 +1,2 @@
 import { MinimapDragPreparationExecution } from './minimap-drag-preparation.execution';
-import { MinimapDragPreparationValidator } from './minimap-drag-preparation.validator';
-export declare const MINIMAP_DRAG_PREPARATION_PROVIDERS: (typeof MinimapDragPreparationExecution | typeof MinimapDragPreparationValidator)[];
+export declare const MINIMAP_DRAG_PREPARATION_PROVIDERS: (typeof MinimapDragPreparationExecution)[];

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

@@ -2,4 +2,4 @@ import { CalculateFlowPointFromMinimapPointExecution } from './calculate-flow-po
 import { MinimapDrawNodesExecution } from './minimap-draw-nodes';
 import { MinimapCalculateViewBoxExecution } from './minimap-calculate-view-box';
 import { MinimapCalculateSvgScaleAndViewBoxExecution } from './minimap-calculate-svg-scale-and-view-box';
-export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeValidator | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationValidator | typeof MinimapDrawNodesExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution | typeof MinimapCalculateViewBoxExecution)[];
+export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof CalculateFlowPointFromMinimapPointExecution | typeof MinimapDrawNodesExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution | typeof MinimapCalculateViewBoxExecution)[];

package/f-minimap/providers.d.ts

@@ -2,4 +2,4 @@ import { FMinimapComponent } from './f-minimap.component';
 import { FMinimapViewDirective } from './f-minimap-view.directive';
 import { FMinimapFlowDirective } from './f-minimap-flow.directive';
 import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
-export declare const F_MINIMAP_PROVIDERS: (typeof FMinimapFlowDirective | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapComponent)[];
+export declare const F_MINIMAP_PROVIDERS: (typeof FMinimapComponent | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapFlowDirective)[];

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

@@ -31,4 +31,8 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     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>;
+    static ngAcceptInputType_fDraggingDisabled: unknown;
+    static ngAcceptInputType_fSelectionDisabled: unknown;
+    static ngAcceptInputType_fIncludePadding: unknown;
+    static ngAcceptInputType_fConnectOnNode: unknown;
 }

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

@@ -2,15 +2,15 @@ import { EventEmitter, InjectionToken } from '@angular/core';
 import { IPoint, IRect, ISize } from '@foblex/2d';
 import { FConnectorBase } from '../f-connectors';
 import { IHasHostElement } from '../i-has-host-element';
-import { ICanChangeSelection } from '../mixins';
+import { ISelectable } from '../mixins';
 import { FChannel } from '../reactivity';
 export declare const F_NODE: InjectionToken<FNodeBase>;
-declare const MIXIN_BASE: import("../mixins").Constructor<ICanChangeSelection> & import("../mixins").AbstractConstructor<ICanChangeSelection> & {
+declare const MIXIN_BASE: import("../mixins").Constructor<ISelectable> & import("../mixins").AbstractConstructor<ISelectable> & {
     new (hostElement: HTMLElement): {
         hostElement: HTMLElement;
     };
 };
-export declare abstract class FNodeBase extends MIXIN_BASE implements ICanChangeSelection, IHasHostElement {
+export declare abstract class FNodeBase extends MIXIN_BASE implements ISelectable, IHasHostElement {
     abstract fId: string;
     abstract fParentId: string | null | undefined;
     readonly stateChanges: FChannel;

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

@@ -31,4 +31,8 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, 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>;
+    static ngAcceptInputType_fDraggingDisabled: unknown;
+    static ngAcceptInputType_fSelectionDisabled: unknown;
+    static ngAcceptInputType_fIncludePadding: unknown;
+    static ngAcceptInputType_fConnectOnNode: unknown;
 }

package/f-node/f-resize-handle/e-f-resize-handle-type.d.ts

@@ -1,6 +1,10 @@
 export declare enum EFResizeHandleType {
+    LEFT = "left",
     LEFT_TOP = "left-top",
+    TOP = "top",
     RIGHT_TOP = "right-top",
-    LEFT_BOTTOM = "left-bottom",
-    RIGHT_BOTTOM = "right-bottom"
+    RIGHT = "right",
+    RIGHT_BOTTOM = "right-bottom",
+    BOTTOM = "bottom",
+    LEFT_BOTTOM = "left-bottom"
 }

package/f-node/providers.d.ts

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

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

@@ -1 +1,3 @@
-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)[];
+import { SelectionAreaPreparationExecution } from './selection-area-preparation';
+import { SelectionAreaFinalizeExecution } from './selection-area-finalize';
+export declare const F_SELECTION_AREA_DRAG_AND_DROP_PROVIDERS: (typeof SelectionAreaPreparationExecution | typeof SelectionAreaFinalizeExecution)[];

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

@@ -1,4 +1,2 @@
-export * from './providers';
 export * from './selection-area-finalize.execution';
 export * from './selection-area-finalize.request';
-export * from './selection-area-finalize.validator';

package/f-selection-area/domain/selection-area-finalize/selection-area-finalize.execution.d.ts

@@ -1,11 +1,10 @@
 import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaFinalizeExecution implements IExecution<SelectionAreaFinalizeRequest, void> {
-    private fDraggableDataContext;
-    constructor(fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
     handle(request: SelectionAreaFinalizeRequest): void;
+    private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaFinalizeExecution>;
 }

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

@@ -1,4 +1,2 @@
-export * from './providers';
 export * from './selection-area-preparation.execution';
 export * from './selection-area-preparation.request';
-export * from './selection-area-preparation.validator';