@foblex/flow 18.0.0 → 18.1.1

package/f-connectors/f-node-outlet/f-node-outlet-base.d.ts

@@ -1,9 +1,10 @@
 import { InjectionToken } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { FConnectorBase, FConnectorKind } from '../f-connector-base';
 import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
 export declare abstract class FNodeOutletBase extends FSourceConnectorBase {
+    kind: FConnectorKind;
     abstract isConnectionFromOutlet: boolean;
     private _outputs;
     get canBeConnected(): boolean;

package/f-connectors/f-node-output/f-node-output-base.d.ts

@@ -1,8 +1,10 @@
 import { InjectionToken, Signal } from '@angular/core';
 import { FSourceConnectorBase } from '../f-source-connector-base';
+import { FConnectorKind } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
 export declare abstract class FNodeOutputBase extends FSourceConnectorBase {
+    kind: FConnectorKind;
     abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;

package/f-draggable/connection/create-connection/create-connection-finalize/create-connection-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class CreateConnectionFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/connection/create-connection/create-connection-finalize/create-connection-finalize.d.ts

@@ -0,0 +1,19 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFinalizeRequest } from './create-connection-finalize-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionFinalize implements IHandler<CreateConnectionFinalizeRequest, void> {
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _dragHandler();
+    handle(request: CreateConnectionFinalizeRequest): void;
+    private _isValid;
+    private _getTargetOutput;
+    private _getOutput;
+    private _getOutlet;
+    private _emitEvent;
+    private _getInputUnderPointer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFinalize>;
+}

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

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

package/f-draggable/connection/create-connection/create-connection-handler/create-connection-handler.d.ts

@@ -0,0 +1,35 @@
+import { IPoint } from '@foblex/2d';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../../f-connectors';
+import { DragHandlerBase } from '../../../infrastructure';
+import { ICreateConnectionEventData } from '../i-create-connection-event-data';
+import * as i0 from "@angular/core";
+type FSourceConnector = FNodeOutputBase | FNodeOutletBase;
+export declare class CreateConnectionHandler extends DragHandlerBase<ICreateConnectionEventData> {
+    protected readonly type = "create-connection";
+    protected readonly kind = "create-connection";
+    protected data(): {
+        fOutputOrOutletId: string;
+    };
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _connectionBehaviour;
+    private readonly _store;
+    private get _connection();
+    private get _snapConnection();
+    private _targets;
+    private _sourceRef;
+    private _pointerDown;
+    initialize(source: FSourceConnector, pointer: IPoint): void;
+    prepareDragSequence(): void;
+    private _collectAndMarkTargets;
+    private _initSnapConnection;
+    private _initCreateConnection;
+    onPointerMove(difference: IPoint): void;
+    private _findClosestTarget;
+    private _drawCreateConnection;
+    private _drawSnapConnection;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionHandler>;
+}
+export {};

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

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

package/f-draggable/connection/create-connection/create-connection-preparation/create-connection-preparation.d.ts

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionPreparationRequest } from './create-connection-preparation-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionPreparation implements IHandler<CreateConnectionPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    handle({ event, fTrigger }: CreateConnectionPreparationRequest): void;
+    private _findOwnerNode;
+    private _isValidConditions;
+    private _isValidTrigger;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionPreparation>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/create-connection-create-drag-handler-request.d.ts

@@ -0,0 +1,8 @@
+import { IPoint } from '@foblex/2d';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../../../f-connectors';
+export declare class CreateConnectionCreateDragHandlerRequest {
+    readonly eventPosition: IPoint;
+    readonly source: FNodeOutputBase | FNodeOutletBase;
+    static readonly fToken: unique symbol;
+    constructor(eventPosition: IPoint, source: FNodeOutputBase | FNodeOutletBase);
+}

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/create-connection-create-drag-handler.d.ts

@@ -0,0 +1,26 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionCreateDragHandlerRequest } from './create-connection-create-drag-handler-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionCreateDragHandler implements IHandler<CreateConnectionCreateDragHandlerRequest, void> {
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _transform();
+    handle({ source, eventPosition }: CreateConnectionCreateDragHandlerRequest): void;
+    /**
+     * Converts raw pointer position to "flow host space":
+     * - applies elementTransform(flowHost)
+     * - normalizes by scale
+     */
+    private _toFlowSpace;
+    /**
+     * Converts from flow space to "canvas local space":
+     * - removes transform offsets (position, scaledPosition)
+     * - keeps normalization consistent
+     *
+     * (Same math as your original chain, just named.)
+     */
+    private _toCanvasSpace;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionCreateDragHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionCreateDragHandler>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-connection-create-drag-handler';
+export * from './create-connection-create-drag-handler-request';

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/create-connection-from-outlet-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FNodeBase } from '../../../../../f-node';
+import { IPointerEvent } from '../../../../../drag-toolkit';
+export declare class CreateConnectionFromOutletPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly node: FNodeBase;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, node: FNodeBase);
+}

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/create-connection-from-outlet-preparation.d.ts

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFromOutletPreparationRequest } from './create-connection-from-outlet-preparation-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionFromOutletPreparation implements IHandler<CreateConnectionFromOutletPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    handle({ event, node }: CreateConnectionFromOutletPreparationRequest): void;
+    private _findOutlet;
+    private _getOutputs;
+    private _resolveOutput;
+    private _startDrag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFromOutletPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFromOutletPreparation>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-connection-from-outlet-preparation';
+export * from './create-connection-from-outlet-preparation-request';

package/f-draggable/connection/create-connection/create-connection-preparation/from-output-preparation/create-connection-from-output-preparation.d.ts

@@ -0,0 +1,13 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFromOutputPreparationRequest } from './create-connection-from-output-preparation-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionFromOutputPreparation implements IHandler<CreateConnectionFromOutputPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    handle({ event, node }: CreateConnectionFromOutputPreparationRequest): void;
+    private _hasOutlet;
+    private _findOutput;
+    private _startDrag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFromOutputPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFromOutputPreparation>;
+}

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

@@ -0,0 +1,5 @@
+export * from './create-drag-handler';
+export * from './from-outlet-preparation';
+export * from './from-output-preparation';
+export * from './create-connection-preparation';
+export * from './create-connection-preparation-request';

package/f-draggable/connection/create-connection/f-create-connection-event.d.ts

@@ -0,0 +1,16 @@
+import { IPoint } from '@foblex/2d';
+export declare class FCreateConnectionEvent {
+    /** Source connector id */
+    readonly sourceId: string;
+    /** Target connector id (can be undefined if dropped to nowhere) */
+    readonly targetId: string | undefined;
+    /** Pointer position where the user dropped pointer. */
+    readonly dropPosition: IPoint;
+    /** @deprecated Use `sourceId` */
+    readonly fOutputId: string;
+    /** @deprecated Use `targetId` */
+    readonly fInputId: string | undefined;
+    /** @deprecated Use `dropPosition` */
+    readonly fDropPosition: IPoint;
+    constructor(sourceId: string, targetId: string | undefined, dropPosition: IPoint);
+}

package/f-draggable/connection/create-connection/i-create-connection-drag-result.d.ts

@@ -0,0 +1,7 @@
+import { RoundedRect } from '@foblex/2d';
+import { IConnectorRectRef } from '../../../domain';
+export interface ICreateConnectionDragResult {
+    toConnectorRect: RoundedRect;
+    fOutputId: string;
+    canBeConnectedInputs: IConnectorRectRef[];
+}

package/f-draggable/connection/create-connection/i-create-connection-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface ICreateConnectionEventData {
+    fOutputOrOutletId: string;
+}

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

@@ -0,0 +1,7 @@
+export * from './create-connection-finalize';
+export * from './create-connection-preparation';
+export * from './resolve-connectable-output-for-outlet';
+export * from './create-connection-handler';
+export * from './f-create-connection-event';
+export * from './i-create-connection-event-data';
+export * from './i-create-connection-drag-result';

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolve-connectable-output-for-outlet';
+export * from './resolve-connectable-output-for-outlet-request';

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/resolve-connectable-output-for-outlet-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeOutletBase } from '../../../../f-connectors';
+export declare class ResolveConnectableOutputForOutletRequest {
+    readonly outlet: FNodeOutletBase;
+    static readonly fToken: unique symbol;
+    constructor(outlet: FNodeOutletBase);
+}

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/resolve-connectable-output-for-outlet.d.ts

@@ -0,0 +1,12 @@
+import { IHandler } from '@foblex/mediator';
+import { FConnectorBase } from '../../../../f-connectors';
+import { ResolveConnectableOutputForOutletRequest } from './resolve-connectable-output-for-outlet-request';
+import * as i0 from "@angular/core";
+export declare class ResolveConnectableOutputForOutlet implements IHandler<ResolveConnectableOutputForOutletRequest, FConnectorBase | undefined> {
+    private readonly _store;
+    handle({ outlet }: ResolveConnectableOutputForOutletRequest): FConnectorBase | undefined;
+    private _findOwnerNode;
+    private _findFirstConnectableOutputInNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectableOutputForOutlet, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectableOutputForOutlet>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/drag-connection-waypoint-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class DragConnectionWaypointFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/drag-connection-waypoint-finalize.d.ts

@@ -0,0 +1,11 @@
+import { DragConnectionWaypointFinalizeRequest } from './drag-connection-waypoint-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragConnectionWaypointFinalize implements IExecution<DragConnectionWaypointFinalizeRequest, void> {
+    private readonly _dragContext;
+    private get _fDragHandler();
+    handle(_request: DragConnectionWaypointFinalizeRequest): void;
+    private _isDroppedConnectionReassignEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointFinalize>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-connection-waypoint-finalize';
+export * from './drag-connection-waypoint-finalize-request';

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

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../../infrastructure';
+import { FConnectionBase, WaypointPick } from '../../../../f-connection-v2';
+import * as i0 from "@angular/core";
+export declare class DragConnectionWaypointHandler extends DragHandlerBase<unknown> {
+    protected readonly type = "move-connection-waypoint";
+    protected readonly kind = "drag-connection-waypoint";
+    private readonly _store;
+    private _point;
+    private _pick;
+    private get _waypointsComponent();
+    private get _connection();
+    setPick(pick: WaypointPick<FConnectionBase>): void;
+    prepareDragSequence(): void;
+    onPointerMove(_difference: IPoint): void;
+    onPointerUp(): void;
+    private _redrawConnection;
+    private _eventFromPick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointHandler>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-handler/index.d.ts

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

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/drag-connection-waypoint-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+import { FEventTrigger } from '../../../../domain';
+export declare class DragConnectionWaypointPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/drag-connection-waypoint-preparation.d.ts

@@ -0,0 +1,19 @@
+import { DragConnectionWaypointPreparationRequest } from './drag-connection-waypoint-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragConnectionWaypointPreparation implements IExecution<DragConnectionWaypointPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _canvas();
+    private get _transform();
+    private get _flowHost();
+    private get _connections();
+    handle(request: DragConnectionWaypointPreparationRequest): void;
+    private _pickControlPoint;
+    private _isValidTrigger;
+    private _updateConnectionLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointPreparation>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-connection-waypoint-preparation';
+export * from './drag-connection-waypoint-preparation-request';

package/f-draggable/connection/drag-connection-waypoint/index.d.ts

@@ -0,0 +1,4 @@
+export * from './drag-connection-waypoint-finalize';
+export * from './drag-connection-waypoint-preparation';
+export * from './drag-connection-waypoint-handler';
+export * from './f-connection-waypoints-changed-event';

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

@@ -0,0 +1,4 @@
+export * from './create-connection';
+export * from './reassign-connection';
+export * from './drag-connection-waypoint';
+export * from './providers';

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

@@ -0,0 +1,4 @@
+import { CreateConnectionFromOutputPreparation, CreateConnectionPreparation, CreateConnectionCreateDragHandler, CreateConnectionFinalize, CreateConnectionFromOutletPreparation, ResolveConnectableOutputForOutlet } from './create-connection';
+import { ReassignConnectionFinalize, ReassignConnectionPreparation } from './reassign-connection';
+import { DragConnectionWaypointFinalize, DragConnectionWaypointPreparation } from './drag-connection-waypoint';
+export declare const DRAG_CONNECTIONS_PROVIDERS: (typeof ResolveConnectableOutputForOutlet | typeof CreateConnectionFinalize | typeof CreateConnectionCreateDragHandler | typeof CreateConnectionFromOutletPreparation | typeof CreateConnectionFromOutputPreparation | typeof CreateConnectionPreparation | typeof ReassignConnectionFinalize | typeof ReassignConnectionPreparation | typeof DragConnectionWaypointFinalize | typeof DragConnectionWaypointPreparation)[];

package/f-draggable/connection/reassign-connection/f-reassign-connection-event.d.ts

@@ -0,0 +1,29 @@
+import { IPoint } from '@foblex/2d';
+export type FConnectionEndpoint = 'source' | 'target';
+export declare class FReassignConnectionEvent {
+    readonly connectionId: string;
+    /** Which endpoint was reassigned. */
+    readonly endpoint: FConnectionEndpoint;
+    /** Previous and next ids; `next*Id` can be `undefined` if dropped to nowhere. */
+    readonly previousSourceId: string;
+    readonly nextSourceId: string | undefined;
+    readonly previousTargetId: string;
+    readonly nextTargetId: string | undefined;
+    /** Pointer position where the user dropped pointer. */
+    readonly dropPosition: IPoint;
+    /** @deprecated Use `endpoint === 'source'` */
+    readonly isSourceReassign: boolean;
+    /** @deprecated Use `endpoint === 'target'` */
+    readonly isTargetReassign: boolean;
+    /** @deprecated Use `previousSourceId` */
+    readonly oldSourceId: string;
+    /** @deprecated Use `nextSourceId` */
+    readonly newSourceId: string | undefined;
+    /** @deprecated Use `previousTargetId` */
+    readonly oldTargetId: string;
+    /** @deprecated Use `nextTargetId` */
+    readonly newTargetId: string | undefined;
+    /** @deprecated Use `dropPosition` */
+    readonly dropPoint: IPoint;
+    constructor(connectionId: string, endpoint: FConnectionEndpoint, previousSourceId: string, nextSourceId: string | undefined, previousTargetId: string, nextTargetId: string | undefined, dropPosition: IPoint);
+}

package/f-draggable/connection/reassign-connection/i-reassign-connection-drag-result.d.ts

@@ -0,0 +1,17 @@
+import { RoundedRect } from '@foblex/2d';
+import { IConnectorRectRef } from '../../../domain';
+import { FConnectionBase } from '../../../f-connection-v2';
+export interface IReassignConnectionDragResult {
+    /** Which handle is being dragged: source(output) or target(input). */
+    draggedEnd: 'source' | 'target';
+    /**
+     * Line endpoints represented as small rects (anchors) so we can use the same math as for connectors.
+     * These are NOT connector bounds.
+     */
+    sourceAnchorRect: RoundedRect;
+    targetAnchorRect: RoundedRect;
+    /** Connection being reassigned. */
+    connection: FConnectionBase;
+    /** Candidate connectors that are connectable for this reassignment. */
+    candidates: IConnectorRectRef[];
+}

package/f-draggable/connection/reassign-connection/i-reassign-connection-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface IReassignConnectionEventData {
+    fConnectionId: string;
+}

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

@@ -0,0 +1,6 @@
+export * from './reassign-connection-finalize';
+export * from './reassign-connection-preparation';
+export * from './reassign-connection-handler';
+export * from './f-reassign-connection-event';
+export * from './i-reassign-connection-drag-result';
+export * from './i-reassign-connection-event-data';

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

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

package/f-draggable/connection/reassign-connection/reassign-connection-finalize/reassign-connection-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class ReassignConnectionFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/connection/reassign-connection/reassign-connection-finalize/reassign-connection-finalize.d.ts

@@ -0,0 +1,18 @@
+import { ReassignConnectionFinalizeRequest } from './reassign-connection-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ReassignConnectionFinalize implements IExecution<ReassignConnectionFinalizeRequest, void> {
+    private readonly _dragResult;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _dragDirective();
+    handle({ event }: ReassignConnectionFinalizeRequest): void;
+    private _findReassignHandler;
+    private _emitIfChanged;
+    private _findConnectableConnector;
+    private _isReassignedToDifferentConnector;
+    private _buildEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionFinalize>;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/i-reassign-handler.d.ts

@@ -0,0 +1,15 @@
+import { IPoint, RoundedRect } from '@foblex/2d';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IClosestConnectorRef, IConnectorRectRef } from '../../../../domain';
+export interface IReassignHandler {
+    /** List used by finalize step to find the closest candidate connector. */
+    candidates(): IConnectorRectRef[];
+    /** Collects candidates and marks them in UI. */
+    collectAndMarkCandidates(): void;
+    /** Optional snap connection preview. */
+    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+}
+export declare function withinSnapThreshold(fClosestConnector: IClosestConnectorRef | undefined, snapConnection: FSnapConnectionComponent): IClosestConnectorRef | undefined;
+export declare function rectFromPoint(point: IPoint): RoundedRect;

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

@@ -0,0 +1,4 @@
+export * from './reassign-connection-source-handler';
+export * from './reassign-connection-target-handler';
+export * from './i-reassign-handler';
+export * from './reassign-connection-handler';

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

@@ -0,0 +1,30 @@
+import { DragHandlerBase } from '../../../infrastructure';
+import { IReassignConnectionEventData } from '../i-reassign-connection-event-data';
+import { FConnectionBase } from '../../../../f-connection-v2';
+import { IPoint } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export declare class ReassignConnectionHandler extends DragHandlerBase<IReassignConnectionEventData> {
+    protected readonly type = "reassign-connection";
+    protected readonly kind = "reassign-connection";
+    protected data(): {
+        fConnectionId: string;
+    };
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _connectionBehaviour;
+    private readonly _store;
+    private get _snapConnection();
+    private _connection;
+    private _draggedEnd;
+    private _sourceRef;
+    private _targetRef;
+    private _reassignHandler;
+    initialize(connection: FConnectionBase, isTargetDragHandle: boolean): void;
+    private _createSourceHandler;
+    private _createTargetHandler;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionHandler>;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/reassign-connection-source-handler.d.ts

@@ -0,0 +1,27 @@
+import { FMediator } from '@foblex/mediator';
+import { IConnectorRectRef } from '../../../../domain';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IReassignHandler } from './i-reassign-handler';
+import { ConnectionBehaviourBuilder, FConnectionBase } from '../../../../f-connection-v2';
+export declare class ReassignConnectionSourceHandler implements IReassignHandler {
+    private readonly _mediator;
+    private readonly _behaviour;
+    private readonly _connection;
+    private readonly _sourceRef;
+    private readonly _targetRef;
+    private _candidates;
+    private _snap;
+    private readonly _anchorRect;
+    private get _source();
+    private get _target();
+    constructor(_mediator: FMediator, _behaviour: ConnectionBehaviourBuilder, _connection: FConnectionBase, _sourceRef: IConnectorRectRef, _targetRef: IConnectorRectRef);
+    candidates(): IConnectorRectRef[];
+    collectAndMarkCandidates(): void;
+    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
+    onPointerMove(difference: IPoint): void;
+    private _findClosest;
+    private _draw;
+    private _drawSnap;
+    onPointerUp(): void;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/reassign-connection-target-handler.d.ts

@@ -0,0 +1,27 @@
+import { FMediator } from '@foblex/mediator';
+import { IConnectorRectRef } from '../../../../domain';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IReassignHandler } from './i-reassign-handler';
+import { ConnectionBehaviourBuilder, FConnectionBase } from '../../../../f-connection-v2';
+export declare class ReassignConnectionTargetHandler implements IReassignHandler {
+    private readonly _mediator;
+    private readonly _behaviour;
+    private readonly _connection;
+    private readonly _sourceRef;
+    private readonly _targetRef;
+    private _candidates;
+    private _snap;
+    private readonly _anchorRect;
+    private get _source();
+    private get _target();
+    constructor(_mediator: FMediator, _behaviour: ConnectionBehaviourBuilder, _connection: FConnectionBase, _sourceRef: IConnectorRectRef, _targetRef: IConnectorRectRef);
+    candidates(): IConnectorRectRef[];
+    collectAndMarkCandidates(): void;
+    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    private _findClosest;
+    private _draw;
+    private _drawSnap;
+}

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

@@ -0,0 +1,3 @@
+export * from './reassign-connection-preparation';
+export * from './reassign-connection-preparation-request';
+export * from './is-pointer-inside-start-or-end-drag-handles';

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/reassign-connection-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../../../domain';
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class ReassignConnectionPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/reassign-connection-preparation.d.ts

@@ -0,0 +1,20 @@
+import { ReassignConnectionPreparationRequest } from './reassign-connection-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ReassignConnectionPreparation implements IExecution<ReassignConnectionPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _canvas();
+    private get _transform();
+    private get _connections();
+    handle(request: ReassignConnectionPreparationRequest): void;
+    private _findConnectionAt;
+    private _capturePointerDown;
+    private _startDrag;
+    private _isValidTrigger;
+    private _bringToFront;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionPreparation>;
+}