@foblex/flow 17.8.4 → 17.8.6

package/domain/drag-rect-cache.d.ts

@@ -0,0 +1,8 @@
+import { IRect } from '@foblex/2d';
+export declare class DragRectCache {
+    private static _cache;
+    static fromElement(element: HTMLElement | SVGElement): IRect;
+    static set(element: HTMLElement | SVGElement): void;
+    static invalidate(element: HTMLElement | SVGElement): void;
+    static invalidateAll(): void;
+}

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

@@ -6,4 +6,4 @@ import { SetBackgroundTransformExecution } 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 AddPatternToBackgroundExecution | typeof RemoveBackgroundFromStoreExecution | typeof SetBackgroundTransformExecution)[];
+export declare const F_BACKGROUND_FEATURES: (typeof AddPatternToBackgroundExecution | typeof AddBackgroundToStoreExecution | typeof RemoveBackgroundFromStoreExecution | typeof SetBackgroundTransformExecution)[];

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

@@ -12,4 +12,4 @@ import { RedrawCanvasWithAnimationExecution } from './redraw-canvas-with-animati
 /**
  * This file exports all the canvas-related executions that can be used in the FCanvas feature.
  */
-export declare const F_CANVAS_FEATURES: (typeof AddCanvasToStoreExecution | typeof CenterGroupOrNodeExecution | typeof FitToFlowExecution | typeof GetCanvasExecution | typeof InputCanvasPositionExecution | typeof InputCanvasScaleExecution | typeof RedrawCanvasWithAnimationExecution | typeof RemoveCanvasFromStoreExecution | typeof ResetScaleExecution | typeof ResetScaleAndCenterExecution | typeof UpdateScaleExecution)[];
+export declare const F_CANVAS_FEATURES: (typeof ResetScaleAndCenterExecution | typeof FitToFlowExecution | typeof CenterGroupOrNodeExecution | typeof AddCanvasToStoreExecution | typeof GetCanvasExecution | typeof InputCanvasPositionExecution | typeof InputCanvasScaleExecution | typeof RedrawCanvasWithAnimationExecution | typeof RemoveCanvasFromStoreExecution | typeof ResetScaleExecution | typeof UpdateScaleExecution)[];

package/domain/f-connection/calculate-connection-line-by-behavior/calculate-connection-line-by-behavior-request.d.ts

@@ -1,12 +1,12 @@
-import { EFConnectionBehavior } from '../../../f-connection';
+import { FConnectionBase } from '../../../f-connection';
 import { EFConnectableSide } from '../../../f-connectors';
 import { IRoundedRect } from '@foblex/2d';
 export declare class CalculateConnectionLineByBehaviorRequest {
-    sourceRect: IRoundedRect;
-    targetRect: IRoundedRect;
-    behavior: EFConnectionBehavior | string;
-    sourceConnectableSide: EFConnectableSide;
-    targetConnectableSide: EFConnectableSide;
+    readonly sourceRect: IRoundedRect;
+    readonly targetRect: IRoundedRect;
+    readonly connection: FConnectionBase;
+    readonly sourceConnectableSide: EFConnectableSide;
+    readonly targetConnectableSide: EFConnectableSide;
     static readonly fToken: unique symbol;
-    constructor(sourceRect: IRoundedRect, targetRect: IRoundedRect, behavior: EFConnectionBehavior | string, sourceConnectableSide: EFConnectableSide, targetConnectableSide: EFConnectableSide);
+    constructor(sourceRect: IRoundedRect, targetRect: IRoundedRect, connection: FConnectionBase, sourceConnectableSide: EFConnectableSide, targetConnectableSide: EFConnectableSide);
 }

package/domain/f-connection/calculate-connection-line-by-behavior/calculate-connection-line-by-behavior.d.ts

@@ -3,11 +3,45 @@ import { IExecution } from '@foblex/mediator';
 import { ILine } from '@foblex/2d';
 import * as i0 from "@angular/core";
 /**
- * Execution that calculates the connection line based on the behavior.
+ * Calculates connection lines based on behavior rules.
+ * It determines which sides of the source and target should connect,
+ * then delegates to a registered behavior handler.
  */
 export declare class CalculateConnectionLineByBehavior implements IExecution<CalculateConnectionLineByBehaviorRequest, ILine> {
-    private _handlers;
-    handle(payload: CalculateConnectionLineByBehaviorRequest): ILine;
+    /**
+     * Main execution entry point.
+     *
+     * @param request The request containing source, target, and connection details.
+     * @returns A calculated connection line (ILine).
+     */
+    handle(request: CalculateConnectionLineByBehaviorRequest): ILine;
+    /**
+     * Computes the directional deltas between two rectangles.
+     */
+    private _calculateDirectionalVectors;
+    /**
+     * Determines the side for the source element.
+     */
+    private _determineSourceSide;
+    /**
+     * Determines the side for the target element.
+     */
+    private _determineTargetSide;
+    /**
+     * Resolves which side of a shape to connect to based on direction, fallback, and connection mode.
+     *
+     * @param requestedSide The side mode (e.g. CALCULATE, CALCULATE_HORIZONTAL, FIXED, etc.).
+     * @param deltaX Difference in X between source and target.
+     * @param deltaY Difference in Y between source and target.
+     * @param fallbackSide The default fallback side if calculation is ambiguous.
+     */
+    private _resolveConnectableSide;
+    /**
+     * Returns the appropriate handler for the given connection behavior.
+     *
+     * @throws Error if no handler is registered for the behavior.
+     */
+    private _getBehaviorHandler;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectionLineByBehavior, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectionLineByBehavior>;
 }

package/domain/f-connection/calculate-connection-line-by-behavior/index.d.ts

@@ -1,5 +1,6 @@
 export * from './calculate-connection-line-by-behavior';
 export * from './calculate-connection-line-by-behavior-request';
-export * from './fixed-center-behavior';
-export * from './fixed-outbound-behavior';
-export * from './floating-behavior';
+export * from './models/calculate-behavior-request';
+export * from './utils/fixed-center-behavior';
+export * from './utils/fixed-outbound-behavior';
+export * from './utils/floating-behavior';

package/domain/f-connection/calculate-connection-line-by-behavior/models/calculate-behavior-request.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { EFConnectableSide } from '../../../../f-connectors';
+export interface CalculateBehaviorRequest {
+    sourceRect: IRoundedRect;
+    targetRect: IRoundedRect;
+    sourceConnectableSide: EFConnectableSide;
+    targetConnectableSide: EFConnectableSide;
+}

package/domain/f-connection/calculate-connection-line-by-behavior/{fixed-center-behavior.d.ts → utils/fixed-center-behavior.d.ts}

@@ -1,8 +1,8 @@
 import { ILine } from '@foblex/2d';
-import { CalculateConnectionLineByBehaviorRequest } from './calculate-connection-line-by-behavior-request';
+import { CalculateBehaviorRequest } from '../models/calculate-behavior-request';
 /**
  * Fixed center behavior calculates the connection line
  * It constructs a line between the gravity centers of the connector rectangles
  * @param payload
  */
-export declare function fixedCenterBehavior({ sourceRect, targetRect, }: CalculateConnectionLineByBehaviorRequest): ILine;
+export declare function fixedCenterBehavior({ sourceRect, targetRect }: CalculateBehaviorRequest): ILine;

package/domain/f-connection/calculate-connection-line-by-behavior/{fixed-outbound-behavior.d.ts → utils/fixed-outbound-behavior.d.ts}

@@ -1,8 +1,8 @@
 import { ILine } from '@foblex/2d';
-import { CalculateConnectionLineByBehaviorRequest } from './calculate-connection-line-by-behavior-request';
+import { CalculateBehaviorRequest } from '../models/calculate-behavior-request';
 /**
  * Fixed outbound behavior calculates the connection line
  * It constructs a line between the specified sides of the output and input rectangles
  * @param payload
  */
-export declare function fixedOutboundBehavior({ sourceRect, sourceConnectableSide, targetRect, targetConnectableSide, }: CalculateConnectionLineByBehaviorRequest): ILine;
+export declare function fixedOutboundBehavior({ sourceRect, sourceConnectableSide, targetRect, targetConnectableSide, }: CalculateBehaviorRequest): ILine;

package/domain/f-connection/calculate-connection-line-by-behavior/{floating-behavior.d.ts → utils/floating-behavior.d.ts}

@@ -1,8 +1,8 @@
 import { ILine } from '@foblex/2d';
-import { CalculateConnectionLineByBehaviorRequest } from './calculate-connection-line-by-behavior-request';
+import { CalculateBehaviorRequest } from '../models/calculate-behavior-request';
 /**
  * Floating behavior calculates the connection line
  * It constructs a line between the intersections of the connectors rectangles and line from the centers of the connector rectangles
  * @param payload
  */
-export declare function floatingBehavior({ sourceRect, targetRect, }: CalculateConnectionLineByBehaviorRequest): ILine;
+export declare function floatingBehavior({ sourceRect, targetRect }: CalculateBehaviorRequest): ILine;

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

@@ -7,9 +7,9 @@ import { RemoveConnectionFromStoreExecution } from './remove-connection-from-sto
 import { RemoveSnapConnectionFromStoreExecution } from './remove-snap-connection-from-store';
 import { AddConnectionMarkerToStoreExecution } from './add-connection-marker-to-store';
 import { RemoveConnectionMarkerFromStoreExecution } from './remove-connection-marker-from-store';
-import { RedrawConnectionsExecution } from './redraw-connections';
+import { RedrawConnections } from './redraw-connections';
 import { CalculateConnectionLineByBehavior } from './calculate-connection-line-by-behavior';
 /**
  * This file exports all the connection-related features for the F-Flow domain.
  */
-export declare const F_CONNECTION_FEATURES: (typeof AddConnectionForCreateToStoreExecution | typeof AddConnectionMarkerToStoreExecution | typeof AddConnectionToStoreExecution | typeof AddSnapConnectionToStoreExecution | typeof CreateConnectionMarkersExecution | typeof CalculateConnectionLineByBehavior | typeof RedrawConnectionsExecution | typeof RemoveConnectionForCreateFromStoreExecution | typeof RemoveConnectionFromStoreExecution | typeof RemoveConnectionMarkerFromStoreExecution | typeof RemoveSnapConnectionFromStoreExecution)[];
+export declare const F_CONNECTION_FEATURES: (typeof RemoveConnectionFromStoreExecution | typeof AddConnectionForCreateToStoreExecution | typeof AddConnectionMarkerToStoreExecution | typeof AddConnectionToStoreExecution | typeof AddSnapConnectionToStoreExecution | typeof CreateConnectionMarkersExecution | typeof CalculateConnectionLineByBehavior | typeof RedrawConnections | typeof RemoveConnectionForCreateFromStoreExecution | typeof RemoveConnectionMarkerFromStoreExecution | typeof RemoveSnapConnectionFromStoreExecution)[];

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

@@ -1,2 +1,2 @@
-export * from './redraw-connections.execution';
+export * from './redraw-connections';
 export * from './redraw-connections-request';

package/domain/f-connection/redraw-connections/{redraw-connections.execution.d.ts → redraw-connections.d.ts}

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
  * It resets connectors, sets markers for temporary and snap connections,
  * and sets up connections based on the stored outputs and inputs.
  */
-export declare class RedrawConnectionsExecution implements IExecution<RedrawConnectionsRequest, void> {
+export declare class RedrawConnections implements IExecution<RedrawConnectionsRequest, void> {
     private readonly _mediator;
     private readonly _store;
     handle(_request: RedrawConnectionsRequest): void;
@@ -16,6 +16,6 @@ export declare class RedrawConnectionsExecution implements IExecution<RedrawConn
     private _setupConnection;
     private _getLine;
     private _setMarkers;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RedrawConnectionsExecution, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RedrawConnectionsExecution>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedrawConnections, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RedrawConnections>;
 }

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

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

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

@@ -0,0 +1,21 @@
+import { CalculateSourceConnectorsToConnectRequest } from './calculate-source-connectors-to-connect-request';
+import { IExecution } from '@foblex/mediator';
+import { IConnectorAndRect } from '../i-connector-and-rect';
+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.
+ */
+export declare class CalculateSourceConnectorsToConnect implements IExecution<CalculateSourceConnectorsToConnectRequest, IConnectorAndRect[]> {
+    private readonly _mediator;
+    private readonly _store;
+    private get _sourceConnectors();
+    handle({ targetConnector, pointerPosition, }: CalculateSourceConnectorsToConnectRequest): IConnectorAndRect[];
+    private _getConnectableSources;
+    private _calculateConnectableSides;
+    /** Delegates to the connected-positions calculation execution. */
+    private _calculateByConnectedPositions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateSourceConnectorsToConnect, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateSourceConnectorsToConnect>;
+}

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

@@ -0,0 +1,2 @@
+export * from './calculate-source-connectors-to-connect-request';
+export * from './calculate-source-connectors-to-connect';

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './calculate-target-connectors-to-connect-request';
+export * from './calculate-target-connectors-to-connect';

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

@@ -3,8 +3,8 @@ export * from './add-outlet-to-store';
 export * from './add-output-to-store';
 export * from './calculate-closest-connector';
 export * from './find-connectable-connector-using-priority-and-position';
-export * from './get-all-can-be-connected-inputs-and-rects';
-export * from './get-all-can-be-connected-source-connectors-and-rects';
+export * from './calculate-target-connectors-to-connect';
+export * from './calculate-source-connectors-to-connect';
 export * from './get-connector-and-rect';
 export * from './mark-connectable-connectors';
 export * from './remove-input-from-store';

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

@@ -6,9 +6,9 @@ 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 { GetAllCanBeConnectedInputsAndRectsExecution } from './get-all-can-be-connected-inputs-and-rects';
+import { CalculateTargetConnectorsToConnect } from './calculate-target-connectors-to-connect';
 import { GetConnectorAndRect } from './get-connector-and-rect';
 import { CalculateClosestConnector } from './calculate-closest-connector';
-import { GetAllCanBeConnectedSourceConnectorsAndRectsExecution } from './get-all-can-be-connected-source-connectors-and-rects';
+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 GetAllCanBeConnectedSourceConnectorsAndRectsExecution | typeof GetAllCanBeConnectedInputsAndRectsExecution | typeof GetConnectorAndRect | typeof MarkConnectableConnectors | typeof RemoveInputFromStore | typeof RemoveOutletFromStoreExecution | typeof RemoveOutputFromStoreExecution | typeof UnmarkConnectableConnectors)[];
+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)[];

package/domain/f-draggable/emit-selection-change-event/emit-selection-change-event.execution.d.ts

@@ -10,7 +10,7 @@ export declare class EmitSelectionChangeEventExecution implements IExecution<Emi
     private readonly _store;
     private get _fSelectionChange();
     private readonly _dragContext;
-    handle(request: EmitSelectionChangeEventRequest): void;
+    handle(_request: EmitSelectionChangeEventRequest): void;
     private _getSelection;
     private _emitSelectionChange;
     static ɵfac: i0.ɵɵFactoryDeclaration<EmitSelectionChangeEventExecution, never>;

package/domain/f-event-trigger.d.ts

@@ -1,4 +1,4 @@
 export type FEventTrigger = (event: FTriggerEvent) => boolean;
 export type FTriggerEvent = MouseEvent | TouchEvent | WheelEvent;
 export declare function isValidEventTrigger(event: FTriggerEvent, fTrigger: FEventTrigger): boolean;
-export declare function defaultEventTrigger(event: FTriggerEvent): boolean;
+export declare function defaultEventTrigger(_event: FTriggerEvent): boolean;

package/domain/f-line-alignment/add-line-alignment-to-store/add-line-alignment-to-store-request.d.ts

@@ -1,6 +1,6 @@
 import { FLineAlignmentBase } from '../../../f-line-alignment';
 export declare class AddLineAlignmentToStoreRequest {
-    fComponent: FLineAlignmentBase;
+    readonly instance: FLineAlignmentBase;
     static readonly fToken: unique symbol;
-    constructor(fComponent: FLineAlignmentBase);
+    constructor(instance: FLineAlignmentBase);
 }

package/domain/f-line-alignment/add-line-alignment-to-store/{add-line-alignment-to-store.execution.d.ts → add-line-alignment-to-store.d.ts}

@@ -4,9 +4,9 @@ import * as i0 from "@angular/core";
 /**
  * Execution that adds a line alignment to the FComponentsStore.
  */
-export declare class AddLineAlignmentToStoreExecution implements IExecution<AddLineAlignmentToStoreRequest, void> {
+export declare class AddLineAlignmentToStore implements IExecution<AddLineAlignmentToStoreRequest, void> {
     private readonly _store;
-    handle(request: AddLineAlignmentToStoreRequest): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AddLineAlignmentToStoreExecution, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AddLineAlignmentToStoreExecution>;
+    handle({ instance }: AddLineAlignmentToStoreRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddLineAlignmentToStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddLineAlignmentToStore>;
 }

package/domain/f-line-alignment/add-line-alignment-to-store/index.d.ts

@@ -1,2 +1,2 @@
-export * from './add-line-alignment-to-store.execution';
+export * from './add-line-alignment-to-store';
 export * from './add-line-alignment-to-store-request';

package/domain/f-line-alignment/providers.d.ts

@@ -1,8 +1,8 @@
-import { AddLineAlignmentToStoreExecution } from './add-line-alignment-to-store';
-import { RemoveLineAlignmentFromStoreExecution } from './remove-line-alignment-from-store';
+import { AddLineAlignmentToStore } from './add-line-alignment-to-store';
+import { RemoveLineAlignmentFromStore } from './remove-line-alignment-from-store';
 /**
  * Collection of all FLineAlignment feature executions.
  * These executions handle the addition and removal of line alignments
  * in the FComponentsStore.
  */
-export declare const F_LINE_ALIGNMENT_FEATURES: (typeof AddLineAlignmentToStoreExecution | typeof RemoveLineAlignmentFromStoreExecution)[];
+export declare const F_LINE_ALIGNMENT_FEATURES: (typeof AddLineAlignmentToStore | typeof RemoveLineAlignmentFromStore)[];

package/domain/f-line-alignment/remove-line-alignment-from-store/index.d.ts

@@ -1,2 +1,2 @@
-export * from './remove-line-alignment-from-store.execution';
+export * from './remove-line-alignment-from-store';
 export * from './remove-line-alignment-from-store-request';

package/domain/f-line-alignment/remove-line-alignment-from-store/{remove-line-alignment-from-store.execution.d.ts → remove-line-alignment-from-store.d.ts}

@@ -4,9 +4,9 @@ import * as i0 from "@angular/core";
 /**
  * Execution that removes a line alignment from the FComponentsStore.
  */
-export declare class RemoveLineAlignmentFromStoreExecution implements IExecution<RemoveLineAlignmentFromStoreRequest, void> {
+export declare class RemoveLineAlignmentFromStore implements IExecution<RemoveLineAlignmentFromStoreRequest, void> {
     private readonly _store;
-    handle(request: RemoveLineAlignmentFromStoreRequest): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveLineAlignmentFromStoreExecution, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveLineAlignmentFromStoreExecution>;
+    handle(_request: RemoveLineAlignmentFromStoreRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveLineAlignmentFromStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveLineAlignmentFromStore>;
 }

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

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

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

@@ -0,0 +1,8 @@
+import { FConnectorBase } from '../../../../f-connectors';
+import { IPoint } from '@foblex/2d';
+export declare class CalculateConnectableSideByConnectedPositionsRequest {
+    readonly connector: FConnectorBase;
+    readonly pointerPosition?: IPoint | undefined;
+    static readonly fToken: unique symbol;
+    constructor(connector: FConnectorBase, pointerPosition?: IPoint | undefined);
+}

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

@@ -14,35 +14,9 @@ export declare class CalculateConnectableSideByConnectedPositions implements IEx
      * @param request - Contains the connector and optionally allowed sides.
      * @returns {EFConnectableSide} - The chosen connectable side.
      */
-    handle({ connector, mode, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
-    /**
-     * Accumulates sum of gravity centers and count, excluding the current host.
-     * Single pass, minimal allocations.
-     */
+    handle({ connector, pointerPosition, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
     private _accumulateConnectedCenters;
-    /**
-     * Converts allowed sides array to a compact bit mask.
-     * If not provided or empty -> all sides allowed.
-     */
-    private _toSideMask;
-    /**
-     * Determines final side using ideal side first; if disallowed, picks best fallback.
-     * Inputs are numbers to avoid object wrappers on hot path.
-     */
-    private _determineSide;
-    /**
-     * Picks the "ideal" side based on vector (dx, dy) with hysteresis.
-     */
-    private _pickIdealSide;
-    /**
-     * Quick membership check via bit mask.
-     */
-    private _isAllowed;
-    /**
-     * Picks the best available side from allowed mask by maximizing directional score.
-     * No intermediate objects, constant-time operations.
-     */
-    private _pickFallbackSide;
+    private _getConnectorRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectableSideByConnectedPositions, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectableSideByConnectedPositions>;
 }

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

@@ -0,0 +1,52 @@
+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 * as i0 from "@angular/core";
+/**
+ * Injection token for configuring the side detection tolerance (in pixels).
+ * A new side must beat the previous side by more than this value to switch.
+ */
+export declare const CONNECTABLE_SIDE_EPSILON: InjectionToken<number>;
+/**
+ * Calculates the connectable side of a connector relative to its node host.
+ *
+ * Optimizations & behavior:
+ * - Hysteresis via epsilon to avoid jitter near boundaries.
+ * - Per-connector memoization using WeakMap (no leaks).
+ * - During drag (isDragging === true) the last memorized side is returned immediately
+ *   for maximum stability and performance; a safe fallback computes it if missing.
+ */
+export declare class CalculateConnectableSideByInternalPosition implements IExecution<CalculateConnectableSideByInternalPositionRequest, EFConnectableSide> {
+    private readonly _mediator;
+    /**
+     * Stores the last computed side per connector.
+     * WeakMap ensures entries are garbage-collected with the connector objects.
+     */
+    private readonly _lastSide;
+    /** Pixel threshold to prevent side switching unless the new side is sufficiently better. */
+    private readonly _epsilon;
+    /**
+     * Entry point: returns the connectable side for a given connector.
+     * If a drag is in progress, returns the last memorized side for stability.
+     */
+    handle({ connector, }: CalculateConnectableSideByInternalPositionRequest): EFConnectableSide;
+    /**
+     * Determines the side of the connector relative to the node host by
+     * comparing distances from the connector's gravity center to each host edge.
+     *
+     * Hysteresis rule:
+     * If the previously chosen side is within `epsilon` pixels of the new best side,
+     * keep the previous side to avoid flicker.
+     *
+     * @param connectorHost - The connector element (HTML or SVG).
+     * @param nodeHost - The parent node element (HTML or SVG).
+     * @param connectorKey - The connector object, used as WeakMap key.
+     * @returns The most stable connectable side.
+     */
+    private _getSideByDelta;
+    /** Returns true if a drag operation is currently active. */
+    private _isDragging;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectableSideByInternalPosition, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectableSideByInternalPosition>;
+}

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

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

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

@@ -0,0 +1,22 @@
+import { IExecution } from '@foblex/mediator';
+import { CalculateConnectorsConnectableSidesRequest } from './calculate-connectors-connectable-sides-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that calculates connectable sides for all connectors of a node.
+ */
+export declare class CalculateConnectorsConnectableSides implements IExecution<CalculateConnectorsConnectableSidesRequest, void> {
+    private readonly _mediator;
+    /**
+     * Orchestrates side calculation for all connectors of the given node.
+     */
+    handle({ nodeOrGroup }: CalculateConnectorsConnectableSidesRequest): void;
+    /**
+     * Resolves the connectable side for a connector quickly.
+     * Avoids intermediate arrays and redundant allocations.
+     */
+    private _resolveSideForConnectorFast;
+    /** Delegates to the connected-positions calculation execution. */
+    private _calculateByConnectedPositions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectorsConnectableSides, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectorsConnectableSides>;
+}

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

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

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

@@ -0,0 +1 @@
+export * from './calculatable-sides';

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

@@ -0,0 +1,7 @@
+export * from './calculate-connectable-side-by-connected-positions';
+export * from './calculate-connectable-side-by-internal-position';
+export * from './constants';
+export * from './models';
+export * from './utils';
+export * from './calculate-connectors-connectable-sides';
+export * from './calculate-connectors-connectable-sides-request';

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

@@ -0,0 +1 @@
+export * from './t-calculate-mode';

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * Converts allowed sides array to a compact bit mask.
+ * If not provided or empty -> all sides allowed.
+ */
+import { EFConnectableSide } from '../../../../f-connectors';
+/**
+ * Determines final side using ideal side first; if disallowed, picks best fallback.
+ * Inputs are numbers to avoid object wrappers on hot path.
+ */
+export declare function determineSide(selfX: number, selfY: number, avgX: number, avgY: number, allowed?: EFConnectableSide[]): EFConnectableSide;

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

@@ -0,0 +1,2 @@
+export * from './determine-side';
+export * from './is-calculate-mode';

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

@@ -0,0 +1,7 @@
+import { EFConnectableSide } from '../../../../f-connectors';
+/**
+ * Checks if the given side is one of the calculate modes.
+ * @param side The connectable side to check.
+ * @returns True if the side is a calculate mode, false otherwise.
+ */
+export declare function isCalculateMode(side: EFConnectableSide): boolean;

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

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

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

@@ -7,9 +7,9 @@ import * as i0 from "@angular/core";
  */
 export declare class CalculateInputConnections implements IExecution<CalculateInputConnectionsRequest, FConnectionBase[]> {
     private readonly _store;
-    handle(request: CalculateInputConnectionsRequest): FConnectionBase[];
-    private _calculateConnectors;
-    private _calculateConnections;
+    handle({ nodeOrGroup }: CalculateInputConnectionsRequest): FConnectionBase[];
+    private _collectInputIds;
+    private _collectConnections;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateInputConnections, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateInputConnections>;
 }

package/domain/f-node/calculate-nodes-bounding-box/calculate-nodes-bounding-box.d.ts

@@ -8,9 +8,8 @@ import * as i0 from "@angular/core";
  */
 export declare class CalculateNodesBoundingBox implements IExecution<CalculateNodesBoundingBoxRequest, IRect | null> {
     private readonly _store;
-    handle(request: CalculateNodesBoundingBoxRequest): IRect | null;
-    private _getNodesRects;
-    private _getElementRect;
+    handle(_request: CalculateNodesBoundingBoxRequest): IRect | null;
+    private _nodesRects;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodesBoundingBox, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodesBoundingBox>;
 }