@foblex/flow 17.1.0 → 17.2.0

package/f-draggable/connections/create-connection/get-can-be-connected-output-by-outlet/get-can-be-connected-output-by-outlet.execution.d.ts

@@ -1,16 +1,16 @@
 import { IHandler } from '@foblex/mediator';
-import { FComponentsStore } from '../../../../f-storage';
 import { FConnectorBase } from '../../../../f-connectors';
 import { GetCanBeConnectedOutputByOutletRequest } from './get-can-be-connected-output-by-outlet.request';
 import * as i0 from "@angular/core";
 export declare class GetCanBeConnectedOutputByOutletExecution implements IHandler<GetCanBeConnectedOutputByOutletRequest, FConnectorBase | undefined> {
-    private fComponentsStore;
-    private get fNodes();
-    private get fOutputs();
-    constructor(fComponentsStore: FComponentsStore);
+    private _fComponentStore;
+    private get _fNodes();
+    private get _fOutputs();
+    private _fNode;
     handle(request: GetCanBeConnectedOutputByOutletRequest): FConnectorBase | undefined;
-    private getConnectableOutputs;
-    private getNode;
+    private _isValid;
+    private _getNode;
+    private _getConnectableOutputs;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetCanBeConnectedOutputByOutletExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetCanBeConnectedOutputByOutletExecution>;
 }

package/f-draggable/connections/create-connection/get-can-be-connected-output-by-outlet/get-can-be-connected-output-by-outlet.request.d.ts

@@ -1,5 +1,5 @@
 import { FNodeOutletBase } from '../../../../f-connectors';
 export declare class GetCanBeConnectedOutputByOutletRequest {
-    outlet: FNodeOutletBase;
-    constructor(outlet: FNodeOutletBase);
+    fOutlet: FNodeOutletBase;
+    constructor(fOutlet: FNodeOutletBase);
 }

package/f-draggable/connections/create-connection/get-can-be-connected-output-by-outlet/index.d.ts

@@ -1,3 +1,2 @@
 export * from './get-can-be-connected-output-by-outlet.execution';
 export * from './get-can-be-connected-output-by-outlet.request';
-export * from './get-can-be-connected-output-by-outlet.validator';

package/f-draggable/connections/i-create-reassign-connection-drag-data.d.ts

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

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

@@ -1,4 +1,4 @@
 export * from './create-connection';
-export * from './get-input-under-pointer';
 export * from './reassign-connection';
+export * from './i-create-reassign-connection-drag-data';
 export * from './providers';

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

@@ -1,4 +1,3 @@
-import { CreateConnectionDragHandlerExecution, CreateConnectionFinalizeExecution, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationValidator, CreateConnectionPreparationExecution, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletValidator } from './create-connection';
+import { CreateConnectionDragHandlerPreparationExecution, CreateConnectionFinalizeExecution, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutputPreparationExecution, CreateConnectionPreparationExecution, GetCanBeConnectedOutputByOutletExecution } from './create-connection';
 import { ReassignConnectionFinalizeExecution, ReassignConnectionPreparationExecution } from './reassign-connection';
-import { GetInputUnderPointerExecution, GetInputUnderPointerValidator } from './get-input-under-pointer';
-export declare const CONNECTIONS_PROVIDERS: (typeof CreateConnectionPreparationExecution | typeof CreateConnectionDragHandlerExecution | typeof CreateConnectionFinalizeExecution | typeof GetInputUnderPointerExecution | typeof ReassignConnectionPreparationExecution | typeof ReassignConnectionFinalizeExecution | typeof GetInputUnderPointerValidator | typeof CreateConnectionFromOutletPreparationExecution | typeof GetCanBeConnectedOutputByOutletExecution | typeof GetCanBeConnectedOutputByOutletValidator | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionFromOutputPreparationValidator)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof CreateConnectionFinalizeExecution | typeof CreateConnectionDragHandlerPreparationExecution | typeof CreateConnectionFromOutletPreparationExecution | typeof GetCanBeConnectedOutputByOutletExecution | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionPreparationExecution | typeof ReassignConnectionFinalizeExecution | typeof ReassignConnectionPreparationExecution)[];

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

@@ -14,6 +14,7 @@ export declare class ReassignConnectionFinalizeExecution implements IExecution<R
     private _isReassignToDifferentInput;
     private _emitReassignConnectionEvent;
     private _getEventData;
+    private _getDragHandlerData;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionFinalizeExecution>;
 }

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

@@ -1,5 +1,7 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
+import { FEventTrigger } from '../../../../domain';
 export declare class ReassignConnectionPreparationRequest {
     event: IPointerEvent;
-    constructor(event: IPointerEvent);
+    fTrigger: FEventTrigger;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
 }

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

@@ -1,30 +1,30 @@
 import { IDraggableItem } from '../../i-draggable-item';
-import { IClosestInput } from '../../../domain';
 import { FConnectionBase } from '../../../f-connection';
-import { FMediator } from '@foblex/mediator';
-import { IPoint, RoundedRect } from '@foblex/2d';
-import { FComponentsStore } from '../../../f-storage';
-export declare class ReassignConnectionDragHandler implements IDraggableItem {
-    private fMediator;
-    private fComponentsStore;
-    fConnection: FConnectionBase;
-    toConnectorRect: RoundedRect;
-    private get fSnapConnection();
-    private fOutputWithRect;
-    private fInputWithRect;
-    private canBeConnectedInputs;
-    constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, fConnection: FConnectionBase);
+import { IPoint } from '@foblex/2d';
+import { ICreateReassignConnectionDragData } from '../i-create-reassign-connection-drag-data';
+export declare class ReassignConnectionDragHandler implements IDraggableItem<ICreateReassignConnectionDragData> {
+    private _fConnection;
+    private _fMediator;
+    private _fComponentsStore;
+    private readonly _toConnectorRect;
+    private get _fSnapConnection();
+    private _fOutputWithRect;
+    private _fInputWithRect;
+    private _canBeConnectedInputs;
+    private get _fOutput();
+    private get _fInput();
+    constructor(_fConnection: FConnectionBase);
     prepareDragSequence(): void;
+    private _getAndMarkCanBeConnectedInputs;
     private _initializeSnapConnection;
-    private getOutput;
-    private getInput;
     onPointerMove(difference: IPoint): void;
     private _drawConnection;
     private _getLineToPointer;
     private _drawSnapConnection;
     private _getLineToClosestInput;
-    getClosetInput(difference: IPoint): IClosestInput | undefined;
     private _findClosestInput;
     private _getClosestInputForSnapConnection;
     onPointerUp(): void;
+    getData(): ICreateReassignConnectionDragData;
+    getConnection(): FConnectionBase;
 }

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

@@ -9,13 +9,16 @@ import * as i0 from "@angular/core";
 export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     abstract fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
-    abstract emitWhenNodeIntersectedWithConnection: boolean;
+    abstract fEmitOnNodeIntersect: boolean;
     abstract fCreateNode: EventEmitter<FCreateNodeEvent>;
     abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     abstract fDropToGroup: EventEmitter<FDropToGroupEvent>;
     abstract vCellSize: number;
     abstract hCellSize: number;
+    abstract fCellSizeWhileDragging: boolean;
+    abstract fDragStarted: EventEmitter<void>;
+    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

@@ -1,9 +1,9 @@
 import { Point } from '@foblex/2d';
 import { IDraggableItem } from './i-draggable-item';
-import { ICanChangeSelection } from '../mixins';
+import { ISelectable } from '../mixins';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
-    selectedItems: ICanChangeSelection[];
+    selectedItems: ISelectable[];
     isSelectedChanged: boolean;
     onPointerDownScale: number;
     onPointerDownPosition: Point;

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

@@ -3,6 +3,7 @@ import { FDraggableBase } from './f-draggable-base';
 import { FDropToGroupEvent } from './node';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import { FSelectionChangeEvent } from './f-selection-change-event';
+import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
 import { BrowserService } from '@foblex/platform';
 import { ICanRunOutsideAngular, IPointerEvent } from '@foblex/drag-toolkit';
@@ -12,17 +13,25 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     private _fBrowser;
     private _elementReference;
     private _fMediator;
+    private _fPlatform;
+    private _injector;
     disabled: boolean;
     get hostElement(): HTMLElement;
+    fMultiSelectTrigger: FEventTrigger;
+    fReassignConnectionTrigger: FEventTrigger;
+    fCreateConnectionTrigger: FEventTrigger;
     fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
-    emitWhenNodeIntersectedWithConnection: boolean;
+    fEmitOnNodeIntersect: boolean;
     fCreateNode: EventEmitter<FCreateNodeEvent<any>>;
     fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     fDropToGroup: EventEmitter<FDropToGroupEvent>;
     vCellSize: number;
     hCellSize: number;
+    fCellSizeWhileDragging: boolean;
+    fDragStarted: EventEmitter<void>;
+    fDragEnded: EventEmitter<void>;
     private plugins;
     constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
     ngOnInit(): void;
@@ -35,6 +44,10 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     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; }; "emitWhenNodeIntersectedWithConnection": { "alias": "emitWhenNodeIntersectedWithConnection"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; }; "hCellSize": { "alias": "hCellSize"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; }, ["plugins"], never, false, never>;
-    static ngAcceptInputType_emitWhenNodeIntersectedWithConnection: unknown;
+    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; }; "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"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["plugins"], 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-injector.d.ts

@@ -0,0 +1,8 @@
+import { Injector, Type } from "@angular/core";
+export declare class FInjector {
+    private static _injector;
+    static set(injector: Injector): void;
+    static clear(): void;
+    static get(): Injector;
+}
+export declare function fInject<T>(token: Type<T>): T;

package/f-draggable/i-draggable-item.d.ts

@@ -1,6 +1,7 @@
 import { IPoint } from '@foblex/2d';
-export interface IDraggableItem {
+export interface IDraggableItem<TData = any> {
     prepareDragSequence?(): void;
     onPointerMove(difference: IPoint): void;
     onPointerUp?(): void;
+    getData?(): TData;
 }

package/f-draggable/index.d.ts

@@ -8,6 +8,7 @@ export * from './single-select';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';
+export * from './f-injector';
 export * from './f-selection-change-event';
 export * from './i-f-drag-and-drop-plugin';
 export * from './i-draggable-item';

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

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection';
+export declare class BaseConnectionDragHandler {
+    fConnection: FConnectionBase;
+    private _fMediator;
+    private _fComponentStore;
+    private _fOutputWithRect;
+    private _fInputWithRect;
+    private get _fOutput();
+    private get _fInput();
+    private _sourceDifference;
+    private _targetDifference;
+    constructor(fConnection: FConnectionBase);
+    private _initialize;
+    setSourceDifference(difference: IPoint): void;
+    setTargetDifference(difference: IPoint): void;
+    protected redraw(): void;
+    private _recalculateConnection;
+    private _redrawConnection;
+    private _connectorNotFoundPrefix;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { FConnectionBase } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+export declare class SourceConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection: FConnectionBase);
+    setSourceDifference(difference: IPoint): void;
+}

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

@@ -0,0 +1,10 @@
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { FConnectionBase } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+export declare class SourceTargetConnectionDragHandler extends BaseConnectionDragHandler {
+    private _callTracker;
+    constructor(fConnection: FConnectionBase);
+    setSourceDifference(difference: IPoint): void;
+    setTargetDifference(difference: IPoint): void;
+    private _checkAndTriggerAction;
+}

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

@@ -0,0 +1,7 @@
+import { FConnectionBase } from '../../../f-connection';
+import { BaseConnectionDragHandler } from './base-connection.drag-handler';
+import { IPoint } from '@foblex/2d';
+export declare class TargetConnectionDragHandler extends BaseConnectionDragHandler {
+    constructor(fConnection: FConnectionBase);
+    setTargetDifference(difference: IPoint): void;
+}

package/f-draggable/node/create-move-nodes-drag-model-from-selection/create-move-nodes-drag-model-from-selection.execution.d.ts

@@ -1,27 +1,28 @@
 import { CreateMoveNodesDragModelFromSelectionRequest } from './create-move-nodes-drag-model-from-selection.request';
 import { IExecution } from '@foblex/mediator';
-import { IDraggableItem } from '../../i-draggable-item';
+import { SummaryNodeDragHandler } from '../summary-node.drag-handler';
 import * as i0 from "@angular/core";
-export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, IDraggableItem[]> {
+export declare class CreateMoveNodesDragModelFromSelectionExecution implements IExecution<CreateMoveNodesDragModelFromSelectionRequest, SummaryNodeDragHandler> {
     private _fMediator;
     private _fComponentsStore;
     private _fDraggableDataContext;
-    handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[];
+    handle(request: CreateMoveNodesDragModelFromSelectionRequest): SummaryNodeDragHandler;
     private _getDraggedNodes;
     private _getNodesFromSelection;
     private _findNode;
-    private _getNodesWithRestrictions;
-    private _getNodeMoveRestrictions;
+    private _getNodesToDragWithCommonLimits;
+    private _getNodesMoveLimits;
+    private _getNodeMoveLimits;
     private _isParentNodeInArray;
-    private _getChildrenItemsToDrag;
     private _getChildrenNodes;
-    private _applyCommonRestrictions;
-    private getAllOutputIds;
-    private getOutputsForNode;
-    private getAllInputIds;
-    private getInputsForNode;
-    private getDragHandlersFromNodes;
-    private getDragHandlersWithConnections;
+    private _calculateCommonLimits;
+    private _getAllOutputIds;
+    private _getNodeOutputIds;
+    private _getAllInputIds;
+    private _getNodeInputIds;
+    private _mapToNodeDragHandlers;
+    private _setConnectionsHandlersToNodes;
+    private _getDraggedNodesBoundingRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<CreateMoveNodesDragModelFromSelectionExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CreateMoveNodesDragModelFromSelectionExecution>;
 }

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

@@ -0,0 +1,19 @@
+import { CalculateCommonNodeMoveLimitsRequest } from './calculate-common-node-move-limits.request';
+import { IExecution } from '@foblex/mediator';
+import { INodeMoveLimits } from '../../i-node-move-limits';
+import * as i0 from "@angular/core";
+export declare class CalculateCommonNodeMoveLimitsExecution implements IExecution<CalculateCommonNodeMoveLimitsRequest, INodeMoveLimits> {
+    private _fComponentsStore;
+    private get _vCellSize();
+    private get _hCellSize();
+    handle(request: CalculateCommonNodeMoveLimitsRequest): INodeMoveLimits;
+    private _calculateCommonLimits;
+    private _clampRestrictions;
+    private _clampMinRestrictions;
+    private _clampMaxRestrictions;
+    private _snapLimitToGrid;
+    private _snapLimitToGridMinimum;
+    private _snapLimitToGridMaximum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateCommonNodeMoveLimitsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateCommonNodeMoveLimitsExecution>;
+}

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

@@ -0,0 +1,5 @@
+import { INodeMoveLimitsAndPosition } from '../../i-node-move-limits-and-position';
+export declare class CalculateCommonNodeMoveLimitsRequest {
+    limits: INodeMoveLimitsAndPosition[];
+    constructor(limits: INodeMoveLimitsAndPosition[]);
+}

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

@@ -0,0 +1,2 @@
+export * from './calculate-common-node-move-limits.execution';
+export * from './calculate-common-node-move-limits.request';

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

@@ -0,0 +1,15 @@
+import { CalculateNodeMoveLimitsRequest } from './calculate-node-move-limits.request';
+import { IExecution } from '@foblex/mediator';
+import { INodeMoveLimits } from '../../i-node-move-limits';
+import * as i0 from "@angular/core";
+export declare class CalculateNodeMoveLimitsExecution implements IExecution<CalculateNodeMoveLimitsRequest, INodeMoveLimits> {
+    private _fMediator;
+    handle(request: CalculateNodeMoveLimitsRequest): INodeMoveLimits;
+    private _fNodeRect;
+    private _fParentRect;
+    private _calculateDifference;
+    private _calculateMinimumDifference;
+    private _calculateMaximumDifference;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodeMoveLimitsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodeMoveLimitsExecution>;
+}

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/{calculate-node-move-restrictions/calculate-node-move-restrictions.request.d.ts → calculate-node-move-limits/calculate-node-move-limits.request.d.ts}

@@ -1,5 +1,5 @@
 import { FNodeBase } from '../../../../../f-node';
-export declare class CalculateNodeMoveRestrictionsRequest {
+export declare class CalculateNodeMoveLimitsRequest {
     fNode: FNodeBase;
     hasParentNodeInSelected: boolean;
     constructor(fNode: FNodeBase, hasParentNodeInSelected: boolean);

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

@@ -0,0 +1,2 @@
+export * from './calculate-node-move-limits.execution';
+export * from './calculate-node-move-limits.request';

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.execution.d.ts

@@ -1,20 +1,15 @@
 import { PutInputConnectionHandlersToArrayRequest } from './put-input-connection-handlers-to-array.request';
 import { IExecution } from '@foblex/mediator';
-import { FNodeBase } from '../../../../../f-node';
-import { FConnectionBase } from '../../../../../f-connection';
 import * as i0 from "@angular/core";
 export declare class PutInputConnectionHandlersToArrayExecution implements IExecution<PutInputConnectionHandlersToArrayRequest, void> {
-    private _fMediator;
     private _fComponentsStore;
     private get _fConnections();
     handle(request: PutInputConnectionHandlersToArrayRequest): void;
-    getInputConnections(node: FNodeBase): FConnectionBase[];
-    private getInputsForNode;
-    private getExistingConnectionHandlerIndex;
-    private createNewConnectionHandler;
-    private getNewConnectionHandler;
-    private updateExistingConnectionHandler;
-    private getNewSourceConnectionHandler;
+    private _getInputConnections;
+    private _getNodeInputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<PutInputConnectionHandlersToArrayExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PutInputConnectionHandlersToArrayExecution>;
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-input-connection-handlers-to-array/put-input-connection-handlers-to-array.request.d.ts

@@ -1,8 +1,8 @@
 import { NodeDragHandler } from '../../../node.drag-handler';
-import { IDraggableItem } from '../../../../i-draggable-item';
+import { BaseConnectionDragHandler } from '../../../connection-drag-handlers/base-connection.drag-handler';
 export declare class PutInputConnectionHandlersToArrayRequest {
-    nodeDragHandler: NodeDragHandler;
+    fDragHandler: NodeDragHandler;
     outputIds: string[];
-    result: IDraggableItem[];
-    constructor(nodeDragHandler: NodeDragHandler, outputIds: string[], result: IDraggableItem[]);
+    result: BaseConnectionDragHandler[];
+    constructor(fDragHandler: NodeDragHandler, outputIds: string[], result: BaseConnectionDragHandler[]);
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.execution.d.ts

@@ -1,22 +1,17 @@
 import { PutOutputConnectionHandlersToArrayRequest } from './put-output-connection-handlers-to-array.request';
-import { FComponentsStore } from '../../../../../f-storage';
-import { FMediator, IExecution } from '@foblex/mediator';
+import { IExecution } from '@foblex/mediator';
 import { FNodeBase } from '../../../../../f-node';
 import { FConnectionBase } from '../../../../../f-connection';
 import * as i0 from "@angular/core";
 export declare class PutOutputConnectionHandlersToArrayExecution implements IExecution<PutOutputConnectionHandlersToArrayRequest, void> {
-    private fComponentsStore;
-    private fMediator;
-    private get fConnections();
-    constructor(fComponentsStore: FComponentsStore, fMediator: FMediator);
+    private _fComponentsStore;
+    private get _fConnections();
     handle(request: PutOutputConnectionHandlersToArrayRequest): void;
-    getOutputConnections(node: FNodeBase): FConnectionBase[];
-    private getOutputsForNode;
-    private getExistingConnectionHandlerIndex;
-    private createNewConnectionHandler;
-    private getNewConnectionHandler;
-    private updateExistingConnectionHandler;
-    private getNewSourceConnectionHandler;
+    _getOutputConnections(node: FNodeBase): FConnectionBase[];
+    private _getNodeOutputIds;
+    private _createAndSetConnectionToNodeHandler;
+    private _getExistingConnectionHandler;
+    private _createConnectionHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<PutOutputConnectionHandlersToArrayExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PutOutputConnectionHandlersToArrayExecution>;
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/domain/put-output-connection-handlers-to-array/put-output-connection-handlers-to-array.request.d.ts

@@ -1,8 +1,8 @@
 import { NodeDragHandler } from '../../../node.drag-handler';
-import { IDraggableItem } from '../../../../i-draggable-item';
+import { BaseConnectionDragHandler } from '../../../connection-drag-handlers/base-connection.drag-handler';
 export declare class PutOutputConnectionHandlersToArrayRequest {
-    nodeDragHandler: NodeDragHandler;
+    fDragHandler: NodeDragHandler;
     inputIds: string[];
-    result: IDraggableItem[];
-    constructor(nodeDragHandler: NodeDragHandler, inputIds: string[], result: IDraggableItem[]);
+    result: BaseConnectionDragHandler[];
+    constructor(fDragHandler: NodeDragHandler, inputIds: string[], result: BaseConnectionDragHandler[]);
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/i-node-move-limits-and-position.d.ts

@@ -0,0 +1,5 @@
+import { IPoint } from '@foblex/2d';
+import { INodeMoveLimits } from './i-node-move-limits';
+export interface INodeMoveLimitsAndPosition extends INodeMoveLimits {
+    position: IPoint;
+}

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

@@ -0,0 +1,3 @@
+import { IMinMaxPoint } from '@foblex/2d';
+export interface INodeMoveLimits extends IMinMaxPoint {
+}

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

@@ -1,8 +1,9 @@
-export * from './domain/calculate-common-node-move-restrictions';
+export * from './domain/calculate-common-node-move-limits';
 export * from './domain/put-input-connection-handlers-to-array';
 export * from './domain/put-output-connection-handlers-to-array';
-export * from './domain/calculate-node-move-restrictions';
+export * from './domain/calculate-node-move-limits';
 export * from './providers';
 export * from './create-move-nodes-drag-model-from-selection.execution';
 export * from './create-move-nodes-drag-model-from-selection.request';
-export * from './i-node-with-distance-restrictions';
+export * from './i-node-move-limits';
+export * from './i-node-move-limits-and-position';

package/f-draggable/node/create-move-nodes-drag-model-from-selection/providers.d.ts

@@ -1,6 +1,6 @@
 import { CreateMoveNodesDragModelFromSelectionExecution } from './create-move-nodes-drag-model-from-selection.execution';
-import { CalculateNodeMoveRestrictionsExecution } from './domain/calculate-node-move-restrictions';
+import { CalculateNodeMoveLimitsExecution } from './domain/calculate-node-move-limits';
 import { PutInputConnectionHandlersToArrayExecution } from './domain/put-input-connection-handlers-to-array';
 import { PutOutputConnectionHandlersToArrayExecution } from './domain/put-output-connection-handlers-to-array';
-import { CalculateCommonNodeMoveRestrictionsExecution } from './domain/calculate-common-node-move-restrictions';
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateCommonNodeMoveRestrictionsExecution | typeof CalculateNodeMoveRestrictionsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];
+import { CalculateCommonNodeMoveLimitsExecution } from './domain/calculate-common-node-move-limits';
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CalculateCommonNodeMoveLimitsExecution | typeof CalculateNodeMoveLimitsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];

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

@@ -1,16 +1,14 @@
+export * from './connection-drag-handlers';
 export * from './create-move-nodes-drag-model-from-selection';
 export * from './line-alignment-preparation';
 export * from './node-drag-to-parent-finalize';
 export * from './node-drag-to-parent-preparation';
 export * from './node-move-preparation';
 export * from './node-move-finalize';
-export * from './connection.drag-handler';
-export * from './connection-base-drag-handler';
-export * from './connection-source.drag-handler';
-export * from './connection-target.drag-handler';
 export * from './f-drop-to-group.event';
 export * from './line-alignment.drag-handler';
 export * from './node.drag-handler';
 export * from './node-drag-to-parent.drag-handler';
-export * from './node-resize-by-child.drag-handler';
+export * from './point-bounds-limiter';
 export * from './providers';
+export * from './summary-node.drag-handler';

package/f-draggable/node/line-alignment-preparation/line-alignment-preparation.execution.d.ts

@@ -8,11 +8,9 @@ export declare class LineAlignmentPreparationExecution implements IExecution<Lin
     private _fBrowser;
     private _lineService;
     handle(request: LineAlignmentPreparationRequest): void;
-    private _getDraggedNodes;
     private _addLineAlignmentDragHandler;
     private _getFlowHostSize;
     private _createLineService;
-    private _getDraggedNodesBoundingRect;
     private _getStaticNodeRects;
     private _getStaticNodes;
     private _getCommonRestrictions;

package/f-draggable/node/line-alignment-preparation/line-alignment-preparation.request.d.ts

@@ -1,2 +1,7 @@
+import { IRect } from '@foblex/2d';
+import { FNodeBase } from '../../../f-node';
 export declare class LineAlignmentPreparationRequest {
+    fNodes: FNodeBase[];
+    commonRect: IRect;
+    constructor(fNodes: FNodeBase[], commonRect: IRect);
 }

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

@@ -1,17 +1,16 @@
 import { IMinMaxPoint, IPoint, IRect, ISize } from '@foblex/2d';
 import { IDraggableItem } from '../index';
-import { FComponentsStore } from '../../f-storage';
 import { ILineAlignmentResult, LineService } from '../../f-line-alignment';
 export declare class LineAlignmentDragHandler implements IDraggableItem {
-    private _fComponentsStore;
     private _lineService;
     private _size;
     private _draggedNodeRect;
     private _rects;
     private _restrictions;
+    private _fComponentsStore;
     private _debounceTimer;
     private readonly _transform;
-    constructor(_fComponentsStore: FComponentsStore, _lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
+    constructor(_lineService: LineService, _size: ISize, _draggedNodeRect: IRect, _rects: IRect[], _restrictions: IMinMaxPoint);
     onPointerMove(difference: IPoint): void;
     private _drawIntersectingLines;
     private _getDifference;

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

@@ -1,4 +1,2 @@
-export * from './providers';
 export * from './node-drag-to-parent-preparation.execution';
 export * from './node-drag-to-parent-preparation.request';
-export * from './node-drag-to-parent-preparation.validator';

package/f-draggable/node/node-drag-to-parent-preparation/node-drag-to-parent-preparation.execution.d.ts

@@ -12,6 +12,7 @@ export declare class NodeDragToParentPreparationExecution implements IExecution<
     private get fCanvasPosition();
     constructor(fMediator: FMediator, fDraggableDataContext: FDraggableDataContext, fComponentsStore: FComponentsStore);
     handle(request: NodeDragToParentPreparationRequest): void;
+    private _isValid;
     private _getNotDraggedNodesRects;
     private _getNodesBeingDragged;
     private _addParentNodes;