@foblex/flow 1.2.1 → 1.2.3

package/f-connection/common/f-gradient/f-connection-gradient.component.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from "@angular/core";
+import { IVector } from '@foblex/core';
+import { IHasConnectionFromTo } from '../i-has-connection-from-to';
+import { IHasConnectionColor } from '../i-has-connection-color';
+import { IConnectionGradient } from './i-connection-gradient';
+import * as i0 from "@angular/core";
+export declare class FConnectionGradientComponent implements IConnectionGradient {
+    private elementReference;
+    private base;
+    get gradientId(): string;
+    get hostElement(): SVGLinearGradientElement;
+    get stop1Element(): SVGStopElement;
+    get stop2Element(): SVGStopElement;
+    constructor(elementReference: ElementRef<SVGLinearGradientElement>, base: IHasConnectionColor & IHasConnectionFromTo);
+    initialize(): void;
+    private updateGradient;
+    private setFromColor;
+    private setToColor;
+    redraw(vector: IVector): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientComponent, "linearGradient[fConnectionGradient]", never, {}, {}, never, never, false, never>;
+}

package/f-connection/common/f-gradient/i-connection-gradient.d.ts

@@ -0,0 +1,7 @@
+import { IHasHostElement, IVector } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+export declare const CONNECTION_GRADIENT: InjectionToken<IConnectionGradient>;
+export interface IConnectionGradient extends IHasHostElement {
+    initialize(): void;
+    redraw(vector: IVector): void;
+}

package/{components/f-connection → f-connection}/common/f-gradient/index.d.ts

@@ -1 +1,2 @@
 export * from './f-connection-gradient.component';
+export * from './i-connection-gradient';

package/f-connection/common/f-path/f-connection-path.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from "@angular/core";
+import { IHasConnectionColor } from '../i-has-connection-color';
+import { IHasConnectionFromTo } from '../i-has-connection-from-to';
+import { IConnectionPath } from './i-connection-path';
+import * as i0 from "@angular/core";
+export declare class FConnectionPathComponent implements IConnectionPath {
+    private elementReference;
+    private base;
+    get linkToGradient(): string;
+    get attrConnectionId(): string;
+    get hostElement(): SVGPathElement;
+    constructor(elementReference: ElementRef<SVGPathElement>, base: IHasConnectionColor & IHasConnectionFromTo);
+    initialize(): void;
+    setPath(path: string): void;
+    select(): void;
+    deselect(): void;
+    isSelected(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionPathComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPathComponent, "path[f-connection-path]", never, {}, {}, never, never, false, never>;
+}

package/f-connection/common/f-path/i-connection-path.d.ts

@@ -0,0 +1,9 @@
+import { IHasHostElement } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+export declare const CONNECTION_PATH: InjectionToken<IConnectionPath>;
+export interface IConnectionPath extends IHasHostElement {
+    initialize(): void;
+    setPath(path: string): void;
+    select(): void;
+    deselect(): void;
+}

package/{components/f-connection → f-connection}/common/f-path/index.d.ts

@@ -1 +1,2 @@
 export * from './f-connection-path.component';
+export * from './i-connection-path';

package/{components/f-connection → f-connection}/common/f-selection/f-connection-selection.component.d.ts

@@ -1,15 +1,14 @@
 import { ElementRef } from "@angular/core";
 import { IHasHostElement } from '@foblex/core';
-import { IInputOutputModel } from '../i-input-output-model';
-import { FNodeOutletBase, FNodeOutputBase } from '../../../f-connectors';
+import { IHasConnectionFromTo } from '../i-has-connection-from-to';
 import * as i0 from "@angular/core";
 export declare class FConnectionSelectionComponent implements IHasHostElement {
     private elementReference;
-    fromTo: IInputOutputModel<FNodeOutputBase | FNodeOutletBase> | undefined;
+    private base;
     get connectionForSelectionId(): string;
     get hostElement(): SVGPathElement;
-    constructor(elementReference: ElementRef<SVGPathElement>);
+    constructor(elementReference: ElementRef<SVGPathElement>, base: IHasConnectionFromTo);
     setPath(path: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionSelectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, { "fromTo": { "alias": "fromTo"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/i-has-connection-color.d.ts

@@ -0,0 +1,4 @@
+export interface IHasConnectionColor {
+    startColor: string;
+    endColor: string;
+}

package/f-connection/common/i-has-connection-from-to.d.ts

@@ -0,0 +1,4 @@
+export interface IHasConnectionFromTo<T = any> {
+    outputId: T;
+    inputId: T;
+}

package/f-connection/common/i-has-connection-text.d.ts

@@ -0,0 +1,3 @@
+export interface IHasConnectionText {
+    text: string;
+}

package/f-connection/common/index.d.ts

@@ -0,0 +1,16 @@
+export * from './f-connection-text';
+export * from './f-drag-handle';
+export * from './f-gradient';
+export * from './f-path';
+export * from './f-selection';
+export * from './mixins';
+export * from './path-constructor';
+export * from './f-connection-base';
+export * from './cast-to-connection-behavior';
+export * from './cast-to-connection-type';
+export * from './e-connection-behavior';
+export * from './e-connection-type';
+export * from './f-connection-identifiers';
+export * from './i-has-connection-color';
+export * from './i-has-connection-from-to';
+export * from './i-has-connection-text';

package/f-connection/common/mixins/change-connection-selection.mixin.d.ts

@@ -0,0 +1,12 @@
+import { IHasHostElement } from '@foblex/core';
+import { AbstractConstructor, Constructor } from '../../../common-behaviours';
+export interface ISelectable {
+    hostElement: HTMLElement | SVGElement;
+    select(): void;
+    deselect(): void;
+    isSelected(): boolean;
+}
+export declare const F_SELECTED_CLASS = "f-selected";
+type CanChangeConnectionSelectionConstructor = Constructor<ISelectable> & AbstractConstructor<ISelectable>;
+export declare function mixinChangeConnectionSelection<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeConnectionSelectionConstructor & T;
+export {};

package/f-connection/common/mixins/change-connection-visibility.mixin.d.ts

@@ -0,0 +1,10 @@
+import { IHasHostElement } from '@foblex/core';
+import { AbstractConstructor, Constructor } from '../../../common-behaviours';
+export interface ICanChangeConnectionVisibility {
+    hostElement: HTMLElement | SVGElement;
+    show(): void;
+    hide(): void;
+}
+type CanChangeConnectionVisibilityConstructor = Constructor<ICanChangeConnectionVisibility> & AbstractConstructor<ICanChangeConnectionVisibility>;
+export declare function mixinChangeConnectionVisibility<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeConnectionVisibilityConstructor & T;
+export {};

package/f-connection/common/mixins/index.d.ts

@@ -0,0 +1,2 @@
+export * from './change-connection-selection.mixin';
+export * from './change-connection-visibility.mixin';

package/f-connection/common/path-constructor/bezier-path.d.ts

@@ -0,0 +1,6 @@
+import { IPathConstructor, IPathConstructorResult } from './i-path-constructor';
+import { IPoint } from '@foblex/core';
+import { EConnectorSide } from '../../../domain';
+export declare class BezierPath implements IPathConstructor {
+    handle(from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide, borderRadius?: number, offset?: number): IPathConstructorResult;
+}

package/f-connection/common/path-constructor/i-path-constructor.d.ts

@@ -0,0 +1,12 @@
+import { IPoint } from '@foblex/core';
+import { EConnectorSide } from '../../../domain';
+export interface IPathConstructorResult {
+    path: string;
+    labelX: number;
+    labelY: number;
+    offsetX: number;
+    offsetY: number;
+}
+export interface IPathConstructor {
+    handle(from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide, borderRadius: number, offset: number): IPathConstructorResult;
+}

package/f-connection/common/path-constructor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './segment-path';
+export * from './straight-path';
+export * from './bezier-path';
+export * from './i-path-constructor';
+export * from './path-constructor';

package/f-connection/common/path-constructor/path-constructor.d.ts

@@ -0,0 +1,8 @@
+import { EConnectionType } from '../e-connection-type';
+import { IPoint } from '@foblex/core';
+import { IPathConstructorResult } from './i-path-constructor';
+import { EConnectorSide } from '../../../domain';
+export declare class PathConstructor {
+    private static constructors;
+    static handle(type: EConnectionType, from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide): IPathConstructorResult;
+}

package/f-connection/common/path-constructor/segment-path/connector-side-point.d.ts

@@ -0,0 +1,6 @@
+export declare const CONNECTOR_SIDE_POINT: {
+    left: import("@foblex/core").IPoint;
+    right: import("@foblex/core").IPoint;
+    top: import("@foblex/core").IPoint;
+    bottom: import("@foblex/core").IPoint;
+};

package/f-connection/common/path-constructor/segment-path/edge-center-calculator.d.ts

@@ -0,0 +1,3 @@
+export declare class EdgeCenterCalculator {
+    static getEdgeCenter(sourceX: number, sourceY: number, targetX: number, targetY: number): [number, number, number, number];
+}

package/f-connection/common/path-constructor/segment-path/index.d.ts

@@ -0,0 +1,5 @@
+export * from './connector-side-point';
+export * from './edge-center-calculator';
+export * from './path-bend';
+export * from './point-utils';
+export * from './segment-path';

package/f-connection/common/path-constructor/segment-path/path-bend.d.ts

@@ -0,0 +1,4 @@
+import { IPoint } from '@foblex/core';
+export declare class PathBend {
+    static getBend(a: IPoint, b: IPoint, c: IPoint, size: number): string;
+}

package/f-connection/common/path-constructor/segment-path/point-utils.d.ts

@@ -0,0 +1,6 @@
+import { IPoint } from '@foblex/core';
+import { EConnectorSide } from '../../../../domain';
+export declare class PointUtils {
+    static getDirection(source: IPoint, sourcePosition: EConnectorSide, target: IPoint): IPoint;
+    static distance(a: IPoint, b: IPoint): number;
+}

package/f-connection/common/path-constructor/segment-path/segment-path.d.ts

@@ -0,0 +1,10 @@
+import { IPoint } from '@foblex/core';
+import { IPathConstructor, IPathConstructorResult } from '../i-path-constructor';
+import { EConnectorSide } from '../../../../domain';
+export declare class SegmentPath implements IPathConstructor {
+    handle(from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide, borderRadius?: number, offset?: number): IPathConstructorResult;
+    static getPoints(source: IPoint, sourcePosition: EConnectorSide, target: IPoint, targetPosition: EConnectorSide, center: Partial<IPoint>, offset: number): [IPoint[], number, number, number, number];
+    private static buildPath;
+    private static buildMoveOrLineSegment;
+    private static buildLastLineSegment;
+}

package/f-connection/common/path-constructor/straight-path/index.d.ts

@@ -0,0 +1 @@
+export * from './straight-path';

package/f-connection/common/path-constructor/straight-path/straight-path.d.ts

@@ -0,0 +1,6 @@
+import { IPathConstructor, IPathConstructorResult } from '../i-path-constructor';
+import { IPoint } from '@foblex/core';
+import { EConnectorSide } from '../../../../domain';
+export declare class StraightPath implements IPathConstructor {
+    handle(from: IPoint, fromSide: EConnectorSide, to: IPoint, toSide: EConnectorSide, borderRadius?: number, offset?: number): IPathConstructorResult;
+}

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

@@ -0,0 +1,35 @@
+import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { FConnectionBase, FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
+import { EConnectionBehavior } from '../common';
+import { EConnectionType } from '../common';
+import { FComponentsStore } from '../../f-components-store';
+import * as i0 from "@angular/core";
+export declare class FConnectionComponent extends FConnectionBase implements OnInit, OnDestroy {
+    private fComponentsStore;
+    id: string;
+    text: string;
+    startColor: string;
+    endColor: string;
+    outputId: any;
+    inputId: any;
+    set behavior(value: 'fixed' | 'floating');
+    get behavior(): EConnectionBehavior;
+    private _behavior;
+    set type(value: 'segment' | 'straight' | 'bezier');
+    get type(): EConnectionType;
+    private _type;
+    disabled: boolean;
+    fDefs: ElementRef<SVGDefsElement>;
+    fPath: IConnectionPath;
+    fGradient: IConnectionGradient;
+    fDragHandle: FConnectionDragHandleComponent;
+    fSelection: FConnectionSelectionComponent;
+    fText: IConnectionText;
+    fLabel: ElementRef<SVGRectElement>;
+    get boundingElement(): HTMLElement | SVGElement;
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", never, { "id": { "alias": "id"; "required": false; }; "text": { "alias": "text"; "required": false; }; "startColor": { "alias": "startColor"; "required": false; }; "endColor": { "alias": "endColor"; "required": false; }; "outputId": { "alias": "outputId"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "behavior": { "alias": "behavior"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}

package/{components/f-connection → f-connection}/f-connection/index.d.ts

@@ -1,2 +1 @@
 export * from './f-connection.component';
-export * from './f-connection.module';

package/f-connection/f-connection-for-create/f-connection-for-create.component.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewInit, ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { FConnectionBase, FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
+import { EConnectionBehavior } from '../common';
+import { EConnectionType } from '../common';
+import { FComponentsStore } from '../../f-components-store';
+import * as i0 from "@angular/core";
+export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {
+    private fComponentsStore;
+    id: string;
+    text: string;
+    startColor: string;
+    endColor: string;
+    outputId: string | undefined;
+    inputId: string | undefined;
+    set behavior(value: 'fixed' | 'floating');
+    get behavior(): EConnectionBehavior;
+    private _behavior;
+    set type(value: 'segment' | 'straight' | 'bezier');
+    get type(): EConnectionType;
+    private _type;
+    disabled: boolean;
+    fDefs: ElementRef<SVGDefsElement>;
+    fPath: IConnectionPath;
+    fGradient: IConnectionGradient;
+    fDragHandle: FConnectionDragHandleComponent;
+    fSelection: FConnectionSelectionComponent;
+    fText: IConnectionText;
+    fLabel: ElementRef<SVGRectElement>;
+    get boundingElement(): HTMLElement | SVGElement;
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "startColor": { "alias": "startColor"; "required": false; }; "endColor": { "alias": "endColor"; "required": false; }; "behavior": { "alias": "behavior"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}

package/f-connection/f-connection-for-create/index.d.ts

@@ -0,0 +1 @@
+export * from './f-connection-for-create.component';

package/{components/f-connection → f-connection}/index.d.ts

@@ -1,3 +1,3 @@
 export * from './common';
-export * from './f-temp-connection';
+export * from './f-connection-for-create';
 export * from './f-connection';

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

@@ -0,0 +1,2 @@
+export * from './f-connection-for-create/f-connection-for-create.component';
+export * from './f-connection/f-connection.component';

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

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

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

@@ -0,0 +1,10 @@
+import { IHandler, IPointerEvent } from '@foblex/core';
+import { FDraggableDataContext } from '../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class CanvasOnPointerUp implements IHandler<IPointerEvent, void> {
+    private fDraggableDataContext;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    handle(event: IPointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasOnPointerUp, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanvasOnPointerUp>;
+}

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { CanvasOnPointerUp } from './canvas.on-pointer-up';
+import { CanvasPrepareDragSequence } from './canvas.prepare-drag-sequence';
+export declare const CANVAS_PROVIDERS: (typeof CanvasOnPointerUp | typeof CanvasPrepareDragSequence)[];

package/f-draggable/components/f-line-alignment/domain/i-line-alignment-rect.d.ts

@@ -0,0 +1,6 @@
+export interface ILineAlignmentRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}

package/f-draggable/components/f-line-alignment/domain/index.d.ts

@@ -0,0 +1,6 @@
+export * from './i-line-alignment-rect';
+export * from './i-line-alignment-result';
+export * from './i-nearest-coordinate-result';
+export * from './line-element';
+export * from './line-service';
+export * from './nearest-coordinate';

package/f-draggable/components/f-line-alignment/domain/line-element.d.ts

@@ -0,0 +1,9 @@
+import { ILineAlignmentRect } from './i-line-alignment-rect';
+export declare class LineElement {
+    private readonly hostElement;
+    private readonly element;
+    constructor(hostElement: HTMLElement);
+    hide(): void;
+    show(): void;
+    draw(object: Partial<ILineAlignmentRect>): void;
+}

package/f-draggable/components/f-line-alignment/domain/line-service.d.ts

@@ -0,0 +1,11 @@
+import { ISize, ITransformModel } from '@foblex/core';
+export declare class LineService {
+    private hostElement;
+    private fHorizontalLine;
+    private fVerticalLine;
+    constructor(hostElement: HTMLElement);
+    drawVerticalLine(x: number, size: ISize, transform: ITransformModel): void;
+    drawHorizontalLine(y: number, size: ISize, transform: ITransformModel): void;
+    hideVerticalLine(): void;
+    hideHorizontalLine(): void;
+}

package/f-draggable/components/f-line-alignment/domain/nearest-coordinate.d.ts

@@ -0,0 +1,25 @@
+import { IRect } from '@foblex/core';
+import { INearestCoordinateResult } from './i-nearest-coordinate-result';
+/**
+ * A class to find the nearest coordinate.
+ */
+export declare class NearestCoordinateFinder {
+    private elements;
+    private target;
+    /**
+     * Constructor to initialize the NearestCoordinateFinder.
+     * @param elements - The array of IRect elements.
+     * @param target - The target IRect element.
+     */
+    constructor(elements: IRect[], target: IRect);
+    /**
+     * Finds the nearest coordinate on a specified axis.
+     * @returns The nearest coordinate and its distance.
+     */
+    findNearestCoordinateByX(): INearestCoordinateResult;
+    /**
+     * Finds the nearest coordinate on a specified axis.
+     * @returns The nearest coordinate and its distance.
+     */
+    findNearestCoordinateByY(): INearestCoordinateResult;
+}

package/f-draggable/components/f-line-alignment/f-line-alignment-base.d.ts

@@ -0,0 +1,15 @@
+import { IHasHostElement, IPoint } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+import { ILineAlignmentResult } from './domain';
+import { FNodeBase } from '../../../f-node';
+import * as i0 from "@angular/core";
+export declare const F_LINE_ALIGNMENT: InjectionToken<FLineAlignmentBase>;
+export declare abstract class FLineAlignmentBase implements IHasHostElement {
+    abstract hostElement: HTMLElement | SVGElement;
+    abstract initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
+    abstract findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
+    abstract handle(difference: IPoint): void;
+    abstract complete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,31 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { IPoint } from '@foblex/core';
+import { ILineAlignmentResult } from './domain';
+import { FLineAlignmentBase } from './f-line-alignment-base';
+import { FComponentsStore } from '../../../f-components-store';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { GetElementRectInFlowHandler } from '../../../domain';
+import { FNodeBase } from '../../../f-node';
+import * as i0 from "@angular/core";
+export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
+    private elementReference;
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private getElementRectInFlowHandler;
+    get hostElement(): HTMLElement;
+    private lineService;
+    private size;
+    private draggedNodeRect;
+    private rects;
+    private get transform();
+    private get flowHost();
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, getElementRectInFlowHandler: GetElementRectInFlowHandler);
+    ngOnInit(): void;
+    initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
+    handle(difference: IPoint): void;
+    private drawIntersectingLines;
+    findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
+    complete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], {}, {}, never, never, false, never>;
+}

package/f-draggable/components/f-line-alignment/index.d.ts

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './f-line-alignment.component';
+export * from './f-line-alignment-base';

package/f-draggable/components/f-line-alignment/public-api.d.ts

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

package/f-draggable/components/f-selection-area/domain/i-selection-area-rect.d.ts

@@ -0,0 +1,6 @@
+export interface ISelectionAreaRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}

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

@@ -0,0 +1 @@
+export * from './i-selection-area-rect';

package/f-draggable/components/f-selection-area/f-selection-area-base.d.ts

@@ -0,0 +1,13 @@
+import { IHasHostElement } from '@foblex/core';
+import { InjectionToken } from '@angular/core';
+import { ISelectionAreaRect } from './domain';
+import * as i0 from "@angular/core";
+export declare const F_SELECTION_AREA: InjectionToken<FSelectionAreaBase>;
+export declare abstract class FSelectionAreaBase implements IHasHostElement {
+    abstract hostElement: HTMLElement | SVGElement;
+    abstract hide(): void;
+    abstract show(): void;
+    abstract draw(object: ISelectionAreaRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionAreaBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FSelectionAreaBase, never, never, {}, {}, never, never, false, never>;
+}

package/f-draggable/components/f-selection-area/f-selection-area.component.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { FSelectionAreaBase } from './f-selection-area-base';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { ISelectionAreaRect } from './domain';
+import * as i0 from "@angular/core";
+export declare class FSelectionAreaComponent extends FSelectionAreaBase implements OnInit {
+    private elementReference;
+    private fDraggableDataContext;
+    get hostElement(): HTMLElement;
+    constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext);
+    ngOnInit(): void;
+    hide(): void;
+    show(): void;
+    draw(object: ISelectionAreaRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSelectionAreaComponent, "f-selection-area", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './f-selection-area.component';
+export * from './f-selection-area-base';

package/f-draggable/components/f-selection-area/public-api.d.ts

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

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

@@ -0,0 +1,3 @@
+export * from './f-external-item';
+export * from './f-line-alignment';
+export * from './f-selection-area';

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

@@ -0,0 +1,3 @@
+export * from './f-external-item/public-api';
+export * from './f-line-alignment/public-api';
+export * from './f-selection-area/public-api';

package/f-draggable/connections/create-connection/create-connection.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, GetOutputRectInFlowHandler } from '../../../domain';
+import { FConnectionBase } from '../../../f-connection';
+export declare class CreateConnectionDragHandler implements IDraggableItem {
+    private getOutputRectInFlowHandler;
+    private getConnectionVectorHandler;
+    connection: FConnectionBase;
+    private mouseDownPoint;
+    readonly type: EDraggableType;
+    private onPointerDownFromConnectorRect;
+    private onPointerDownToConnectorRect;
+    private outputSide;
+    constructor(getOutputRectInFlowHandler: GetOutputRectInFlowHandler, getConnectionVectorHandler: GetConnectionVectorHandler, connection: FConnectionBase, mouseDownPoint: IPoint);
+    initialize(): void;
+    move(difference: IPoint): void;
+    complete(): void;
+}