@foblex/flow 0.0.1

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

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

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

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

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

@@ -0,0 +1,4 @@
+export * from './reassign-on-pointer-down';
+export * from './reassign-on-pointer-move';
+export * from './reassign-on-pointer-up';
+export * from './reassign-connection.event';

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

@@ -0,0 +1,7 @@
+export declare class ReassignConnectionEvent<T = any> {
+    connectionId: T;
+    outputId: T;
+    oldInputId: T;
+    newInputId: T;
+    constructor(connectionId: T, outputId: T, oldInputId: T, newInputId: T);
+}

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/directives/f-draggable/connections/reassign-connection/reassign-on-pointer-up/reassign-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 ReassignConnectionOnPointerUpRequest {
+    event: IPointerEvent;
+    dragHandler: IDragHandler;
+    constructor(event: IPointerEvent, dragHandler: IDragHandler);
+}

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

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

package/lib/directives/f-draggable/default-drag-handler/default-drag.handler.d.ts

@@ -0,0 +1,5 @@
+import { IHandler } from '@foblex/core';
+import { IDragHandler } from '../i-drag-handler';
+export declare class DefaultDragHandler implements IHandler<void, IDragHandler> {
+    handle(): IDragHandler;
+}

package/lib/directives/f-draggable/default-drag-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './default-drag.handler';

package/lib/directives/f-draggable/e-draggable-type.d.ts

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

package/lib/directives/f-draggable/external-item/create-node.event.d.ts

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/core';
+export declare class CreateNodeEvent<TData = any> {
+    rect: IRect;
+    data: TData;
+    constructor(rect: IRect, data: TData);
+}

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

@@ -0,0 +1,10 @@
+import { IHandler } from '@foblex/core';
+import { ExternalItemOnPointerDownRequest } from './external-item-on-pointer-down.request';
+import { IDragHandler } from '../../i-drag-handler';
+import { FExternalItemService } from '../../../f-external-item';
+export declare class ExternalItemOnPointerDownHandler implements IHandler<ExternalItemOnPointerDownRequest, IDragHandler | undefined> {
+    private fExternalItemService;
+    private hostElement;
+    constructor(fExternalItemService: FExternalItemService, hostElement: SVGSVGElement);
+    handle(payload: ExternalItemOnPointerDownRequest): IDragHandler | undefined;
+}

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

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

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

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

package/lib/directives/f-draggable/external-item/external-item-on-pointer-move/external-item-on-pointer-move.handler.d.ts

@@ -0,0 +1,17 @@
+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 {
+    externalItem: FExternalItemBase;
+    readonly type = EDraggableType.PALETTE_ITEM;
+    placeholder: HTMLElement | SVGElement | undefined;
+    private onPointerDownRect;
+    private difference;
+    constructor(externalItem: FExternalItemBase);
+    private getStyle;
+    initialize(): void;
+    move(difference: IPoint): void;
+    getPlaceholderRect(): IRect;
+    complete(): void;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { IHandler } from '@foblex/core';
+import { ExternalItemOnPointerUpRequest } from './external-item-on-pointer-up.request';
+import { FFlowBase } from '../../../../components';
+import { EventEmitter } from '@angular/core';
+import { CreateNodeEvent } from '../create-node.event';
+export declare class ExternalItemOnPointerUpHandler implements IHandler<ExternalItemOnPointerUpRequest, void> {
+    private fFlow;
+    private onCreateNode;
+    constructor(fFlow: FFlowBase, onCreateNode: EventEmitter<CreateNodeEvent>);
+    handle(payload: ExternalItemOnPointerUpRequest): void;
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './external-item-on-pointer-up.handler';
+export * from './external-item-on-pointer-up.request';

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

@@ -0,0 +1,4 @@
+export * from './external-item-on-pointer-down';
+export * from './external-item-on-pointer-move';
+export * from './external-item-on-pointer-up';
+export * from './create-node.event';

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

@@ -0,0 +1,46 @@
+import { IDragAndDropBase, IHasHostElement, IPointerEvent } from '@foblex/core';
+import { AfterViewInit, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy } from '@angular/core';
+import { FFlowBase, FSelectionDirective } from '../../components';
+import { ReassignConnectionEvent } from './connections';
+import { CreateConnectionEvent } from './connections';
+import { FConnectIfIntersectDirective } from '../f-connect-if-intersect';
+import { FLineAlignmentDirective } from '../f-line-alignment';
+import { FExternalItemService } from '../f-external-item';
+import { FDraggableService } from './f-draggable.service';
+import { CreateNodeEvent } from './external-item';
+import * as i0 from "@angular/core";
+export declare const F_DND_DIRECTIVE: InjectionToken<FDraggableBase>;
+export declare abstract class FDraggableBase extends IDragAndDropBase implements IHasHostElement, AfterViewInit, OnDestroy {
+    protected fFlow: FFlowBase;
+    protected fDNDService: FDraggableService;
+    protected fExternalItemService: FExternalItemService;
+    private elementReference;
+    private subscriptions$;
+    get hostElement(): SVGSVGElement;
+    private get transform();
+    private get fItemsContainer();
+    private get fBackground();
+    private dragHandler;
+    private dragSelection;
+    private reassignConnection;
+    private dragCanvas;
+    private dragNode;
+    private createConnection;
+    private dragExternalItem;
+    abstract onCreateConnection: EventEmitter<CreateConnectionEvent>;
+    abstract onReassignConnection: EventEmitter<ReassignConnectionEvent>;
+    abstract onCreateNode: EventEmitter<CreateNodeEvent>;
+    abstract fLineAlignment: FLineAlignmentDirective | undefined;
+    abstract fConnectIfIntersect: FConnectIfIntersectDirective | undefined;
+    abstract fSelection: FSelectionDirective | undefined;
+    private selectedItems;
+    protected constructor(fFlow: FFlowBase, fDNDService: FDraggableService, fExternalItemService: FExternalItemService, elementReference: ElementRef<SVGSVGElement>, ngZone: NgZone);
+    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<FDraggableBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,22 @@
+import { ElementRef, EventEmitter, NgZone } from "@angular/core";
+import { FDraggableBase } from './f-draggable-base';
+import { FFlowBase, FSelectionDirective } from '../../components';
+import { FConnectIfIntersectDirective } from '../f-connect-if-intersect';
+import { FLineAlignmentDirective } from '../f-line-alignment';
+import { FExternalItemService } from '../f-external-item';
+import { FDraggableService } from './f-draggable.service';
+import { CreateConnectionEvent, ReassignConnectionEvent } from './connections';
+import { CreateNodeEvent } from './external-item';
+import * as i0 from "@angular/core";
+export declare class FDraggableDirective extends FDraggableBase {
+    disabled: boolean;
+    fLineAlignment: FLineAlignmentDirective | undefined;
+    fConnectIfIntersect: FConnectIfIntersectDirective | undefined;
+    fSelection: FSelectionDirective | undefined;
+    onCreateConnection: EventEmitter<CreateConnectionEvent>;
+    onReassignConnection: EventEmitter<ReassignConnectionEvent>;
+    onCreateNode: EventEmitter<CreateNodeEvent>;
+    constructor(fFlow: FFlowBase, fDNDService: FDraggableService, fExternalItemService: FExternalItemService, elementReference: ElementRef<SVGSVGElement>, ngZone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "svg[fDraggable]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "onCreateConnection": "onCreateConnection"; "onReassignConnection": "onReassignConnection"; "onCreateNode": "onCreateNode"; }, ["fLineAlignment", "fConnectIfIntersect", "fSelection"], never, false, never>;
+}

package/lib/directives/f-draggable/f-draggable.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./f-draggable.directive";
+import * as i2 from "../f-external-item/f-external-item.directive";
+import * as i3 from "../f-line-alignment/f-line-alignment.directive";
+import * as i4 from "../f-selection/f-selection.directive";
+import * as i5 from "../f-connect-if-intersect/f-connect-if-intersect.directive";
+export declare class FDraggableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FDraggableModule, [typeof i1.FDraggableDirective, typeof i2.FExternalItemDirective, typeof i3.FLineAlignmentDirective, typeof i4.FSelectionDirective, typeof i5.FConnectIfIntersectDirective], never, [typeof i1.FDraggableDirective, typeof i2.FExternalItemDirective, typeof i3.FLineAlignmentDirective, typeof i4.FSelectionDirective, typeof i5.FConnectIfIntersectDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FDraggableModule>;
+}

package/lib/directives/f-draggable/f-draggable.service.d.ts

@@ -0,0 +1,13 @@
+import { FFlowBase } from '../../components';
+import { ITransformModel } from '@foblex/core';
+import * as i0 from "@angular/core";
+export declare class FDraggableService {
+    private fFlow;
+    get hostElement(): SVGSVGElement;
+    get transform(): ITransformModel;
+    constructor();
+    setFlow(fFlow: FFlowBase): void;
+    onPointerDown(event: PointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FDraggableService>;
+}

package/lib/directives/f-draggable/i-drag-handler.d.ts

@@ -0,0 +1,9 @@
+import { Point } from '@foblex/core';
+import { IDraggableItem } from './i-draggable-item';
+import { ISelectable } from '../../i-selectable';
+export interface IDragHandler {
+    onPointerDownScale: number;
+    onPointerDownPosition: Point;
+    draggableItems: IDraggableItem[];
+    selectedItems?: ISelectable[];
+}

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

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

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

@@ -0,0 +1,13 @@
+export * from './canvas';
+export * from './connections';
+export * from './default-drag-handler';
+export * from './external-item';
+export * from './node';
+export * from './selection';
+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 './i-draggable-item';
+export * from './i-drag-handler';

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

@@ -0,0 +1,3 @@
+export * from './node-on-pointer-down';
+export * from './node-on-pointer-move';
+export * from './node-on-pointer-up';

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

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

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

@@ -0,0 +1,9 @@
+import { IPointerEvent, ITransformModel } from '@foblex/core';
+import { ISelectable } from '../../../../i-selectable';
+export declare class NodeOnPointerDownRequest {
+    event: IPointerEvent;
+    transform: ITransformModel;
+    selectedItems: ISelectable[];
+    isMoveCurrentNode: boolean;
+    constructor(event: IPointerEvent, transform: ITransformModel, selectedItems: ISelectable[], isMoveCurrentNode?: boolean);
+}

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

@@ -0,0 +1,17 @@
+import { IHandler } from '@foblex/core';
+import { NodeOnPointerDownRequest } from './node-on-pointer-down.request';
+import { FFlowBase } from '../../../../components';
+import { IDragHandler } from '../../i-drag-handler';
+import { FLineAlignmentDirective } from '../../../f-line-alignment';
+export declare class NodeOnPointerDown implements IHandler<NodeOnPointerDownRequest, IDragHandler | undefined> {
+    private fLineAlignment;
+    private fFlow;
+    private hostElement;
+    private get fConnectionsContainer();
+    private get fNodesContainer();
+    constructor(fLineAlignment: FLineAlignmentDirective | undefined, fFlow: FFlowBase, hostElement: SVGSVGElement);
+    handle(payload: NodeOnPointerDownRequest): IDragHandler | undefined;
+    private calculateDraggableConnectionsAndNodes;
+    private getInputsForNode;
+    private getOutputsForNode;
+}

package/lib/directives/f-draggable/node/node-on-pointer-move/f-connection-source.drag-handler.d.ts

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

package/lib/directives/f-draggable/node/node-on-pointer-move/f-connection-target.drag-handler.d.ts

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

package/lib/directives/f-draggable/node/node-on-pointer-move/f-connection.drag-handler.d.ts

@@ -0,0 +1,14 @@
+import { IPoint, ITransformModel } from '@foblex/core';
+import { IDraggableItem } from '../../i-draggable-item';
+import { EDraggableType } from '../../e-draggable-type';
+import { FConnectionBase } from '../../../../components/f-connection/f-connection-base';
+import { FNodeOutputBase } from '../../../../components';
+export declare class FConnectionDragHandler implements IDraggableItem {
+    connection: FConnectionBase<FNodeOutputBase>;
+    readonly type = EDraggableType.CONNECTION;
+    private onPointerDownVector;
+    constructor(connection: FConnectionBase<FNodeOutputBase>, canvasTransform: ITransformModel, canvasHost: SVGSVGElement);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}

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

@@ -0,0 +1,4 @@
+export * from './f-connection.drag-handler';
+export * from './f-connection-source.drag-handler';
+export * from './f-connection-target.drag-handler';
+export * from './node.on-pointer-move';

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

@@ -0,0 +1,15 @@
+import { IPoint } from '@foblex/core';
+import { IDraggableItem } from '../../i-draggable-item';
+import { EDraggableType } from '../../e-draggable-type';
+import { FNodeBase } from '../../../../components';
+import { FLineAlignmentDirective } from '../../../f-line-alignment';
+export declare class NodeOnPointerMove implements IDraggableItem {
+    private fLineAlignment;
+    fNode: FNodeBase;
+    readonly type: EDraggableType;
+    private onPointerDownPosition;
+    constructor(fLineAlignment: FLineAlignmentDirective | undefined, fNode: FNodeBase);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { IHandler } from '@foblex/core';
+import { NodeOnPointerUpRequest } from './node-on-pointer-up.request';
+import { FConnectIfIntersectDirective } from '../../../f-connect-if-intersect';
+import { FLineAlignmentDirective } from '../../../f-line-alignment';
+export declare class NodeOnPointerUp implements IHandler<NodeOnPointerUpRequest, void> {
+    private fLineAlignment;
+    private fConnectIfIntersect;
+    hostElement: SVGSVGElement;
+    constructor(fLineAlignment: FLineAlignmentDirective | undefined, fConnectIfIntersect: FConnectIfIntersectDirective | undefined, hostElement: SVGSVGElement);
+    handle(payload: NodeOnPointerUpRequest): void;
+}

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

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

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

@@ -0,0 +1,3 @@
+export * from './selection-on-pointer-down';
+export * from './selection-on-pointer-move';
+export * from './selection-on-pointer-up';

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

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

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

@@ -0,0 +1,8 @@
+import { IPointerEvent, ITransformModel } from '@foblex/core';
+import { ISelectable } from '../../../../i-selectable';
+export declare class SelectionOnPointerDownRequest {
+    event: IPointerEvent;
+    transform: ITransformModel;
+    selectedItems: ISelectable[];
+    constructor(event: IPointerEvent, transform: ITransformModel, selectedItems: ISelectable[]);
+}

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

@@ -0,0 +1,11 @@
+import { IHandler } from '@foblex/core';
+import { FFlowBase, FSelectionDirective } from '../../../../components';
+import { SelectionOnPointerDownRequest } from './selection-on-pointer-down.request';
+import { IDragHandler } from '../../i-drag-handler';
+export declare class SelectionOnPointerDown implements IHandler<SelectionOnPointerDownRequest, IDragHandler> {
+    private fFlow;
+    private fSelection;
+    private hostElement;
+    constructor(fFlow: FFlowBase, fSelection: FSelectionDirective | undefined, hostElement: SVGSVGElement);
+    handle(payload: SelectionOnPointerDownRequest): IDragHandler;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { IPoint } from '@foblex/core';
+import { IDraggableItem } from '../../i-draggable-item';
+import { EDraggableType } from '../../e-draggable-type';
+import { FSelectionDirective } from '../../../f-selection';
+import { ISelectable } from '../../../../i-selectable';
+import { FFlowBase } from '../../../../components';
+export declare class SelectionOnPointerMove implements IDraggableItem {
+    private fFlow;
+    private fSelection;
+    private selectedOnStart;
+    private onPointerDownPosition;
+    readonly type: EDraggableType;
+    selectedItems: ISelectable[];
+    private items;
+    constructor(fFlow: FFlowBase, fSelection: FSelectionDirective | undefined, selectedOnStart: ISelectable[], onPointerDownPosition?: IPoint);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}

package/lib/directives/f-draggable/selection/selection-on-pointer-up/index.d.ts

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

package/lib/directives/f-draggable/selection/selection-on-pointer-up/selection-on-pointer-up.request.d.ts

@@ -0,0 +1,9 @@
+import { IPointerEvent } from '@foblex/core';
+import { IDragHandler } from '../../i-drag-handler';
+import { ISelectable } from '../../../../i-selectable';
+export declare class SelectionOnPointerUpRequest {
+    event: IPointerEvent;
+    dragHandler: IDragHandler;
+    selectedItems: ISelectable[];
+    constructor(event: IPointerEvent, dragHandler: IDragHandler, selectedItems: ISelectable[]);
+}

package/lib/directives/f-draggable/selection/selection-on-pointer-up/selection.on-pointer-up.d.ts

@@ -0,0 +1,8 @@
+import { IHandler } from '@foblex/core';
+import { SelectionOnPointerUpRequest } from './selection-on-pointer-up.request';
+import { ISelectable } from '../../../../i-selectable';
+export declare class SelectionOnPointerUp implements IHandler<SelectionOnPointerUpRequest, ISelectable[]> {
+    hostElement: SVGSVGElement;
+    constructor(hostElement: SVGSVGElement);
+    handle(payload: SelectionOnPointerUpRequest): ISelectable[];
+}

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

@@ -0,0 +1,11 @@
+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;
+    abstract hostElement: HTMLElement | SVGElement;
+    abstract data: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,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 {
+    private elementReference;
+    private fExternalItemService;
+    id: string;
+    get hostElement(): HTMLElement | SVGElement;
+    data: any;
+    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>;
+}

package/lib/directives/f-external-item/f-external-item.service.d.ts

@@ -0,0 +1,10 @@
+import { FExternalItemBase } from './f-external-item-base';
+import * as i0 from "@angular/core";
+export declare class FExternalItemService {
+    private items;
+    registerItem(item: FExternalItemBase): void;
+    getItem(element: HTMLElement | SVGElement): FExternalItemBase | undefined;
+    removeItem(item: FExternalItemBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemService>;
+}

package/lib/directives/f-external-item/index.d.ts

@@ -0,0 +1,4 @@
+export * from './f-external-item-base';
+export * from './is-external-item';
+export * from './f-external-item.directive';
+export * from './f-external-item.service';