@foblex/flow 17.7.0 → 17.8.0

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

@@ -1,8 +1,6 @@
 import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
-import { FConnectionDragHandleEndComponent, FConnectionDragHandleStartComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FConnectionCenterDirective } from '../f-connection-center';
 import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
@@ -10,8 +8,6 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fId: import("@angular/core").WritableSignal<string>;
     fText: string;
     fTextStartOffset: string;
-    fStartColor: import("@angular/core").InputSignal<string>;
-    fEndColor: import("@angular/core").InputSignal<string>;
     fSnapThreshold: number;
     fOutputId: string;
     fInputId: string;
@@ -19,26 +15,15 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fOffset: number;
     fBehavior: EFConnectionBehavior;
     fType: EFConnectionType | string;
-    fDraggingDisabled: boolean;
-    fSelectionDisabled: boolean;
-    fDefs: import("@angular/core").Signal<ElementRef<SVGDefsElement>>;
-    fPath: import("@angular/core").Signal<IConnectionPath>;
-    fGradient: import("@angular/core").Signal<IConnectionGradient>;
-    fDragHandleStart: import("@angular/core").Signal<FConnectionDragHandleStartComponent | undefined>;
-    fDragHandleEnd: import("@angular/core").Signal<FConnectionDragHandleEndComponent>;
-    fSelection: import("@angular/core").Signal<FConnectionSelectionComponent>;
-    fTextComponent: import("@angular/core").Signal<IConnectionText>;
-    fConnectionCenter: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
-    fConnectionCenters: import("@angular/core").Signal<readonly FConnectionCenterDirective[]>;
     get boundingElement(): HTMLElement | SVGElement;
-    private readonly _fMediator;
+    private readonly _mediator;
     constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fStartColor": { "alias": "fStartColor"; "required": false; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": false; "isSignal": true; }; "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, never, ["*", "[fConnectionCenter]"], false, never>;
     static ngAcceptInputType_fSnapThreshold: unknown;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;

package/f-draggable/domain/get-normalized-parent-node-rect/get-normalized-parent-node-rect.execution.d.ts

@@ -3,9 +3,9 @@ import { IRect } from '@foblex/2d';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class GetNormalizedParentNodeRectExecution implements IExecution<GetNormalizedParentNodeRectRequest, IRect> {
-    private readonly _fComponentsStore;
-    private readonly _fMediator;
-    handle(request: GetNormalizedParentNodeRectRequest): IRect;
+    private readonly _store;
+    private readonly _mediator;
+    handle({ nodeOrGroup }: GetNormalizedParentNodeRectRequest): IRect;
     private _getNode;
     private _getParentRect;
     private _getNodeRect;

package/f-draggable/domain/get-normalized-parent-node-rect/get-normalized-parent-node-rect.request.d.ts

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

package/f-draggable/domain/is-connection-under-node/is-connection-under-node.execution.d.ts

@@ -3,7 +3,7 @@ import { IsConnectionUnderNodeRequest } from './is-connection-under-node.request
 import * as i0 from "@angular/core";
 export declare class IsConnectionUnderNodeExecution implements IExecution<IsConnectionUnderNodeRequest, void> {
     private readonly _fMediator;
-    private readonly _fComponentsStore;
+    private readonly _store;
     handle(request: IsConnectionUnderNodeRequest): void;
     private _getOutputConnectors;
     private _getInputConnectors;

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

@@ -3,7 +3,7 @@ import { IFDragHandler } from '../f-drag-handler';
 import { Injector } from '@angular/core';
 export declare class FCanvasDragHandler implements IFDragHandler {
     fEventType: string;
-    private readonly _fComponentsStore;
+    private readonly _store;
     private _onPointerDownPosition;
     constructor(_injector: Injector);
     prepareDragSequence(): void;

package/f-draggable/f-canvas/move-finalize/f-canvas-move-finalize.execution.d.ts

@@ -2,7 +2,7 @@ import { FCanvasMoveFinalizeRequest } from './f-canvas-move-finalize.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FCanvasMoveFinalizeExecution implements IExecution<FCanvasMoveFinalizeRequest, void> {
-    private _fDraggableDataContext;
+    private _dragContext;
     handle(request: FCanvasMoveFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasMoveFinalizeExecution, never>;

package/f-draggable/f-canvas/move-preparation/f-canvas-move-preparation.execution.d.ts

@@ -2,8 +2,8 @@ import { FCanvasMovePreparationRequest } from './f-canvas-move-preparation.reque
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FCanvasMovePreparationExecution implements IExecution<FCanvasMovePreparationRequest, void> {
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     private readonly _injector;
     private get _fHost();
     handle(request: FCanvasMovePreparationRequest): void;

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

@@ -4,8 +4,8 @@ import * as i0 from "@angular/core";
 export declare class FCreateConnectionFinalizeExecution implements IHandler<FCreateConnectionFinalizeRequest, void> {
     private _fResult;
     private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private _store;
+    private _dragContext;
     private get _fDragHandler();
     handle(request: FCreateConnectionFinalizeRequest): void;
     private _isValid;

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

@@ -2,8 +2,8 @@ import { IHandler } from '@foblex/mediator';
 import { FCreateConnectionDragHandlerPreparationRequest } from './f-create-connection-drag-handler-preparation.request';
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionDragHandlerPreparationExecution implements IHandler<FCreateConnectionDragHandlerPreparationRequest, void> {
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     private readonly _injector;
     private get _fHost();
     private get _transform();

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

@@ -3,8 +3,8 @@ import { FCreateConnectionPreparationRequest } from './f-create-connection-prepa
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionPreparationExecution implements IHandler<FCreateConnectionPreparationRequest, void> {
     private _fMediator;
-    private _fComponentsStore;
-    private _fDraggableDataContext;
+    private _store;
+    private _dragContext;
     private _fNode;
     handle(request: FCreateConnectionPreparationRequest): void;
     private _isValid;

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

@@ -3,7 +3,7 @@ import { FCreateConnectionFromOutletPreparationRequest } from './f-create-connec
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionFromOutletPreparationExecution implements IHandler<FCreateConnectionFromOutletPreparationRequest, void> {
     private _fMediator;
-    private _fComponentsStore;
+    private _store;
     handle(request: FCreateConnectionFromOutletPreparationRequest): void;
     private _getNodeOutlet;
     private _getNodeOutputs;

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

@@ -3,7 +3,7 @@ import { FCreateConnectionFromOutputPreparationRequest } from './f-create-connec
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionFromOutputPreparationExecution implements IHandler<FCreateConnectionFromOutputPreparationRequest, void> {
     private _fMediator;
-    private _fComponentsStore;
+    private _store;
     handle(request: FCreateConnectionFromOutputPreparationRequest): void;
     private _isValid;
     private _isNodeOutput;

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

@@ -8,7 +8,7 @@ export declare class FCreateConnectionDragHandler implements IFDragHandler {
     fData: any;
     private readonly _fResult;
     private readonly _fMediator;
-    private readonly _fComponentsStore;
+    private readonly _store;
     private readonly _toConnectorRect;
     private get _fConnection();
     private get _fSnapConnection();

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

@@ -3,8 +3,8 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FReassignConnectionPreparationExecution implements IExecution<FReassignConnectionPreparationRequest, void> {
     private readonly _fMediator;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private readonly _store;
+    private readonly _dragContext;
     private readonly _injector;
     private _fConnection;
     private get _transform();

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

@@ -1,12 +1,11 @@
-import { EventEmitter } from '@angular/core';
+import { EventEmitter, InputSignalWithTransform } from '@angular/core';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FCreateNodeEvent } from '../f-external-item';
 import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import { FDropToGroupEvent } from './f-drop-to-group';
-import { DragAndDropBase, ICanRunOutsideAngular } from "../drag-toolkit";
-import { FMoveNodesEvent } from "./f-node-move";
-import * as i0 from "@angular/core";
+import { DragAndDropBase, ICanRunOutsideAngular } from '../drag-toolkit';
+import { FMoveNodesEvent } from './f-node-move';
 export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     abstract fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
@@ -16,12 +15,10 @@ export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     abstract fDropToGroup: EventEmitter<FDropToGroupEvent>;
-    abstract vCellSize: number;
-    abstract hCellSize: number;
-    abstract fCellSizeWhileDragging: boolean;
+    abstract vCellSize: InputSignalWithTransform<number, unknown>;
+    abstract hCellSize: InputSignalWithTransform<number, unknown>;
+    abstract fCellSizeWhileDragging: InputSignalWithTransform<boolean, unknown>;
     abstract fDragStarted: EventEmitter<FDragStartedEvent>;
     abstract fDragEnded: EventEmitter<void>;
     protected constructor(ngZone: ICanRunOutsideAngular | undefined);
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-draggable/f-draggable-data-context.d.ts

@@ -3,6 +3,7 @@ import { IFDragHandler } from './f-drag-handler';
 import { ISelectable } from '../mixins';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
+    isDragging: boolean;
     selectedItems: ISelectable[];
     isSelectedChanged: boolean;
     onPointerDownScale: number;

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

@@ -1,21 +1,20 @@
-import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FDraggableBase } from './f-draggable-base';
 import { FMoveNodesEvent } from './f-node-move';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
-import { BrowserService } from '@foblex/platform';
 import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import { FDropToGroupEvent } from './f-drop-to-group';
-import { ICanRunOutsideAngular, IPointerEvent } from "../drag-toolkit";
+import { ICanRunOutsideAngular, IPointerEvent } from '../drag-toolkit';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
-    private _fBrowser;
-    private _elementReference;
-    private _fResult;
-    private _fMediator;
-    private _fPlatform;
+    private readonly _elementReference;
+    private readonly _fResult;
+    private readonly _mediator;
+    private readonly _platform;
+    private readonly _browser;
     disabled: boolean;
     get hostElement(): HTMLElement;
     fMultiSelectTrigger: FEventTrigger;
@@ -34,14 +33,29 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     fDropToGroup: EventEmitter<FDropToGroupEvent>;
-    vCellSize: number;
-    hCellSize: number;
-    fCellSizeWhileDragging: boolean;
+    /**
+     * Defines the vertical cell size for the grid.
+     * This value is used to snap nodes to a vertical grid while dragging.
+     * The default value is `1`, which means that nodes will snap to every pixel vertically.
+     */
+    vCellSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /**
+     * Defines the horizontal cell size for the grid.
+     * This value is used to snap nodes to a horizontal grid while dragging.
+     * The default value is `1`, which means that nodes will snap to every pixel horizontally.
+     */
+    hCellSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /**
+     * Defines whether the cell size should be applied while dragging.
+     * If set to `true`, the dragged nodes will snap to the grid defined by `vCellSize` and `hCellSize`.
+     * If set to `false`, the nodes will move freely without snapping to the grid.
+     */
+    fCellSizeWhileDragging: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     fDragStarted: EventEmitter<FDragStartedEvent>;
     fDragEnded: EventEmitter<void>;
     private _beforePlugins;
     private _afterPlugins;
-    constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
+    constructor(ngZone: ICanRunOutsideAngular);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     onPointerDown(event: IPointerEvent): boolean;
@@ -51,11 +65,8 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     onPointerUp(event: IPointerEvent): void;
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; "isSignal": true; }; "hCellSize": { "alias": "hCellSize"; "required": false; "isSignal": true; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; "isSignal": true; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
     static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_fEmitOnNodeIntersect: unknown;
-    static ngAcceptInputType_vCellSize: unknown;
-    static ngAcceptInputType_hCellSize: unknown;
-    static ngAcceptInputType_fCellSizeWhileDragging: unknown;
 }

package/f-draggable/{f-node-resize/resize-finalize/f-node-resize-finalize.request.d.ts → f-drop-to-group/drop-to-group-finalize/drop-to-group-finalize-request.d.ts}

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

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

@@ -0,0 +1,16 @@
+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 _dragContext;
+    private readonly _store;
+    handle(request: DropToGroupFinalizeRequest): void;
+    private _isValid;
+    private _emitDroppedChildrenEvent;
+    private _getDragHandleItem;
+    private _findDragHandleItem;
+    private _getDroppedIds;
+    private _getSummaryHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupFinalize>;
+}

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

@@ -1,2 +1,2 @@
-export * from './f-node-drop-to-group-finalize.execution';
-export * from './f-node-drop-to-group-finalize.request';
+export * from './drop-to-group-finalize';
+export * from './drop-to-group-finalize-request';

package/f-draggable/f-drop-to-group/{drop-to-group-finalize/f-node-drop-to-group-finalize.request.d.ts → drop-to-group-preparation/drop-to-group-preparation-request.d.ts}

@@ -1,5 +1,5 @@
 import { IPointerEvent } from "../../../drag-toolkit";
-export declare class FNodeDropToGroupFinalizeRequest {
+export declare class DropToGroupPreparationRequest {
     event: IPointerEvent;
     static readonly fToken: unique symbol;
     constructor(event: IPointerEvent);

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

@@ -0,0 +1,29 @@
+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 _injector;
+    private get _allNodesAndGroups();
+    private get _canvasTransform();
+    private get _canvasPosition();
+    handle({ event }: DropToGroupPreparationRequest): void;
+    private _canPrepareDropToGroup;
+    private _isNodeDragHandler;
+    private _isExternalItemDragHandler;
+    private _collectGroupingTargetRects;
+    private _draggedNodes;
+    /**
+     * Returns the list of dragged nodes extended with all of their parent nodes.
+     *
+     * This ensures that parent nodes are excluded from the potential drop targets,
+     * since they already act as containers for the dragged elements.
+     */
+    private _draggedNodesWithParents;
+    private _eligibleTargets;
+    private _toCanvasRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupPreparation>;
+}

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

@@ -1,2 +1,2 @@
-export * from './f-node-drop-to-group-preparation.execution';
-export * from './f-node-drop-to-group-preparation.request';
+export * from './drop-to-group-preparation';
+export * from './drop-to-group-preparation-request';

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

@@ -2,18 +2,16 @@ import { Injector } from '@angular/core';
 import { IPoint } from '@foblex/2d';
 import { IFDragHandler } from '../f-drag-handler';
 import { INodeWithRect } from '../domain';
-import * as i0 from "@angular/core";
 export declare class FNodeDropToGroupDragHandler implements IFDragHandler {
-    private notDraggedNodesRects;
-    private readonly _fComponentsStore;
-    private readonly _fDraggableDataContext;
+    private _containersForDrop;
+    private readonly _store;
     fEventType: string;
-    private _DEBOUNCE_TIME;
     private get _transform();
     private _onPointerDownPosition;
     private _debounceTimer;
     fNodeWithRect: INodeWithRect | null;
-    constructor(_injector: Injector, notDraggedNodesRects: INodeWithRect[]);
+    constructor(injector: Injector, _containersForDrop: INodeWithRect[]);
+    prepareDragSequence(): void;
     private _toggleParentNode;
     private _getNewPosition;
     private _isNodeInsideAnotherNode;
@@ -21,6 +19,4 @@ export declare class FNodeDropToGroupDragHandler implements IFDragHandler {
     private _markIncludeNode;
     private _unmarkIncludeNode;
     onPointerUp(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDropToGroupDragHandler, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDropToGroupDragHandler, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -1,5 +1,6 @@
 export * from './drop-to-group-finalize';
 export * from './drop-to-group-preparation';
 export * from './f-node-drop-to-group.drag-handler';
+export * from './sort-containers-for-drop-by-layer';
 export * from './f-drop-to-group.event';
 export * from './providers';

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

@@ -1,3 +1,4 @@
-import { FNodeDropToGroupPreparationExecution } from './drop-to-group-preparation';
-import { FNodeDropToGroupFinalizeExecution } from './drop-to-group-finalize';
-export declare const NODE_DROP_TO_GROUP_PROVIDERS: (typeof FNodeDropToGroupFinalizeExecution | typeof FNodeDropToGroupPreparationExecution)[];
+import { DropToGroupPreparation } from './drop-to-group-preparation';
+import { DropToGroupFinalize } from './drop-to-group-finalize';
+import { SortContainersForDropByLayer } from './sort-containers-for-drop-by-layer';
+export declare const NODE_DROP_TO_GROUP_PROVIDERS: (typeof DropToGroupFinalize | typeof SortContainersForDropByLayer | typeof DropToGroupPreparation)[];

package/f-draggable/f-drop-to-group/sort-containers-for-drop-by-layer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sort-containers-for-drop-by-layer';
+export * from './sort-containers-for-drop-by-layer-request';

package/f-draggable/f-drop-to-group/sort-containers-for-drop-by-layer/sort-containers-for-drop-by-layer-request.d.ts

@@ -0,0 +1,6 @@
+import { INodeWithRect } from "../../domain";
+export declare class SortContainersForDropByLayerRequest {
+    containersForDrop: INodeWithRect[];
+    static readonly fToken: unique symbol;
+    constructor(containersForDrop: INodeWithRect[]);
+}

package/f-draggable/f-drop-to-group/sort-containers-for-drop-by-layer/sort-containers-for-drop-by-layer.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { SortContainersForDropByLayerRequest } from "./sort-containers-for-drop-by-layer-request";
+import { INodeWithRect } from "../../domain";
+import * as i0 from "@angular/core";
+export declare class SortContainersForDropByLayer implements IExecution<SortContainersForDropByLayerRequest, INodeWithRect[]> {
+    handle({ containersForDrop }: SortContainersForDropByLayerRequest): INodeWithRect[];
+    private _domOrder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortContainersForDropByLayer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortContainersForDropByLayer>;
+}

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

@@ -3,8 +3,8 @@ import { FConnectionBase } from '../../../f-connection';
 import { Injector } from '@angular/core';
 export declare class BaseConnectionDragHandler {
     fConnection: FConnectionBase;
-    private readonly _fMediator;
-    private readonly _fComponentsStore;
+    private readonly _mediator;
+    private readonly _store;
     private _fOutputWithRect;
     private _fInputWithRect;
     private get _fOutput();

package/f-draggable/f-node-move/constraint/drag-constraint-pipeline.d.ts

@@ -0,0 +1,17 @@
+import { IPoint } from "@foblex/2d";
+import { IConstraintResult } from "./rect-constraint";
+import { Injector } from "@angular/core";
+import { IDragLimits } from "../create-drag-model-from-selection";
+export interface IConstraintSummary {
+    hardDifference: IPoint;
+    soft: IConstraintResult[];
+}
+export declare class DragConstraintPipeline {
+    private readonly _snapper;
+    private readonly _hardConstraint;
+    private readonly _softConstraints;
+    constructor(injector: Injector, pointerDown: IPoint, limits: IDragLimits);
+    private _initSoftConstraints;
+    apply(difference: IPoint, adjustCellSize?: boolean): IConstraintSummary;
+    finalize(difference: IPoint): IConstraintSummary;
+}

package/f-draggable/f-node-move/constraint/expand-rect-from-baseline.d.ts

@@ -0,0 +1,3 @@
+import { IPoint, IRect } from "@foblex/2d";
+import { IConstraintEdges } from "./rect-constraint";
+export declare function expandRectFromBaseline(boundingRect: IRect, overflow: IPoint, edges: IConstraintEdges): IRect;

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

@@ -0,0 +1,4 @@
+export * from './drag-constraint-pipeline';
+export * from './expand-rect-from-baseline';
+export * from './rect-constraint';
+export * from './snap-to-grid';

package/f-draggable/f-node-move/constraint/rect-constraint.d.ts

@@ -0,0 +1,19 @@
+import { IMinMaxPoint, IPoint } from "@foblex/2d";
+export interface IConstraintEdges {
+    left: boolean;
+    right: boolean;
+    top: boolean;
+    bottom: boolean;
+}
+export interface IConstraintResult {
+    value: IPoint;
+    overflow: IPoint;
+    edges: IConstraintEdges;
+}
+export declare class RectConstraint {
+    private readonly _limits;
+    constructor(_limits: IMinMaxPoint);
+    apply(offset: IPoint): IConstraintResult;
+    private _quantizeSigned;
+    private _clamp;
+}

package/f-draggable/f-node-move/constraint/snap-to-grid.d.ts

@@ -0,0 +1,15 @@
+import { Injector } from "@angular/core";
+import { IPoint } from "@foblex/2d";
+export declare class SnapToGrid {
+    private _onPointerDown;
+    private readonly _store;
+    private readonly _vCellSize;
+    private readonly _hCellSize;
+    private readonly _adjustCellSize;
+    constructor(_injector: Injector, _onPointerDown: IPoint);
+    snap(difference: IPoint, adjustCellSize: boolean): IPoint;
+    private _cellSizeStrategies;
+    private _snapWithCellSize;
+    private _noSnap;
+    private _snapToGrid;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/build-drag-hierarchy/build-drag-hierarchy-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeBase } from "../../../../f-node";
+export declare class BuildDragHierarchyRequest {
+    selectedNodesAndGroupsWithChildren: FNodeBase[];
+    static readonly fToken: unique symbol;
+    constructor(selectedNodesAndGroupsWithChildren: FNodeBase[]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/build-drag-hierarchy/build-drag-hierarchy-response.d.ts

@@ -0,0 +1,6 @@
+import { MoveDragHandler } from "../../move-drag-handler";
+export declare class BuildDragHierarchyResponse {
+    roots: MoveDragHandler[];
+    list: MoveDragHandler[];
+    constructor(roots: MoveDragHandler[], list: MoveDragHandler[]);
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/build-drag-hierarchy/build-drag-hierarchy.d.ts

@@ -0,0 +1,13 @@
+import { IExecution } from '@foblex/mediator';
+import { BuildDragHierarchyRequest } from "./build-drag-hierarchy-request";
+import { BuildDragHierarchyResponse } from "./build-drag-hierarchy-response";
+import * as i0 from "@angular/core";
+export declare class BuildDragHierarchy implements IExecution<BuildDragHierarchyRequest, BuildDragHierarchyResponse> {
+    private readonly _injector;
+    private readonly _mediator;
+    handle({ selectedNodesAndGroupsWithChildren }: BuildDragHierarchyRequest): BuildDragHierarchyResponse;
+    private _createHandlersMap;
+    private _linkParentsAndCollectRoots;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildDragHierarchy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildDragHierarchy>;
+}

package/f-draggable/f-node-move/create-drag-model-from-selection/build-drag-hierarchy/index.d.ts

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

package/f-draggable/f-node-move/create-drag-model-from-selection/calculate-drag-limits/calculate-drag-limits-request.d.ts

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

package/f-draggable/f-node-move/create-drag-model-from-selection/calculate-drag-limits/calculate-drag-limits.d.ts

@@ -0,0 +1,19 @@
+import { IExecution } from '@foblex/mediator';
+import { CalculateDragLimitsRequest } from "./calculate-drag-limits-request";
+import { IDragLimits } from "./i-drag-limits";
+import * as i0 from "@angular/core";
+export declare class CalculateDragLimits implements IExecution<CalculateDragLimitsRequest, IDragLimits> {
+    private readonly _mediator;
+    handle({ nodeOrGroup }: CalculateDragLimitsRequest): IDragLimits;
+    private _getCurrentRect;
+    private _getParentsChain;
+    private _buildSoftHardLimits;
+    private _getParentInfo;
+    private _calculateDifference;
+    private _calculateMinimumDifference;
+    private _calculateMaximumDifference;
+    private _isAutoExpand;
+    private _makeSoftLimit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateDragLimits, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateDragLimits>;
+}