@foblex/flow 17.9.81 → 18.1.0

package/domain/f-connectors/find-connectable-connector-using-priority-and-position/find-connectable-connector-using-priority-and-position.execution.d.ts

@@ -14,7 +14,7 @@ export declare class FindConnectableConnectorUsingPriorityAndPositionExecution i
     private get _transform();
     private get _fHost();
     private get _fNodes();
-    private get _fSnapConnection();
+    private get _snapConnection();
     handle(payload: FindConnectableConnectorUsingPriorityAndPositionRequest): FConnectorBase | undefined;
     private _findConnectorAtPosition;
     private _filterConnectorsThatLocatedAtPosition;

package/domain/f-connectors/find-connectable-connector-using-priority-and-position/find-connectable-connector-using-priority-and-position.request.d.ts

@@ -1,8 +1,8 @@
 import { IPoint } from '@foblex/2d';
-import { IConnectorAndRect } from '../i-connector-and-rect';
+import { IConnectorRectRef } from '../i-connector-rect-ref';
 export declare class FindConnectableConnectorUsingPriorityAndPositionRequest {
     pointerPosition: IPoint;
-    connectableConnectors: IConnectorAndRect[];
+    connectableConnectors: IConnectorRectRef[];
     static readonly fToken: unique symbol;
-    constructor(pointerPosition: IPoint, connectableConnectors: IConnectorAndRect[]);
+    constructor(pointerPosition: IPoint, connectableConnectors: IConnectorRectRef[]);
 }

package/domain/f-connectors/get-connector-rect-reference/get-connector-rect-reference-request.d.ts

@@ -0,0 +1,6 @@
+import { FConnectorBase } from '../../../f-connectors';
+export declare class GetConnectorRectReferenceRequest {
+    readonly connector: FConnectorBase;
+    static readonly fToken: unique symbol;
+    constructor(connector: FConnectorBase);
+}

package/domain/f-connectors/get-connector-rect-reference/get-connector-rect-reference.d.ts

@@ -0,0 +1,14 @@
+import { IExecution } from '@foblex/mediator';
+import { GetConnectorRectReferenceRequest } from './get-connector-rect-reference-request';
+import { IConnectorRectRef } from '../i-connector-rect-ref';
+import * as i0 from "@angular/core";
+/**
+ * Returns a connector + its normalized rounded rect.
+ */
+export declare class GetConnectorRectReference implements IExecution<GetConnectorRectReferenceRequest, IConnectorRectRef> {
+    private readonly _mediator;
+    handle({ connector }: GetConnectorRectReferenceRequest): IConnectorRectRef;
+    private _getRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetConnectorRectReference, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetConnectorRectReference>;
+}

package/domain/f-connectors/get-connector-rect-reference/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-connector-rect-reference';
+export * from './get-connector-rect-reference-request';

package/domain/f-connectors/i-closest-connector-ref.d.ts

@@ -0,0 +1,8 @@
+import { IConnectorRectRef } from './i-connector-rect-ref';
+import { FConnectorBase } from '../../f-connectors';
+/**
+ * Interface that describes the closest connector to a point.
+ */
+export interface IClosestConnectorRef<TConnector extends FConnectorBase = FConnectorBase> extends IConnectorRectRef<TConnector> {
+    distance: number;
+}

package/domain/f-connectors/i-connector-rect-ref.d.ts

@@ -0,0 +1,6 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectorBase } from '../../f-connectors';
+export interface IConnectorRectRef<TConnector extends FConnectorBase = FConnectorBase> {
+    connector: TConnector;
+    rect: IRoundedRect;
+}

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

@@ -1,16 +1,12 @@
-export * from './add-input-to-store';
-export * from './add-outlet-to-store';
-export * from './add-output-to-store';
+export * from './add-connector-to-store';
 export * from './calculate-closest-connector';
 export * from './find-connectable-connector-using-priority-and-position';
 export * from './calculate-target-connectors-to-connect';
 export * from './calculate-source-connectors-to-connect';
-export * from './get-connector-and-rect';
+export * from './get-connector-rect-reference';
 export * from './mark-connectable-connectors';
-export * from './remove-input-from-store';
-export * from './remove-outlet-from-store';
-export * from './remove-output-from-store';
+export * from './remove-connector-from-store';
 export * from './unmark-connectable-connectors';
-export * from './i-closest-connector';
-export * from './i-connector-and-rect';
+export * from './i-closest-connector-ref';
+export * from './i-connector-rect-ref';
 export * from './providers';

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

@@ -1,14 +1,10 @@
-import { AddInputToStore } from './add-input-to-store';
-import { AddOutletToStore } from './add-outlet-to-store';
-import { AddOutputToStore } from './add-output-to-store';
-import { RemoveInputFromStore } from './remove-input-from-store';
-import { RemoveOutletFromStoreExecution } from './remove-outlet-from-store';
-import { RemoveOutputFromStoreExecution } from './remove-output-from-store';
 import { MarkConnectableConnectors } from './mark-connectable-connectors';
 import { UnmarkConnectableConnectors } from './unmark-connectable-connectors';
 import { CalculateTargetConnectorsToConnect } from './calculate-target-connectors-to-connect';
-import { GetConnectorAndRect } from './get-connector-and-rect';
+import { GetConnectorRectReference } from './get-connector-rect-reference';
 import { CalculateClosestConnector } from './calculate-closest-connector';
 import { CalculateSourceConnectorsToConnect } from './calculate-source-connectors-to-connect';
 import { FindConnectableConnectorUsingPriorityAndPositionExecution } from './find-connectable-connector-using-priority-and-position';
-export declare const F_CONNECTORS_FEATURES: (typeof AddInputToStore | typeof AddOutletToStore | typeof AddOutputToStore | typeof CalculateClosestConnector | typeof FindConnectableConnectorUsingPriorityAndPositionExecution | typeof CalculateSourceConnectorsToConnect | typeof CalculateTargetConnectorsToConnect | typeof GetConnectorAndRect | typeof MarkConnectableConnectors | typeof RemoveInputFromStore | typeof RemoveOutletFromStoreExecution | typeof RemoveOutputFromStoreExecution | typeof UnmarkConnectableConnectors)[];
+import { AddConnectorToStore } from './add-connector-to-store';
+import { RemoveConnectorFromStore } from './remove-connector-from-store';
+export declare const F_CONNECTORS_FEATURES: (typeof AddConnectorToStore | typeof RemoveConnectorFromStore | typeof CalculateClosestConnector | typeof FindConnectableConnectorUsingPriorityAndPositionExecution | typeof CalculateSourceConnectorsToConnect | typeof CalculateTargetConnectorsToConnect | typeof GetConnectorRectReference | typeof MarkConnectableConnectors | typeof UnmarkConnectableConnectors)[];

package/domain/f-connectors/remove-connector-from-store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './remove-connector-from-store';
+export * from './remove-connector-from-store-request';

package/domain/f-connectors/remove-connector-from-store/remove-connector-from-store-request.d.ts

@@ -0,0 +1,6 @@
+import { FConnectorBase } from '../../../f-connectors';
+export declare class RemoveConnectorFromStoreRequest {
+    readonly instance: FConnectorBase;
+    static readonly fToken: unique symbol;
+    constructor(instance: FConnectorBase);
+}

package/domain/f-connectors/remove-connector-from-store/remove-connector-from-store.d.ts

@@ -0,0 +1,15 @@
+import { IExecution } from '@foblex/mediator';
+import { RemoveConnectorFromStoreRequest } from './remove-connector-from-store-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that removes an inputConnector from the FComponentsStore.
+ */
+export declare class RemoveConnectorFromStore implements IExecution<RemoveConnectorFromStoreRequest, void> {
+    private readonly _store;
+    handle({ instance }: RemoveConnectorFromStoreRequest): void;
+    private _removeInput;
+    private _removeOutput;
+    private _removeOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectorFromStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectorFromStore>;
+}

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

@@ -1,10 +1,7 @@
 export * from './add-dnd-to-store';
-export * from './emit-selection-change-event';
-export * from './end-drag-sequence';
 export * from './on-pointer-move';
 export * from './initialize-drag-sequence';
 export * from './is-drag-started';
 export * from './prepare-drag-sequence';
 export * from './remove-dnd-from-store';
-export * from './start-drag-sequence';
 export * from './providers';

package/domain/f-draggable/on-pointer-move/on-pointer-move.execution.d.ts

@@ -10,7 +10,7 @@ export declare class OnPointerMoveExecution implements IExecution<OnPointerMoveR
     private readonly _store;
     private get _hostElement();
     private readonly _dragContext;
-    handle(request: OnPointerMoveRequest): void;
+    handle({ event }: OnPointerMoveRequest): void;
     private _setDifferenceToDraggableItems;
     private _getDifferenceBetweenPointerAndPointerDown;
     private _getPointerPositionInCanvas;

package/domain/f-draggable/prepare-drag-sequence/prepare-drag-sequence.execution.d.ts

@@ -7,7 +7,7 @@ import * as i0 from "@angular/core";
 export declare class PrepareDragSequenceExecution implements IExecution<PrepareDragSequenceRequest, void> {
     private readonly _mediator;
     private readonly _dragContext;
-    handle(request: PrepareDragSequenceRequest): void;
+    handle(_request: PrepareDragSequenceRequest): void;
     private _callPrepareDragSequence;
     static ɵfac: i0.ɵɵFactoryDeclaration<PrepareDragSequenceExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PrepareDragSequenceExecution>;

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

@@ -1,13 +1,10 @@
 import { AddDndToStoreExecution } from './add-dnd-to-store';
-import { EmitSelectionChangeEventExecution } from './emit-selection-change-event';
 import { RemoveDndFromStoreExecution } from './remove-dnd-from-store';
 import { PrepareDragSequenceExecution } from './prepare-drag-sequence';
-import { EndDragSequenceExecution } from './end-drag-sequence';
 import { InitializeDragSequenceExecution } from './initialize-drag-sequence';
 import { OnPointerMoveExecution } from './on-pointer-move';
 import { IsDragStarted } from './is-drag-started';
-import { StartDragSequenceExecution } from './start-drag-sequence';
 /**
  * Collection of all FDraggable feature executions.
  */
-export declare const F_DRAGGABLE_FEATURES: (typeof AddDndToStoreExecution | typeof EmitSelectionChangeEventExecution | typeof EndDragSequenceExecution | typeof OnPointerMoveExecution | typeof InitializeDragSequenceExecution | typeof PrepareDragSequenceExecution | typeof IsDragStarted | typeof StartDragSequenceExecution | typeof RemoveDndFromStoreExecution)[];
+export declare const F_DRAGGABLE_FEATURES: (typeof AddDndToStoreExecution | typeof OnPointerMoveExecution | typeof InitializeDragSequenceExecution | typeof PrepareDragSequenceExecution | typeof IsDragStarted | typeof RemoveDndFromStoreExecution)[];

package/domain/f-flow/calculate-flow-state/calculate-connections-state/calculate-connections-state-request.d.ts

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

package/domain/f-flow/calculate-flow-state/calculate-connections-state/calculate-connections-state.d.ts

@@ -0,0 +1,14 @@
+import { CalculateConnectionsStateRequest } from './calculate-connections-state-request';
+import { IExecution } from '@foblex/mediator';
+import { IFFlowStateConnection } from '../i-f-flow-state-connection';
+import * as i0 from "@angular/core";
+/**
+ * Execution that retrieves the current Flow state connections from the FComponentsStore.
+ */
+export declare class CalculateConnectionsState implements IExecution<CalculateConnectionsStateRequest, IFFlowStateConnection[]> {
+    private readonly _store;
+    handle(_request: CalculateConnectionsStateRequest): IFFlowStateConnection[];
+    private _mapToConnectionState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectionsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectionsState>;
+}

package/domain/f-flow/calculate-flow-state/calculate-connections-state/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-connections-state';
+export * from './calculate-connections-state-request';

package/domain/f-flow/calculate-flow-state/calculate-flow-state-request.d.ts

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

package/domain/f-flow/calculate-flow-state/calculate-flow-state.d.ts

@@ -0,0 +1,17 @@
+import { CalculateFlowStateRequest } from './calculate-flow-state-request';
+import { IExecution } from '@foblex/mediator';
+import { IFFlowState } from './i-f-flow-state';
+import * as i0 from "@angular/core";
+/**
+ * Execution that retrieves the current state of the Flow, including its position, scale, nodes, groups, and connections.
+ */
+export declare class CalculateFlowState implements IExecution<CalculateFlowStateRequest, IFFlowState> {
+    private readonly _mediator;
+    private readonly _store;
+    private get _canvas();
+    private get _transform();
+    private get _canvasPosition();
+    handle(_payload: CalculateFlowStateRequest): IFFlowState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateFlowState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateFlowState>;
+}

package/domain/f-flow/calculate-flow-state/calculate-nodes-state/calculate-nodes-state-request.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@angular/core';
+export declare class CalculateNodesStateRequest {
+    readonly component: Type<unknown>;
+    static readonly fToken: unique symbol;
+    constructor(component: Type<unknown>);
+}

package/domain/f-flow/calculate-flow-state/calculate-nodes-state/calculate-nodes-state.d.ts

@@ -0,0 +1,15 @@
+import { CalculateNodesStateRequest } from './calculate-nodes-state-request';
+import { IExecution } from '@foblex/mediator';
+import { IFFlowStateNode } from '../i-f-flow-state-node';
+import * as i0 from "@angular/core";
+/**
+ * Execution that retrieves the state of Flow nodes, including their position, size, inputs, outputs, and selection status.
+ */
+export declare class CalculateNodesState implements IExecution<CalculateNodesStateRequest, IFFlowStateNode[]> {
+    private readonly _store;
+    handle({ component }: CalculateNodesStateRequest): IFFlowStateNode[];
+    private _getOutputs;
+    private _getInputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodesState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodesState>;
+}

package/domain/f-flow/calculate-flow-state/calculate-nodes-state/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-nodes-state';
+export * from './calculate-nodes-state-request';

package/domain/f-flow/calculate-flow-state/i-f-flow-state-connection.d.ts

@@ -0,0 +1,13 @@
+import { EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType } from '../../../f-connection-v2';
+import { IPoint } from '@foblex/2d';
+export interface IFFlowStateConnection {
+    id: string;
+    fOutputId: string;
+    fInputId: string;
+    fType: EFConnectionType | string;
+    fBehavior: EFConnectionBehavior;
+    isSelected: boolean;
+    waypoints: IPoint[];
+    fInputSide: EFConnectionConnectableSide;
+    fOutputSide: EFConnectionConnectableSide;
+}

package/domain/f-flow/calculate-flow-state/i-f-flow-state-connector.d.ts

@@ -0,0 +1,5 @@
+import { EFConnectableSide } from '../../../f-connection-v2';
+export interface IFFlowStateConnector {
+    id: string;
+    fConnectableSide: EFConnectableSide;
+}

package/domain/f-flow/calculate-flow-state/index.d.ts

@@ -0,0 +1,9 @@
+export * from './calculate-connections-state';
+export * from './calculate-nodes-state';
+export * from './calculate-flow-state';
+export * from './calculate-flow-state-request';
+export * from './i-f-flow-state';
+export * from './i-f-flow-state-connection';
+export * from './i-f-flow-state-connector';
+export * from './i-f-flow-state-node';
+export * from './providers';

package/domain/f-flow/calculate-flow-state/providers.d.ts

@@ -0,0 +1,7 @@
+import { CalculateFlowState } from './calculate-flow-state';
+import { CalculateNodesState } from './calculate-nodes-state';
+import { CalculateConnectionsState } from './calculate-connections-state';
+/**
+ * Providers for retrieving the current Flow state, including nodes, groups, and connections.
+ */
+export declare const GET_FLOW_STATE_PROVIDERS: (typeof CalculateFlowState | typeof CalculateNodesState | typeof CalculateConnectionsState)[];

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

@@ -1,6 +1,5 @@
 export * from './add-flow-to-store';
 export * from './get-flow';
-export * from './get-flow-host-element';
-export * from './get-flow-state';
+export * from './calculate-flow-state';
 export * from './remove-flow-from-store';
 export * from './providers';

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

@@ -1,4 +1,3 @@
-import { GetFlowHostElementExecution } from './get-flow-host-element';
 import { AddFlowToStoreExecution } from './add-flow-to-store';
 import { RemoveFlowFromStoreExecution } from './remove-flow-from-store';
 import { GetFlowExecution } from './get-flow';
@@ -7,4 +6,4 @@ import { GetFlowExecution } from './get-flow';
  * This includes adding, retrieving, and removing the Flow,
  * as well as getting the Flow host element and its state.
  */
-export declare const F_FLOW_FEATURES: (typeof AddFlowToStoreExecution | typeof GetFlowExecution | typeof GetFlowHostElementExecution | typeof import("./get-flow-state").GetFlowStateExecution | typeof import("./get-flow-state").GetFlowStateNodesExecution | typeof import("./get-flow-state").GetFlowStateConnectionsExecution | typeof RemoveFlowFromStoreExecution)[];
+export declare const F_FLOW_FEATURES: (typeof AddFlowToStoreExecution | typeof GetFlowExecution | typeof import("./calculate-flow-state").CalculateFlowState | typeof import("./calculate-flow-state").CalculateNodesState | typeof import("./calculate-flow-state").CalculateConnectionsState | typeof RemoveFlowFromStoreExecution)[];

package/domain/f-node/add-node-to-store/add-node-to-store.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
  */
 export declare class AddNodeToStore implements IExecution<AddNodeToStoreRequest, void> {
     private readonly _store;
-    handle(request: AddNodeToStoreRequest): void;
+    handle({ nodeOrGroup }: AddNodeToStoreRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AddNodeToStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AddNodeToStore>;
 }

package/domain/f-node/calculate-connectors-connectable-sides/calculate-connectable-side-by-connected-positions/calculate-connectable-side-by-connected-positions.d.ts

@@ -1,6 +1,6 @@
 import { IExecution } from '@foblex/mediator';
 import { CalculateConnectableSideByConnectedPositionsRequest } from './calculate-connectable-side-by-connected-positions-request';
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 import * as i0 from "@angular/core";
 /**
  * Execution that calculates the connectable side for a connector

package/domain/f-node/calculate-connectors-connectable-sides/calculate-connectable-side-by-internal-position/calculate-connectable-side-by-internal-position.d.ts

@@ -1,7 +1,7 @@
 import { InjectionToken } from '@angular/core';
 import { IExecution } from '@foblex/mediator';
 import { CalculateConnectableSideByInternalPositionRequest } from './calculate-connectable-side-by-internal-position-request';
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 import * as i0 from "@angular/core";
 /**
  * Injection token for configuring the side detection tolerance (in pixels).

package/domain/f-node/calculate-connectors-connectable-sides/constants/calculatable-sides.d.ts

@@ -1,4 +1,4 @@
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 export declare const CALCULATABLE_SIDES: {
     calculate: EFConnectableSide[];
     calculate_horizontal: EFConnectableSide[];

package/domain/f-node/calculate-connectors-connectable-sides/models/t-calculate-mode.d.ts

@@ -1,2 +1,2 @@
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 export type TCalculateMode = EFConnectableSide.CALCULATE | EFConnectableSide.CALCULATE_HORIZONTAL | EFConnectableSide.CALCULATE_VERTICAL;

package/domain/f-node/calculate-connectors-connectable-sides/utils/determine-side.d.ts

@@ -2,7 +2,7 @@
  * Converts allowed sides array to a compact bit mask.
  * If not provided or empty -> all sides allowed.
  */
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 /**
  * Determines final side using ideal side first; if disallowed, picks best fallback.
  * Inputs are numbers to avoid object wrappers on hot path.

package/domain/f-node/calculate-connectors-connectable-sides/utils/is-calculate-mode.d.ts

@@ -1,4 +1,4 @@
-import { EFConnectableSide } from '../../../../f-connectors';
+import { EFConnectableSide } from '../../../../f-connection-v2';
 /**
  * Checks if the given side is one of the calculate modes.
  * @param side The connectable side to check.

package/domain/f-node/calculate-input-connections/calculate-input-connections.d.ts

@@ -1,6 +1,6 @@
 import { IExecution } from '@foblex/mediator';
 import { CalculateInputConnectionsRequest } from './calculate-input-connections-request';
-import { FConnectionBase } from '../../../f-connection';
+import { FConnectionBase } from '../../../f-connection-v2';
 import * as i0 from "@angular/core";
 /**
  * Execution that calculates input connections for a given FNode.

package/domain/f-node/calculate-output-connections/calculate-output-connections.d.ts

@@ -1,6 +1,6 @@
 import { IExecution } from '@foblex/mediator';
 import { CalculateOutputConnectionsRequest } from './calculate-output-connections-request';
-import { FConnectionBase } from '../../../f-connection';
+import { FConnectionBase } from '../../../f-connection-v2';
 import * as i0 from "@angular/core";
 /**
  * Execution that calculates output connections for a given FNode.

package/domain/f-selection/calculate-selectable-items/calculate-selectable-items-request.d.ts

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

package/domain/f-selection/calculate-selectable-items/calculate-selectable-items.d.ts

@@ -0,0 +1,28 @@
+import { ICanBeSelectedElementAndRect } from './i-can-be-selected-element-and-rect';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+/**
+ * Execution that retrieves elements that can be selected in the Flow, along with their bounding rectangles.
+ * It filters out elements that are already selected in the FDraggableDataContext.
+ */
+export declare class CalculateSelectableItems implements IExecution<void, ICanBeSelectedElementAndRect[]> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _nodes();
+    private get _connections();
+    private get _transform();
+    handle(): ICanBeSelectedElementAndRect[];
+    /**
+     * Retrieves nodes with their bounding rectangles that can be selected.
+     * @private
+     */
+    private _nodeRects;
+    /**
+     * Retrieves connections with their bounding rectangles that can be selected.
+     * @private
+     */
+    private _connectionRects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateSelectableItems, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateSelectableItems>;
+}

package/domain/f-selection/calculate-selectable-items/index.d.ts

@@ -0,0 +1,3 @@
+export * from './calculate-selectable-items';
+export * from './calculate-selectable-items-request';
+export * from './i-can-be-selected-element-and-rect';

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

@@ -1,5 +1,5 @@
 export * from './clear-selection';
-export * from './get-can-be-selected-items';
+export * from './calculate-selectable-items';
 export * from './get-current-selection';
 export * from './select';
 export * from './select-all';

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

@@ -1,10 +1,10 @@
 import { ClearSelectionExecution } from './clear-selection';
 import { GetCurrentSelectionExecution } from './get-current-selection';
 import { SelectExecution } from './select';
-import { SelectAllExecution } from './select-all';
-import { SelectAndUpdateNodeLayerExecution } from './select-and-update-node-layer';
-import { GetCanBeSelectedItemsExecution } from './get-can-be-selected-items';
+import { SelectAll } from './select-all';
+import { SelectAndUpdateNodeLayer } from './select-and-update-node-layer';
+import { CalculateSelectableItems } from './calculate-selectable-items';
 /**
  * This module provides a collection of executions related to selection features in the FFlow domain.
  */
-export declare const F_SELECTION_FEATURES: (typeof ClearSelectionExecution | typeof GetCanBeSelectedItemsExecution | typeof GetCurrentSelectionExecution | typeof SelectExecution | typeof SelectAllExecution | typeof SelectAndUpdateNodeLayerExecution)[];
+export declare const F_SELECTION_FEATURES: (typeof ClearSelectionExecution | typeof CalculateSelectableItems | typeof GetCurrentSelectionExecution | typeof SelectExecution | typeof SelectAll | typeof SelectAndUpdateNodeLayer)[];

package/domain/f-selection/select-all/index.d.ts

@@ -1,2 +1,2 @@
-export * from './select-all.execution';
-export * from './select-all.request';
+export * from './select-all';
+export * from './select-all-request';

package/domain/f-selection/select-all/select-all.d.ts

@@ -0,0 +1,14 @@
+import { SelectAllRequest } from './select-all-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+/**
+ * Execution that selects all components in the FComponentsStore.
+ * It marks all nodes and connections as selected and updates the selected items in the FDraggableDataContext.
+ */
+export declare class SelectAll implements IExecution<SelectAllRequest, void> {
+    private readonly _dragSession;
+    private readonly _store;
+    handle(_request: SelectAllRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAll, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectAll>;
+}

package/domain/f-selection/select-and-update-node-layer/index.d.ts

@@ -1,2 +1,2 @@
-export * from './select-and-update-node-layer.execution';
-export * from './select-and-update-node-layer.request';
+export * from './select-and-update-node-layer';
+export * from './select-and-update-node-layer-request';

package/domain/f-selection/select-and-update-node-layer/select-and-update-node-layer.d.ts

@@ -0,0 +1,16 @@
+import { IHandler } from '@foblex/mediator';
+import { SelectAndUpdateNodeLayerRequest } from './select-and-update-node-layer-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that selects a node and updates its layer along with its children.
+ * It checks if the node is already selected, and if not, it marks it as selected
+ * and updates the layers of the node and its children.
+ */
+export declare class SelectAndUpdateNodeLayer implements IHandler<SelectAndUpdateNodeLayerRequest, void> {
+    private readonly _dragSession;
+    private readonly _mediator;
+    handle({ nodeOrGroup }: SelectAndUpdateNodeLayerRequest): void;
+    private _selectNodeIfNotSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAndUpdateNodeLayer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectAndUpdateNodeLayer>;
+}

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

@@ -1,6 +1,3 @@
-export * from './add-zoom-to-store';
-export * from './remove-zoom-from-store';
 export * from './reset-zoom';
 export * from './set-zoom';
-export * from './f-zoom-tag';
 export * from './providers';

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

@@ -1,10 +1,8 @@
-import { AddZoomToStoreExecution } from './add-zoom-to-store';
-import { RemoveZoomFromStoreExecution } from './remove-zoom-from-store';
-import { SetZoomExecution } from './set-zoom';
-import { ResetZoomExecution } from './reset-zoom';
+import { SetZoom } from './set-zoom';
+import { ResetZoom } from './reset-zoom';
 /**
  * Collection of all FZoom feature executions.
  * These executions handle the addition, removal, and resetting of zoom levels
  * in the FComponentsStore.
  */
-export declare const F_ZOOM_FEATURES: (typeof AddZoomToStoreExecution | typeof RemoveZoomFromStoreExecution | typeof ResetZoomExecution | typeof SetZoomExecution)[];
+export declare const F_ZOOM_FEATURES: (typeof ResetZoom | typeof SetZoom)[];

package/domain/f-zoom/reset-zoom/index.d.ts

@@ -1,2 +1,2 @@
-export * from './reset-zoom.execution';
+export * from './reset-zoom';
 export * from './reset-zoom-request';

package/domain/f-zoom/reset-zoom/reset-zoom.d.ts

@@ -0,0 +1,13 @@
+import { IExecution } from '@foblex/mediator';
+import { ResetZoomRequest } from './reset-zoom-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that resets the zoom level of the FCanvas.
+ */
+export declare class ResetZoom implements IExecution<ResetZoomRequest, void> {
+    private readonly _store;
+    private get _canvas();
+    handle(_request: ResetZoomRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResetZoom, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResetZoom>;
+}

package/domain/f-zoom/set-zoom/index.d.ts

@@ -1,2 +1,2 @@
-export * from './set-zoom.execution';
+export * from './set-zoom';
 export * from './set-zoom-request';

package/domain/f-zoom/set-zoom/set-zoom.d.ts

@@ -0,0 +1,20 @@
+import { IExecution } from '@foblex/mediator';
+import { SetZoomRequest } from './set-zoom-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that sets the zoom level of the FCanvas based on the provided request.
+ * It adjusts the zoom level by a specified step and direction, ensuring it stays within defined limits.
+ */
+export declare class SetZoom implements IExecution<SetZoomRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private get _flowHost();
+    private get _canvas();
+    private get _zoomComponent();
+    private get _isDragStarted();
+    handle(request: SetZoomRequest): void;
+    private _clamp;
+    private _castPositionToFlow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetZoom, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SetZoom>;
+}

package/domain/get-normalized-element-rect/get-normalized-element-rect-request.d.ts

@@ -1,5 +1,5 @@
 export declare class GetNormalizedElementRectRequest {
-    element: HTMLElement | SVGElement;
+    readonly element: HTMLElement | SVGElement;
     static readonly fToken: unique symbol;
     constructor(element: HTMLElement | SVGElement);
 }