@foblex/flow 17.0.0 → 17.0.2

package/f-backgroud/f-circle-pattern/f-circle-pattern.component.d.ts

@@ -1,34 +1,33 @@
-import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { OnChanges, OnInit, SimpleChanges } from "@angular/core";
 import { ITransformModel } from '@foblex/2d';
 import { IFBackgroundPattern } from '../domain';
 import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
-export declare class FCirclePatternComponent implements OnInit, OnDestroy, IFBackgroundPattern {
-    private elementReference;
-    private fBrowser;
-    private _subscription$;
+export declare class FCirclePatternComponent implements OnInit, OnChanges, IFBackgroundPattern {
+    private _fBrowser;
+    private _destroyRef;
+    private _elementReference;
     private _stateChanges;
     get hostElement(): HTMLElement;
     id: string;
-    private _color;
-    set color(value: string);
-    private _radius;
+    color: string;
+    radius: number;
     private _scaledRadius;
-    set radius(value: number);
     private _transform;
     private _position;
     private _pattern;
     private _circle;
-    constructor(elementReference: ElementRef<HTMLElement>, fBrowser: BrowserService);
-    private createPattern;
+    constructor(_fBrowser: BrowserService);
+    private _createPattern;
     ngOnInit(): void;
-    private subscribeToStateChanges;
-    private calculatePattern;
-    private redraw;
-    private redrawPattern;
-    private redrawElement;
+    private _listenStateChanges;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _redraw;
+    private _calculatePattern;
+    private _redrawPattern;
+    private _redrawElement;
     setTransform(transform: ITransformModel): void;
-    ngOnDestroy(): void;
+    private _refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCirclePatternComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FCirclePatternComponent, "f-circle-pattern", never, { "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-backgroud/f-rect-pattern/f-rect-pattern.component.d.ts

@@ -1,39 +1,36 @@
-import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { OnChanges, OnInit, SimpleChanges } from "@angular/core";
 import { ITransformModel } from '@foblex/2d';
 import { IFBackgroundPattern } from '../domain';
 import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
-export declare class FRectPatternComponent implements OnInit, OnDestroy, IFBackgroundPattern {
-    private elementReference;
-    private fBrowser;
-    private _subscription$;
+export declare class FRectPatternComponent implements OnInit, OnChanges, IFBackgroundPattern {
+    private _fBrowser;
+    private _destroyRef;
+    private _elementReference;
     private _stateChanges;
     get hostElement(): HTMLElement;
     id: string;
-    private _vColor;
-    set vColor(value: string);
-    private _hColor;
-    set hColor(value: string);
-    private _vSize;
-    set vSize(value: number);
-    private _hSize;
-    set hSize(value: number);
+    vColor: string;
+    hColor: string;
+    vSize: number;
+    hSize: number;
     private _transform;
     private _position;
     private _size;
     private _pattern;
     private _vLine;
     private _hLine;
-    constructor(elementReference: ElementRef<HTMLElement>, fBrowser: BrowserService);
-    private createPattern;
+    constructor(_fBrowser: BrowserService);
+    private _createPattern;
     ngOnInit(): void;
-    private subscribeToStateChanges;
-    private calculatePattern;
-    private redraw;
-    private redrawPattern;
+    private _listenStateChanges;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _redraw;
+    private _calculatePattern;
+    private _redrawPattern;
     private redrawLine;
     setTransform(transform: ITransformModel): void;
-    ngOnDestroy(): void;
+    private _refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<FRectPatternComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FRectPatternComponent, "f-rect-pattern", never, { "id": { "alias": "id"; "required": false; }; "vColor": { "alias": "vColor"; "required": false; }; "hColor": { "alias": "hColor"; "required": false; }; "vSize": { "alias": "vSize"; "required": false; }; "hSize": { "alias": "hSize"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -1,13 +1,11 @@
 import { IPoint } from '@foblex/2d';
 import { ElementRef, EventEmitter, InjectionToken } from '@angular/core';
 import { FCanvasChangeEvent } from './domain';
-import { FNodeBase } from '../f-node';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_CANVAS: InjectionToken<FCanvasBase>;
 export declare abstract class FCanvasBase implements IHasHostElement {
     abstract fCanvasChange: EventEmitter<FCanvasChangeEvent>;
-    abstract fNodes: FNodeBase[];
     abstract hostElement: HTMLElement;
     abstract fGroupsContainer: ElementRef<HTMLElement>;
     abstract fNodesContainer: ElementRef<HTMLElement>;

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

@@ -1,33 +1,27 @@
-import { ElementRef, EventEmitter, OnInit } from "@angular/core";
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from "@angular/core";
 import { FCanvasBase } from './f-canvas-base';
 import { IPoint } from '@foblex/2d';
 import { FCanvasChangeEvent } from './domain';
-import { FComponentsStore } from '../f-storage';
-import { FNodeBase } from '../f-node';
-import { FMediator } from '@foblex/mediator';
 import * as i0 from "@angular/core";
-export declare class FCanvasComponent extends FCanvasBase implements OnInit {
-    private elementReference;
-    private fMediator;
-    private fComponentsStore;
+export declare class FCanvasComponent extends FCanvasBase implements OnInit, OnDestroy {
+    private _elementReference;
     fCanvasChange: EventEmitter<FCanvasChangeEvent>;
     set position(value: IPoint | undefined);
     set scale(value: number | undefined);
-    get fNodes(): FNodeBase[];
     get hostElement(): HTMLElement;
     fGroupsContainer: ElementRef<HTMLElement>;
     fNodesContainer: ElementRef<HTMLElement>;
     fConnectionsContainer: ElementRef<HTMLElement>;
-    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FMediator, fComponentsStore: FComponentsStore);
+    private _fMediator;
     ngOnInit(): void;
     redraw(): void;
     redrawWithAnimation(): void;
-    private isMobile;
     centerGroupOrNode(id: string, animated?: boolean): void;
     fitToScreen(toCenter?: IPoint, animated?: boolean): void;
     resetScaleAndCenter(animated?: boolean): void;
     setZoom(scale: number, toPosition?: IPoint): void;
     resetZoom(): void;
+    ngOnDestroy(): 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"; }, never, ["[fGroup]", "f-snap-connection", "f-connection", "f-connection-for-create", "[fNode]"], false, never>;
 }

package/f-connection/common/f-connection-base.d.ts

@@ -1,6 +1,5 @@
 import { ElementRef } from '@angular/core';
 import { ILine, IPoint } from '@foblex/2d';
-import { Subject } from 'rxjs';
 import { EFConnectionBehavior } from './e-f-connection-behavior';
 import { EFConnectionType } from './e-f-connection-type';
 import { IHasConnectionColor } from './i-has-connection-color';
@@ -11,7 +10,6 @@ import { IConnectionGradient } from './f-gradient';
 import { FConnectionDragHandleComponent } from './f-drag-handle';
 import { FConnectionSelectionComponent } from './f-selection';
 import { IConnectionText } from './f-connection-text';
-import { IHasStateChanges } from '../../i-has-state-changes';
 import { EFConnectableSide } from '../../f-connectors';
 import { FConnectionFactory } from '../f-connection-builder';
 import { IHasHostElement } from '../../i-has-host-element';
@@ -22,7 +20,7 @@ declare const MIXIN_BASE: import("../../mixins").Constructor<ICanChangeSelection
         hostElement: HTMLElement;
     };
 };
-export declare abstract class FConnectionBase extends MIXIN_BASE implements IHasHostElement, ICanChangeSelection, ICanChangeVisibility, IHasStateChanges, IHasConnectionColor, IHasConnectionFromTo, IHasConnectionText {
+export declare abstract class FConnectionBase extends MIXIN_BASE implements IHasHostElement, ICanChangeSelection, ICanChangeVisibility, IHasConnectionColor, IHasConnectionFromTo, IHasConnectionText {
     private cFactory;
     abstract fId: string;
     abstract fStartColor: string;
@@ -33,12 +31,11 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements IHas
     abstract fOffset: number;
     path: string;
     line: ILine;
-    readonly stateChanges: Subject<void>;
     abstract fDraggingDisabled: boolean;
     abstract fSelectionDisabled: boolean;
     abstract boundingElement: HTMLElement | SVGElement;
     abstract fBehavior: EFConnectionBehavior;
-    abstract fType: EFConnectionType;
+    abstract fType: EFConnectionType | string;
     abstract fDefs: ElementRef<SVGDefsElement>;
     abstract fPath: IConnectionPath;
     abstract fGradient: IConnectionGradient;
@@ -46,6 +43,7 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements IHas
     abstract fSelection: FConnectionSelectionComponent;
     abstract fTextComponent: IConnectionText;
     abstract fText: string;
+    abstract fTextStartOffset: string;
     abstract fConnectionCenter: ElementRef<HTMLDivElement>;
     private penultimatePoint;
     protected constructor(elementReference: ElementRef<HTMLElement>, cFactory: FConnectionFactory);

package/f-connection/common/f-drag-handle/f-connection-drag-handle.component.d.ts

@@ -9,7 +9,7 @@ export declare class FConnectionDragHandleComponent implements IHasHostElement {
     get hostElement(): SVGCircleElement;
     constructor(elementReference: ElementRef<SVGCircleElement>);
     redraw(penultimatePoint: IPoint, endPoint: IPoint): void;
-    private calculateCircleCenter;
+    private _calculateCircleCenter;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionDragHandleComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleComponent, "circle[f-connection-drag-handle]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-path/i-connection-path.d.ts

@@ -1,7 +1,7 @@
 import { InjectionToken } from '@angular/core';
 import { IHasHostElement } from '../../../i-has-host-element';
 export declare const CONNECTION_PATH: InjectionToken<IConnectionPath>;
-export interface IConnectionPath extends IHasHostElement {
+export interface IConnectionPath extends IHasHostElement<SVGPathElement> {
     initialize(): void;
     setPath(path: string): void;
     select(): void;

package/f-connection/common/i-has-connection-text.d.ts

@@ -1,3 +1,4 @@
 export interface IHasConnectionText {
     fText: string;
+    fTextStartOffset: string;
 }

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

@@ -1,44 +1,23 @@
-import { ElementRef, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { ElementRef, OnChanges, OnDestroy, OnInit, QueryList } from "@angular/core";
 import { FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FComponentsStore } from '../../f-storage';
 import { FConnectionCenterDirective } from '../f-connection-center';
 import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
-import { FMediator } from '@foblex/mediator';
 import * as i0 from "@angular/core";
-export declare class FConnectionComponent extends FConnectionBase implements OnInit, OnDestroy {
-    private fComponentsStore;
-    private fMediator;
+export declare class FConnectionComponent extends FConnectionBase implements OnInit, OnChanges, OnDestroy {
     fId: string;
-    private _fText;
-    set fText(value: string);
-    get fText(): string;
-    private _fStartColor;
-    set fStartColor(value: string);
-    get fStartColor(): string;
-    private _fEndColor;
-    set fEndColor(value: string);
-    get fEndColor(): string;
-    private _fOutputId;
-    set fOutputId(value: string);
-    get fOutputId(): string;
-    private _fInputId;
-    set fInputId(value: string);
-    get fInputId(): string;
-    private _fRadius;
-    set fRadius(value: number);
-    get fRadius(): number;
-    private _fOffset;
-    set fOffset(value: number);
-    get fOffset(): number;
-    private _behavior;
-    set fBehavior(value: string | EFConnectionBehavior);
-    get fBehavior(): EFConnectionBehavior;
-    private _type;
-    set fType(value: EFConnectionType | string);
-    get fType(): EFConnectionType;
+    fText: string;
+    fTextStartOffset: string;
+    fStartColor: string;
+    fEndColor: string;
+    fOutputId: string;
+    fInputId: string;
+    fRadius: number;
+    fOffset: number;
+    fBehavior: EFConnectionBehavior;
+    fType: EFConnectionType | string;
     fDraggingDisabled: boolean;
     fSelectionDisabled: boolean;
     fDefs: ElementRef<SVGDefsElement>;
@@ -50,9 +29,12 @@ export declare class FConnectionComponent extends FConnectionBase implements OnI
     fConnectionCenter: ElementRef<HTMLDivElement>;
     fConnectionCenters: QueryList<FConnectionCenterDirective>;
     get boundingElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory, fComponentsStore: FComponentsStore, fMediator: FMediator);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; }; "fText": { "alias": "fText"; "required": false; }; "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": false; }; "fInputId": { "alias": "fInputId"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; }; "fText": { "alias": "fText"; "required": false; }; "fTextStartOffset": { "alias": "fTextStartOffset"; "required": false; }; "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": false; }; "fInputId": { "alias": "fInputId"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ngAcceptInputType_fBehavior: unknown;
 }

package/f-connection/f-connection-builder/i-f-connection-factory-request.d.ts

@@ -1,6 +1,6 @@
 import { EFConnectionType } from '../common';
 import { IFConnectionBuilderRequest } from './i-f-connection-builder-request';
 export interface IFConnectionFactoryRequest {
-    type: EFConnectionType;
+    type: EFConnectionType | string;
     payload: IFConnectionBuilderRequest;
 }

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

@@ -1,36 +1,23 @@
-import { AfterViewInit, ElementRef, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit, QueryList } from "@angular/core";
 import { FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
 import { FConnectionCenterDirective } from '../f-connection-center';
 import { FConnectionFactory } from '../f-connection-builder';
-import { FComponentsStore } from '../../f-storage';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
-export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {
-    private fComponentsStore;
+export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
     fId: string;
     fText: string;
-    private _fStartColor;
-    set fStartColor(value: string);
-    get fStartColor(): string;
-    private _fEndColor;
-    set fEndColor(value: string);
-    get fEndColor(): string;
+    fTextStartOffset: string;
+    fStartColor: string;
+    fEndColor: string;
     fOutputId: string;
     fInputId: string;
-    private _fRadius;
-    set fRadius(value: number);
-    get fRadius(): number;
-    private _fOffset;
-    set fOffset(value: number);
-    get fOffset(): number;
-    private _behavior;
-    set fBehavior(value: EFConnectionBehavior | string);
-    get fBehavior(): EFConnectionBehavior;
-    private _type;
-    set fType(value: EFConnectionType | string);
-    get fType(): EFConnectionType;
+    fRadius: number;
+    fOffset: number;
+    fBehavior: EFConnectionBehavior;
+    fType: EFConnectionType | string;
     fDraggingDisabled: boolean;
     fSelectionDisabled: boolean;
     fDefs: ElementRef<SVGDefsElement>;
@@ -42,10 +29,13 @@ export declare class FConnectionForCreateComponent extends FConnectionBase imple
     fConnectionCenter: ElementRef<HTMLDivElement>;
     fConnectionCenters: QueryList<FConnectionCenterDirective>;
     get boundingElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory, fComponentsStore: FComponentsStore);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ngAcceptInputType_fBehavior: unknown;
 }

package/f-connection/f-marker/f-marker.directive.d.ts

@@ -1,9 +1,7 @@
 import { ElementRef, OnDestroy, OnInit } from "@angular/core";
 import { FMarkerBase } from './f-marker-base';
-import { FComponentsStore } from '../../f-storage';
 import * as i0 from "@angular/core";
 export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnDestroy {
-    private fComponentsStore;
     private elementReference;
     get hostElement(): HTMLElement;
     width: number;
@@ -13,7 +11,8 @@ export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnD
     type: string;
     orient: 'auto' | 'auto-start-reverse' | 'calculated' | string;
     markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    constructor(fComponentsStore: FComponentsStore, elementReference: ElementRef<HTMLElement>);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerDirective, never>;

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

@@ -1,37 +1,24 @@
-import { AfterViewInit, ElementRef, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit, QueryList } from "@angular/core";
 import { FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
 import { FConnectionCenterDirective } from '../f-connection-center';
 import { FConnectionFactory } from '../f-connection-builder';
-import { FComponentsStore } from '../../f-storage';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
-export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {
-    private fComponentsStore;
+export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
     fId: string;
     fText: string;
-    private _fStartColor;
-    set fStartColor(value: string);
-    get fStartColor(): string;
-    private _fEndColor;
-    set fEndColor(value: string);
-    get fEndColor(): string;
+    fTextStartOffset: string;
+    fStartColor: string;
+    fEndColor: string;
     fSnapThreshold: number;
     fOutputId: string;
     fInputId: string;
-    private _fRadius;
-    set fRadius(value: number);
-    get fRadius(): number;
-    private _fOffset;
-    set fOffset(value: number);
-    get fOffset(): number;
-    private _behavior;
-    set fBehavior(value: EFConnectionBehavior | string);
-    get fBehavior(): EFConnectionBehavior;
-    private _type;
-    set fType(value: EFConnectionType | string);
-    get fType(): EFConnectionType;
+    fRadius: number;
+    fOffset: number;
+    fBehavior: EFConnectionBehavior;
+    fType: EFConnectionType | string;
     fDraggingDisabled: boolean;
     fSelectionDisabled: boolean;
     fDefs: ElementRef<SVGDefsElement>;
@@ -43,10 +30,13 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fConnectionCenter: ElementRef<HTMLDivElement>;
     fConnectionCenters: QueryList<FConnectionCenterDirective>;
     get boundingElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory, fComponentsStore: FComponentsStore);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ngAcceptInputType_fBehavior: unknown;
 }

package/f-connection/providers.d.ts

@@ -4,4 +4,4 @@ import { FConnectionCenterDirective } from './f-connection-center';
 import { FConnectionForCreateComponent } from './f-connection-for-create';
 import { FMarkerDirective } from './f-marker';
 import { FSnapConnectionComponent } from './f-snap-connection';
-export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionDragHandleComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionSelectionComponent | typeof FMarkerDirective | typeof FConnectionCenterDirective | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FSnapConnectionComponent)[];
+export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionDragHandleComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FMarkerDirective | typeof FSnapConnectionComponent)[];

package/f-connectors/f-connector-base.d.ts

@@ -1,17 +1,16 @@
-import { Subject } from 'rxjs';
 import { EFConnectableSide } from './e-f-connectable-side';
-import { IHasStateChanges } from '../i-has-state-changes';
 import { IHasHostElement } from '../i-has-host-element';
-export declare abstract class FConnectorBase implements IHasStateChanges, IHasHostElement {
-    abstract id: string;
+export declare abstract class FConnectorBase implements IHasHostElement {
+    abstract fId: string;
     abstract disabled: boolean;
     abstract hostElement: HTMLElement | SVGElement;
-    readonly stateChanges: Subject<void>;
     abstract canBeConnected: boolean;
-    abstract isConnected: boolean;
+    private _isConnected;
+    get isConnected(): boolean;
+    toConnector: FConnectorBase | undefined;
     isSelfConnectable: boolean;
     fConnectableSide: EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
+    userFConnectableSide: EFConnectableSide;
     isContains(element: HTMLElement | SVGElement): boolean;
-    setConnected(isConnected: boolean): void;
+    setConnected(isConnected: boolean, toConnector?: FConnectorBase): void;
 }

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

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
     abstract multiple: boolean;
-    isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, false, never>;

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

@@ -1,27 +1,25 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { FNodeInputBase } from './f-node-input-base';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
-export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnDestroy {
-    private elementReference;
+export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
     private fNode;
-    private fComponentsStore;
-    id: any;
+    fId: any;
     multiple: boolean;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
-    set _fSide(value: EFConnectableSide | string);
-    get _fSide(): EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
-    isConnected: boolean;
+    disabled: boolean;
+    userFConnectableSide: EFConnectableSide;
     get hostElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
+    private _elementReference;
+    private _fMediator;
+    constructor(fNode: FNodeBase);
     ngOnInit(): void;
-    setConnected(isConnected: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setConnected(isConnected: boolean, toConnector?: FConnectorBase): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "id": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "_fSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "fId": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_userFConnectableSide: unknown;
 }

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

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
 export declare abstract class FNodeOutletBase extends FConnectorBase {
     abstract isConnectionFromOutlet: boolean;
-    isConnected: boolean;
     private outputs;
     get canBeConnected(): boolean;
     setOutputs(outputs: FConnectorBase[]): void;

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

@@ -1,24 +1,22 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { FNodeOutletBase } from './f-node-outlet-base';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
-    private elementReference;
     private fNode;
-    private fComponentsStore;
-    id: string;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
+    fId: string;
+    disabled: boolean;
     fConnectableSide: EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
+    userFConnectableSide: EFConnectableSide;
     isConnectionFromOutlet: boolean;
     get hostElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
+    private _elementReference;
+    private _fMediator;
+    constructor(fNode: FNodeBase);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "id": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
 }

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

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
 export declare abstract class FNodeOutputBase extends FConnectorBase {
     abstract multiple: boolean;
-    isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false, never>;