@foblex/flow 17.4.1 → 17.4.3

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

@@ -1,9 +1,11 @@
 import { IPoint } from '@foblex/2d';
 import { IFDragHandler } from '../f-drag-handler';
+import { Injector } from '@angular/core';
 export declare class FCanvasDragHandler implements IFDragHandler {
     fEventType: string;
-    private _fComponentsStore;
+    private readonly _fComponentsStore;
     private _onPointerDownPosition;
+    constructor(_injector: Injector);
     prepareDragSequence(): void;
     onPointerMove(difference: IPoint): void;
     onPointerUp(): void;

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

@@ -2,8 +2,9 @@ import { FCanvasMovePreparationRequest } from './f-canvas-move-preparation.reque
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FCanvasMovePreparationExecution implements IExecution<FCanvasMovePreparationRequest, void> {
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
     private get _fHost();
     handle(request: FCanvasMovePreparationRequest): void;
     private _isValid;

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

@@ -1,3 +1,3 @@
 import { FCanvasMovePreparationExecution } from './move-preparation';
 import { FCanvasMoveFinalizeExecution } from './move-finalize';
-export declare const CANVAS_PROVIDERS: (typeof FCanvasMoveFinalizeExecution | typeof FCanvasMovePreparationExecution)[];
+export declare const CANVAS_PROVIDERS: (typeof FCanvasMovePreparationExecution | typeof FCanvasMoveFinalizeExecution)[];

package/f-draggable/f-connection/f-create-connection/create-preparation/drag-handler-preparation/f-create-connection-drag-handler-preparation.execution.d.ts

@@ -2,8 +2,9 @@ import { IHandler } from '@foblex/mediator';
 import { FCreateConnectionDragHandlerPreparationRequest } from './f-create-connection-drag-handler-preparation.request';
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionDragHandlerPreparationExecution implements IHandler<FCreateConnectionDragHandlerPreparationRequest, void> {
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
     private get _fHost();
     private get _transform();
     handle(request: FCreateConnectionDragHandlerPreparationRequest): void;

package/f-draggable/f-connection/f-create-connection/f-create-connection.drag-handler.d.ts

@@ -1,19 +1,20 @@
 import { IFDragHandler } from '../../f-drag-handler';
 import { FNodeOutletBase, FNodeOutputBase } from '../../../f-connectors';
 import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
 export declare class FCreateConnectionDragHandler implements IFDragHandler {
     private _fOutputOrOutlet;
     fEventType: string;
     fData: any;
-    private _fResult;
-    private _fMediator;
-    private _fComponentsStore;
+    private readonly _fResult;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
     private readonly _toConnectorRect;
     private get _fConnection();
     private get _fSnapConnection();
     private _fOutputWithRect;
     private _canBeConnectedInputs;
-    constructor(_fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase, _onPointerDownPosition: IPoint);
+    constructor(_injector: Injector, _fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase, _onPointerDownPosition: IPoint);
     prepareDragSequence(): void;
     private _getAndMarkCanBeConnectedInputs;
     private _initializeSnapConnection;

package/f-draggable/f-connection/f-create-connection/get-first-connectable-output/get-first-connectable-output.execution.d.ts

@@ -3,7 +3,7 @@ import { FConnectorBase } from '../../../../f-connectors';
 import { GetFirstConnectableOutputRequest } from './get-first-connectable-output.request';
 import * as i0 from "@angular/core";
 export declare class GetFirstConnectableOutputExecution implements IHandler<GetFirstConnectableOutputRequest, FConnectorBase | undefined> {
-    private _fComponentStore;
+    private readonly _fComponentStore;
     private get _fNodes();
     private get _fOutputs();
     private _fNode;

package/f-draggable/f-connection/f-reassign-connection/f-reassign-connection.drag-handler.d.ts

@@ -1,13 +1,14 @@
 import { IFDragHandler } from '../../f-drag-handler';
 import { FConnectionBase } from '../../../f-connection';
 import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
 export declare class FReassignConnectionDragHandler implements IFDragHandler {
     private _fConnection;
     fEventType: string;
     fData: any;
-    private _fResult;
-    private _fMediator;
-    private _fComponentsStore;
+    private readonly _fResult;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
     private readonly _toConnectorRect;
     private get _fSnapConnection();
     private _fOutputWithRect;
@@ -15,7 +16,7 @@ export declare class FReassignConnectionDragHandler implements IFDragHandler {
     private _canBeConnectedInputs;
     private get _fOutput();
     private get _fInput();
-    constructor(_fConnection: FConnectionBase);
+    constructor(_injector: Injector, _fConnection: FConnectionBase);
     prepareDragSequence(): void;
     private _getAndMarkCanBeConnectedInputs;
     private _initializeSnapConnection;

package/f-draggable/f-connection/f-reassign-connection/reassign-preparation/f-reassign-connection-preparation.execution.d.ts

@@ -2,9 +2,10 @@ import { FReassignConnectionPreparationRequest } from './f-reassign-connection-p
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FReassignConnectionPreparationExecution implements IExecution<FReassignConnectionPreparationRequest, void> {
-    private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
     private _fConnection;
     private get _transform();
     private get _fHost();

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

@@ -1,3 +1,3 @@
 import { FCreateConnectionDragHandlerPreparationExecution, FCreateConnectionFinalizeExecution, FCreateConnectionFromOutletPreparationExecution, FCreateConnectionFromOutputPreparationExecution, FCreateConnectionPreparationExecution, GetFirstConnectableOutputExecution } from './f-create-connection';
 import { FReassignConnectionFinalizeExecution, FReassignConnectionPreparationExecution } from './f-reassign-connection';
-export declare const CONNECTIONS_PROVIDERS: (typeof GetFirstConnectableOutputExecution | typeof FCreateConnectionFinalizeExecution | typeof FCreateConnectionDragHandlerPreparationExecution | typeof FCreateConnectionFromOutletPreparationExecution | typeof FCreateConnectionFromOutputPreparationExecution | typeof FReassignConnectionFinalizeExecution | typeof FReassignConnectionPreparationExecution | typeof FCreateConnectionPreparationExecution)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof FCreateConnectionDragHandlerPreparationExecution | typeof FCreateConnectionFinalizeExecution | typeof FReassignConnectionPreparationExecution | typeof FReassignConnectionFinalizeExecution | typeof FCreateConnectionFromOutletPreparationExecution | typeof GetFirstConnectableOutputExecution | typeof FCreateConnectionFromOutputPreparationExecution | typeof FCreateConnectionPreparationExecution)[];

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

@@ -15,13 +15,13 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     private _fResult;
     private _fMediator;
     private _fPlatform;
-    private _injector;
     disabled: boolean;
     get hostElement(): HTMLElement;
     fMultiSelectTrigger: FEventTrigger;
     fReassignConnectionTrigger: FEventTrigger;
     fCreateConnectionTrigger: FEventTrigger;
     fNodeResizeTrigger: FEventTrigger;
+    fNodeRotateTrigger: FEventTrigger;
     fNodeMoveTrigger: FEventTrigger;
     fCanvasMoveTrigger: FEventTrigger;
     fExternalItemTrigger: FEventTrigger;
@@ -50,7 +50,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
     static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_fEmitOnNodeIntersect: unknown;
     static ngAcceptInputType_vCellSize: unknown;

package/f-draggable/f-drop-to-group/drop-to-group-preparation/f-node-drop-to-group-preparation.execution.d.ts

@@ -2,9 +2,10 @@ import { FNodeDropToGroupPreparationRequest } from './f-node-drop-to-group-prepa
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeDropToGroupPreparationExecution implements IExecution<FNodeDropToGroupPreparationRequest, void> {
-    private _fMediator;
-    private _fDraggableDataContext;
-    private _fComponentsStore;
+    private readonly _fMediator;
+    private readonly _fDraggableDataContext;
+    private readonly _fComponentsStore;
+    private readonly _injector;
     private get _fNodes();
     private get _transform();
     private get _fCanvasPosition();

package/f-draggable/f-drop-to-group/f-node-drop-to-group.drag-handler.d.ts

@@ -1,18 +1,19 @@
+import { Injector } from '@angular/core';
 import { IPoint } from '@foblex/2d';
 import { IFDragHandler } from '../f-drag-handler';
 import { INodeWithRect } from '../domain';
 import * as i0 from "@angular/core";
 export declare class FNodeDropToGroupDragHandler implements IFDragHandler {
     private notDraggedNodesRects;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
     fEventType: string;
     private _DEBOUNCE_TIME;
     private get _transform();
     private _onPointerDownPosition;
     private _debounceTimer;
     fNodeWithRect: INodeWithRect | null;
-    constructor(notDraggedNodesRects: INodeWithRect[]);
+    constructor(_injector: Injector, notDraggedNodesRects: INodeWithRect[]);
     private _toggleParentNode;
     private _getNewPosition;
     private _isNodeInsideAnotherNode;

package/f-draggable/f-drop-to-group/providers.d.ts

@@ -1,3 +1,3 @@
 import { FNodeDropToGroupPreparationExecution } from './drop-to-group-preparation';
 import { FNodeDropToGroupFinalizeExecution } from './drop-to-group-finalize';
-export declare const NODE_DROP_TO_GROUP_PROVIDERS: (typeof FNodeDropToGroupFinalizeExecution | typeof FNodeDropToGroupPreparationExecution)[];
+export declare const NODE_DROP_TO_GROUP_PROVIDERS: (typeof FNodeDropToGroupPreparationExecution | typeof FNodeDropToGroupFinalizeExecution)[];

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

@@ -1,16 +1,17 @@
 import { IPoint } from '@foblex/2d';
 import { FConnectionBase } from '../../../f-connection';
+import { Injector } from '@angular/core';
 export declare class BaseConnectionDragHandler {
     fConnection: FConnectionBase;
-    private _fMediator;
-    private _fComponentStore;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
     private _fOutputWithRect;
     private _fInputWithRect;
     private get _fOutput();
     private get _fInput();
     private _sourceDifference;
     private _targetDifference;
-    constructor(fConnection: FConnectionBase);
+    constructor(_injector: Injector, fConnection: FConnectionBase);
     private _initialize;
     setSourceDifference(difference: IPoint): void;
     setTargetDifference(difference: IPoint): void;

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

@@ -1,7 +1,8 @@
 import { BaseConnectionDragHandler } from './base-connection.drag-handler';
 import { FConnectionBase } from '../../../f-connection';
 import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
 export declare class SourceConnectionDragHandler extends BaseConnectionDragHandler {
-    constructor(fConnection: FConnectionBase);
+    constructor(injector: Injector, fConnection: FConnectionBase);
     setSourceDifference(difference: IPoint): void;
 }

package/f-draggable/f-node-move/connection-drag-handlers/source-target-connection.drag-handler.d.ts

@@ -1,9 +1,10 @@
 import { BaseConnectionDragHandler } from './base-connection.drag-handler';
 import { FConnectionBase } from '../../../f-connection';
 import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
 export declare class SourceTargetConnectionDragHandler extends BaseConnectionDragHandler {
-    private _callTracker;
-    constructor(fConnection: FConnectionBase);
+    private readonly _callTracker;
+    constructor(injector: Injector, fConnection: FConnectionBase);
     setSourceDifference(difference: IPoint): void;
     setTargetDifference(difference: IPoint): void;
     private _checkAndTriggerAction;

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

@@ -1,7 +1,8 @@
 import { FConnectionBase } from '../../../f-connection';
 import { BaseConnectionDragHandler } from './base-connection.drag-handler';
 import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
 export declare class TargetConnectionDragHandler extends BaseConnectionDragHandler {
-    constructor(fConnection: FConnectionBase);
+    constructor(injector: Injector, fConnection: FConnectionBase);
     setTargetDifference(difference: IPoint): void;
 }

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

@@ -3,9 +3,10 @@ import { IExecution } from '@foblex/mediator';
 import { FSummaryNodeMoveDragHandler } from '../f-summary-node-move.drag-handler';
 import * as i0 from "@angular/core";
 export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, FSummaryNodeMoveDragHandler> {
-    private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
     handle(request: CreateMoveNodesDragModelFromSelectionRequest): FSummaryNodeMoveDragHandler;
     private _getDraggedNodes;
     private _getNodesFromSelection;

package/f-draggable/f-node-move/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.execution.d.ts

@@ -2,7 +2,8 @@ import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class PutInputConnectionHandlersToArrayExecution implements IExecution<PutInputConnectionHandlersToArrayRequest, void> {
-    private _fComponentsStore;
+    private readonly _fComponentsStore;
+    private readonly _injector;
     private get _fConnections();
     handle(request: PutInputConnectionHandlersToArrayRequest): void;
     private _getInputConnections;

package/f-draggable/f-node-move/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.execution.d.ts

@@ -4,7 +4,8 @@ import { FNodeBase } from '../../../../../f-node';
 import { FConnectionBase } from '../../../../../f-connection';
 import * as i0 from "@angular/core";
 export declare class PutOutputConnectionHandlersToArrayExecution implements IExecution<PutOutputConnectionHandlersToArrayRequest, void> {
-    private _fComponentsStore;
+    private readonly _fComponentsStore;
+    private readonly _injector;
     private get _fConnections();
     handle(request: PutOutputConnectionHandlersToArrayRequest): void;
     _getOutputConnections(node: FNodeBase): FConnectionBase[];

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

@@ -3,4 +3,4 @@ import { CalculateNodeMoveLimitsExecution } from './domain/calculate-node-move-l
 import { PutInputConnectionHandlersToArrayExecution } from './domain/put-input-connection-handlers-to-array';
 import { PutOutputConnectionHandlersToArrayExecution } from './domain/put-output-connection-handlers-to-array';
 import { CalculateCommonNodeMoveLimitsExecution } from './domain/calculate-common-node-move-limits';
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateCommonNodeMoveLimitsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CalculateNodeMoveLimitsExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof PutOutputConnectionHandlersToArrayExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution | typeof CalculateCommonNodeMoveLimitsExecution | typeof CalculateNodeMoveLimitsExecution)[];

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

@@ -1,17 +1,18 @@
 import { IMinMaxPoint, IPoint, IRect, ISize } from '@foblex/2d';
 import { IFDragHandler } from '../index';
 import { ILineAlignmentResult, LineService } from '../../f-line-alignment';
+import { Injector } from '@angular/core';
 export declare class FLineAlignmentDragHandler implements IFDragHandler {
     private _lineService;
     private _size;
     private _draggedNodeRect;
     private _rects;
     private _restrictions;
-    fEventType: string;
-    private _fComponentsStore;
+    readonly fEventType = "line-alignment";
+    private readonly _fComponentsStore;
     private _debounceTimer;
     private readonly _transform;
-    constructor(_lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
+    constructor(_injector: Injector, _lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private _drawIntersectingLines;
     private _getDifference;

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

@@ -6,7 +6,7 @@ export declare class FNodeMoveDragHandler implements IFDragHandler {
     fNode: FNodeBase;
     fSourceHandlers: BaseConnectionDragHandler[];
     fTargetHandlers: BaseConnectionDragHandler[];
-    fEventType: string;
+    readonly fEventType = "move-node";
     private readonly _onPointerDownPosition;
     constructor(fNode: FNodeBase, fSourceHandlers?: BaseConnectionDragHandler[], fTargetHandlers?: BaseConnectionDragHandler[]);
     onPointerMove(difference: IPoint): void;

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

@@ -1,15 +1,16 @@
 import { IMinMaxPoint, IPoint, IRect } from '@foblex/2d';
 import { IFDragHandler } from '../f-drag-handler';
 import { FNodeMoveDragHandler } from './f-node-move.drag-handler';
+import { Injector } from '@angular/core';
 export declare class FSummaryNodeMoveDragHandler implements IFDragHandler {
     limits: IMinMaxPoint;
     fHandlers: FNodeMoveDragHandler[];
     commonRect: IRect;
-    fEventType: string;
-    fData: any;
-    private _fComponentStore;
+    readonly fEventType = "move-node";
+    readonly fData: any;
+    private readonly _fComponentStore;
     private readonly _fBoundsLimiter;
-    constructor(limits: IMinMaxPoint, fHandlers: FNodeMoveDragHandler[], commonRect: IRect);
+    constructor(_injector: Injector, limits: IMinMaxPoint, fHandlers: FNodeMoveDragHandler[], commonRect: IRect);
     onPointerMove(difference: IPoint): void;
     onPointerUp(): void;
     calculateRestrictedDifference(difference: IPoint): IPoint;

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

@@ -2,10 +2,11 @@ import { LineAlignmentPreparationRequest } from './line-alignment-preparation.re
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class LineAlignmentPreparationExecution implements IExecution<LineAlignmentPreparationRequest, void> {
-    private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
-    private _fBrowser;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _fBrowser;
+    private readonly _injector;
     private _lineService;
     handle(request: LineAlignmentPreparationRequest): void;
     private _addLineAlignmentDragHandler;

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

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

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)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof FNodeMoveFinalizeExecution | typeof FNodeMovePreparationExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateCommonNodeMoveLimitsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CalculateNodeMoveLimitsExecution | typeof LineAlignmentPreparationExecution)[];

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

@@ -1,6 +1,7 @@
 import { IRect } from '@foblex/2d';
+import { INodeResizeRestrictions } from '../get-node-resize-restrictions';
 export declare class ApplyChildResizeRestrictionsRequest {
     rect: IRect;
-    restrictionsRect: IRect;
-    constructor(rect: IRect, restrictionsRect: IRect);
+    restrictions: INodeResizeRestrictions;
+    constructor(rect: IRect, restrictions: INodeResizeRestrictions);
 }

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

@@ -1,15 +1,16 @@
 import { IPoint } from '@foblex/2d';
 import { IFDragHandler } from '../f-drag-handler';
 import { EFResizeHandleType, FNodeBase } from '../../f-node';
+import { Injector } from '@angular/core';
 export declare class FNodeResizeDragHandler implements IFDragHandler {
     private _fNode;
     private _fResizeHandleType;
-    fEventType: string;
-    fData: any;
-    private _fMediator;
+    readonly fEventType = "node-resize";
+    readonly fData: any;
+    private readonly _fMediator;
     private _originalRect;
     private _resizeRestrictions;
-    constructor(_fNode: FNodeBase, _fResizeHandleType: EFResizeHandleType);
+    constructor(_injector: Injector, _fNode: FNodeBase, _fResizeHandleType: EFResizeHandleType);
     prepareDragSequence(): void;
     private _getOriginalNodeRect;
     private _getNodeResizeRestrictions;

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

@@ -6,4 +6,4 @@ import { ApplyParentResizeRestrictionsExecution } from './apply-parent-resize-re
 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 FNodeResizeFinalizeExecution | typeof FNodeResizePreparationExecution)[];
+export declare const NODE_RESIZE_PROVIDERS: (typeof FNodeResizePreparationExecution | typeof FNodeResizeFinalizeExecution | typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution)[];

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

@@ -2,9 +2,10 @@ import { FNodeResizePreparationRequest } from './f-node-resize-preparation.reque
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeResizePreparationExecution implements IExecution<FNodeResizePreparationRequest, void> {
-    private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
     private get _transform();
     private get _fHost();
     private _fNode;

package/f-draggable/f-node-rotate/calculate-difference-after-rotation.d.ts

@@ -0,0 +1,20 @@
+export declare function calculateDifferenceAfterRotation(position: {
+    x: number;
+    y: number;
+}, rotation: number, pivot: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+export declare function calculatePositionAfterRotation(position: {
+    x: number;
+    y: number;
+}, rotation: number, pivot: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};

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

@@ -0,0 +1,35 @@
+import { IPoint } from '@foblex/2d';
+import { IFDragHandler } from '../f-drag-handler';
+import { FNodeBase } from '../../f-node';
+import { BaseConnectionDragHandler } from '../f-node-move';
+import { Injector } from '@angular/core';
+export declare class FNodeRotateDragHandler implements IFDragHandler {
+    private _fNode;
+    private _fSourceHandlers;
+    private _fTargetHandlers;
+    private readonly _fComponentsStore;
+    private readonly _fMediator;
+    private readonly _fDraggableDataContext;
+    fEventType: string;
+    fData: any;
+    private _initialRotationToX;
+    private readonly _startRotation;
+    private _onDownPoint;
+    private _fNodeRect;
+    private get _transform();
+    constructor(_injector: Injector, _fNode: FNodeBase, _fSourceHandlers: {
+        connection: BaseConnectionDragHandler;
+        connector: IPoint;
+    }[], _fTargetHandlers: {
+        connection: BaseConnectionDragHandler;
+        connector: IPoint;
+    }[]);
+    prepareDragSequence(): void;
+    private _getOriginalNodeRect;
+    private _calculateDownPoint;
+    private _calculateAngleBetweenVectors;
+    onPointerMove(difference: IPoint): void;
+    private _updateNodeRendering;
+    private _calculateDifferenceAfterRotation;
+    onPointerUp(): void;
+}

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

@@ -0,0 +1,4 @@
+export * from './rotate-finalize';
+export * from './rotate-preparation';
+export * from './f-node-rotate.drag-handler';
+export * from './providers';

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { IPointerEvent } from '@foblex/drag-toolkit';
+export declare class FNodeRotateFinalizeRequest {
+    event: IPointerEvent;
+    constructor(event: IPointerEvent);
+}

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

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

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

@@ -0,0 +1,23 @@
+import { FNodeRotatePreparationRequest } from './f-node-rotate-preparation.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FNodeRotatePreparationExecution implements IExecution<FNodeRotatePreparationRequest, void> {
+    private readonly _fMediator;
+    private readonly _fComponentsStore;
+    private readonly _fDraggableDataContext;
+    private readonly _injector;
+    private get _transform();
+    private get _fHost();
+    private _fNode;
+    handle(request: FNodeRotatePreparationRequest): void;
+    private _isValid;
+    private _isNodeCanBeDragged;
+    private _getNode;
+    private _isValidTrigger;
+    private _selectAndUpdateNodeLayer;
+    private _calculateInputConnectionsDragHandlers;
+    private _calculateOutputConnectionsDragHandlers;
+    private _getOriginalNodeRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeRotatePreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FNodeRotatePreparationExecution>;
+}

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

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

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

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

package/f-draggable/index.d.ts

@@ -5,11 +5,11 @@ export * from './f-drag-handler';
 export * from './f-drop-to-group';
 export * from './f-node-move';
 export * from './f-node-resize';
+export * from './f-node-rotate';
 export * from './f-single-select';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';
-export * from './f-injector';
 export * from './f-selection-change-event';
 export * from './i-f-drag-and-drop-plugin';
 export * from './providers';