@foblex/flow 12.6.2 → 12.6.4

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

@@ -1,4 +1,4 @@
-import { FFlowMediator, IExecution } from '../../infrastructure';
+import { FMediator, IExecution } from '@foblex/mediator';
 import { SingleSelectRequest } from './single-select.request';
 import { FComponentsStore } from '../../f-storage';
 import { FDraggableDataContext } from '../f-draggable-data-context';
@@ -9,7 +9,7 @@ export declare class SingleSelectExecution implements IExecution<SingleSelectReq
     private fComponentsStore;
     private fDraggableDataContext;
     private fMediator;
-    constructor(fPlatform: PlatformService, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
+    constructor(fPlatform: PlatformService, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
     handle(request: SingleSelectRequest): void;
     private getSelectableItem;
     private getConnectionHandler;

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

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

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

@@ -1,4 +1,4 @@
-import { IValidator } from '../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { SingleSelectRequest } from './single-select.request';
 import { FComponentsStore } from '../../f-storage';
 import { FDraggableDataContext } from '../f-draggable-data-context';

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

@@ -1,5 +1,5 @@
 import { ExternalItemFinalizeRequest } from './external-item-finalize.request';
-import { FFlowMediator, IExecution } from '../../../infrastructure';
+import { FMediator, IExecution } from '@foblex/mediator';
 import { FComponentsStore } from '../../../f-storage';
 import { FDraggableDataContext } from '../../../f-draggable';
 import { BrowserService } from '@foblex/platform';
@@ -12,7 +12,7 @@ export declare class ExternalItemFinalizeExecution implements IExecution<Externa
     private get flowHost();
     private get fCreateNode();
     private get dragHandler();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator, fBrowser: BrowserService);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator, fBrowser: BrowserService);
     handle(request: ExternalItemFinalizeRequest): void;
     private getExternalItemElementsFromPoint;
     private emitEvent;

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

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

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

@@ -1,5 +1,5 @@
 import { ExternalItemFinalizeRequest } from './external-item-finalize.request';
-import { IValidator } from '../../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class ExternalItemFinalizeValidator implements IValidator<ExternalItemFinalizeRequest> {

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

@@ -1,5 +1,5 @@
 import { ExternalItemPreparationRequest } from './external-item-preparation.request';
-import { IExecution } from '../../../infrastructure';
+import { IExecution } from '@foblex/mediator';
 import { FComponentsStore } from '../../../f-storage';
 import { FExternalItemService } from '../../../f-external-item';
 import { FDraggableDataContext } from '../../../f-draggable';

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

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

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

@@ -1,5 +1,5 @@
 import { ExternalItemPreparationRequest } from './external-item-preparation.request';
-import { IValidator } from '../../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { FExternalItemService } from '../../../f-external-item';
 import * as i0 from "@angular/core";
 export declare class ExternalItemPreparationValidator implements IValidator<ExternalItemPreparationRequest> {

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

@@ -1,4 +1,4 @@
-import { IPoint } from '@foblex/core';
+import { IPoint } from '@foblex/2d';
 import { FExternalItemBase } from '../../f-external-item';
 import { IDraggableItem } from '../../f-draggable';
 import { BrowserService } from '@foblex/platform';

package/f-external-item/domain/f-create-node.event.d.ts

@@ -1,4 +1,4 @@
-import { IRect } from '@foblex/core';
+import { IRect } from '@foblex/2d';
 export declare class FCreateNodeEvent<TData = any> {
     rect: IRect;
     data: TData;

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

@@ -1,5 +1,5 @@
-import { IHasHostElement } from '@foblex/core';
 import { InjectionToken } from '@angular/core';
+import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
 export declare abstract class FExternalItemBase<TData = any> implements IHasHostElement {
@@ -8,5 +8,5 @@ export declare abstract class FExternalItemBase<TData = any> implements IHasHost
     abstract fData: TData | undefined;
     abstract fDisabled: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never>;
 }

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

@@ -14,5 +14,5 @@ export declare class FExternalItemDirective<TData> extends FExternalItemBase<TDa
     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; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": "fExternalItemId"; "fData": "fData"; "fDisabled": "fDisabled"; }, {}, never>;
 }

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

@@ -1,5 +1,5 @@
 import { EventEmitter, InjectionToken } from '@angular/core';
-import { IHasHostElement } from '@foblex/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;

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

@@ -1,7 +1,8 @@
 import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FFlowBase } from './f-flow-base';
-import { IPoint, IRect } from '@foblex/core';
-import { FFlowMediator } from '../infrastructure';
+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';
@@ -16,7 +17,7 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
     private isLoaded;
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     private subscribeOnComponentsCountChanges;
@@ -26,10 +27,11 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     getAllNodesRect(): IRect | null;
     getSelection(): FSelectionChangeEvent;
     getPositionInFlow(position: IPoint): IRect;
+    getState(): IFFlowState;
     selectAll(): void;
     select(nodes: string[], connections: string[]): void;
     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, { "fFlowId": "fFlowId"; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "f-minimap"]>;
 }

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

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

package/f-line-alignment/domain/nearest-coordinate.d.ts

@@ -1,4 +1,4 @@
-import { IRect } from '@foblex/core';
+import { IRect } from '@foblex/2d';
 import { INearestCoordinateResult } from './i-nearest-coordinate-result';
 /**
  * A class to find the nearest coordinate.

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

@@ -1,7 +1,8 @@
-import { IHasHostElement, IPoint } from '@foblex/core';
+import { IPoint } from '@foblex/2d';
 import { InjectionToken } from '@angular/core';
 import { ILineAlignmentResult } from './domain';
 import { FNodeBase } from '../f-node';
+import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_LINE_ALIGNMENT: InjectionToken<FLineAlignmentBase>;
 export declare abstract class FLineAlignmentBase implements IHasHostElement {
@@ -11,5 +12,5 @@ export declare abstract class FLineAlignmentBase implements IHasHostElement {
     abstract handle(difference: IPoint): void;
     abstract complete(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never>;
 }

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

@@ -1,11 +1,11 @@
 import { ElementRef, OnInit } from '@angular/core';
-import { IPoint } from '@foblex/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 { FFlowMediator } from '../infrastructure';
+import { FMediator } from '@foblex/mediator';
 import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
@@ -21,7 +21,7 @@ export declare class FLineAlignmentComponent extends FLineAlignmentBase implemen
     private rects;
     private get transform();
     private get flowHost();
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator, fBrowser: BrowserService);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
     handle(difference: IPoint): void;
@@ -29,5 +29,5 @@ export declare class FLineAlignmentComponent extends FLineAlignmentBase implemen
     findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
     complete(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "fAlignThreshold": { "alias": "fAlignThreshold"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "fAlignThreshold": "fAlignThreshold"; }, {}, never, never>;
 }

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

@@ -1,7 +1,7 @@
-import { IPoint, Point } from '@foblex/core';
+import { IPoint, Point } from '@foblex/2d';
 import { CalculateFlowPointFromMinimapPointRequest } from './calculate-flow-point-from-minimap-point.request';
 import { FComponentsStore } from '../../../f-storage';
-import { IExecution } from '../../../infrastructure';
+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> {

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

@@ -1,4 +1,4 @@
-import { IPoint, IRect } from '@foblex/core';
+import { IPoint, IRect } from '@foblex/2d';
 import { FMinimapData } from '../f-minimap-data';
 export declare class CalculateFlowPointFromMinimapPointRequest {
     flowRect: IRect;

package/f-minimap/domain/check-rect-is-finite.d.ts

@@ -0,0 +1,2 @@
+import { IRect } from '@foblex/2d';
+export declare function checkRectIsFinite(rect: IRect): IRect;

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

@@ -1,4 +1,4 @@
-import { IRect } from '@foblex/core';
+import { IRect } from '@foblex/2d';
 export declare class FMinimapData {
     element: SVGSVGElement;
     scale: number;

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

@@ -1,7 +1,7 @@
-import { IPoint, IRect } from '@foblex/core';
+import { IPoint, IRect } from '@foblex/2d';
 import { FComponentsStore } from '../../f-storage';
 import { IDraggableItem } from '../../f-draggable';
-import { FFlowMediator } from '../../infrastructure';
+import { FMediator } from '@foblex/mediator';
 import { FMinimapData } from './f-minimap-data';
 export declare class FMinimapDragHandler implements IDraggableItem {
     private fComponentsStore;
@@ -11,7 +11,7 @@ export declare class FMinimapDragHandler implements IDraggableItem {
     private eventPoint;
     private minimap;
     private lastDifference;
-    constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
+    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
     initialize(): void;
     move(difference: IPoint): void;
     private isSamePoint;

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

@@ -1,6 +1,7 @@
 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 './f-minimap.drag-handler';
 export * from './f-minimap-data';
 export * from './providers';

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

@@ -1,5 +1,5 @@
 import { MinimapDragFinalizeRequest } from './minimap-drag-finalize.request';
-import { IExecution } from '../../../infrastructure';
+import { IExecution } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class MinimapDragFinalizeExecution implements IExecution<MinimapDragFinalizeRequest, void> {

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

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

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

@@ -1,5 +1,5 @@
 import { MinimapDragFinalizeRequest } from './minimap-drag-finalize.request';
-import { IValidator } from '../../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class MinimapDragFinalizeValidator implements IValidator<MinimapDragFinalizeRequest> {

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

@@ -1,5 +1,5 @@
 import { MinimapDragPreparationRequest } from './minimap-drag-preparation.request';
-import { FFlowMediator, IExecution } from '../../../infrastructure';
+import { FMediator, IExecution } from '@foblex/mediator';
 import { FComponentsStore } from '../../../f-storage';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
@@ -8,7 +8,7 @@ export declare class MinimapDragPreparationExecution implements IExecution<Minim
     private fMediator;
     private fDraggableDataContext;
     private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fDraggableDataContext: FDraggableDataContext);
+    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, fDraggableDataContext: FDraggableDataContext);
     handle(request: MinimapDragPreparationRequest): void;
     private getNewPosition;
     private getFlowRect;

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

@@ -1,4 +1,4 @@
-import { IPointerEvent } from '@foblex/core';
+import { IPointerEvent } from '@foblex/drag-toolkit';
 import { FMinimapData } from '../f-minimap-data';
 export declare class MinimapDragPreparationRequest {
     event: IPointerEvent;

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

@@ -1,5 +1,5 @@
 import { MinimapDragPreparationRequest } from './minimap-drag-preparation.request';
-import { IValidator } from '../../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import { FComponentsStore } from '../../../f-storage';
 import * as i0 from "@angular/core";

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

@@ -1,2 +1,2 @@
 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)[];
+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)[];

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

@@ -18,5 +18,5 @@ export declare class FMinimapCanvasDirective {
     private setElementAttributes;
     private applyClassList;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapCanvasDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never>;
 }

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

@@ -1,6 +1,6 @@
 import { ElementRef } from "@angular/core";
 import { FComponentsStore } from '../f-storage';
-import { FFlowMediator } from '../infrastructure';
+import { FMediator } from '@foblex/mediator';
 import { FMinimapData } from './domain';
 import * as i0 from "@angular/core";
 export declare class FMinimapFlowDirective {
@@ -11,7 +11,7 @@ export declare class FMinimapFlowDirective {
     fMinSize: number;
     private get flowHost();
     get hostElement(): SVGSVGElement;
-    constructor(elementReference: ElementRef<SVGSVGElement>, fMediator: FFlowMediator, fComponentsStore: FComponentsStore);
+    constructor(elementReference: ElementRef<SVGSVGElement>, fMediator: FMediator, fComponentsStore: FComponentsStore);
     update(): void;
     private getProcessedNodesRect;
     private getNodesRect;
@@ -24,5 +24,5 @@ export declare class FMinimapFlowDirective {
     private calculateCenteredViewBox;
     private setViewBox;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapFlowDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": { "alias": "fMinSize"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": "fMinSize"; }, {}, never>;
 }

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

@@ -10,5 +10,5 @@ export declare class FMinimapViewDirective {
     update(): void;
     private setAttributes;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapViewDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never>;
 }

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

@@ -1,9 +1,9 @@
 import { AfterViewInit, ElementRef, OnDestroy } from "@angular/core";
-import { FFlowMediator } from '../infrastructure';
+import { FMediator } from '@foblex/mediator';
 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/core';
+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 {
@@ -14,7 +14,7 @@ export declare class FMinimapComponent implements AfterViewInit, OnDestroy, IFDr
     fMinimapFlow: FMinimapFlowDirective;
     fMinimapView: FMinimapViewDirective;
     fMinSize: number;
-    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FMediator);
     ngAfterViewInit(): void;
     private subscribeOnTransformChanges;
     private getTransformChanges;
@@ -22,5 +22,5 @@ export declare class FMinimapComponent implements AfterViewInit, OnDestroy, IFDr
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FMinimapComponent, "f-minimap", ["fComponent"], { "fMinSize": "fMinSize"; }, {}, never, never>;
 }

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

@@ -1,5 +1,5 @@
 import { ElementRef, InjectionToken } from "@angular/core";
-import { IHasHostElement } from '@foblex/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 {
@@ -7,5 +7,5 @@ export declare class FDragHandleDirective implements IHasHostElement {
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never>;
 }

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

@@ -1,13 +1,13 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
-import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/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 { FFlowMediator } from '../infrastructure';
+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 elementReference;
     private renderer;
     private fComponentsStore;
     private fMediator;
@@ -25,9 +25,8 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     fSelectionDisabled: boolean;
     fIncludePadding: boolean;
     fConnectOnNode: boolean;
-    get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
@@ -38,5 +37,5 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; }; "fParentId": { "alias": "fGroupParentId"; "required": false; }; "position": { "alias": "fGroupPosition"; "required": false; }; "size": { "alias": "fGroupSize"; "required": false; }; "fDraggingDisabled": { "alias": "fGroupDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fGroupSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": "fGroupId"; "fParentId": "fGroupParentId"; "position": "fGroupPosition"; "size": "fGroupSize"; "fDraggingDisabled": "fGroupDraggingDisabled"; "fSelectionDisabled": "fGroupSelectionDisabled"; "fIncludePadding": "fIncludePadding"; "fConnectOnNode": "fConnectOnNode"; }, { "positionChange": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; }, never>;
 }

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

@@ -1,14 +1,19 @@
 import { EventEmitter, InjectionToken } from '@angular/core';
 import { Subject } from 'rxjs';
-import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/core';
-import { ISelectable } from '../f-connection';
+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';
 export declare const F_NODE: InjectionToken<FNodeBase>;
-export declare abstract class FNodeBase implements IHasStateChanges, ISelectable, IHasHostElement {
+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 {
     abstract fId: string;
     abstract fParentId: string | null | undefined;
-    abstract hostElement: HTMLElement;
     readonly stateChanges: Subject<void>;
     abstract positionChange: EventEmitter<IPoint>;
     abstract position: IPoint;
@@ -28,9 +33,7 @@ export declare abstract class FNodeBase implements IHasStateChanges, ISelectable
     protected abstract setStyle(name: string, value: string): void;
     isContains(element: HTMLElement | SVGElement): boolean;
     redraw(): void;
-    deselect(): void;
-    select(): void;
-    isSelected(): boolean;
     updatePosition(position: IPoint): void;
     updateSize(value: ISize): void;
 }
+export {};

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

@@ -1,13 +1,13 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
-import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/core';
+import { IPoint, IRect, ISize } from '@foblex/2d';
 import { BrowserService } from '@foblex/platform';
 import { FComponentsStore } from '../f-storage';
 import { FConnectorBase } from '../f-connectors';
-import { FFlowMediator } from '../infrastructure';
+import { FMediator } from '@foblex/mediator';
 import { FNodeBase } from './f-node-base';
+import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
-    private elementReference;
     private renderer;
     private fComponentsStore;
     private fMediator;
@@ -25,9 +25,8 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     fSelectionDisabled: boolean;
     fIncludePadding: boolean;
     fConnectOnNode: boolean;
-    get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
@@ -38,5 +37,5 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; }; "fParentId": { "alias": "fNodeParentId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "size": { "alias": "fNodeSize"; "required": false; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": "fNodeId"; "fParentId": "fNodeParentId"; "position": "fNodePosition"; "size": "fNodeSize"; "fDraggingDisabled": "fNodeDraggingDisabled"; "fSelectionDisabled": "fNodeSelectionDisabled"; "fIncludePadding": "fIncludePadding"; "fConnectOnNode": "fConnectOnNode"; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never>;
 }

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

@@ -1,6 +1,6 @@
 import { ElementRef, InjectionToken } from "@angular/core";
-import { IHasHostElement } from '@foblex/core';
 import { EFResizeHandleType } from './e-f-resize-handle-type';
+import { IHasHostElement } from '../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_RESIZE_HANDLE: InjectionToken<FResizeHandleDirective>;
 export declare class FResizeHandleDirective implements IHasHostElement {
@@ -12,5 +12,5 @@ export declare class FResizeHandleDirective implements IHasHostElement {
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FResizeHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": "fResizeHandleType"; }, {}, never>;
 }

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

@@ -1,5 +1,5 @@
 import { ElementRef } from "@angular/core";
-import { IHasHostElement } from '@foblex/core';
+import { IHasHostElement } from '../../i-has-host-element';
 export declare class FRotateHandleDirective implements IHasHostElement {
     private elementReference;
     private isDisabled;

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

@@ -1,5 +1,5 @@
 import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
-import { IExecution } from '../../../infrastructure';
+import { IExecution } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaFinalizeExecution implements IExecution<SelectionAreaFinalizeRequest, void> {

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

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

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

@@ -1,5 +1,5 @@
 import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
-import { IValidator } from '../../../infrastructure';
+import { IValidator } from '@foblex/mediator';
 import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectionAreaFinalizeValidator implements IValidator<SelectionAreaFinalizeRequest> {