@foblex/flow 17.1.1 → 17.2.1

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

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/mediator';
+import { FCreateConnectionFromOutputPreparationRequest } from './f-create-connection-from-output-preparation.request';
+import * as i0 from "@angular/core";
+export declare class FCreateConnectionFromOutputPreparationExecution implements IHandler<FCreateConnectionFromOutputPreparationRequest, void> {
+    private _fMediator;
+    private _fComponentsStore;
+    handle(request: FCreateConnectionFromOutputPreparationRequest): void;
+    private _isValid;
+    private _isNodeOutput;
+    private _getNodeOutlets;
+    private _getOutput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FCreateConnectionFromOutputPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FCreateConnectionFromOutputPreparationExecution>;
+}

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

@@ -0,0 +1,7 @@
+import { IPointerEvent } from '@foblex/drag-toolkit';
+import { FNodeBase } from '../../../../../f-node';
+export declare class FCreateConnectionFromOutputPreparationRequest {
+    event: IPointerEvent;
+    fNode: FNodeBase;
+    constructor(event: IPointerEvent, fNode: FNodeBase);
+}

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { IFDragHandler } from '../../f-drag-handler';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../f-connectors';
+import { IPoint } from '@foblex/2d';
+export declare class FCreateConnectionDragHandler implements IFDragHandler {
+    private _fOutputOrOutlet;
+    fEventType: string;
+    fData: any;
+    private _fResult;
+    private _fMediator;
+    private _fComponentsStore;
+    private readonly _toConnectorRect;
+    private get _fConnection();
+    private get _fSnapConnection();
+    private _fOutputWithRect;
+    private _canBeConnectedInputs;
+    constructor(_fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase, _onPointerDownPosition: IPoint);
+    prepareDragSequence(): void;
+    private _getAndMarkCanBeConnectedInputs;
+    private _initializeSnapConnection;
+    private _initializeConnectionForCreate;
+    onPointerMove(difference: IPoint): void;
+    private _drawConnectionForCreate;
+    private _drawSnapConnection;
+    private _findClosestInput;
+    private _getClosestInputForSnapConnection;
+    onPointerUp(): void;
+}

package/f-draggable/f-connection/f-create-connection/get-first-connectable-output/get-first-connectable-output.execution.d.ts

@@ -0,0 +1,16 @@
+import { IHandler } from '@foblex/mediator';
+import { FConnectorBase } from '../../../../f-connectors';
+import { GetFirstConnectableOutputRequest } from './get-first-connectable-output.request';
+import * as i0 from "@angular/core";
+export declare class GetFirstConnectableOutputExecution implements IHandler<GetFirstConnectableOutputRequest, FConnectorBase | undefined> {
+    private _fComponentStore;
+    private get _fNodes();
+    private get _fOutputs();
+    private _fNode;
+    handle(request: GetFirstConnectableOutputRequest): FConnectorBase | undefined;
+    private _isValid;
+    private _getNode;
+    private _getConnectableOutputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetFirstConnectableOutputExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetFirstConnectableOutputExecution>;
+}

package/f-draggable/f-connection/f-create-connection/get-first-connectable-output/get-first-connectable-output.request.d.ts

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

package/f-draggable/f-connection/f-create-connection/get-first-connectable-output/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-first-connectable-output.execution';
+export * from './get-first-connectable-output.request';

package/f-draggable/{connections/i-create-reassign-connection-drag-data.d.ts → f-connection/f-create-connection/i-f-create-connection-drag-result.d.ts}

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

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

@@ -0,0 +1,6 @@
+export * from './create-finalize';
+export * from './create-preparation';
+export * from './get-first-connectable-output';
+export * from './f-create-connection.drag-handler';
+export * from './f-create-connection.event';
+export * from './i-f-create-connection-drag-result';

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

@@ -1,13 +1,13 @@
-import { IDraggableItem } from '../../i-draggable-item';
+import { IFDragHandler } from '../../f-drag-handler';
 import { FConnectionBase } from '../../../f-connection';
-import { FMediator } from '@foblex/mediator';
 import { IPoint } from '@foblex/2d';
-import { FComponentsStore } from '../../../f-storage';
-import { ICreateReassignConnectionDragData } from '../i-create-reassign-connection-drag-data';
-export declare class ReassignConnectionDragHandler implements IDraggableItem<ICreateReassignConnectionDragData> {
+export declare class FReassignConnectionDragHandler implements IFDragHandler {
+    private _fConnection;
+    fEventType: string;
+    fData: any;
+    private _fResult;
     private _fMediator;
     private _fComponentsStore;
-    private _fConnection;
     private readonly _toConnectorRect;
     private get _fSnapConnection();
     private _fOutputWithRect;
@@ -15,7 +15,7 @@ export declare class ReassignConnectionDragHandler implements IDraggableItem<ICr
     private _canBeConnectedInputs;
     private get _fOutput();
     private get _fInput();
-    constructor(_fMediator: FMediator, _fComponentsStore: FComponentsStore, _fConnection: FConnectionBase);
+    constructor(_fConnection: FConnectionBase);
     prepareDragSequence(): void;
     private _getAndMarkCanBeConnectedInputs;
     private _initializeSnapConnection;
@@ -27,6 +27,4 @@ export declare class ReassignConnectionDragHandler implements IDraggableItem<ICr
     private _findClosestInput;
     private _getClosestInputForSnapConnection;
     onPointerUp(): void;
-    getData(): ICreateReassignConnectionDragData;
-    getConnection(): FConnectionBase;
 }

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

@@ -0,0 +1,8 @@
+import { RoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection';
+import { IConnectorAndRect } from '../../../domain';
+export interface IFReassignConnectionDragResult {
+    toConnectorRect: RoundedRect;
+    fConnection: FConnectionBase;
+    canBeConnectedInputs: IConnectorAndRect[];
+}

package/f-draggable/{connections/reassign-connection → f-connection/f-reassign-connection}/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { FReassignConnectionFinalizeRequest } from './f-reassign-connection-finalize.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FReassignConnectionFinalizeExecution implements IExecution<FReassignConnectionFinalizeRequest, void> {
+    private _fResult;
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private get _fDraggable();
+    private get _fDragHandler();
+    handle(request: FReassignConnectionFinalizeRequest): void;
+    private _isDroppedConnectionReassignEvent;
+    private _applyReassignEvent;
+    private _getInputUnderPointer;
+    private _isReassignToDifferentInput;
+    private _emitReassignConnectionEvent;
+    private _getEventData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FReassignConnectionFinalizeExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FReassignConnectionFinalizeExecution>;
+}

package/f-draggable/{connections/create-connection/create-connection-preparation/create-connection-preparation.request.d.ts → f-connection/f-reassign-connection/reassign-connection-finalize/f-reassign-connection-finalize.request.d.ts}

@@ -1,5 +1,5 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
-export declare class CreateConnectionPreparationRequest {
+export declare class FReassignConnectionFinalizeRequest {
     event: IPointerEvent;
     constructor(event: IPointerEvent);
 }

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

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

package/f-draggable/{connections/reassign-connection/reassign-connection-preparation/reassign-connection-preparation.execution.d.ts → f-connection/f-reassign-connection/reassign-connection-preparation/f-reassign-connection-preparation.execution.d.ts}

@@ -1,7 +1,7 @@
-import { ReassignConnectionPreparationRequest } from './reassign-connection-preparation.request';
+import { FReassignConnectionPreparationRequest } from './f-reassign-connection-preparation.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
-export declare class ReassignConnectionPreparationExecution implements IExecution<ReassignConnectionPreparationRequest, void> {
+export declare class FReassignConnectionPreparationExecution implements IExecution<FReassignConnectionPreparationRequest, void> {
     private _fMediator;
     private _fComponentsStore;
     private _fDraggableDataContext;
@@ -9,13 +9,13 @@ export declare class ReassignConnectionPreparationExecution implements IExecutio
     private get _transform();
     private get _fHost();
     private get _fConnections();
-    handle(request: ReassignConnectionPreparationRequest): void;
+    handle(request: FReassignConnectionPreparationRequest): void;
     private _isValid;
     private _getPointInFlow;
     private _getConnectionToReassign;
     private _getConnectionsFromPoint;
     private _isPointInsideCircle;
     private _updateConnectionLayer;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionPreparationExecution, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionPreparationExecution>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FReassignConnectionPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FReassignConnectionPreparationExecution>;
 }

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

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

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

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

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

@@ -0,0 +1,3 @@
+export * from './f-create-connection';
+export * from './f-reassign-connection';
+export * from './providers';

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

@@ -0,0 +1,3 @@
+import { FCreateConnectionDragHandlerPreparationExecution, FCreateConnectionFinalizeExecution, FCreateConnectionFromOutletPreparationExecution, FCreateConnectionFromOutputPreparationExecution, FCreateConnectionPreparationExecution, GetFirstConnectableOutputExecution } from './f-create-connection';
+import { FReassignConnectionFinalizeExecution, FReassignConnectionPreparationExecution } from './f-reassign-connection';
+export declare const CONNECTIONS_PROVIDERS: (typeof FCreateConnectionFinalizeExecution | typeof FCreateConnectionDragHandlerPreparationExecution | typeof FCreateConnectionFromOutletPreparationExecution | typeof GetFirstConnectableOutputExecution | typeof FCreateConnectionFromOutputPreparationExecution | typeof FCreateConnectionPreparationExecution | typeof FReassignConnectionFinalizeExecution | typeof FReassignConnectionPreparationExecution)[];

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class FDragHandlerResult<T> {
+    private _data;
+    setData(data: Partial<T>): void;
+    getData(): T;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandlerResult<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FDragHandlerResult<any>>;
+}

package/f-draggable/{i-draggable-item.d.ts → f-drag-handler/i-f-drag-handler.d.ts}

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

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

@@ -0,0 +1,2 @@
+export * from './f-drag-handler-result';
+export * from './i-f-drag-handler';

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

@@ -1,21 +1,24 @@
 import { EventEmitter } from '@angular/core';
-import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
+import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FCreateNodeEvent } from '../f-external-item';
 import { DragAndDropBase, ICanRunOutsideAngular } from '@foblex/drag-toolkit';
 import { FDropToGroupEvent } from './node';
-import { FNodeIntersectedWithConnections } from './domain';
+import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 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<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

@@ -1,13 +1,13 @@
 import { Point } from '@foblex/2d';
-import { IDraggableItem } from './i-draggable-item';
-import { ICanChangeSelection } from '../mixins';
+import { IFDragHandler } from './f-drag-handler';
+import { ISelectable } from '../mixins';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
-    selectedItems: ICanChangeSelection[];
+    selectedItems: ISelectable[];
     isSelectedChanged: boolean;
     onPointerDownScale: number;
     onPointerDownPosition: Point;
-    draggableItems: IDraggableItem[];
+    draggableItems: IFDragHandler[];
     reset(): void;
     markSelectionAsChanged(): void;
     isEmpty(): boolean;

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

@@ -1,28 +1,38 @@
 import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from "@angular/core";
 import { FDraggableBase } from './f-draggable-base';
 import { FDropToGroupEvent } from './node';
-import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
+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 { ICanRunOutsideAngular, IPointerEvent } from '@foblex/drag-toolkit';
-import { FNodeIntersectedWithConnections } from './domain';
+import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 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 _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<FDragStartedEvent>;
+    fDragEnded: EventEmitter<void>;
     private plugins;
     constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
     ngOnInit(): void;
@@ -35,6 +45,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/f-selection-change-event.d.ts

@@ -1,7 +1,7 @@
 import { ICurrentSelection } from '../domain';
 export declare class FSelectionChangeEvent implements ICurrentSelection {
-    nodes: string[];
-    groups: string[];
-    connections: string[];
-    constructor(nodes: string[], groups: string[], connections: string[]);
+    fNodeIds: string[];
+    fGroupIds: string[];
+    fConnectionIds: string[];
+    constructor(fNodeIds: string[], fGroupIds: string[], fConnectionIds: string[]);
 }

package/f-draggable/f-single-select/f-single-select.execution.d.ts

@@ -0,0 +1,62 @@
+import { IExecution } from '@foblex/mediator';
+import { FSingleSelectRequest } from './f-single-select.request';
+import * as i0 from "@angular/core";
+/**
+ * Implements the functionality for selecting elements in a graphical interface.
+ * This class handles both single and multi-selection, updating the selection state
+ * of elements and managing related data.
+ *
+ * Logic flow:
+ * 1. **Validate the selection event**:
+ *    - The event is considered valid if it occurs within the flow boundaries
+ *      and there are no active draggable data operations.
+ *
+ * 2. **Determine the target element to select**:
+ *    - The target element is determined based on the event’s target.
+ *      It can be a node, a group of nodes, or a connection.
+ *    - If no element is found, the current selection state is cleared.
+ *
+ * 3. **Update element layers**:
+ *    - If an element is found, its visual layer and the layers of its child elements are updated.
+ *
+ * 4. **Single or multi-selection**:
+ *    - If the event meets the criteria for multi-selection (e.g., a modifier key is pressed),
+ *      multi-selection logic is applied.
+ *    - Otherwise, single-selection logic is used.
+ *
+ * 5. **Single-selection logic**:
+ *    - If the element is not selected and can be selected:
+ *      - Clear the selection of all other elements.
+ *      - Mark the current element as selected.
+ *    - If the element cannot be selected, the current selection is cleared.
+ *
+ * 6. **Multi-selection logic**:
+ *    - If the element is already selected, it is removed from the selection.
+ *    - If the element is not selected and can be selected, it is added to the selection.
+ *
+ * 7. **Manage selection state**:
+ *    - Adding or removing an element from the selection triggers the corresponding methods.
+ *    - Selection state is tracked in the shared context for future use.
+ */
+export declare class FSingleSelectExecution implements IExecution<FSingleSelectRequest, void> {
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    handle(request: FSingleSelectRequest): void;
+    private _isValid;
+    private _isEventInFlowBounds;
+    private _getItemToSelect;
+    private _getNodeOrGroup;
+    private _getConnection;
+    private _updateItemAndChildrenLayers;
+    private _isMultiSelect;
+    private _singleSelect;
+    private _isItemNotSelectedAndSelectable;
+    private _clearSelection;
+    private _multiSelect;
+    private _deselectItem;
+    private _removeItemFromSelectedItems;
+    private _selectItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSingleSelectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FSingleSelectExecution>;
+}

package/f-draggable/f-single-select/f-single-select.request.d.ts

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

package/f-draggable/f-single-select/index.d.ts

@@ -0,0 +1,3 @@
+export * from './providers';
+export * from './f-single-select.execution';
+export * from './f-single-select.request';

package/f-draggable/f-single-select/providers.d.ts

@@ -0,0 +1,2 @@
+import { FSingleSelectExecution } from './f-single-select.execution';
+export declare const SINGLE_SELECT_PROVIDERS: (typeof FSingleSelectExecution)[];

package/f-draggable/index.d.ts

@@ -1,14 +1,14 @@
-export * from './canvas';
-export * from './connections';
+export * from './f-canvas';
+export * from './f-drag-handler';
+export * from './f-connection';
 export * from './domain';
-export * from '../domain/f-draggable/is-drag-started';
 export * from './node';
 export * from './node-resize';
-export * from './single-select';
+export * from './f-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';
 export * from './providers';

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