@foblex/flow 1.4.0 → 1.4.5

package/f-connectors/domain/calculate-connector-connectable-side/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-connector-connectable-side.handler';
+export * from './calculate-connector-connectable-side-request';

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

@@ -0,0 +1 @@
+export * from './calculate-connector-connectable-side';

package/f-connectors/e-f-connectable-side.d.ts

@@ -0,0 +1,7 @@
+export declare enum EFConnectableSide {
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom",
+    AUTO = "auto"
+}

package/{f-node/f-connectors → f-connectors}/f-connector-base.d.ts

@@ -1,7 +1,7 @@
 import { Subject } from 'rxjs';
 import { IHasHostElement } from '@foblex/core';
-import { IHasStateChanges } from '../../i-has-state-changes';
-import { EConnectorSide } from '../../domain';
+import { EFConnectableSide } from './e-f-connectable-side';
+import { IHasStateChanges } from '../i-has-state-changes';
 export declare abstract class FConnectorBase implements IHasStateChanges, IHasHostElement {
     abstract id: string;
     abstract disabled: boolean;
@@ -9,7 +9,8 @@ export declare abstract class FConnectorBase implements IHasStateChanges, IHasHo
     readonly stateChanges: Subject<void>;
     abstract canBeConnected: boolean;
     abstract isConnected: boolean;
-    side: EConnectorSide;
+    fConnectableSide: EFConnectableSide;
+    _fConnectableSide: EFConnectableSide;
     isContains(element: HTMLElement | SVGElement): boolean;
     setConnected(isConnected: boolean): void;
 }

package/{f-node/f-connectors → f-connectors}/f-node-input/f-node-input.directive.d.ts

@@ -1,7 +1,8 @@
 import { ElementRef, OnDestroy, OnInit } from '@angular/core';
 import { FNodeInputBase } from './f-node-input-base';
-import { FNodeBase } from '../../f-node-base';
-import { FComponentsStore } from '../../../f-components-store';
+import { EFConnectableSide } from '../e-f-connectable-side';
+import { FNodeBase } from '../../f-node';
+import { FComponentsStore } from '../../f-components-store';
 import * as i0 from "@angular/core";
 export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnDestroy {
     private elementReference;
@@ -12,6 +13,7 @@ export declare class FNodeInputDirective extends FNodeInputBase implements OnIni
     get disabled(): boolean;
     set disabled(isDisabled: boolean | undefined | string);
     private isDisabled;
+    _fConnectableSide: EFConnectableSide;
     isConnected: boolean;
     get hostElement(): HTMLElement | SVGElement;
     constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
@@ -19,5 +21,5 @@ export declare class FNodeInputDirective extends FNodeInputBase implements OnIni
     setConnected(isConnected: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "id": { "alias": "fNodeInputId"; "required": false; }; "multiple": { "alias": "fNodeInputMultiple"; "required": false; }; "disabled": { "alias": "fNodeInputDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "id": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "_fConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
 }

package/{f-node/f-connectors → f-connectors}/f-node-outlet/f-node-outlet.directive.d.ts

@@ -1,7 +1,8 @@
 import { ElementRef, OnDestroy, OnInit } from '@angular/core';
 import { FNodeOutletBase } from './f-node-outlet-base';
-import { FNodeBase } from '../../f-node-base';
-import { FComponentsStore } from '../../../f-components-store';
+import { FNodeBase } from '../../f-node';
+import { FComponentsStore } from '../../f-components-store';
+import { EFConnectableSide } from '../e-f-connectable-side';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
     private elementReference;
@@ -11,11 +12,13 @@ export declare class FNodeOutletDirective extends FNodeOutletBase implements OnI
     get disabled(): boolean;
     set disabled(isDisabled: boolean | undefined | string);
     private isDisabled;
+    fConnectableSide: EFConnectableSide;
+    _fConnectableSide: EFConnectableSide;
     isConnectionFromOutlet: boolean;
     get hostElement(): HTMLElement | SVGElement;
     constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "id": { "alias": "fNodeOutletId"; "required": false; }; "disabled": { "alias": "fNodeOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; }, {}, never, never, false, 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>;
 }

package/{f-node/f-connectors → f-connectors}/f-node-output/f-node-output.directive.d.ts

@@ -1,7 +1,8 @@
 import { ElementRef, OnDestroy, OnInit } from '@angular/core';
 import { FNodeOutputBase } from './f-node-output-base';
-import { FNodeBase } from '../../f-node-base';
-import { FComponentsStore } from '../../../f-components-store';
+import { EFConnectableSide } from '../e-f-connectable-side';
+import { FNodeBase } from '../../f-node';
+import { FComponentsStore } from '../../f-components-store';
 import * as i0 from "@angular/core";
 export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnDestroy {
     private elementReference;
@@ -11,6 +12,7 @@ export declare class FNodeOutputDirective extends FNodeOutputBase implements OnI
     get disabled(): boolean;
     set disabled(isDisabled: boolean | undefined | string);
     private isDisabled;
+    _fConnectableSide: EFConnectableSide;
     isConnected: boolean;
     get hostElement(): HTMLElement | SVGElement;
     constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
@@ -18,5 +20,5 @@ export declare class FNodeOutputDirective extends FNodeOutputBase implements OnI
     setConnected(isConnected: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "id": { "alias": "fNodeOutputId"; "required": false; }; "disabled": { "alias": "fNodeOutputDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "id": { "alias": "fOutputId"; "required": false; }; "disabled": { "alias": "fOutputDisabled"; "required": false; }; "_fConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
 }

package/{f-node/f-connectors → f-connectors}/index.d.ts

@@ -1,4 +1,6 @@
+export * from './domain';
 export * from './f-node-input';
 export * from './f-node-outlet';
 export * from './f-node-output';
 export * from './f-connector-base';
+export * from './e-f-connectable-side';

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

@@ -1,10 +1,10 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { FComponentsStore } from '../../f-components-store';
 export declare class CanvasDragHandler implements IDraggableItem {
     private fComponentsStore;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private onPointerDownPosition;
     constructor(fComponentsStore: FComponentsStore);
     initialize(): void;

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

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../../i-draggable-item';
-import { EDraggableType } from '../../e-draggable-type';
+import { EFDraggableType } from '../../e-f-draggable-type';
 import { GetConnectionVectorHandler, GetOutputRectInFlowHandler } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
 export declare class CreateConnectionDragHandler implements IDraggableItem {
@@ -8,7 +8,7 @@ export declare class CreateConnectionDragHandler implements IDraggableItem {
     private getConnectionVectorHandler;
     connection: FConnectionBase;
     private mouseDownPoint;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private onPointerDownFromConnectorRect;
     private onPointerDownToConnectorRect;
     private outputSide;

package/f-draggable/connections/create-connection/find-first-can-be-connected-output-by-outlet/find-first-can-be-connected-output-by-outlet.handler.d.ts

@@ -1,6 +1,6 @@
 import { IHandler } from '@foblex/core';
 import { FComponentsStore } from '../../../../f-components-store';
-import { FConnectorBase, FNodeOutletBase } from '../../../../f-node';
+import { FConnectorBase, FNodeOutletBase } from '../../../../f-connectors';
 import * as i0 from "@angular/core";
 export declare class FindFirstCanBeConnectedOutputByOutletHandler implements IHandler<FNodeOutletBase, FConnectorBase | undefined> {
     private fComponentsStore;

package/f-draggable/connections/find-inputs-under-pointer/find-inputs-under-pointer.handler.d.ts

@@ -3,7 +3,7 @@ import { FindInputsUnderPointerRequest } from './find-inputs-under-pointer.reque
 import { FComponentsStore } from '../../../f-components-store';
 import { InputsUnderPointerHandler } from './inputs-under-pointer';
 import { FirstNotConnectedInputOfNodeUnderPointerHandler } from './first-not-connected-input-of-node-under-pointer';
-import { FConnectorBase } from '../../../f-node';
+import { FConnectorBase } from '../../../f-connectors';
 import * as i0 from "@angular/core";
 export declare class FindInputsUnderPointerHandler implements IHandler<FindInputsUnderPointerRequest, FConnectorBase[]> {
     private fComponentsStore;

package/f-draggable/connections/find-inputs-under-pointer/first-not-connected-input-of-node-under-pointer/first-not-connected-input-of-node-under-pointer.handler.d.ts

@@ -1,6 +1,6 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../../../f-components-store';
-import { FConnectorBase } from '../../../../f-node';
+import { FConnectorBase } from '../../../../f-connectors';
 import * as i0 from "@angular/core";
 export declare class FirstNotConnectedInputOfNodeUnderPointerHandler implements IHandler<IPointerEvent, FConnectorBase | undefined> {
     private fComponentsStore;

package/f-draggable/connections/find-inputs-under-pointer/inputs-under-pointer/inputs-under-pointer.handler.d.ts

@@ -1,6 +1,6 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../../../f-components-store';
-import { FConnectorBase } from '../../../../f-node';
+import { FConnectorBase } from '../../../../f-connectors';
 import * as i0 from "@angular/core";
 export declare class InputsUnderPointerHandler implements IHandler<IPointerEvent, FConnectorBase[]> {
     private fComponentsStore;

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

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../../i-draggable-item';
-import { EDraggableType } from '../../e-draggable-type';
+import { EFDraggableType } from '../../e-f-draggable-type';
 import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
 export declare class ReassignConnectionDragHandler implements IDraggableItem {
@@ -8,7 +8,7 @@ export declare class ReassignConnectionDragHandler implements IDraggableItem {
     private getOutputRectInFlowHandler;
     private getConnectionVectorHandler;
     connection: FConnectionBase;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private onPointerDownFromConnectorRect;
     private onPointerDownToConnectorRect;
     private outputSide;

package/f-draggable/{e-draggable-type.d.ts → e-f-draggable-type.d.ts}

@@ -1,4 +1,4 @@
-export declare enum EDraggableType {
+export declare enum EFDraggableType {
     NODE = "node",
     REASSIGN_CONNECTION = "reassign-connection",
     CREATE_CONNECTION = "create-connection",

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

@@ -1,10 +1,10 @@
 import { IPoint, IRect } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { FExternalItemBase } from '../components';
 export declare class ExternalItemDragHandler implements IDraggableItem {
     externalItem: FExternalItemBase;
-    readonly type = EDraggableType.PALETTE_ITEM;
+    readonly type = EFDraggableType.PALETTE_ITEM;
     placeholder: HTMLElement | SVGElement | undefined;
     private onPointerDownRect;
     private difference;

package/f-draggable/i-draggable-item.d.ts

@@ -1,7 +1,7 @@
 import { IPoint } from '@foblex/core';
-import { EDraggableType } from './e-draggable-type';
+import { EFDraggableType } from './e-f-draggable-type';
 export interface IDraggableItem {
-    type: EDraggableType;
+    type: EFDraggableType;
     initialize?(): void;
     move(difference: IPoint): void;
     complete?(): void;

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

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
 export declare class ConnectionSourceDragHandler implements IDraggableItem {
@@ -8,7 +8,7 @@ export declare class ConnectionSourceDragHandler implements IDraggableItem {
     private getOutputRectInFlowHandler;
     private getConnectionVectorHandler;
     private connection;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private fromConnectorRect;
     private fromConnectorSide;
     private toConnectorRect;

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

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
 export declare class ConnectionTargetDragHandler implements IDraggableItem {
@@ -8,7 +8,7 @@ export declare class ConnectionTargetDragHandler implements IDraggableItem {
     private getOutputRectInFlowHandler;
     private getConnectionVectorHandler;
     private connection;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private fromConnectorRect;
     private fromConnectorSide;
     private toConnectorRect;

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

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { GetConnectionVectorHandler, GetInputRectInFlowHandler, GetOutputRectInFlowHandler } from '../../domain';
 import { FConnectionBase } from '../../f-connection';
 export declare class ConnectionDragHandler implements IDraggableItem {
@@ -8,7 +8,7 @@ export declare class ConnectionDragHandler implements IDraggableItem {
     private getOutputRectInFlowHandler;
     private getConnectionVectorHandler;
     connection: FConnectionBase;
-    readonly type = EDraggableType.CONNECTION;
+    readonly type = EFDraggableType.CONNECTION;
     private onPointerDownVector;
     private fromConnectorSide;
     private toConnectorSide;

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

@@ -1,3 +1,4 @@
+export * from './domain/is-connection-under-node';
 export * from './connection.drag-handler';
 export * from './connection-source.drag-handler';
 export * from './connection-target.drag-handler';

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

@@ -1,12 +1,12 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import { FNodeBase } from '../../f-node';
 export declare class NodeDragHandler implements IDraggableItem {
     private fDraggableDataContext;
     fNode: FNodeBase;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private onPointerDownPosition;
     constructor(fDraggableDataContext: FDraggableDataContext, fNode: FNodeBase);
     move(difference: IPoint): void;

package/f-draggable/public-api.d.ts

@@ -1,4 +1,13 @@
-export * from './components/public-api';
-export * from './connections/public-api';
-export * from './external-item/public-api';
+export * from './canvas';
+export * from './components';
+export * from './connections';
+export * from './external-item';
+export * from './node';
+export * from './selection-area';
+export * from './single-select';
+export * from './e-f-draggable-type';
 export * from './f-draggable.directive';
+export * from './f-draggable-base';
+export * from './f-draggable-data-context';
+export * from './i-drag-and-drop-base';
+export * from './i-draggable-item';

package/f-draggable/selection-area/selection-area.drag-handle.d.ts

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { IDraggableItem } from '../i-draggable-item';
-import { EDraggableType } from '../e-draggable-type';
+import { EFDraggableType } from '../e-f-draggable-type';
 import { FComponentsStore } from '../../f-components-store';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import { Injector } from '@angular/core';
@@ -8,7 +8,7 @@ export declare class SelectionAreaDragHandle implements IDraggableItem {
     private fComponentsStore;
     private fDraggableDataContext;
     private injector;
-    readonly type: EDraggableType;
+    readonly type: EFDraggableType;
     private canBeSelected;
     private selectedByMove;
     private get canvasPosition();

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

@@ -0,0 +1,8 @@
+import { EventEmitter, InjectionToken } from '@angular/core';
+import { IHasHostElement } from '@foblex/core';
+export declare const F_FLOW: InjectionToken<FFlowBase>;
+export declare abstract class FFlowBase implements IHasHostElement {
+    abstract fFlowId: string;
+    abstract hostElement: HTMLElement;
+    abstract fLoaded: EventEmitter<void>;
+}

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

@@ -1,17 +1,17 @@
 import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
-import { IFlowBase } from './i-flow-base';
+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 * as i0 from "@angular/core";
-export declare class FFlowComponent implements IFlowBase, OnInit, AfterContentInit, OnDestroy {
+export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private elementReference;
     private redrawConnectionsHandler;
     private getAllNodesRectHandler;
     private fComponentsStore;
     private subscription$;
-    id: string;
+    fFlowId: string;
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
     private isLoaded;
@@ -22,5 +22,5 @@ export declare class FFlowComponent implements IFlowBase, OnInit, AfterContentIn
     getNodesRect(): IRect;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "id": { "alias": "id"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fFlowId": { "alias": "fFlowId"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area"], false, never>;
 }

package/f-flow/index.d.ts

@@ -1,4 +1,3 @@
 export * from './domain/redraw-connections/redraw-connections.handler';
 export * from './f-flow.component';
-export * from './i-flow-base';
-export * from './f-parent.injection-token';
+export * from './f-flow-base';

package/f-flow.module.d.ts

@@ -12,9 +12,9 @@ import * as i10 from "./f-node/f-node.directive";
 import * as i11 from "./f-connection/f-connection/f-connection.component";
 import * as i12 from "./f-connection/f-connection-for-create/f-connection-for-create.component";
 import * as i13 from "./f-canvas/f-zoom/f-zoom.directive";
-import * as i14 from "./f-node/f-connectors/f-node-input/f-node-input.directive";
-import * as i15 from "./f-node/f-connectors/f-node-outlet/f-node-outlet.directive";
-import * as i16 from "./f-node/f-connectors/f-node-output/f-node-output.directive";
+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";

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

@@ -1,12 +1,12 @@
 import { EventEmitter, InjectionToken } from '@angular/core';
 import { Subject } from 'rxjs';
 import { IHasHostElement, IPoint } from '@foblex/core';
-import { FConnectorBase } from './f-connectors';
 import { ISelectable } from '../f-connection';
 import { IHasStateChanges } from '../i-has-state-changes';
+import { FConnectorBase } from '../f-connectors';
 export declare const F_NODE: InjectionToken<FNodeBase>;
 export declare abstract class FNodeBase implements IHasStateChanges, ISelectable, IHasHostElement {
-    abstract id: any;
+    abstract fNodeId: string;
     abstract hostElement: HTMLElement;
     readonly stateChanges: Subject<void>;
     abstract positionChange: EventEmitter<IPoint>;

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

@@ -1,15 +1,15 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
 import { IHasHostElement, IPoint, PointInput } from '@foblex/core';
 import { FNodeBase } from './f-node-base';
-import { FConnectorBase } from './f-connectors';
 import { FComponentsStore } from '../f-components-store';
+import { FConnectorBase } from '../f-connectors';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private elementReference;
     private renderer;
     private fComponentsStore;
     private subscriptions$;
-    id: string;
+    fNodeId: string;
     set position(value: PointInput);
     get position(): IPoint;
     positionChange: EventEmitter<IPoint>;
@@ -26,5 +26,5 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "id": { "alias": "id"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "positionChange": "fNodePositionChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fNodeId": { "alias": "fNodeId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "positionChange": "fNodePositionChange"; }, never, never, false, never>;
 }

package/f-node/index.d.ts

@@ -1,4 +1,3 @@
-export * from './f-connectors';
 export * from './f-drag-handle';
 export * from './f-node.directive';
 export * from './f-node-base';