@foblex/flow 1.2.2 → 1.2.4

package/common-behaviours/change-position.d.ts

@@ -1,5 +1,6 @@
 import { AbstractConstructor, Constructor } from './constructor';
-import { IPoint, ITransformable } from '@foblex/core';
+import { IPoint } from '@foblex/core';
+import { ITransformable } from './i-transformable';
 export interface ICanChangePosition {
     setPosition(position: IPoint): void;
     getPosition(): IPoint;

package/common-behaviours/change-zoom/change-zoom.d.ts

@@ -1,6 +1,6 @@
 import { AbstractConstructor, Constructor } from '../constructor';
 import { ICanChangeZoom } from './i-can-change-zoom';
-import { ITransformable } from '@foblex/core';
+import { ITransformable } from '../i-transformable';
 type CanChangeZoomConstructor = Constructor<ICanChangeZoom> & AbstractConstructor<ICanChangeZoom>;
 export declare function mixinChangeZoom<T extends AbstractConstructor<ITransformable>>(base: T): CanChangeZoomConstructor & T;
 export {};

package/common-behaviours/fit-to-parent/fit-to-parent.d.ts

@@ -1,6 +1,6 @@
 import { AbstractConstructor, Constructor } from '../constructor';
 import { ICanFitToParent } from './i-can-fit-to-parent';
-import { ITransformable } from '@foblex/core';
+import { ITransformable } from '../i-transformable';
 type CanFitToParentConstructor = Constructor<ICanFitToParent> & AbstractConstructor<ICanFitToParent>;
 export declare function mixinFitToParent<T extends AbstractConstructor<ITransformable>>(base: T): CanFitToParentConstructor & T;
 export {};

package/common-behaviours/i-transformable.d.ts

@@ -0,0 +1,4 @@
+import { ITransformModel } from '@foblex/core';
+export interface ITransformable {
+    transform: ITransformModel;
+}

package/common-behaviours/index.d.ts

@@ -3,3 +3,4 @@ export * from './fit-to-parent';
 export * from './one-to-one-centering';
 export * from './change-position';
 export * from './constructor';
+export * from './i-transformable';

package/common-behaviours/one-to-one-centering/one-to-one-centering.d.ts

@@ -1,6 +1,6 @@
 import { AbstractConstructor, Constructor } from '../constructor';
 import { ICanOneToOneCentering } from './i-can-one-to-one-centering';
-import { ITransformable } from '@foblex/core';
+import { ITransformable } from '../i-transformable';
 type CanOneToOneCenteringConstructor = Constructor<ICanOneToOneCentering> & AbstractConstructor<ICanOneToOneCentering>;
 export declare function mixinOneToOneCentering<T extends AbstractConstructor<ITransformable>>(base: T): CanOneToOneCenteringConstructor & T;
 export {};

package/components/f-flow/f-backgroud/domain/i-f-background-pattern.d.ts

@@ -0,0 +1,6 @@
+import { ITransformModel } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+export declare const F_BACKGROUND_PATTERN: InjectionToken<IFBackgroundPattern>;
+export interface IFBackgroundPattern {
+    setTransform(transform: ITransformModel): void;
+}

package/components/f-flow/f-backgroud/domain/index.d.ts

@@ -0,0 +1 @@
+export * from './i-f-background-pattern';

package/components/f-flow/f-backgroud/domain/public-api.d.ts

@@ -0,0 +1 @@
+export * from './i-f-background-pattern';

package/{internal → components/f-flow}/f-backgroud/f-background-base.d.ts

@@ -1,15 +1,11 @@
-import { ElementRef, InjectionToken } from '@angular/core';
+import { InjectionToken } from '@angular/core';
 import { IHasHostElement, ITransformModel } from '@foblex/core';
-import { FCanvasBase } from '../f-canvas';
 import * as i0 from "@angular/core";
 export declare const F_BACKGROUND: InjectionToken<FBackgroundBase>;
 export declare abstract class FBackgroundBase implements IHasHostElement {
-    private elementReference;
-    private fCanvas;
-    transform: ITransformModel;
-    get hostElement(): SVGGElement;
-    protected constructor(elementReference: ElementRef<SVGGElement>, fCanvas: FCanvasBase);
-    isBackgroundElement(element: HTMLElement | SVGElement): boolean;
+    abstract hostElement: HTMLElement;
+    abstract isBackgroundElement(element: HTMLElement | SVGElement): boolean;
+    abstract setTransform(transform: ITransformModel): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FBackgroundBase, never, never, {}, {}, never, never, false, never>;
 }

package/components/f-flow/f-backgroud/f-background.component.d.ts

@@ -0,0 +1,20 @@
+import { AfterContentInit, ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { FBackgroundBase } from './f-background-base';
+import { FComponentsStore } from '../../../f-components-store';
+import { ITransformModel } from '@foblex/core';
+import * as i0 from "@angular/core";
+export declare class FBackgroundComponent extends FBackgroundBase implements OnInit, AfterContentInit, OnDestroy {
+    private elementReference;
+    private fComponentsStore;
+    private changeDetectorRef;
+    get hostElement(): HTMLElement;
+    fBackgroundPattern: FBackgroundBase | undefined;
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    isBackgroundElement(element: HTMLElement | SVGElement): boolean;
+    setTransform(transform: ITransformModel): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FBackgroundComponent, "f-background", never, {}, {}, ["fBackgroundPattern"], ["*"], false, never>;
+}

package/components/f-flow/f-backgroud/f-cell-pattern/f-cell-pattern.component.d.ts

@@ -0,0 +1,31 @@
+import { ChangeDetectorRef, ElementRef, OnInit } from "@angular/core";
+import { ITransformModel } from '@foblex/core';
+import { IFBackgroundPattern } from '../domain';
+import * as i0 from "@angular/core";
+export declare class FCellPatternComponent implements OnInit, IFBackgroundPattern {
+    private elementReference;
+    private changeDetectorRef;
+    id: string;
+    verticalLineColor: string;
+    horizontalLineColor: string;
+    get hostElement(): HTMLElement;
+    private transform;
+    x: number;
+    y: number;
+    private defaultCellSize;
+    cellSize: number;
+    private pattern;
+    private horizontalLine;
+    private verticalLine;
+    constructor(elementReference: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    private createPatternDom;
+    private calculatePattern;
+    private redraw;
+    private redrawPattern;
+    private redrawHorizontalLine;
+    private redrawVerticalLine;
+    setTransform(transform: ITransformModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FCellPatternComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCellPatternComponent, "f-cell-pattern", never, { "id": { "alias": "id"; "required": false; }; "verticalLineColor": { "alias": "verticalLineColor"; "required": false; }; "horizontalLineColor": { "alias": "horizontalLineColor"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/f-flow/f-backgroud/f-cell-pattern/index.d.ts

@@ -0,0 +1 @@
+export * from './f-cell-pattern.component';

package/components/f-flow/f-backgroud/f-cell-pattern/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-cell-pattern.component';

package/components/f-flow/f-backgroud/index.d.ts

@@ -0,0 +1,4 @@
+export * from './domain';
+export * from './f-cell-pattern';
+export * from './f-background.component';
+export * from './f-background-base';

package/components/f-flow/f-backgroud/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './domain/public-api';
+export * from './f-cell-pattern/public-api';
+export * from './f-background.component';

package/{directives/f-containers/f-items-container/canvas-change.event.d.ts → components/f-flow/f-canvas/domain/f-canvas-change.event.d.ts}

@@ -1,5 +1,5 @@
 import { IPoint } from '@foblex/core';
-export declare class CanvasChangeEvent {
+export declare class FCanvasChangeEvent {
     readonly position: IPoint;
     readonly scale: number;
     constructor(position: IPoint, scale: number);

package/components/f-flow/f-canvas/domain/index.d.ts

@@ -0,0 +1 @@
+export * from './f-canvas-change.event';

package/components/f-flow/f-canvas/domain/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-canvas-change.event';

package/{directives/f-containers/f-items-container/f-items-container-base.d.ts → components/f-flow/f-canvas/f-canvas-base.d.ts}

@@ -1,24 +1,25 @@
 import { IHasHostElement, ITransformModel } from '@foblex/core';
 import { ElementRef, EventEmitter, InjectionToken } from '@angular/core';
 import { ICanChangePosition, ICanChangeZoom, ICanFitToParent, ICanOneToOneCentering } from '../../../common-behaviours';
-import { CanvasChangeEvent } from './canvas-change.event';
+import { FCanvasChangeEvent } from './domain/f-canvas-change.event';
+import { FNodeBase } from '../../../f-node';
 import * as i0 from "@angular/core";
-export declare const F_ITEMS_CONTAINER: InjectionToken<FItemsContainerBase>;
+export declare const F_CANVAS: InjectionToken<FCanvasBase>;
 declare const MIXIN_BASE: import("../../../common-behaviours").Constructor<ICanChangePosition> & import("../../../common-behaviours").AbstractConstructor<ICanChangePosition> & import("../../../common-behaviours").Constructor<ICanFitToParent> & import("../../../common-behaviours").AbstractConstructor<ICanFitToParent> & import("../../../common-behaviours").Constructor<ICanOneToOneCentering> & import("../../../common-behaviours").AbstractConstructor<ICanOneToOneCentering> & import("../../../common-behaviours").Constructor<ICanChangeZoom> & import("../../../common-behaviours").AbstractConstructor<ICanChangeZoom> & {
     new (transform: ITransformModel): {
         transform: ITransformModel;
     };
 };
-export declare abstract class FItemsContainerBase extends MIXIN_BASE implements IHasHostElement, ICanChangePosition, ICanFitToParent, ICanOneToOneCentering, ICanChangeZoom {
-    private elementReference;
-    abstract canvasChange: EventEmitter<CanvasChangeEvent>;
-    get hostElement(): SVGGElement;
-    protected constructor(elementReference: ElementRef<SVGGElement>);
-    parseData(): void;
-    redraw(): void;
-    redrawWithAnimation(): void;
+export declare abstract class FCanvasBase extends MIXIN_BASE implements IHasHostElement, ICanChangePosition, ICanFitToParent, ICanOneToOneCentering, ICanChangeZoom {
+    abstract fCanvasChange: EventEmitter<FCanvasChangeEvent>;
+    abstract fNodes: FNodeBase[];
+    abstract hostElement: HTMLElement;
+    abstract fNodesContainer: ElementRef<HTMLElement>;
+    protected constructor();
+    abstract redraw(): void;
+    abstract redrawWithAnimation(): void;
     completeDrag(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FItemsContainerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FItemsContainerBase, never, never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never, never, false, never>;
 }
 export {};

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

@@ -0,0 +1,28 @@
+import { ElementRef, EventEmitter, OnInit } from "@angular/core";
+import { FCanvasBase } from './f-canvas-base';
+import { IPoint } from '@foblex/core';
+import { FCanvasChangeEvent } from './domain';
+import { FComponentsStore } from '../../../f-components-store';
+import { GetAllNodesRectHandler } from '../../../domain';
+import { FNodeBase } from '../../../f-node';
+import * as i0 from "@angular/core";
+export declare class FCanvasComponent extends FCanvasBase implements OnInit {
+    private getAllNodesRectHandler;
+    private elementReference;
+    private fComponentsStore;
+    fCanvasChange: EventEmitter<FCanvasChangeEvent>;
+    set position(value: IPoint | undefined);
+    set scale(value: number | undefined);
+    get fNodes(): FNodeBase[];
+    get hostElement(): HTMLElement;
+    onInitialized: EventEmitter<void>;
+    fNodesContainer: ElementRef<HTMLElement>;
+    constructor(getAllNodesRectHandler: GetAllNodesRectHandler, elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore);
+    ngOnInit(): void;
+    redraw(): void;
+    redrawWithAnimation(): void;
+    fitToScreen(toCenter?: IPoint, animated?: boolean): void;
+    oneToOne(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCanvasComponent, "f-canvas", ["fComponent"], { "position": { "alias": "position"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; }, { "fCanvasChange": "fCanvasChange"; "onInitialized": "onInitialized"; }, never, ["f-connection", "f-connection-for-create", "f-node"], false, never>;
+}

package/components/f-flow/f-canvas/f-zoom/f-zoom-base.d.ts

@@ -0,0 +1,26 @@
+import { IPoint } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+import { FComponentsStore } from '../../../../f-components-store';
+export declare const F_ZOOM: InjectionToken<FZoomBase>;
+export declare abstract class FZoomBase {
+    protected fComponentsStore: FComponentsStore;
+    protected isEnabled: boolean;
+    abstract minimum: number;
+    abstract maximum: number;
+    abstract step: number;
+    abstract dblClickStep: number;
+    private listeners;
+    private get flowHost();
+    private get fCanvas();
+    protected constructor(fComponentsStore: FComponentsStore);
+    protected toggleZoom(): void;
+    private subscribe;
+    getScale(): number;
+    private onWheel;
+    private onDoubleClick;
+    private onZoomToCenter;
+    zoomIn(position?: IPoint): void;
+    zoomOut(position?: IPoint): void;
+    reset(): void;
+    protected unsubscribe(): void;
+}

package/components/f-flow/f-canvas/f-zoom/f-zoom.directive.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit, OnDestroy } from "@angular/core";
+import { FZoomBase } from './f-zoom-base';
+import { FComponentsStore } from '../../../../f-components-store';
+import * as i0 from "@angular/core";
+export declare class FZoomDirective extends FZoomBase implements AfterViewInit, OnDestroy {
+    get fFlowZoom(): boolean;
+    set fFlowZoom(isEnabled: boolean | undefined | string);
+    minimum: number;
+    maximum: number;
+    step: number;
+    dblClickStep: number;
+    constructor(fComponentsStore: FComponentsStore);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FZoomDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FZoomDirective, "f-canvas[fZoom]", ["fComponent"], { "fFlowZoom": { "alias": "fZoom"; "required": false; }; "minimum": { "alias": "fZoomMinimum"; "required": false; }; "maximum": { "alias": "fZoomMaximum"; "required": false; }; "step": { "alias": "fZoomStep"; "required": false; }; "dblClickStep": { "alias": "fZoomDblClickStep"; "required": false; }; }, {}, never, never, false, never>;
+}

package/components/f-flow/f-canvas/index.d.ts

@@ -0,0 +1,4 @@
+export * from './domain';
+export * from './f-zoom';
+export * from './f-canvas.component';
+export * from './f-canvas-base';

package/components/f-flow/f-canvas/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './domain/public-api';
+export * from './f-zoom/public-api';
+export * from './f-canvas.component';

package/components/f-flow/f-definitions/domain/i-connection-marker.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+import { IHasHostElement } from '@foblex/core';
+export declare const F_CONNECTION_MARKER: InjectionToken<IConnectionMarker>;
+export interface IConnectionMarker extends IHasHostElement {
+}

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

@@ -0,0 +1,10 @@
+import { IHasHostElement } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const F_DEFINITIONS: InjectionToken<FDefinitionsBase>;
+export declare abstract class FDefinitionsBase implements IHasHostElement {
+    abstract hostElement: HTMLElement;
+    abstract getMarkersForConnection(connectionId: string, startColor: string, endColor: string): SVGMarkerElement[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDefinitionsBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDefinitionsBase, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,20 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { FDefinitionsBase } from './f-definitions-base';
+import { FComponentsStore } from '../../../f-components-store';
+import { IConnectionMarker } from './domain/i-connection-marker';
+import * as i0 from "@angular/core";
+export declare class FDefinitionsComponent extends FDefinitionsBase implements OnInit, OnDestroy {
+    private elementReference;
+    fComponentsStore: FComponentsStore;
+    private changeDetectorRef;
+    private subscriptions$;
+    get hostElement(): HTMLElement;
+    fMarkers: QueryList<IConnectionMarker>;
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    getMarkersForConnection(connectionId: string, startColor: string, endColor: string): SVGMarkerElement[];
+    private subscribeOnMarkersChanges;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDefinitionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FDefinitionsComponent, "svg[fDefinitions]", ["fComponent"], {}, {}, ["fMarkers"], ["*"], false, never>;
+}

package/components/f-flow/f-definitions/f-markers/f-connection-marker-end-selected.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import { FFlowBase } from '../../f-flow-base';
+import { IConnectionMarker } from '../domain/i-connection-marker';
+import * as i0 from "@angular/core";
+export declare class FConnectionMarkerEndSelectedDirective implements IConnectionMarker {
+    private elementReference;
+    private fFlow;
+    get hostElement(): SVGMarkerElement;
+    protected get id(): string;
+    constructor(elementReference: ElementRef<SVGMarkerElement>, fFlow: FFlowBase);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerEndSelectedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionMarkerEndSelectedDirective, "[fConnectionMarkerEndSelected]", ["fComponent"], {}, {}, never, never, false, never>;
+}

package/components/f-flow/f-definitions/f-markers/f-connection-marker-end.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import { FFlowBase } from '../../f-flow-base';
+import { IConnectionMarker } from '../domain/i-connection-marker';
+import * as i0 from "@angular/core";
+export declare class FConnectionMarkerEndDirective implements IConnectionMarker {
+    private elementReference;
+    private fFlow;
+    get hostElement(): SVGMarkerElement;
+    protected get id(): string;
+    fConnectionMarkerEnd: string;
+    constructor(elementReference: ElementRef<SVGMarkerElement>, fFlow: FFlowBase);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerEndDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionMarkerEndDirective, "[fConnectionMarkerEnd]", ["fComponent"], { "fConnectionMarkerEnd": { "alias": "fConnectionMarkerEnd"; "required": false; }; }, {}, never, never, false, never>;
+}

package/components/f-flow/f-definitions/f-markers/f-connection-marker-start-selected.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+import { FFlowBase } from '../../f-flow-base';
+import { IConnectionMarker } from '../domain/i-connection-marker';
+import * as i0 from "@angular/core";
+export declare class FConnectionMarkerStartSelectedDirective implements IConnectionMarker {
+    private elementReference;
+    private fFlow;
+    get hostElement(): SVGMarkerElement;
+    protected get id(): string;
+    constructor(elementReference: ElementRef<SVGMarkerElement>, fFlow: FFlowBase);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerStartSelectedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionMarkerStartSelectedDirective, "[fConnectionMarkerStartSelected]", ["fComponent"], {}, {}, never, never, false, never>;
+}

package/components/f-flow/f-definitions/f-markers/f-connection-marker-start.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import { FFlowBase } from '../../f-flow-base';
+import { IConnectionMarker } from '../domain/i-connection-marker';
+import * as i0 from "@angular/core";
+export declare class FConnectionMarkerStartDirective implements IConnectionMarker {
+    private elementReference;
+    private fFlow;
+    get hostElement(): SVGMarkerElement;
+    protected get id(): string;
+    fConnectionMarkerStart: string;
+    constructor(elementReference: ElementRef<SVGMarkerElement>, fFlow: FFlowBase);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerStartDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionMarkerStartDirective, "[fConnectionMarkerStart]", ["fComponent"], { "fConnectionMarkerStart": { "alias": "fConnectionMarkerStart"; "required": false; }; }, {}, never, never, false, never>;
+}

package/components/f-flow/f-definitions/f-markers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './f-connection-marker-end.directive';
+export * from './f-connection-marker-end-selected.directive';
+export * from './f-connection-marker-start.directive';
+export * from './f-connection-marker-start-selected.directive';

package/components/f-flow/f-definitions/f-markers/public-api.d.ts

@@ -0,0 +1,4 @@
+export * from './f-connection-marker-end.directive';
+export * from './f-connection-marker-end-selected.directive';
+export * from './f-connection-marker-start.directive';
+export * from './f-connection-marker-start-selected.directive';

package/components/f-flow/f-definitions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './f-markers';
+export * from './f-definitions.component';
+export * from './f-definitions-base';

package/components/f-flow/f-definitions/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './f-markers/public-api';
+export * from './f-definitions.component';

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

@@ -1,40 +1,10 @@
-import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy } from '@angular/core';
-import { IHasHostElement, IPoint, ITransformModel } from '@foblex/core';
-import { FItemsContainerBase, FZoomBase } from '../../directives';
-import { FNodeInputBase, FNodeOutletBase, FNodeOutputBase } from '../f-connectors';
-import { Subject } from 'rxjs';
-import { FBackgroundBase } from '../../internal';
-import { FConnectionsContainerBase } from '../../directives';
-import { FNodesContainerBase } from '../../directives';
+import { InjectionToken } from '@angular/core';
+import { IHasHostElement } from '@foblex/core';
 import * as i0 from "@angular/core";
-export declare const F_FLOW_COMPONENT: InjectionToken<FFlowBase>;
-export declare abstract class FFlowBase implements IHasHostElement, AfterContentInit, OnDestroy {
-    private elementReference;
-    private changeDetectorRef;
-    private ngZone;
+export declare const F_FLOW: InjectionToken<FFlowBase>;
+export declare abstract class FFlowBase implements IHasHostElement {
     abstract id: any;
-    get hostElement(): SVGSVGElement;
-    private readonly onDestroy;
-    abstract fNodesContainer: FNodesContainerBase;
-    abstract fConnectionsContainer: FConnectionsContainerBase;
-    abstract fZoom: FZoomBase | undefined;
-    abstract fItemsContainer: FItemsContainerBase;
-    abstract fBackground: FBackgroundBase;
-    abstract transform: ITransformModel;
-    abstract outlets: FNodeOutletBase[];
-    abstract outputs: FNodeOutputBase[];
-    abstract inputs: FNodeInputBase[];
-    connectorChanges: Subject<void>;
-    abstract onInitialized: EventEmitter<void>;
-    protected constructor(elementReference: ElementRef<SVGSVGElement>, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
-    ngAfterViewInit(): void;
-    ngAfterContentInit(): void;
-    protected subscribeOnComponentsChanges(): void;
-    fitToScreen(toCenter?: IPoint, animated?: boolean): void;
-    oneToOne(): void;
-    zoomIn(): void;
-    zoomOut(): void;
-    ngOnDestroy(): void;
+    abstract hostElement: HTMLElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FFlowBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -1,37 +1,27 @@
-import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone } from '@angular/core';
-import { FItemsContainerBase, FZoomBase } from '../../directives';
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FFlowBase } from './f-flow-base';
-import { ITransformModel } from '@foblex/core';
-import { FNodesContainerBase } from '../../directives';
-import { FConnectionsContainerBase } from '../../directives';
-import { FBackgroundBase } from '../../internal';
-import { IFlowConnectorParent } from './i-flow-connector-parent';
-import { FConnectorBase, FNodeInputBase, FNodeOutletBase, FNodeOutputBase } from '../f-connectors';
+import { FComponentsStore } from '../../f-components-store';
+import { GetAllNodesRectHandler, GetConnectionVectorHandler, GetElementRectInFlowHandler } from '../../domain';
+import { IRect } from '@foblex/core';
 import * as i0 from "@angular/core";
-import * as i1 from "../../internal/f-canvas/f-canvas.directive";
-export declare const CONNECTION_MARKER_START = "connection-marker-start";
-export declare const CONNECTION_MARKER_END = "connection-marker-end";
-export declare const CONNECTION_MARKER_START_SELECTED = "connection-marker-start-selected";
-export declare const CONNECTION_MARKER_END_SELECTED = "connection-marker-end-selected";
-export declare class FFlowComponent extends FFlowBase implements IFlowConnectorParent {
-    readonly CONNECTION_MARKER_START = "connection-marker-start";
-    readonly CONNECTION_MARKER_END = "connection-marker-end";
-    readonly CONNECTION_MARKER_START_SELECTED = "connection-marker-start-selected";
-    readonly CONNECTION_MARKER_END_SELECTED = "connection-marker-end-selected";
+export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
+    private elementReference;
+    private getElementRectInFlowHandler;
+    private getConnectionVectorHandler;
+    private getAllNodesRectHandler;
+    private fComponentsStore;
     id: string;
-    fNodesContainer: FNodesContainerBase;
-    fConnectionsContainer: FConnectionsContainerBase;
-    fItemsContainer: FItemsContainerBase;
-    fBackground: FBackgroundBase;
-    fZoom: FZoomBase | undefined;
-    outlets: FNodeOutletBase[];
-    outputs: FNodeOutputBase[];
-    inputs: FNodeInputBase[];
-    get transform(): ITransformModel;
-    onInitialized: EventEmitter<void>;
-    constructor(elementReference: ElementRef<SVGSVGElement>, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
-    addConnector(connector: FConnectorBase): void;
-    removeConnector(connector: FConnectorBase): void;
+    get hostElement(): HTMLElement;
+    private readonly onDestroy;
+    onInitialized: EventEmitter<IRect>;
+    private isInitialized;
+    constructor(elementReference: ElementRef<HTMLElement>, getElementRectInFlowHandler: GetElementRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, getAllNodesRectHandler: GetAllNodesRectHandler, fComponentsStore: FComponentsStore);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    private subscribeOnElementsChanges;
+    private calculateConnections;
+    getNodesRect(): IRect;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "svg[fFlow]", never, { "id": { "alias": "id"; "required": false; }; }, { "onInitialized": "onInitialized"; }, ["fNodesContainer", "fConnectionsContainer", "fItemsContainer", "fZoom"], ["*"], false, [{ directive: typeof i1.FCanvasDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "id": { "alias": "id"; "required": false; }; }, { "onInitialized": "onInitialized"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area"], false, never>;
 }

package/components/f-flow/f-parent.injection-token.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+export declare const F_PARENT: InjectionToken<unknown>;
+export interface IHasId<T = string> {
+    id: T;
+}

package/components/f-flow/index.d.ts

@@ -1,2 +1,6 @@
+export * from './f-backgroud';
+export * from './f-canvas';
+export * from './f-definitions';
 export * from './f-flow.component';
 export * from './f-flow-base';
+export * from './f-parent.injection-token';

package/components/f-flow/public-api.d.ts

@@ -1 +1,4 @@
+export * from './f-backgroud/public-api';
+export * from './f-canvas/public-api';
+export * from './f-definitions/public-api';
 export * from './f-flow.component';

package/components/index.d.ts

@@ -1,4 +1 @@
-export * from './f-connection';
-export * from './f-connectors';
 export * from './f-flow';
-export * from './f-node';

package/components/public-api.d.ts

@@ -1,4 +1 @@
-export * from './f-connection/public-api';
-export * from './f-connectors/public-api';
 export * from './f-flow/public-api';
-export * from './f-node/public-api';

package/domain/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function OutputNotFound(outputId: any): Error;
+export declare function InputNotFound(inputId: any): Error;
+export declare function requiredOutput(): Error;

package/domain/get-all-nodes-rect.handler.d.ts

@@ -0,0 +1,10 @@
+import { IHandler, IRect } from '@foblex/core';
+import { FComponentsStore } from '../f-components-store';
+import * as i0 from "@angular/core";
+export declare class GetAllNodesRectHandler implements IHandler<void, IRect> {
+    private fComponentsStore;
+    constructor(fComponentsStore: FComponentsStore);
+    handle(): IRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetAllNodesRectHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetAllNodesRectHandler>;
+}

package/domain/get-connection-vector/get-connection-vector.handler.d.ts

@@ -0,0 +1,12 @@
+import { IHandler, IVector } from '@foblex/core';
+import { GetConnectionVectorRequest } from './get-connection-vector.request';
+import * as i0 from "@angular/core";
+export declare class GetConnectionVectorHandler implements IHandler<GetConnectionVectorRequest, IVector> {
+    private behaviorHandlers;
+    handle(payload: GetConnectionVectorRequest): IVector;
+    private floatingBehavior;
+    private fixedBehavior;
+    private fixedOutboundBehaviour;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetConnectionVectorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetConnectionVectorHandler>;
+}

package/domain/get-connection-vector/get-connection-vector.request.d.ts

@@ -0,0 +1,11 @@
+import { IRect } from '@foblex/core';
+import { EConnectorSide } from '../get-connector-side-in-node';
+import { EConnectionBehavior } from '../../f-connection';
+export declare class GetConnectionVectorRequest {
+    outputRect: IRect;
+    inputRect: IRect;
+    behavior: EConnectionBehavior | string;
+    outputSide: EConnectorSide;
+    inputSide: EConnectorSide;
+    constructor(outputRect: IRect, inputRect: IRect, behavior: EConnectionBehavior | string, outputSide: EConnectorSide, inputSide: EConnectorSide);
+}

package/domain/get-connection-vector/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-connection-vector.handler';
+export * from './get-connection-vector.request';