@foblex/flow 0.0.1

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

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef, ElementRef, NgZone, QueryList } from '@angular/core';
+import { FItemsContainerBase } from '../../directives/f-containers/f-items-container';
+import { FFlowBase } from './f-flow-base';
+import { ITransformModel } from '@foblex/core';
+import { FNodeInputBase, FNodeOutletBase, FNodeOutputBase } from '../f-connectors';
+import { FNodesContainerBase } from '../../directives/f-containers/f-nodes-container';
+import { FConnectionsContainerBase } from '../../directives/f-containers/f-connections-container/f-connections-container-base';
+import { FBackgroundBase } from '../../internal/f-backgroud';
+import * as i0 from "@angular/core";
+import * as i1 from "../../internal/f-canvas/f-canvas.directive";
+export declare const CONNECTION_MARKER_START = "connection-marker-start";
+export declare const CONNECTION_MARKER_END = "connection-marker-end";
+export declare const CONNECTION_MARKER_START_SELECTED = "connection-marker-start-selected";
+export declare const CONNECTION_MARKER_END_SELECTED = "connection-marker-end-selected";
+export declare class FFlowComponent extends FFlowBase {
+    readonly CONNECTION_MARKER_START = "connection-marker-start";
+    readonly CONNECTION_MARKER_END = "connection-marker-end";
+    readonly CONNECTION_MARKER_START_SELECTED = "connection-marker-start-selected";
+    readonly CONNECTION_MARKER_END_SELECTED = "connection-marker-end-selected";
+    id: string;
+    fNodesContainer: FNodesContainerBase;
+    fConnectionsContainer: FConnectionsContainerBase;
+    fItemsContainer: FItemsContainerBase;
+    fBackground: FBackgroundBase;
+    outlets: QueryList<FNodeOutletBase>;
+    outputs: QueryList<FNodeOutputBase>;
+    inputs: QueryList<FNodeInputBase>;
+    get transform(): ITransformModel;
+    constructor(elementReference: ElementRef<SVGSVGElement>, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "svg[fFlow]", never, { "id": { "alias": "id"; "required": false; }; }, {}, ["fNodesContainer", "fConnectionsContainer", "fItemsContainer", "outlets", "outputs", "inputs"], ["*"], false, [{ directive: typeof i1.FCanvasDirective; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,2 @@
+export * from './f-flow.component';
+export * from './f-flow-base';

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

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

package/lib/components/f-node/f-drag-handle/f-drag-handle.directive.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef, InjectionToken, OnDestroy } from "@angular/core";
+import { Subject } from 'rxjs';
+import { IHasHostElement } from '@foblex/core';
+import { IHasStateChanges } from '../../../i-has-state-changes';
+import * as i0 from "@angular/core";
+export declare const F_DRAG_HANDLE: InjectionToken<FDragHandleDirective>;
+export declare class FDragHandleDirective implements IHasHostElement, IHasStateChanges, OnDestroy {
+    private elementReference;
+    readonly stateChanges: Subject<void>;
+    _parentNode: {} | undefined;
+    get disabled(): boolean;
+    set disabled(isDisabled: boolean | undefined | string);
+    private isDisabled;
+    get hostElement(): HTMLElement;
+    constructor(elementReference: ElementRef<HTMLElement>, _parentNode?: any);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, [null, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, { "disabled": { "alias": "fDragHandleDisabled"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/f-node/f-drag-handle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-drag-handle.directive';
+export * from './is-drag-handle';

package/lib/components/f-node/f-drag-handle/is-drag-handle.d.ts

@@ -0,0 +1 @@
+export declare function isNodeDragHandle(element: HTMLElement | SVGElement): boolean;

package/lib/components/f-node/f-drag-handle/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-drag-handle.directive';

package/lib/components/f-node/f-foreign-object/f-foreign-object-base.d.ts

@@ -0,0 +1,20 @@
+import { AfterViewInit, InjectionToken, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { IHasHostElement, ITransformModel } from '@foblex/core';
+import { IHasStateChanges } from '../../../i-has-state-changes';
+import * as i0 from "@angular/core";
+export declare const F_FOREIGN_OBJECT_COMPONENT: InjectionToken<FForeignObjectBase>;
+export declare abstract class FForeignObjectBase implements AfterViewInit, IHasStateChanges, IHasHostElement, OnDestroy {
+    private subscriptions$;
+    _parentNode: {} | undefined;
+    abstract hostElement: SVGForeignObjectElement;
+    stateChanges: Subject<void>;
+    abstract transform: ITransformModel;
+    protected constructor(_parentNode?: any);
+    ngAfterViewInit(): void;
+    private subscribeOnResizeChanges;
+    redraw(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FForeignObjectBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FForeignObjectBase, never, never, {}, {}, never, never, false, never>;
+}

package/lib/components/f-node/f-foreign-object/f-foreign-object.component.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef } from "@angular/core";
+import { FForeignObjectBase } from './f-foreign-object-base';
+import { FFlowComponent } from '../../f-flow';
+import { ITransformModel } from '@foblex/core';
+import * as i0 from "@angular/core";
+export declare class FForeignObjectComponent extends FForeignObjectBase {
+    private elementReference;
+    private flow;
+    defaultWidth: number;
+    defaultHeight: number;
+    get hostElement(): SVGForeignObjectElement;
+    get transform(): ITransformModel;
+    constructor(elementReference: ElementRef<SVGForeignObjectElement>, flow: FFlowComponent, _parentNode?: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FForeignObjectComponent, [null, null, { optional: true; skipSelf: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FForeignObjectComponent, "foreignObject[fForeignObject]", ["fComponent"], { "defaultWidth": { "alias": "fDefaultWidth"; "required": false; }; "defaultHeight": { "alias": "fDefaultHeight"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/components/f-node/f-foreign-object/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-foreign-object.component';
+export * from './f-foreign-object-base';

package/lib/components/f-node/f-foreign-object/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-foreign-object.component';

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

@@ -0,0 +1,24 @@
+import { EventEmitter, InjectionToken, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import { IHasHostElement, IPoint } from '@foblex/core';
+import { IHasStateChanges } from '../../i-has-state-changes';
+import { ISelectable } from '../../i-selectable';
+import { FDragHandleDirective } from './f-drag-handle';
+import { FForeignObjectBase } from './f-foreign-object';
+export declare const F_NODE_COMPONENT: InjectionToken<FNodeBase>;
+export declare abstract class FNodeBase implements IHasStateChanges, ISelectable, IHasHostElement {
+    abstract id: any;
+    abstract handles: QueryList<FDragHandleDirective>;
+    abstract fForeignObject: FForeignObjectBase;
+    abstract hostElement: SVGGElement;
+    readonly stateChanges: Subject<void>;
+    abstract positionChange: EventEmitter<IPoint>;
+    abstract position: IPoint;
+    abstract refresh(): void;
+    isContains(element: HTMLElement | SVGElement): boolean;
+    redraw(): void;
+    deselect(): void;
+    select(): void;
+    updatePosition(position: IPoint): void;
+    completeDrag(): void;
+}

package/lib/components/f-node/f-node.component.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { IHasHostElement, IPoint, PointInput } from '@foblex/core';
+import { FNodeBase } from './f-node-base';
+import { FDragHandleDirective } from './f-drag-handle';
+import { FForeignObjectBase } from './f-foreign-object';
+import * as i0 from "@angular/core";
+export declare class FNodeComponent extends FNodeBase implements OnInit, IHasHostElement, OnDestroy {
+    private elementReference;
+    id: any;
+    handles: QueryList<FDragHandleDirective>;
+    fForeignObject: FForeignObjectBase;
+    set position(value: PointInput);
+    get position(): IPoint;
+    private _position;
+    positionChange: EventEmitter<IPoint>;
+    get hostElement(): SVGGElement;
+    constructor(elementReference: ElementRef<SVGGElement>);
+    ngOnInit(): void;
+    refresh(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FNodeComponent, "g[fNode]", ["fComponent"], { "id": { "alias": "id"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; }, { "positionChange": "fNodePositionChange"; }, ["fForeignObject", "handles"], ["*"], false, never>;
+}

package/lib/components/f-node/index.d.ts

@@ -0,0 +1,4 @@
+export * from './f-drag-handle';
+export * from './f-foreign-object';
+export * from './f-node.component';
+export * from './f-node-base';

package/lib/components/f-node/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './f-drag-handle/public-api';
+export * from './f-foreign-object/public-api';
+export * from './f-node.component';

package/lib/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './f-connection';
+export * from './f-connectors';
+export * from './f-flow';
+export * from './f-node';
+export * from '../directives/f-selection';

package/lib/components/public-api.d.ts

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

package/lib/directives/f-connect-if-intersect/connect-if-intersect/connect-if-intersect.handler.d.ts

@@ -0,0 +1,16 @@
+import { IHandler } from '@foblex/core';
+import { ConnectIfIntersectRequest } from './connect-if-intersect.request';
+import { FConnectionBase } from '../../../components/f-connection/f-connection-base';
+import { FFlowBase, FNodeOutputBase } from '../../../components';
+import { FItemsContainerBase } from '../../f-containers';
+export declare class ConnectIfIntersectHandler implements IHandler<ConnectIfIntersectRequest> {
+    private connections;
+    private fFlow;
+    private fItemsContainer;
+    constructor(connections: FConnectionBase<FNodeOutputBase>[], fFlow: FFlowBase, fItemsContainer: FItemsContainerBase);
+    handle(request: ConnectIfIntersectRequest): void;
+    private isValidRequest;
+    private getOutputsForNode;
+    private getInputsForNode;
+    private findConnectionsUnderNode;
+}

package/lib/directives/f-connect-if-intersect/connect-if-intersect/connect-if-intersect.request.d.ts

@@ -0,0 +1,5 @@
+import { IDraggableItem } from '../../f-draggable';
+export declare class ConnectIfIntersectRequest {
+    readonly draggableItems: IDraggableItem[];
+    constructor(draggableItems: IDraggableItem[]);
+}

package/lib/directives/f-connect-if-intersect/connect-if-intersect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connect-if-intersect.handler';
+export * from './connect-if-intersect.request';

package/lib/directives/f-connect-if-intersect/f-connect-if-intersect.directive.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken, QueryList } from '@angular/core';
+import { FConnectionBase } from '../../components/f-connection/f-connection-base';
+import { FFlowBase, FNodeOutputBase } from '../../components';
+import { FItemsContainerBase } from '../f-containers';
+import { IDraggableItem } from '../f-draggable';
+import * as i0 from "@angular/core";
+export declare const F_CONNECT_IF_INTERSECT: InjectionToken<FConnectIfIntersectDirective>;
+export declare class FConnectIfIntersectDirective {
+    private fFlow;
+    private fItemsContainer;
+    fConnections: QueryList<FConnectionBase<FNodeOutputBase>>;
+    constructor(fFlow: FFlowBase, fItemsContainer: FItemsContainerBase);
+    handle(draggableItems: IDraggableItem[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectIfIntersectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectIfIntersectDirective, "g[fConnectIfIntersect]", never, {}, {}, ["fConnections"], never, false, never>;
+}

package/lib/directives/f-connect-if-intersect/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connect-if-intersect';
+export * from './f-connect-if-intersect.directive';

package/lib/directives/f-connect-if-intersect/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-connect-if-intersect.directive';

package/lib/directives/f-containers/f-connections-container/f-connections-container-base.d.ts

@@ -0,0 +1,18 @@
+import { IHasHostElement } from '@foblex/core';
+import { InjectionToken, QueryList } from '@angular/core';
+import { FConnectionBase } from '../../../components/f-connection/f-connection-base';
+import { FNodeInputBase, FNodeOutletBase, FNodeOutputBase } from '../../../components';
+import * as i0 from "@angular/core";
+export declare const F_CONNECTIONS_CONTAINER: InjectionToken<FConnectionsContainerBase>;
+export declare abstract class FConnectionsContainerBase implements IHasHostElement {
+    abstract hostElement: SVGGElement;
+    abstract fConnections: QueryList<FConnectionBase<FNodeOutputBase>>;
+    abstract fTempConnection: FConnectionBase<FNodeOutputBase | FNodeOutletBase>;
+    findConnectionWithElement(element: HTMLElement | SVGElement): FConnectionBase<FNodeOutputBase> | undefined;
+    findOutgoingConnections(outputs: FNodeOutputBase[]): FConnectionBase<FNodeOutputBase>[];
+    findIncomingConnections(inputs: FNodeInputBase[]): FConnectionBase<FNodeOutputBase>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionsContainerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionsContainerBase, never, never, {}, {}, never, never, false, never>;
+}
+export declare function findIncomingConnections(allConnections: FConnectionBase<FNodeOutputBase>[], inputs: FNodeInputBase[]): FConnectionBase<FNodeOutputBase>[];
+export declare function findOutgoingConnections(allConnections: FConnectionBase<FNodeOutputBase>[], outputs: FNodeOutputBase[]): FConnectionBase<FNodeOutputBase>[];

package/lib/directives/f-containers/f-connections-container/f-connections-container.component.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, QueryList } from "@angular/core";
+import { FConnectionsContainerBase } from './f-connections-container-base';
+import { FConnectionBase } from '../../../components/f-connection/f-connection-base';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../components';
+import * as i0 from "@angular/core";
+export declare class FConnectionsContainerComponent extends FConnectionsContainerBase {
+    private elementReference;
+    fConnections: QueryList<FConnectionBase<FNodeOutputBase>>;
+    fTempConnection: FConnectionBase<FNodeOutputBase | FNodeOutletBase>;
+    get hostElement(): SVGGElement;
+    constructor(elementReference: ElementRef<SVGGElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionsContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionsContainerComponent, "g[fConnectionsContainer]", ["fComponent"], {}, {}, ["fConnections"], ["[fConnection]"], false, never>;
+}

package/lib/directives/f-containers/f-connections-container/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-connections-container.component';
+export * from './f-connections-container-base';

package/lib/directives/f-containers/f-connections-container/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-connections-container.component';

package/lib/directives/f-containers/f-items-container/f-items-container-base.d.ts

@@ -0,0 +1,23 @@
+import { IHasHostElement, ITransformModel } from '@foblex/core';
+import { ElementRef, EventEmitter, InjectionToken } from '@angular/core';
+import { ICanChangePosition, ICanChangeZoom, ICanFitToParent, ICanOneToOneCentering } from '../../../common-behaviours';
+import * as i0 from "@angular/core";
+export declare const F_ITEMS_CONTAINER: InjectionToken<FItemsContainerBase>;
+declare const MIXIN_BASE: import("../../../common-behaviours").Constructor<ICanChangePosition> & import("../../../common-behaviours").AbstractConstructor<ICanChangePosition> & import("../../../common-behaviours").Constructor<ICanFitToParent> & import("../../../common-behaviours").AbstractConstructor<ICanFitToParent> & import("../../../common-behaviours").Constructor<ICanOneToOneCentering> & import("../../../common-behaviours").AbstractConstructor<ICanOneToOneCentering> & import("../../../common-behaviours").Constructor<ICanChangeZoom> & import("../../../common-behaviours").AbstractConstructor<ICanChangeZoom> & {
+    new (transform: ITransformModel): {
+        transform: ITransformModel;
+    };
+};
+export declare abstract class FItemsContainerBase extends MIXIN_BASE implements IHasHostElement, ICanChangePosition, ICanFitToParent, ICanOneToOneCentering, ICanChangeZoom {
+    private elementReference;
+    abstract canvasChange: EventEmitter<void>;
+    get hostElement(): SVGGElement;
+    protected constructor(elementReference: ElementRef<SVGGElement>);
+    parseData(): void;
+    redraw(): void;
+    redrawWithAnimation(): void;
+    completeDrag(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FItemsContainerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FItemsContainerBase, never, never, {}, {}, never, never, false, never>;
+}
+export {};

package/lib/directives/f-containers/f-items-container/f-items-container.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef, EventEmitter } from "@angular/core";
+import { FItemsContainerBase } from './f-items-container-base';
+import * as i0 from "@angular/core";
+export declare class FItemsContainerDirective extends FItemsContainerBase {
+    canvasChange: EventEmitter<void>;
+    constructor(elementReference: ElementRef<SVGGElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FItemsContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FItemsContainerDirective, "g[fItemsContainer]", ["fComponent"], {}, { "canvasChange": "canvasChange"; }, never, never, false, never>;
+}

package/lib/directives/f-containers/f-items-container/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-items-container.directive';
+export * from './f-items-container-base';

package/lib/directives/f-containers/f-items-container/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-items-container.directive';

package/lib/directives/f-containers/f-nodes-container/f-nodes-container-base.d.ts

@@ -0,0 +1,18 @@
+import { IHasHostElement } from '@foblex/core';
+import { InjectionToken, NgZone, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FNodeBase } from '../../../components';
+import { IHasStateChanges } from '../../../i-has-state-changes';
+import * as i0 from "@angular/core";
+export declare const F_NODES_CONTAINER: InjectionToken<FNodesContainerBase>;
+export declare abstract class FNodesContainerBase implements IHasHostElement, IHasStateChanges {
+    private ngZone;
+    abstract hostElement: SVGGElement;
+    abstract fNodes: QueryList<FNodeBase>;
+    readonly stateChanges: Observable<void>;
+    protected constructor(ngZone: NgZone);
+    findNode(element: HTMLElement | SVGElement): FNodeBase | undefined;
+    setNodeToTopLayer(node: FNodeBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FNodesContainerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodesContainerBase, never, never, {}, {}, never, never, false, never>;
+}

package/lib/directives/f-containers/f-nodes-container/f-nodes-container.component.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef, NgZone, QueryList } from "@angular/core";
+import { FNodesContainerBase } from './f-nodes-container-base';
+import { FNodeBase } from '../../../components';
+import * as i0 from "@angular/core";
+export declare class FNodesContainerComponent extends FNodesContainerBase {
+    private elementReference;
+    get hostElement(): SVGGElement;
+    fNodes: QueryList<FNodeBase>;
+    constructor(elementReference: ElementRef<SVGGElement>, ngZone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FNodesContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FNodesContainerComponent, "g[fNodesContainer]", ["fComponent"], {}, {}, ["fNodes"], ["[fNode]"], false, never>;
+}

package/lib/directives/f-containers/f-nodes-container/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-nodes-container.component';
+export * from './f-nodes-container-base';

package/lib/directives/f-containers/f-nodes-container/public-api.d.ts

@@ -0,0 +1 @@
+export * from './f-nodes-container.component';

package/lib/directives/f-containers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './f-connections-container';
+export * from './f-items-container';
+export * from './f-nodes-container';

package/lib/directives/f-containers/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './f-connections-container/public-api';
+export * from './f-items-container/public-api';
+export * from './f-nodes-container/public-api';

package/lib/directives/f-draggable/canvas/canvas-on-pointer-down/canvas-on-pointer-down.handler.d.ts

@@ -0,0 +1,12 @@
+import { IHandler } from '@foblex/core';
+import { CanvasOnPointerDownRequest } from './canvas-on-pointer-down.request';
+import { IDragHandler } from '../../i-drag-handler';
+import { FItemsContainerBase } from '../../../f-containers';
+import { FBackgroundBase } from '../../../../internal';
+export declare class CanvasOnPointerDownHandler implements IHandler<CanvasOnPointerDownRequest, IDragHandler | undefined> {
+    private fBackground;
+    private fItemsContainer;
+    private hostElement;
+    constructor(fBackground: FBackgroundBase, fItemsContainer: FItemsContainerBase, hostElement: SVGSVGElement);
+    handle(payload: CanvasOnPointerDownRequest): IDragHandler | undefined;
+}

package/lib/directives/f-draggable/canvas/canvas-on-pointer-down/canvas-on-pointer-down.request.d.ts

@@ -0,0 +1,5 @@
+import { IPointerEvent } from '@foblex/core';
+export declare class CanvasOnPointerDownRequest {
+    event: IPointerEvent;
+    constructor(event: IPointerEvent);
+}

package/lib/directives/f-draggable/canvas/canvas-on-pointer-down/index.d.ts

@@ -0,0 +1,2 @@
+export * from './canvas-on-pointer-down.handler';
+export * from './canvas-on-pointer-down.request';

package/lib/directives/f-draggable/canvas/canvas-on-pointer-move/canvas.on-pointer-move.d.ts

@@ -0,0 +1,13 @@
+import { IPoint } from '@foblex/core';
+import { FItemsContainerBase } from '../../../f-containers/f-items-container';
+import { EDraggableType } from '../../e-draggable-type';
+import { IDraggableItem } from '../../i-draggable-item';
+export declare class CanvasOnPointerMove implements IDraggableItem {
+    private fItemsContainer;
+    readonly type: EDraggableType;
+    private onPointerDownPosition;
+    constructor(fItemsContainer: FItemsContainerBase);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}

package/lib/directives/f-draggable/canvas/canvas-on-pointer-move/index.d.ts

@@ -0,0 +1 @@
+export * from './canvas.on-pointer-move';

package/lib/directives/f-draggable/canvas/index.d.ts

@@ -0,0 +1,2 @@
+export * from './canvas-on-pointer-down';
+export * from './canvas-on-pointer-move';

package/lib/directives/f-draggable/connections/create-connection/create-connection-on-pointer-down/create-connection-on-pointer-down.request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent, ITransformModel } from '@foblex/core';
+export declare class CreateConnectionOnPointerDownRequest {
+    event: IPointerEvent;
+    transform: ITransformModel;
+    constructor(event: IPointerEvent, transform: ITransformModel);
+}

package/lib/directives/f-draggable/connections/create-connection/create-connection-on-pointer-down/create-connection.on-pointer-down.d.ts

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/core';
+import { CreateConnectionOnPointerDownRequest } from './create-connection-on-pointer-down.request';
+import { IDragHandler } from '../../../i-drag-handler';
+import { FFlowBase } from '../../../../../components';
+export declare class CreateConnectionOnPointerDown implements IHandler<CreateConnectionOnPointerDownRequest, IDragHandler | undefined> {
+    private fFlow;
+    private hostElement;
+    private get fConnectionsContainer();
+    private get fNodesContainer();
+    constructor(fFlow: FFlowBase, hostElement: SVGSVGElement);
+    handle(payload: CreateConnectionOnPointerDownRequest): IDragHandler | undefined;
+    private createConnectionHandler;
+    private isNodeOutput;
+}

package/lib/directives/f-draggable/connections/create-connection/create-connection-on-pointer-down/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-connection-on-pointer-down.request';
+export * from './create-connection.on-pointer-down';

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

@@ -0,0 +1,7 @@
+import { IPointerEvent } from '@foblex/core';
+import { IDragHandler } from '../../../i-drag-handler';
+export declare class CreateConnectionOnPointerUpRequest {
+    event: IPointerEvent;
+    dragHandler: IDragHandler;
+    constructor(event: IPointerEvent, dragHandler: IDragHandler);
+}

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

@@ -0,0 +1,11 @@
+import { IHandler } from '@foblex/core';
+import { FFlowBase } from '../../../../../components';
+import { CreateConnectionOnPointerUpRequest } from './create-connection-on-pointer-up.request';
+import { EventEmitter } from '@angular/core';
+import { CreateConnectionEvent } from '../create-connection.event';
+export declare class CreateConnectionOnPointerUp implements IHandler<CreateConnectionOnPointerUpRequest, void> {
+    private fFlow;
+    private onCreateConnection;
+    constructor(fFlow: FFlowBase, onCreateConnection: EventEmitter<CreateConnectionEvent>);
+    handle(payload: CreateConnectionOnPointerUpRequest): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './create-connection.on-pointer-up';
+export * from './create-connection-on-pointer-up.request';

package/lib/directives/f-draggable/connections/create-connection/create-connection.event.d.ts

@@ -0,0 +1,5 @@
+export declare class CreateConnectionEvent<T = any> {
+    outputId: T;
+    inputId: T;
+    constructor(outputId: T, inputId: T);
+}

package/lib/directives/f-draggable/connections/create-connection/create-connection.on-pointer-move.d.ts

@@ -0,0 +1,16 @@
+import { IPoint, ITransformModel } from '@foblex/core';
+import { FConnectionBase } from '../../../../components/f-connection/f-connection-base';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../../components';
+import { IDraggableItem } from '../../i-draggable-item';
+import { EDraggableType } from '../../e-draggable-type';
+export declare class CreateConnectionOnPointerMove implements IDraggableItem {
+    connection: FConnectionBase<FNodeOutputBase | FNodeOutletBase>;
+    private mouseDownPoint;
+    readonly type: EDraggableType;
+    private readonly onPointerDownFromConnectorRect;
+    private readonly onPointerDownToConnectorRect;
+    constructor(connection: FConnectionBase<FNodeOutputBase | FNodeOutletBase>, mouseDownPoint: IPoint, transform: ITransformModel, hostElement: SVGSVGElement);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}

package/lib/directives/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,8 @@
+import { IHandler } from '@foblex/core';
+import { FindFirstCanBeConnectedOutputByOutletRequest } from './find-first-can-be-connected-output-by-outlet.request';
+import { FFlowBase, FNodeOutputBase } from '../../../../../components';
+export declare class FindFirstCanBeConnectedOutputByOutletHandler implements IHandler<FindFirstCanBeConnectedOutputByOutletRequest, FNodeOutputBase | undefined> {
+    private fFlow;
+    constructor(fFlow: FFlowBase);
+    handle(payload: FindFirstCanBeConnectedOutputByOutletRequest): FNodeOutputBase | undefined;
+}

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

@@ -0,0 +1,5 @@
+import { FNodeOutletBase } from '../../../../../components';
+export declare class FindFirstCanBeConnectedOutputByOutletRequest {
+    outlet: FNodeOutletBase;
+    constructor(outlet: FNodeOutletBase);
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { IHandler } from '@foblex/core';
+import { FindInputsUnderPointerRequest } from './find-inputs-under-pointer.request';
+import { FFlowBase, FNodeInputBase } from '../../../../components';
+export declare class FindInputsUnderPointerHandler implements IHandler<FindInputsUnderPointerRequest, FNodeInputBase[]> {
+    private fFlow;
+    constructor(fFlow: FFlowBase);
+    handle(payload: FindInputsUnderPointerRequest): FNodeInputBase[];
+    private getInputsUnderPointer;
+}

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

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

package/lib/directives/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,8 @@
+import { IHandler } from '@foblex/core';
+import { FFlowBase, FNodeInputBase } from '../../../../../components';
+import { FirstNotConnectedInputOfNodeUnderPointerRequest } from './first-not-connected-input-of-node-under-pointer.request';
+export declare class FirstNotConnectedInputOfNodeUnderPointerHandler implements IHandler<FirstNotConnectedInputOfNodeUnderPointerRequest, FNodeInputBase | undefined> {
+    private fFlow;
+    constructor(fFlow: FFlowBase);
+    handle(payload: FirstNotConnectedInputOfNodeUnderPointerRequest): FNodeInputBase | undefined;
+}

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

@@ -0,0 +1,5 @@
+import { IPointerEvent } from '@foblex/core';
+export declare class FirstNotConnectedInputOfNodeUnderPointerRequest {
+    event: IPointerEvent;
+    constructor(event: IPointerEvent);
+}

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

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

package/lib/directives/f-draggable/connections/find-inputs-under-pointer/index.d.ts

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

package/lib/directives/f-draggable/connections/find-inputs-under-pointer/inputs-under-pointer/index.d.ts

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

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

@@ -0,0 +1,8 @@
+import { IHandler } from '@foblex/core';
+import { FFlowBase, FNodeInputBase } from '../../../../../components';
+import { InputsUnderPointerRequest } from './inputs-under-pointer.request';
+export declare class InputsUnderPointerHandler implements IHandler<InputsUnderPointerRequest, FNodeInputBase[]> {
+    private fFlow;
+    constructor(fFlow: FFlowBase);
+    handle(payload: InputsUnderPointerRequest): FNodeInputBase[];
+}