@foblex/flow 1.5.5 → 1.5.7

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

@@ -1,20 +1,19 @@
 import { IHandler, IPointerEvent } from '@foblex/core';
 import { FComponentsStore } from '../../f-components-store';
 import { FDraggableDataContext } from '../f-draggable-data-context';
-import { GetIncomingConnectionsHandler, GetInputRectInFlowHandler, GetOutgoingConnectionsHandler, UpdateNodeLayerHandler } from '../../domain';
+import { GetIncomingConnectionsHandler, 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 getOutgoingConnectionsHandler;
     private getIncomingConnectionsHandler;
     private fMediator;
     private get transform();
     private get flowHost();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, updateNodeLayerHandler: UpdateNodeLayerHandler, getInputRectInFlowHandler: GetInputRectInFlowHandler, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler, fMediator: FFlowMediator);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, updateNodeLayerHandler: UpdateNodeLayerHandler, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler, fMediator: FFlowMediator);
     handle(event: IPointerEvent): void;
     private calculateDraggableConnectionsAndNodes;
     private getInputsForNode;

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

@@ -1,4 +1,4 @@
 import { NodeOnPointerUp } from './node.on-pointer-up';
 import { NodePrepareDragSequence } from './node.prepare-drag-sequence';
 import { IsConnectionUnderNodeHandler } from './domain/is-connection-under-node';
-export declare const NODE_PROVIDERS: (typeof NodeOnPointerUp | typeof NodePrepareDragSequence | typeof IsConnectionUnderNodeHandler)[];
+export declare const NODE_PROVIDERS: (typeof IsConnectionUnderNodeHandler | typeof NodeOnPointerUp | typeof NodePrepareDragSequence)[];

package/f-draggable/selection-area/get-can-be-selected-items/get-can-be-selected-items.handler.d.ts

@@ -2,16 +2,16 @@ import { IHandler } from '@foblex/core';
 import { ISelectableWithRect } from './i-selectable-with-rect';
 import { FComponentsStore } from '../../../f-components-store';
 import { FDraggableDataContext } from '../../f-draggable-data-context';
-import { GetElementRectInFlowHandler } from '../../../domain';
+import { FFlowMediator } from '../../../f-mediator';
 import * as i0 from "@angular/core";
 export declare class GetCanBeSelectedItemsHandler implements IHandler<void, ISelectableWithRect[]> {
     private fComponentsStore;
     private fDraggableDataContext;
-    private getElementRectInFlowHandler;
+    private fMediator;
     private get fNodes();
     private get fConnections();
     private get transform();
-    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler);
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
     handle(): ISelectableWithRect[];
     private getNodesWithRects;
     private getConnectionsWithRects;

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

@@ -1,11 +1,12 @@
 import { IHasHostElement } from '@foblex/core';
 import { InjectionToken } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase>;
-export declare abstract class FExternalItemBase implements IHasHostElement {
-    abstract id: any;
+export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
+export declare abstract class FExternalItemBase<TData = any> implements IHasHostElement {
+    abstract fExternalItemId: string;
     abstract hostElement: HTMLElement | SVGElement;
-    abstract data: any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase, never, never, {}, {}, never, never, false, never>;
+    abstract fData: TData | undefined;
+    abstract fDisabled: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -2,15 +2,16 @@ import { ElementRef, OnDestroy, OnInit } from '@angular/core';
 import { FExternalItemBase } from './f-external-item-base';
 import { FExternalItemService } from './f-external-item.service';
 import * as i0 from "@angular/core";
-export declare class FExternalItemDirective extends FExternalItemBase implements OnInit, OnDestroy {
+export declare class FExternalItemDirective<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
     private elementReference;
     private fExternalItemService;
-    id: string;
+    fExternalItemId: string;
     get hostElement(): HTMLElement | SVGElement;
-    data: any;
+    fData: TData | undefined;
+    fDisabled: boolean;
     constructor(elementReference: ElementRef<HTMLElement>, fExternalItemService: FExternalItemService);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective, "[fExternalItem]", never, { "id": { "alias": "id"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": { "alias": "fExternalItemId"; "required": false; }; "fData": { "alias": "fData"; "required": false; }; "fDisabled": { "alias": "fDisabled"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -1,14 +1,12 @@
 import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FFlowBase } from './f-flow-base';
 import { FComponentsStore } from '../f-components-store';
-import { GetAllNodesRectHandler } from '../domain';
 import { IRect } from '@foblex/core';
 import { FFlowMediator } from '../f-mediator';
 import { FSelectionChangeEvent } from '../f-draggable';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private elementReference;
-    private getAllNodesRectHandler;
     private fComponentsStore;
     private fMediator;
     private subscription$;
@@ -16,15 +14,16 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
     private isLoaded;
-    constructor(elementReference: ElementRef<HTMLElement>, getAllNodesRectHandler: GetAllNodesRectHandler, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     private subscribeOnElementsChanges;
+    reset(): void;
     getNodesRect(): IRect;
     getSelection(): FSelectionChangeEvent;
     selectAll(): void;
     clearSelection(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fFlowId": { "alias": "fFlowId"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area"], 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", "f-mini-map"], false, never>;
 }

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

@@ -4,14 +4,14 @@ import { ILineAlignmentResult } from './domain';
 import { FLineAlignmentBase } from './f-line-alignment-base';
 import { FComponentsStore } from '../f-components-store';
 import { FDraggableDataContext } from '../f-draggable';
-import { GetElementRectInFlowHandler } from '../domain';
 import { FNodeBase } from '../f-node';
+import { FFlowMediator } from '../f-mediator';
 import * as i0 from "@angular/core";
 export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
     private elementReference;
     private fComponentsStore;
     private fDraggableDataContext;
-    private getElementRectInFlowHandler;
+    private fMediator;
     get hostElement(): HTMLElement;
     private lineService;
     private size;
@@ -19,7 +19,7 @@ export declare class FLineAlignmentComponent extends FLineAlignmentBase implemen
     private rects;
     private get transform();
     private get flowHost();
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
     ngOnInit(): void;
     initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
     handle(difference: IPoint): void;