@foblex/flow 17.7.0 → 17.8.0

package/f-draggable/f-node-resize/constraint/i-resize-overflow.d.ts

@@ -0,0 +1,6 @@
+export interface IResizeOverflow {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}

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

@@ -0,0 +1,4 @@
+export * from './i-resize-constraint';
+export * from './i-resize-limit';
+export * from './i-resize-limits';
+export * from './i-resize-overflow';

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

@@ -1,11 +1,11 @@
-export * from './apply-child-resize-restrictions';
-export * from './apply-parent-resize-restrictions';
-export * from './calculate-changed-position';
-export * from './calculate-changed-size';
-export * from './get-normalized-children-nodes-rect';
-export * from './get-node-resize-restrictions';
+export * from './apply-child-resize-constraints';
+export * from './apply-parent-resize-constraints';
+export * from './calculate-changed-rect-from-difference';
+export * from './calculate-direct-children-union-rect';
+export * from './calculate-resize-limits';
+export * from './constraint';
 export * from './resize-finalize';
 export * from './resize-preparation';
-export * from './f-node-resize.drag-handler';
+export * from './node-resize.drag-handler';
 export * from './providers';
 export * from './resize-direction';

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

@@ -0,0 +1,25 @@
+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 NodeResizeDragHandler implements IFDragHandler {
+    private _nodeOrGroup;
+    private _handleType;
+    readonly fEventType = "node-resize";
+    readonly fData: any;
+    private readonly _mediator;
+    private _originalRect;
+    private _constraints;
+    constructor(injector: Injector, _nodeOrGroup: FNodeBase, _handleType: EFResizeHandleType);
+    prepareDragSequence(): void;
+    private _getOriginalNodeRect;
+    private _calculateResizeLimits;
+    onPointerMove(difference: IPoint): void;
+    private _newRect;
+    private _applyResizeChanges;
+    private _redraw;
+    private _applyChildConstraints;
+    private _applyParentConstraints;
+    onPointerUp(): void;
+    private _getNewRect;
+}

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

@@ -1,9 +1,8 @@
-import { FNodeResizeFinalizeExecution } from './resize-finalize';
-import { FNodeResizePreparationExecution } from './resize-preparation';
-import { GetNodeResizeRestrictionsExecution } from './get-node-resize-restrictions';
-import { ApplyChildResizeRestrictionsExecution } from './apply-child-resize-restrictions';
-import { ApplyParentResizeRestrictionsExecution } from './apply-parent-resize-restrictions';
-import { CalculateChangedSizeExecution } from './calculate-changed-size';
-import { CalculateChangedPositionExecution } from './calculate-changed-position';
-import { GetNormalizedChildrenNodesRectExecution } from './get-normalized-children-nodes-rect';
-export declare const NODE_RESIZE_PROVIDERS: (typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof FNodeResizeFinalizeExecution | typeof FNodeResizePreparationExecution)[];
+import { NodeResizeFinalize } from './resize-finalize';
+import { NodeResizePreparation } from './resize-preparation';
+import { CalculateResizeLimits } from './calculate-resize-limits';
+import { ApplyChildResizeConstraints } from './apply-child-resize-constraints';
+import { ApplyParentResizeConstraints } from './apply-parent-resize-constraints';
+import { CalculateChangedRectFromDifference } from './calculate-changed-rect-from-difference';
+import { CalculateDirectChildrenUnionRect } from './calculate-direct-children-union-rect';
+export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeConstraints | typeof ApplyParentResizeConstraints | typeof CalculateChangedRectFromDifference | typeof CalculateDirectChildrenUnionRect | typeof CalculateResizeLimits | typeof NodeResizeFinalize | typeof NodeResizePreparation)[];

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

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

package/f-draggable/{f-drop-to-group/drop-to-group-preparation/f-node-drop-to-group-preparation.request.d.ts → f-node-resize/resize-finalize/node-resize-finalize-request.d.ts}

@@ -1,6 +1,6 @@
 import { IPointerEvent } from "../../../drag-toolkit";
-export declare class FNodeDropToGroupPreparationRequest {
-    event: IPointerEvent;
+export declare class NodeResizeFinalizeRequest {
+    readonly event: IPointerEvent;
     static readonly fToken: unique symbol;
     constructor(event: IPointerEvent);
 }

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

@@ -0,0 +1,10 @@
+import { NodeResizeFinalizeRequest } from './node-resize-finalize-request';
+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;
+    private _isNodeResizeHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizeFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizeFinalize>;
+}

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

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

package/f-draggable/f-node-resize/resize-preparation/{f-node-resize-preparation.request.d.ts → node-resize-preparation-request.d.ts}

@@ -1,6 +1,6 @@
 import { FEventTrigger } from '../../../domain';
 import { IPointerEvent } from "../../../drag-toolkit";
-export declare class FNodeResizePreparationRequest {
+export declare class NodeResizePreparationRequest {
     event: IPointerEvent;
     fTrigger: FEventTrigger;
     static readonly fToken: unique symbol;

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

@@ -0,0 +1,22 @@
+import { NodeResizePreparationRequest } from './node-resize-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class NodeResizePreparation implements IExecution<NodeResizePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _injector;
+    private get _transform();
+    private get _fHost();
+    private _nodeOrGroup;
+    handle(request: NodeResizePreparationRequest): void;
+    private _isValid;
+    private _isResizeHandleElement;
+    private _isNodeCanBeDragged;
+    private _getNode;
+    private _isValidTrigger;
+    private _selectAndUpdateNodeLayer;
+    private _getHandleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeResizePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeResizePreparation>;
+}

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

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

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 _fDraggableDataContext;
+    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

@@ -3,8 +3,8 @@ 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 _store;
+    private readonly _dragContext;
     private readonly _injector;
     private get _transform();
     private get _fHost();

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

@@ -40,8 +40,8 @@ import * as i0 from "@angular/core";
  */
 export declare class FSingleSelectExecution implements IExecution<FSingleSelectRequest, void> {
     private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     handle(request: FSingleSelectRequest): void;
     private _isValid;
     private _isEventInFlowBounds;

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | 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").CalculateCommonNodeMoveLimitsExecution | typeof import("./f-node-move").PutInputConnectionHandlersToArrayExecution | typeof import("./f-node-move").PutOutputConnectionHandlersToArrayExecution | typeof import("./f-node-move").CalculateNodeMoveLimitsExecution | typeof import("./f-node-move").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./f-node-move").LineAlignmentPreparationExecution | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-drop-to-group").FNodeDropToGroupFinalizeExecution | typeof import("./f-drop-to-group").FNodeDropToGroupPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./f-node-resize").GetNodeResizeRestrictionsExecution | typeof import("./f-node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./f-node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./f-node-resize").CalculateChangedPositionExecution | typeof import("./f-node-resize").CalculateChangedSizeExecution | typeof import("./f-node-resize").FNodeResizeFinalizeExecution | typeof import("./f-node-resize").FNodeResizePreparationExecution | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | 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").GetNodeBoundingIncludePaddings | 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").CreateDragModelFromSelection | typeof import("./f-node-move").CreateSnapLines | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-drop-to-group").DropToGroupFinalize | typeof import("./f-drop-to-group").SortContainersForDropByLayer | typeof import("./f-drop-to-group").DropToGroupPreparation | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | 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-single-select").FSingleSelectExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution)[];

package/{f-draggable/f-node-move/point-bounds-limiter.d.ts → f-external-item/domain/constraint/external-rect-constraint.d.ts}

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

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

@@ -0,0 +1 @@
+export * from './external-rect-constraint';

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

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

@@ -1,10 +1,9 @@
 import { ISize, ITransformModel } from '@foblex/2d';
 import { BrowserService } from '@foblex/platform';
-export declare class LineService {
-    private hostElement;
-    private fHorizontalLine;
-    private fVerticalLine;
-    constructor(fBrowser: BrowserService, hostElement: HTMLElement);
+export declare class SnapLineService {
+    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/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();