@foblex/flow 17.8.0 → 17.8.2

package/f-connection/common/f-connection-base.d.ts

@@ -11,10 +11,10 @@ import { FConnectionDragHandleEndComponent, FConnectionDragHandleStartComponent
 import { FConnectionSelectionComponent } from './f-selection';
 import { IConnectionText } from './f-connection-text';
 import { EFConnectableSide } from '../../f-connectors';
-import { FConnectionFactory } from '../f-connection-builder';
 import { IHasHostElement } from '../../i-has-host-element';
 import { ISelectable, ICanChangeVisibility } from '../../mixins';
-import { FConnectionCenterDirective } from "../f-connection-center";
+import { FConnectionCenterDirective } from '../f-connection-center';
+import { FConnectionContent } from '../f-connection-content';
 import * as i0 from "@angular/core";
 declare const MIXIN_BASE: import("../../mixins").Constructor<ISelectable> & import("../../mixins").AbstractConstructor<ISelectable> & import("../../mixins").Constructor<ICanChangeVisibility> & import("../../mixins").AbstractConstructor<ICanChangeVisibility> & {
     new (hostElement: HTMLElement): {
@@ -22,12 +22,12 @@ declare const MIXIN_BASE: import("../../mixins").Constructor<ISelectable> & impo
     };
 };
 export declare abstract class FConnectionBase extends MIXIN_BASE implements IHasHostElement, ISelectable, ICanChangeVisibility, IHasConnectionColor, IHasConnectionFromTo, IHasConnectionText {
-    private cFactory;
+    private readonly _connectionFactory;
     abstract fId: Signal<string>;
     readonly fStartColor: import("@angular/core").InputSignal<string>;
     readonly fEndColor: import("@angular/core").InputSignal<string>;
-    abstract fOutputId: string;
-    abstract fInputId: string;
+    abstract fOutputId: Signal<string>;
+    abstract fInputId: Signal<string>;
     abstract fRadius: number;
     abstract fOffset: number;
     path: string;
@@ -49,18 +49,20 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements IHas
     abstract fTextStartOffset: string;
     readonly fConnectionCenter: Signal<ElementRef<HTMLDivElement> | undefined>;
     readonly fConnectionCenters: Signal<readonly FConnectionCenterDirective[]>;
-    private penultimatePoint;
-    private secondPoint;
-    protected constructor(elementReference: ElementRef<HTMLElement>, cFactory: FConnectionFactory);
+    readonly fConnectionContents: Signal<readonly FConnectionContent[]>;
+    private _penultimatePoint;
+    private _secondPoint;
+    protected constructor();
     initialize(): void;
     isContains(element: HTMLElement | SVGElement): boolean;
     setLine({ point1, point2 }: ILine, sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
-    private getPathResult;
-    private getTransform;
+    private _contents;
+    private _getPathResult;
+    private _createTransformString;
     markChildrenAsSelected(): void;
     unmarkChildrenAsSelected(): void;
     redraw(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, { "fStartColor": { "alias": "fStartColor"; "required": false; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": false; "isSignal": true; }; }, {}, ["fConnectionCenters"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, { "fStartColor": { "alias": "fStartColor"; "required": false; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": false; "isSignal": true; }; }, {}, ["fConnectionCenters", "fConnectionContents"], never, false, never>;
 }
 export {};

package/f-connection/common/f-connection-text/f-connection-text-path.directive.d.ts

@@ -1,23 +1,18 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { IHasConnectionText } from '../i-has-connection-text';
-import { IHasConnectionFromTo } from '../i-has-connection-from-to';
-import { BrowserService } from '@foblex/platform';
+import { OnInit } from '@angular/core';
 import { IHasHostElement } from '../../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FConnectionTextPathDirective implements IHasHostElement, OnInit {
-    private elementReference;
-    private base;
-    private fBrowser;
+    readonly hostElement: any;
+    private readonly _base;
+    private readonly _browser;
     get linkToConnection(): string;
-    get hostElement(): SVGTextPathElement;
     symbolWidth: number;
     fontSize: string;
-    constructor(elementReference: ElementRef<SVGTextPathElement>, base: IHasConnectionText & IHasConnectionFromTo, fBrowser: BrowserService);
     ngOnInit(): void;
     getBBox(): DOMRect;
     redraw(): void;
-    private getFontStyles;
-    private getSymbolWidth;
+    private _getFontStyles;
+    private _getSymbolWidth;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionTextPathDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionTextPathDirective, "textPath[f-connection-text-path]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-connection-text/f-connection-text.component.d.ts

@@ -1,22 +1,16 @@
-import { ElementRef } from "@angular/core";
 import { ILine } from '@foblex/2d';
-import { FConnectionTextPathDirective } from './f-connection-text-path.directive';
-import { IHasConnectionText } from '../i-has-connection-text';
-import { IHasConnectionFromTo } from '../i-has-connection-from-to';
 import { IConnectionText } from './i-connection-text';
 import * as i0 from "@angular/core";
 export declare class FConnectionTextComponent implements IConnectionText {
-    private elementReference;
-    private base;
+    readonly hostElement: any;
+    private readonly _base;
+    private readonly _textPathDirective;
     get textId(): string;
-    get hostElement(): SVGTextElement;
     get text(): string;
-    textPathDirective: FConnectionTextPathDirective;
-    constructor(elementReference: ElementRef<SVGTextElement>, base: IHasConnectionText & IHasConnectionFromTo);
     redraw(line: ILine): void;
-    private calculateDy;
-    private static isTextReverse;
-    private static getTextStartOffset;
+    private _calculateDy;
+    private static _isTextReverse;
+    private static _getTextStartOffset;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionTextComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionTextComponent, "text[f-connection-text]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-gradient/f-connection-gradient.component.d.ts

@@ -1,21 +1,16 @@
-import { ElementRef } from "@angular/core";
 import { ILine } from '@foblex/2d';
-import { IHasConnectionFromTo } from '../i-has-connection-from-to';
-import { IHasConnectionColor } from '../i-has-connection-color';
 import { IConnectionGradient } from './i-connection-gradient';
 import * as i0 from "@angular/core";
 export declare class FConnectionGradientComponent implements IConnectionGradient {
-    private elementReference;
-    private base;
+    readonly hostElement: any;
+    private readonly _base;
     get gradientId(): string;
-    get hostElement(): SVGLinearGradientElement;
     get stop1Element(): SVGStopElement;
     get stop2Element(): SVGStopElement;
-    constructor(elementReference: ElementRef<SVGLinearGradientElement>, base: IHasConnectionColor & IHasConnectionFromTo);
     initialize(): void;
-    private updateGradient;
-    private setFromColor;
-    private setToColor;
+    private _updateGradient;
+    private _setFromColor;
+    private _setToColor;
     redraw(line: ILine): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientComponent, "linearGradient[fConnectionGradient]", never, {}, {}, never, never, false, never>;

package/f-connection/common/f-path/f-connection-path.component.d.ts

@@ -1,16 +1,11 @@
-import { ElementRef } from "@angular/core";
-import { IHasConnectionColor } from '../i-has-connection-color';
-import { IHasConnectionFromTo } from '../i-has-connection-from-to';
 import { IConnectionPath } from './i-connection-path';
 import * as i0 from "@angular/core";
 export declare class FConnectionPathComponent implements IConnectionPath {
-    private elementReference;
-    private base;
+    readonly hostElement: any;
+    private readonly _base;
     get fPathId(): string;
     get linkToGradient(): string;
     get attrConnectionId(): string;
-    get hostElement(): SVGPathElement;
-    constructor(elementReference: ElementRef<SVGPathElement>, base: IHasConnectionColor & IHasConnectionFromTo);
     initialize(): void;
     setPath(path: string): void;
     select(): void;

package/f-connection/common/f-selection/f-connection-selection.component.d.ts

@@ -1,13 +1,9 @@
-import { ElementRef } from "@angular/core";
-import { IHasConnectionFromTo } from '../i-has-connection-from-to';
 import { IHasHostElement } from '../../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FConnectionSelectionComponent implements IHasHostElement {
-    private elementReference;
-    private base;
+    readonly hostElement: any;
+    private readonly _base;
     get connectionForSelectionId(): string;
-    get hostElement(): SVGPathElement;
-    constructor(elementReference: ElementRef<SVGPathElement>, base: IHasConnectionFromTo);
     setPath(path: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionSelectionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, {}, {}, never, never, false, never>;

package/f-connection/common/i-has-connection-from-to.d.ts

@@ -1,6 +1,6 @@
-import { Signal } from "@angular/core";
+import { Signal } from '@angular/core';
 export interface IHasConnectionFromTo {
     fId: Signal<string>;
-    fOutputId: string;
-    fInputId: string;
+    fOutputId: Signal<string>;
+    fInputId: Signal<string>;
 }

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

@@ -1,14 +1,15 @@
-import { ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
+import { OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { EFConnectionBehavior, EFConnectionType } from '../common';
-import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
 export declare class FConnectionComponent extends FConnectionBase implements OnInit, OnChanges, OnDestroy {
     fId: import("@angular/core").InputSignal<string>;
+    /** @deprecated [fText] is deprecated and will be removed in v18.0.0. Use FConnectionContent directive instead. */
     fText: string;
+    /** @deprecated [fTextStartOffset] is deprecated and will be removed in v18.0.0. Use FConnectionContent directive instead. */
     fTextStartOffset: string;
-    fOutputId: any;
-    fInputId: any;
+    fOutputId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    fInputId: import("@angular/core").InputSignalWithTransform<string, unknown>;
     fRadius: number;
     fOffset: number;
     fBehavior: EFConnectionBehavior;
@@ -18,12 +19,11 @@ export declare class FConnectionComponent extends FConnectionBase implements OnI
     fDraggingDisabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     get boundingElement(): HTMLElement | SVGElement;
     private readonly _mediator;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; "isSignal": true; }; "fText": { "alias": "fText"; "required": false; }; "fTextStartOffset": { "alias": "fTextStartOffset"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": false; }; "fInputId": { "alias": "fInputId"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; "isSignal": true; }; "fReassignableStart": { "alias": "fReassignableStart"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; "isSignal": true; }; "fText": { "alias": "fText"; "required": false; }; "fTextStartOffset": { "alias": "fTextStartOffset"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "fInputId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; "isSignal": true; }; "fReassignableStart": { "alias": "fReassignableStart"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[fConnectionCenter]", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;
     static ngAcceptInputType_fBehavior: unknown;

package/f-connection/f-connection-builder/i-f-connection-builder-response.d.ts

@@ -4,4 +4,5 @@ export interface IFConnectionBuilderResponse {
     connectionCenter: IPoint;
     penultimatePoint: IPoint;
     secondPoint: IPoint;
+    points?: IPoint[];
 }

package/f-connection/f-connection-center/f-connection-center.directive.d.ts

@@ -1,5 +1,10 @@
 import * as i0 from "@angular/core";
+/** @deprecated '[fConnectionCenter] is deprecated and will be removed in v18.0.0. Use FConnectionContent directive instead.' */
 export declare class FConnectionCenterDirective {
+    /**
+     * @deprecated '[fConnectionCenter] is deprecated and will be removed in v18.0.0. Use FConnectionContent directive instead.'
+     */
+    readonly fConnectionCenter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionCenterDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionCenterDirective, "[fConnectionCenter]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionCenterDirective, "[fConnectionCenter]", never, { "fConnectionCenter": { "alias": "fConnectionCenter"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
 }

package/f-connection/f-connection-content/f-connection-content.d.ts

@@ -0,0 +1,69 @@
+import { OnInit } from '@angular/core';
+import { IPolylineContent, PolylineContentAlign } from './polyline-content-engine';
+import * as i0 from "@angular/core";
+/**
+ * Directive for placing custom user content (text, icons, buttons, etc.)
+ * along a connection line.
+ *
+ * It allows you to specify the position along the connection,
+ * shift the content sideways (perpendicular to the path),
+ * apply a margin near the edges, and control orientation.
+ *
+ * ### Usage examples
+ *
+ * ```html
+ * <!-- Text centered on the connection -->
+ * <div fConnectionContent [position]="0.5">
+ *   Hello
+ * </div>
+ *
+ * <!-- Button near the start of the connection, shifted upward by 12px -->
+ * <button fConnectionContent [position]="0.2" [offset]="-12">
+ *   +
+ * </button>
+ *
+ * <!-- Icon at the end of the connection, with 6px margin and rotated along the path -->
+ * <span fConnectionContent [position]="1" [margin]="6" align="along">
+ *   ⮕
+ * </span>
+ * ```
+ */
+export declare class FConnectionContent implements OnInit, IPolylineContent {
+    private readonly _mediator;
+    private readonly _injector;
+    /**
+     * The host DOM element to which the directive is applied.
+     * Used internally for positioning calculations.
+     */
+    readonly hostElement: any;
+    /**
+     * Position along the connection.
+     *
+     * A normalized value in the range `0..1`:
+     * - `0` — at the start of the connection,
+     * - `1` — at the end of the connection,
+     * - `0.5` — at the middle of the connection (default).
+     */
+    readonly position: import("@angular/core").InputSignalWithTransform<number, number>;
+    /**
+     * Perpendicular offset from the connection line (in pixels).
+     *
+     * - Positive values shift the element to the right
+     *   relative to the line direction.
+     * - Negative values shift it to the left.
+     * - Default: `0` (no shift).
+     */
+    readonly offset: import("@angular/core").InputSignal<number>;
+    /**
+     * Controls the orientation (rotation) of the content relative to the connection.
+     *
+     * Possible values:
+     * - `'none'` — no rotation (default).
+     * - `'along'` — aligned along the path (tangent).
+     */
+    readonly align: import("@angular/core").InputSignalWithTransform<PolylineContentAlign, unknown>;
+    ngOnInit(): void;
+    private _listenChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionContent, "[fConnectionContent]", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,2 @@
+export * from './polyline-content-engine';
+export * from './f-connection-content';

package/f-connection/f-connection-content/polyline-content-engine/i-polyline-content.d.ts

@@ -0,0 +1,9 @@
+import { Signal } from '@angular/core';
+import { PolylineContentAlign } from './polyline-content-align';
+/** Domain contract for content item to be placed along the path. */
+export interface IPolylineContent {
+    position: Signal<number>;
+    offset: Signal<number>;
+    align: Signal<PolylineContentAlign>;
+    hostElement: HTMLElement;
+}

package/f-connection/f-connection-content/polyline-content-engine/index.d.ts

@@ -0,0 +1,5 @@
+export * from './polyline-sampler';
+export * from './polyline-content-align';
+export * from './i-polyline-content';
+export * from './polyline-content-layout-engine';
+export * from './polyline-content-place';

package/f-connection/f-connection-content/polyline-content-engine/polyline-content-align.d.ts

@@ -0,0 +1,4 @@
+export declare enum PolylineContentAlign {
+    NONE = "none",
+    ALONG = "along"
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-content-layout-engine.d.ts

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { IPolylineContent } from './i-polyline-content';
+import { PolylineContentPlace } from './polyline-content-place';
+/**
+ * Engine that orchestrates positioning and orientation of all
+ * connection contents along a computed path.
+ */
+export declare class ConnectionContentLayoutEngine {
+    private readonly _placement;
+    constructor(_placement?: PolylineContentPlace);
+    layout(line: {
+        point1: IPoint;
+        point2: IPoint;
+    }, builderResult: {
+        points?: IPoint[];
+        secondPoint: IPoint;
+        connectionCenter: IPoint;
+        penultimatePoint: IPoint;
+    }, contents: Iterable<IPolylineContent>): number;
+    private _createTransformString;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-content-place.d.ts

@@ -0,0 +1,18 @@
+import { IPolylineContent } from './i-polyline-content';
+import { IPoint } from '@foblex/2d';
+import { PolylineSampler } from './polyline-sampler';
+/**
+ * Encapsulates placement logic for a single content item along the path.
+ */
+export declare class PolylineContentPlace {
+    compute(sampler: PolylineSampler, content: IPolylineContent): {
+        position: IPoint;
+        rotationDeg: number;
+    };
+    private _clamp01;
+    private _applyEdgeGuard;
+    private _sizeAlongDirection;
+    private _normalize180;
+    private _keepUpright;
+    private _calculateContentRotation;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/i-sampler-result.d.ts

@@ -0,0 +1,11 @@
+import { ITangent } from './i-tangent';
+import { IPoint } from '@foblex/2d';
+/** Result of sampling the path. */
+export interface ISamplerResult {
+    /** Interpolated point on the polyline. */
+    point: IPoint;
+    /** Unit tangent (segment direction) at that point. */
+    tangent: ITangent;
+    /** Whether the result was clamped to the path edge (start or end). */
+    atEdge: boolean;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/i-tangent.d.ts

@@ -0,0 +1,4 @@
+import { IPoint } from '@foblex/2d';
+/** Unit tangent vector. */
+export interface ITangent extends IPoint {
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/index.d.ts

@@ -0,0 +1,4 @@
+export * from './i-sampler-result';
+export * from './i-tangent';
+export * from './polyline';
+export * from './polyline-sampler';

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/polyline-sampler.d.ts

@@ -0,0 +1,60 @@
+import { IPoint } from '@foblex/2d';
+import { ISamplerResult } from './i-sampler-result';
+/**
+ * Provides sampling (interpolation) along a {@link Polyline}.
+ * Separates traversal logic from pure geometry stored in {@link Polyline}.
+ */
+export declare class PolylineSampler {
+    private _polyline;
+    /**
+     * @param points Initial points to build the underlying polyline.
+     *               You can later call {@link updatePoints} to rebuild.
+     */
+    constructor(points?: IPoint[]);
+    /**
+     * Rebuild the underlying polyline from new points.
+     * @returns Total length of the rebuilt polyline.
+     */
+    updatePoints(points: IPoint[]): number;
+    /**
+     * Backward-compatible alias for older API naming.
+     * @returns Total length of the rebuilt polyline.
+     */
+    calculateTotalLength(points: IPoint[]): number;
+    /** Total length of the current polyline. */
+    get totalLength(): number;
+    /**
+     * Sample a point by normalized progress along the whole length.
+     *
+     * - `progress = 0` → start vertex
+     * - `progress = 1` → end vertex
+     *
+     * Uses a small edge threshold (0.5 units) to snap near-start/near-end queries to exact vertices,
+     * mirroring the behavior in the original implementation.
+     *
+     * @param progress Normalized value in [0..1]. Values are clamped to this range.
+     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
+     */
+    getPointAtProgress(progress: number): ISamplerResult;
+    /**
+     * Backward-compatible alias.
+     * Equivalent to {@link getPointAtProgress}.
+     */
+    getPointAtLength(progress: number): ISamplerResult;
+    /**
+     * Sample a point by absolute distance from the start (in the same units as your points).
+     * This is a convenience wrapper over {@link getPointAtProgress}.
+     *
+     * @param distance Distance from 0 to {@link totalLength}. Values outside are clamped.
+     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
+     */
+    getPointAtDistance(distance: number): ISamplerResult;
+    /** Binary-search the first index where cumulativeLengths[index] >= target. */
+    private static _findRightIndex;
+    /** Linear interpolation between `a` and `b`. */
+    private static _lerp;
+    /** Clamp `value` into [min, max]. */
+    private static _clamp;
+    /** Safe ratio `num / den` with tiny-denominator guard. */
+    private static _safeRatio;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/polyline.d.ts

@@ -0,0 +1,29 @@
+import { IPoint } from '@foblex/2d';
+import { ITangent } from './i-tangent';
+/**
+ * Immutable polyline geometry with precomputed cumulative lengths and segment tangents.
+ * Keep this class focused on geometry only; sampling/traversal lives in PolylineSampler.
+ */
+export declare class Polyline {
+    /** Cleaned points (with consecutive duplicates removed). */
+    readonly points: IPoint[];
+    /** Cumulative length from start to each vertex. Same length as `points`. */
+    readonly cumulativeLengths: number[];
+    /** Unit tangent per segment `i` for segment [i -> i+1]. Length = points.length - 1. */
+    readonly segmentTangents: ITangent[];
+    /** Total length of the polyline (>= 1 for the degenerate fallback). */
+    readonly totalLength: number;
+    /**
+     * Construct a polyline from raw points.
+     * Consecutive duplicate points are removed.
+     * If less than 2 points remain, it falls back to a unit horizontal segment [0,0] → [1,0].
+     */
+    constructor(points: IPoint[]);
+    /**
+     * Create a polyline by cloning points (defensive copy).
+     * @param points Raw input points; they will be copied and cleaned.
+     */
+    static from(points: IPoint[]): Polyline;
+    /** Remove consecutive duplicate points. */
+    private static _removeConsecutiveDuplicates;
+}

package/f-connection/f-connection-for-create/f-connection-for-create.component.d.ts

@@ -1,28 +1,26 @@
-import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
 export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
     fId: import("@angular/core").WritableSignal<string>;
     fText: string;
     fTextStartOffset: string;
-    fOutputId: string;
-    fInputId: string;
+    fOutputId: import("@angular/core").WritableSignal<string>;
+    fInputId: import("@angular/core").WritableSignal<string>;
     fRadius: number;
     fOffset: number;
     fBehavior: EFConnectionBehavior;
     fType: EFConnectionType | string;
     get boundingElement(): HTMLElement | SVGElement;
     private readonly _mediator;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, never, ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, never, ["*", "[fConnectionCenter]", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;
     static ngAcceptInputType_fBehavior: unknown;

package/f-connection/f-marker/f-marker-base.d.ts

@@ -1,6 +1,5 @@
 import { InjectionToken } from '@angular/core';
 import { IHasHostElement } from '../../i-has-host-element';
-import * as i0 from "@angular/core";
 export declare const F_MARKER: InjectionToken<unknown>;
 export declare abstract class FMarkerBase implements IHasHostElement {
     abstract hostElement: HTMLElement;
@@ -11,6 +10,4 @@ export declare abstract class FMarkerBase implements IHasHostElement {
     abstract type: string;
     abstract orient: 'auto' | 'auto-start-reverse' | string;
     abstract markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-connection/f-marker/f-marker.directive.d.ts

@@ -1,9 +1,9 @@
-import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { OnDestroy, OnInit } from '@angular/core';
 import { FMarkerBase } from './f-marker-base';
 import * as i0 from "@angular/core";
 export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnDestroy {
-    private elementReference;
-    get hostElement(): HTMLElement;
+    readonly hostElement: any;
+    private readonly _mediator;
     width: number;
     height: number;
     refX: number;
@@ -11,10 +11,8 @@ export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnD
     type: string;
     orient: 'auto' | 'auto-start-reverse' | 'calculated' | string;
     markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    private _fMediator;
-    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "hostElement": { "alias": "hostElement"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-connection/f-snap-connection/f-snap-connection.component.d.ts

@@ -1,7 +1,6 @@
-import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
 export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
@@ -9,21 +8,20 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fText: string;
     fTextStartOffset: string;
     fSnapThreshold: number;
-    fOutputId: string;
-    fInputId: string;
+    fOutputId: import("@angular/core").WritableSignal<string>;
+    fInputId: import("@angular/core").WritableSignal<string>;
     fRadius: number;
     fOffset: number;
     fBehavior: EFConnectionBehavior;
     fType: EFConnectionType | string;
     get boundingElement(): HTMLElement | SVGElement;
     private readonly _mediator;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, never, ["*", "[fConnectionCenter]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, never, ["*", "[fConnectionCenter]", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fSnapThreshold: unknown;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;

package/f-connection/index.d.ts

@@ -3,6 +3,7 @@ export * from './f-connection-for-create';
 export * from './f-connection';
 export * from './f-connection-builder';
 export * from './f-connection-center';
+export * from './f-connection-content';
 export * from './f-marker';
 export * from './f-snap-connection';
 export * from './providers';