@foblex/flow 18.0.0 → 18.1.1

package/domain/f-background/add-pattern-to-background/add-pattern-to-background.d.ts

@@ -1,4 +1,4 @@
-import { AddPatternToBackgroundRequest } from './add-pattern-to-background.request';
+import { AddPatternToBackgroundRequest } from './add-pattern-to-background-request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 /**

package/domain/f-background/add-pattern-to-background/index.d.ts

@@ -1,2 +1,2 @@
 export * from './add-pattern-to-background';
-export * from './add-pattern-to-background.request';
+export * from './add-pattern-to-background-request';

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

@@ -1,5 +1,3 @@
-export * from './add-background-to-store';
 export * from './add-pattern-to-background';
-export * from './remove-background-from-store';
 export * from './set-background-transform';
 export * from './providers';

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

@@ -1,9 +1,7 @@
 import { AddPatternToBackground } from './add-pattern-to-background';
-import { AddBackgroundToStoreExecution } from './add-background-to-store';
-import { RemoveBackgroundFromStoreExecution } from './remove-background-from-store';
-import { SetBackgroundTransformExecution } from './set-background-transform';
+import { SetBackgroundTransform } from './set-background-transform';
 /**
  * This file exports all the background-related features for the F-Flow domain.
  * It includes executions for adding, removing, and setting the background in the FComponentsStore.
  */
-export declare const F_BACKGROUND_FEATURES: (typeof AddBackgroundToStoreExecution | typeof AddPatternToBackground | typeof RemoveBackgroundFromStoreExecution | typeof SetBackgroundTransformExecution)[];
+export declare const F_BACKGROUND_FEATURES: (typeof AddPatternToBackground | typeof SetBackgroundTransform)[];

package/domain/f-background/set-background-transform/index.d.ts

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

package/domain/f-background/set-background-transform/set-background-transform.d.ts

@@ -0,0 +1,12 @@
+import { IExecution } from '@foblex/mediator';
+import { SetBackgroundTransformRequest } from './set-background-transform-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that sets the transform for the background when canvas is transformed.
+ */
+export declare class SetBackgroundTransform implements IExecution<SetBackgroundTransformRequest, void> {
+    private readonly _store;
+    handle(request: SetBackgroundTransformRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetBackgroundTransform, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SetBackgroundTransform>;
+}

package/domain/f-canvas/center-group-or-node/center-group-or-node.execution.d.ts

@@ -7,13 +7,12 @@ import * as i0 from "@angular/core";
  */
 export declare class CenterGroupOrNodeExecution implements IExecution<CenterGroupOrNodeRequest, void> {
     private readonly _store;
-    private readonly _fMediator;
-    private get transform();
-    handle(request: CenterGroupOrNodeRequest): void;
+    private readonly _mediator;
+    private get _transform();
+    handle({ id, animated }: CenterGroupOrNodeRequest): void;
     toCenter(fNodeRect: IRect, fFlowRect: IRect, position: IPoint): void;
-    private getNode;
-    private getNodeRect;
-    private getFlowRect;
+    private _getNodeRect;
+    private _getFlowRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<CenterGroupOrNodeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CenterGroupOrNodeExecution>;
 }

package/domain/f-canvas/fit-to-flow/fit-to-flow.execution.d.ts

@@ -7,11 +7,11 @@ import * as i0 from "@angular/core";
  */
 export declare class FitToFlowExecution implements IExecution<FitToFlowRequest, void> {
     private readonly _store;
-    private get transform();
+    private get _transform();
     private _fMediator;
     handle(request: FitToFlowRequest): void;
     fitToParent(rect: IRect, parentRect: IRect, points: IPoint[], toCenter: IPoint): void;
-    private getZeroPositionWithoutScale;
+    private _getZeroPositionWithoutScale;
     static ɵfac: i0.ɵɵFactoryDeclaration<FitToFlowExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FitToFlowExecution>;
 }

package/domain/f-canvas/remove-canvas-from-store/remove-canvas-from-store.execution.d.ts

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

package/domain/f-connection/add-connection-for-create-to-store/add-connection-for-create-to-store-request.d.ts

@@ -1,6 +1,6 @@
-import { FConnectionBase } from '../../../f-connection-v2';
+import { FConnectionForCreateComponent } from '../../../f-connection';
 export declare class AddConnectionForCreateToStoreRequest {
-    readonly connection: FConnectionBase;
+    readonly connection: FConnectionForCreateComponent;
     static readonly fToken: unique symbol;
-    constructor(connection: FConnectionBase);
+    constructor(connection: FConnectionForCreateComponent);
 }

package/domain/f-connection/add-connection-marker-to-store/add-connection-marker-to-store-request.d.ts

@@ -1,6 +1,6 @@
 import { FConnectionMarkerBase } from '../../../f-connection-v2';
 export declare class AddConnectionMarkerToStoreRequest {
-    readonly component: FConnectionMarkerBase;
+    readonly instance: FConnectionMarkerBase;
     static readonly fToken: unique symbol;
-    constructor(component: FConnectionMarkerBase);
+    constructor(instance: FConnectionMarkerBase);
 }

package/domain/f-connection/add-connection-marker-to-store/add-connection-marker-to-store.d.ts

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

package/domain/f-connection/add-snap-connection-to-store/add-snap-connection-to-store-request.d.ts

@@ -1,6 +1,6 @@
-import { FConnectionBase } from '../../../f-connection-v2';
+import { FSnapConnectionComponent } from '../../../f-connection';
 export declare class AddSnapConnectionToStoreRequest {
-    readonly connection: FConnectionBase;
+    readonly connection: FSnapConnectionComponent;
     static readonly fToken: unique symbol;
-    constructor(connection: FConnectionBase);
+    constructor(connection: FSnapConnectionComponent);
 }

package/domain/f-connection/redraw-connections/redraw-connections.d.ts

@@ -11,8 +11,6 @@ export declare class RedrawConnections implements IExecution<RedrawConnectionsRe
     private readonly _store;
     private readonly _connectionBehaviour;
     handle(_request: RedrawConnectionsRequest): void;
-    private _getSourceConnector;
-    private _getTargetConnector;
     private _resetConnectors;
     private _setupConnection;
     private _calculateConnectionLine;

package/domain/f-connection/remove-connection-from-store/remove-connection-from-store.d.ts

@@ -1,11 +1,8 @@
 import { IExecution } from '@foblex/mediator';
 import { RemoveConnectionFromStoreRequest } from './remove-connection-from-store-request';
 import * as i0 from "@angular/core";
-/**
- * Execution that removes a connection from the FComponentsStore.
- */
 export declare class RemoveConnectionFromStore implements IExecution<RemoveConnectionFromStoreRequest, void> {
-    private _store;
+    private readonly _store;
     handle({ connection }: RemoveConnectionFromStoreRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionFromStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionFromStore>;

package/domain/f-connection/remove-connection-marker-from-store/remove-connection-marker-from-store-request.d.ts

@@ -1,6 +1,6 @@
 import { FConnectionMarkerBase } from '../../../f-connection-v2';
 export declare class RemoveConnectionMarkerFromStoreRequest {
-    readonly component: FConnectionMarkerBase;
+    readonly instance: FConnectionMarkerBase;
     static readonly fToken: unique symbol;
-    constructor(component: FConnectionMarkerBase);
+    constructor(instance: FConnectionMarkerBase);
 }

package/domain/f-connection/remove-connection-marker-from-store/remove-connection-marker-from-store.d.ts

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

package/domain/f-connection/remove-connection-waypoint/remove-connection-waypoint.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare class RemoveConnectionWaypoint implements IExecution<RemoveConnectionWaypointRequest, void> {
     private readonly _store;
     handle({ waypointIndex, connectionId }: RemoveConnectionWaypointRequest): void;
-    private _findConnection;
     private _changeEvent;
     static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionWaypoint, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionWaypoint>;

package/domain/f-connectors/add-connector-to-store/add-connector-to-store-request.d.ts

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

package/domain/f-connectors/add-connector-to-store/add-connector-to-store.d.ts

@@ -0,0 +1,15 @@
+import { IExecution } from '@foblex/mediator';
+import { AddConnectorToStoreRequest } from './add-connector-to-store-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that adds an InputConnector to the FComponentsStore.
+ */
+export declare class AddConnectorToStore implements IExecution<AddConnectorToStoreRequest, void> {
+    private readonly _store;
+    handle({ instance }: AddConnectorToStoreRequest): void;
+    private _addInput;
+    private _addOutput;
+    private _addOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddConnectorToStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddConnectorToStore>;
+}

package/domain/f-connectors/add-connector-to-store/index.d.ts

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

package/domain/f-connectors/calculate-closest-connector/calculate-closest-connector-request.d.ts

@@ -1,8 +1,8 @@
 import { IPoint } from '@foblex/2d';
-import { IConnectorAndRect } from '../index';
+import { IConnectorRectRef } from '../index';
 export declare class CalculateClosestConnectorRequest {
     readonly position: IPoint;
-    readonly connectors: IConnectorAndRect[];
+    readonly connectorRefs: IConnectorRectRef[];
     static readonly fToken: unique symbol;
-    constructor(position: IPoint, connectors: IConnectorAndRect[]);
+    constructor(position: IPoint, connectorRefs: IConnectorRectRef[]);
 }

package/domain/f-connectors/calculate-closest-connector/calculate-closest-connector.d.ts

@@ -1,15 +1,13 @@
 import { CalculateClosestConnectorRequest } from './calculate-closest-connector-request';
 import { IExecution } from '@foblex/mediator';
-import { IClosestConnector } from '../i-closest-connector';
+import { IClosestConnectorRef } from '../i-closest-connector-ref';
 import * as i0 from "@angular/core";
 /**
- * Execution that finds the closest connector to a given point.
- * It calculates the distance from the point to each connector's rectangle
- * and returns the closest one along with its distance.
+ * Finds the closest connector rect to the given point.
  */
-export declare class CalculateClosestConnector implements IExecution<CalculateClosestConnectorRequest, IClosestConnector | undefined> {
-    handle({ position, connectors, }: CalculateClosestConnectorRequest): IClosestConnector | undefined;
-    private _distanceToRectangle;
+export declare class CalculateClosestConnector implements IExecution<CalculateClosestConnectorRequest, IClosestConnectorRef | undefined> {
+    handle({ position, connectorRefs, }: CalculateClosestConnectorRequest): IClosestConnectorRef | undefined;
+    private _distanceToRect;
     private _clamp;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateClosestConnector, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateClosestConnector>;

package/domain/f-connectors/calculate-source-connectors-to-connect/calculate-source-connectors-to-connect-request.d.ts

@@ -1,8 +1,8 @@
 import { FNodeInputBase } from '../../../f-connectors';
 import { IPoint } from '@foblex/2d';
 export declare class CalculateSourceConnectorsToConnectRequest {
-    readonly targetConnector: FNodeInputBase;
-    readonly pointerPosition: IPoint;
+    readonly target: FNodeInputBase;
+    readonly pointer: IPoint;
     static readonly fToken: unique symbol;
-    constructor(targetConnector: FNodeInputBase, pointerPosition: IPoint);
+    constructor(target: FNodeInputBase, pointer: IPoint);
 }

package/domain/f-connectors/calculate-source-connectors-to-connect/calculate-source-connectors-to-connect.d.ts

@@ -1,19 +1,19 @@
 import { CalculateSourceConnectorsToConnectRequest } from './calculate-source-connectors-to-connect-request';
 import { IExecution } from '@foblex/mediator';
-import { IConnectorAndRect } from '../i-connector-and-rect';
+import { IConnectorRectRef } from '../i-connector-rect-ref';
 import * as i0 from "@angular/core";
 /**
- * Execution that retrieves all source connectors that can be connected to a given target connector,
- * along with their rectangles.
- * Source - Output or Outlet connectors.
+ * Returns all source connectors (outputs/outlets) that can connect to the given target input,
+ * along with their rect references.
  */
-export declare class CalculateSourceConnectorsToConnect implements IExecution<CalculateSourceConnectorsToConnectRequest, IConnectorAndRect[]> {
+export declare class CalculateSourceConnectorsToConnect implements IExecution<CalculateSourceConnectorsToConnectRequest, IConnectorRectRef[]> {
     private readonly _mediator;
     private readonly _store;
-    private get _sourceConnectors();
-    handle({ targetConnector, pointerPosition, }: CalculateSourceConnectorsToConnectRequest): IConnectorAndRect[];
+    private get _sources();
+    handle({ target, pointer, }: CalculateSourceConnectorsToConnectRequest): IConnectorRectRef[];
     private _getConnectableSources;
-    private _calculateConnectableSides;
+    private _scheduleApplyCalculatedSides;
+    private _applyCalculatedConnectableSides;
     /** Delegates to the connected-positions calculation execution. */
     private _calculateByConnectedPositions;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateSourceConnectorsToConnect, never>;

package/domain/f-connectors/calculate-target-connectors-to-connect/calculate-target-connectors-to-connect-request.d.ts

@@ -1,8 +1,8 @@
 import { FNodeOutletBase, FNodeOutputBase } from '../../../f-connectors';
 import { IPoint } from '@foblex/2d';
 export declare class CalculateTargetConnectorsToConnectRequest {
-    readonly sourceConnector: FNodeOutputBase | FNodeOutletBase;
-    readonly pointerPosition: IPoint;
+    readonly source: FNodeOutputBase | FNodeOutletBase;
+    readonly pointer: IPoint;
     static readonly fToken: unique symbol;
-    constructor(sourceConnector: FNodeOutputBase | FNodeOutletBase, pointerPosition: IPoint);
+    constructor(source: FNodeOutputBase | FNodeOutletBase, pointer: IPoint);
 }

package/domain/f-connectors/calculate-target-connectors-to-connect/calculate-target-connectors-to-connect.d.ts

@@ -1,18 +1,19 @@
 import { CalculateTargetConnectorsToConnectRequest } from './calculate-target-connectors-to-connect-request';
 import { IExecution } from '@foblex/mediator';
-import { IConnectorAndRect } from '../i-connector-and-rect';
+import { IConnectorRectRef } from '../i-connector-rect-ref';
 import * as i0 from "@angular/core";
 /**
- * Execution that retrieves all input connectors that can be connected to a given output or outlet connector,
+ * Returns all input connectors that can be connected to the given source (output or outlet),
+ * along with their rect references.
  */
-export declare class CalculateTargetConnectorsToConnect implements IExecution<CalculateTargetConnectorsToConnectRequest, IConnectorAndRect[]> {
+export declare class CalculateTargetConnectorsToConnect implements IExecution<CalculateTargetConnectorsToConnectRequest, IConnectorRectRef[]> {
     private readonly _mediator;
     private readonly _store;
-    private get _targetConnectors();
-    handle({ sourceConnector, pointerPosition, }: CalculateTargetConnectorsToConnectRequest): IConnectorAndRect[];
-    private _getCanBeConnectedInputs;
-    private _filterSelfConnectable;
-    private _calculateConnectableSides;
+    private get _targets();
+    handle({ source, pointer, }: CalculateTargetConnectorsToConnectRequest): IConnectorRectRef[];
+    private _getConnectableTargets;
+    private _scheduleApplyCalculatedSides;
+    private _applyCalculatedConnectableSides;
     /** Delegates to the connected-positions calculation execution. */
     private _calculateByConnectedPositions;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateTargetConnectorsToConnect, never>;

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/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/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 './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("./calculate-flow-state").CalculateFlowState | typeof import("./calculate-flow-state").CalculateNodesState | typeof import("./calculate-flow-state").CalculateConnectionsState | 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-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 { 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 CalculateSelectableItems | 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>;
+}