@foblex/flow 18.1.1 → 18.2.0

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

@@ -1,3 +1,3 @@
-import { PinchToZoomPreparation } from './preparation';
-import { PinchToZoomFinalize } from './finalize';
+import { PinchToZoomPreparation } from './pinch-to-zoom-preparation';
+import { PinchToZoomFinalize } from './pinch-to-zoom-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").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)[];
+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("./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").AttachSoftParentConnectionDragHandlersToNode | 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("./drag-external-item").DragExternalItemCreatePlaceholder | typeof import("./drag-external-item").DragExternalItemCreatePreview | typeof import("./drag-external-item").DragExternalItemFinalize | typeof import("./drag-external-item").DragExternalItemPreparation | typeof import("./drag-external-item").PreventDefaultIsExternalItem | 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("./resize-node").ApplyChildResizeConstraints | typeof import("./resize-node").ApplyParentResizeConstraints | typeof import("./resize-node").CalculateChangedRectFromDifference | typeof import("./resize-node").CalculateDirectChildrenUnionRect | typeof import("./resize-node").CalculateResizeLimits | typeof import("./resize-node").ResizeNodeFinalize | typeof import("./resize-node").AttachResizeConnectionDragHandlersToNode | typeof import("./resize-node").ResizeNodePreparation | typeof import("./rotate-node").RotateNodeFinalize | typeof import("./rotate-node").RotateNodePreparation | typeof import("./drag-minimap").CalculateFlowPointFromMinimapPoint | typeof import("./drag-minimap").DragMinimapFinalize | typeof import("./drag-minimap").DragMinimapPreparation | typeof import("./domain").EmitSelectionChangeEvent | typeof import("./domain").GetNormalizedParentNodeRect | typeof import("./domain").IsArrayHasParentNode | typeof import("./domain").DetectConnectionsUnderDragNode | typeof import("./select-by-pointer").SelectByPointer)[];

package/f-draggable/resize-node/apply-parent-resize-constraints/apply-parent-resize-constraints-request.d.ts

@@ -0,0 +1,8 @@
+import { IRect } from '@foblex/2d';
+import { IResizeLimits } from '../constraint';
+export declare class ApplyParentResizeConstraintsRequest {
+    rect: IRect;
+    limits: IResizeLimits;
+    static readonly fToken: unique symbol;
+    constructor(rect: IRect, limits: IResizeLimits);
+}

package/f-draggable/resize-node/apply-parent-resize-constraints/apply-parent-resize-constraints.d.ts

@@ -0,0 +1,37 @@
+import { ApplyParentResizeConstraintsRequest } from './apply-parent-resize-constraints-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+/**
+ * Resize constraints behavior:
+ * - SOFT (parents): if the child hits the innerRect, a NEW parent rect is calculated
+ *   from the original boundingRect and applied via updatePosition/Size/redraw.
+ *   The original boundingRect/innerRect are never mutated.
+ * - HARD (child): the child rect is clamped to stay within the hard.innerRect.
+ */
+export declare class ApplyParentResizeConstraints implements IExecution<ApplyParentResizeConstraintsRequest, void> {
+    private readonly _mediator;
+    /** Entry point: applies soft and hard resize constraints. */
+    handle({ rect, limits }: ApplyParentResizeConstraintsRequest): void;
+    private _applyResizeConstraints;
+    /** Returns a copy of the child rect pre-clamped to the hard innerRect if it exists. */
+    private _clampedCopyForCalculation;
+    /** Clamps the rect inside the given innerRect. Mutates the rect directly. */
+    private _clampRectToInner;
+    /** Iterates over all soft limits and applies expansion if overflow is detected. */
+    private _applySoftParentExpansions;
+    /**
+     * If the child overflows the parent's innerRect, calculate a new parent rect
+     * based on the original boundingRect and apply it. Otherwise, reset to original.
+     */
+    private _expandParentFromOriginalIfOverflow;
+    /** Returns true if any overflow exists. */
+    private _hasOverflow;
+    /** Computes overflow values for each side relative to innerRect. */
+    private _computeOverflow;
+    /** Builds new parent rect from original rect and overflow values. */
+    private _buildExpandedParentRect;
+    /** Applies the calculated parent rect to the node/group. */
+    private _applyParentRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyParentResizeConstraints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyParentResizeConstraints>;
+}

package/f-draggable/resize-node/calculate-changed-rect-from-difference/calculate-changed-rect-from-difference.d.ts

@@ -0,0 +1,11 @@
+import { CalculateChangedRectFromDifferenceRequest } from './calculate-changed-rect-from-difference-request';
+import { IRect } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class CalculateChangedRectFromDifference implements IExecution<CalculateChangedRectFromDifferenceRequest, IRect> {
+    handle({ originalRect, difference, handleType, minimumSize, }: CalculateChangedRectFromDifferenceRequest): IRect;
+    private _changeSizeInRect;
+    private _changePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateChangedRectFromDifference, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateChangedRectFromDifference>;
+}

package/f-draggable/resize-node/calculate-resize-limits/calculate-resize-limits-request.d.ts

@@ -0,0 +1,8 @@
+import { FNodeBase } from '../../../f-node';
+import { IRect } from '@foblex/2d';
+export declare class CalculateResizeLimitsRequest {
+    readonly nodeOrGroup: FNodeBase;
+    readonly rect: IRect;
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup: FNodeBase, rect: IRect);
+}

package/f-draggable/resize-node/constraint/i-resize-constraint.d.ts

@@ -0,0 +1,7 @@
+import { IRect, ISize } from '@foblex/2d';
+import { IResizeLimits } from './i-resize-limits';
+export interface IResizeConstraint {
+    limits: IResizeLimits;
+    childrenBounds: IRect | null;
+    minimumSize: ISize;
+}

package/f-draggable/resize-node/constraint/i-resize-limit.d.ts

@@ -0,0 +1,7 @@
+import { IRect } from '@foblex/2d';
+import { FNodeBase } from '../../../f-node';
+export interface IResizeLimit {
+    boundingRect: IRect;
+    innerRect: IRect;
+    nodeOrGroup: FNodeBase;
+}

package/f-draggable/resize-node/constraint/i-resize-limits.d.ts

@@ -0,0 +1,5 @@
+import { IResizeLimit } from './i-resize-limit';
+export interface IResizeLimits {
+    softLimits: IResizeLimit[];
+    hardLimit: IResizeLimit | undefined;
+}

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

@@ -0,0 +1,5 @@
+export * from './i-resize-constraint';
+export * from './i-resize-limit';
+export * from './i-resize-limits';
+export * from './i-resize-overflow';
+export * from './resize-direction';

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

@@ -0,0 +1,4 @@
+export declare class FResizeNodeStartEventData {
+    readonly fNodeId: string;
+    constructor(fNodeId: string);
+}

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

@@ -0,0 +1,12 @@
+export * from './apply-child-resize-constraints';
+export * from './apply-parent-resize-constraints';
+export * from './calculate-changed-rect-from-difference';
+export * from './calculate-direct-children-union-rect';
+export * from './calculate-resize-limits';
+export * from './constraint';
+export * from './resize-node-finalize';
+export * from './resize-node-handler';
+export * from './resize-preparation';
+export * from './f-resize-node-start-event-data';
+export * from './is-resize-node-handler';
+export * from './providers';

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

@@ -0,0 +1,5 @@
+import { DragHandlerBase } from '../infrastructure';
+import { ResizeNodeHandler } from './resize-node-handler';
+export declare const RESIZE_NODE_HANDLER_TYPE = "node-resize";
+export declare const RESIZE_NODE_HANDLER_KIND = "resize-node";
+export declare function isResizeNodeHandler(value: DragHandlerBase<unknown>): value is ResizeNodeHandler;

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

@@ -0,0 +1,9 @@
+import { ResizeNodeFinalize } from './resize-node-finalize';
+import { ResizeNodePreparation } from './resize-preparation';
+import { CalculateResizeLimits } from './calculate-resize-limits';
+import { ApplyChildResizeConstraints } from './apply-child-resize-constraints';
+import { ApplyParentResizeConstraints } from './apply-parent-resize-constraints';
+import { CalculateChangedRectFromDifference } from './calculate-changed-rect-from-difference';
+import { CalculateDirectChildrenUnionRect } from './calculate-direct-children-union-rect';
+import { AttachResizeConnectionDragHandlersToNode } from './resize-preparation';
+export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeConstraints | typeof ApplyParentResizeConstraints | typeof CalculateChangedRectFromDifference | typeof CalculateDirectChildrenUnionRect | typeof CalculateResizeLimits | typeof ResizeNodeFinalize | typeof AttachResizeConnectionDragHandlersToNode | typeof ResizeNodePreparation)[];

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

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

package/f-draggable/resize-node/resize-node-finalize/resize-node-finalize-request.d.ts

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

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

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

package/f-draggable/resize-node/resize-node-handler/i-resize-node-connection-handlers.d.ts

@@ -0,0 +1,10 @@
+import { ResizeNodeConnectionHandlerBase } from './resize-node-dependent-connection-handlers';
+import { FConnectorBase } from '../../../f-connectors';
+export interface IResizeNodeConnectionEndpointHandler {
+    handler: ResizeNodeConnectionHandlerBase;
+    connector: FConnectorBase;
+}
+export interface IResizeNodeConnectionHandlers {
+    source: IResizeNodeConnectionEndpointHandler[];
+    target: IResizeNodeConnectionEndpointHandler[];
+}

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

@@ -0,0 +1,3 @@
+export * from './resize-node-handler';
+export * from './i-resize-node-connection-handlers';
+export * from './resize-node-dependent-connection-handlers';

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './resize-node-connection-both-sides-handler';
+export * from './resize-node-connection-handler-base';
+export * from './resize-node-connection-source-handler';
+export * from './resize-node-connection-target-handler';

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-both-sides-handler.d.ts

@@ -0,0 +1,12 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionBothSidesHandler extends ResizeNodeConnectionHandlerBase {
+    private _sourceUpdated;
+    private _targetUpdated;
+    setSourceRect(rect: IRoundedRect): void;
+    setTargetRect(rect: IRoundedRect): void;
+    private _redrawIfReady;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionBothSidesHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionBothSidesHandler>;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-handler-base.d.ts

@@ -0,0 +1,20 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../../f-connection-v2';
+export declare class ResizeNodeConnectionHandlerBase {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _behaviour;
+    private _source;
+    private _target;
+    private _sourceRef;
+    private _targetRef;
+    private _sourceRect;
+    private _targetRect;
+    connection: FConnectionBase;
+    initialize(connection: FConnectionBase): void;
+    setSourceRect(rect: IRoundedRect): void;
+    setTargetRect(rect: IRoundedRect): void;
+    protected redraw(): void;
+    private _buildLine;
+    private _readRectRef;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-source-handler.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionSourceHandler extends ResizeNodeConnectionHandlerBase {
+    setSourceRect(rect: IRoundedRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionSourceHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionSourceHandler>;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-target-handler.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionTargetHandler extends ResizeNodeConnectionHandlerBase {
+    setTargetRect(rect: IRoundedRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionTargetHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionTargetHandler>;
+}

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

@@ -0,0 +1,35 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { EFResizeHandleType, FNodeBase } from '../../../f-node';
+import { FResizeNodeStartEventData } from '../f-resize-node-start-event-data';
+import { IResizeNodeConnectionHandlers } from './i-resize-node-connection-handlers';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeHandler extends DragHandlerBase<FResizeNodeStartEventData> {
+    protected readonly type = "node-resize";
+    protected readonly kind = "resize-node";
+    protected data(): FResizeNodeStartEventData;
+    private readonly _mediator;
+    private _baselineRect;
+    private _constraints;
+    private _lastRect;
+    private _nodeOrGroup;
+    private _handleType;
+    private _nodeConnections;
+    private _softParentConnections;
+    initialize(nodeOrGroup: FNodeBase, handleType: EFResizeHandleType): void;
+    setNodeConnectionHandlers(handlers: IResizeNodeConnectionHandlers): void;
+    setSoftParentConnectionHandlers(handlers: IResizeNodeConnectionHandlers[]): void;
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _readBaselineRect;
+    private _buildConstraints;
+    private _calcNextRect;
+    private _applyConstraints;
+    private _commitRect;
+    private _fallbackRectFromModel;
+    private _applyConnectionHandlers;
+    private _readConnectorRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeHandler>;
+}

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node-request.d.ts

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

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node.d.ts

@@ -0,0 +1,16 @@
+import { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class AttachResizeConnectionDragHandlersToNode implements IExecution<AttachResizeConnectionDragHandlersToNodeRequest, void> {
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _dragInjector;
+    handle({ handler, nodeOrGroup }: AttachResizeConnectionDragHandlersToNodeRequest): void;
+    private _readSoftParents;
+    private _collectSourceConnectorIds;
+    private _collectTargetConnectorIds;
+    private _buildConnectionHandlersForNode;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachResizeConnectionDragHandlersToNode, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AttachResizeConnectionDragHandlersToNode>;
+}

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attach-resize-connection-drag-handlers-to-node';
+export * from './attach-resize-connection-drag-handlers-to-node-request';

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

@@ -0,0 +1,3 @@
+export * from './resize-node-preparation';
+export * from './resize-node-preparation-request';
+export * from './attach-resize-connection-drag-handlers-to-node';

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

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

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

@@ -0,0 +1,17 @@
+import { ResizeNodePreparationRequest } from './resize-node-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ResizeNodePreparation implements IExecution<ResizeNodePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    private readonly _dragInjector;
+    private get _transform();
+    handle({ event, fTrigger }: ResizeNodePreparationRequest): void;
+    private _isResizeHandle;
+    private _findResizableNode;
+    private _selectBeforeResize;
+    private _readResizeHandleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodePreparation>;
+}

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

@@ -0,0 +1,4 @@
+export declare class FRotateNodeStartEventData {
+    readonly fNodeId: string;
+    constructor(fNodeId: string);
+}

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

@@ -0,0 +1,7 @@
+export * from './rotate-node-finalize';
+export * from './rotate-node-preparation';
+export * from './rotate-node-handler';
+export * from './calculate-difference-after-rotation';
+export * from './f-rotate-node-start-event-data';
+export * from './is-rotate-node-handler';
+export * from './providers';

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

@@ -0,0 +1,5 @@
+import { DragHandlerBase } from '../infrastructure';
+import { RotateNodeHandler } from './rotate-node-handler';
+export declare const ROTATE_NODE_HANDLER_TYPE = "node-rotate";
+export declare const ROTATE_NODE_HANDLER_KIND = "rotate-node";
+export declare function isRotateNodeHandler(value: DragHandlerBase<unknown>): value is RotateNodeHandler;

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

@@ -0,0 +1,3 @@
+import { RotateNodeFinalize } from './rotate-node-finalize';
+import { RotateNodePreparation } from './rotate-node-preparation';
+export declare const NODE_ROTATE_PROVIDERS: (typeof RotateNodeFinalize | typeof RotateNodePreparation)[];

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

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

package/f-draggable/rotate-node/rotate-node-finalize/rotate-node-finalize-request.d.ts

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

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

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

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

@@ -0,0 +1 @@
+export * from './rotate-node-handler';

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

@@ -0,0 +1,43 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { FRotateNodeStartEventData } from '../f-rotate-node-start-event-data';
+import { FNodeBase } from '../../../f-node';
+import { DragNodeConnectionHandlerBase } from '../../drag-node';
+import * as i0 from "@angular/core";
+type TRotateConnectionHandler = {
+    connection: DragNodeConnectionHandlerBase;
+    connector: IPoint;
+};
+export declare class RotateNodeHandler extends DragHandlerBase<FRotateNodeStartEventData> {
+    protected readonly type = "node-rotate";
+    protected readonly kind = "rotate-node";
+    protected data(): FRotateNodeStartEventData;
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _dragSession;
+    private _nodeOrGroup;
+    private _sourceConnections;
+    private _targetConnections;
+    private _startRotation;
+    private _nodeRect;
+    private _nodeCenter;
+    private _pointerDownInFlow;
+    /**
+     * Difference between pointer angle and node rotation at pointer-down.
+     * This lets us keep rotation “locked” to the initial grab angle.
+     */
+    private _rotationOffsetDeg;
+    private get _transform();
+    initialize(nodeOrGroup: FNodeBase, sourceConnections: TRotateConnectionHandler[], targetConnections: TRotateConnectionHandler[]): void;
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _readNodeRect;
+    private _calculatePointerDownInFlow;
+    private _angleDeg;
+    private _applyRotation;
+    private _deltaAfterRotation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodeHandler>;
+}
+export {};

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { RotateNodePreparationRequest } from './rotate-node-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class RotateNodePreparation implements IExecution<RotateNodePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _transform();
+    handle(request: RotateNodePreparationRequest): void;
+    private _isPreparationAllowed;
+    private _findRotatableNode;
+    private _selectBeforeRotate;
+    private _buildInputConnectionHandlers;
+    private _buildOutputConnectionHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodePreparation>;
+}

package/f-external-item/f-external-item-base.d.ts

@@ -1,14 +1,14 @@
-import { TemplateRef } from '@angular/core';
-import { IHasHostElement } from '../i-has-host-element';
+import { InjectionToken, ModelSignal, Signal, TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare abstract class FExternalItemBase<TData = unknown> implements IHasHostElement {
-    abstract fExternalItemId: string;
-    abstract hostElement: HTMLElement | SVGElement;
-    abstract fData: TData | undefined;
-    abstract fDisabled: boolean;
-    abstract fPreview: TemplateRef<unknown> | undefined;
-    abstract fPreviewMatchSize: boolean;
-    abstract fPlaceholder: TemplateRef<unknown> | undefined;
+export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
+export declare abstract class FExternalItemBase<TData = any> {
+    readonly hostElement: any;
+    abstract externalItemId: Signal<string>;
+    abstract data: Signal<TData | undefined>;
+    abstract disabled: Signal<boolean>;
+    abstract preview: ModelSignal<TemplateRef<unknown> | undefined>;
+    abstract previewMatchSize: Signal<boolean>;
+    abstract placeholder: ModelSignal<TemplateRef<unknown> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
 }

package/f-external-item/f-external-item-placeholder.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FExternalItemPlaceholder<T = unknown> implements OnInit, OnDestroy {
+    private readonly _instance;
+    private readonly _templateRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPlaceholder<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPlaceholder<any>, "ng-template[fExternalItemPlaceholder]", never, {}, {}, never, never, true, never>;
+}

package/f-external-item/f-external-item-preview.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FExternalItemPreview<T = unknown> implements OnInit, OnDestroy {
+    private readonly _instance;
+    private readonly _templateRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPreview<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPreview<any>, "ng-template[fExternalItemPreview]", never, {}, {}, never, never, true, never>;
+}

package/f-external-item/f-external-item.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { FExternalItemBase } from './f-external-item-base';
+import * as i0 from "@angular/core";
+export declare class FExternalItem<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
+    private readonly _apiService;
+    /** Stable id for matching drag sessions, lookups, etc. */
+    readonly externalItemId: import("@angular/core").InputSignal<string>;
+    /** Payload attached to external item. */
+    readonly data: import("@angular/core").InputSignal<TData | undefined>;
+    /** Disables dragging/interaction. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Template shown while item is dragged (preview). */
+    readonly preview: import("@angular/core").ModelSignal<TemplateRef<unknown> | undefined>;
+    /** Whether preview should match original element size. */
+    readonly previewMatchSize: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder template that stays in original place while dragging. */
+    readonly placeholder: import("@angular/core").ModelSignal<TemplateRef<unknown> | undefined>;
+    ngOnInit(): void;
+    private _disablePointerEvents;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItem<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItem<any>, "[fExternalItem]", never, { "externalItemId": { "alias": "fExternalItemId"; "required": false; "isSignal": true; }; "data": { "alias": "fData"; "required": false; "isSignal": true; }; "disabled": { "alias": "fDisabled"; "required": false; "isSignal": true; }; "preview": { "alias": "fPreview"; "required": false; "isSignal": true; }; "previewMatchSize": { "alias": "fPreviewMatchSize"; "required": false; "isSignal": true; }; "placeholder": { "alias": "fPlaceholder"; "required": false; "isSignal": true; }; }, { "preview": "fPreviewChange"; "placeholder": "fPlaceholderChange"; }, never, never, true, never>;
+}

package/f-external-item/f-external-item.service.d.ts

@@ -1,10 +1,17 @@
 import { FExternalItemBase } from './f-external-item-base';
 import * as i0 from "@angular/core";
 export declare class FExternalItemService {
+    private readonly _byHost;
     private readonly _items;
-    registerItem(item: FExternalItemBase): void;
-    getItem(element: HTMLElement | SVGElement): FExternalItemBase | undefined;
-    removeItem(item: FExternalItemBase): void;
+    /** Reactive list (internal consumers) */
+    readonly items: import("@angular/core").Signal<readonly FExternalItemBase<any>[]>;
+    /** lookup by element (supports passing a nested child) */
+    getByElement(el: HTMLElement | SVGElement): FExternalItemBase | undefined;
+    /** lookup by host */
+    getByHost(host: HTMLElement | SVGElement): FExternalItemBase | undefined;
+    register(item: FExternalItemBase): void;
+    remove(item: FExternalItemBase): void;
+    private _sync;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemService>;
 }