@foblex/flow 17.9.81 → 18.1.0

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

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './enums';
+export * from './models';
+export * from './utils';

package/f-connection-v2/models/f-connection-components-parent.d.ts

@@ -0,0 +1,15 @@
+import { InjectionToken, Signal } from '@angular/core';
+import { EFConnectableSide } from '../enums';
+import { EFConnectionBehavior, EFConnectionConnectableSide } from '../utils';
+export declare const F_CONNECTION_COMPONENTS_PARENT: InjectionToken<FConnectionComponentsParent>;
+export declare abstract class FConnectionComponentsParent {
+    abstract fId: Signal<string>;
+    abstract fOutputId: Signal<string>;
+    abstract fInputId: Signal<string>;
+    abstract fStartColor: Signal<string>;
+    abstract fEndColor: Signal<string>;
+    abstract fBehavior: EFConnectionBehavior;
+    abstract _applyResolvedSidesToConnection(sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
+    abstract fInputSide: Signal<EFConnectionConnectableSide>;
+    abstract fOutputSide: Signal<EFConnectionConnectableSide>;
+}

package/f-connection-v2/models/index.d.ts

@@ -0,0 +1 @@
+export * from './f-connection-components-parent';

package/f-connection-v2/utils/connection-behaviour/connection-behaviour-builder-request.d.ts

@@ -0,0 +1,11 @@
+import { IRoundedRect } from '@foblex/2d';
+import { EFConnectableSide } from '../../enums';
+import { FConnectionComponentsParent } from '../../models';
+export declare class ConnectionBehaviourBuilderRequest {
+    readonly sourceRect: IRoundedRect;
+    readonly targetRect: IRoundedRect;
+    readonly connection: FConnectionComponentsParent;
+    readonly sourceConnectableSide: EFConnectableSide;
+    readonly targetConnectableSide: EFConnectableSide;
+    constructor(sourceRect: IRoundedRect, targetRect: IRoundedRect, connection: FConnectionComponentsParent, sourceConnectableSide: EFConnectableSide, targetConnectableSide: EFConnectableSide);
+}

package/f-connection-v2/utils/connection-behaviour/connection-behaviour-builder.d.ts

@@ -0,0 +1,46 @@
+import { ConnectionBehaviourBuilderRequest } from './connection-behaviour-builder-request';
+import { ILine } from '@foblex/2d';
+import * as i0 from "@angular/core";
+/**
+ * Calculates connection lines based on behavior rules.
+ * It determines which sides of the source and target should connect,
+ * then delegates to a registered behavior handler.
+ */
+export declare class ConnectionBehaviourBuilder {
+    /**
+     * Main execution entry point.
+     *
+     * @param request The request containing source, target, and connection details.
+     * @returns A calculated connection line (ILine).
+     */
+    handle(request: ConnectionBehaviourBuilderRequest): ILine;
+    /**
+     * Computes the directional deltas between two rectangles.
+     */
+    private _calculateDirectionalVectors;
+    /**
+     * Determines the side for the source element.
+     */
+    private _determineSourceSide;
+    /**
+     * Determines the side for the target element.
+     */
+    private _determineTargetSide;
+    /**
+     * Resolves which side of a shape to connect to based on direction, fallback, and connection mode.
+     *
+     * @param requestedSide The side mode (e.g. CALCULATE, CALCULATE_HORIZONTAL, FIXED, etc.).
+     * @param deltaX Difference in X between source and target.
+     * @param deltaY Difference in Y between source and target.
+     * @param fallbackSide The default fallback side if calculation is ambiguous.
+     */
+    private _resolveConnectableSide;
+    /**
+     * Returns the appropriate handler for the given connection behavior.
+     *
+     * @throws Error if no handler is registered for the behavior.
+     */
+    private _getBehaviorHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBehaviourBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionBehaviourBuilder>;
+}

package/f-connection-v2/utils/connection-behaviour/enums/index.d.ts

@@ -0,0 +1,2 @@
+export * from './e-f-connection-behavior';
+export * from './e-f-connection-connectable-side';

package/f-connection-v2/utils/connection-behaviour/index.d.ts

@@ -0,0 +1,5 @@
+export * from './enums';
+export * from './models';
+export * from './utils';
+export * from './connection-behaviour-builder';
+export * from './connection-behaviour-builder-request';

package/f-connection-v2/utils/connection-behaviour/models/i-calculate-behavior-request.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { EFConnectableSide } from '../../../enums';
+export interface ICalculateBehaviorRequest {
+    sourceRect: IRoundedRect;
+    targetRect: IRoundedRect;
+    sourceConnectableSide: EFConnectableSide;
+    targetConnectableSide: EFConnectableSide;
+}

package/f-connection-v2/utils/connection-behaviour/models/index.d.ts

@@ -0,0 +1 @@
+export * from './i-calculate-behavior-request';

package/f-connection-v2/utils/connection-behaviour/utils/fixed-center-behavior.d.ts

@@ -0,0 +1,8 @@
+import { ILine } from '@foblex/2d';
+import { ICalculateBehaviorRequest } from '../models';
+/**
+ * Fixed center behavior calculates the connection line
+ * It constructs a line between the gravity centers of the connector rectangles
+ * @param payload
+ */
+export declare function fixedCenterBehavior({ sourceRect, targetRect }: ICalculateBehaviorRequest): ILine;

package/f-connection-v2/utils/connection-behaviour/utils/fixed-outbound-behavior.d.ts

@@ -0,0 +1,8 @@
+import { ILine } from '@foblex/2d';
+import { ICalculateBehaviorRequest } from '../models';
+/**
+ * Fixed outbound behavior calculates the connection line
+ * It constructs a line between the specified sides of the output and input rectangles
+ * @param payload
+ */
+export declare function fixedOutboundBehavior({ sourceRect, sourceConnectableSide, targetRect, targetConnectableSide, }: ICalculateBehaviorRequest): ILine;

package/f-connection-v2/utils/connection-behaviour/utils/floating-behavior.d.ts

@@ -0,0 +1,8 @@
+import { ILine } from '@foblex/2d';
+import { ICalculateBehaviorRequest } from '../models';
+/**
+ * Floating behavior calculates the connection line
+ * It constructs a line between the intersections of the connectors rectangles and line from the centers of the connector rectangles
+ * @param payload
+ */
+export declare function floatingBehavior({ sourceRect, targetRect }: ICalculateBehaviorRequest): ILine;

package/f-connection-v2/utils/connection-behaviour/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fixed-center-behavior';
+export * from './fixed-outbound-behavior';
+export * from './floating-behavior';

package/f-connection-v2/utils/connection-line-builder/builders/adaptive-curve/calculate-adaptive-curve-data.d.ts

@@ -0,0 +1,8 @@
+import { IFConnectionBuilder, IFConnectionBuilderRequest, IFConnectionBuilderResponse } from '../../models';
+export declare class CalculateAdaptiveCurveData implements IFConnectionBuilder {
+    private static _dir;
+    private static _isHorizontal;
+    private static _handleLength;
+    private static _softControl;
+    handle({ source, sourceSide, target, targetSide, offset, waypoints, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
+}

package/f-connection-v2/utils/connection-line-builder/builders/adaptive-curve/index.d.ts

@@ -0,0 +1 @@
+export * from './calculate-adaptive-curve-data';

package/f-connection-v2/utils/connection-line-builder/builders/bezier-curve/calculate-bezier-curve-data.d.ts

@@ -0,0 +1,4 @@
+import { IFConnectionBuilder, IFConnectionBuilderRequest, IFConnectionBuilderResponse } from '../../models';
+export declare class CalculateBezierCurveData implements IFConnectionBuilder {
+    handle({ source, sourceSide, target, targetSide, offset, waypoints, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
+}

package/f-connection-v2/utils/connection-line-builder/builders/bezier-curve/index.d.ts

@@ -0,0 +1 @@
+export * from './calculate-bezier-curve-data';

package/f-connection-v2/utils/connection-line-builder/builders/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adaptive-curve';
+export * from './bezier-curve';
+export * from './segment-line';
+export * from './straight-line';
+export * from './utils';

package/f-connection-v2/utils/connection-line-builder/builders/segment-line/build-corner-mid-points-and-apply-offsets.d.ts

@@ -0,0 +1,17 @@
+import { IPoint } from '@foblex/2d';
+import { EFConnectableSide } from '../../../../enums';
+export declare function buildCornerMidPointsAndApplyOffsets(params: {
+    axis: 'x' | 'y';
+    source: IPoint;
+    target: IPoint;
+    sourceSide: EFConnectableSide;
+    targetSide: EFConnectableSide;
+    sourceGap: IPoint;
+    targetGap: IPoint;
+    sourceDir: IPoint;
+    targetDir: IPoint;
+    currentDir: number;
+    offset: number;
+    sourceGapOffset: IPoint;
+    targetGapOffset: IPoint;
+}): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/segment-line/calculate-segment-line-data.d.ts

@@ -0,0 +1,6 @@
+import { IFConnectionBuilder, IFConnectionBuilderRequest, IFConnectionBuilderResponse } from '../../models';
+export declare class CalculateSegmentLineData implements IFConnectionBuilder {
+    handle({ source, sourceSide, target, targetSide, waypoints, offset, radius, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
+    private _getPathPoints;
+    private _getDirection;
+}

package/f-connection-v2/utils/connection-line-builder/builders/segment-line/create-segment-line-path.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function createSegmentLinePath(points: IPoint[], borderRadius: number): string;

package/f-connection-v2/utils/connection-line-builder/builders/segment-line/index.d.ts

@@ -0,0 +1,3 @@
+export * from './build-corner-mid-points-and-apply-offsets';
+export * from './calculate-segment-line-data';
+export * from './create-segment-line-path';

package/f-connection-v2/utils/connection-line-builder/builders/straight-line/calculate-straight-line-data.d.ts

@@ -0,0 +1,4 @@
+import { IFConnectionBuilder, IFConnectionBuilderRequest, IFConnectionBuilderResponse } from '../../models';
+export declare class CalculateStraightLineData implements IFConnectionBuilder {
+    handle(request: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
+}

package/f-connection-v2/utils/connection-line-builder/builders/straight-line/index.d.ts

@@ -0,0 +1 @@
+export * from './calculate-straight-line-data';

package/f-connection-v2/utils/connection-line-builder/builders/utils/build-connection-anchors.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function buildConnectionAnchors(source: IPoint, target: IPoint, waypoints?: IPoint[]): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-center-between-points.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function calculateCenterBetweenPoints(source: IPoint, target: IPoint): IPoint;

package/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-curve-candidates.d.ts

@@ -0,0 +1,3 @@
+import { ICubicSegment } from './multi-cubic';
+import { IPoint } from '@foblex/2d';
+export declare function calculateCurveCandidates(segments: ICubicSegment[]): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-polyline-candidates.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function calculatePolylineCandidates(polyline: IPoint[]): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './build-connection-anchors';
+export * from './calculate-center-between-points';
+export * from './calculate-curve-candidates';
+export * from './calculate-polyline-candidates';
+export * from './merge-point-chains';
+export * from './multi-cubic';
+export * from './normalize-polyline';
+export * from './sample-cubic-bezier-uniform';

package/f-connection-v2/utils/connection-line-builder/builders/utils/merge-point-chains.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function mergePointChains(chains: IPoint[][]): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/multi-cubic.d.ts

@@ -0,0 +1,10 @@
+import { IPoint } from '@foblex/2d';
+export interface ICubicSegment {
+    p0: IPoint;
+    c1: IPoint;
+    c2: IPoint;
+    p3: IPoint;
+    chainIndex: number;
+}
+export declare function createMultiCubicPath(segments: ICubicSegment[]): string;
+export declare function sampleMultiCubicUniform(segments: ICubicSegment[], samplesPerSegment?: number): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/normalize-polyline.d.ts

@@ -0,0 +1,2 @@
+import { IPoint } from '@foblex/2d';
+export declare function normalizePolyline(points: IPoint[], eps?: number): IPoint[];

package/f-connection-v2/utils/connection-line-builder/builders/utils/sample-cubic-bezier-uniform.d.ts

@@ -0,0 +1,24 @@
+import { IPoint } from '@foblex/2d';
+/**
+ * Uniformly samples a cubic Bézier segment.
+ *
+ * @param points - Start point, First control point, Second control point, End point.
+ * @param samples - Number of sub-segments (default: 32). The function returns `samples + 1` points.
+ * @returns Array of sampled points including both endpoints.
+ * @remarks
+ * Sampling is uniform in parameter `t`, not in arc length. This is typically
+ * sufficient for hit-testing and bounding boxes; if you need error-bounded
+ * flattening, consider an adaptive subdivision strategy instead.
+ */
+export declare function sampleCubicBezierUniform(points: IPoint[], samples?: number): IPoint[];
+/**
+ * Evaluates a cubic Bézier at parameter `t` in [0, 1].
+ *
+ * @param p0 - Start point.
+ * @param p1 - First control point.
+ * @param p2 - Second control point.
+ * @param p3 - End point.
+ * @param t - Parameter in [0, 1].
+ * @returns Point on the curve at `t`.
+ */
+export declare function cubicBezierAtT(p0: IPoint, p1: IPoint, p2: IPoint, p3: IPoint, t: number): IPoint;

package/f-connection-v2/utils/connection-line-builder/connection-line-builder-request.d.ts

@@ -0,0 +1,7 @@
+import { IFConnectionBuilderRequest } from './models';
+import { EFConnectionType } from '../../enums';
+export declare class ConnectionLineBuilderRequest {
+    readonly type: string | EFConnectionType;
+    readonly payload: IFConnectionBuilderRequest;
+    constructor(type: string | EFConnectionType, payload: IFConnectionBuilderRequest);
+}

package/f-connection-v2/utils/connection-line-builder/connection-line-builder.d.ts

@@ -0,0 +1,13 @@
+import { IFConnectionBuilderResponse } from './models';
+import { ConnectionLineBuilderRequest } from './connection-line-builder-request';
+import * as i0 from "@angular/core";
+export declare class ConnectionLineBuilder {
+    private readonly _builtinBuilders;
+    private readonly _providedBuilders;
+    private readonly _builders;
+    constructor();
+    handle({ type, payload }: ConnectionLineBuilderRequest): IFConnectionBuilderResponse;
+    private _createBuilderNotFoundError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionLineBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionLineBuilder>;
+}

package/f-connection-v2/utils/connection-line-builder/index.d.ts

@@ -0,0 +1,5 @@
+export * from './builders';
+export * from './models';
+export * from './providers';
+export * from './connection-line-builder';
+export * from './connection-line-builder-request';

package/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder-request.d.ts

@@ -0,0 +1,11 @@
+import { IPoint } from '@foblex/2d';
+import { EFConnectableSide } from '../../../enums';
+export interface IFConnectionBuilderRequest {
+    source: IPoint;
+    sourceSide: EFConnectableSide;
+    target: IPoint;
+    targetSide: EFConnectableSide;
+    radius: number;
+    offset: number;
+    waypoints: IPoint[];
+}

package/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder-response.d.ts

@@ -0,0 +1,8 @@
+import { IPoint } from '@foblex/2d';
+export interface IFConnectionBuilderResponse {
+    path: string;
+    penultimatePoint: IPoint;
+    secondPoint: IPoint;
+    points: IPoint[];
+    candidates: IPoint[];
+}

package/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder.d.ts

@@ -0,0 +1,5 @@
+import { IFConnectionBuilderRequest } from './i-f-connection-builder-request';
+import { IFConnectionBuilderResponse } from './i-f-connection-builder-response';
+export interface IFConnectionBuilder {
+    handle(request: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
+}

package/f-connection-v2/utils/connection-line-builder/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './i-f-connection-builder-request';
+export * from './i-f-connection-builder-response';
+export * from './i-f-connection-builder';

package/f-connection-v2/utils/connection-line-builder/providers/f-connection-builders.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { IFConnectionBuilder } from '../models';
+export type IConnectionBuilders = Record<string, IFConnectionBuilder>;
+export declare const F_CONNECTION_BUILDERS: InjectionToken<IConnectionBuilders>;

package/f-connection-v2/utils/connection-line-builder/providers/index.d.ts

@@ -0,0 +1 @@
+export * from './f-connection-builders';

package/f-connection-v2/utils/create-connection-dom-identifier.d.ts

@@ -0,0 +1 @@
+export declare function createConnectionDomIdentifier(componentId: string, sourceId: string, targetId: string): string;

package/f-connection-v2/utils/create-connection-selection-dom-identifier.d.ts

@@ -0,0 +1 @@
+export declare function createConnectionSelectionDomIdentifier(componentId: string, sourceId: string, targetId: string): string;

package/f-connection-v2/utils/create-gradient-dom-identifier.d.ts

@@ -0,0 +1 @@
+export declare function createGradientDomIdentifier(componentId: string, sourceId: string, targetId: string): string;

package/f-connection-v2/utils/create-gradient-dom-url.d.ts

@@ -0,0 +1 @@
+export declare function createGradientDomUrl(componentId: string, sourceId: string, targetId: string): string;

package/f-connection-v2/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './connection-behaviour';
+export * from './connection-line-builder';
+export * from './create-connection-dom-identifier';
+export * from './create-connection-selection-dom-identifier';
+export * from './create-gradient-dom-identifier';
+export * from './create-gradient-dom-url';

package/f-connectors/f-connector-base.d.ts

@@ -1,7 +1,9 @@
-import { EFConnectableSide } from './e-f-connectable-side';
 import { IHasHostElement } from '../i-has-host-element';
 import { Signal } from '@angular/core';
+import { EFConnectableSide } from '../f-connection-v2/enums/e-f-connectable-side';
+export type FConnectorKind = 'input' | 'output' | 'outlet';
 export declare abstract class FConnectorBase implements IHasHostElement {
+    abstract readonly kind: FConnectorKind;
     abstract fId: Signal<string>;
     abstract fNodeId: string;
     abstract fNodeHost: HTMLElement | SVGElement;

package/f-connectors/f-node-input/f-node-input-base.d.ts

@@ -1,8 +1,9 @@
 import { InjectionToken, Signal } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { FConnectorBase, FConnectorKind } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
+    kind: FConnectorKind;
     abstract category: Signal<string | undefined>;
     abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;

package/f-connectors/f-node-input/f-node-input.directive.d.ts

@@ -1,7 +1,7 @@
 import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { FNodeInputBase } from './f-node-input-base';
-import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
+import { EFConnectableSide } from '../../f-connection-v2';
 import * as i0 from "@angular/core";
 export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
     readonly hostElement: any;

package/f-connectors/f-node-outlet/f-node-outlet-base.d.ts

@@ -1,9 +1,10 @@
 import { InjectionToken } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { FConnectorBase, FConnectorKind } from '../f-connector-base';
 import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
 export declare abstract class FNodeOutletBase extends FSourceConnectorBase {
+    kind: FConnectorKind;
     abstract isConnectionFromOutlet: boolean;
     private _outputs;
     get canBeConnected(): boolean;

package/f-connectors/f-node-outlet/f-node-outlet.directive.d.ts

@@ -1,6 +1,6 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { FNodeOutletBase } from './f-node-outlet-base';
-import { EFConnectableSide } from '../e-f-connectable-side';
+import { EFConnectableSide } from '../../f-connection-v2';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
     readonly hostElement: any;

package/f-connectors/f-node-output/f-node-output-base.d.ts

@@ -1,8 +1,10 @@
 import { InjectionToken, Signal } from '@angular/core';
 import { FSourceConnectorBase } from '../f-source-connector-base';
+import { FConnectorKind } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
 export declare abstract class FNodeOutputBase extends FSourceConnectorBase {
+    kind: FConnectorKind;
     abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;

package/f-connectors/f-node-output/f-node-output.directive.d.ts

@@ -1,7 +1,7 @@
 import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { FNodeOutputBase } from './f-node-output-base';
-import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
+import { EFConnectableSide } from '../../f-connection-v2';
 import * as i0 from "@angular/core";
 export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnChanges, OnDestroy {
     readonly hostElement: any;

package/f-connectors/f-source-connector-base.d.ts

@@ -1,7 +1,10 @@
 import { FConnectorBase } from './f-connector-base';
 import { FNodeInputBase } from './f-node-input';
+import * as i0 from "@angular/core";
 export declare abstract class FSourceConnectorBase extends FConnectorBase {
     abstract canBeConnectedInputs: string[];
     get hasConnectionLimits(): boolean;
     canConnectTo(targetConnector: FNodeInputBase): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSourceConnectorBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FSourceConnectorBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-connectors/index.d.ts

@@ -3,5 +3,4 @@ export * from './f-node-outlet';
 export * from './f-node-output';
 export * from './f-connector-base';
 export * from './f-source-connector-base';
-export * from './e-f-connectable-side';
 export * from './providers';

package/f-draggable/connection/create-connection/create-connection-finalize/create-connection-finalize-request.d.ts

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

package/f-draggable/connection/create-connection/create-connection-finalize/create-connection-finalize.d.ts

@@ -0,0 +1,19 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFinalizeRequest } from './create-connection-finalize-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionFinalize implements IHandler<CreateConnectionFinalizeRequest, void> {
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _dragHandler();
+    handle(request: CreateConnectionFinalizeRequest): void;
+    private _isValid;
+    private _getTargetOutput;
+    private _getOutput;
+    private _getOutlet;
+    private _emitEvent;
+    private _getInputUnderPointer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFinalize>;
+}

package/f-draggable/connection/create-connection/create-connection-finalize/index.d.ts

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

package/f-draggable/connection/create-connection/create-connection-handler/create-connection-handler.d.ts

@@ -0,0 +1,35 @@
+import { IPoint } from '@foblex/2d';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../../f-connectors';
+import { DragHandlerBase } from '../../../infrastructure';
+import { ICreateConnectionEventData } from '../i-create-connection-event-data';
+import * as i0 from "@angular/core";
+type FSourceConnector = FNodeOutputBase | FNodeOutletBase;
+export declare class CreateConnectionHandler extends DragHandlerBase<ICreateConnectionEventData> {
+    protected readonly type = "create-connection";
+    protected readonly kind = "create-connection";
+    protected data(): {
+        fOutputOrOutletId: string;
+    };
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _connectionBehaviour;
+    private readonly _store;
+    private get _connection();
+    private get _snapConnection();
+    private _targets;
+    private _sourceRef;
+    private _pointerDown;
+    initialize(source: FSourceConnector, pointer: IPoint): void;
+    prepareDragSequence(): void;
+    private _collectAndMarkTargets;
+    private _initSnapConnection;
+    private _initCreateConnection;
+    onPointerMove(difference: IPoint): void;
+    private _findClosestTarget;
+    private _drawCreateConnection;
+    private _drawSnapConnection;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionHandler>;
+}
+export {};

package/f-draggable/connection/create-connection/create-connection-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './create-connection-handler';

package/f-draggable/connection/create-connection/create-connection-preparation/create-connection-preparation.d.ts

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionPreparationRequest } from './create-connection-preparation-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionPreparation implements IHandler<CreateConnectionPreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    handle({ event, fTrigger }: CreateConnectionPreparationRequest): void;
+    private _findOwnerNode;
+    private _isValidConditions;
+    private _isValidTrigger;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionPreparation>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/create-connection-create-drag-handler-request.d.ts

@@ -0,0 +1,8 @@
+import { IPoint } from '@foblex/2d';
+import { FNodeOutletBase, FNodeOutputBase } from '../../../../../f-connectors';
+export declare class CreateConnectionCreateDragHandlerRequest {
+    readonly eventPosition: IPoint;
+    readonly source: FNodeOutputBase | FNodeOutletBase;
+    static readonly fToken: unique symbol;
+    constructor(eventPosition: IPoint, source: FNodeOutputBase | FNodeOutletBase);
+}

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/create-connection-create-drag-handler.d.ts

@@ -0,0 +1,26 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionCreateDragHandlerRequest } from './create-connection-create-drag-handler-request';
+import * as i0 from "@angular/core";
+export declare class CreateConnectionCreateDragHandler implements IHandler<CreateConnectionCreateDragHandlerRequest, void> {
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _transform();
+    handle({ source, eventPosition }: CreateConnectionCreateDragHandlerRequest): void;
+    /**
+     * Converts raw pointer position to "flow host space":
+     * - applies elementTransform(flowHost)
+     * - normalizes by scale
+     */
+    private _toFlowSpace;
+    /**
+     * Converts from flow space to "canvas local space":
+     * - removes transform offsets (position, scaledPosition)
+     * - keeps normalization consistent
+     *
+     * (Same math as your original chain, just named.)
+     */
+    private _toCanvasSpace;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionCreateDragHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionCreateDragHandler>;
+}