@foblex/flow 17.9.81 → 18.1.0

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

@@ -1,6 +1,8 @@
+export * from './emit-end-drag-sequence-event';
+export * from './emit-start-drag-sequence-event';
+export * from './emit-selection-change-event';
 export * from './get-normalized-parent-node-rect';
 export * from './is-array-has-parent-node';
-export * from './is-connection-under-node';
-export * from './f-drag-started-event';
+export * from './detect-connections-under-drag-node';
 export * from './i-node-with-rect';
 export * from './providers';

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

@@ -1,4 +1,7 @@
 import { IsArrayHasParentNodeExecution } from './is-array-has-parent-node';
 import { GetNormalizedParentNodeRectExecution } from './get-normalized-parent-node-rect';
-import { IsConnectionUnderNodeExecution } from './is-connection-under-node';
-export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution | typeof IsConnectionUnderNodeExecution)[];
+import { DetectConnectionsUnderDragNode } from './detect-connections-under-drag-node';
+import { EmitStartDragSequenceEvent } from './emit-start-drag-sequence-event';
+import { EmitEndDragSequenceEvent } from './emit-end-drag-sequence-event';
+import { EmitSelectionChangeEvent } from './emit-selection-change-event';
+export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof EmitEndDragSequenceEvent | typeof EmitStartDragSequenceEvent | typeof EmitSelectionChangeEvent | typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution | typeof DetectConnectionsUnderDragNode)[];

package/f-draggable/drag-canvas/drag-canvas-finalize/drag-canvas-finalize-request.d.ts

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

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

@@ -0,0 +1,10 @@
+import { DragCanvasFinalizeRequest } from './drag-canvas-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragCanvasFinalize implements IExecution<DragCanvasFinalizeRequest, void> {
+    private readonly _dragContext;
+    handle(_request: DragCanvasFinalizeRequest): void;
+    private _isValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasFinalize>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class DragCanvasHandler extends DragHandlerBase<unknown> {
+    protected readonly type = "canvas-move";
+    protected readonly kind = "drag-canvas";
+    private readonly _store;
+    private _onPointerDownPosition;
+    constructor();
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasHandler>;
+}

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

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

package/f-draggable/drag-canvas/drag-canvas-preparation/drag-canvas-preparation-request.d.ts

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

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

@@ -0,0 +1,16 @@
+import { DragCanvasPreparationRequest } from './drag-canvas-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragCanvasPreparation implements IExecution<DragCanvasPreparationRequest, void> {
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    handle({ event, fTrigger }: DragCanvasPreparationRequest): void;
+    private _isValid;
+    private _isBackgroundElement;
+    private _isDragOnHost;
+    private _getNode;
+    private _isValidTrigger;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasPreparation>;
+}

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

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

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

@@ -0,0 +1,4 @@
+export * from './drag-canvas-finalize';
+export * from './drag-canvas-handler';
+export * from './drag-canvas-preparation';
+export * from './providers';

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

@@ -0,0 +1,3 @@
+import { DragCanvasPreparation } from './drag-canvas-preparation';
+import { DragCanvasFinalize } from './drag-canvas-finalize';
+export declare const DRAG_CANVAS_PROVIDERS: (typeof DragCanvasFinalize | typeof DragCanvasPreparation)[];

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-drag-node-handler-from-selection-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeBase } from '../../../f-node';
+export declare class AttachDragNodeHandlerFromSelectionRequest {
+    readonly nodeOrGroup?: FNodeBase | undefined;
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup?: FNodeBase | undefined);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-drag-node-handler-from-selection.d.ts

@@ -0,0 +1,18 @@
+import { AttachDragNodeHandlerFromSelectionRequest } from './attach-drag-node-handler-from-selection-request';
+import { IExecution } from '@foblex/mediator';
+import { DragNodeHandler } from '../drag-node-handler';
+import * as i0 from "@angular/core";
+export declare class AttachDragNodeHandlerFromSelection implements IExecution<AttachDragNodeHandlerFromSelectionRequest, DragNodeHandler> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    handle({ nodeOrGroup }: AttachDragNodeHandlerFromSelectionRequest): DragNodeHandler;
+    private _collectSelected;
+    private _findNodeByHost;
+    private _withDeepChildren;
+    private _collectSourceConnectorIds;
+    private _collectTargetConnectorIds;
+    private _attachConnectionHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachDragNodeHandlerFromSelection, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AttachDragNodeHandlerFromSelection>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/attach-source-connection-drag-handlers-to-node-request.d.ts

@@ -0,0 +1,28 @@
+import { DragNodeConnectionHandlerBase } from '../../drag-node-dependent-connection-handlers';
+import { DragNodeItemHandler } from '../../drag-node-handler';
+export declare class AttachSourceConnectionDragHandlersToNodeRequest {
+    /** Node move handler we attach connection handlers to. */
+    readonly dragHandler: DragNodeItemHandler;
+    /**
+     * Connectors considered "target side" for connections (previously: inputIds).
+     * These are target connector ids that are within current drag selection.
+     */
+    readonly targetIds: string[];
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    readonly handlerPool: DragNodeConnectionHandlerBase[];
+    static readonly fToken: unique symbol;
+    constructor(
+    /** Node move handler we attach connection handlers to. */
+    dragHandler: DragNodeItemHandler, 
+    /**
+     * Connectors considered "target side" for connections (previously: inputIds).
+     * These are target connector ids that are within current drag selection.
+     */
+    targetIds: string[], 
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    handlerPool: DragNodeConnectionHandlerBase[]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/attach-source-connection-drag-handlers-to-node.d.ts

@@ -0,0 +1,18 @@
+import { AttachSourceConnectionDragHandlersToNodeRequest } from './attach-source-connection-drag-handlers-to-node-request';
+import { IExecution } from '@foblex/mediator';
+import { FNodeBase } from '../../../../f-node';
+import { FConnectionBase } from '../../../../f-connection-v2';
+import * as i0 from "@angular/core";
+export declare class AttachSourceConnectionDragHandlersToNode implements IExecution<AttachSourceConnectionDragHandlersToNodeRequest, void> {
+    private readonly _store;
+    private readonly _dragInjector;
+    private get _connections();
+    handle(request: AttachSourceConnectionDragHandlersToNodeRequest): void;
+    _getOutputConnections(nodeOrGroup: FNodeBase): FConnectionBase[];
+    private _getNodeOutputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachSourceConnectionDragHandlersToNode, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AttachSourceConnectionDragHandlersToNode>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-source-connection-drag-handlers-to-node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attach-source-connection-drag-handlers-to-node';
+export * from './attach-source-connection-drag-handlers-to-node-request';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/attach-target-connection-drag-handlers-to-node-request.d.ts

@@ -0,0 +1,28 @@
+import { DragNodeConnectionHandlerBase } from '../../drag-node-dependent-connection-handlers';
+import { DragNodeItemHandler } from '../../drag-node-handler';
+export declare class AttachTargetConnectionDragHandlersToNodeRequest {
+    /** Node move handler we attach connection handlers to. */
+    readonly dragHandler: DragNodeItemHandler;
+    /**
+     * Connectors considered "source side" for connections (previously: outputIds).
+     * These are source connector ids that are within current drag selection.
+     */
+    readonly sourceIds: string[];
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    readonly handlerPool: DragNodeConnectionHandlerBase[];
+    static readonly fToken: unique symbol;
+    constructor(
+    /** Node move handler we attach connection handlers to. */
+    dragHandler: DragNodeItemHandler, 
+    /**
+     * Connectors considered "source side" for connections (previously: outputIds).
+     * These are source connector ids that are within current drag selection.
+     */
+    sourceIds: string[], 
+    /**
+     * Shared pool to reuse already created handlers for the same connection.
+     */
+    handlerPool: DragNodeConnectionHandlerBase[]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/attach-target-connection-drag-handlers-to-node.d.ts

@@ -0,0 +1,16 @@
+import { AttachTargetConnectionDragHandlersToNodeRequest } from './attach-target-connection-drag-handlers-to-node-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class AttachTargetConnectionDragHandlersToNode implements IExecution<AttachTargetConnectionDragHandlersToNodeRequest, void> {
+    private readonly _store;
+    private readonly _dragInjector;
+    private get _connections();
+    handle(request: AttachTargetConnectionDragHandlersToNodeRequest): void;
+    private _getInputConnections;
+    private _getNodeInputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachTargetConnectionDragHandlersToNode, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AttachTargetConnectionDragHandlersToNode>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/attach-target-connection-drag-handlers-to-node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attach-target-connection-drag-handlers-to-node';
+export * from './attach-target-connection-drag-handlers-to-node-request';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/build-drag-node-constraints-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeBase } from '../../../../f-node';
+export declare class BuildDragNodeConstraintsRequest {
+    readonly nodeOrGroup: FNodeBase;
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup: FNodeBase);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/build-drag-node-constraints.d.ts

@@ -0,0 +1,19 @@
+import { IExecution } from '@foblex/mediator';
+import { BuildDragNodeConstraintsRequest } from './build-drag-node-constraints-request';
+import { IDragNodeDeltaConstraints } from '../../drag-node-constraint';
+import * as i0 from "@angular/core";
+export declare class BuildDragNodeConstraints implements IExecution<BuildDragNodeConstraintsRequest, IDragNodeDeltaConstraints> {
+    private readonly _mediator;
+    handle({ nodeOrGroup }: BuildDragNodeConstraintsRequest): IDragNodeDeltaConstraints;
+    private _readCurrentRect;
+    private _readParentsChain;
+    private _buildConstraints;
+    private _readParentBounds;
+    private _calculateDifference;
+    private _calculateMinimumDifference;
+    private _calculateMaximumDifference;
+    private _isAutoExpand;
+    private _makeSoftLimit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildDragNodeConstraints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildDragNodeConstraints>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/build-drag-node-constraints/index.d.ts

@@ -0,0 +1,2 @@
+export * from './build-drag-node-constraints';
+export * from './build-drag-node-constraints-request';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-handler/create-drag-node-handler-request.d.ts

@@ -0,0 +1,13 @@
+import { DragNodeItemHandler } from '../../drag-node-handler';
+export declare class CreateDragNodeHandlerRequest {
+    /** Root handlers (handlers without parents in the selection). */
+    readonly rootHandlers: DragNodeItemHandler[];
+    /** All handlers participating in the drag operation. */
+    readonly participants: DragNodeItemHandler[];
+    static readonly fToken: unique symbol;
+    constructor(
+    /** Root handlers (handlers without parents in the selection). */
+    rootHandlers: DragNodeItemHandler[], 
+    /** All handlers participating in the drag operation. */
+    participants: DragNodeItemHandler[]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-handler/create-drag-node-handler.d.ts

@@ -0,0 +1,13 @@
+import { IExecution } from '@foblex/mediator';
+import { CreateDragNodeHandlerRequest } from './create-drag-node-handler-request';
+import { DragNodeHandler } from '../../drag-node-handler';
+import * as i0 from "@angular/core";
+export declare class CreateDragNodeHandler implements IExecution<CreateDragNodeHandlerRequest, DragNodeHandler> {
+    private readonly _dragInjector;
+    private readonly _mediator;
+    handle({ rootHandlers, participants }: CreateDragNodeHandlerRequest): DragNodeHandler;
+    private _applyConstraintsToRoots;
+    private _calculateConstraints;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDragNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDragNodeHandler>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-handler/index.d.ts

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

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-hierarchy/create-drag-node-hierarchy-request.d.ts

@@ -0,0 +1,7 @@
+import { FNodeBase } from '../../../../f-node';
+export declare class CreateDragNodeHierarchyRequest {
+    readonly nodesAndGroups: FNodeBase[];
+    static readonly fToken: unique symbol;
+    /** Selected nodes and groups including their deep children. */
+    constructor(nodesAndGroups: FNodeBase[]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-hierarchy/create-drag-node-hierarchy.d.ts

@@ -0,0 +1,12 @@
+import { IExecution } from '@foblex/mediator';
+import { CreateDragNodeHierarchyRequest } from './create-drag-node-hierarchy-request';
+import { DragNodeHierarchy } from './drag-node-hierarchy';
+import * as i0 from "@angular/core";
+export declare class CreateDragNodeHierarchy implements IExecution<CreateDragNodeHierarchyRequest, DragNodeHierarchy> {
+    private readonly _injector;
+    handle({ nodesAndGroups }: CreateDragNodeHierarchyRequest): DragNodeHierarchy;
+    private _createHandlerByNodeId;
+    private _linkParentsAndCollectRoots;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDragNodeHierarchy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDragNodeHierarchy>;
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-hierarchy/drag-node-hierarchy.d.ts

@@ -0,0 +1,6 @@
+import { DragNodeItemHandler } from '../../drag-node-handler';
+export declare class DragNodeHierarchy {
+    readonly rootHandlers: DragNodeItemHandler[];
+    readonly participants: DragNodeItemHandler[];
+    constructor(rootHandlers: DragNodeItemHandler[], participants: DragNodeItemHandler[]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/create-drag-node-hierarchy/index.d.ts

@@ -0,0 +1,3 @@
+export * from './create-drag-node-hierarchy';
+export * from './create-drag-node-hierarchy-request';
+export * from './drag-node-hierarchy';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/index.d.ts

@@ -0,0 +1,9 @@
+export * from './create-drag-node-hierarchy';
+export * from './build-drag-node-constraints';
+export * from './create-drag-node-handler';
+export * from './read-node-bounds-with-paddings';
+export * from './attach-target-connection-drag-handlers-to-node';
+export * from './attach-source-connection-drag-handlers-to-node';
+export * from './providers';
+export * from './attach-drag-node-handler-from-selection';
+export * from './attach-drag-node-handler-from-selection-request';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/providers.d.ts

@@ -0,0 +1,8 @@
+import { AttachDragNodeHandlerFromSelection } from './attach-drag-node-handler-from-selection';
+import { AttachTargetConnectionDragHandlersToNode } from './attach-target-connection-drag-handlers-to-node';
+import { AttachSourceConnectionDragHandlersToNode } from './attach-source-connection-drag-handlers-to-node';
+import { CreateDragNodeHierarchy } from './create-drag-node-hierarchy';
+import { BuildDragNodeConstraints } from './build-drag-node-constraints';
+import { CreateDragNodeHandler } from './create-drag-node-handler';
+import { ReadNodeBoundsWithPaddings } from './read-node-bounds-with-paddings';
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CreateDragNodeHierarchy | typeof ReadNodeBoundsWithPaddings | typeof BuildDragNodeConstraints | typeof CreateDragNodeHandler | typeof AttachTargetConnectionDragHandlersToNode | typeof AttachSourceConnectionDragHandlersToNode | typeof AttachDragNodeHandlerFromSelection)[];

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/read-node-bounds-with-paddings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './read-node-bounds-with-paddings';
+export * from './read-node-bounds-with-paddings-request';
+export * from './read-node-bounds-with-paddings-response';

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/read-node-bounds-with-paddings/read-node-bounds-with-paddings-request.d.ts

@@ -0,0 +1,7 @@
+import { FNodeBase } from '../../../../f-node';
+export declare class ReadNodeBoundsWithPaddingsRequest {
+    readonly nodeOrGroup: FNodeBase;
+    readonly childrenPaddings: [number, number, number, number];
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup: FNodeBase, childrenPaddings: [number, number, number, number]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/read-node-bounds-with-paddings/read-node-bounds-with-paddings-response.d.ts

@@ -0,0 +1,9 @@
+import { FNodeBase } from '../../../../f-node';
+import { IRect } from '@foblex/2d';
+export declare class ReadNodeBoundsWithPaddingsResponse {
+    readonly nodeOrGroup: FNodeBase;
+    readonly boundingRect: IRect;
+    readonly innerRect: IRect;
+    readonly paddings: [number, number, number, number];
+    constructor(nodeOrGroup: FNodeBase, boundingRect: IRect, innerRect: IRect, paddings: [number, number, number, number]);
+}

package/f-draggable/drag-node/attach-drag-node-handler-from-selection/read-node-bounds-with-paddings/read-node-bounds-with-paddings.d.ts

@@ -0,0 +1,12 @@
+import { ReadNodeBoundsWithPaddingsRequest } from './read-node-bounds-with-paddings-request';
+import { IExecution } from '@foblex/mediator';
+import { ReadNodeBoundsWithPaddingsResponse } from './read-node-bounds-with-paddings-response';
+import * as i0 from "@angular/core";
+export declare class ReadNodeBoundsWithPaddings implements IExecution<ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse> {
+    private readonly _mediator;
+    handle({ nodeOrGroup, childrenPaddings, }: ReadNodeBoundsWithPaddingsRequest): ReadNodeBoundsWithPaddingsResponse;
+    private _readBoundingRect;
+    private _readOwnPaddings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadNodeBoundsWithPaddings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReadNodeBoundsWithPaddings>;
+}

package/f-draggable/drag-node/drag-node-constraint/delta-clamp.d.ts

@@ -0,0 +1,20 @@
+import { IMinMaxPoint, IPoint } from '@foblex/2d';
+export interface IConstraintEdges {
+    left: boolean;
+    right: boolean;
+    top: boolean;
+    bottom: boolean;
+}
+export interface IDeltaClampResult {
+    value: IPoint;
+    overflow: IPoint;
+    edges: IConstraintEdges;
+}
+export declare class DeltaClamp {
+    private readonly _limits;
+    private readonly _quantizeStep;
+    constructor(_limits: IMinMaxPoint, _quantizeStep?: number);
+    applyInto(offset: IPoint, out: IDeltaClampResult): void;
+    private _quantizeSigned;
+    private _clamp;
+}

package/f-draggable/drag-node/drag-node-constraint/drag-node-delta-constraints.d.ts

@@ -0,0 +1,14 @@
+import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
+import { IDragNodeDeltaConstraintsResult } from './i-drag-node-delta-constraints-result';
+import { IDragNodeDeltaConstraints } from './i-drag-node-delta-constraints';
+export declare class DragNodeDeltaConstraints {
+    private readonly _snapper;
+    private readonly _hardClamp;
+    private readonly _hardResult;
+    private readonly _softClamps;
+    private readonly _softResults;
+    constructor(injector: Injector, pointerDown: IPoint, limits: IDragNodeDeltaConstraints);
+    apply(delta: IPoint, forceSnap?: boolean): IDragNodeDeltaConstraintsResult;
+    finalize(delta: IPoint): IDragNodeDeltaConstraintsResult;
+}

package/f-draggable/drag-node/drag-node-constraint/expand-rect-by-overflow.d.ts

@@ -0,0 +1,3 @@
+import { IPoint, IRect } from '@foblex/2d';
+import { IConstraintEdges } from './delta-clamp';
+export declare function expandRectByOverflow(baselineRect: IRect, overflowDelta: IPoint, edges: IConstraintEdges): IRect;

package/f-draggable/drag-node/drag-node-constraint/grid-snapper.d.ts

@@ -0,0 +1,18 @@
+import { Signal } from '@angular/core';
+import { IPoint } from '@foblex/2d';
+export declare class GridSnapper {
+    private readonly _pointerDown;
+    private readonly _vCellSize;
+    private readonly _hCellSize;
+    private readonly _snapWhileDragging;
+    constructor(data: {
+        vCellSize: Signal<number>;
+        hCellSize: Signal<number>;
+        fCellSizeWhileDragging: Signal<boolean>;
+    }, _pointerDown: IPoint);
+    snap(difference: IPoint, adjustCellSize: boolean): IPoint;
+    private _strategies;
+    private _snapWithCellSize;
+    private _noSnap;
+    private _snapToGrid;
+}

package/f-draggable/drag-node/drag-node-constraint/i-drag-node-delta-constraints-result.d.ts

@@ -0,0 +1,8 @@
+import { IPoint } from '@foblex/2d';
+import { IDeltaClampResult } from './delta-clamp';
+export interface IDragNodeDeltaConstraintsResult {
+    /** Delta after snap + hard clamp */
+    hardDelta: IPoint;
+    /** Per-soft-constraint overflow based on hardDelta */
+    soft: IDeltaClampResult[];
+}

package/f-draggable/drag-node/drag-node-constraint/i-drag-node-delta-constraints.d.ts

@@ -0,0 +1,12 @@
+import { IMinMaxPoint, IRect, ISize } from '@foblex/2d';
+import { FNodeBase } from '../../../f-node';
+export interface IDragNodeSoftConstraint {
+    nodeOrGroup: FNodeBase;
+    boundingRect: IRect;
+    initialSize: ISize | undefined;
+    limits: IMinMaxPoint;
+}
+export interface IDragNodeDeltaConstraints {
+    hard: IMinMaxPoint;
+    soft: IDragNodeSoftConstraint[];
+}

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

@@ -0,0 +1,6 @@
+export * from './delta-clamp';
+export * from './drag-node-delta-constraints';
+export * from './expand-rect-by-overflow';
+export * from './grid-snapper';
+export * from './i-drag-node-delta-constraints-result';
+export * from './i-drag-node-delta-constraints';

package/f-draggable/drag-node/drag-node-dependent-connection-handlers/drag-node-connection-both-sides-handler.d.ts

@@ -0,0 +1,12 @@
+import { DragNodeConnectionHandlerBase } from './drag-node-connection-handler-base';
+import { IPoint } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export declare class DragNodeConnectionBothSidesHandler extends DragNodeConnectionHandlerBase {
+    private _sourceUpdated;
+    private _targetUpdated;
+    setSourceDelta(delta: IPoint): void;
+    setTargetDelta(delta: IPoint): void;
+    private _redrawIfReady;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionBothSidesHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionBothSidesHandler>;
+}

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

@@ -0,0 +1,20 @@
+import { IPoint } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection-v2';
+export declare class DragNodeConnectionHandlerBase {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _behaviour;
+    private _source;
+    private _target;
+    private _sourceRef;
+    private _targetRef;
+    private _sourceDelta;
+    private _targetDelta;
+    connection: FConnectionBase;
+    initialize(connection: FConnectionBase): void;
+    setSourceDelta(delta: IPoint): void;
+    setTargetDelta(delta: IPoint): void;
+    protected redraw(): void;
+    private _buildLine;
+    private _readRectRef;
+}

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

@@ -0,0 +1,8 @@
+import { DragNodeConnectionHandlerBase } from './drag-node-connection-handler-base';
+import { IPoint } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export declare class DragNodeConnectionSourceHandler extends DragNodeConnectionHandlerBase {
+    setSourceDelta(delta: IPoint): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionSourceHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionSourceHandler>;
+}

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

@@ -0,0 +1,8 @@
+import { DragNodeConnectionHandlerBase } from './drag-node-connection-handler-base';
+import { IPoint } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export declare class DragNodeConnectionTargetHandler extends DragNodeConnectionHandlerBase {
+    setTargetDelta(delta: IPoint): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionTargetHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionTargetHandler>;
+}

package/f-draggable/drag-node/drag-node-dependent-connection-handlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './drag-node-connection-handler-base';
+export * from './drag-node-connection-source-handler';
+export * from './drag-node-connection-both-sides-handler';
+export * from './drag-node-connection-target-handler';

package/f-draggable/drag-node/drag-node-finalize/drag-node-finalize-request.d.ts

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

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

@@ -0,0 +1,21 @@
+import { DragNodeFinalizeRequest } from './drag-node-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragNodeFinalize implements IExecution<DragNodeFinalizeRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    private _dragHandler?;
+    handle({ event }: DragNodeFinalizeRequest): void;
+    private _getDragHandler;
+    private _buildDragDelta;
+    private _applySnapToDelta;
+    private _hasLineSnapValue;
+    private _hasRectSnapValue;
+    private _finalizeMove;
+    private _buildMoveNodesEvent;
+    private _emitNodeIntersectIfNeeded;
+    private _isDraggedJustOneNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeFinalize>;
+}

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

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