@foblex/flow 1.2.1 → 1.2.3

package/f-draggable/connections/create-connection/create-connection.on-pointer-up.d.ts

@@ -0,0 +1,16 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FindInputsUnderPointerHandler } from '../find-inputs-under-pointer';
+import { FComponentsStore } from '../../../f-components-store';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FindFirstCanBeConnectedOutputByOutletHandler } from './find-first-can-be-connected-output-by-outlet';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionOnPointerUp implements IHandler<IPointerEvent, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private findInputsUnderPointerHandler;
+    private findFirstCanBeConnectedOutputByOutletHandler;
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, findInputsUnderPointerHandler: FindInputsUnderPointerHandler, findFirstCanBeConnectedOutputByOutletHandler: FindFirstCanBeConnectedOutputByOutletHandler);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionOnPointerUp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionOnPointerUp>;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { IHandler } from '@foblex/core';
+import { FComponentsStore } from '../../../../f-components-store';
+import { FConnectorBase, FNodeOutletBase } from '../../../../f-node';
+import * as i0 from "@angular/core";
+export declare class FindFirstCanBeConnectedOutputByOutletHandler implements IHandler<FNodeOutletBase, FConnectorBase | undefined> {
+    private fComponentsStore;
+    private get fNodes();
+    private get fOutputs();
+    constructor(fComponentsStore: FComponentsStore);
+    handle(outlet: FNodeOutletBase): FConnectorBase | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FindFirstCanBeConnectedOutputByOutletHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FindFirstCanBeConnectedOutputByOutletHandler>;
+}

package/{directives/f-draggable → f-draggable}/connections/create-connection/find-first-can-be-connected-output-by-outlet/index.d.ts

@@ -1,2 +1 @@
 export * from './find-first-can-be-connected-output-by-outlet.handler';
-export * from './find-first-can-be-connected-output-by-outlet.request';

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

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

package/f-draggable/connections/create-connection/public-api.d.ts

@@ -0,0 +1 @@
+export * from './create-connection.event';

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

@@ -0,0 +1,18 @@
+import { IHandler } from '@foblex/core';
+import { FindInputsUnderPointerRequest } from './find-inputs-under-pointer.request';
+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 * as i0 from "@angular/core";
+export declare class FindInputsUnderPointerHandler implements IHandler<FindInputsUnderPointerRequest, FConnectorBase[]> {
+    private fComponentsStore;
+    private inputsUnderPointerHandler;
+    private firstNotConnectedInputOfNodeUnderPointerHandler;
+    private get fNodes();
+    constructor(fComponentsStore: FComponentsStore, inputsUnderPointerHandler: InputsUnderPointerHandler, firstNotConnectedInputOfNodeUnderPointerHandler: FirstNotConnectedInputOfNodeUnderPointerHandler);
+    handle(payload: FindInputsUnderPointerRequest): FConnectorBase[];
+    private getInputsUnderPointer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FindInputsUnderPointerHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FindInputsUnderPointerHandler>;
+}

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

@@ -0,0 +1,8 @@
+import { IPointerEvent } from '@foblex/core';
+import { CreateConnectionDragHandler } from '../create-connection';
+import { ReassignConnectionDragHandler } from '../reassign-connection';
+export declare class FindInputsUnderPointerRequest {
+    event: IPointerEvent;
+    dragHandler: CreateConnectionDragHandler | ReassignConnectionDragHandler;
+    constructor(event: IPointerEvent, dragHandler: CreateConnectionDragHandler | ReassignConnectionDragHandler);
+}

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

@@ -0,0 +1,13 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FComponentsStore } from '../../../../f-components-store';
+import { FConnectorBase } from '../../../../f-node';
+import * as i0 from "@angular/core";
+export declare class FirstNotConnectedInputOfNodeUnderPointerHandler implements IHandler<IPointerEvent, FConnectorBase | undefined> {
+    private fComponentsStore;
+    private get fNodes();
+    private get fInputs();
+    constructor(fComponentsStore: FComponentsStore);
+    handle(event: IPointerEvent): FConnectorBase | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirstNotConnectedInputOfNodeUnderPointerHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FirstNotConnectedInputOfNodeUnderPointerHandler>;
+}

package/{directives/f-draggable → f-draggable}/connections/find-inputs-under-pointer/first-not-connected-input-of-node-under-pointer/index.d.ts

@@ -1,2 +1 @@
 export * from './first-not-connected-input-of-node-under-pointer.handler';
-export * from './first-not-connected-input-of-node-under-pointer.request';

package/{directives/f-draggable → f-draggable}/connections/find-inputs-under-pointer/inputs-under-pointer/index.d.ts

@@ -1,2 +1 @@
 export * from './inputs-under-pointer.handler';
-export * from './inputs-under-pointer.request';

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

@@ -0,0 +1,12 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FComponentsStore } from '../../../../f-components-store';
+import { FConnectorBase } from '../../../../f-node';
+import * as i0 from "@angular/core";
+export declare class InputsUnderPointerHandler implements IHandler<IPointerEvent, FConnectorBase[]> {
+    private fComponentsStore;
+    private get fInputs();
+    constructor(fComponentsStore: FComponentsStore);
+    handle(event: IPointerEvent): FConnectorBase[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputsUnderPointerHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InputsUnderPointerHandler>;
+}

package/{directives/f-draggable → f-draggable}/connections/index.d.ts

@@ -1,3 +1,4 @@
 export * from './create-connection';
 export * from './find-inputs-under-pointer';
 export * from './reassign-connection';
+export * from './providers';

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

@@ -0,0 +1,4 @@
+import { CreateConnectionOnPointerUp, CreateConnectionPrepareDragSequence, FindFirstCanBeConnectedOutputByOutletHandler } from './create-connection';
+import { FindInputsUnderPointerHandler, FirstNotConnectedInputOfNodeUnderPointerHandler, InputsUnderPointerHandler } from './find-inputs-under-pointer';
+import { ReassignConnectionOnPointerUp, ReassignConnectionPrepareDragSequence } from './reassign-connection';
+export declare const CONNECTIONS_PROVIDERS: (typeof FindFirstCanBeConnectedOutputByOutletHandler | typeof CreateConnectionOnPointerUp | typeof CreateConnectionPrepareDragSequence | typeof FirstNotConnectedInputOfNodeUnderPointerHandler | typeof InputsUnderPointerHandler | typeof FindInputsUnderPointerHandler | typeof ReassignConnectionOnPointerUp | typeof ReassignConnectionPrepareDragSequence)[];

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

@@ -0,0 +1,2 @@
+export * from './create-connection/public-api';
+export * from './reassign-connection/public-api';

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

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

package/f-draggable/connections/reassign-connection/public-api.d.ts

@@ -0,0 +1 @@
+export * from './reassign-connection.event';

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

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

package/f-draggable/connections/reassign-connection/reassign-connection.on-pointer-up.d.ts

@@ -0,0 +1,15 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FindInputsUnderPointerHandler } from '../index';
+import { FComponentsStore } from '../../../f-components-store';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class ReassignConnectionOnPointerUp implements IHandler<IPointerEvent, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private findInputsUnderPointerHandler;
+    private get fDraggable();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, findInputsUnderPointerHandler: FindInputsUnderPointerHandler);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionOnPointerUp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionOnPointerUp>;
+}

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

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

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

@@ -1,10 +1,9 @@
 export declare enum EDraggableType {
     NODE = "node",
     REASSIGN_CONNECTION = "reassign-connection",
-    TEMP_CONNECTION = "temp-connection",
+    CREATE_CONNECTION = "create-connection",
     CONNECTION = "connection",
     CANVAS = "canvas",
     PALETTE_ITEM = "palette-item",
-    DEFAULT = "default",
     SELECTION = "selection"
 }

package/{directives/f-draggable/external-item/external-item-on-pointer-move/external-item-on-pointer-move.handler.d.ts → f-draggable/external-item/external-item.drag-handler.d.ts}

@@ -1,8 +1,8 @@
 import { IPoint, IRect } from '@foblex/core';
-import { EDraggableType } from '../../e-draggable-type';
-import { FExternalItemBase } from '../../../f-external-item';
-import { IDraggableItem } from '../../i-draggable-item';
-export declare class ExternalItemOnPointerMoveHandler implements IDraggableItem {
+import { IDraggableItem } from '../i-draggable-item';
+import { EDraggableType } from '../e-draggable-type';
+import { FExternalItemBase } from '../components';
+export declare class ExternalItemDragHandler implements IDraggableItem {
     externalItem: FExternalItemBase;
     readonly type = EDraggableType.PALETTE_ITEM;
     placeholder: HTMLElement | SVGElement | undefined;
@@ -11,6 +11,7 @@ export declare class ExternalItemOnPointerMoveHandler implements IDraggableItem
     constructor(externalItem: FExternalItemBase);
     private getStyle;
     initialize(): void;
+    private getExternalItemRect;
     move(difference: IPoint): void;
     getPlaceholderRect(): IRect;
     complete(): void;

package/f-draggable/external-item/external-item.on-pointer-up.d.ts

@@ -0,0 +1,16 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FComponentsStore } from '../../f-components-store';
+import { FDraggableDataContext } from '../f-draggable-data-context';
+import { GetElementRectInFlowHandler } from '../../domain';
+import * as i0 from "@angular/core";
+export declare class ExternalItemOnPointerUp implements IHandler<IPointerEvent, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private getElementRectInFlowHandler;
+    private get flowHost();
+    private get fCreateNode();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalItemOnPointerUp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExternalItemOnPointerUp>;
+}

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

@@ -0,0 +1,16 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FExternalItemService } from '../components';
+import { FComponentsStore } from '../../f-components-store';
+import { FDraggableDataContext } from '../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class ExternalItemPrepareDragSequence implements IHandler<IPointerEvent, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private fExternalItemService;
+    private get transform();
+    private get flowHost();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fExternalItemService: FExternalItemService);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalItemPrepareDragSequence, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExternalItemPrepareDragSequence>;
+}

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

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

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

@@ -0,0 +1,3 @@
+import { ExternalItemOnPointerUp } from './external-item.on-pointer-up';
+import { ExternalItemPrepareDragSequence } from './external-item.prepare-drag-sequence';
+export declare const EXTERNAL_ITEM_PROVIDERS: (typeof ExternalItemOnPointerUp | typeof ExternalItemPrepareDragSequence)[];

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

@@ -0,0 +1,16 @@
+import { IDragAndDropBase, IHasHostElement } from '@foblex/core';
+import { EventEmitter, InjectionToken, NgZone } from '@angular/core';
+import { CreateNodeEvent } from './external-item';
+import { ReassignConnectionEvent } from './connections/reassign-connection/reassign-connection.event';
+import { CreateConnectionEvent } from './connections/create-connection/create-connection.event';
+import * as i0 from "@angular/core";
+export declare const F_DRAGGABLE: InjectionToken<FDraggableBase>;
+export declare abstract class FDraggableBase extends IDragAndDropBase implements IHasHostElement {
+    abstract hostElement: HTMLElement;
+    abstract fCreateNode: EventEmitter<CreateNodeEvent>;
+    abstract fReassignConnection: EventEmitter<ReassignConnectionEvent>;
+    abstract fCreateConnection: EventEmitter<CreateConnectionEvent>;
+    protected constructor(ngZone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,16 @@
+import { Point } from '@foblex/core';
+import { IDraggableItem } from './i-draggable-item';
+import { FLineAlignmentBase, FSelectionAreaBase } from './components';
+import { ISelectable } from '../f-connection';
+import * as i0 from "@angular/core";
+export declare class FDraggableDataContext {
+    selectedItems: ISelectable[];
+    onPointerDownScale: number;
+    onPointerDownPosition: Point;
+    draggableItems: IDraggableItem[];
+    fSelectionArea: FSelectionAreaBase | undefined;
+    fLineAlignment: FLineAlignmentBase | undefined;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDataContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FDraggableDataContext>;
+}

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

@@ -0,0 +1,31 @@
+import { AfterViewInit, ElementRef, EventEmitter, Injector, NgZone, OnDestroy, OnInit } from "@angular/core";
+import { FDraggableBase } from './f-draggable-base';
+import { FComponentsStore } from '../f-components-store';
+import { FDraggableDataContext } from './f-draggable-data-context';
+import { CreateNodeEvent } from './external-item';
+import { IPointerEvent } from '@foblex/core';
+import { CreateConnectionEvent, ReassignConnectionEvent } from './connections';
+import * as i0 from "@angular/core";
+export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
+    private elementReference;
+    private fDraggableDataContext;
+    private injector;
+    private fComponentsStore;
+    private subscriptions$;
+    disabled: boolean;
+    get hostElement(): HTMLElement;
+    fCreateNode: EventEmitter<CreateNodeEvent>;
+    fReassignConnection: EventEmitter<ReassignConnectionEvent>;
+    fCreateConnection: EventEmitter<CreateConnectionEvent>;
+    private readonly document;
+    constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext, ngZone: NgZone, injector: Injector, fComponentsStore: FComponentsStore, document: any);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onPointerDown(event: IPointerEvent): boolean;
+    protected prepareDragSequence(event: IPointerEvent): void;
+    onPointerMove(event: IPointerEvent): void;
+    onPointerUp(event: IPointerEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; }, never, never, false, never>;
+}

package/{directives/f-draggable → f-draggable}/i-draggable-item.d.ts

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

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

@@ -1,13 +1,12 @@
 export * from './canvas';
+export * from './components';
 export * from './connections';
-export * from './default-drag-handler';
 export * from './external-item';
 export * from './node';
-export * from './selection';
+export * from './single-select';
+export * from './selection-area';
 export * from './e-draggable-type';
 export * from './f-draggable.directive';
-export * from './f-draggable.module';
-export * from './f-draggable.service';
 export * from './f-draggable-base';
+export * from './f-draggable-data-context';
 export * from './i-draggable-item';
-export * from './i-drag-handler';

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

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

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

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

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

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

package/f-draggable/node/domain/is-connection-under-node/index.d.ts

@@ -0,0 +1 @@
+export * from './is-connection-under-node.handler';

package/f-draggable/node/domain/is-connection-under-node/is-connection-under-node.handler.d.ts

@@ -0,0 +1,22 @@
+import { IHandler } from '@foblex/core';
+import { FComponentsStore } from '../../../../f-components-store';
+import { FDraggableDataContext } from '../../../f-draggable-data-context';
+import { GetElementRectInFlowHandler, GetIncomingConnectionsHandler, GetOutgoingConnectionsHandler } from '../../../../domain';
+import * as i0 from "@angular/core";
+export declare class IsConnectionUnderNodeHandler implements IHandler<void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private getElementRectInFlowHandler;
+    private getOutgoingConnectionsHandler;
+    private getIncomingConnectionsHandler;
+    private get transform();
+    private get flowHost();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler, getOutgoingConnectionsHandler: GetOutgoingConnectionsHandler, getIncomingConnectionsHandler: GetIncomingConnectionsHandler);
+    handle(): void;
+    private isValidRequest;
+    private getOutputsForNode;
+    private getInputsForNode;
+    private findConnectionsUnderNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionUnderNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionUnderNodeHandler>;
+}

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

@@ -0,0 +1,7 @@
+export * from './connection.drag-handler';
+export * from './connection-source.drag-handler';
+export * from './connection-target.drag-handler';
+export * from './node.drag-handler';
+export * from './node.on-pointer-up';
+export * from './node.prepare-drag-sequence';
+export * from './providers';

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

@@ -0,0 +1,14 @@
+import { IPoint } from '@foblex/core';
+import { IDraggableItem } from '../i-draggable-item';
+import { EDraggableType } from '../e-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;
+    private onPointerDownPosition;
+    constructor(fDraggableDataContext: FDraggableDataContext, fNode: FNodeBase);
+    move(difference: IPoint): void;
+    complete(): void;
+}

package/f-draggable/node/node.on-pointer-up.d.ts

@@ -0,0 +1,16 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FComponentsStore } from '../../f-components-store';
+import { FDraggableDataContext } from '../f-draggable-data-context';
+import { IsConnectionUnderNodeHandler } from './domain/is-connection-under-node';
+import * as i0 from "@angular/core";
+export declare class NodeOnPointerUp implements IHandler<IPointerEvent, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private isConnectionUnderNodeHandler;
+    private get transform();
+    private get flowHost();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, isConnectionUnderNodeHandler: IsConnectionUnderNodeHandler);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeOnPointerUp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeOnPointerUp>;
+}

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

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

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

@@ -0,0 +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)[];

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

@@ -1,4 +1,4 @@
+export * from './components/public-api';
 export * from './connections/public-api';
 export * from './external-item/public-api';
 export * from './f-draggable.directive';
-export * from './f-draggable.module';

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

@@ -0,0 +1,20 @@
+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 * as i0 from "@angular/core";
+export declare class GetCanBeSelectedItemsHandler implements IHandler<void, ISelectableWithRect[]> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private getElementRectInFlowHandler;
+    private get fNodes();
+    private get fConnections();
+    private get transform();
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler);
+    handle(): ISelectableWithRect[];
+    private getNodesWithRects;
+    private getConnectionsWithRects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetCanBeSelectedItemsHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetCanBeSelectedItemsHandler>;
+}

package/f-draggable/selection-area/get-can-be-selected-items/i-selectable-with-rect.d.ts

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/core';
+import { ISelectable } from '../../../f-connection';
+export interface ISelectableWithRect {
+    element: ISelectable;
+    rect: IRect;
+}

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

@@ -0,0 +1,2 @@
+export * from './get-can-be-selected-items.handler';
+export * from './i-selectable-with-rect';

package/f-draggable/selection-area/index.d.ts

@@ -0,0 +1,5 @@
+export * from './get-can-be-selected-items';
+export * from './providers';
+export * from './selection-area.prepare-drag-sequence';
+export * from './selection-area.drag-handle';
+export * from './selection-area.on-pointer-up';