@foblex/flow 17.7.1 → 17.8.1

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

@@ -1,12 +1,11 @@
-import { EventEmitter, InputSignal } from '@angular/core';
+import { EventEmitter, InputSignalWithTransform } from '@angular/core';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FCreateNodeEvent } from '../f-external-item';
 import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import { FDropToGroupEvent } from './f-drop-to-group';
-import { DragAndDropBase, ICanRunOutsideAngular } from "../drag-toolkit";
-import { FMoveNodesEvent } from "./f-node-move";
-import * as i0 from "@angular/core";
+import { DragAndDropBase, ICanRunOutsideAngular } from '../drag-toolkit';
+import { FMoveNodesEvent } from './f-node-move';
 export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     abstract fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
@@ -16,12 +15,10 @@ export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     abstract fDropToGroup: EventEmitter<FDropToGroupEvent>;
-    abstract vCellSize: InputSignal<number>;
-    abstract hCellSize: InputSignal<number>;
-    abstract fCellSizeWhileDragging: InputSignal<boolean>;
+    abstract vCellSize: InputSignalWithTransform<number, unknown>;
+    abstract hCellSize: InputSignalWithTransform<number, unknown>;
+    abstract fCellSizeWhileDragging: InputSignalWithTransform<boolean, unknown>;
     abstract fDragStarted: EventEmitter<FDragStartedEvent>;
     abstract fDragEnded: EventEmitter<void>;
-    protected constructor(ngZone: ICanRunOutsideAngular | undefined);
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
+    protected constructor(ngZone: ICanRunOutsideAngular | null);
 }

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

@@ -1,23 +1,21 @@
-import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FDraggableBase } from './f-draggable-base';
 import { FMoveNodesEvent } from './f-node-move';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
-import { BrowserService } from '@foblex/platform';
 import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import { FDropToGroupEvent } from './f-drop-to-group';
-import { ICanRunOutsideAngular, IPointerEvent } from "../drag-toolkit";
+import { IPointerEvent } from '../drag-toolkit';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
-    private _fBrowser;
-    private readonly _elementReference;
-    private readonly _fResult;
+    readonly hostElement: any;
+    private readonly _result;
     private readonly _mediator;
     private readonly _platform;
+    private readonly _browser;
     disabled: boolean;
-    get hostElement(): HTMLElement;
     fMultiSelectTrigger: FEventTrigger;
     fReassignConnectionTrigger: FEventTrigger;
     fCreateConnectionTrigger: FEventTrigger;
@@ -39,24 +37,24 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
      * This value is used to snap nodes to a vertical grid while dragging.
      * The default value is `1`, which means that nodes will snap to every pixel vertically.
      */
-    vCellSize: import("@angular/core").InputSignalWithTransform<number, any>;
+    vCellSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
     /**
      * Defines the horizontal cell size for the grid.
      * This value is used to snap nodes to a horizontal grid while dragging.
      * The default value is `1`, which means that nodes will snap to every pixel horizontally.
      */
-    hCellSize: import("@angular/core").InputSignalWithTransform<number, any>;
+    hCellSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
     /**
      * Defines whether the cell size should be applied while dragging.
      * If set to `true`, the dragged nodes will snap to the grid defined by `vCellSize` and `hCellSize`.
      * If set to `false`, the nodes will move freely without snapping to the grid.
      */
-    fCellSizeWhileDragging: import("@angular/core").InputSignalWithTransform<boolean, any>;
+    fCellSizeWhileDragging: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     fDragStarted: EventEmitter<FDragStartedEvent>;
     fDragEnded: EventEmitter<void>;
     private _beforePlugins;
     private _afterPlugins;
-    constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
+    constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
     onPointerDown(event: IPointerEvent): boolean;
@@ -66,7 +64,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     onPointerUp(event: IPointerEvent): void;
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, 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; "isSignal": true; }; "hCellSize": { "alias": "hCellSize"; "required": false; "isSignal": true; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; "isSignal": true; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
     static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_fEmitOnNodeIntersect: unknown;

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

@@ -2,17 +2,15 @@ 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 containersForDrop;
+    private _containersForDrop;
     private readonly _store;
     fEventType: string;
-    private _DEBOUNCE_TIME;
     private get _transform();
     private _onPointerDownPosition;
     private _debounceTimer;
     fNodeWithRect: INodeWithRect | null;
-    constructor(_injector: Injector, containersForDrop: INodeWithRect[]);
+    constructor(injector: Injector, _containersForDrop: INodeWithRect[]);
     prepareDragSequence(): void;
     private _toggleParentNode;
     private _getNewPosition;
@@ -21,6 +19,4 @@ export declare class FNodeDropToGroupDragHandler implements IFDragHandler {
     private _markIncludeNode;
     private _unmarkIncludeNode;
     onPointerUp(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDropToGroupDragHandler, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDropToGroupDragHandler, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -5,4 +5,4 @@ import { BuildDragHierarchy } from "./build-drag-hierarchy";
 import { CalculateDragLimits } from "./calculate-drag-limits";
 import { CreateSummaryDragHandler } from "./create-summary-drag-handler";
 import { GetNodeBoundingIncludePaddings } from "./get-node-bounding-include-paddings";
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof BuildDragHierarchy | typeof CalculateDragLimits | typeof CreateSummaryDragHandler | typeof CreateInputConnectionHandlerAndSetToNodeHandler | typeof CreateOutputConnectionHandlerAndSetToNodeHandler | typeof GetNodeBoundingIncludePaddings | typeof CreateDragModelFromSelection)[];
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateDragLimits | typeof BuildDragHierarchy | typeof CreateSummaryDragHandler | typeof CreateInputConnectionHandlerAndSetToNodeHandler | typeof CreateOutputConnectionHandlerAndSetToNodeHandler | typeof GetNodeBoundingIncludePaddings | typeof CreateDragModelFromSelection)[];

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

@@ -1,4 +1,4 @@
 import { FNodeMoveFinalizeExecution } from './move-finalize';
 import { FNodeMovePreparationExecution } from './move-preparation';
 import { CreateSnapLines } from './create-snap-lines';
-export declare const NODE_PROVIDERS: (typeof import("./create-drag-model-from-selection").BuildDragHierarchy | typeof import("./create-drag-model-from-selection").CalculateDragLimits | typeof import("./create-drag-model-from-selection").CreateSummaryDragHandler | typeof import("./create-drag-model-from-selection").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").GetNodeBoundingIncludePaddings | typeof import("./create-drag-model-from-selection").CreateDragModelFromSelection | typeof CreateSnapLines | typeof FNodeMoveFinalizeExecution | typeof FNodeMovePreparationExecution)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-drag-model-from-selection").CalculateDragLimits | typeof import("./create-drag-model-from-selection").BuildDragHierarchy | typeof import("./create-drag-model-from-selection").CreateSummaryDragHandler | typeof import("./create-drag-model-from-selection").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./create-drag-model-from-selection").GetNodeBoundingIncludePaddings | typeof import("./create-drag-model-from-selection").CreateDragModelFromSelection | typeof CreateSnapLines | typeof FNodeMoveFinalizeExecution | typeof FNodeMovePreparationExecution)[];

package/f-draggable/f-node-resize/apply-parent-resize-constraints/apply-parent-resize-constraints.d.ts

@@ -17,12 +17,12 @@ export declare class ApplyParentResizeConstraints implements IExecution<ApplyPar
     /** Clamps the rect inside the given innerRect. Mutates the rect directly. */
     private _clampRectToInner;
     /** Iterates over all soft limits and applies expansion if overflow is detected. */
-    private applySoftParentExpansions;
+    private _applySoftParentExpansions;
     /**
      * If the child overflows the parent's innerRect, calculate a new parent rect
      * based on the original boundingRect and apply it. Otherwise, reset to original.
      */
-    private expandParentFromOriginalIfOverflow;
+    private _expandParentFromOriginalIfOverflow;
     /** Returns true if any overflow exists. */
     private _hasOverflow;
     /** Computes overflow values for each side relative to innerRect. */

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

@@ -3,7 +3,7 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class NodeResizeFinalize implements IExecution<NodeResizeFinalizeRequest, void> {
     private readonly _dragContext;
-    handle(request: NodeResizeFinalizeRequest): void;
+    handle(_request: NodeResizeFinalizeRequest): void;
     private _isNodeResizeHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizeFinalize, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizeFinalize>;

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

@@ -8,7 +8,7 @@ export declare class FNodeRotateDragHandler implements IFDragHandler {
     private _fSourceHandlers;
     private _fTargetHandlers;
     private readonly _store;
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _dragContext;
     fEventType: string;
     fData: any;

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

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

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

@@ -2,7 +2,7 @@ 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 _dragContext;
+    private readonly _draggableDataContext;
     handle(request: FNodeRotateFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeRotateFinalizeExecution, never>;

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

@@ -2,7 +2,7 @@ import { FNodeRotatePreparationRequest } from './f-node-rotate-preparation.reque
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeRotatePreparationExecution implements IExecution<FNodeRotatePreparationRequest, void> {
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _store;
     private readonly _dragContext;
     private readonly _injector;

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-node-resize").ApplyChildResizeConstraints | typeof import("./f-node-resize").ApplyParentResizeConstraints | typeof import("./f-node-resize").CalculateChangedRectFromDifference | typeof import("./f-node-resize").CalculateDirectChildrenUnionRect | typeof import("./f-node-resize").CalculateResizeLimits | typeof import("./f-node-resize").NodeResizeFinalize | typeof import("./f-node-resize").NodeResizePreparation | typeof import("./f-drop-to-group").SortContainersForDropByLayer | typeof import("./f-drop-to-group").DropToGroupPreparation | typeof import("./f-drop-to-group").DropToGroupFinalize | typeof import("./f-node-move").BuildDragHierarchy | typeof import("./f-node-move").CalculateDragLimits | typeof import("./f-node-move").CreateSummaryDragHandler | typeof import("./f-node-move").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").GetNodeBoundingIncludePaddings | typeof import("./f-node-move").CreateDragModelFromSelection | typeof import("./f-node-move").CreateSnapLines | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-node-move").CalculateDragLimits | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./f-node-move").BuildDragHierarchy | typeof import("./f-node-move").CreateSummaryDragHandler | typeof import("./f-node-move").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").GetNodeBoundingIncludePaddings | typeof import("./f-node-move").CreateDragModelFromSelection | typeof import("./f-node-move").CreateSnapLines | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-drop-to-group").SortContainersForDropByLayer | typeof import("./f-drop-to-group").DropToGroupPreparation | typeof import("./f-drop-to-group").DropToGroupFinalize | typeof import("./f-node-resize").ApplyChildResizeConstraints | typeof import("./f-node-resize").ApplyParentResizeConstraints | typeof import("./f-node-resize").CalculateChangedRectFromDifference | typeof import("./f-node-resize").CalculateDirectChildrenUnionRect | typeof import("./f-node-resize").CalculateResizeLimits | typeof import("./f-node-resize").NodeResizeFinalize | typeof import("./f-node-resize").NodeResizePreparation | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];

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

@@ -16,7 +16,7 @@ export declare class FExternalItemFinalizeExecution implements IExecution<FExter
     private _getDropToGroupHandler;
     private _getElementsFromPoint;
     private _emitEvent;
-    private isPointerInCanvasRect;
+    private _isPointerInCanvasRect;
     private _getPreviewRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemFinalizeExecution>;

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

@@ -1,14 +1,14 @@
 import { TemplateRef } from '@angular/core';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
-export declare abstract class FExternalItemBase<TData = any> implements IHasHostElement {
+export declare abstract class FExternalItemBase<TData = unknown> implements IHasHostElement {
     abstract fExternalItemId: string;
     abstract hostElement: HTMLElement | SVGElement;
     abstract fData: TData | undefined;
     abstract fDisabled: boolean;
-    abstract fPreview: TemplateRef<any> | undefined;
+    abstract fPreview: TemplateRef<unknown> | undefined;
     abstract fPreviewMatchSize: boolean;
-    abstract fPlaceholder: TemplateRef<any> | undefined;
+    abstract fPlaceholder: TemplateRef<unknown> | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -1,6 +1,6 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class FExternalItemPlaceholderDirective<T = any> implements OnInit, OnDestroy {
+export declare class FExternalItemPlaceholderDirective<T = unknown> implements OnInit, OnDestroy {
     private readonly _fExternalItem;
     private readonly _templateRef;
     ngOnInit(): void;

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

@@ -1,6 +1,6 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class FExternalItemPreviewDirective<T = any> implements OnInit, OnDestroy {
+export declare class FExternalItemPreviewDirective<T = unknown> implements OnInit, OnDestroy {
     private readonly _fExternalItem;
     private readonly _templateRef;
     ngOnInit(): void;

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

@@ -1,3 +1,3 @@
 import { InjectionToken } from '@angular/core';
 import { FExternalItemBase } from './f-external-item-base';
-export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
+export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<unknown>>;

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

@@ -2,17 +2,16 @@ import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
 import { FExternalItemBase } from './f-external-item-base';
 import * as i0 from "@angular/core";
 export declare class FExternalItemDirective<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
-    private readonly _elementReference;
-    private readonly _fExternalItemService;
+    hostElement: HTMLElement;
+    private readonly _externalItemService;
     fExternalItemId: string;
-    get hostElement(): HTMLElement | SVGElement;
     fData: TData | undefined;
     fDisabled: boolean;
-    fPreview: TemplateRef<any> | undefined;
+    fPreview: TemplateRef<unknown> | undefined;
     fPreviewMatchSize: boolean;
-    fPlaceholder: TemplateRef<any> | undefined;
+    fPlaceholder: TemplateRef<unknown> | undefined;
     ngOnInit(): void;
-    private disablePointerEvents;
+    private _disablePointerEvents;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": { "alias": "fExternalItemId"; "required": false; }; "fData": { "alias": "fData"; "required": false; }; "fDisabled": { "alias": "fDisabled"; "required": false; }; "fPreview": { "alias": "fPreview"; "required": false; }; "fPreviewMatchSize": { "alias": "fPreviewMatchSize"; "required": false; }; "fPlaceholder": { "alias": "fPlaceholder"; "required": false; }; }, {}, never, never, true, never>;

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

@@ -1,7 +1,7 @@
 import { FExternalItemBase } from './f-external-item-base';
 import * as i0 from "@angular/core";
 export declare class FExternalItemService {
-    private _items;
+    private readonly _items;
     registerItem(item: FExternalItemBase): void;
     getItem(element: HTMLElement | SVGElement): FExternalItemBase | undefined;
     removeItem(item: FExternalItemBase): void;

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

@@ -1,9 +1,8 @@
 import { ILineAlignmentRect } from './i-line-alignment-rect';
 import { BrowserService } from '@foblex/platform';
 export declare class SnapLineElement {
-    private readonly hostElement;
-    private readonly element;
-    constructor(fBrowser: BrowserService, hostElement: HTMLElement);
+    private readonly _element;
+    constructor(browser: BrowserService, hostElement: HTMLElement);
     hide(): void;
     show(): void;
     draw(object: Partial<ILineAlignmentRect>): void;

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

@@ -1,10 +1,9 @@
 import { ISize, ITransformModel } from '@foblex/2d';
 import { BrowserService } from '@foblex/platform';
 export declare class SnapLineService {
-    private hostElement;
-    private fHorizontalLine;
-    private fVerticalLine;
-    constructor(fBrowser: BrowserService, hostElement: HTMLElement);
+    private readonly _horizontalLine;
+    private readonly _verticalLine;
+    constructor(browser: BrowserService, hostElement: HTMLElement);
     drawVerticalLine(x: number, size: ISize, transform: ITransformModel): void;
     drawHorizontalLine(y: number, size: ISize, transform: ITransformModel): void;
     hideVerticalLine(): void;

package/f-minimap/domain/calculate-flow-point-from-minimap-point/calculate-flow-point-from-minimap-point.execution.d.ts

@@ -1,18 +1,16 @@
 import { IPoint, Point } from '@foblex/2d';
 import { CalculateFlowPointFromMinimapPointRequest } from './calculate-flow-point-from-minimap-point.request';
-import { FComponentsStore } from '../../../f-storage';
 import { IExecution } from '@foblex/mediator';
 import { FMinimapData } from '../f-minimap-data';
 import * as i0 from "@angular/core";
 export declare class CalculateFlowPointFromMinimapPointExecution implements IExecution<CalculateFlowPointFromMinimapPointRequest, IPoint> {
-    private fComponentsStore;
-    private get canvasScale();
-    constructor(fComponentsStore: FComponentsStore);
+    private readonly _store;
+    private get _canvasScale();
     handle(payload: CalculateFlowPointFromMinimapPointRequest): IPoint;
-    private getNormalizedFlowCenter;
-    private getPositionInViewBox;
+    private _getNormalizedFlowCenter;
+    private _getPositionInViewBox;
     normalizeEventPoint(point: IPoint, minimap: FMinimapData): Point;
-    private getEventPointInMinimap;
+    private _getEventPointInMinimap;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateFlowPointFromMinimapPointExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateFlowPointFromMinimapPointExecution>;
 }

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

@@ -4,18 +4,18 @@ import { IFDragHandler } from '../../f-draggable';
 import { FMediator } from '@foblex/mediator';
 import { FMinimapData } from './f-minimap-data';
 export declare class FMinimapDragHandler implements IFDragHandler {
-    private fComponentsStore;
-    private fMediator;
-    private flowRect;
-    private canvasPosition;
-    private eventPoint;
-    private minimap;
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _flowRect;
+    private readonly _canvasPosition;
+    private readonly _eventPoint;
+    private readonly _minimap;
     fEventType: string;
-    private lastDifference;
-    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
+    private _lastDifference;
+    constructor(_store: FComponentsStore, _mediator: FMediator, _flowRect: IRect, _canvasPosition: IPoint, _eventPoint: IPoint, _minimap: FMinimapData);
     prepareDragSequence(): void;
     onPointerMove(difference: IPoint): void;
-    private isSamePoint;
-    private getNewPosition;
+    private _isSamePoint;
+    private _getNewPosition;
     onPointerUp(): void;
 }

package/f-minimap/domain/minimap-calculate-view-box/minimap-calculate-view-box.execution.d.ts

@@ -3,9 +3,9 @@ import { IExecution } from '@foblex/mediator';
 import { IRect } from '@foblex/2d';
 import * as i0 from "@angular/core";
 export declare class MinimapCalculateViewBoxExecution implements IExecution<MinimapCalculateViewBoxRequest, IRect> {
-    private _fComponentStore;
-    private get _fFlow();
-    private get _fCanvas();
+    private readonly _store;
+    private get _flowComponent();
+    private get _canvasComponent();
     handle(request: MinimapCalculateViewBoxRequest): IRect;
     private _getRectForMinimapView;
     private _calculateViewBox;

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

@@ -1,10 +1,8 @@
 import { MinimapDragFinalizeRequest } from './minimap-drag-finalize.request';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class MinimapDragFinalizeExecution implements IExecution<MinimapDragFinalizeRequest, void> {
-    private fDraggableDataContext;
-    constructor(fDraggableDataContext: FDraggableDataContext);
+    private readonly _draggableDataContext;
     handle(request: MinimapDragFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragFinalizeExecution, never>;

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

@@ -1,18 +1,15 @@
 import { MinimapDragPreparationRequest } from './minimap-drag-preparation.request';
-import { FMediator, IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../../f-draggable';
+import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class MinimapDragPreparationExecution implements IExecution<MinimapDragPreparationRequest, void> {
-    private fComponentsStore;
-    private fMediator;
-    private fDraggableDataContext;
-    private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, fDraggableDataContext: FDraggableDataContext);
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _draggableDataContext;
+    private get _flowHost();
     handle(request: MinimapDragPreparationRequest): void;
     private _isValid;
-    private getNewPosition;
-    private getFlowRect;
+    private _getNewPosition;
+    private _getFlowRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragPreparationExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragPreparationExecution>;
 }

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-node.directive.d.ts

@@ -1,4 +1,4 @@
-import { AfterViewInit, ElementRef, OnDestroy, OnInit } from "@angular/core";
+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';
@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private readonly _destroyRef;
     private readonly _mediator;
-    readonly fId: import("@angular/core").InputSignal<string>;
+    readonly fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
     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>;

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, any>;
+    type: import("@angular/core").InputSignalWithTransform<EFResizeHandleType, unknown>;
     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 { FDragHandleDirective } from './f-drag-handle.directive';
-export declare const F_NODE_PROVIDERS: (typeof FNodeDirective | typeof FGroupDirective | typeof FDragHandleDirective)[];
+export declare const F_NODE_PROVIDERS: (typeof FGroupDirective | typeof FNodeDirective | typeof FDragHandleDirective)[];

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

@@ -2,8 +2,8 @@ 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 _dragContext;
-    handle(request: SelectionAreaFinalizeRequest): void;
+    private readonly _dragContext;
+    handle(_request: SelectionAreaFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaFinalizeExecution>;

package/f-storage/f-components-store.d.ts

@@ -14,7 +14,7 @@ export declare class FComponentsStore {
     readonly dataChanges$: FChannel;
     readonly countChanges$: FChannel;
     get flowHost(): HTMLElement;
-    fComponents: IMap<any>;
+    fComponents: IMap<unknown>;
     fFlow: FFlowBase | undefined;
     fCanvas: FCanvasBase | undefined;
     fBackground: FBackgroundBase | undefined;

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

@@ -3,8 +3,8 @@ 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 _store;
-    handle(request: ListenDataChangesRequest): FChannelHub;
+    private readonly _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,8 +3,8 @@ 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 _store;
-    handle(request: ListenCountChangesRequest): FChannelHub;
+    private readonly _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,8 +3,8 @@ import { IExecution } from '@foblex/mediator';
 import { FChannelHub } from '../../../reactivity';
 import * as i0 from "@angular/core";
 export declare class ListenTransformChangesExecution implements IExecution<ListenTransformChangesRequest, FChannelHub> {
-    private _store;
-    handle(request: ListenTransformChangesRequest): FChannelHub;
+    private readonly _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,8 +2,8 @@ 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 _store;
-    handle(request: NotifyDataChangedRequest): void;
+    private readonly _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,8 +2,8 @@ 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 _store;
-    handle(request: NotifyTransformChangedRequest): void;
+    private readonly _store;
+    handle(_request: NotifyTransformChangedRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NotifyTransformChangedExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NotifyTransformChangedExecution>;
 }

package/f-storage/providers.d.ts

@@ -4,4 +4,4 @@ import { FComponentsStore } from './f-components-store';
 import { ListenCountChangesExecution } from './features/listen-count-changes';
 import { ListenTransformChangesExecution } from './features/listen-transform-changes';
 import { NotifyTransformChangedExecution } from './features/notify-transform-changed';
-export declare const F_STORAGE_PROVIDERS: (typeof NotifyDataChangedExecution | typeof FComponentsStore | typeof ListenDataChangesExecution | typeof ListenCountChangesExecution | typeof ListenTransformChangesExecution | typeof NotifyTransformChangedExecution)[];
+export declare const F_STORAGE_PROVIDERS: (typeof FComponentsStore | typeof NotifyDataChangedExecution | typeof ListenCountChangesExecution | typeof ListenDataChangesExecution | typeof ListenTransformChangesExecution | typeof NotifyTransformChangedExecution)[];