@foblex/flow 18.0.0 → 18.1.1

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';

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

@@ -0,0 +1,39 @@
+import { IPoint } from '@foblex/2d';
+import { DragNodeItemHandler } from './drag-node-item-handler';
+import { DragHandlerBase } from '../../infrastructure';
+import { FDragNodeStartEventData } from '../f-drag-node-start-event-data';
+import { IMagneticGuidesResult, MagneticLinesHandler } from '../magnetic-lines';
+import { IMagneticRectsResult, MagneticRectsHandler } from '../magnetic-rects';
+import * as i0 from "@angular/core";
+export declare class DragNodeHandler extends DragHandlerBase<FDragNodeStartEventData> {
+    protected readonly type = "move-node";
+    protected readonly kind = "drag-node";
+    protected data(): FDragNodeStartEventData;
+    private _magneticLines;
+    private _magneticRects;
+    /** Every dragged item (nodes + groups including deep children) */
+    items: DragNodeItemHandler[];
+    /** Roots of drag hierarchy (top-level items without selected parents) */
+    roots: DragNodeItemHandler[];
+    initialize(
+    /** Every dragged item (nodes + groups including deep children) */
+    items: DragNodeItemHandler[], 
+    /** Roots of drag hierarchy (top-level items without selected parents) */
+    roots: DragNodeItemHandler[]): void;
+    setMagneticLines(handler: MagneticLinesHandler): void;
+    setMagneticRects(handler: MagneticRectsHandler): void;
+    calculateMagneticLinesGuides(delta: IPoint): IMagneticGuidesResult | undefined;
+    calculateMagneticSnaps(delta: IPoint): {
+        lines?: IMagneticGuidesResult;
+        rects?: IMagneticRectsResult;
+    };
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _previewRoots;
+    private _rootsUnionRect;
+    private _refreshDraggedNodes;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeHandler>;
+}

package/f-draggable/drag-node/drag-node-handler/drag-node-item-handler.d.ts

@@ -0,0 +1,36 @@
+import { IPoint, IRect } from '@foblex/2d';
+import { Injector } from '@angular/core';
+import { DragHandlerBase } from '../../infrastructure';
+import { IDragNodeDeltaConstraints } from '../drag-node-constraint';
+import { FNodeBase } from '../../../f-node';
+import { DragNodeConnectionHandlerBase } from '../drag-node-dependent-connection-handlers';
+export declare class DragNodeItemHandler extends DragHandlerBase<unknown> {
+    private readonly _injector;
+    readonly nodeOrGroup: FNodeBase;
+    children: DragNodeItemHandler[];
+    sourceConnectionHandlers: DragNodeConnectionHandlerBase[];
+    targetConnectionHandlers: DragNodeConnectionHandlerBase[];
+    protected readonly type = "move-node";
+    protected readonly kind = "drag-node";
+    private readonly _startPosition;
+    private readonly _startRect;
+    private _applyConstraints;
+    private _lastSoftResults;
+    private _deltaConstraints;
+    private _constraints;
+    private _lastPosition;
+    private readonly _mediator;
+    constructor(_injector: Injector, nodeOrGroup: FNodeBase, children?: DragNodeItemHandler[], sourceConnectionHandlers?: DragNodeConnectionHandlerBase[], targetConnectionHandlers?: DragNodeConnectionHandlerBase[]);
+    setConstraints(constraints: IDragNodeDeltaConstraints): void;
+    finalizeConstraints(): void;
+    getLastRect(): IRect;
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _startPlus;
+    private _redraw;
+    private _applySoftExpansions;
+    private _commitParentRect;
+    private _emitExpandedEvent;
+    destroy(): void;
+}

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { DragNodePreparationRequest } from './drag-node-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragNodePreparation implements IExecution<DragNodePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    handle({ event, trigger }: DragNodePreparationRequest): void;
+    private _canStartDrag;
+    private _isDragHandle;
+    private _findDraggableNode;
+    private _storePointerDownContext;
+    private _buildDragNodeHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodePreparation>;
+}

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

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

package/f-draggable/drag-node/f-drag-node-start-event-data.d.ts

@@ -0,0 +1,4 @@
+export declare class FDragNodeStartEventData {
+    readonly fNodeIds: string[];
+    constructor(fNodeIds: string[]);
+}

package/f-draggable/drag-node/f-move-nodes-event.d.ts

@@ -0,0 +1,16 @@
+import { IPoint } from '@foblex/2d';
+export type FMoveNodePosition = {
+    id: string;
+    position: IPoint;
+};
+/**
+ * Event that is emitted when nodes and groups are moved.
+ * It contains the moved nodes and groups and their new positions.
+ */
+export declare class FMoveNodesEvent {
+    /** Preferred name */
+    readonly nodes: FMoveNodePosition[];
+    /** @deprecated Use `nodes` */
+    readonly fNodes: FMoveNodePosition[];
+    constructor(nodes: FMoveNodePosition[]);
+}

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

@@ -0,0 +1,11 @@
+export * from './attach-drag-node-handler-from-selection';
+export * from './magnetic-lines';
+export * from './magnetic-rects';
+export * from './drag-node-constraint';
+export * from './drag-node-dependent-connection-handlers';
+export * from './drag-node-finalize';
+export * from './drag-node-handler';
+export * from './drag-node-preparation';
+export * from './f-move-nodes-event';
+export * from './f-drag-node-start-event-data';
+export * from './providers';

package/f-draggable/drag-node/magnetic-lines/domain/calculate-magnetic-guides.d.ts

@@ -0,0 +1,3 @@
+import { IRect } from '@foblex/2d';
+import { IMagneticGuidesResult } from './i-magnetic-guides-result';
+export declare function calculateMagneticGuides(elements: IRect[], target: IRect, alignThreshold?: number): IMagneticGuidesResult;

package/f-draggable/drag-node/magnetic-lines/domain/i-magnetic-axis-guide.d.ts

@@ -0,0 +1,6 @@
+export interface IMagneticAxisGuide {
+    /** Guide coordinate (x or y) that we align to */
+    guide?: number;
+    /** Signed delta to apply to the dragged rect to align with the guide */
+    delta?: number;
+}

package/f-draggable/drag-node/magnetic-lines/domain/i-magnetic-guides-result.d.ts

@@ -0,0 +1,5 @@
+import { IMagneticAxisGuide } from './i-magnetic-axis-guide';
+export interface IMagneticGuidesResult {
+    x: IMagneticAxisGuide;
+    y: IMagneticAxisGuide;
+}

package/f-draggable/drag-node/magnetic-lines/domain/index.d.ts

@@ -0,0 +1,5 @@
+export * from './calculate-magnetic-guides';
+export * from './i-magnetic-axis-guide';
+export * from './i-magnetic-guides-result';
+export * from './magnetic-line-element';
+export * from './magnetic-line-renderer';

package/f-draggable/drag-node/magnetic-lines/domain/magnetic-line-element.d.ts

@@ -0,0 +1,17 @@
+import { BrowserService } from '@foblex/platform';
+type MagneticLineRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare class MagneticLineElement {
+    private readonly _element;
+    constructor(browser: BrowserService, hostElement: HTMLElement, className?: string);
+    show(): void;
+    hide(): void;
+    render(rect: Partial<MagneticLineRect>): void;
+    clearRect(): void;
+    destroy(): void;
+}
+export {};

package/f-draggable/drag-node/magnetic-lines/domain/magnetic-line-renderer.d.ts

@@ -0,0 +1,13 @@
+import { ISize, ITransformModel } from '@foblex/2d';
+import { BrowserService } from '@foblex/platform';
+export declare class MagneticLineRenderer {
+    private readonly _horizontal;
+    private readonly _vertical;
+    constructor(browser: BrowserService, hostElement: HTMLElement);
+    drawVerticalLine(x: number, size: ISize, transform: ITransformModel): void;
+    drawHorizontalLine(y: number, size: ISize, transform: ITransformModel): void;
+    hideVertical(): void;
+    hideHorizontal(): void;
+    hideAll(): void;
+    destroy(): void;
+}

package/f-draggable/drag-node/magnetic-lines/index.d.ts

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './magnetic-lines-preparation';
+export * from './magnetic-lines-handler';

package/f-draggable/drag-node/magnetic-lines/magnetic-lines-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './magnetic-lines-handler';

package/f-draggable/drag-node/magnetic-lines/magnetic-lines-handler/magnetic-lines-handler.d.ts

@@ -0,0 +1,18 @@
+import { IRect, ISize } from '@foblex/2d';
+import { Injector } from '@angular/core';
+import { IMagneticGuidesResult, MagneticLineRenderer } from '../domain';
+export declare class MagneticLinesHandler {
+    private _renderer;
+    private _size;
+    private _rects;
+    private _timerId;
+    private readonly _canvasTransform;
+    private readonly _alignThreshold;
+    constructor(injector: Injector, _renderer: MagneticLineRenderer, _size: ISize, _rects: IRect[]);
+    scheduleRender(_draggedRect: IRect): void;
+    private _renderGuides;
+    private _renderVertical;
+    private _renderHorizontal;
+    _computeGuides(_draggedRect: IRect): IMagneticGuidesResult;
+    clearGuides(): void;
+}

package/f-draggable/drag-node/magnetic-lines/magnetic-lines-preparation/index.d.ts

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

package/f-draggable/drag-node/magnetic-lines/magnetic-lines-preparation/magnetic-lines-preparation-request.d.ts

@@ -0,0 +1,3 @@
+export declare class MagneticLinesPreparationRequest {
+    static readonly fToken: unique symbol;
+}

package/f-draggable/drag-node/magnetic-lines/magnetic-lines-preparation/magnetic-lines-preparation.d.ts

@@ -0,0 +1,18 @@
+import { MagneticLinesPreparationRequest } from './magnetic-lines-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class MagneticLinesPreparation implements IExecution<MagneticLinesPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _browser;
+    private readonly _injector;
+    private readonly _dragSession;
+    private _renderer;
+    handle(_: MagneticLinesPreparationRequest): void;
+    private _draggedNodes;
+    private _flowHostSize;
+    private _createRenderer;
+    private _notDraggedRects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagneticLinesPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MagneticLinesPreparation>;
+}

package/f-draggable/drag-node/magnetic-rects/domain/calculate-magnetic-rects.d.ts

@@ -0,0 +1,3 @@
+import { IRect } from '@foblex/2d';
+import { IMagneticRectsResult } from './i-magnetic-rects-result';
+export declare function calculateMagneticRects(elements: IRect[], target: IRect, alignThreshold?: number, spacingThreshold?: number): IMagneticRectsResult;

package/f-draggable/drag-node/magnetic-rects/domain/i-magnetic-gap-rect.d.ts

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

package/f-draggable/drag-node/magnetic-rects/domain/i-magnetic-rects-result.d.ts

@@ -0,0 +1,11 @@
+import { IMagneticGapRect } from './i-magnetic-gap-rect';
+export type MagneticRectsAxis = 'x' | 'y';
+export type MagneticRectsAlignMode = 'top' | 'center' | 'bottom' | 'left' | 'right';
+export interface IMagneticRectsResult {
+    axis?: MagneticRectsAxis;
+    delta?: number;
+    gap?: number;
+    rects: IMagneticGapRect[];
+    alignMode?: MagneticRectsAlignMode;
+    crossDelta?: number;
+}

package/f-draggable/drag-node/magnetic-rects/domain/index.d.ts

@@ -0,0 +1,5 @@
+export * from './calculate-magnetic-rects';
+export * from './i-magnetic-gap-rect';
+export * from './i-magnetic-rects-result';
+export * from './magnetic-rect-element';
+export * from './magnetic-rects-renderer';

package/f-draggable/drag-node/magnetic-rects/domain/magnetic-rect-element.d.ts

@@ -0,0 +1,15 @@
+import { BrowserService } from '@foblex/platform';
+export declare class MagneticRectElement {
+    private readonly _element;
+    private _isVisible;
+    private _left;
+    private _top;
+    private _width;
+    private _height;
+    constructor(browser: BrowserService, hostElement: HTMLElement, className?: string);
+    show(): void;
+    hide(): void;
+    render(left: number, top: number, width: number, height: number): void;
+    clearRect(): void;
+    destroy(): void;
+}

package/f-draggable/drag-node/magnetic-rects/domain/magnetic-rects-renderer.d.ts

@@ -0,0 +1,15 @@
+import { ITransformModel } from '@foblex/2d';
+import { BrowserService } from '@foblex/platform';
+import { IMagneticGapRect } from './i-magnetic-gap-rect';
+export declare class MagneticRectsRenderer {
+    private readonly _browser;
+    private readonly _hostElement;
+    private readonly _className;
+    private readonly _pool;
+    private _activeCount;
+    constructor(_browser: BrowserService, _hostElement: HTMLElement, _className?: string);
+    draw(rects: IMagneticGapRect[], transform: ITransformModel): void;
+    hideAll(): void;
+    destroy(): void;
+    private _getOrCreate;
+}

package/f-draggable/drag-node/magnetic-rects/index.d.ts

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './magnetic-rects-preparation';
+export * from './magnetic-rects-handler';

package/f-draggable/drag-node/magnetic-rects/magnetic-rects-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './magnetic-rects-handler';

package/f-draggable/drag-node/magnetic-rects/magnetic-rects-handler/magnetic-rects-handler.d.ts

@@ -0,0 +1,16 @@
+import { IRect } from '@foblex/2d';
+import { Injector } from '@angular/core';
+import { IMagneticRectsResult, MagneticRectsRenderer } from '../domain';
+export declare class MagneticRectsHandler {
+    private readonly _renderer;
+    private readonly _rects;
+    private _timerId;
+    private readonly _canvasTransform;
+    private readonly _alignThreshold;
+    private readonly _spacingThreshold;
+    constructor(injector: Injector, _renderer: MagneticRectsRenderer, _rects: IRect[]);
+    scheduleRender(_draggedRect: IRect): void;
+    private _renderRects;
+    _computeRects(_draggedRect: IRect): IMagneticRectsResult;
+    clearGuides(): void;
+}

package/f-draggable/drag-node/magnetic-rects/magnetic-rects-preparation/index.d.ts

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

package/f-draggable/drag-node/magnetic-rects/magnetic-rects-preparation/magnetic-rects-preparation-request.d.ts

@@ -0,0 +1,3 @@
+export declare class MagneticRectsPreparationRequest {
+    static readonly fToken: unique symbol;
+}

package/f-draggable/drag-node/magnetic-rects/magnetic-rects-preparation/magnetic-rects-preparation.d.ts

@@ -0,0 +1,17 @@
+import { MagneticRectsPreparationRequest } from './magnetic-rects-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class MagneticRectsPreparation implements IExecution<MagneticRectsPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _browser;
+    private readonly _injector;
+    private readonly _dragSession;
+    private _renderer;
+    handle(_: MagneticRectsPreparationRequest): void;
+    private _draggedNodes;
+    private _getRenderer;
+    private _notDraggedRects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagneticRectsPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MagneticRectsPreparation>;
+}

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

@@ -0,0 +1,5 @@
+import { DragNodeFinalize } from './drag-node-finalize';
+import { DragNodePreparation } from './drag-node-preparation';
+import { MagneticLinesPreparation } from './magnetic-lines';
+import { MagneticRectsPreparation } from './magnetic-rects';
+export declare const NODE_PROVIDERS: (typeof MagneticLinesPreparation | typeof MagneticRectsPreparation | typeof import("./attach-drag-node-handler-from-selection").CreateDragNodeHierarchy | typeof import("./attach-drag-node-handler-from-selection").ReadNodeBoundsWithPaddings | typeof import("./attach-drag-node-handler-from-selection").BuildDragNodeConstraints | typeof import("./attach-drag-node-handler-from-selection").CreateDragNodeHandler | typeof import("./attach-drag-node-handler-from-selection").AttachTargetConnectionDragHandlersToNode | typeof import("./attach-drag-node-handler-from-selection").AttachSourceConnectionDragHandlersToNode | typeof import("./attach-drag-node-handler-from-selection").AttachDragNodeHandlerFromSelection | typeof DragNodeFinalize | typeof DragNodePreparation)[];

package/f-draggable/drop-to-group/drop-to-group-finalize/drop-to-group-finalize-request.d.ts

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

package/f-draggable/drop-to-group/drop-to-group-finalize/drop-to-group-finalize.d.ts

@@ -0,0 +1,18 @@
+import { DropToGroupFinalizeRequest } from './drop-to-group-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DropToGroupFinalize implements IExecution<DropToGroupFinalizeRequest, void> {
+    private readonly _dragSession;
+    private readonly _store;
+    handle({ event }: DropToGroupFinalizeRequest): void;
+    private _findDropHandler;
+    private _emitDropToGroupEvent;
+    /**
+     * Returns only "top-level" dragged items:
+     * if a node's parent is also in dragged set, we exclude the child.
+     */
+    private _getTopLevelDraggedIds;
+    private _getMoveSummaryHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupFinalize>;
+}

package/f-draggable/drop-to-group/drop-to-group-handler/drop-to-group-handler.d.ts

@@ -0,0 +1,30 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { INodeWithRect } from '../../domain';
+import * as i0 from "@angular/core";
+export declare class DropToGroupHandler extends DragHandlerBase<unknown> {
+    /** Legacy identifier (external compatibility). */
+    protected readonly type = "move-node-to-parent";
+    /** New identifier. */
+    protected readonly kind = "drop-to-group";
+    private readonly _store;
+    private readonly _dragSession;
+    private get _transform();
+    private _candidateGroups;
+    private _pointerDownInFlow;
+    private _debounceTimer;
+    private _activeTarget;
+    /** Read-only access for finalize stage. */
+    get activeTarget(): INodeWithRect | null;
+    initialize(candidateGroups: INodeWithRect[]): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+    private _updateActiveTarget;
+    private _getPointerInCanvas;
+    private _findTargetUnderPointer;
+    private _setActiveTarget;
+    private _clearActiveTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupHandler>;
+}

package/f-draggable/drop-to-group/drop-to-group-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './drop-to-group-handler';

package/f-draggable/drop-to-group/drop-to-group-preparation/drop-to-group-preparation.d.ts

@@ -0,0 +1,23 @@
+import { DropToGroupPreparationRequest } from './drop-to-group-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DropToGroupPreparation implements IExecution<DropToGroupPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _dragContext;
+    private readonly _store;
+    private readonly _dragInjector;
+    private get _allNodes();
+    private get _transform();
+    private get _canvasOffset();
+    handle({ event }: DropToGroupPreparationRequest): void;
+    private _canPrepare;
+    private _hasMoveDrag;
+    private _hasExternalDrag;
+    private _sortedTargetsForDrop;
+    private _getDraggedNodes;
+    private _withParents;
+    private _eligibleTargets;
+    private _toCanvasRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupPreparation>;
+}

package/f-draggable/drop-to-group/f-drop-to-group-event.d.ts

@@ -0,0 +1,16 @@
+import { IPoint } from '@foblex/2d';
+export declare class FDropToGroupEvent {
+    /** Preferred name: Group (target) id */
+    readonly targetGroupId: string;
+    /** Preferred name: Dropped node ids */
+    readonly nodeIds: string[];
+    /** Preferred name: Pointer drop position */
+    readonly dropPosition: IPoint;
+    /** @deprecated Use `targetGroupId` */
+    readonly fTargetNode: string;
+    /** @deprecated Use `nodeIds` */
+    readonly fNodes: string[];
+    /** @deprecated Use `dropPosition` */
+    readonly fDropPosition: IPoint;
+    constructor(targetGroupId: string, nodeIds: string[], dropPosition: IPoint);
+}

package/f-draggable/drop-to-group/index.d.ts

@@ -0,0 +1,6 @@
+export * from './drop-to-group-finalize';
+export * from './drop-to-group-preparation';
+export * from './drop-to-group-handler';
+export * from './sort-drop-candidates-by-layer';
+export * from './f-drop-to-group-event';
+export * from './providers';

package/f-draggable/drop-to-group/providers.d.ts

@@ -0,0 +1,4 @@
+import { DropToGroupPreparation } from './drop-to-group-preparation';
+import { DropToGroupFinalize } from './drop-to-group-finalize';
+import { SortDropCandidatesByLayer } from './sort-drop-candidates-by-layer';
+export declare const DRAG_DROP_TO_GROUP_PROVIDERS: (typeof DropToGroupFinalize | typeof SortDropCandidatesByLayer | typeof DropToGroupPreparation)[];