@foblex/flow 1.5.0 → 1.5.2

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

@@ -7,7 +7,7 @@ import { FMarkerBase } from '../f-marker';
 import * as i0 from "@angular/core";
 export declare class FConnectionComponent extends FConnectionBase implements OnInit, OnDestroy {
     private fComponentsStore;
-    id: string;
+    fConnectionId: string;
     fText: string;
     fStartColor: string;
     fEndColor: string;
@@ -33,7 +33,7 @@ export declare class FConnectionComponent extends FConnectionBase implements OnI
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "id": { "alias": "id"; "required": false; }; "fText": { "alias": "fText"; "required": false; }; "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": true; }; "fInputId": { "alias": "fInputId"; "required": true; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["fMarkers"], ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fConnectionId": { "alias": "fConnectionId"; "required": false; }; "fText": { "alias": "fText"; "required": false; }; "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": true; }; "fInputId": { "alias": "fInputId"; "required": true; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["fMarkers"], ["*", "[fConnectionCenter]"], false, never>;
     static ngAcceptInputType_fBehavior: string;
     static ngAcceptInputType_fType: string;
 }

package/f-connection/f-connection-for-create/f-connection-for-create.component.d.ts

@@ -7,7 +7,7 @@ import { FMarkerBase } from '../f-marker';
 import * as i0 from "@angular/core";
 export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {
     private fComponentsStore;
-    id: string;
+    fConnectionId: string;
     fText: string;
     fStartColor: string;
     fEndColor: string;

package/f-draggable/connections/create-connection/create-connection.drag-handler.d.ts

@@ -1,18 +1,17 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../../i-draggable-item';
 import { EFDraggableType } from '../../e-f-draggable-type';
-import { GetConnectionVectorHandler, GetOutputRectInFlowHandler } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
+import { FFlowMediator } from '../../../f-mediator';
 export declare class CreateConnectionDragHandler implements IDraggableItem {
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     connection: FConnectionBase;
     private mouseDownPoint;
     readonly type: EFDraggableType;
     private onPointerDownFromConnectorRect;
     private onPointerDownToConnectorRect;
     private outputSide;
-    constructor(getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase, mouseDownPoint: IPoint);
+    constructor(fMediator: FFlowMediator, connection: FConnectionBase, mouseDownPoint: IPoint);
     initialize(): void;
     move(difference: IPoint): void;
     complete(): void;

package/f-draggable/connections/create-connection/create-connection.prepare-drag-sequence.d.ts

@@ -2,18 +2,18 @@ import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../../f-components-store';
 import { FDraggableDataContext } from '../../f-draggable-data-context';
 import { FindFirstCanBeConnectedOutputByOutletHandler } from './find-first-can-be-connected-output-by-outlet';
-import { GetConnectionVectorHandler, GetElementRectInFlowHandler, GetOutputRectInFlowHandler } from '../../../domain';
+import { GetElementRectInFlowHandler } from '../../../domain';
+import { FFlowMediator } from '../../../f-mediator';
 import * as i0 from "@angular/core";
 export declare class CreateConnectionPrepareDragSequence implements IHandler<IPointerEvent, void> {
     private fComponentsStore;
     private fDraggableDataContext;
     private getElementRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     private findFirstCanBeConnectedOutputByOutletHandler;
-    private getOutputRectInFlowHandler;
     private get transform();
     private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, findFirstCanBeConnectedOutputByOutletHandler: FindFirstCanBeConnectedOutputByOutletHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler, fMediator: FFlowMediator, findFirstCanBeConnectedOutputByOutletHandler: FindFirstCanBeConnectedOutputByOutletHandler);
     handle(event: IPointerEvent): void;
     private createConnectionHandler;
     private isNodeOutput;

package/f-draggable/connections/create-connection/f-create-connection.event.d.ts

@@ -0,0 +1,5 @@
+export declare class FCreateConnectionEvent {
+    fOutputId: string;
+    fInputId: string;
+    constructor(fOutputId: string, fInputId: string);
+}

package/f-draggable/connections/create-connection/index.d.ts

@@ -1,5 +1,5 @@
 export * from './find-first-can-be-connected-output-by-outlet';
 export * from './create-connection.drag-handler';
-export * from './create-connection.event';
+export * from './f-create-connection.event';
 export * from './create-connection.on-pointer-up';
 export * from './create-connection.prepare-drag-sequence';

package/f-draggable/connections/reassign-connection/f-reassign-connection.event.d.ts

@@ -0,0 +1,7 @@
+export declare class FReassignConnectionEvent<T = any> {
+    connectionId: T;
+    fOutputId: T;
+    oldFInputId: T;
+    newFInputId: T;
+    constructor(connectionId: T, fOutputId: T, oldFInputId: T, newFInputId: T);
+}

package/f-draggable/connections/reassign-connection/index.d.ts

@@ -1,4 +1,4 @@
 export * from './reassign-connection.drag-handler';
-export * from './reassign-connection.event';
+export * from './f-reassign-connection.event';
 export * from './reassign-connection.on-pointer-up';
 export * from './reassign-connection.prepare-drag-sequence';

package/f-draggable/connections/reassign-connection/reassign-connection.drag-handler.d.ts

@@ -1,19 +1,19 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../../i-draggable-item';
 import { EFDraggableType } from '../../e-f-draggable-type';
-import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../../domain';
+import { GetInputRectInFlowHandler } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
+import { FFlowMediator } from '../../../f-mediator';
 export declare class ReassignConnectionDragHandler implements IDraggableItem {
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     connection: FConnectionBase;
     readonly type: EFDraggableType;
     private onPointerDownFromConnectorRect;
     private onPointerDownToConnectorRect;
     private outputSide;
     private inputSide;
-    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase);
+    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, fMediator: FFlowMediator, connection: FConnectionBase);
     initialize(): void;
     move(difference: IPoint): void;
     complete(): void;

package/f-draggable/connections/reassign-connection/reassign-connection.prepare-drag-sequence.d.ts

@@ -1,19 +1,19 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../../f-components-store';
 import { FDraggableDataContext } from '../../f-draggable-data-context';
-import { GetConnectionHandler, GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler, UpdateConnectionLayerHandler } from '../../../domain';
+import { GetConnectionHandler, GetInputRectInFlowHandler, UpdateConnectionLayerHandler } from '../../../domain';
+import { FFlowMediator } from '../../../f-mediator';
 import * as i0 from "@angular/core";
 export declare class ReassignConnectionPrepareDragSequence implements IHandler<IPointerEvent, void> {
     private fComponentsStore;
     private fDraggableDataContext;
     private getConnectionHandler;
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     private updateConnectionLayerHandler;
     private get transform();
     private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getConnectionHandler: GetConnectionHandler, getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, updateConnectionLayerHandler: UpdateConnectionLayerHandler);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getConnectionHandler: GetConnectionHandler, getInputRectInFlowHandler: GetInputRectInFlowHandler, fMediator: FFlowMediator, updateConnectionLayerHandler: UpdateConnectionLayerHandler);
     handle(event: IPointerEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionPrepareDragSequence, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionPrepareDragSequence>;

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

@@ -1,7 +1,7 @@
 import { IPoint, IRect } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
 import { EFDraggableType } from '../e-f-draggable-type';
-import { FExternalItemBase } from '../components';
+import { FExternalItemBase } from '../../f-external-item';
 export declare class ExternalItemDragHandler implements IDraggableItem {
     externalItem: FExternalItemBase;
     readonly type = EFDraggableType.PALETTE_ITEM;

package/f-draggable/external-item/external-item.prepare-drag-sequence.d.ts

@@ -1,7 +1,7 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
-import { FExternalItemService } from '../components';
 import { FComponentsStore } from '../../f-components-store';
 import { FDraggableDataContext } from '../f-draggable-data-context';
+import { FExternalItemService } from '../../f-external-item';
 import * as i0 from "@angular/core";
 export declare class ExternalItemPrepareDragSequence implements IHandler<IPointerEvent, void> {
     private fComponentsStore;

package/f-draggable/external-item/{create-node.event.d.ts → f-create-node.event.d.ts}

@@ -1,5 +1,5 @@
 import { IRect } from '@foblex/core';
-export declare class CreateNodeEvent<TData = any> {
+export declare class FCreateNodeEvent<TData = any> {
     rect: IRect;
     data: TData;
     constructor(rect: IRect, data: TData);

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

@@ -1,4 +1,4 @@
-export * from './create-node.event';
+export * from './f-create-node.event';
 export * from './external-item.prepare-drag-sequence';
 export * from './external-item.drag-handler';
 export * from './external-item.on-pointer-up';

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

@@ -1,18 +1,18 @@
 import { IHasHostElement } from '@foblex/core';
 import { EventEmitter, InjectionToken, NgZone } from '@angular/core';
-import { CreateNodeEvent } from './external-item';
-import { ReassignConnectionEvent } from './connections/reassign-connection/reassign-connection.event';
-import { CreateConnectionEvent } from './connections/create-connection/create-connection.event';
-import { SelectionChangeEvent } from './single-select';
+import { FCreateNodeEvent } from './external-item';
+import { FReassignConnectionEvent } from './connections/reassign-connection/f-reassign-connection.event';
+import { FCreateConnectionEvent } from './connections/create-connection/f-create-connection.event';
+import { FSelectionChangeEvent } from './single-select';
 import { IDragAndDropBase } from './i-drag-and-drop-base';
 import * as i0 from "@angular/core";
 export declare const F_DRAGGABLE: InjectionToken<FDraggableBase>;
 export declare abstract class FDraggableBase extends IDragAndDropBase implements IHasHostElement {
     abstract hostElement: HTMLElement;
-    abstract fSelectionChange: EventEmitter<SelectionChangeEvent>;
-    abstract fCreateNode: EventEmitter<CreateNodeEvent>;
-    abstract fReassignConnection: EventEmitter<ReassignConnectionEvent>;
-    abstract fCreateConnection: EventEmitter<CreateConnectionEvent>;
+    abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
+    abstract fCreateNode: EventEmitter<FCreateNodeEvent>;
+    abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
+    abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     protected constructor(ngZone: NgZone);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;

package/f-draggable/f-draggable-data-context.d.ts

@@ -1,7 +1,8 @@
 import { Point } from '@foblex/core';
 import { IDraggableItem } from './i-draggable-item';
-import { FLineAlignmentBase, FSelectionAreaBase } from './components';
 import { ISelectable } from '../f-connection';
+import { FLineAlignmentBase } from '../f-line-alignment';
+import { FSelectionAreaBase } from '../f-selection-area';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
     selectedItems: ISelectable[];

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

@@ -2,10 +2,10 @@ import { AfterViewInit, ElementRef, EventEmitter, Injector, NgZone, OnDestroy, O
 import { FDraggableBase } from './f-draggable-base';
 import { FComponentsStore } from '../f-components-store';
 import { FDraggableDataContext } from './f-draggable-data-context';
-import { CreateNodeEvent } from './external-item';
+import { FCreateNodeEvent } from './external-item';
 import { IPointerEvent } from '@foblex/core';
-import { SelectionChangeEvent } from './single-select';
-import { CreateConnectionEvent, ReassignConnectionEvent } from './connections';
+import { FSelectionChangeEvent } from './single-select';
+import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
     private elementReference;
@@ -15,10 +15,10 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     private subscriptions$;
     disabled: boolean;
     get hostElement(): HTMLElement;
-    fSelectionChange: EventEmitter<SelectionChangeEvent>;
-    fCreateNode: EventEmitter<CreateNodeEvent>;
-    fReassignConnection: EventEmitter<ReassignConnectionEvent>;
-    fCreateConnection: EventEmitter<CreateConnectionEvent>;
+    fSelectionChange: EventEmitter<FSelectionChangeEvent>;
+    fCreateNode: EventEmitter<FCreateNodeEvent>;
+    fReassignConnection: EventEmitter<FReassignConnectionEvent>;
+    fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     private readonly document;
     private selectedItemsOnPointerDown;
     constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext, ngZone: NgZone, injector: Injector, fComponentsStore: FComponentsStore, document: any);

package/f-draggable/{public-api.d.ts → index.d.ts}

@@ -1,5 +1,4 @@
 export * from './canvas';
-export * from './components';
 export * from './connections';
 export * from './external-item';
 export * from './node';

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

@@ -1,19 +1,19 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
 import { EFDraggableType } from '../e-f-draggable-type';
-import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
+import { GetInputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
+import { FFlowMediator } from '../../f-mediator';
 export declare class ConnectionSourceDragHandler implements IDraggableItem {
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     private connection;
     readonly type: EFDraggableType;
     private fromConnectorRect;
     private fromConnectorSide;
     private toConnectorRect;
     private toConnectorSide;
-    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase);
+    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, fMediator: FFlowMediator, connection: FConnectionBase);
     initialize(): void;
     move(difference: IPoint): void;
 }

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

@@ -1,19 +1,19 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
 import { EFDraggableType } from '../e-f-draggable-type';
-import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
+import { GetInputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
+import { FFlowMediator } from '../../f-mediator';
 export declare class ConnectionTargetDragHandler implements IDraggableItem {
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     private connection;
     readonly type: EFDraggableType;
     private fromConnectorRect;
     private fromConnectorSide;
     private toConnectorRect;
     private toConnectorSide;
-    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase);
+    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, fMediator: FFlowMediator, connection: FConnectionBase);
     initialize(): void;
     move(difference: IPoint): void;
 }

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

@@ -1,18 +1,18 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
 import { EFDraggableType } from '../e-f-draggable-type';
-import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
+import { GetInputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
+import { FFlowMediator } from '../../f-mediator';
 export declare class ConnectionDragHandler implements IDraggableItem {
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     connection: FConnectionBase;
     readonly type = EFDraggableType.CONNECTION;
     private onPointerDownVector;
     private fromConnectorSide;
     private toConnectorSide;
-    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase);
+    constructor(getInputRectInFlowHandler: GetInputRectInFlowHandler, fMediator: FFlowMediator, connection: FConnectionBase);
     initialize(): void;
     move(difference: IPoint): void;
 }

package/f-draggable/node/node.prepare-drag-sequence.d.ts

@@ -1,20 +1,20 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../f-components-store';
 import { FDraggableDataContext } from '../f-draggable-data-context';
-import { GetConnectionVectorHandler, GetIncomingConnectionsHandler, GetInputRectInFlowHandler, GetOutgoingConnectionsHandler, GetOutputRectInFlowHandler, UpdateNodeLayerHandler } from '../../domain';
+import { GetIncomingConnectionsHandler, GetInputRectInFlowHandler, GetOutgoingConnectionsHandler, UpdateNodeLayerHandler } from '../../domain';
+import { FFlowMediator } from '../../f-mediator';
 import * as i0 from "@angular/core";
 export declare class NodePrepareDragSequence implements IHandler<IPointerEvent, void> {
     private fComponentsStore;
     private fDraggableDataContext;
     private updateNodeLayerHandler;
     private getInputRectInFlowHandler;
-    private getOutputRectInFlowHandler;
     private getOutgoingConnectionsHandler;
     private getIncomingConnectionsHandler;
-    private getConnectionVectorHandler;
+    private fMediator;
     private get transform();
     private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, updateNodeLayerHandler: UpdateNodeLayerHandler, getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler, getConnectionVectorHandler: GetConnectionVectorHandler);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, updateNodeLayerHandler: UpdateNodeLayerHandler, getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler, fMediator: FFlowMediator);
     handle(event: IPointerEvent): void;
     private calculateDraggableConnectionsAndNodes;
     private getInputsForNode;

package/f-draggable/single-select/{selection-change-event.d.ts → f-selection-change-event.d.ts}

@@ -1,4 +1,4 @@
-export declare class SelectionChangeEvent {
+export declare class FSelectionChangeEvent {
     nodes: string[];
     connections: string[];
     constructor(nodes: string[], connections: string[]);

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

@@ -1,3 +1,3 @@
 export * from './providers';
-export * from './selection-change-event';
+export * from './f-selection-change-event';
 export * from './single-select.on-pointer-down';

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

@@ -3,19 +3,19 @@ import { FFlowBase } from './f-flow-base';
 import { FComponentsStore } from '../f-components-store';
 import { GetAllNodesRectHandler } from '../domain';
 import { IRect } from '@foblex/core';
-import { RedrawConnectionsHandler } from './domain/redraw-connections/redraw-connections.handler';
+import { FFlowMediator } from '../f-mediator';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private elementReference;
-    private redrawConnectionsHandler;
     private getAllNodesRectHandler;
     private fComponentsStore;
+    private fMediator;
     private subscription$;
     fFlowId: string;
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
     private isLoaded;
-    constructor(elementReference: ElementRef<HTMLElement>, redrawConnectionsHandler: RedrawConnectionsHandler, getAllNodesRectHandler: GetAllNodesRectHandler, fComponentsStore: FComponentsStore);
+    constructor(elementReference: ElementRef<HTMLElement>, getAllNodesRectHandler: GetAllNodesRectHandler, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     private subscribeOnElementsChanges;

package/f-flow/index.d.ts

@@ -1,3 +1,2 @@
-export * from './domain/redraw-connections/redraw-connections.handler';
 export * from './f-flow.component';
 export * from './f-flow-base';

package/f-flow.module.d.ts

@@ -16,9 +16,9 @@ import * as i14 from "./f-connectors/f-node-input/f-node-input.directive";
 import * as i15 from "./f-connectors/f-node-outlet/f-node-outlet.directive";
 import * as i16 from "./f-connectors/f-node-output/f-node-output.directive";
 import * as i17 from "./f-draggable/f-draggable.directive";
-import * as i18 from "./f-draggable/components/f-external-item/f-external-item.directive";
-import * as i19 from "./f-draggable/components/f-selection-area/f-selection-area.component";
-import * as i20 from "./f-draggable/components/f-line-alignment/f-line-alignment.component";
+import * as i18 from "./f-external-item/f-external-item.directive";
+import * as i19 from "./f-selection-area/f-selection-area.component";
+import * as i20 from "./f-line-alignment/f-line-alignment.component";
 import * as i21 from "@angular/common";
 export declare class FFlowModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowModule, never>;

package/{f-draggable/components/f-line-alignment → f-line-alignment}/f-line-alignment-base.d.ts

@@ -1,7 +1,7 @@
 import { IHasHostElement, IPoint } from '@foblex/core';
 import { InjectionToken } from '@angular/core';
 import { ILineAlignmentResult } from './domain';
-import { FNodeBase } from '../../../f-node';
+import { FNodeBase } from '../f-node';
 import * as i0 from "@angular/core";
 export declare const F_LINE_ALIGNMENT: InjectionToken<FLineAlignmentBase>;
 export declare abstract class FLineAlignmentBase implements IHasHostElement {

package/{f-draggable/components/f-line-alignment → f-line-alignment}/f-line-alignment.component.d.ts

@@ -2,10 +2,10 @@ import { ElementRef, OnInit } from '@angular/core';
 import { IPoint } from '@foblex/core';
 import { ILineAlignmentResult } from './domain';
 import { FLineAlignmentBase } from './f-line-alignment-base';
-import { FComponentsStore } from '../../../f-components-store';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
-import { GetElementRectInFlowHandler } from '../../../domain';
-import { FNodeBase } from '../../../f-node';
+import { FComponentsStore } from '../f-components-store';
+import { FDraggableDataContext } from '../f-draggable';
+import { GetElementRectInFlowHandler } from '../domain';
+import { FNodeBase } from '../f-node';
 import * as i0 from "@angular/core";
 export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
     private elementReference;

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

@@ -0,0 +1,12 @@
+import { Injector, Type } from '@angular/core';
+import { IHandler } from '@foblex/core';
+import * as i0 from "@angular/core";
+export declare class FFlowMediator {
+    private injector;
+    constructor(injector: Injector);
+    private static handlers;
+    static register<TRequest, TResponse>(type: Type<TRequest>, handler: Type<IHandler<TRequest, TResponse>>): void;
+    send<TResponse>(request: any): TResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FFlowMediator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FFlowMediator>;
+}

package/f-mediator/f-handler-register.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@angular/core';
+import { IHandler } from '@foblex/core';
+type Constructor<T = any> = new (...args: any[]) => T;
+export declare function FHandlerRegister<TRequest, TResponse>(requestType: Type<TRequest>): (constructor: Constructor<IHandler<TRequest, TResponse>>) => void;
+export {};

package/f-mediator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-flow-mediator';
+export * from './f-handler-register';

package/{f-draggable/components/f-selection-area → f-selection-area}/f-selection-area.component.d.ts

@@ -1,7 +1,7 @@
 import { ElementRef, OnInit } from '@angular/core';
 import { FSelectionAreaBase } from './f-selection-area-base';
-import { FDraggableDataContext } from '../../f-draggable-data-context';
 import { ISelectionAreaRect } from './domain';
+import { FDraggableDataContext } from '../f-draggable';
 import * as i0 from "@angular/core";
 export declare class FSelectionAreaComponent extends FSelectionAreaBase implements OnInit {
     private elementReference;