@foblex/flow 17.1.0 → 17.2.0

package/domain/css-cls.d.ts

@@ -0,0 +1,13 @@
+export declare const F_CSS_CLASS: {
+    DRAG_AND_DROP: {
+        DRAGGING: string;
+        CONNECTIONS_DRAGGING: string;
+    };
+    CONNECTOR: {
+        OUTPUT_CONNECTED: string;
+        OUTPUT_NOT_CONNECTABLE: string;
+        INPUT_CONNECTED: string;
+        INPUT_NOT_CONNECTABLE: string;
+        INPUT_CAN_BE_CONNECTED_TO: string;
+    };
+};

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

@@ -2,4 +2,4 @@ import { AddPatternToBackgroundExecution } from './add-pattern-to-background';
 import { AddBackgroundToStoreExecution } from './add-background-to-store';
 import { RemoveBackgroundFromStoreExecution } from './remove-background-from-store';
 import { SetBackgroundTransformExecution } from './set-background-transform';
-export declare const F_BACKGROUND_FEATURES: (typeof AddPatternToBackgroundExecution | typeof AddBackgroundToStoreExecution | typeof RemoveBackgroundFromStoreExecution | typeof SetBackgroundTransformExecution)[];
+export declare const F_BACKGROUND_FEATURES: (typeof AddBackgroundToStoreExecution | typeof AddPatternToBackgroundExecution | typeof RemoveBackgroundFromStoreExecution | typeof SetBackgroundTransformExecution)[];

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

@@ -9,4 +9,4 @@ import { AddCanvasToStoreExecution } from './add-canvas-to-store';
 import { RemoveCanvasFromStoreExecution } from './remove-canvas-from-store';
 import { GetCanvasExecution } from './get-canvas';
 import { RedrawCanvasWithAnimationExecution } from './redraw-canvas-with-animation';
-export declare const F_CANVAS_FEATURES: (typeof ResetScaleAndCenterExecution | typeof FitToFlowExecution | typeof CenterGroupOrNodeExecution | typeof AddCanvasToStoreExecution | typeof GetCanvasExecution | typeof InputCanvasPositionExecution | typeof InputCanvasScaleExecution | typeof RedrawCanvasWithAnimationExecution | typeof RemoveCanvasFromStoreExecution | typeof ResetScaleExecution | typeof UpdateScaleExecution)[];
+export declare const F_CANVAS_FEATURES: (typeof AddCanvasToStoreExecution | typeof CenterGroupOrNodeExecution | typeof FitToFlowExecution | typeof GetCanvasExecution | typeof InputCanvasPositionExecution | typeof InputCanvasScaleExecution | typeof RedrawCanvasWithAnimationExecution | typeof RemoveCanvasFromStoreExecution | typeof ResetScaleExecution | typeof ResetScaleAndCenterExecution | typeof UpdateScaleExecution)[];

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

@@ -3,10 +3,7 @@ export * from './add-connection-marker-to-store';
 export * from './add-connection-to-store';
 export * from './add-snap-connection-to-store';
 export * from './create-connection-markers';
-export * from './find-closest-input';
-export * from './get-all-can-be-connected-input-positions';
 export * from './calculate-connection-line-by-behavior';
-export * from './get-connector-with-rect';
 export * from './redraw-connections';
 export * from './remove-connection-for-create-from-store';
 export * from './remove-connection-from-store';

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

@@ -1,6 +1,3 @@
-import { FindClosestInputExecution } from './find-closest-input';
-import { GetAllCanBeConnectedInputPositionsExecution } from './get-all-can-be-connected-input-positions';
-import { GetConnectorWithRectExecution } from './get-connector-with-rect';
 import { CreateConnectionMarkersExecution } from './create-connection-markers';
 import { AddConnectionForCreateToStoreExecution } from './add-connection-for-create-to-store';
 import { AddConnectionToStoreExecution } from './add-connection-to-store';
@@ -12,4 +9,4 @@ import { AddConnectionMarkerToStoreExecution } from './add-connection-marker-to-
 import { RemoveConnectionMarkerFromStoreExecution } from './remove-connection-marker-from-store';
 import { RedrawConnectionsExecution } from './redraw-connections';
 import { CalculateConnectionLineByBehaviorExecution } from './calculate-connection-line-by-behavior';
-export declare const F_CONNECTION_FEATURES: (typeof AddConnectionForCreateToStoreExecution | typeof AddConnectionMarkerToStoreExecution | typeof AddConnectionToStoreExecution | typeof AddSnapConnectionToStoreExecution | typeof CreateConnectionMarkersExecution | typeof FindClosestInputExecution | typeof GetAllCanBeConnectedInputPositionsExecution | typeof CalculateConnectionLineByBehaviorExecution | typeof GetConnectorWithRectExecution | typeof RedrawConnectionsExecution | typeof RemoveConnectionForCreateFromStoreExecution | typeof RemoveConnectionFromStoreExecution | typeof RemoveConnectionMarkerFromStoreExecution | typeof RemoveSnapConnectionFromStoreExecution)[];
+export declare const F_CONNECTION_FEATURES: (typeof AddConnectionForCreateToStoreExecution | typeof AddConnectionMarkerToStoreExecution | typeof AddConnectionToStoreExecution | typeof AddSnapConnectionToStoreExecution | typeof CreateConnectionMarkersExecution | typeof CalculateConnectionLineByBehaviorExecution | typeof RedrawConnectionsExecution | typeof RemoveConnectionForCreateFromStoreExecution | typeof RemoveConnectionFromStoreExecution | typeof RemoveConnectionMarkerFromStoreExecution | typeof RemoveSnapConnectionFromStoreExecution)[];

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

@@ -7,8 +7,8 @@ export declare class RedrawConnectionsExecution implements IExecution<RedrawConn
     private fMediator;
     constructor(fComponentsStore: FComponentsStore, fMediator: FMediator);
     handle(request: RedrawConnectionsRequest): void;
-    private resetConnectors;
-    private setupConnection;
+    private _resetConnectors;
+    private _setupConnection;
     private getLine;
     private setMarkers;
     static ɵfac: i0.ɵɵFactoryDeclaration<RedrawConnectionsExecution, never>;

package/domain/f-connectors/calculate-closest-input/calculate-closest-input.execution.d.ts

@@ -0,0 +1,11 @@
+import { CalculateClosestInputRequest } from './calculate-closest-input.request';
+import { IExecution } from '@foblex/mediator';
+import { IClosestInput } from '../i-closest-input';
+import * as i0 from "@angular/core";
+export declare class CalculateClosestInputExecution implements IExecution<CalculateClosestInputRequest, IClosestInput | undefined> {
+    handle(payload: CalculateClosestInputRequest): IClosestInput | undefined;
+    private _distanceToRectangle;
+    private _clamp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateClosestInputExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateClosestInputExecution>;
+}

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

@@ -0,0 +1,7 @@
+import { IPoint } from '@foblex/2d';
+import { IConnectorAndRect } from '../index';
+export declare class CalculateClosestInputRequest {
+    position: IPoint;
+    canBeConnectedInputs: IConnectorAndRect[];
+    constructor(position: IPoint, canBeConnectedInputs: IConnectorAndRect[]);
+}

package/domain/f-connectors/calculate-closest-input/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-closest-input.request';
+export * from './calculate-closest-input.execution';

package/domain/f-connectors/find-input-at-position/find-input-at-position.execution.d.ts

@@ -0,0 +1,24 @@
+import { FindInputAtPositionRequest } from './find-input-at-position.request';
+import { IExecution } from '@foblex/mediator';
+import { FConnectorBase } from '../../../f-connectors';
+import * as i0 from "@angular/core";
+export declare class FindInputAtPositionExecution implements IExecution<FindInputAtPositionRequest, FConnectorBase | undefined> {
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private _fBrowser;
+    private get _fNodes();
+    private get _fSnapConnection();
+    handle(payload: FindInputAtPositionRequest): FConnectorBase | undefined;
+    private _findInputsAtPosition;
+    private _getConnectableInputsAtPosition;
+    private _calculateDifference;
+    private _calculateClosetInput;
+    private _isValidClosestInput;
+    private _getFirstConnectableInputOfNodeAtPosition;
+    private _getElementsFromPoint;
+    private _findConnectableNode;
+    private _findFirstConnectableInputOfNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FindInputAtPositionExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FindInputAtPositionExecution>;
+}

package/domain/f-connectors/find-input-at-position/find-input-at-position.request.d.ts

@@ -0,0 +1,8 @@
+import { IPoint, IRoundedRect } from '@foblex/2d';
+import { IConnectorAndRect } from '../i-connector-and-rect';
+export declare class FindInputAtPositionRequest {
+    pointerPosition: IPoint;
+    toConnectorRect: IRoundedRect;
+    canBeConnectedInputs: IConnectorAndRect[];
+    constructor(pointerPosition: IPoint, toConnectorRect: IRoundedRect, canBeConnectedInputs: IConnectorAndRect[]);
+}

package/domain/f-connectors/find-input-at-position/index.d.ts

@@ -0,0 +1,2 @@
+export * from './find-input-at-position.request';
+export * from './find-input-at-position.execution';

package/domain/f-connectors/get-all-can-be-connected-inputs-and-rects/get-all-can-be-connected-inputs-and-rects.execution.d.ts

@@ -0,0 +1,14 @@
+import { GetAllCanBeConnectedInputsAndRectsRequest } from './get-all-can-be-connected-inputs-and-rects.request';
+import { IExecution } from '@foblex/mediator';
+import { IConnectorAndRect } from '../i-connector-and-rect';
+import * as i0 from "@angular/core";
+export declare class GetAllCanBeConnectedInputsAndRectsExecution implements IExecution<GetAllCanBeConnectedInputsAndRectsRequest, IConnectorAndRect[]> {
+    private _fMediator;
+    private _fComponentsStore;
+    private get _fInputs();
+    handle(payload: GetAllCanBeConnectedInputsAndRectsRequest): IConnectorAndRect[];
+    private _getCanBeConnectedInputs;
+    private _filterSelfConnectable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetAllCanBeConnectedInputsAndRectsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetAllCanBeConnectedInputsAndRectsExecution>;
+}

package/domain/f-connectors/get-all-can-be-connected-inputs-and-rects/get-all-can-be-connected-inputs-and-rects.request.d.ts

@@ -0,0 +1,5 @@
+import { FNodeOutletBase, FNodeOutputBase } from '../../../f-connectors';
+export declare class GetAllCanBeConnectedInputsAndRectsRequest {
+    fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase;
+    constructor(fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase);
+}

package/domain/f-connectors/get-all-can-be-connected-inputs-and-rects/index.d.ts

@@ -0,0 +1,2 @@
+export * from './get-all-can-be-connected-inputs-and-rects.request';
+export * from './get-all-can-be-connected-inputs-and-rects.execution';

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

@@ -0,0 +1,5 @@
+import { FConnectorBase } from '../../../f-connectors';
+export declare class GetConnectorAndRectRequest {
+    fConnector: FConnectorBase;
+    constructor(fConnector: FConnectorBase);
+}

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

@@ -0,0 +1,11 @@
+import { IExecution } from '@foblex/mediator';
+import { GetConnectorAndRectRequest } from './get-connector-and-rect-request';
+import { IConnectorAndRect } from '../i-connector-and-rect';
+import * as i0 from "@angular/core";
+export declare class GetConnectorAndRectExecution implements IExecution<GetConnectorAndRectRequest, IConnectorAndRect> {
+    private _fMediator;
+    handle(request: GetConnectorAndRectRequest): IConnectorAndRect;
+    private _getConnectorRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetConnectorAndRectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetConnectorAndRectExecution>;
+}

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

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

package/domain/{f-connection/find-closest-input → f-connectors}/i-closest-input.d.ts

@@ -1,5 +1,5 @@
 import { IRoundedRect } from '@foblex/2d';
-import { FConnectorBase } from '../../../f-connectors';
+import { FConnectorBase } from '../../f-connectors';
 export interface IClosestInput {
     fConnector: FConnectorBase;
     fRect: IRoundedRect;

package/domain/{f-connection/get-connector-with-rect/i-connector-with-rect.d.ts → f-connectors/i-connector-and-rect.d.ts}

@@ -1,6 +1,6 @@
 import { IRoundedRect } from '@foblex/2d';
-import { FConnectorBase } from '../../../f-connectors';
-export interface IConnectorWithRect {
+import { FConnectorBase } from '../../f-connectors';
+export interface IConnectorAndRect {
     fConnector: FConnectorBase;
     fRect: IRoundedRect;
 }

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

@@ -1,7 +1,15 @@
 export * from './add-input-to-store';
 export * from './add-outlet-to-store';
 export * from './add-output-to-store';
+export * from './calculate-closest-input';
+export * from './find-input-at-position';
+export * from './get-all-can-be-connected-inputs-and-rects';
+export * from './get-connector-and-rect';
+export * from './mark-all-can-be-connected-inputs';
 export * from './remove-input-from-store';
 export * from './remove-outlet-from-store';
 export * from './remove-output-from-store';
+export * from './unmark-all-can-be-connected-inputs';
+export * from './i-closest-input';
+export * from './i-connector-and-rect';
 export * from './providers';

package/domain/f-connectors/mark-all-can-be-connected-inputs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mark-all-can-be-connected-inputs.request';
+export * from './mark-all-can-be-connected-inputs.execution';

package/domain/f-connectors/mark-all-can-be-connected-inputs/mark-all-can-be-connected-inputs.execution.d.ts

@@ -0,0 +1,10 @@
+import { MarkAllCanBeConnectedInputsRequest } from './mark-all-can-be-connected-inputs.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class MarkAllCanBeConnectedInputsExecution implements IExecution<MarkAllCanBeConnectedInputsRequest, void> {
+    private _fComponentsStore;
+    handle(payload: MarkAllCanBeConnectedInputsRequest): void;
+    private _markCanBeConnectedTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkAllCanBeConnectedInputsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkAllCanBeConnectedInputsExecution>;
+}

package/domain/f-connectors/mark-all-can-be-connected-inputs/mark-all-can-be-connected-inputs.request.d.ts

@@ -0,0 +1,5 @@
+import { FConnectorBase } from '../../../f-connectors';
+export declare class MarkAllCanBeConnectedInputsRequest {
+    fInputs: FConnectorBase[];
+    constructor(fInputs: FConnectorBase[]);
+}

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

@@ -4,4 +4,10 @@ import { AddOutputToStoreExecution } from './add-output-to-store';
 import { RemoveInputFromStoreExecution } from './remove-input-from-store';
 import { RemoveOutletFromStoreExecution } from './remove-outlet-from-store';
 import { RemoveOutputFromStoreExecution } from './remove-output-from-store';
-export declare const F_CONNECTORS_FEATURES: (typeof AddInputToStoreExecution | typeof AddOutletToStoreExecution | typeof AddOutputToStoreExecution | typeof RemoveInputFromStoreExecution | typeof RemoveOutletFromStoreExecution | typeof RemoveOutputFromStoreExecution)[];
+import { MarkAllCanBeConnectedInputsExecution } from './mark-all-can-be-connected-inputs';
+import { UnmarkAllCanBeConnectedInputsExecution } from './unmark-all-can-be-connected-inputs';
+import { GetAllCanBeConnectedInputsAndRectsExecution } from './get-all-can-be-connected-inputs-and-rects';
+import { GetConnectorAndRectExecution } from './get-connector-and-rect';
+import { CalculateClosestInputExecution } from './calculate-closest-input';
+import { FindInputAtPositionExecution } from './find-input-at-position';
+export declare const F_CONNECTORS_FEATURES: (typeof FindInputAtPositionExecution | typeof AddInputToStoreExecution | typeof AddOutletToStoreExecution | typeof AddOutputToStoreExecution | typeof CalculateClosestInputExecution | typeof GetAllCanBeConnectedInputsAndRectsExecution | typeof GetConnectorAndRectExecution | typeof MarkAllCanBeConnectedInputsExecution | typeof RemoveInputFromStoreExecution | typeof RemoveOutletFromStoreExecution | typeof RemoveOutputFromStoreExecution | typeof UnmarkAllCanBeConnectedInputsExecution)[];

package/domain/f-connectors/unmark-all-can-be-connected-inputs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './unmark-all-can-be-connected-inputs.request';
+export * from './unmark-all-can-be-connected-inputs.execution';

package/domain/f-connectors/unmark-all-can-be-connected-inputs/unmark-all-can-be-connected-inputs.execution.d.ts

@@ -0,0 +1,10 @@
+import { UnmarkAllCanBeConnectedInputsRequest } from './unmark-all-can-be-connected-inputs.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class UnmarkAllCanBeConnectedInputsExecution implements IExecution<UnmarkAllCanBeConnectedInputsRequest, void> {
+    private _fComponentsStore;
+    handle(payload: UnmarkAllCanBeConnectedInputsRequest): void;
+    private _unmarkCanBeConnectedTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnmarkAllCanBeConnectedInputsExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnmarkAllCanBeConnectedInputsExecution>;
+}

package/domain/f-connectors/unmark-all-can-be-connected-inputs/unmark-all-can-be-connected-inputs.request.d.ts

@@ -0,0 +1,5 @@
+import { FConnectorBase } from '../../../f-connectors';
+export declare class UnmarkAllCanBeConnectedInputsRequest {
+    fInputs: FConnectorBase[];
+    constructor(fInputs: FConnectorBase[]);
+}

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

@@ -6,6 +6,7 @@ export declare class EndDragSequenceExecution implements IExecution<EndDragSeque
     private get _hostElement();
     private _fDraggableDataContext;
     handle(request: EndDragSequenceRequest): void;
+    private _emitDragEnded;
     static ɵfac: i0.ɵɵFactoryDeclaration<EndDragSequenceExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EndDragSequenceExecution>;
 }

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

@@ -7,4 +7,4 @@ import { InitializeDragSequenceExecution } from './initialize-drag-sequence';
 import { OnPointerMoveExecution } from './on-pointer-move';
 import { IsDragStartedExecution } from './is-drag-started';
 import { StartDragSequenceExecution } from './start-drag-sequence';
-export declare const F_DRAGGABLE_FEATURES: (typeof AddDndToStoreExecution | typeof EmitSelectionChangeEventExecution | typeof EndDragSequenceExecution | typeof OnPointerMoveExecution | typeof InitializeDragSequenceExecution | typeof PrepareDragSequenceExecution | typeof IsDragStartedExecution | typeof StartDragSequenceExecution | typeof RemoveDndFromStoreExecution)[];
+export declare const F_DRAGGABLE_FEATURES: (typeof PrepareDragSequenceExecution | typeof StartDragSequenceExecution | typeof InitializeDragSequenceExecution | typeof OnPointerMoveExecution | typeof EndDragSequenceExecution | typeof EmitSelectionChangeEventExecution | typeof AddDndToStoreExecution | typeof IsDragStartedExecution | typeof RemoveDndFromStoreExecution)[];

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

@@ -7,6 +7,7 @@ export declare class StartDragSequenceExecution implements IExecution<StartDragS
     private get _hostElement();
     private _fDraggableDataContext;
     handle(request: StartDragSequenceRequest): void;
+    private _emitDragStarted;
     static ɵfac: i0.ɵɵFactoryDeclaration<StartDragSequenceExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<StartDragSequenceExecution>;
 }

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

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

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

@@ -1,4 +1,4 @@
 import { GetFlowStateExecution } from './get-flow-state.execution';
 import { GetFlowStateNodesExecution } from './get-flow-state-nodes';
 import { GetFlowStateConnectionsExecution } from './get-flow-state-connections';
-export declare const GET_FLOW_STATE_PROVIDERS: (typeof GetFlowStateConnectionsExecution | typeof GetFlowStateNodesExecution | typeof GetFlowStateExecution)[];
+export declare const GET_FLOW_STATE_PROVIDERS: (typeof GetFlowStateExecution | typeof GetFlowStateNodesExecution | typeof GetFlowStateConnectionsExecution)[];

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

@@ -2,4 +2,4 @@ import { GetFlowHostElementExecution } from './get-flow-host-element';
 import { AddFlowToStoreExecution } from './add-flow-to-store';
 import { RemoveFlowFromStoreExecution } from './remove-flow-from-store';
 import { GetFlowExecution } from './get-flow';
-export declare const F_FLOW_FEATURES: (typeof import("./get-flow-state").GetFlowStateConnectionsExecution | typeof import("./get-flow-state").GetFlowStateNodesExecution | typeof import("./get-flow-state").GetFlowStateExecution | typeof AddFlowToStoreExecution | typeof GetFlowExecution | typeof GetFlowHostElementExecution | typeof RemoveFlowFromStoreExecution)[];
+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)[];

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

@@ -6,4 +6,4 @@ import { CalculateNodesBoundingBoxExecution } from './calculate-nodes-bounding-b
 import { CalculateNodesBoundingBoxNormalizedPositionExecution } from './calculate-nodes-bounding-box-normalized-position';
 import { GetNodePaddingExecution } from './get-node-padding';
 import { GetParentNodesExecution } from './get-parent-nodes';
-export declare const F_NODE_FEATURES: (typeof CalculateNodesBoundingBoxNormalizedPositionExecution | typeof AddNodeToStoreExecution | typeof CalculateNodesBoundingBoxExecution | typeof GetNodePaddingExecution | typeof GetNodesExecution | typeof GetParentNodesExecution | typeof UpdateNodeWhenStateOrSizeChangedExecution | typeof RemoveNodeFromStoreExecution)[];
+export declare const F_NODE_FEATURES: (typeof AddNodeToStoreExecution | typeof CalculateNodesBoundingBoxExecution | typeof CalculateNodesBoundingBoxNormalizedPositionExecution | typeof GetNodePaddingExecution | typeof GetNodesExecution | typeof GetParentNodesExecution | typeof UpdateNodeWhenStateOrSizeChangedExecution | typeof RemoveNodeFromStoreExecution)[];

package/domain/f-node/update-node-when-state-or-size-changed/update-node-when-state-or-size-changed.execution.d.ts

@@ -5,6 +5,8 @@ export declare class UpdateNodeWhenStateOrSizeChangedExecution implements IExecu
     private _fMediator;
     handle(request: UpdateNodeWhenStateOrSizeChangedRequest): void;
     private _calculateConnectorsConnectableSide;
+    private _calculateConnectorConnectableSide;
+    private _getSideByDelta;
     static ɵfac: i0.ɵɵFactoryDeclaration<UpdateNodeWhenStateOrSizeChangedExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<UpdateNodeWhenStateOrSizeChangedExecution>;
 }

package/domain/f-selection/clear-selection/clear-selection.execution.d.ts

@@ -1,10 +1,8 @@
 import { ClearSelectionRequest } from './clear-selection.request';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class ClearSelectionExecution implements IExecution<ClearSelectionRequest, void> {
-    private fDraggableDataContext;
-    constructor(fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
     handle(request: ClearSelectionRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClearSelectionExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ClearSelectionExecution>;

package/domain/f-selection/get-can-be-selected-items/get-can-be-selected-items.execution.d.ts

@@ -1,16 +1,14 @@
-import { ICanBeSelected } from './i-can-be-selected';
+import { ICanBeSelectedElementAndRect } from './i-can-be-selected-element-and-rect';
 import { IExecution } from '@foblex/mediator';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
-export declare class GetCanBeSelectedItemsExecution implements IExecution<void, ICanBeSelected[]> {
-    private fDraggableDataContext;
+export declare class GetCanBeSelectedItemsExecution implements IExecution<void, ICanBeSelectedElementAndRect[]> {
     private _fMediator;
     private _fComponentsStore;
+    private _fDraggableDataContext;
     private get fNodes();
     private get fConnections();
     private get transform();
-    constructor(fDraggableDataContext: FDraggableDataContext);
-    handle(): ICanBeSelected[];
+    handle(): ICanBeSelectedElementAndRect[];
     private getNodesWithRects;
     private getConnectionsWithRects;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetCanBeSelectedItemsExecution, never>;

package/domain/f-selection/get-can-be-selected-items/i-can-be-selected-element-and-rect.d.ts

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/2d';
+import { ISelectable } from '../../../mixins';
+export interface ICanBeSelectedElementAndRect {
+    element: ISelectable;
+    fRect: IRect;
+}

package/domain/f-selection/get-can-be-selected-items/index.d.ts

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

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

@@ -4,4 +4,4 @@ import { SelectExecution } from './select';
 import { SelectAllExecution } from './select-all';
 import { SelectAndUpdateNodeLayerExecution } from './select-and-update-node-layer';
 import { GetCanBeSelectedItemsExecution } from './get-can-be-selected-items';
-export declare const F_SELECTION_FEATURES: (typeof ClearSelectionExecution | typeof GetCanBeSelectedItemsExecution | typeof GetCurrentSelectionExecution | typeof SelectExecution | typeof SelectAllExecution | typeof SelectAndUpdateNodeLayerExecution)[];
+export declare const F_SELECTION_FEATURES: (typeof SelectAndUpdateNodeLayerExecution | typeof SelectAllExecution | typeof SelectExecution | typeof GetCurrentSelectionExecution | typeof GetCanBeSelectedItemsExecution | typeof ClearSelectionExecution)[];

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

@@ -1,12 +1,9 @@
 import { SelectRequest } from './select.request';
 import { IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectExecution implements IExecution<SelectRequest, void> {
-    private fDataContext;
-    private fDraggableDataContext;
-    constructor(fDataContext: FComponentsStore, fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
+    private _fComponentsStore;
     handle(request: SelectRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectExecution>;

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

@@ -1,12 +1,9 @@
 import { SelectAllRequest } from './select-all.request';
 import { IExecution } from '@foblex/mediator';
-import { FComponentsStore } from '../../../f-storage';
-import { FDraggableDataContext } from '../../../f-draggable';
 import * as i0 from "@angular/core";
 export declare class SelectAllExecution implements IExecution<SelectAllRequest, void> {
-    private fDataContext;
-    private fDraggableDataContext;
-    constructor(fDataContext: FComponentsStore, fDraggableDataContext: FDraggableDataContext);
+    private _fDraggableDataContext;
+    private _fComponentsStore;
     handle(request: SelectAllRequest): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectAllExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectAllExecution>;

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

@@ -0,0 +1,5 @@
+import { FZoomBase } from '../../../f-zoom';
+export declare class AddZoomToStoreRequest {
+    fComponent: FZoomBase;
+    constructor(fComponent: FZoomBase);
+}

package/domain/f-zoom/add-zoom-to-store/add-zoom-to-store.execution.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { AddZoomToStoreRequest } from './add-zoom-to-store-request';
+import * as i0 from "@angular/core";
+export declare class AddZoomToStoreExecution implements IExecution<AddZoomToStoreRequest, void> {
+    private _fComponentsStore;
+    handle(request: AddZoomToStoreRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddZoomToStoreExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddZoomToStoreExecution>;
+}

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

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

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

@@ -0,0 +1 @@
+export declare const F_ZOOM_TAG = "F_ZOOM";

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

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

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

@@ -0,0 +1,5 @@
+import { AddZoomToStoreExecution } from './add-zoom-to-store';
+import { RemoveZoomFromStoreExecution } from './remove-zoom-from-store';
+import { SetZoomExecution } from './set-zoom';
+import { ResetZoomExecution } from './reset-zoom';
+export declare const F_ZOOM_FEATURES: (typeof AddZoomToStoreExecution | typeof RemoveZoomFromStoreExecution | typeof ResetZoomExecution | typeof SetZoomExecution)[];

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

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

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

@@ -0,0 +1,2 @@
+export declare class RemoveZoomFromStoreRequest {
+}

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

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { RemoveZoomFromStoreRequest } from './remove-zoom-from-store-request';
+import * as i0 from "@angular/core";
+export declare class RemoveZoomFromStoreExecution implements IExecution<RemoveZoomFromStoreRequest, void> {
+    private _fComponentsStore;
+    handle(request: RemoveZoomFromStoreRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveZoomFromStoreExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveZoomFromStoreExecution>;
+}

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

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

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

@@ -0,0 +1,2 @@
+export declare class ResetZoomRequest {
+}

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

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { ResetZoomRequest } from './reset-zoom-request';
+import * as i0 from "@angular/core";
+export declare class ResetZoomExecution implements IExecution<ResetZoomRequest, void> {
+    private _fComponentsStore;
+    private get _fCanvas();
+    handle(request: ResetZoomRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResetZoomExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResetZoomExecution>;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { IPoint } from '@foblex/2d';
+export declare class SetZoomRequest {
+    position: IPoint;
+    step: number;
+    direction: number;
+    animate: boolean;
+    constructor(position: IPoint, step: number, direction: number, animate?: boolean);
+}

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

@@ -0,0 +1,16 @@
+import { IExecution } from '@foblex/mediator';
+import { SetZoomRequest } from './set-zoom-request';
+import * as i0 from "@angular/core";
+export declare class SetZoomExecution implements IExecution<SetZoomRequest, void> {
+    private _fMediator;
+    private _fComponentsStore;
+    private get _fHost();
+    private get _fCanvas();
+    private get _fZoomComponent();
+    private get _isDragStarted();
+    handle(request: SetZoomRequest): void;
+    private _clamp;
+    private _castPositionToFlow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetZoomExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SetZoomExecution>;
+}

package/domain/i-f-action-trigger.d.ts

@@ -0,0 +1,14 @@
+export interface IFActionTrigger<TAction = string, TEvent = Event> {
+    event: EFTriggerEvent;
+    action: TAction;
+    validator?: (event: TEvent) => boolean;
+}
+export declare enum EFTriggerEvent {
+    WHEEL = "wheel",
+    DOUBLE_CLICK = "dblclick",
+    MOUSE_DOWN = "mousedown",
+    MOUSE_UP = "mouseup",
+    MOUSE_MOVE = "mousemove",
+    KEY_DOWN = "keydown",
+    KEY_UP = "keyup"
+}

package/domain/index.d.ts

@@ -8,14 +8,19 @@ export * from './f-flow';
 export * from './f-line-alignment';
 export * from './f-node';
 export * from './f-selection';
+export * from './f-zoom';
 export * from './get-deep-children-nodes-and-groups';
 export * from './get-normalized-element-rect';
 export * from './get-normalized-point';
 export * from './sort-item-layers';
 export * from './update-item-and-children-layers';
 export * from './create-dom-element';
+export * from './css-cls';
+export * from './f-event-trigger';
+export * from './i-f-action-trigger';
 export * from './i-map';
 export * from './is-mobile';
+export * from './log-deprecated';
 export * from './log-execution-time';
 export * from './providers';
 export * from './transition-end';

package/domain/log-deprecated.d.ts

@@ -0,0 +1 @@
+export declare function Deprecated(newMethodName: string, removalVersion?: string): MethodDecorator;