@foblex/flow 17.8.3 → 17.8.5

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-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-flow/providers.d.ts

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

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

@@ -5,4 +5,4 @@ import { RemoveLineAlignmentFromStoreExecution } from './remove-line-alignment-f
  * 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 RemoveLineAlignmentFromStoreExecution | typeof AddLineAlignmentToStoreExecution)[];

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-node-connectors-connectable-sides → calculate-connectors-connectable-sides}/calculate-connectable-side-by-connected-positions/calculate-connectable-side-by-connected-positions-request.d.ts

@@ -1,6 +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);
+    constructor(connector: FConnectorBase, pointerPosition?: IPoint | undefined);
 }

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

@@ -0,0 +1,22 @@
+import { IExecution } from '@foblex/mediator';
+import { CalculateConnectableSideByConnectedPositionsRequest } from './calculate-connectable-side-by-connected-positions-request';
+import { EFConnectableSide } from '../../../../f-connectors';
+import * as i0 from "@angular/core";
+/**
+ * Execution that calculates the connectable side for a connector
+ * based on positions of connected connectors and allowed sides.
+ */
+export declare class CalculateConnectableSideByConnectedPositions implements IExecution<CalculateConnectableSideByConnectedPositionsRequest, EFConnectableSide> {
+    private readonly _mediator;
+    /**
+     * Entry point (hot path). Avoids intermediate arrays and redundant allocations.
+     *
+     * @param request - Contains the connector and optionally allowed sides.
+     * @returns {EFConnectableSide} - The chosen connectable side.
+     */
+    handle({ connector, pointerPosition, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
+    private _accumulateConnectedCenters;
+    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>;
 }

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

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

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

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

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

@@ -1,13 +1,12 @@
 export * from './add-node-to-store';
 export * from './calculate-input-connections';
-export * from './calculate-node-connectors-connectable-sides';
+export * from './calculate-connectors-connectable-sides';
 export * from './calculate-nodes-bounding-box';
 export * from './calculate-nodes-bounding-box-normalized-position';
 export * from './calculate-output-connections';
 export * from './fit-to-child-nodes-and-groups';
 export * from './get-child-node-ids';
 export * from './get-node-padding';
-export * from './get-nodes';
 export * from './get-parent-nodes';
 export * from './update-node-when-state-or-size-changed';
 export * from './remove-node-from-store';

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

@@ -1,7 +1,6 @@
 import { AddNodeToStore } from './add-node-to-store';
 import { RemoveNodeFromStore } from './remove-node-from-store';
 import { UpdateNodeWhenStateOrSizeChanged } from './update-node-when-state-or-size-changed';
-import { GetNodes } from './get-nodes';
 import { CalculateNodesBoundingBox } from './calculate-nodes-bounding-box';
 import { CalculateNodesBoundingBoxNormalizedPosition } from './calculate-nodes-bounding-box-normalized-position';
 import { GetNodePadding } from './get-node-padding';
@@ -10,8 +9,8 @@ import { CalculateInputConnections } from './calculate-input-connections';
 import { CalculateOutputConnections } from './calculate-output-connections';
 import { GetChildNodeIds } from './get-child-node-ids';
 import { FitToChildNodesAndGroups } from './fit-to-child-nodes-and-groups';
-import { CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByInternalPosition, CalculateNodeConnectorsConnectableSides } from './calculate-node-connectors-connectable-sides';
+import { CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByInternalPosition, CalculateConnectorsConnectableSides } from './calculate-connectors-connectable-sides';
 /**
  * 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 AddNodeToStore | typeof CalculateConnectableSideByConnectedPositions | typeof CalculateConnectableSideByInternalPosition | typeof CalculateInputConnections | typeof CalculateConnectorsConnectableSides | typeof CalculateNodesBoundingBox | typeof CalculateNodesBoundingBoxNormalizedPosition | typeof CalculateOutputConnections | typeof FitToChildNodesAndGroups | typeof GetChildNodeIds | typeof GetNodePadding | typeof GetParentNodes | typeof UpdateNodeWhenStateOrSizeChanged | typeof RemoveNodeFromStore)[];

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

@@ -9,8 +9,8 @@ import * as i0 from "@angular/core";
 export declare class SelectAndUpdateNodeLayerExecution implements IHandler<SelectAndUpdateNodeLayerRequest, void> {
     private readonly _dragContext;
     private readonly _mediator;
-    handle(request: SelectAndUpdateNodeLayerRequest): void;
-    private selectNodeIfNotSelected;
+    handle({ nodeOrGroup }: SelectAndUpdateNodeLayerRequest): void;
+    private _selectNodeIfNotSelected;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectAndUpdateNodeLayerExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectAndUpdateNodeLayerExecution>;
 }

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

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

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

@@ -7,4 +7,4 @@ import { ResetZoomExecution } from './reset-zoom';
  * These executions handle the addition, removal, and resetting of zoom levels
  * in the FComponentsStore.
  */
-export declare const F_ZOOM_FEATURES: (typeof AddZoomToStoreExecution | typeof RemoveZoomFromStoreExecution | typeof ResetZoomExecution | typeof SetZoomExecution)[];
+export declare const F_ZOOM_FEATURES: (typeof SetZoomExecution | typeof ResetZoomExecution | typeof RemoveZoomFromStoreExecution | typeof AddZoomToStoreExecution)[];

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-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").CalculateSourceConnectorsToConnect | typeof import("./f-connectors").CalculateTargetConnectorsToConnect | 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-zoom").SetZoomExecution | typeof import("./f-zoom").AddZoomToStoreExecution | typeof import("./f-line-alignment").AddLineAlignmentToStoreExecution | typeof import("./f-flow").GetFlowStateNodesExecution | typeof import("./f-flow").AddFlowToStoreExecution | 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-draggable").AddDndToStoreExecution | typeof import("./f-draggable").OnPointerMoveExecution | typeof import("./f-node").AddNodeToStore | typeof import("./f-node").CalculateConnectableSideByConnectedPositions | typeof import("./f-node").CalculateConnectableSideByInternalPosition | typeof import("./f-node").CalculateInputConnections | typeof import("./f-node").CalculateConnectorsConnectableSides | 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 GetElementRoundedRectExecution | typeof import("./f-selection").SelectExecution | typeof import("./f-selection").SelectAndUpdateNodeLayerExecution | typeof GetDeepChildrenNodesAndGroupsExecution | typeof GetNormalizedConnectorRectExecution | typeof GetNormalizedElementRectExecution | typeof GetNormalizedPointExecution | typeof UpdateItemAndChildrenLayersExecution | typeof MoveFrontElementsBeforeTargetElementExecution)[];

package/esm2022/domain/css-cls.mjs

@@ -1,3 +1,4 @@
+/* eslint-disable */
 export const F_CSS_CLASS = {
     DRAG_AND_DROP: {
         DRAGGING: 'f-dragging',
@@ -18,4 +19,4 @@ export const F_CSS_CLASS = {
         DRAG_HANDLE: 'f-connection-drag-handle',
     },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3NzLWNscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZG9tYWluL2Nzcy1jbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHO0lBRXpCLGFBQWEsRUFBRTtRQUViLFFBQVEsRUFBRSxZQUFZO1FBRXRCLG9CQUFvQixFQUFFLHdCQUF3QjtLQUMvQztJQUVELFFBQVEsRUFBRTtRQUVSLGFBQWEsRUFBRSwwQkFBMEI7UUFFekMsV0FBVyxFQUFFLHdCQUF3QjtLQUN0QztJQUVELFNBQVMsRUFBRTtRQUVULGdCQUFnQixFQUFFLHlCQUF5QjtRQUUzQyxzQkFBc0IsRUFBRSwrQkFBK0I7UUFFdkQsZUFBZSxFQUFFLHdCQUF3QjtRQUV6QyxxQkFBcUIsRUFBRSw4QkFBOEI7UUFFckQsV0FBVyxFQUFFLHlCQUF5QjtLQUN2QztJQUVELFVBQVUsRUFBRTtRQUVWLFdBQVcsRUFBRSwwQkFBMEI7S0FDeEM7Q0FDRixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEZfQ1NTX0NMQVNTID0ge1xuXG4gIERSQUdfQU5EX0RST1A6IHtcblxuICAgIERSQUdHSU5HOiAnZi1kcmFnZ2luZycsXG5cbiAgICBDT05ORUNUSU9OU19EUkFHR0lORzogJ2YtY29ubmVjdGlvbnMtZHJhZ2dpbmcnLFxuICB9LFxuXG4gIEdST1VQSU5HOiB7XG5cbiAgICBPVkVSX0JPVU5EQVJZOiAnZi1ncm91cGluZy1vdmVyLWJvdW5kYXJ5JyxcblxuICAgIERST1BfQUNUSVZFOiAnZi1ncm91cGluZy1kcm9wLWFjdGl2ZScsXG4gIH0sXG5cbiAgQ09OTkVDVE9SOiB7XG5cbiAgICBPVVRQVVRfQ09OTkVDVEVEOiAnZi1ub2RlLW91dHB1dC1jb25uZWN0ZWQnLFxuXG4gICAgT1VUUFVUX05PVF9DT05ORUNUQUJMRTogJ2Ytbm9kZS1vdXRwdXQtbm90LWNvbm5lY3RhYmxlJyxcblxuICAgIElOUFVUX0NPTk5FQ1RFRDogJ2Ytbm9kZS1pbnB1dC1jb25uZWN0ZWQnLFxuXG4gICAgSU5QVVRfTk9UX0NPTk5FQ1RBQkxFOiAnZi1ub2RlLWlucHV0LW5vdC1jb25uZWN0YWJsZScsXG5cbiAgICBDT05ORUNUQUJMRTogJ2YtY29ubmVjdG9yLWNvbm5lY3RhYmxlJyxcbiAgfSxcblxuICBDT05ORUNUSU9OOiB7XG5cbiAgICBEUkFHX0hBTkRMRTogJ2YtY29ubmVjdGlvbi1kcmFnLWhhbmRsZScsXG4gIH0sXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3NzLWNscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZG9tYWluL2Nzcy1jbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRztJQUN6QixhQUFhLEVBQUU7UUFDYixRQUFRLEVBQUUsWUFBWTtRQUV0QixvQkFBb0IsRUFBRSx3QkFBd0I7S0FDL0M7SUFFRCxRQUFRLEVBQUU7UUFDUixhQUFhLEVBQUUsMEJBQTBCO1FBRXpDLFdBQVcsRUFBRSx3QkFBd0I7S0FDdEM7SUFFRCxTQUFTLEVBQUU7UUFDVCxnQkFBZ0IsRUFBRSx5QkFBeUI7UUFFM0Msc0JBQXNCLEVBQUUsK0JBQStCO1FBRXZELGVBQWUsRUFBRSx3QkFBd0I7UUFFekMscUJBQXFCLEVBQUUsOEJBQThCO1FBRXJELFdBQVcsRUFBRSx5QkFBeUI7S0FDdkM7SUFFRCxVQUFVLEVBQUU7UUFDVixXQUFXLEVBQUUsMEJBQTBCO0tBQ3hDO0NBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlICovXG5leHBvcnQgY29uc3QgRl9DU1NfQ0xBU1MgPSB7XG4gIERSQUdfQU5EX0RST1A6IHtcbiAgICBEUkFHR0lORzogJ2YtZHJhZ2dpbmcnLFxuXG4gICAgQ09OTkVDVElPTlNfRFJBR0dJTkc6ICdmLWNvbm5lY3Rpb25zLWRyYWdnaW5nJyxcbiAgfSxcblxuICBHUk9VUElORzoge1xuICAgIE9WRVJfQk9VTkRBUlk6ICdmLWdyb3VwaW5nLW92ZXItYm91bmRhcnknLFxuXG4gICAgRFJPUF9BQ1RJVkU6ICdmLWdyb3VwaW5nLWRyb3AtYWN0aXZlJyxcbiAgfSxcblxuICBDT05ORUNUT1I6IHtcbiAgICBPVVRQVVRfQ09OTkVDVEVEOiAnZi1ub2RlLW91dHB1dC1jb25uZWN0ZWQnLFxuXG4gICAgT1VUUFVUX05PVF9DT05ORUNUQUJMRTogJ2Ytbm9kZS1vdXRwdXQtbm90LWNvbm5lY3RhYmxlJyxcblxuICAgIElOUFVUX0NPTk5FQ1RFRDogJ2Ytbm9kZS1pbnB1dC1jb25uZWN0ZWQnLFxuXG4gICAgSU5QVVRfTk9UX0NPTk5FQ1RBQkxFOiAnZi1ub2RlLWlucHV0LW5vdC1jb25uZWN0YWJsZScsXG5cbiAgICBDT05ORUNUQUJMRTogJ2YtY29ubmVjdG9yLWNvbm5lY3RhYmxlJyxcbiAgfSxcblxuICBDT05ORUNUSU9OOiB7XG4gICAgRFJBR19IQU5ETEU6ICdmLWNvbm5lY3Rpb24tZHJhZy1oYW5kbGUnLFxuICB9LFxufTtcbiJdfQ==

package/esm2022/domain/f-connectors/calculate-source-connectors-to-connect/calculate-source-connectors-to-connect-request.mjs

@@ -0,0 +1,10 @@
+export class CalculateSourceConnectorsToConnectRequest {
+    targetConnector;
+    pointerPosition;
+    static fToken = Symbol('CalculateSourceConnectorsToConnectRequest');
+    constructor(targetConnector, pointerPosition) {
+        this.targetConnector = targetConnector;
+        this.pointerPosition = pointerPosition;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QtcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdG9ycy9jYWxjdWxhdGUtc291cmNlLWNvbm5lY3RvcnMtdG8tY29ubmVjdC9jYWxjdWxhdGUtc291cmNlLWNvbm5lY3RvcnMtdG8tY29ubmVjdC1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx5Q0FBeUM7SUFJbEM7SUFDQTtJQUpsQixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO0lBRTdFLFlBQ2tCLGVBQStCLEVBQy9CLGVBQXVCO1FBRHZCLG9CQUFlLEdBQWYsZUFBZSxDQUFnQjtRQUMvQixvQkFBZSxHQUFmLGVBQWUsQ0FBUTtJQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRk5vZGVJbnB1dEJhc2UgfSBmcm9tICcuLi8uLi8uLi9mLWNvbm5lY3RvcnMnO1xuaW1wb3J0IHsgSVBvaW50IH0gZnJvbSAnQGZvYmxleC8yZCc7XG5cbmV4cG9ydCBjbGFzcyBDYWxjdWxhdGVTb3VyY2VDb25uZWN0b3JzVG9Db25uZWN0UmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0NhbGN1bGF0ZVNvdXJjZUNvbm5lY3RvcnNUb0Nvbm5lY3RSZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIHJlYWRvbmx5IHRhcmdldENvbm5lY3RvcjogRk5vZGVJbnB1dEJhc2UsXG4gICAgcHVibGljIHJlYWRvbmx5IHBvaW50ZXJQb3NpdGlvbjogSVBvaW50LFxuICApIHt9XG59XG4iXX0=

package/esm2022/domain/f-connectors/calculate-source-connectors-to-connect/calculate-source-connectors-to-connect.mjs

@@ -0,0 +1,59 @@
+import { __decorate } from "tslib";
+import { CalculateSourceConnectorsToConnectRequest } from './calculate-source-connectors-to-connect-request';
+import { inject, Injectable } from '@angular/core';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { GetConnectorAndRectRequest } from '../get-connector-and-rect';
+import { CalculateConnectableSideByConnectedPositionsRequest, isCalculateMode } from '../../f-node';
+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.
+ */
+let CalculateSourceConnectorsToConnect = class CalculateSourceConnectorsToConnect {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    get _sourceConnectors() {
+        return this._store.fOutputs;
+    }
+    handle({ targetConnector, pointerPosition, }) {
+        const result = this._getConnectableSources(targetConnector).map((x) => {
+            return this._mediator.execute(new GetConnectorAndRectRequest(x));
+        });
+        setTimeout(() => {
+            this._calculateConnectableSides(result, pointerPosition);
+        });
+        return result;
+    }
+    _getConnectableSources(targetConnector) {
+        return this._sourceConnectors.filter((x) => {
+            let result = x.canBeConnected;
+            if (result && x.hasConnectionLimits) {
+                result = x.canConnectTo(targetConnector);
+            }
+            return result;
+        });
+    }
+    _calculateConnectableSides(connectors, pointerPosition) {
+        connectors.forEach((x) => {
+            if (isCalculateMode(x.fConnector.userFConnectableSide)) {
+                x.fConnector.fConnectableSide = this._calculateByConnectedPositions(x.fConnector, pointerPosition);
+            }
+        });
+    }
+    /** Delegates to the connected-positions calculation execution. */
+    _calculateByConnectedPositions(connector, pointerPosition) {
+        return this._mediator.execute(new CalculateConnectableSideByConnectedPositionsRequest(connector, pointerPosition));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateSourceConnectorsToConnect, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateSourceConnectorsToConnect });
+};
+CalculateSourceConnectorsToConnect = __decorate([
+    FExecutionRegister(CalculateSourceConnectorsToConnectRequest)
+], CalculateSourceConnectorsToConnect);
+export { CalculateSourceConnectorsToConnect };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalculateSourceConnectorsToConnect, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9mLWNvbm5lY3RvcnMvY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QvY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBQzdHLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxTQUFTLEVBQWMsTUFBTSxrQkFBa0IsQ0FBQztBQU83RSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RCxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV2RSxPQUFPLEVBQUUsbURBQW1ELEVBQUUsZUFBZSxFQUFFLE1BQU0sY0FBYyxDQUFDOztBQUVwRzs7OztHQUlHO0FBR0ksSUFBTSxrQ0FBa0MsR0FBeEMsTUFBTSxrQ0FBa0M7SUFHNUIsU0FBUyxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM5QixNQUFNLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFFbkQsSUFBWSxpQkFBaUI7UUFDM0IsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQTZCLENBQUM7SUFDbkQsQ0FBQztJQUVNLE1BQU0sQ0FBQyxFQUNaLGVBQWUsRUFDZixlQUFlLEdBQzJCO1FBQzFDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxlQUFlLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUNwRSxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFvQixJQUFJLDBCQUEwQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdEYsQ0FBQyxDQUFDLENBQUM7UUFFSCxVQUFVLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxDQUFDLDBCQUEwQixDQUFDLE1BQU0sRUFBRSxlQUFlLENBQUMsQ0FBQztRQUMzRCxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFTyxzQkFBc0IsQ0FBQyxlQUErQjtRQUM1RCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUN6QyxJQUFJLE1BQU0sR0FBRyxDQUFDLENBQUMsY0FBYyxDQUFDO1lBQzlCLElBQUksTUFBTSxJQUFJLENBQUMsQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO2dCQUNwQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLFlBQVksQ0FBQyxlQUFlLENBQUMsQ0FBQztZQUMzQyxDQUFDO1lBRUQsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sMEJBQTBCLENBQ2hDLFVBQStCLEVBQy9CLGVBQXVCO1FBRXZCLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUN2QixJQUFJLGVBQWUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLG9CQUFvQixDQUFDLEVBQUUsQ0FBQztnQkFDdkQsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsOEJBQThCLENBQ2pFLENBQUMsQ0FBQyxVQUFVLEVBQ1osZUFBZSxDQUNoQixDQUFDO1lBQ0osQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELGtFQUFrRTtJQUMxRCw4QkFBOEIsQ0FDcEMsU0FBeUIsRUFDekIsZUFBdUI7UUFFdkIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FDM0IsSUFBSSxtREFBbUQsQ0FBQyxTQUFTLEVBQUUsZUFBZSxDQUFDLENBQ3BGLENBQUM7SUFDSixDQUFDO3dHQTFEVSxrQ0FBa0M7NEdBQWxDLGtDQUFrQzs7QUFBbEMsa0NBQWtDO0lBRDlDLGtCQUFrQixDQUFDLHlDQUF5QyxDQUFDO0dBQ2pELGtDQUFrQyxDQTJEOUM7OzRGQTNEWSxrQ0FBa0M7a0JBRjlDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYWxjdWxhdGVTb3VyY2VDb25uZWN0b3JzVG9Db25uZWN0UmVxdWVzdCB9IGZyb20gJy4vY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QtcmVxdWVzdCc7XG5pbXBvcnQgeyBpbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZFeGVjdXRpb25SZWdpc3RlciwgRk1lZGlhdG9yLCBJRXhlY3V0aW9uIH0gZnJvbSAnQGZvYmxleC9tZWRpYXRvcic7XG5pbXBvcnQge1xuICBFRkNvbm5lY3RhYmxlU2lkZSxcbiAgRkNvbm5lY3RvckJhc2UsXG4gIEZOb2RlSW5wdXRCYXNlLFxuICBGTm9kZU91dHB1dEJhc2UsXG59IGZyb20gJy4uLy4uLy4uL2YtY29ubmVjdG9ycyc7XG5pbXBvcnQgeyBGQ29tcG9uZW50c1N0b3JlIH0gZnJvbSAnLi4vLi4vLi4vZi1zdG9yYWdlJztcbmltcG9ydCB7IElDb25uZWN0b3JBbmRSZWN0IH0gZnJvbSAnLi4vaS1jb25uZWN0b3ItYW5kLXJlY3QnO1xuaW1wb3J0IHsgR2V0Q29ubmVjdG9yQW5kUmVjdFJlcXVlc3QgfSBmcm9tICcuLi9nZXQtY29ubmVjdG9yLWFuZC1yZWN0JztcbmltcG9ydCB7IElQb2ludCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuaW1wb3J0IHsgQ2FsY3VsYXRlQ29ubmVjdGFibGVTaWRlQnlDb25uZWN0ZWRQb3NpdGlvbnNSZXF1ZXN0LCBpc0NhbGN1bGF0ZU1vZGUgfSBmcm9tICcuLi8uLi9mLW5vZGUnO1xuXG4vKipcbiAqIEV4ZWN1dGlvbiB0aGF0IHJldHJpZXZlcyBhbGwgc291cmNlIGNvbm5lY3RvcnMgdGhhdCBjYW4gYmUgY29ubmVjdGVkIHRvIGEgZ2l2ZW4gdGFyZ2V0IGNvbm5lY3RvcixcbiAqIGFsb25nIHdpdGggdGhlaXIgcmVjdGFuZ2xlcy5cbiAqIFNvdXJjZSAtIE91dHB1dCBvciBPdXRsZXQgY29ubmVjdG9ycy5cbiAqL1xuQEluamVjdGFibGUoKVxuQEZFeGVjdXRpb25SZWdpc3RlcihDYWxjdWxhdGVTb3VyY2VDb25uZWN0b3JzVG9Db25uZWN0UmVxdWVzdClcbmV4cG9ydCBjbGFzcyBDYWxjdWxhdGVTb3VyY2VDb25uZWN0b3JzVG9Db25uZWN0XG4gIGltcGxlbWVudHMgSUV4ZWN1dGlvbjxDYWxjdWxhdGVTb3VyY2VDb25uZWN0b3JzVG9Db25uZWN0UmVxdWVzdCwgSUNvbm5lY3RvckFuZFJlY3RbXT5cbntcbiAgcHJpdmF0ZSByZWFkb25seSBfbWVkaWF0b3IgPSBpbmplY3QoRk1lZGlhdG9yKTtcbiAgcHJpdmF0ZSByZWFkb25seSBfc3RvcmUgPSBpbmplY3QoRkNvbXBvbmVudHNTdG9yZSk7XG5cbiAgcHJpdmF0ZSBnZXQgX3NvdXJjZUNvbm5lY3RvcnMoKTogRk5vZGVPdXRwdXRCYXNlW10ge1xuICAgIHJldHVybiB0aGlzLl9zdG9yZS5mT3V0cHV0cyBhcyBGTm9kZU91dHB1dEJhc2VbXTtcbiAgfVxuXG4gIHB1YmxpYyBoYW5kbGUoe1xuICAgIHRhcmdldENvbm5lY3RvcixcbiAgICBwb2ludGVyUG9zaXRpb24sXG4gIH06IENhbGN1bGF0ZVNvdXJjZUNvbm5lY3RvcnNUb0Nvbm5lY3RSZXF1ZXN0KTogSUNvbm5lY3RvckFuZFJlY3RbXSB7XG4gICAgY29uc3QgcmVzdWx0ID0gdGhpcy5fZ2V0Q29ubmVjdGFibGVTb3VyY2VzKHRhcmdldENvbm5lY3RvcikubWFwKCh4KSA9PiB7XG4gICAgICByZXR1cm4gdGhpcy5fbWVkaWF0b3IuZXhlY3V0ZTxJQ29ubmVjdG9yQW5kUmVjdD4obmV3IEdldENvbm5lY3RvckFuZFJlY3RSZXF1ZXN0KHgpKTtcbiAgICB9KTtcblxuICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgdGhpcy5fY2FsY3VsYXRlQ29ubmVjdGFibGVTaWRlcyhyZXN1bHQsIHBvaW50ZXJQb3NpdGlvbik7XG4gICAgfSk7XG5cbiAgICByZXR1cm4gcmVzdWx0O1xuICB9XG5cbiAgcHJpdmF0ZSBfZ2V0Q29ubmVjdGFibGVTb3VyY2VzKHRhcmdldENvbm5lY3RvcjogRk5vZGVJbnB1dEJhc2UpOiBGQ29ubmVjdG9yQmFzZVtdIHtcbiAgICByZXR1cm4gdGhpcy5fc291cmNlQ29ubmVjdG9ycy5maWx0ZXIoKHgpID0+IHtcbiAgICAgIGxldCByZXN1bHQgPSB4LmNhbkJlQ29ubmVjdGVkO1xuICAgICAgaWYgKHJlc3VsdCAmJiB4Lmhhc0Nvbm5lY3Rpb25MaW1pdHMpIHtcbiAgICAgICAgcmVzdWx0ID0geC5jYW5Db25uZWN0VG8odGFyZ2V0Q29ubmVjdG9yKTtcbiAgICAgIH1cblxuICAgICAgcmV0dXJuIHJlc3VsdDtcbiAgICB9KTtcbiAgfVxuXG4gIHByaXZhdGUgX2NhbGN1bGF0ZUNvbm5lY3RhYmxlU2lkZXMoXG4gICAgY29ubmVjdG9yczogSUNvbm5lY3RvckFuZFJlY3RbXSxcbiAgICBwb2ludGVyUG9zaXRpb246IElQb2ludCxcbiAgKTogdm9pZCB7XG4gICAgY29ubmVjdG9ycy5mb3JFYWNoKCh4KSA9PiB7XG4gICAgICBpZiAoaXNDYWxjdWxhdGVNb2RlKHguZkNvbm5lY3Rvci51c2VyRkNvbm5lY3RhYmxlU2lkZSkpIHtcbiAgICAgICAgeC5mQ29ubmVjdG9yLmZDb25uZWN0YWJsZVNpZGUgPSB0aGlzLl9jYWxjdWxhdGVCeUNvbm5lY3RlZFBvc2l0aW9ucyhcbiAgICAgICAgICB4LmZDb25uZWN0b3IsXG4gICAgICAgICAgcG9pbnRlclBvc2l0aW9uLFxuICAgICAgICApO1xuICAgICAgfVxuICAgIH0pO1xuICB9XG5cbiAgLyoqIERlbGVnYXRlcyB0byB0aGUgY29ubmVjdGVkLXBvc2l0aW9ucyBjYWxjdWxhdGlvbiBleGVjdXRpb24uICovXG4gIHByaXZhdGUgX2NhbGN1bGF0ZUJ5Q29ubmVjdGVkUG9zaXRpb25zKFxuICAgIGNvbm5lY3RvcjogRkNvbm5lY3RvckJhc2UsXG4gICAgcG9pbnRlclBvc2l0aW9uOiBJUG9pbnQsXG4gICk6IEVGQ29ubmVjdGFibGVTaWRlIHtcbiAgICByZXR1cm4gdGhpcy5fbWVkaWF0b3IuZXhlY3V0ZShcbiAgICAgIG5ldyBDYWxjdWxhdGVDb25uZWN0YWJsZVNpZGVCeUNvbm5lY3RlZFBvc2l0aW9uc1JlcXVlc3QoY29ubmVjdG9yLCBwb2ludGVyUG9zaXRpb24pLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/domain/f-connectors/calculate-source-connectors-to-connect/index.mjs

@@ -0,0 +1,3 @@
+export * from './calculate-source-connectors-to-connect-request';
+export * from './calculate-source-connectors-to-connect';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2RvbWFpbi9mLWNvbm5lY3RvcnMvY2FsY3VsYXRlLXNvdXJjZS1jb25uZWN0b3JzLXRvLWNvbm5lY3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrREFBa0QsQ0FBQztBQUVqRSxjQUFjLDBDQUEwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jYWxjdWxhdGUtc291cmNlLWNvbm5lY3RvcnMtdG8tY29ubmVjdC1yZXF1ZXN0JztcblxuZXhwb3J0ICogZnJvbSAnLi9jYWxjdWxhdGUtc291cmNlLWNvbm5lY3RvcnMtdG8tY29ubmVjdCc7XG4iXX0=

package/esm2022/domain/f-connectors/calculate-target-connectors-to-connect/calculate-target-connectors-to-connect-request.mjs

@@ -0,0 +1,10 @@
+export class CalculateTargetConnectorsToConnectRequest {
+    sourceConnector;
+    pointerPosition;
+    static fToken = Symbol('CalculateTargetConnectorsToConnectRequest');
+    constructor(sourceConnector, pointerPosition) {
+        this.sourceConnector = sourceConnector;
+        this.pointerPosition = pointerPosition;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLXRhcmdldC1jb25uZWN0b3JzLXRvLWNvbm5lY3QtcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZG9tYWluL2YtY29ubmVjdG9ycy9jYWxjdWxhdGUtdGFyZ2V0LWNvbm5lY3RvcnMtdG8tY29ubmVjdC9jYWxjdWxhdGUtdGFyZ2V0LWNvbm5lY3RvcnMtdG8tY29ubmVjdC1yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx5Q0FBeUM7SUFHbEM7SUFDQTtJQUhsQixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO0lBQzdFLFlBQ2tCLGVBQWtELEVBQ2xELGVBQXVCO1FBRHZCLG9CQUFlLEdBQWYsZUFBZSxDQUFtQztRQUNsRCxvQkFBZSxHQUFmLGVBQWUsQ0FBUTtJQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRk5vZGVPdXRsZXRCYXNlLCBGTm9kZU91dHB1dEJhc2UgfSBmcm9tICcuLi8uLi8uLi9mLWNvbm5lY3RvcnMnO1xuaW1wb3J0IHsgSVBvaW50IH0gZnJvbSAnQGZvYmxleC8yZCc7XG5cbmV4cG9ydCBjbGFzcyBDYWxjdWxhdGVUYXJnZXRDb25uZWN0b3JzVG9Db25uZWN0UmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0NhbGN1bGF0ZVRhcmdldENvbm5lY3RvcnNUb0Nvbm5lY3RSZXF1ZXN0Jyk7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyByZWFkb25seSBzb3VyY2VDb25uZWN0b3I6IEZOb2RlT3V0cHV0QmFzZSB8IEZOb2RlT3V0bGV0QmFzZSxcbiAgICBwdWJsaWMgcmVhZG9ubHkgcG9pbnRlclBvc2l0aW9uOiBJUG9pbnQsXG4gICkge31cbn1cbiJdfQ==