@foblex/flow 17.7.0 → 17.7.1

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

@@ -7,18 +7,19 @@ export declare class FExternalItemDragHandler implements IFDragHandler {
     fEventType: string;
     fData: any;
     private readonly _fResult;
-    private readonly _fMediator;
-    private readonly _fBrowser;
-    private readonly _fComponentStore;
+    private readonly _mediator;
+    private readonly _browser;
+    private readonly _store;
     private _preview;
     private _placeholder;
     private _onPointerDownRect;
-    private readonly _fBoundsLimiter;
     private get _fItemHost();
     private get _body();
     private get _transform();
     private readonly _fItemHostDisplay;
-    constructor(_injector: Injector, _fExternalItem: FExternalItemBase);
+    private _applyConstraints;
+    constructor(injector: Injector, _fExternalItem: FExternalItemBase);
+    private _initializeConstraints;
     private _getStartPoint;
     prepareDragSequence(): void;
     private _createAndAppendPreview;

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

@@ -4,8 +4,8 @@ import * as i0 from "@angular/core";
 export declare class FExternalItemFinalizeExecution implements IExecution<FExternalItemFinalizeRequest, void> {
     private readonly _fResult;
     private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     private readonly _fBrowser;
     private get _fHost();
     private get _fCreateNode();

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

@@ -1,3 +1,4 @@
+export * from './constraint';
 export * from './create-placeholder';
 export * from './create-preview';
 export * from './finalize';

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

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

package/f-line-alignment/domain/{i-nearest-coordinate-result.d.ts → i-snap-coordinate.d.ts}

@@ -1,4 +1,4 @@
-export interface INearestCoordinateResult {
+export interface ISnapCoordinate {
     value: number | undefined;
     distance: number | undefined;
 }

package/f-line-alignment/domain/i-snap-result.d.ts

@@ -0,0 +1,5 @@
+import { ISnapCoordinate } from './i-snap-coordinate';
+export interface ISnapResult {
+    xResult: ISnapCoordinate;
+    yResult: ISnapCoordinate;
+}

package/f-line-alignment/domain/index.d.ts

@@ -1,5 +1,5 @@
 export * from './i-line-alignment-rect';
-export * from './i-line-alignment-result';
-export * from './i-nearest-coordinate-result';
-export * from './line-element';
-export * from './line-service';
+export * from './i-snap-result';
+export * from './i-snap-coordinate';
+export * from './snap-line-element';
+export * from './snap-line-service';

package/f-line-alignment/domain/{line-element.d.ts → snap-line-element.d.ts}

@@ -1,6 +1,6 @@
 import { ILineAlignmentRect } from './i-line-alignment-rect';
 import { BrowserService } from '@foblex/platform';
-export declare class LineElement {
+export declare class SnapLineElement {
     private readonly hostElement;
     private readonly element;
     constructor(fBrowser: BrowserService, hostElement: HTMLElement);

package/f-line-alignment/domain/{line-service.d.ts → snap-line-service.d.ts}

@@ -1,6 +1,6 @@
 import { ISize, ITransformModel } from '@foblex/2d';
 import { BrowserService } from '@foblex/platform';
-export declare class LineService {
+export declare class SnapLineService {
     private hostElement;
     private fHorizontalLine;
     private fVerticalLine;

package/f-minimap/domain/minimap-draw-nodes/minimap-draw-nodes.execution.d.ts

@@ -2,8 +2,8 @@ import { MinimapDrawNodesRequest } from './minimap-draw-nodes.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class MinimapDrawNodesExecution implements IExecution<MinimapDrawNodesRequest, SVGRectElement[]> {
-    private readonly _fBrowser;
-    private readonly _fComponentStore;
+    private readonly _browser;
+    private readonly _store;
     private get _fFlow();
     private get _fNodes();
     private get _fCanvas();

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-preparation").MinimapDragPreparationExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof MinimapDrawNodesExecution | typeof MinimapCalculateViewBoxExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution)[];
+export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof MinimapDrawNodesExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution | typeof MinimapCalculateViewBoxExecution)[];

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

@@ -1,42 +1,33 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
-import { IPoint, IRect, ISize } from '@foblex/2d';
+import { AfterViewInit, ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { IRect, ISize } from '@foblex/2d';
 import { FNodeBase } from './f-node-base';
-import { BrowserService } from '@foblex/platform';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FGroupDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
-    private renderer;
-    private fBrowser;
     private readonly _destroyRef;
-    private readonly _fMediator;
-    fId: import("@angular/core").InputSignal<string>;
-    fParentId: string | null | undefined;
-    set position(value: IPoint);
-    get position(): IPoint;
-    positionChange: EventEmitter<IPoint>;
-    set rotate(value: number);
-    get rotate(): number;
-    rotateChange: EventEmitter<number>;
-    set size(value: ISize);
-    get size(): ISize;
-    sizeChange: EventEmitter<IRect>;
-    fDraggingDisabled: boolean;
-    fSelectionDisabled: boolean;
-    fIncludePadding: boolean;
-    fConnectOnNode: boolean;
-    fMinimapClass: string[] | string;
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fBrowser: BrowserService);
+    private readonly _mediator;
+    readonly fId: import("@angular/core").InputSignal<string>;
+    readonly fParentId: import("@angular/core").InputSignal<string | null | undefined>;
+    readonly position: import("@angular/core").ModelSignal<import("@foblex/2d").IPoint>;
+    readonly size: import("@angular/core").InputSignal<ISize | undefined>;
+    sizeChange: import("@angular/core").OutputEmitterRef<IRect>;
+    readonly rotate: import("@angular/core").ModelSignal<number>;
+    readonly fConnectOnNode: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fMinimapClass: import("@angular/core").InputSignal<string | string[]>;
+    readonly fDraggingDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fSelectionDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fIncludePadding: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fAutoExpandOnChildHit: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fAutoSizeToFitChildren: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
+    protected removeStyle(styleName: string): void;
     redraw(): void;
     ngAfterViewInit(): void;
     private _listenStateSizeChanges;
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fGroupParentId"; "required": false; }; "position": { "alias": "fGroupPosition"; "required": false; }; "rotate": { "alias": "fGroupRotate"; "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; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; }; }, { "positionChange": "fGroupPositionChange"; "rotateChange": "fGroupRotateChange"; "sizeChange": "fGroupSizeChange"; }, never, never, false, never>;
-    static ngAcceptInputType_fDraggingDisabled: unknown;
-    static ngAcceptInputType_fSelectionDisabled: unknown;
-    static ngAcceptInputType_fIncludePadding: unknown;
-    static ngAcceptInputType_fConnectOnNode: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fGroupParentId"; "required": false; "isSignal": true; }; "position": { "alias": "fGroupPosition"; "required": false; "isSignal": true; }; "size": { "alias": "fGroupSize"; "required": false; "isSignal": true; }; "rotate": { "alias": "fGroupRotate"; "required": false; "isSignal": true; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; "isSignal": true; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fGroupDraggingDisabled"; "required": false; "isSignal": true; }; "fSelectionDisabled": { "alias": "fGroupSelectionDisabled"; "required": false; "isSignal": true; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; "isSignal": true; }; "fAutoExpandOnChildHit": { "alias": "fAutoExpandOnChildHit"; "required": false; "isSignal": true; }; "fAutoSizeToFitChildren": { "alias": "fAutoSizeToFitChildren"; "required": false; "isSignal": true; }; }, { "position": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; "rotate": "fGroupRotateChange"; }, never, never, false, never>;
 }

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

@@ -1,9 +1,10 @@
-import { EventEmitter, InjectionToken, Signal } from '@angular/core';
+import { InjectionToken, InputSignal, ModelSignal, OutputEmitterRef, Renderer2, Signal } from '@angular/core';
 import { IPoint, IRect, ISize } from '@foblex/2d';
 import { FConnectorBase } from '../f-connectors';
 import { IHasHostElement } from '../i-has-host-element';
 import { ISelectable } from '../mixins';
 import { FChannel } from '../reactivity';
+import { BrowserService } from "@foblex/platform";
 export declare const F_NODE: InjectionToken<FNodeBase>;
 declare const MIXIN_BASE: import("../mixins").Constructor<ISelectable> & import("../mixins").AbstractConstructor<ISelectable> & {
     new (hostElement: HTMLElement): {
@@ -11,29 +12,37 @@ declare const MIXIN_BASE: import("../mixins").Constructor<ISelectable> & import(
     };
 };
 export declare abstract class FNodeBase extends MIXIN_BASE implements ISelectable, IHasHostElement {
+    private readonly _injector;
+    protected readonly renderer: Renderer2;
+    protected readonly browser: BrowserService;
     abstract fId: Signal<string>;
-    abstract fParentId: string | null | undefined;
+    abstract fParentId: Signal<string | null | undefined>;
     readonly stateChanges: FChannel;
-    abstract positionChange: EventEmitter<IPoint>;
-    abstract position: IPoint;
-    protected _position: IPoint;
-    abstract rotateChange: EventEmitter<number>;
-    abstract rotate: number;
-    protected _rotate: number;
-    abstract sizeChange: EventEmitter<IRect>;
-    abstract size: ISize;
-    protected _size: ISize | undefined;
-    abstract fMinimapClass: string[] | string;
-    abstract fDraggingDisabled: boolean;
-    abstract fSelectionDisabled: boolean;
-    abstract fConnectOnNode: boolean;
-    fCanBeResizedByChild: boolean;
-    abstract fIncludePadding: boolean;
+    abstract position: ModelSignal<IPoint>;
+    _position: IPoint;
+    abstract rotate: ModelSignal<number>;
+    _rotate: number;
+    abstract sizeChange: OutputEmitterRef<IRect>;
+    abstract size: InputSignal<ISize | undefined>;
+    _size: ISize | undefined;
+    abstract fConnectOnNode: Signal<boolean>;
+    abstract fMinimapClass: Signal<string[] | string>;
+    abstract fDraggingDisabled: Signal<boolean>;
+    abstract fAutoExpandOnChildHit: Signal<boolean>;
+    abstract fAutoSizeToFitChildren: Signal<boolean>;
+    abstract fIncludePadding: Signal<boolean>;
     abstract refresh(): void;
     connectors: FConnectorBase[];
+    protected positionChanges(): void;
+    protected sizeChanges(): void;
+    protected rotateChanges(): void;
+    protected parentChanges(): void;
+    private _isSizeEqual;
     protected abstract setStyle(name: string, value: string): void;
+    protected abstract removeStyle(name: string): void;
     isContains(element: HTMLElement | SVGElement): boolean;
     redraw(): void;
+    resetSize(): void;
     updatePosition(position: IPoint): void;
     updateRotate(rotate: number): void;
     updateSize(value: ISize): void;

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

@@ -1,42 +1,33 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
-import { IPoint, IRect, ISize } from '@foblex/2d';
-import { BrowserService } from '@foblex/platform';
+import { AfterViewInit, ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { IRect, ISize } from '@foblex/2d';
 import { FNodeBase } from './f-node-base';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
-    private renderer;
-    private fBrowser;
     private readonly _destroyRef;
-    private readonly _fMediator;
-    fId: import("@angular/core").InputSignal<string>;
-    fParentId: string | null | undefined;
-    set position(value: IPoint);
-    get position(): IPoint;
-    positionChange: EventEmitter<IPoint>;
-    set size(value: ISize);
-    set rotate(value: number);
-    get rotate(): number;
-    rotateChange: EventEmitter<number>;
-    get size(): ISize;
-    sizeChange: EventEmitter<IRect>;
-    fDraggingDisabled: boolean;
-    fSelectionDisabled: boolean;
-    fIncludePadding: boolean;
-    fConnectOnNode: boolean;
-    fMinimapClass: string[] | string;
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fBrowser: BrowserService);
+    private readonly _mediator;
+    readonly fId: import("@angular/core").InputSignal<string>;
+    readonly fParentId: import("@angular/core").InputSignal<string | null | undefined>;
+    readonly position: import("@angular/core").ModelSignal<import("@foblex/2d").IPoint>;
+    readonly size: import("@angular/core").InputSignal<ISize | undefined>;
+    sizeChange: import("@angular/core").OutputEmitterRef<IRect>;
+    readonly rotate: import("@angular/core").ModelSignal<number>;
+    readonly fConnectOnNode: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fMinimapClass: import("@angular/core").InputSignal<string | string[]>;
+    readonly fDraggingDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fSelectionDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fIncludePadding: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fAutoExpandOnChildHit: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly fAutoSizeToFitChildren: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
+    protected removeStyle(styleName: string): void;
     redraw(): void;
     ngAfterViewInit(): void;
     private _listenStateSizeChanges;
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fNodeParentId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "size": { "alias": "fNodeSize"; "required": false; }; "rotate": { "alias": "fNodeRotate"; "required": false; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; }; }, { "positionChange": "fNodePositionChange"; "rotateChange": "fNodeRotateChange"; "sizeChange": "fNodeSizeChange"; }, never, never, false, never>;
-    static ngAcceptInputType_fDraggingDisabled: unknown;
-    static ngAcceptInputType_fSelectionDisabled: unknown;
-    static ngAcceptInputType_fIncludePadding: unknown;
-    static ngAcceptInputType_fConnectOnNode: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fNodeParentId"; "required": false; "isSignal": true; }; "position": { "alias": "fNodePosition"; "required": false; "isSignal": true; }; "size": { "alias": "fNodeSize"; "required": false; "isSignal": true; }; "rotate": { "alias": "fNodeRotate"; "required": false; "isSignal": true; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; "isSignal": true; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; "isSignal": true; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; "isSignal": true; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; "isSignal": true; }; "fAutoExpandOnChildHit": { "alias": "fAutoExpandOnChildHit"; "required": false; "isSignal": true; }; "fAutoSizeToFitChildren": { "alias": "fAutoSizeToFitChildren"; "required": false; "isSignal": true; }; }, { "position": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; "rotate": "fNodeRotateChange"; }, never, never, false, never>;
 }

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

@@ -1,7 +1,7 @@
 import { EFResizeHandleType } from './e-f-resize-handle-type';
 import * as i0 from "@angular/core";
 export declare class FResizeHandleDirective {
-    type: import("@angular/core").InputSignalWithTransform<EFResizeHandleType, unknown>;
+    type: import("@angular/core").InputSignalWithTransform<EFResizeHandleType, any>;
     protected class: import("@angular/core").Signal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FResizeHandleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;

package/f-node/providers.d.ts

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

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

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

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

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

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

@@ -3,8 +3,8 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaPreparationExecution implements IExecution<SelectionAreaPreparationRequest, void> {
     private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private _store;
+    private _dragContext;
     private get _fHost();
     handle(request: SelectionAreaPreparationRequest): void;
     private _isValid;

package/f-selection-area/domain/selection-area.drag-handle.d.ts

@@ -4,15 +4,15 @@ import { FMediator } from '@foblex/mediator';
 import { FDraggableDataContext, IFDragHandler } from '../../f-draggable';
 import { FSelectionAreaBase } from '../f-selection-area-base';
 export declare class SelectionAreaDragHandle implements IFDragHandler {
-    private _fComponentsStore;
+    private _store;
     private _fSelectionArea;
-    private _fDraggableDataContext;
+    private _dragContext;
     private _fMediator;
     fEventType: string;
     private _canBeSelected;
     private _selectedByMove;
     private get _fCanvasPosition();
-    constructor(_fComponentsStore: FComponentsStore, _fSelectionArea: FSelectionAreaBase, _fDraggableDataContext: FDraggableDataContext, _fMediator: FMediator);
+    constructor(_store: FComponentsStore, _fSelectionArea: FSelectionAreaBase, _dragContext: FDraggableDataContext, _fMediator: FMediator);
     prepareDragSequence(): void;
     onPointerMove(difference: IPoint): void;
     private _getMinimumPoint;

package/f-storage/features/listen-components-data-changed/listen-data-changes.execution.d.ts

@@ -3,7 +3,7 @@ import { ListenDataChangesRequest } from './listen-data-changes-request';
 import { FChannelHub } from '../../../reactivity';
 import * as i0 from "@angular/core";
 export declare class ListenDataChangesExecution implements IExecution<ListenDataChangesRequest, FChannelHub> {
-    private _fComponentsStore;
+    private _store;
     handle(request: ListenDataChangesRequest): FChannelHub;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListenDataChangesExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ListenDataChangesExecution>;

package/f-storage/features/listen-count-changes/listen-count-changes.execution.d.ts

@@ -3,7 +3,7 @@ import { ListenCountChangesRequest } from './listen-count-changes-request';
 import { FChannelHub } from '../../../reactivity';
 import * as i0 from "@angular/core";
 export declare class ListenCountChangesExecution implements IExecution<ListenCountChangesRequest, FChannelHub> {
-    private _fComponentsStore;
+    private _store;
     handle(request: ListenCountChangesRequest): FChannelHub;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListenCountChangesExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ListenCountChangesExecution>;

package/f-storage/features/listen-transform-changes/listen-transform-changes.execution.d.ts

@@ -3,7 +3,7 @@ import { IExecution } from '@foblex/mediator';
 import { FChannelHub } from '../../../reactivity';
 import * as i0 from "@angular/core";
 export declare class ListenTransformChangesExecution implements IExecution<ListenTransformChangesRequest, FChannelHub> {
-    private _fComponentsStore;
+    private _store;
     handle(request: ListenTransformChangesRequest): FChannelHub;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListenTransformChangesExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ListenTransformChangesExecution>;

package/f-storage/features/notify-data-changed/notify-data-changed.execution.d.ts

@@ -2,7 +2,7 @@ import { IExecution } from '@foblex/mediator';
 import { NotifyDataChangedRequest } from './notify-data-changed-request';
 import * as i0 from "@angular/core";
 export declare class NotifyDataChangedExecution implements IExecution<NotifyDataChangedRequest, void> {
-    private _fComponentsStore;
+    private _store;
     handle(request: NotifyDataChangedRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NotifyDataChangedExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NotifyDataChangedExecution>;

package/f-storage/features/notify-transform-changed/notify-transform-changed.execution.d.ts

@@ -2,7 +2,7 @@ import { NotifyTransformChangedRequest } from './notify-transform-changed.reques
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class NotifyTransformChangedExecution implements IExecution<NotifyTransformChangedRequest, void> {
-    private _fComponentsStore;
+    private _store;
     handle(request: NotifyTransformChangedRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NotifyTransformChangedExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NotifyTransformChangedExecution>;