@foblex/flow 17.9.81 → 18.1.0

package/f-draggable/f-draggable.directive.d.ts

@@ -1,13 +1,14 @@
 import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { FDraggableBase } from './f-draggable-base';
-import { FMoveNodesEvent } from './f-node-move';
-import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
+import { FMoveNodesEvent } from './drag-node';
+import { FConnectionWaypointsChangedEvent, FCreateConnectionEvent, FReassignConnectionEvent } from './connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
-import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
-import { FDropToGroupEvent } from './f-drop-to-group';
+import { FNodeConnectionsIntersectionEvent, FNodeIntersectedWithConnections } from './domain';
+import { FDropToGroupEvent } from './drop-to-group';
 import { IPointerEvent } from '../drag-toolkit';
+import { FDragStartedEvent } from './f-drag-started-event';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
     private readonly _result;
@@ -17,18 +18,23 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     fMultiSelectTrigger: FEventTrigger;
     fReassignConnectionTrigger: FEventTrigger;
     fCreateConnectionTrigger: FEventTrigger;
+    fConnectionWaypointsTrigger: import("@angular/core").InputSignal<FEventTrigger>;
+    fMoveControlPointTrigger: FEventTrigger;
     fNodeResizeTrigger: FEventTrigger;
     fNodeRotateTrigger: FEventTrigger;
     fNodeMoveTrigger: FEventTrigger;
     fCanvasMoveTrigger: FEventTrigger;
     fExternalItemTrigger: FEventTrigger;
     fSelectionChange: EventEmitter<FSelectionChangeEvent>;
+    /** @deprecated Use `fNodeConnectionsIntersection` */
     fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
+    readonly fNodeConnectionsIntersection: import("@angular/core").OutputEmitterRef<FNodeConnectionsIntersectionEvent>;
     fEmitOnNodeIntersect: boolean;
     fCreateNode: EventEmitter<FCreateNodeEvent<any>>;
     fMoveNodes: EventEmitter<FMoveNodesEvent>;
     fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     fCreateConnection: EventEmitter<FCreateConnectionEvent>;
+    fConnectionWaypointsChanged: import("@angular/core").OutputEmitterRef<FConnectionWaypointsChangedEvent>;
     fDropToGroup: EventEmitter<FDropToGroupEvent>;
     /**
      * Defines the vertical cell size for the grid.
@@ -48,10 +54,11 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
      * If set to `false`, the nodes will move freely without snapping to the grid.
      */
     fCellSizeWhileDragging: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    fDragStarted: EventEmitter<FDragStartedEvent>;
+    fDragStarted: EventEmitter<FDragStartedEvent<unknown>>;
     fDragEnded: EventEmitter<void>;
     private _beforePlugins;
     private _afterPlugins;
+    private readonly _dragHandlerInjector;
     ngOnInit(): void;
     ngAfterViewInit(): void;
     onPointerDown(event: IPointerEvent): boolean;
@@ -62,7 +69,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; "isSignal": true; }; "hCellSize": { "alias": "hCellSize"; "required": false; "isSignal": true; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; "isSignal": true; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fConnectionWaypointsTrigger": { "alias": "fConnectionWaypointsTrigger"; "required": false; "isSignal": true; }; "fMoveControlPointTrigger": { "alias": "fMoveControlPointTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; "isSignal": true; }; "hCellSize": { "alias": "hCellSize"; "required": false; "isSignal": true; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; "isSignal": true; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fNodeConnectionsIntersection": "fNodeConnectionsIntersection"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fConnectionWaypointsChanged": "fConnectionWaypointsChanged"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
     static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_fEmitOnNodeIntersect: unknown;
 }

package/f-draggable/f-node-resize/i-node-resize-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface INodeResizeEventData {
+    fNodeId: string;
+}

package/f-draggable/f-node-resize/index.d.ts

@@ -6,6 +6,7 @@ export * from './calculate-resize-limits';
 export * from './constraint';
 export * from './resize-finalize';
 export * from './resize-preparation';
+export * from './i-node-resize-event-data';
 export * from './node-resize.drag-handler';
 export * from './providers';
 export * from './resize-direction';

package/f-draggable/f-node-resize/node-resize.drag-handler.d.ts

@@ -1,12 +1,16 @@
 import { IPoint } from '@foblex/2d';
-import { IFDragHandler } from '../f-drag-handler';
+import { DragHandlerBase } from '../infrastructure';
 import { EFResizeHandleType, FNodeBase } from '../../f-node';
 import { Injector } from '@angular/core';
-export declare class NodeResizeDragHandler implements IFDragHandler {
+import { INodeResizeEventData } from './i-node-resize-event-data';
+export declare class NodeResizeDragHandler extends DragHandlerBase<INodeResizeEventData> {
     private _nodeOrGroup;
     private _handleType;
-    readonly fEventType = "node-resize";
-    readonly fData: any;
+    protected readonly type = "node-resize";
+    protected readonly kind = "resize-node";
+    protected data(): {
+        fNodeId: string;
+    };
     private readonly _mediator;
     private _originalRect;
     private _constraints;

package/f-draggable/f-node-resize/resize-preparation/node-resize-preparation.d.ts

@@ -7,7 +7,6 @@ export declare class NodeResizePreparation implements IExecution<NodeResizePrepa
     private readonly _dragContext;
     private readonly _injector;
     private get _transform();
-    private get _fHost();
     private _nodeOrGroup;
     handle(request: NodeResizePreparationRequest): void;
     private _isValid;

package/f-draggable/f-node-rotate/f-node-rotate.drag-handler.d.ts

@@ -1,27 +1,31 @@
 import { IPoint } from '@foblex/2d';
-import { IFDragHandler } from '../f-drag-handler';
+import { DragHandlerBase } from '../infrastructure';
 import { FNodeBase } from '../../f-node';
-import { BaseConnectionDragHandler } from '../f-node-move';
+import { DragNodeConnectionHandlerBase } from '../drag-node';
 import { Injector } from '@angular/core';
-export declare class FNodeRotateDragHandler implements IFDragHandler {
+import { INodeRotateEventData } from './i-node-rotate-event-data';
+export declare class FNodeRotateDragHandler extends DragHandlerBase<INodeRotateEventData> {
     private _fNode;
     private _fSourceHandlers;
     private _fTargetHandlers;
+    protected readonly type = "node-rotate";
+    protected readonly kind = "rotate-node";
+    protected data(): {
+        fNodeId: string;
+    };
     private readonly _store;
     private readonly _mediator;
     private readonly _dragContext;
-    fEventType: string;
-    fData: any;
     private _initialRotationToX;
     private readonly _startRotation;
     private _onDownPoint;
     private _fNodeRect;
     private get _transform();
     constructor(_injector: Injector, _fNode: FNodeBase, _fSourceHandlers: {
-        connection: BaseConnectionDragHandler;
+        connection: DragNodeConnectionHandlerBase;
         connector: IPoint;
     }[], _fTargetHandlers: {
-        connection: BaseConnectionDragHandler;
+        connection: DragNodeConnectionHandlerBase;
         connector: IPoint;
     }[]);
     prepareDragSequence(): void;

package/f-draggable/f-node-rotate/i-node-rotate-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface INodeRotateEventData {
+    fNodeId: string;
+}

package/f-draggable/f-node-rotate/index.d.ts

@@ -1,4 +1,5 @@
 export * from './rotate-finalize';
 export * from './rotate-preparation';
 export * from './f-node-rotate.drag-handler';
+export * from './i-node-rotate-event-data';
 export * from './providers';

package/f-draggable/f-node-rotate/rotate-preparation/f-node-rotate-preparation.execution.d.ts

@@ -6,8 +6,9 @@ export declare class FNodeRotatePreparationExecution implements IExecution<FNode
     private readonly _store;
     private readonly _dragContext;
     private readonly _injector;
+    private readonly _dragInjector;
     private get _transform();
-    private get _fHost();
+    private get _flowHost();
     private _fNode;
     handle(request: FNodeRotatePreparationRequest): void;
     private _isValid;

package/f-draggable/f-selection-change-event.d.ts

@@ -1,7 +1,13 @@
 import { ICurrentSelection } from '../domain';
 export declare class FSelectionChangeEvent implements ICurrentSelection {
-    fNodeIds: string[];
-    fGroupIds: string[];
-    fConnectionIds: string[];
-    constructor(fNodeIds: string[], fGroupIds: string[], fConnectionIds: string[]);
+    readonly nodeIds: string[];
+    readonly groupIds: string[];
+    readonly connectionIds: string[];
+    /** @deprecated Use `nodeIds` */
+    get fNodeIds(): string[];
+    /** @deprecated Use `groupIds` */
+    get fGroupIds(): string[];
+    /** @deprecated Use `connectionIds` */
+    get fConnectionIds(): string[];
+    constructor(nodeIds: string[], groupIds: string[], connectionIds: string[]);
 }

package/f-draggable/index.d.ts

@@ -1,13 +1,16 @@
 export * from './domain';
-export * from './f-canvas';
-export * from './f-connection';
-export * from './f-drag-handler';
-export * from './f-drop-to-group';
-export * from './f-node-move';
+export * from './drag-canvas';
+export * from './connection';
+export * from './infrastructure';
+export * from './drop-to-group';
+export * from './drag-node';
 export * from './f-node-resize';
 export * from './f-node-rotate';
-export * from './f-single-select';
+export * from './pinch-to-zoom';
+export * from './select-by-pointer';
+export * from './selection-area';
 export * from './f-drag-blocker.directive';
+export * from './f-drag-started-event';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';

package/f-draggable/infrastructure/drag-handler-base.d.ts

@@ -0,0 +1,20 @@
+import { IPoint } from '@foblex/2d';
+import { IPointerEvent } from '../../drag-toolkit';
+import { FDragStartedEvent } from '../f-drag-started-event';
+import { IDragSessionContext, IDragSessionFeature } from './i-drag-session-feature';
+export declare abstract class DragHandlerBase<TData> {
+    protected abstract readonly type: string;
+    protected abstract readonly kind: string;
+    protected data(): TData | undefined;
+    private readonly _features;
+    getEvent(): FDragStartedEvent<TData>;
+    attachFeature(feature: IDragSessionFeature): void;
+    protected featuresPrepare(ctx: IDragSessionContext): void;
+    protected featuresMove(ctx: IDragSessionContext, delta: IPoint): void;
+    protected featuresFinalize(ctx: IDragSessionContext, delta: IPoint): void;
+    protected featuresEnd(ctx: IDragSessionContext): void;
+    prepareDragSequence?(): void;
+    abstract onPointerMove(difference: IPoint, event?: IPointerEvent): void;
+    onPointerUp?(): void;
+    destroy?(): void;
+}

package/f-draggable/infrastructure/drag-handler-injector.d.ts

@@ -0,0 +1,18 @@
+import { ProviderToken } from '@angular/core';
+import * as i0 from "@angular/core";
+type NoArgsCtor<T> = new () => T;
+export interface IDestroyable {
+    destroy(): void;
+}
+export declare class DragHandlerInjector {
+    private readonly _injector;
+    private _dragInjector;
+    private _created;
+    create(): void;
+    get<T>(token: ProviderToken<T>): T;
+    createInstance<T>(ctor: NoArgsCtor<T>): T;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragHandlerInjector, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragHandlerInjector>;
+}
+export {};

package/f-draggable/infrastructure/i-drag-session-feature.d.ts

@@ -0,0 +1,12 @@
+import { IPoint, IRect, ITransformModel } from '@foblex/2d';
+export interface IDragSessionFeature {
+    onPrepare?(ctx: IDragSessionContext): void;
+    onMove?(ctx: IDragSessionContext, delta: IPoint): void;
+    onFinalize?(ctx: IDragSessionContext, delta: IPoint): void;
+    onEnd?(ctx: IDragSessionContext): void;
+}
+export interface IDragSessionContext {
+    flowHost: HTMLElement;
+    transform: ITransformModel;
+    getDraggedUnionRect(delta: IPoint): IRect;
+}

package/f-draggable/infrastructure/index.d.ts

@@ -0,0 +1,4 @@
+export * from './drag-handler-base';
+export * from './drag-handler-injector';
+export * from './f-drag-handler-result';
+export * from './i-drag-session-feature';

package/f-draggable/pinch-to-zoom/finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pinch-to-zoom-finalize';
+export * from './pinch-to-zoom-finalize-request';

package/f-draggable/pinch-to-zoom/finalize/pinch-to-zoom-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class PinchToZoomFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/pinch-to-zoom/finalize/pinch-to-zoom-finalize.d.ts

@@ -0,0 +1,10 @@
+import { PinchToZoomFinalizeRequest } from './pinch-to-zoom-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class PinchToZoomFinalize implements IExecution<PinchToZoomFinalizeRequest, void> {
+    private readonly _dragSession;
+    handle(_: PinchToZoomFinalizeRequest): void;
+    private _hasPinchZoomHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomFinalize>;
+}

package/f-draggable/pinch-to-zoom/handler/index.d.ts

@@ -0,0 +1 @@
+export * from './pinch-to-zoom-handler';

package/f-draggable/pinch-to-zoom/handler/pinch-to-zoom-handler.d.ts

@@ -0,0 +1,24 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { IPointerEvent } from '../../../drag-toolkit';
+import * as i0 from "@angular/core";
+export declare class PinchToZoomHandler extends DragHandlerBase<unknown> {
+    protected readonly type = "pinch-to-zoom";
+    protected readonly kind = "pinch-to-zoom";
+    private readonly _store;
+    private get _flowHost();
+    private get _canvas();
+    private get _zoomComponent();
+    private _startDistance;
+    private _startScale;
+    private _touches;
+    initialize(touches: TouchList): void;
+    prepareDragSequence(): void;
+    onPointerMove(_: IPoint, event: IPointerEvent): void;
+    private _clamp;
+    private _castPositionToFlow;
+    private _reset;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomHandler>;
+}

package/f-draggable/pinch-to-zoom/index.d.ts

@@ -0,0 +1,4 @@
+export * from './finalize';
+export * from './handler';
+export * from './preparation';
+export * from './providers';

package/f-draggable/pinch-to-zoom/preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pinch-to-zoom-preparation';
+export * from './pinch-to-zoom-preparation-request';

package/f-draggable/pinch-to-zoom/preparation/pinch-to-zoom-preparation-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class PinchToZoomPreparationRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/pinch-to-zoom/preparation/pinch-to-zoom-preparation.d.ts

@@ -0,0 +1,14 @@
+import { PinchToZoomPreparationRequest } from './pinch-to-zoom-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class PinchToZoomPreparation implements IExecution<PinchToZoomPreparationRequest, void> {
+    private readonly _dragInjector;
+    private readonly _store;
+    private readonly _dragSession;
+    handle({ event }: PinchToZoomPreparationRequest): void;
+    private _canStart;
+    private _hasZoomComponent;
+    private _getHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomPreparation>;
+}

package/f-draggable/pinch-to-zoom/providers.d.ts

@@ -0,0 +1,3 @@
+import { PinchToZoomPreparation } from './preparation';
+import { PinchToZoomFinalize } from './finalize';
+export declare const PINCH_TO_ZOOM_PROVIDERS: (typeof PinchToZoomFinalize | typeof PinchToZoomPreparation)[];

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").CreateConnectionFromOutputPreparation | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./f-node-move").BuildDragHierarchy | typeof import("./f-node-move").GetNodeBoundingIncludePaddings | typeof import("./f-node-move").CalculateDragLimits | typeof import("./f-node-move").CreateSummaryDragHandler | typeof import("./f-node-move").CreateInputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").CreateOutputConnectionHandlerAndSetToNodeHandler | typeof import("./f-node-move").CreateDragModelFromSelection | typeof import("./f-node-move").CreateSnapLines | typeof import("./f-node-move").FNodeMovePreparationExecution | typeof import("./f-node-move").FNodeMoveFinalizeExecution | typeof import("./f-drop-to-group").DropToGroupFinalize | typeof import("./f-drop-to-group").SortContainersForDropByLayer | typeof import("./f-drop-to-group").DropToGroupPreparation | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./f-connection").CreateConnectionPreparation | typeof import("./f-node-resize").ApplyChildResizeConstraints | typeof import("./f-node-resize").ApplyParentResizeConstraints | typeof import("./f-node-resize").CalculateChangedRectFromDifference | typeof import("./f-node-resize").CalculateDirectChildrenUnionRect | typeof import("./f-node-resize").CalculateResizeLimits | typeof import("./f-node-resize").NodeResizeFinalize | typeof import("./f-node-resize").NodeResizePreparation | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./domain").EmitEndDragSequenceEvent | typeof import("./domain").EmitStartDragSequenceEvent | typeof import("./drag-canvas").DragCanvasFinalize | typeof import("./drag-canvas").DragCanvasPreparation | typeof import("./connection").ResolveConnectableOutputForOutlet | typeof import("./connection").CreateConnectionFinalize | typeof import("./connection").CreateConnectionCreateDragHandler | typeof import("./connection").CreateConnectionFromOutletPreparation | typeof import("./connection").CreateConnectionFromOutputPreparation | typeof import("./connection").CreateConnectionPreparation | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./drag-node").MagneticLinesPreparation | typeof import("./drag-node").MagneticRectsPreparation | typeof import("./drag-node").CreateDragNodeHierarchy | typeof import("./drag-node").ReadNodeBoundsWithPaddings | typeof import("./drag-node").BuildDragNodeConstraints | typeof import("./drag-node").CreateDragNodeHandler | typeof import("./drag-node").AttachTargetConnectionDragHandlersToNode | typeof import("./drag-node").AttachSourceConnectionDragHandlersToNode | typeof import("./drag-node").AttachDragNodeHandlerFromSelection | typeof import("./drag-node").DragNodeFinalize | typeof import("./drag-node").DragNodePreparation | typeof import("./drop-to-group").DropToGroupFinalize | typeof import("./drop-to-group").SortDropCandidatesByLayer | typeof import("./drop-to-group").DropToGroupPreparation | typeof import("./connection").ReassignConnectionFinalize | typeof import("./connection").ReassignConnectionPreparation | typeof import("./connection").DragConnectionWaypointFinalize | typeof import("./connection").DragConnectionWaypointPreparation | typeof import("./pinch-to-zoom").PinchToZoomFinalize | typeof import("./pinch-to-zoom").PinchToZoomPreparation | typeof import("./selection-area").SelectionAreaFinalize | typeof import("./selection-area").SelectionAreaPreparation | typeof import("./domain").EmitSelectionChangeEvent | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").DetectConnectionsUnderDragNode | typeof import("./f-node-resize").ApplyChildResizeConstraints | typeof import("./f-node-resize").ApplyParentResizeConstraints | typeof import("./f-node-resize").CalculateChangedRectFromDifference | typeof import("./f-node-resize").CalculateDirectChildrenUnionRect | typeof import("./f-node-resize").CalculateResizeLimits | typeof import("./f-node-resize").NodeResizeFinalize | typeof import("./f-node-resize").NodeResizePreparation | typeof import("./f-node-rotate").FNodeRotateFinalizeExecution | typeof import("./f-node-rotate").FNodeRotatePreparationExecution | typeof import("./select-by-pointer").SelectByPointer | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution)[];

package/f-draggable/select-by-pointer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './providers';
+export * from './select-by-pointer';
+export * from './select-by-pointer-request';

package/f-draggable/select-by-pointer/providers.d.ts

@@ -0,0 +1,2 @@
+import { SelectByPointer } from './select-by-pointer';
+export declare const DRAG_SELECT_BY_POINTER_PROVIDERS: (typeof SelectByPointer)[];

package/f-draggable/select-by-pointer/select-by-pointer-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../domain';
+import { IPointerEvent } from '../../drag-toolkit';
+export declare class SelectByPointerRequest {
+    readonly event: IPointerEvent;
+    readonly trigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, trigger: FEventTrigger);
+}

package/f-draggable/select-by-pointer/select-by-pointer.d.ts

@@ -0,0 +1,58 @@
+import { IExecution } from '@foblex/mediator';
+import { SelectByPointerRequest } from './select-by-pointer-request';
+import * as i0 from "@angular/core";
+/**
+ * Implements the functionality for selecting elements in a graphical interface.
+ * This class handles both single and multi-selection, updating the selection state
+ * of elements and managing related data.
+ *
+ * Logic flow:
+ * 1. **Validate the selection event**:
+ *    - The event is considered valid if it occurs within the flow boundaries
+ *      and there are no active draggable data operations.
+ *
+ * 2. **Determine the target element to select**:
+ *    - The target element is determined based on the event’s target.
+ *      It can be a node, a group of nodes, or a connection.
+ *    - If no element is found, the current selection state is cleared.
+ *
+ * 3. **Update element layers**:
+ *    - If an element is found, its visual layer and the layers of its child elements are updated.
+ *
+ * 4. **Single or multi-selection**:
+ *    - If the event meets the criteria for multi-selection (e.g., a modifier key is pressed),
+ *      multi-selection logic is applied.
+ *    - Otherwise, single-selection logic is used.
+ *
+ * 5. **Single-selection logic**:
+ *    - If the element is not selected and can be selected:
+ *      - Clear the selection of all other elements.
+ *      - Mark the current element as selected.
+ *    - If the element cannot be selected, the current selection is cleared.
+ *
+ * 6. **Multi-selection logic**:
+ *    - If the element is already selected, it is removed from the selection.
+ *    - If the element is not selected and can be selected, it is added to the selection.
+ *
+ * 7. **Manage selection state**:
+ *    - Adding or removing an element from the selection triggers the corresponding methods.
+ *    - Selection state is tracked in the shared context for future use.
+ */
+export declare class SelectByPointer implements IExecution<SelectByPointerRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    handle({ event, trigger }: SelectByPointerRequest): void;
+    private _isSelectionAllowed;
+    private _resolveSelectable;
+    private _findNodeOrGroupAt;
+    private _findConnectionAt;
+    private _deferRaiseLayerFor;
+    private _applySingleSelect;
+    private _applyToggleSelect;
+    private _clearSelection;
+    private _select;
+    private _deselect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectByPointer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectByPointer>;
+}

package/f-draggable/selection-area/index.d.ts

@@ -0,0 +1,4 @@
+export * from './selection-area-finalize';
+export * from './selection-area-handler';
+export * from './selection-area-preparation';
+export * from './providers';

package/f-draggable/selection-area/providers.d.ts

@@ -0,0 +1,3 @@
+import { SelectionAreaPreparation } from './selection-area-preparation';
+import { SelectionAreaFinalize } from './selection-area-finalize';
+export declare const DRAG_SELECTION_AREA_PROVIDERS: (typeof SelectionAreaFinalize | typeof SelectionAreaPreparation)[];

package/f-draggable/selection-area/selection-area-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './selection-area-finalize';
+export * from './selection-area-finalize-request';

package/f-draggable/selection-area/selection-area-finalize/selection-area-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class SelectionAreaFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/selection-area/selection-area-finalize/selection-area-finalize.d.ts

@@ -0,0 +1,10 @@
+import { SelectionAreaFinalizeRequest } from './selection-area-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class SelectionAreaFinalize implements IExecution<SelectionAreaFinalizeRequest, void> {
+    private readonly _dragSession;
+    handle(_request: SelectionAreaFinalizeRequest): void;
+    private _isValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaFinalize>;
+}

package/f-draggable/selection-area/selection-area-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './selection-area-handler';

package/f-draggable/selection-area/selection-area-handler/selection-area-handler.d.ts

@@ -0,0 +1,24 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import * as i0 from "@angular/core";
+export declare class SelectionAreaHandler extends DragHandlerBase<unknown> {
+    protected readonly type = "selection-area";
+    protected readonly kind = "selection-area";
+    private readonly _store;
+    private readonly _dragSession;
+    private readonly _mediator;
+    private _canBeSelected;
+    private _selectedByMove;
+    private get _transform();
+    private get _canvasPosition();
+    private get _instance();
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    private _getMinimumPoint;
+    onPointerUp(): void;
+    private _draw;
+    private _show;
+    private _hide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaHandler>;
+}

package/f-draggable/selection-area/selection-area-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './selection-area-preparation';
+export * from './selection-area-preparation-request';

package/f-draggable/selection-area/selection-area-preparation/selection-area-preparation-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class SelectionAreaPreparationRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/selection-area/selection-area-preparation/selection-area-preparation.d.ts

@@ -0,0 +1,13 @@
+import { SelectionAreaPreparationRequest } from './selection-area-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class SelectionAreaPreparation implements IExecution<SelectionAreaPreparationRequest, void> {
+    private readonly _store;
+    private readonly _dragSession;
+    private readonly _dragInjector;
+    private get _instance();
+    handle(request: SelectionAreaPreparationRequest): void;
+    private _isValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaPreparation>;
+}

package/f-external-item/domain/f-external-item.drag-handler.d.ts

@@ -1,11 +1,14 @@
 import { IPoint } from '@foblex/2d';
 import { FExternalItemBase } from '../../f-external-item';
-import { IFDragHandler } from '../../f-draggable';
+import { DragHandlerBase } from '../../f-draggable';
 import { Injector } from '@angular/core';
-export declare class FExternalItemDragHandler implements IFDragHandler {
+export declare class FExternalItemDragHandler extends DragHandlerBase<unknown> {
     private _fExternalItem;
-    fEventType: string;
-    fData: any;
+    protected readonly type = "external-item";
+    protected readonly kind = "drag-external-item";
+    protected data(): {
+        fData: unknown;
+    };
     private readonly _fResult;
     private readonly _mediator;
     private readonly _browser;

package/f-external-item/domain/finalize/f-external-item-finalize.execution.d.ts

@@ -3,11 +3,10 @@ import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FExternalItemFinalizeExecution implements IExecution<FExternalItemFinalizeRequest, void> {
     private readonly _fResult;
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _store;
     private readonly _dragContext;
-    private readonly _fBrowser;
-    private get _fHost();
+    private readonly _browser;
     private get _fCreateNode();
     private get _fDragHandler();
     handle(request: FExternalItemFinalizeRequest): void;

package/f-flow/f-flow.component.d.ts

@@ -5,7 +5,7 @@ import { IPoint, IRect } from '@foblex/2d';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private readonly _destroyRef;
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _browserService;
     private readonly _elementReference;
     fId: import("@angular/core").InputSignal<string>;