@foblex/flow 16.0.5 → 17.0.1

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

@@ -10,6 +10,7 @@ export declare class NodeMoveFinalizeExecution implements IExecution<NodeMoveFin
     private get flowHost();
     constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
     handle(request: NodeMoveFinalizeRequest): void;
+    private getItems;
     private getDifferenceBetweenPreparationAndFinalize;
     private getDifferenceWithLineAlignment;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeMoveFinalizeExecution, never>;

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

@@ -5,6 +5,7 @@ export declare class NodeResizeByChildDragHandler implements IDraggableItem {
     private fDraggableDataContext;
     private onPointerDownPosition;
     constructor(fDraggableDataContext: FDraggableDataContext);
-    move(difference: IPoint): void;
-    complete(): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
 }

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

@@ -9,9 +9,9 @@ export declare class NodeDragHandler implements IDraggableItem {
     maxDistance: IPoint;
     private onPointerDownPosition;
     constructor(fDraggableDataContext: FDraggableDataContext, fNode: FNodeBase, minDistance: IPoint, maxDistance: IPoint);
-    move(difference: IPoint): void;
+    onPointerMove(difference: IPoint): void;
     private getNewPosition;
     private getDifference;
     private redrawNode;
-    complete(): void;
+    onPointerUp(): void;
 }

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

@@ -1 +1 @@
-export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").GetNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-move-preparation").NodeMovePreparationValidator | typeof import("./node-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").GetNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeExecution | typeof import("./node-drag-to-parent-finalize").NodeDragToParentFinalizeValidator | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationExecution | typeof import("./node-drag-to-parent-preparation").NodeDragToParentPreparationValidator | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-move-preparation").NodeMovePreparationValidator | typeof import("./node-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator)[];

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

@@ -10,11 +10,11 @@ export declare class NodeResizeDragHandler implements IDraggableItem {
     private restrictions;
     private childRestrictions;
     constructor(fMediator: FMediator, fNode: FNodeBase, fResizeHandleType: EFResizeHandleType);
-    initialize(): void;
-    move(difference: IPoint): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
     private changeSize;
     private changePosition;
     private applyChildRestrictions;
     private applyParentRestrictions;
-    complete(): void;
+    onPointerUp(): void;
 }

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemFinalizeValidator | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./domain").GetNodePaddingExecution | typeof import("./domain").GetNormalizedNodeRectExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").GetParentNodesExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("../f-minimap/domain").CalculateFlowPointFromMinimapPointExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeValidator | typeof import("../f-minimap/domain").MinimapDragPreparationExecution | typeof import("../f-minimap/domain").MinimapDragPreparationValidator | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemFinalizeValidator | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./domain").GetNodePaddingExecution | typeof import("./domain").GetNormalizedNodeRectExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").GetParentNodesExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./node").NodeDragToParentFinalizeValidator | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentPreparationValidator | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragPreparationValidator | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeValidator | 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").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator)[];

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

@@ -12,6 +12,7 @@ export declare class SingleSelectExecution implements IExecution<SingleSelectReq
     constructor(fPlatform: PlatformService, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
     handle(request: SingleSelectRequest): void;
     private getSelectableItem;
+    private _findNode;
     private getConnectionHandler;
     private isMultiselectEnabled;
     private isShiftPressed;

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

@@ -10,8 +10,8 @@ export declare class ExternalItemDragHandler implements IDraggableItem {
     private difference;
     constructor(externalItem: FExternalItemBase, fBrowser: BrowserService);
     private getStyle;
-    initialize(): void;
+    prepareDragSequence(): void;
     private getExternalItemRect;
-    move(difference: IPoint): void;
-    complete(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
 }

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

@@ -1,5 +1,6 @@
 export * from './external-item-finalize';
 export * from './external-item-preparation';
 export * from './f-create-node.event';
+export * from './prevent-default-is-external-item';
 export * from './external-item.drag-handler';
 export * from './providers';

package/f-external-item/domain/prevent-default-is-external-item/index.d.ts

@@ -0,0 +1,2 @@
+export * from './prevent-default-is-external-item.execution';
+export * from './prevent-default-is-external-item.request';

package/f-external-item/domain/prevent-default-is-external-item/prevent-default-is-external-item.execution.d.ts

@@ -0,0 +1,10 @@
+import { PreventDefaultIsExternalItemRequest } from './prevent-default-is-external-item.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class PreventDefaultIsExternalItemExecution implements IExecution<PreventDefaultIsExternalItemRequest, void> {
+    handle(request: PreventDefaultIsExternalItemRequest): void;
+    private _isTargetItemExternal;
+    private _isExternalItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventDefaultIsExternalItemExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreventDefaultIsExternalItemExecution>;
+}

package/f-external-item/domain/prevent-default-is-external-item/prevent-default-is-external-item.request.d.ts

@@ -0,0 +1,4 @@
+export declare class PreventDefaultIsExternalItemRequest {
+    event: Event;
+    constructor(event: Event);
+}

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

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

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

@@ -2,7 +2,7 @@ import { EventEmitter, InjectionToken } from '@angular/core';
 import { IHasHostElement } from '../i-has-host-element';
 export declare const F_FLOW: InjectionToken<FFlowBase>;
 export declare abstract class FFlowBase implements IHasHostElement {
-    abstract fFlowId: string;
+    abstract fId: string;
     abstract hostElement: HTMLElement;
     abstract fLoaded: EventEmitter<void>;
 }

package/f-flow/f-flow.component.d.ts

@@ -1,27 +1,25 @@
-import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { AfterContentInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FFlowBase } from './f-flow-base';
 import { IFFlowState } from '../domain';
 import { IPoint, IRect } from '@foblex/2d';
-import { FMediator } from '@foblex/mediator';
 import { FSelectionChangeEvent } from '../f-draggable';
-import { FComponentsStore } from '../f-storage';
 import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
-    private elementReference;
-    private fComponentsStore;
-    private fMediator;
     private fBrowser;
-    private subscription$;
-    fFlowId: string;
+    private _destroyRef;
+    private _fMediator;
+    private _elementReference;
+    fId: string;
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
-    private isLoaded;
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
+    private _isLoaded;
+    constructor(fBrowser: BrowserService);
     ngOnInit(): void;
     ngAfterContentInit(): void;
-    private subscribeOnComponentsCountChanges;
-    private subscribeOnElementsChanges;
+    private _listenCountChanges;
+    private _listenDataChanges;
+    private _emitLoaded;
     redraw(): void;
     reset(): void;
     getAllNodesRect(): IRect | null;
@@ -33,5 +31,5 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     clearSelection(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fFlowId": { "alias": "fFlowId"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "f-minimap"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fId": { "alias": "fFlowId"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "f-minimap"], false, never>;
 }

package/f-line-alignment/f-line-alignment.component.d.ts

@@ -1,28 +1,26 @@
-import { ElementRef, OnInit } from '@angular/core';
+import { AfterViewInit, ElementRef } from '@angular/core';
 import { IPoint } from '@foblex/2d';
 import { ILineAlignmentResult } from './domain';
 import { FLineAlignmentBase } from './f-line-alignment-base';
-import { FComponentsStore } from '../f-storage';
 import { FDraggableDataContext } from '../f-draggable';
 import { FNodeBase } from '../f-node';
-import { FMediator } from '@foblex/mediator';
 import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
-export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
+export declare class FLineAlignmentComponent extends FLineAlignmentBase implements AfterViewInit {
     private elementReference;
-    private fComponentsStore;
     private fDraggableDataContext;
-    private fMediator;
     fAlignThreshold: number;
     get hostElement(): HTMLElement;
     private lineService;
     private size;
     private draggedNodeRect;
     private rects;
-    private get transform();
-    private get flowHost();
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator, fBrowser: BrowserService);
-    ngOnInit(): void;
+    private _fMediator;
+    private _fCanvas;
+    private get _transform();
+    private get _fFlowHostElement();
+    constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext, fBrowser: BrowserService);
+    ngAfterViewInit(): void;
     initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
     handle(difference: IPoint): void;
     private drawIntersectingLines;

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

@@ -12,9 +12,9 @@ export declare class FMinimapDragHandler implements IDraggableItem {
     private minimap;
     private lastDifference;
     constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
-    initialize(): void;
-    move(difference: IPoint): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
     private isSamePoint;
     private getNewPosition;
-    complete(): void;
+    onPointerUp(): void;
 }

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

@@ -1,7 +1,9 @@
 export * from './calculate-flow-point-from-minimap-point';
 export * from './minimap-drag-finalize';
 export * from './minimap-drag-preparation';
-export * from './check-rect-is-finite';
+export * from './minimap-draw-nodes';
+export * from './minimap-calculate-svg-scale-and-view-box';
+export * from './minimap-calculate-view-box';
 export * from './f-minimap.drag-handler';
 export * from './f-minimap-data';
 export * from './providers';

package/f-minimap/domain/minimap-calculate-svg-scale-and-view-box/i-f-minimap-scale-and-view-box.d.ts

@@ -0,0 +1,5 @@
+import { IRect } from '@foblex/2d';
+export interface IFMinimapScaleAndViewBox {
+    scale: number;
+    viewBox: IRect;
+}

package/f-minimap/domain/minimap-calculate-svg-scale-and-view-box/index.d.ts

@@ -0,0 +1,3 @@
+export * from './i-f-minimap-scale-and-view-box';
+export * from './minimap-calculate-svg-scale-and-view-box.execution';
+export * from './minimap-calculate-svg-scale-and-view-box.request';

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

@@ -0,0 +1,22 @@
+import { MinimapCalculateSvgScaleAndViewBoxRequest } from './minimap-calculate-svg-scale-and-view-box.request';
+import { IExecution } from '@foblex/mediator';
+import { IFMinimapScaleAndViewBox } from './i-f-minimap-scale-and-view-box';
+import * as i0 from "@angular/core";
+export declare class MinimapCalculateSvgScaleAndViewBoxExecution implements IExecution<MinimapCalculateSvgScaleAndViewBoxRequest, IFMinimapScaleAndViewBox> {
+    private _fMediator;
+    private _fComponentStore;
+    private get _fFlow();
+    private get _fCanvas();
+    handle(request: MinimapCalculateSvgScaleAndViewBoxRequest): IFMinimapScaleAndViewBox;
+    private _getScaledNodesBoundingBox;
+    private _calculateNodesBoundingBox;
+    private _convertFromGlobalToFlowRect;
+    private _convertRectToMinimapScale;
+    private _getMinimapRect;
+    private _calculateViewScale;
+    private _calculateViewBox;
+    private _calculateViewSize;
+    private _calculateCenteredViewBox;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateSvgScaleAndViewBoxExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateSvgScaleAndViewBoxExecution>;
+}

package/f-minimap/domain/minimap-calculate-svg-scale-and-view-box/minimap-calculate-svg-scale-and-view-box.request.d.ts

@@ -0,0 +1,5 @@
+export declare class MinimapCalculateSvgScaleAndViewBoxRequest {
+    element: SVGSVGElement;
+    minSize: number;
+    constructor(element: SVGSVGElement, minSize: number);
+}

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

@@ -0,0 +1,2 @@
+export * from './minimap-calculate-view-box.execution';
+export * from './minimap-calculate-view-box.request';

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

@@ -0,0 +1,14 @@
+import { MinimapCalculateViewBoxRequest } from './minimap-calculate-view-box.request';
+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();
+    handle(request: MinimapCalculateViewBoxRequest): IRect;
+    private _getRectForMinimapView;
+    private _calculateViewBox;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateViewBoxExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateViewBoxExecution>;
+}

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

@@ -0,0 +1,2 @@
+export declare class MinimapCalculateViewBoxRequest {
+}

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

@@ -0,0 +1,2 @@
+export * from './minimap-draw-nodes.execution';
+export * from './minimap-draw-nodes.request';

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

@@ -0,0 +1,18 @@
+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 _fBrowser;
+    private _fComponentStore;
+    private get _fFlow();
+    private get _fNodes();
+    private get _fCanvas();
+    handle(request: MinimapDrawNodesRequest): SVGRectElement[];
+    private _createMinimapNodeElements;
+    private _createNodeElement;
+    private _getNodeRect;
+    private _getNodeRectInFlow;
+    private _applyClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDrawNodesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDrawNodesExecution>;
+}

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

@@ -0,0 +1,2 @@
+export declare class MinimapDrawNodesRequest {
+}

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

@@ -1,2 +1,5 @@
 import { CalculateFlowPointFromMinimapPointExecution } from './calculate-flow-point-from-minimap-point';
-export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeValidator | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationValidator)[];
+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-preparation").MinimapDragPreparationValidator | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeValidator | typeof MinimapDrawNodesExecution | typeof MinimapCalculateViewBoxExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution)[];

package/f-minimap/f-minimap-canvas.directive.d.ts

@@ -1,22 +1,10 @@
-import { ElementRef } from "@angular/core";
-import { FComponentsStore } from '../f-storage';
-import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FMinimapCanvasDirective {
-    private elementReference;
-    private fComponentsStore;
-    private fBrowser;
+    private _fMediator;
+    private _elementReference;
     get hostElement(): SVGGElement;
-    private get flowHost();
-    private get flowScale();
-    constructor(elementReference: ElementRef<SVGGElement>, fComponentsStore: FComponentsStore, fBrowser: BrowserService);
     redraw(): void;
-    private clearCanvas;
-    private renderNode;
-    private configureNodeElement;
-    private getNodeRect;
-    private setElementAttributes;
-    private applyClassList;
+    private _clearCanvas;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapCanvasDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never, never, false, never>;
 }

package/f-minimap/f-minimap-flow.directive.d.ts

@@ -1,28 +1,12 @@
-import { ElementRef } from "@angular/core";
-import { FComponentsStore } from '../f-storage';
-import { FMediator } from '@foblex/mediator';
 import { FMinimapData } from './domain';
 import * as i0 from "@angular/core";
 export declare class FMinimapFlowDirective {
-    private elementReference;
-    private fMediator;
-    private fComponentsStore;
-    model: FMinimapData;
     fMinSize: number;
-    private get flowHost();
+    private _fMediator;
+    private _elementReference;
     get hostElement(): SVGSVGElement;
-    constructor(elementReference: ElementRef<SVGSVGElement>, fMediator: FMediator, fComponentsStore: FComponentsStore);
-    update(): void;
-    private getProcessedNodesRect;
-    private getNodesRect;
-    private getMinimapRect;
-    private normalizeRect;
-    private ensureMinimumSize;
-    private calculateViewScale;
-    private calculateViewBox;
-    private calculateViewSize;
-    private calculateCenteredViewBox;
-    private setViewBox;
+    model: FMinimapData;
+    redraw(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapFlowDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": { "alias": "fMinSize"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-minimap/f-minimap-view.directive.d.ts

@@ -1,14 +1,9 @@
-import { ElementRef } from "@angular/core";
-import { FComponentsStore } from '../f-storage';
 import * as i0 from "@angular/core";
 export declare class FMinimapViewDirective {
-    private elementReference;
-    private fComponentsStore;
-    get hostElement(): SVGRectElement;
-    private get flowScale();
-    constructor(elementReference: ElementRef<SVGRectElement>, fComponentsStore: FComponentsStore);
-    update(): void;
-    private setAttributes;
+    private _fMediator;
+    private _elementReference;
+    get hostElement(): SVGGElement;
+    redraw(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapViewDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never, never, false, never>;
 }

package/f-minimap/f-minimap.component.d.ts

@@ -1,26 +1,23 @@
-import { AfterViewInit, ElementRef, OnDestroy } from "@angular/core";
-import { FMediator } from '@foblex/mediator';
+import { AfterViewInit } from "@angular/core";
 import { FMinimapFlowDirective } from './f-minimap-flow.directive';
 import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
 import { FMinimapViewDirective } from './f-minimap-view.directive';
 import { IPointerEvent } from '@foblex/drag-toolkit';
 import { IFDragAndDropPlugin } from '../f-draggable';
 import * as i0 from "@angular/core";
-export declare class FMinimapComponent implements AfterViewInit, OnDestroy, IFDragAndDropPlugin {
-    private elementReference;
-    private fMediator;
-    private subscriptions$;
+export declare class FMinimapComponent implements AfterViewInit, IFDragAndDropPlugin {
+    private _destroyRef;
+    private _fMediator;
+    private _fBrowser;
     fMinimapCanvas: FMinimapCanvasDirective;
     fMinimapFlow: FMinimapFlowDirective;
     fMinimapView: FMinimapViewDirective;
     fMinSize: number;
-    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FMediator);
     ngAfterViewInit(): void;
-    private subscribeOnTransformChanges;
-    private getTransformChanges;
+    private _listenTransformChanges;
+    private _redraw;
     onPointerDown(event: IPointerEvent): void;
     onPointerUp(event: IPointerEvent): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FMinimapComponent, "f-minimap", ["fComponent"], { "fMinSize": { "alias": "fMinSize"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-node/domain/index.d.ts

@@ -1,2 +1 @@
-export * from './is-group';
 export * from './is-node';

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

@@ -1,11 +1,10 @@
-import { ElementRef, InjectionToken } from "@angular/core";
+import { InjectionToken } from "@angular/core";
 import { IHasHostElement } from '../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_DRAG_HANDLE: InjectionToken<FDragHandleDirective>;
 export declare class FDragHandleDirective implements IHasHostElement {
-    private elementReference;
+    private _elementReference;
     get hostElement(): HTMLElement;
-    constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
 }

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

@@ -1,18 +1,12 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
 import { IPoint, IRect, ISize } from '@foblex/2d';
 import { FNodeBase } from './f-node-base';
-import { FComponentsStore } from '../f-storage';
-import { FConnectorBase } from '../f-connectors';
-import { FMediator } from '@foblex/mediator';
 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 fComponentsStore;
-    private fMediator;
     private fBrowser;
-    private subscriptions$;
     fId: string;
     fParentId: string | null | undefined;
     set position(value: IPoint);
@@ -25,15 +19,14 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     fSelectionDisabled: boolean;
     fIncludePadding: boolean;
     fConnectOnNode: boolean;
-    connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
+    private _destroyRef;
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
     ngAfterViewInit(): void;
-    private subscribeOnResizeChanges;
-    addConnector(connector: FConnectorBase): void;
-    removeConnector(connector: FConnectorBase): void;
+    private _listenStateSizeChanges;
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;

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

@@ -1,20 +1,19 @@
 import { EventEmitter, InjectionToken } from '@angular/core';
-import { Subject } from 'rxjs';
 import { IPoint, IRect, ISize } from '@foblex/2d';
-import { IHasStateChanges } from '../i-has-state-changes';
 import { FConnectorBase } from '../f-connectors';
 import { IHasHostElement } from '../i-has-host-element';
 import { ICanChangeSelection } from '../mixins';
+import { FChannel } from '../reactivity';
 export declare const F_NODE: InjectionToken<FNodeBase>;
 declare const MIXIN_BASE: import("../mixins").Constructor<ICanChangeSelection> & import("../mixins").AbstractConstructor<ICanChangeSelection> & {
     new (hostElement: HTMLElement): {
         hostElement: HTMLElement;
     };
 };
-export declare abstract class FNodeBase extends MIXIN_BASE implements IHasStateChanges, ICanChangeSelection, IHasHostElement {
+export declare abstract class FNodeBase extends MIXIN_BASE implements ICanChangeSelection, IHasHostElement {
     abstract fId: string;
     abstract fParentId: string | null | undefined;
-    readonly stateChanges: Subject<void>;
+    readonly stateChanges: FChannel;
     abstract positionChange: EventEmitter<IPoint>;
     abstract position: IPoint;
     protected _position: IPoint;
@@ -27,13 +26,15 @@ export declare abstract class FNodeBase extends MIXIN_BASE implements IHasStateC
     fCanBeResizedByChild: boolean;
     abstract fIncludePadding: boolean;
     abstract refresh(): void;
-    abstract connectors: FConnectorBase[];
-    abstract addConnector(connector: FConnectorBase): void;
-    abstract removeConnector(connector: FConnectorBase): void;
+    connectors: FConnectorBase[];
     protected abstract setStyle(name: string, value: string): void;
     isContains(element: HTMLElement | SVGElement): boolean;
     redraw(): void;
     updatePosition(position: IPoint): void;
     updateSize(value: ISize): void;
+    setClass(className: string): void;
+    removeClass(className: string): void;
+    addConnector(connector: FConnectorBase): void;
+    removeConnector(connector: FConnectorBase): void;
 }
 export {};