@foblex/flow 17.8.3 → 17.8.4

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

@@ -1,6 +1,9 @@
-import { FConnectorBase } from '../../../../f-connectors';
+import { EFConnectableSide, FConnectorBase } from '../../../../f-connectors';
+export type TCalculateMode = EFConnectableSide.CALCULATE | EFConnectableSide.CALCULATE_HORIZONTAL | EFConnectableSide.CALCULATE_VERTICAL;
+export declare const CALCULATE_MODES: EFConnectableSide[];
 export declare class CalculateConnectableSideByConnectedPositionsRequest {
     readonly connector: FConnectorBase;
+    readonly mode: TCalculateMode;
     static readonly fToken: unique symbol;
-    constructor(connector: FConnectorBase);
+    constructor(connector: FConnectorBase, mode: TCalculateMode);
 }

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

@@ -4,42 +4,45 @@ import { EFConnectableSide } from '../../../../f-connectors';
 import * as i0 from "@angular/core";
 /**
  * Execution that calculates the connectable side for a connector
- * based on the positions of its connected connectors.
+ * based on positions of connected connectors and allowed sides.
  */
 export declare class CalculateConnectableSideByConnectedPositions implements IExecution<CalculateConnectableSideByConnectedPositionsRequest, EFConnectableSide> {
     private readonly _mediator;
     /**
-     * Handles the request to calculate the connectable side for a connector
-     * based on the positions of its connected connectors.
+     * Entry point (hot path). Avoids intermediate arrays and redundant allocations.
      *
-     * @param request - Contains the connector host element and its connected connectors.
-     * @returns {EFConnectableSide} - The calculated connectable side.
+     * @param request - Contains the connector and optionally allowed sides.
+     * @returns {EFConnectableSide} - The chosen connectable side.
      */
-    handle({ connector, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
+    handle({ connector, mode, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
     /**
-     * Extracts the gravity centers of connected connectors, excluding the current connector.
-     *
-     * @param selfHost - The host element of the current connector.
-     * @param connected - The list of connected connectors.
-     * @returns {Array<{x: number, y: number}>} - An array of gravity center coordinates.
+     * Accumulates sum of gravity centers and count, excluding the current host.
+     * Single pass, minimal allocations.
      */
-    private _getConnectedCenters;
+    private _accumulateConnectedCenters;
     /**
-     * Calculates the average point (center of mass) from a set of points.
-     *
-     * @param points - An array of point objects with x and y coordinates.
-     * @returns {{x: number, y: number}} - The average x and y coordinate.
+     * Converts allowed sides array to a compact bit mask.
+     * If not provided or empty -> all sides allowed.
      */
-    private _calculateAveragePoint;
+    private _toSideMask;
     /**
-     * Determines the connectable side of the current connector relative to the
-     * average position of its connected connectors.
-     *
-     * @param self - The gravity center of the current connector.
-     * @param avg - The average gravity center of connected connectors.
-     * @returns {EFConnectableSide} - The chosen side (LEFT, RIGHT, TOP, BOTTOM).
+     * 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;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectableSideByConnectedPositions, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectableSideByConnectedPositions>;
 }

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

@@ -4,56 +4,25 @@ import * as i0 from "@angular/core";
 /**
  * Execution that calculates connectable sides for all connectors of a node.
  *
- * Responsibility:
- * - For each connector, decide the effective connectable side according to:
- *   - AUTO       -> by internal position relative to node host
- *   - CALCULATE  -> by positions of connected connectors
- *   - explicit   -> use the user-defined side as-is
- * - For each `toConnector` whose user side is CALCULATE, recalculate it as well.
+ * Performance goals:
+ * - Single-pass loops (no `forEach`).
+ * - Unique target recomputation (avoid repeated mediator calls for the same target).
+ * - Fast checks for "calculate" modes (bit mask instead of `includes`).
  */
 export declare class CalculateNodeConnectorsConnectableSides implements IExecution<CalculateNodeConnectorsConnectableSidesRequest, void> {
     private readonly _mediator;
     /**
      * Orchestrates side calculation for all connectors of the given node.
-     *
-     * @param request.node - Node whose connectors should be recalculated.
+     * Two-phase approach:
+     *  1) Update each connector's own side.
+     *  2) Collect unique `toConnector` with calculate modes and recompute once.
      */
     handle({ node }: CalculateNodeConnectorsConnectableSidesRequest): void;
     /**
-     * Calculates and assigns the connectable side for a single connector.
-     *
-     * @param connector - The connector being updated.
+     * Fast resolver for a single connector.
+     * Uses switch and avoids array operations.
      */
-    private _updateConnectorSide;
-    /**
-     * Recalculates connectable sides for all `toConnector` items that are marked as CALCULATE.
-     *
-     * @param source - The source connector whose outgoing connections should be processed.
-     */
-    private _updateConnectedTargets;
-    /**
-     * Resolves the effective side for a connector according to its user preference.
-     *
-     * @param connector - The connector to resolve side for.
-     * @returns {EFConnectableSide} - The resolved side.
-     */
-    private _resolveSideForConnector;
-    /**
-     * Calculates side using the connector's internal position relative to the node host.
-     * Delegates to `CalculateConnectableSideByInternalPositionRequest`.
-     *
-     * @param connector - Current connector.
-     * @returns {EFConnectableSide}
-     */
-    private _resolveSideByInternalPosition;
-    /**
-     * Calculates side using average positions of connectors connected to the given connector.
-     * Delegates to `CalculateConnectableSideByConnectedPositionsRequest`.
-     *
-     * @param connector - Current connector.
-     * @returns {EFConnectableSide}
-     */
-    private _resolveSideByConnectedPositions;
+    private _resolveSideForConnectorFast;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodeConnectorsConnectableSides, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodeConnectorsConnectableSides>;
 }

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

@@ -14,4 +14,4 @@ import { CalculateConnectableSideByConnectedPositions, CalculateConnectableSideB
 /**
  * This file exports all the node-related executions that can be used in the F-Flow domain.
  */
-export declare const F_NODE_FEATURES: (typeof AddNodeToStore | typeof CalculateConnectableSideByConnectedPositions | typeof CalculateConnectableSideByInternalPosition | typeof CalculateInputConnections | typeof CalculateNodeConnectorsConnectableSides | typeof CalculateNodesBoundingBox | typeof CalculateNodesBoundingBoxNormalizedPosition | typeof CalculateOutputConnections | typeof FitToChildNodesAndGroups | typeof GetChildNodeIds | typeof GetNodePadding | typeof GetNodes | typeof GetParentNodes | typeof UpdateNodeWhenStateOrSizeChanged | typeof RemoveNodeFromStore)[];
+export declare const F_NODE_FEATURES: (typeof CalculateConnectableSideByConnectedPositions | typeof CalculateNodeConnectorsConnectableSides | typeof AddNodeToStore | typeof CalculateConnectableSideByInternalPosition | typeof CalculateInputConnections | typeof CalculateNodesBoundingBox | typeof CalculateNodesBoundingBoxNormalizedPosition | typeof CalculateOutputConnections | typeof FitToChildNodesAndGroups | typeof GetChildNodeIds | typeof GetNodePadding | typeof GetNodes | typeof GetParentNodes | typeof UpdateNodeWhenStateOrSizeChanged | typeof RemoveNodeFromStore)[];

package/domain/providers.d.ts

@@ -10,4 +10,4 @@ import { GetNormalizedConnectorRectExecution } from "./get-normalized-connector-
  * draggable elements, flow, line alignment, nodes, selection, zoom,
  * and various utility executions.
  */
-export declare const COMMON_PROVIDERS: (typeof import("./f-node").AddNodeToStore | typeof import("./f-node").CalculateConnectableSideByConnectedPositions | typeof import("./f-node").CalculateConnectableSideByInternalPosition | typeof import("./f-node").CalculateInputConnections | typeof import("./f-node").CalculateNodeConnectorsConnectableSides | typeof import("./f-node").CalculateNodesBoundingBoxNormalizedPosition | typeof import("./f-node").CalculateOutputConnections | typeof import("./f-node").FitToChildNodesAndGroups | typeof import("./f-node").GetChildNodeIds | typeof import("./f-node").GetNodePadding | typeof import("./f-node").GetParentNodes | typeof import("./f-node").UpdateNodeWhenStateOrSizeChanged | typeof import("./f-node").RemoveNodeFromStore | typeof import("./f-canvas").AddCanvasToStoreExecution | typeof import("./f-canvas").CenterGroupOrNodeExecution | typeof import("./f-canvas").FitToFlowExecution | typeof import("./f-canvas").InputCanvasPositionExecution | typeof import("./f-canvas").InputCanvasScaleExecution | typeof import("./f-canvas").RedrawCanvasWithAnimationExecution | typeof import("./f-canvas").ResetScaleAndCenterExecution | typeof import("./f-canvas").UpdateScaleExecution | typeof import("./f-connection").AddConnectionForCreateToStoreExecution | typeof import("./f-connection").AddConnectionMarkerToStoreExecution | typeof import("./f-connection").AddConnectionToStoreExecution | typeof import("./f-connection").AddSnapConnectionToStoreExecution | typeof import("./f-connection").CreateConnectionMarkersExecution | typeof import("./f-connection").CalculateConnectionLineByBehavior | typeof import("./f-connection").RemoveConnectionFromStoreExecution | typeof import("./f-connection").RemoveConnectionMarkerFromStoreExecution | typeof import("./f-background").AddBackgroundToStoreExecution | typeof import("./f-background").AddPatternToBackgroundExecution | typeof import("./f-background").RemoveBackgroundFromStoreExecution | typeof import("./f-background").SetBackgroundTransformExecution | typeof import("./f-connectors").AddInputToStore | typeof import("./f-connectors").AddOutletToStore | typeof import("./f-connectors").AddOutputToStore | typeof import("./f-connectors").CalculateClosestConnector | typeof import("./f-connectors").FindConnectableConnectorUsingPriorityAndPositionExecution | typeof import("./f-connectors").GetAllCanBeConnectedSourceConnectorsAndRectsExecution | typeof import("./f-connectors").GetAllCanBeConnectedInputsAndRectsExecution | typeof import("./f-connectors").GetConnectorAndRect | typeof import("./f-connectors").MarkConnectableConnectors | typeof import("./f-connectors").RemoveInputFromStore | typeof import("./f-connectors").RemoveOutletFromStoreExecution | typeof import("./f-connectors").RemoveOutputFromStoreExecution | typeof import("./f-connectors").UnmarkConnectableConnectors | typeof import("./f-draggable").AddDndToStoreExecution | typeof import("./f-draggable").OnPointerMoveExecution | typeof import("./f-flow").AddFlowToStoreExecution | typeof import("./f-flow").GetFlowStateNodesExecution | typeof import("./f-line-alignment").AddLineAlignmentToStoreExecution | typeof GetElementRoundedRectExecution | typeof import("./f-selection").SelectExecution | typeof import("./f-selection").SelectAndUpdateNodeLayerExecution | typeof import("./f-zoom").AddZoomToStoreExecution | typeof import("./f-zoom").SetZoomExecution | typeof GetDeepChildrenNodesAndGroupsExecution | typeof GetNormalizedConnectorRectExecution | typeof GetNormalizedElementRectExecution | typeof GetNormalizedPointExecution | typeof UpdateItemAndChildrenLayersExecution | typeof MoveFrontElementsBeforeTargetElementExecution)[];
+export declare const COMMON_PROVIDERS: (typeof import("./f-node").CalculateConnectableSideByConnectedPositions | typeof import("./f-node").CalculateNodeConnectorsConnectableSides | typeof GetElementRoundedRectExecution | typeof import("./f-canvas").AddCanvasToStoreExecution | typeof import("./f-canvas").CenterGroupOrNodeExecution | typeof import("./f-canvas").FitToFlowExecution | typeof import("./f-canvas").InputCanvasPositionExecution | typeof import("./f-canvas").InputCanvasScaleExecution | typeof import("./f-canvas").RedrawCanvasWithAnimationExecution | typeof import("./f-canvas").ResetScaleAndCenterExecution | typeof import("./f-canvas").UpdateScaleExecution | typeof import("./f-connection").AddConnectionForCreateToStoreExecution | typeof import("./f-connection").AddConnectionMarkerToStoreExecution | typeof import("./f-connection").AddConnectionToStoreExecution | typeof import("./f-connection").AddSnapConnectionToStoreExecution | typeof import("./f-connection").CreateConnectionMarkersExecution | typeof import("./f-connection").CalculateConnectionLineByBehavior | typeof import("./f-connection").RemoveConnectionFromStoreExecution | typeof import("./f-connection").RemoveConnectionMarkerFromStoreExecution | typeof import("./f-background").AddBackgroundToStoreExecution | typeof import("./f-background").AddPatternToBackgroundExecution | typeof import("./f-background").RemoveBackgroundFromStoreExecution | typeof import("./f-background").SetBackgroundTransformExecution | typeof import("./f-connectors").AddInputToStore | typeof import("./f-connectors").AddOutletToStore | typeof import("./f-connectors").AddOutputToStore | typeof import("./f-connectors").CalculateClosestConnector | typeof import("./f-connectors").FindConnectableConnectorUsingPriorityAndPositionExecution | typeof import("./f-connectors").GetAllCanBeConnectedSourceConnectorsAndRectsExecution | typeof import("./f-connectors").GetAllCanBeConnectedInputsAndRectsExecution | typeof import("./f-connectors").GetConnectorAndRect | typeof import("./f-connectors").MarkConnectableConnectors | typeof import("./f-connectors").RemoveInputFromStore | typeof import("./f-connectors").RemoveOutletFromStoreExecution | typeof import("./f-connectors").RemoveOutputFromStoreExecution | typeof import("./f-connectors").UnmarkConnectableConnectors | typeof import("./f-draggable").AddDndToStoreExecution | typeof import("./f-draggable").OnPointerMoveExecution | typeof import("./f-flow").AddFlowToStoreExecution | typeof import("./f-flow").GetFlowStateNodesExecution | typeof import("./f-line-alignment").AddLineAlignmentToStoreExecution | typeof import("./f-node").AddNodeToStore | typeof import("./f-node").CalculateConnectableSideByInternalPosition | typeof import("./f-node").CalculateInputConnections | typeof import("./f-node").CalculateNodesBoundingBoxNormalizedPosition | typeof import("./f-node").CalculateOutputConnections | typeof import("./f-node").FitToChildNodesAndGroups | typeof import("./f-node").GetChildNodeIds | typeof import("./f-node").GetNodePadding | typeof import("./f-node").GetParentNodes | typeof import("./f-node").UpdateNodeWhenStateOrSizeChanged | typeof import("./f-node").RemoveNodeFromStore | typeof import("./f-selection").SelectExecution | typeof import("./f-selection").SelectAndUpdateNodeLayerExecution | typeof import("./f-zoom").AddZoomToStoreExecution | typeof import("./f-zoom").SetZoomExecution | typeof GetDeepChildrenNodesAndGroupsExecution | typeof GetNormalizedConnectorRectExecution | typeof GetNormalizedElementRectExecution | typeof GetNormalizedPointExecution | typeof UpdateItemAndChildrenLayersExecution | typeof MoveFrontElementsBeforeTargetElementExecution)[];

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

@@ -1,8 +1,16 @@
+import { EFConnectableSide } from '../../../../f-connectors';
+export const CALCULATE_MODES = [
+    EFConnectableSide.CALCULATE,
+    EFConnectableSide.CALCULATE_HORIZONTAL,
+    EFConnectableSide.CALCULATE_VERTICAL,
+];
 export class CalculateConnectableSideByConnectedPositionsRequest {
     connector;
+    mode;
     static fToken = Symbol('CalculateConnectableSideByConnectedPositionsRequest');
-    constructor(connector) {
+    constructor(connector, mode) {
         this.connector = connector;
+        this.mode = mode;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLWNvbm5lY3RhYmxlLXNpZGUtYnktY29ubmVjdGVkLXBvc2l0aW9ucy1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9kb21haW4vZi1ub2RlL2NhbGN1bGF0ZS1ub2RlLWNvbm5lY3RvcnMtY29ubmVjdGFibGUtc2lkZXMvY2FsY3VsYXRlLWNvbm5lY3RhYmxlLXNpZGUtYnktY29ubmVjdGVkLXBvc2l0aW9ucy9jYWxjdWxhdGUtY29ubmVjdGFibGUtc2lkZS1ieS1jb25uZWN0ZWQtcG9zaXRpb25zLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLG1EQUFtRDtJQUVsQztJQUQ1QixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO0lBQ3ZGLFlBQTRCLFNBQXlCO1FBQXpCLGNBQVMsR0FBVCxTQUFTLENBQWdCO0lBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZDb25uZWN0b3JCYXNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZi1jb25uZWN0b3JzJztcblxuZXhwb3J0IGNsYXNzIENhbGN1bGF0ZUNvbm5lY3RhYmxlU2lkZUJ5Q29ubmVjdGVkUG9zaXRpb25zUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0NhbGN1bGF0ZUNvbm5lY3RhYmxlU2lkZUJ5Q29ubmVjdGVkUG9zaXRpb25zUmVxdWVzdCcpO1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgcmVhZG9ubHkgY29ubmVjdG9yOiBGQ29ubmVjdG9yQmFzZSkge31cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLWNvbm5lY3RhYmxlLXNpZGUtYnktY29ubmVjdGVkLXBvc2l0aW9ucy1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9kb21haW4vZi1ub2RlL2NhbGN1bGF0ZS1ub2RlLWNvbm5lY3RvcnMtY29ubmVjdGFibGUtc2lkZXMvY2FsY3VsYXRlLWNvbm5lY3RhYmxlLXNpZGUtYnktY29ubmVjdGVkLXBvc2l0aW9ucy9jYWxjdWxhdGUtY29ubmVjdGFibGUtc2lkZS1ieS1jb25uZWN0ZWQtcG9zaXRpb25zLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFrQixNQUFNLDBCQUEwQixDQUFDO0FBTzdFLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRztJQUM3QixpQkFBaUIsQ0FBQyxTQUFTO0lBQzNCLGlCQUFpQixDQUFDLG9CQUFvQjtJQUN0QyxpQkFBaUIsQ0FBQyxrQkFBa0I7Q0FDckMsQ0FBQztBQUVGLE1BQU0sT0FBTyxtREFBbUQ7SUFHNUM7SUFDQTtJQUhsQixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO0lBQ3ZGLFlBQ2tCLFNBQXlCLEVBQ3pCLElBQW9CO1FBRHBCLGNBQVMsR0FBVCxTQUFTLENBQWdCO1FBQ3pCLFNBQUksR0FBSixJQUFJLENBQWdCO0lBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFRkNvbm5lY3RhYmxlU2lkZSwgRkNvbm5lY3RvckJhc2UgfSBmcm9tICcuLi8uLi8uLi8uLi9mLWNvbm5lY3RvcnMnO1xuXG5leHBvcnQgdHlwZSBUQ2FsY3VsYXRlTW9kZSA9XG4gIHwgRUZDb25uZWN0YWJsZVNpZGUuQ0FMQ1VMQVRFXG4gIHwgRUZDb25uZWN0YWJsZVNpZGUuQ0FMQ1VMQVRFX0hPUklaT05UQUxcbiAgfCBFRkNvbm5lY3RhYmxlU2lkZS5DQUxDVUxBVEVfVkVSVElDQUw7XG5cbmV4cG9ydCBjb25zdCBDQUxDVUxBVEVfTU9ERVMgPSBbXG4gIEVGQ29ubmVjdGFibGVTaWRlLkNBTENVTEFURSxcbiAgRUZDb25uZWN0YWJsZVNpZGUuQ0FMQ1VMQVRFX0hPUklaT05UQUwsXG4gIEVGQ29ubmVjdGFibGVTaWRlLkNBTENVTEFURV9WRVJUSUNBTCxcbl07XG5cbmV4cG9ydCBjbGFzcyBDYWxjdWxhdGVDb25uZWN0YWJsZVNpZGVCeUNvbm5lY3RlZFBvc2l0aW9uc1JlcXVlc3Qge1xuICBzdGF0aWMgcmVhZG9ubHkgZlRva2VuID0gU3ltYm9sKCdDYWxjdWxhdGVDb25uZWN0YWJsZVNpZGVCeUNvbm5lY3RlZFBvc2l0aW9uc1JlcXVlc3QnKTtcbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIHJlYWRvbmx5IGNvbm5lY3RvcjogRkNvbm5lY3RvckJhc2UsXG4gICAgcHVibGljIHJlYWRvbmx5IG1vZGU6IFRDYWxjdWxhdGVNb2RlLFxuICApIHt9XG59XG4iXX0=

package/esm2022/domain/f-node/calculate-node-connectors-connectable-sides/calculate-connectable-side-by-connected-positions/calculate-connectable-side-by-connected-positions.mjs

@@ -3,82 +3,171 @@ import { inject, Injectable } from '@angular/core';
 import { FExecutionRegister, FMediator } from '@foblex/mediator';
 import { CalculateConnectableSideByConnectedPositionsRequest } from './calculate-connectable-side-by-connected-positions-request';
 import { EFConnectableSide } from '../../../../f-connectors';
-import { PointExtensions, RectExtensions } from '@foblex/2d';
+import { RectExtensions } from '@foblex/2d';
 import { CalculateConnectableSideByInternalPositionRequest } from '../calculate-connectable-side-by-internal-position';
 import * as i0 from "@angular/core";
+const SNAP_EPS = 2;
+const CALCULATE_SIDES = {
+    [EFConnectableSide.CALCULATE]: [
+        EFConnectableSide.TOP,
+        EFConnectableSide.BOTTOM,
+        EFConnectableSide.LEFT,
+        EFConnectableSide.RIGHT,
+    ],
+    [EFConnectableSide.CALCULATE_HORIZONTAL]: [EFConnectableSide.LEFT, EFConnectableSide.RIGHT],
+    [EFConnectableSide.CALCULATE_VERTICAL]: [EFConnectableSide.TOP, EFConnectableSide.BOTTOM],
+};
 /**
  * Execution that calculates the connectable side for a connector
- * based on the positions of its connected connectors.
+ * based on positions of connected connectors and allowed sides.
  */
 let CalculateConnectableSideByConnectedPositions = class CalculateConnectableSideByConnectedPositions {
     _mediator = inject(FMediator);
     /**
-     * Handles the request to calculate the connectable side for a connector
-     * based on the positions of its connected connectors.
+     * Entry point (hot path). Avoids intermediate arrays and redundant allocations.
      *
-     * @param request - Contains the connector host element and its connected connectors.
-     * @returns {EFConnectableSide} - The calculated connectable side.
+     * @param request - Contains the connector and optionally allowed sides.
+     * @returns {EFConnectableSide} - The chosen connectable side.
      */
-    handle({ connector, }) {
+    handle({ connector, mode, }) {
         const selfCenter = RectExtensions.fromElement(connector.hostElement).gravityCenter;
-        const targetCenters = this._getConnectedCenters(connector.hostElement, connector.toConnector);
-        if (!targetCenters.length) {
+        const acc = this._accumulateConnectedCenters(connector.hostElement, connector.toConnector);
+        if (acc.count === 0) {
             return this._mediator.execute(new CalculateConnectableSideByInternalPositionRequest(connector));
         }
-        const avg = this._calculateAveragePoint(targetCenters);
-        return this._determineSide(selfCenter, avg);
+        const avgX = acc.sumX / acc.count;
+        const avgY = acc.sumY / acc.count;
+        const mask = this._toSideMask(CALCULATE_SIDES[mode]);
+        return this._determineSide(selfCenter.x, selfCenter.y, avgX, avgY, mask);
     }
     /**
-     * Extracts the gravity centers of connected connectors, excluding the current connector.
-     *
-     * @param selfHost - The host element of the current connector.
-     * @param connected - The list of connected connectors.
-     * @returns {Array<{x: number, y: number}>} - An array of gravity center coordinates.
+     * Accumulates sum of gravity centers and count, excluding the current host.
+     * Single pass, minimal allocations.
      */
-    _getConnectedCenters(selfHost, connected) {
-        return (connected ?? [])
-            .map((c) => c?.hostElement)
-            .filter((el) => !!el && el !== selfHost)
-            .map((el) => RectExtensions.fromElement(el).gravityCenter);
+    _accumulateConnectedCenters(selfHost, connected) {
+        let sumX = 0;
+        let sumY = 0;
+        let count = 0;
+        if (connected && connected.length) {
+            for (let i = 0; i < connected.length; i++) {
+                const el = connected[i]?.hostElement;
+                if (!el || el === selfHost)
+                    continue;
+                const c = RectExtensions.fromElement(el).gravityCenter;
+                sumX += c.x;
+                sumY += c.y;
+                count++;
+            }
+        }
+        return { sumX, sumY, count };
     }
     /**
-     * Calculates the average point (center of mass) from a set of points.
-     *
-     * @param points - An array of point objects with x and y coordinates.
-     * @returns {{x: number, y: number}} - The average x and y coordinate.
+     * Converts allowed sides array to a compact bit mask.
+     * If not provided or empty -> all sides allowed.
      */
-    _calculateAveragePoint(points) {
-        const sum = points.reduce((result, p) => {
-            result.x += p.x;
-            result.y += p.y;
-            return result;
-        }, PointExtensions.initialize());
-        return {
-            x: sum.x / points.length,
-            y: sum.y / points.length,
-        };
+    _toSideMask(allowed) {
+        if (!allowed || allowed.length === 0)
+            return 15 /* SideMask.ALL */;
+        let mask = 0 /* SideMask.NONE */;
+        for (let i = 0; i < allowed.length; i++) {
+            switch (allowed[i]) {
+                case EFConnectableSide.LEFT:
+                    mask |= 1 /* SideMask.LEFT */;
+                    break;
+                case EFConnectableSide.RIGHT:
+                    mask |= 2 /* SideMask.RIGHT */;
+                    break;
+                case EFConnectableSide.TOP:
+                    mask |= 4 /* SideMask.TOP */;
+                    break;
+                case EFConnectableSide.BOTTOM:
+                    mask |= 8 /* SideMask.BOTTOM */;
+                    break;
+            }
+        }
+        return mask || 15 /* SideMask.ALL */;
     }
     /**
-     * Determines the connectable side of the current connector relative to the
-     * average position of its connected connectors.
-     *
-     * @param self - The gravity center of the current connector.
-     * @param avg - The average gravity center of connected connectors.
-     * @returns {EFConnectableSide} - The chosen side (LEFT, RIGHT, TOP, BOTTOM).
+     * Determines final side using ideal side first; if disallowed, picks best fallback.
+     * Inputs are numbers to avoid object wrappers on hot path.
      */
-    _determineSide(self, avg) {
-        const dx = avg.x - self.x;
-        const dy = avg.y - self.y;
-        const snapEps = 2; // px — hysteresis threshold to avoid side-flipping near diagonals
-        if (Math.abs(dx) - Math.abs(dy) > snapEps) {
+    _determineSide(selfX, selfY, avgX, avgY, allowedMask) {
+        const dx = avgX - selfX;
+        const dy = avgY - selfY;
+        const ideal = this._pickIdealSide(dx, dy);
+        if (this._isAllowed(ideal, allowedMask)) {
+            return ideal;
+        }
+        return this._pickFallbackSide(dx, dy, allowedMask, ideal);
+    }
+    /**
+     * Picks the "ideal" side based on vector (dx, dy) with hysteresis.
+     */
+    _pickIdealSide(dx, dy) {
+        const ax = dx < 0 ? -dx : dx;
+        const ay = dy < 0 ? -dy : dy;
+        if (ax - ay > SNAP_EPS) {
             return dx < 0 ? EFConnectableSide.LEFT : EFConnectableSide.RIGHT;
         }
-        if (Math.abs(dy) - Math.abs(dx) > snapEps) {
+        if (ay - ax > SNAP_EPS) {
             return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;
         }
-        // When differences are nearly equal, prefer vertical orientation for stability
         return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;
     }
+    /**
+     * Quick membership check via bit mask.
+     */
+    _isAllowed(side, mask) {
+        switch (side) {
+            case EFConnectableSide.LEFT:
+                return (mask & 1 /* SideMask.LEFT */) !== 0;
+            case EFConnectableSide.RIGHT:
+                return (mask & 2 /* SideMask.RIGHT */) !== 0;
+            case EFConnectableSide.TOP:
+                return (mask & 4 /* SideMask.TOP */) !== 0;
+            case EFConnectableSide.BOTTOM:
+                return (mask & 8 /* SideMask.BOTTOM */) !== 0;
+            default:
+                return true;
+        }
+    }
+    /**
+     * Picks the best available side from allowed mask by maximizing directional score.
+     * No intermediate objects, constant-time operations.
+     */
+    _pickFallbackSide(dx, dy, allowedMask, ideal) {
+        let bestSide = ideal;
+        let bestScore = -Infinity;
+        if (allowedMask & 2 /* SideMask.RIGHT */) {
+            const s = dx;
+            if (s > bestScore) {
+                bestScore = s;
+                bestSide = EFConnectableSide.RIGHT;
+            }
+        }
+        if (allowedMask & 1 /* SideMask.LEFT */) {
+            const s = -dx;
+            if (s > bestScore) {
+                bestScore = s;
+                bestSide = EFConnectableSide.LEFT;
+            }
+        }
+        if (allowedMask & 8 /* SideMask.BOTTOM */) {
+            const s = dy;
+            if (s > bestScore) {
+                bestScore = s;
+                bestSide = EFConnectableSide.BOTTOM;
+            }
+        }
+        if (allowedMask & 4 /* SideMask.TOP */) {
+            const s = -dy;
+            if (s > bestScore) {
+                bestScore = s;
+                bestSide = EFConnectableSide.TOP;
+            }
+        }
+        return bestSide;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateConnectableSideByConnectedPositions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateConnectableSideByConnectedPositions });
 };
@@ -89,4 +178,4 @@ export { CalculateConnectableSideByConnectedPositions };
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateConnectableSideByConnectedPositions, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculate-connectable-side-by-connected-positions.js","sourceRoot":"","sources":["../../../../../../../projects/f-flow/src/domain/f-node/calculate-node-connectors-connectable-sides/calculate-connectable-side-by-connected-positions/calculate-connectable-side-by-connected-positions.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { CalculateConnectableSideByConnectedPositionsRequest } from './calculate-connectable-side-by-connected-positions-request';\nimport { EFConnectableSide, FConnectorBase } from '../../../../f-connectors';\nimport { IPoint, PointExtensions, RectExtensions } from '@foblex/2d';\nimport { CalculateConnectableSideByInternalPositionRequest } from '../calculate-connectable-side-by-internal-position';\n\n/**\n * Execution that calculates the connectable side for a connector\n * based on the positions of its connected connectors.\n */\n@Injectable()\n@FExecutionRegister(CalculateConnectableSideByConnectedPositionsRequest)\nexport class CalculateConnectableSideByConnectedPositions\n  implements IExecution<CalculateConnectableSideByConnectedPositionsRequest, EFConnectableSide>\n{\n  private readonly _mediator = inject(FMediator);\n\n  /**\n   * Handles the request to calculate the connectable side for a connector\n   * based on the positions of its connected connectors.\n   *\n   * @param request - Contains the connector host element and its connected connectors.\n   * @returns {EFConnectableSide} - The calculated connectable side.\n   */\n  public handle({\n    connector,\n  }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide {\n    const selfCenter = RectExtensions.fromElement(connector.hostElement).gravityCenter;\n    const targetCenters = this._getConnectedCenters(connector.hostElement, connector.toConnector);\n\n    if (!targetCenters.length) {\n      return this._mediator.execute(\n        new CalculateConnectableSideByInternalPositionRequest(connector),\n      );\n    }\n\n    const avg = this._calculateAveragePoint(targetCenters);\n\n    return this._determineSide(selfCenter, avg);\n  }\n\n  /**\n   * Extracts the gravity centers of connected connectors, excluding the current connector.\n   *\n   * @param selfHost - The host element of the current connector.\n   * @param connected - The list of connected connectors.\n   * @returns {Array<{x: number, y: number}>} - An array of gravity center coordinates.\n   */\n  private _getConnectedCenters(\n    selfHost: HTMLElement | SVGElement,\n    connected: FConnectorBase[],\n  ): { x: number; y: number }[] {\n    return (connected ?? [])\n      .map((c) => c?.hostElement)\n      .filter((el): el is HTMLElement | SVGElement => !!el && el !== selfHost)\n      .map((el) => RectExtensions.fromElement(el).gravityCenter);\n  }\n\n  /**\n   * Calculates the average point (center of mass) from a set of points.\n   *\n   * @param points - An array of point objects with x and y coordinates.\n   * @returns {{x: number, y: number}} - The average x and y coordinate.\n   */\n  private _calculateAveragePoint(points: IPoint[]): IPoint {\n    const sum = points.reduce((result: IPoint, p: IPoint) => {\n      result.x += p.x;\n      result.y += p.y;\n\n      return result;\n    }, PointExtensions.initialize());\n\n    return {\n      x: sum.x / points.length,\n      y: sum.y / points.length,\n    };\n  }\n\n  /**\n   * Determines the connectable side of the current connector relative to the\n   * average position of its connected connectors.\n   *\n   * @param self - The gravity center of the current connector.\n   * @param avg - The average gravity center of connected connectors.\n   * @returns {EFConnectableSide} - The chosen side (LEFT, RIGHT, TOP, BOTTOM).\n   */\n  private _determineSide(\n    self: { x: number; y: number },\n    avg: { x: number; y: number },\n  ): EFConnectableSide {\n    const dx = avg.x - self.x;\n    const dy = avg.y - self.y;\n    const snapEps = 2; // px — hysteresis threshold to avoid side-flipping near diagonals\n\n    if (Math.abs(dx) - Math.abs(dy) > snapEps) {\n      return dx < 0 ? EFConnectableSide.LEFT : EFConnectableSide.RIGHT;\n    }\n    if (Math.abs(dy) - Math.abs(dx) > snapEps) {\n      return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;\n    }\n\n    // When differences are nearly equal, prefer vertical orientation for stability\n    return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculate-connectable-side-by-connected-positions.js","sourceRoot":"","sources":["../../../../../../../projects/f-flow/src/domain/f-node/calculate-node-connectors-connectable-sides/calculate-connectable-side-by-connected-positions/calculate-connectable-side-by-connected-positions.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { CalculateConnectableSideByConnectedPositionsRequest } from './calculate-connectable-side-by-connected-positions-request';\nimport { EFConnectableSide, FConnectorBase } from '../../../../f-connectors';\nimport { RectExtensions } from '@foblex/2d';\nimport { CalculateConnectableSideByInternalPositionRequest } from '../calculate-connectable-side-by-internal-position';\n\nconst SNAP_EPS = 2;\n\nconst enum SideMask {\n  NONE = 0,\n  LEFT = 1 << 0,\n  RIGHT = 1 << 1,\n  TOP = 1 << 2,\n  BOTTOM = 1 << 3,\n  ALL = (1 << 4) - 1,\n}\n\nconst CALCULATE_SIDES = {\n  [EFConnectableSide.CALCULATE]: [\n    EFConnectableSide.TOP,\n    EFConnectableSide.BOTTOM,\n    EFConnectableSide.LEFT,\n    EFConnectableSide.RIGHT,\n  ],\n  [EFConnectableSide.CALCULATE_HORIZONTAL]: [EFConnectableSide.LEFT, EFConnectableSide.RIGHT],\n  [EFConnectableSide.CALCULATE_VERTICAL]: [EFConnectableSide.TOP, EFConnectableSide.BOTTOM],\n};\n\n/**\n * Execution that calculates the connectable side for a connector\n * based on positions of connected connectors and allowed sides.\n */\n@Injectable()\n@FExecutionRegister(CalculateConnectableSideByConnectedPositionsRequest)\nexport class CalculateConnectableSideByConnectedPositions\n  implements IExecution<CalculateConnectableSideByConnectedPositionsRequest, EFConnectableSide>\n{\n  private readonly _mediator = inject(FMediator);\n\n  /**\n   * Entry point (hot path). Avoids intermediate arrays and redundant allocations.\n   *\n   * @param request - Contains the connector and optionally allowed sides.\n   * @returns {EFConnectableSide} - The chosen connectable side.\n   */\n  public handle({\n    connector,\n    mode,\n  }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide {\n    const selfCenter = RectExtensions.fromElement(connector.hostElement).gravityCenter;\n\n    const acc = this._accumulateConnectedCenters(connector.hostElement, connector.toConnector);\n\n    if (acc.count === 0) {\n      return this._mediator.execute(\n        new CalculateConnectableSideByInternalPositionRequest(connector),\n      );\n    }\n\n    const avgX = acc.sumX / acc.count;\n    const avgY = acc.sumY / acc.count;\n\n    const mask = this._toSideMask(CALCULATE_SIDES[mode]);\n\n    return this._determineSide(selfCenter.x, selfCenter.y, avgX, avgY, mask);\n  }\n\n  /**\n   * Accumulates sum of gravity centers and count, excluding the current host.\n   * Single pass, minimal allocations.\n   */\n  private _accumulateConnectedCenters(\n    selfHost: HTMLElement | SVGElement,\n    connected: FConnectorBase[] | null | undefined,\n  ): { sumX: number; sumY: number; count: number } {\n    let sumX = 0;\n    let sumY = 0;\n    let count = 0;\n\n    if (connected && connected.length) {\n      for (let i = 0; i < connected.length; i++) {\n        const el = connected[i]?.hostElement as HTMLElement | SVGElement | undefined;\n        if (!el || el === selfHost) continue;\n\n        const c = RectExtensions.fromElement(el).gravityCenter;\n        sumX += c.x;\n        sumY += c.y;\n        count++;\n      }\n    }\n\n    return { sumX, sumY, count };\n  }\n\n  /**\n   * Converts allowed sides array to a compact bit mask.\n   * If not provided or empty -> all sides allowed.\n   */\n  private _toSideMask(allowed?: EFConnectableSide[]): SideMask {\n    if (!allowed || allowed.length === 0) return SideMask.ALL;\n\n    let mask = SideMask.NONE;\n    for (let i = 0; i < allowed.length; i++) {\n      switch (allowed[i]) {\n        case EFConnectableSide.LEFT:\n          mask |= SideMask.LEFT;\n          break;\n        case EFConnectableSide.RIGHT:\n          mask |= SideMask.RIGHT;\n          break;\n        case EFConnectableSide.TOP:\n          mask |= SideMask.TOP;\n          break;\n        case EFConnectableSide.BOTTOM:\n          mask |= SideMask.BOTTOM;\n          break;\n      }\n    }\n\n    return mask || SideMask.ALL;\n  }\n\n  /**\n   * Determines final side using ideal side first; if disallowed, picks best fallback.\n   * Inputs are numbers to avoid object wrappers on hot path.\n   */\n  private _determineSide(\n    selfX: number,\n    selfY: number,\n    avgX: number,\n    avgY: number,\n    allowedMask: SideMask,\n  ): EFConnectableSide {\n    const dx = avgX - selfX;\n    const dy = avgY - selfY;\n\n    const ideal = this._pickIdealSide(dx, dy);\n\n    if (this._isAllowed(ideal, allowedMask)) {\n      return ideal;\n    }\n\n    return this._pickFallbackSide(dx, dy, allowedMask, ideal);\n  }\n\n  /**\n   * Picks the \"ideal\" side based on vector (dx, dy) with hysteresis.\n   */\n  private _pickIdealSide(dx: number, dy: number): EFConnectableSide {\n    const ax = dx < 0 ? -dx : dx;\n    const ay = dy < 0 ? -dy : dy;\n\n    if (ax - ay > SNAP_EPS) {\n      return dx < 0 ? EFConnectableSide.LEFT : EFConnectableSide.RIGHT;\n    }\n    if (ay - ax > SNAP_EPS) {\n      return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;\n    }\n\n    return dy < 0 ? EFConnectableSide.TOP : EFConnectableSide.BOTTOM;\n  }\n\n  /**\n   * Quick membership check via bit mask.\n   */\n  private _isAllowed(side: EFConnectableSide, mask: SideMask): boolean {\n    switch (side) {\n      case EFConnectableSide.LEFT:\n        return (mask & SideMask.LEFT) !== 0;\n      case EFConnectableSide.RIGHT:\n        return (mask & SideMask.RIGHT) !== 0;\n      case EFConnectableSide.TOP:\n        return (mask & SideMask.TOP) !== 0;\n      case EFConnectableSide.BOTTOM:\n        return (mask & SideMask.BOTTOM) !== 0;\n      default:\n        return true;\n    }\n  }\n\n  /**\n   * Picks the best available side from allowed mask by maximizing directional score.\n   * No intermediate objects, constant-time operations.\n   */\n  private _pickFallbackSide(\n    dx: number,\n    dy: number,\n    allowedMask: SideMask,\n    ideal: EFConnectableSide,\n  ): EFConnectableSide {\n    let bestSide: EFConnectableSide = ideal;\n    let bestScore = -Infinity;\n\n    if (allowedMask & SideMask.RIGHT) {\n      const s = dx;\n      if (s > bestScore) {\n        bestScore = s;\n        bestSide = EFConnectableSide.RIGHT;\n      }\n    }\n    if (allowedMask & SideMask.LEFT) {\n      const s = -dx;\n      if (s > bestScore) {\n        bestScore = s;\n        bestSide = EFConnectableSide.LEFT;\n      }\n    }\n    if (allowedMask & SideMask.BOTTOM) {\n      const s = dy;\n      if (s > bestScore) {\n        bestScore = s;\n        bestSide = EFConnectableSide.BOTTOM;\n      }\n    }\n    if (allowedMask & SideMask.TOP) {\n      const s = -dy;\n      if (s > bestScore) {\n        bestScore = s;\n        bestSide = EFConnectableSide.TOP;\n      }\n    }\n\n    return bestSide;\n  }\n}\n"]}