@foblex/flow 17.9.21 → 18.0.0

package/esm2022/{f-connection/f-connection-content/polyline-content-engine → f-connection-v2/components/connection-content/utils}/polyline-content-place.mjs

@@ -1,5 +1,5 @@
 import { PolylineContentAlign } from './polyline-content-align';
-import { DragRectCache } from '../../../domain';
+import { DragRectCache } from '../../../../domain';
 /**
  * Encapsulates placement logic for a single content item along the path.
  */
@@ -63,4 +63,4 @@ export class PolylineContentPlace {
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/components/connection-content/utils/polyline-sampler/i-sampler-result.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS1zYW1wbGVyLXJlc3VsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uLXYyL2NvbXBvbmVudHMvY29ubmVjdGlvbi1jb250ZW50L3V0aWxzL3BvbHlsaW5lLXNhbXBsZXIvaS1zYW1wbGVyLXJlc3VsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVRhbmdlbnQgfSBmcm9tICcuL2ktdGFuZ2VudCc7XG5pbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcblxuLyoqIFJlc3VsdCBvZiBzYW1wbGluZyB0aGUgcGF0aC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSVNhbXBsZXJSZXN1bHQge1xuICAvKiogSW50ZXJwb2xhdGVkIHBvaW50IG9uIHRoZSBwb2x5bGluZS4gKi9cbiAgcG9pbnQ6IElQb2ludDtcbiAgLyoqIFVuaXQgdGFuZ2VudCAoc2VnbWVudCBkaXJlY3Rpb24pIGF0IHRoYXQgcG9pbnQuICovXG4gIHRhbmdlbnQ6IElUYW5nZW50O1xuICAvKiogV2hldGhlciB0aGUgcmVzdWx0IHdhcyBjbGFtcGVkIHRvIHRoZSBwYXRoIGVkZ2UgKHN0YXJ0IG9yIGVuZCkuICovXG4gIGF0RWRnZTogYm9vbGVhbjtcbn1cbiJdfQ==

package/esm2022/f-connection-v2/components/connection-content/utils/polyline-sampler/i-tangent.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS10YW5nZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvY29tcG9uZW50cy9jb25uZWN0aW9uLWNvbnRlbnQvdXRpbHMvcG9seWxpbmUtc2FtcGxlci9pLXRhbmdlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuXG4vKiogVW5pdCB0YW5nZW50IHZlY3Rvci4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSVRhbmdlbnQgZXh0ZW5kcyBJUG9pbnQge31cbiJdfQ==

package/esm2022/f-connection-v2/components/connection-content/utils/polyline-sampler/index.mjs

@@ -0,0 +1,5 @@
+export * from './i-sampler-result';
+export * from './i-tangent';
+export * from './polyline';
+export * from './polyline-sampler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tY29udGVudC91dGlscy9wb2x5bGluZS1zYW1wbGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsY0FBYyxhQUFhLENBQUM7QUFFNUIsY0FBYyxZQUFZLENBQUM7QUFFM0IsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaS1zYW1wbGVyLXJlc3VsdCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaS10YW5nZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9wb2x5bGluZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcG9seWxpbmUtc2FtcGxlcic7XG4iXX0=

package/esm2022/f-connection-v2/components/connection-content/utils/polyline-sampler/polyline-sampler.mjs

@@ -0,0 +1,143 @@
+import { Polyline } from './polyline';
+/**
+ * Provides sampling (interpolation) along a {@link Polyline}.
+ * Separates traversal logic from pure geometry stored in {@link Polyline}.
+ */
+export class PolylineSampler {
+    _polyline;
+    /**
+     * @param points Initial points to build the underlying polyline.
+     *               You can later call {@link updatePoints} to rebuild.
+     */
+    constructor(points = []) {
+        this._polyline = new Polyline(points);
+    }
+    /**
+     * Rebuild the underlying polyline from new points.
+     * @returns Total length of the rebuilt polyline.
+     */
+    updatePoints(points) {
+        this._polyline = new Polyline(points);
+        return this._polyline.totalLength;
+    }
+    /**
+     * Backward-compatible alias for older API naming.
+     * @returns Total length of the rebuilt polyline.
+     */
+    calculateTotalLength(points) {
+        return this.updatePoints(points);
+    }
+    /** Total length of the current polyline. */
+    get totalLength() {
+        return this._polyline.totalLength;
+    }
+    /**
+     * 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) {
+        const { points, cumulativeLengths, segmentTangents, totalLength } = this._polyline;
+        const clamped = PolylineSampler._clamp(progress, 0, 1);
+        const target = clamped * totalLength;
+        const edgeThreshold = 0.5;
+        if (target <= edgeThreshold) {
+            return {
+                point: points[0],
+                tangent: segmentTangents[0] ?? { x: 1, y: 0 },
+                atEdge: true,
+            };
+        }
+        if (totalLength - target <= edgeThreshold) {
+            const last = points.length - 1;
+            return {
+                point: points[last],
+                tangent: segmentTangents[last - 1] ?? { x: 1, y: 0 },
+                atEdge: true,
+            };
+        }
+        const rightIndex = PolylineSampler._findRightIndex(cumulativeLengths, target);
+        const i = Math.max(1, rightIndex);
+        const leftLen = cumulativeLengths[i - 1];
+        const rightLen = cumulativeLengths[i];
+        const t = PolylineSampler._safeRatio(target - leftLen, rightLen - leftLen);
+        const a = points[i - 1];
+        const b = points[i];
+        const point = {
+            x: PolylineSampler._lerp(a.x, b.x, t),
+            y: PolylineSampler._lerp(a.y, b.y, t),
+        };
+        const tangent = segmentTangents[i - 1] ?? { x: 1, y: 0 };
+        return { point, tangent, atEdge: false };
+    }
+    /**
+     * Backward-compatible alias.
+     * Equivalent to {@link getPointAtProgress}.
+     */
+    getPointAtLength(progress) {
+        return this.getPointAtProgress(progress);
+    }
+    /**
+     * 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) {
+        const progress = this._polyline.totalLength ? distance / this._polyline.totalLength : 0;
+        return this.getPointAtProgress(progress);
+    }
+    // =============== Internal utilities ===============
+    /** Binary-search the first index where cumulativeLengths[index] >= target. */
+    static _findRightIndex(cumulativeLengths, target) {
+        let lo = 0;
+        let hi = cumulativeLengths.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (cumulativeLengths[mid] < target)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    /** Linear interpolation between `a` and `b`. */
+    static _lerp(a, b, t) {
+        return a + (b - a) * t;
+    }
+    /** Clamp `value` into [min, max]. */
+    static _clamp(value, min, max) {
+        return value < min ? min : value > max ? max : value;
+    }
+    /** Safe ratio `num / den` with tiny-denominator guard. */
+    static _safeRatio(num, den) {
+        const d = Math.abs(den) < 1e-6 ? 1e-6 : den;
+        return num / d;
+    }
+}
+/* ============================
+   Example
+===============================
+const sampler = new PolylineSampler([
+  { x: 0, y: 0 },
+  { x: 10, y: 0 },
+  { x: 10, y: 10 },
+]);
+
+console.log('Total length:', sampler.totalLength); // -> 20
+
+const s1 = sampler.getPointAtProgress(0.25);
+console.log(s1.point, s1.tangent, s1.atEdge);
+
+const s2 = sampler.getPointAtDistance(15); // same as progress 0.75
+console.log(s2.point, s2.tangent, s2.atEdge);
+*/
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polyline-sampler.js","sourceRoot":"","sources":["../../../../../../../../projects/f-flow/src/f-connection-v2/components/connection-content/utils/polyline-sampler/polyline-sampler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC;;;GAGG;AACH,MAAM,OAAO,eAAe;IAClB,SAAS,CAAW;IAE5B;;;OAGG;IACH,YAAY,SAAmB,EAAE;QAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,MAAgB;QAClC,IAAI,CAAC,SAAS,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEtC,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;IACpC,CAAC;IAED;;;OAGG;IACI,oBAAoB,CAAC,MAAgB;QAC1C,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,4CAA4C;IAC5C,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;OAWG;IACI,kBAAkB,CAAC,QAAgB;QACxC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,eAAe,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QAEnF,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvD,MAAM,MAAM,GAAG,OAAO,GAAG,WAAW,CAAC;QAErC,MAAM,aAAa,GAAG,GAAG,CAAC;QAC1B,IAAI,MAAM,IAAI,aAAa,EAAE,CAAC;YAC5B,OAAO;gBACL,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;gBAChB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;gBAC7C,MAAM,EAAE,IAAI;aACb,CAAC;QACJ,CAAC;QACD,IAAI,WAAW,GAAG,MAAM,IAAI,aAAa,EAAE,CAAC;YAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YAE/B,OAAO;gBACL,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC;gBACnB,OAAO,EAAE,eAAe,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;gBACpD,MAAM,EAAE,IAAI;aACb,CAAC;QACJ,CAAC;QAED,MAAM,UAAU,GAAG,eAAe,CAAC,eAAe,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QAC9E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAElC,MAAM,OAAO,GAAG,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;QACtC,MAAM,CAAC,GAAG,eAAe,CAAC,UAAU,CAAC,MAAM,GAAG,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC;QAE3E,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACxB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,MAAM,KAAK,GAAG;YACZ,CAAC,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACrC,CAAC,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SACtC,CAAC;QACF,MAAM,OAAO,GAAG,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QAEzD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACI,gBAAgB,CAAC,QAAgB;QACtC,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,QAAgB;QACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAExF,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED,qDAAqD;IAErD,8EAA8E;IACtE,MAAM,CAAC,eAAe,CAAC,iBAA2B,EAAE,MAAc;QACxE,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC;QACtC,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC;YACf,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,MAAM;gBAAE,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;;gBAC7C,EAAE,GAAG,GAAG,CAAC;QAChB,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,gDAAgD;IACxC,MAAM,CAAC,KAAK,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;QAClD,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,qCAAqC;IAC7B,MAAM,CAAC,MAAM,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;QAC3D,OAAO,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC;IAED,0DAA0D;IAClD,MAAM,CAAC,UAAU,CAAC,GAAW,EAAE,GAAW;QAChD,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;QAE5C,OAAO,GAAG,GAAG,CAAC,CAAC;IACjB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;EAgBE","sourcesContent":["import { Polyline } from './polyline';\nimport { IPoint } from '@foblex/2d';\nimport { ISamplerResult } from './i-sampler-result';\n\n/**\n * Provides sampling (interpolation) along a {@link Polyline}.\n * Separates traversal logic from pure geometry stored in {@link Polyline}.\n */\nexport class PolylineSampler {\n  private _polyline: Polyline;\n\n  /**\n   * @param points Initial points to build the underlying polyline.\n   *               You can later call {@link updatePoints} to rebuild.\n   */\n  constructor(points: IPoint[] = []) {\n    this._polyline = new Polyline(points);\n  }\n\n  /**\n   * Rebuild the underlying polyline from new points.\n   * @returns Total length of the rebuilt polyline.\n   */\n  public updatePoints(points: IPoint[]): number {\n    this._polyline = new Polyline(points);\n\n    return this._polyline.totalLength;\n  }\n\n  /**\n   * Backward-compatible alias for older API naming.\n   * @returns Total length of the rebuilt polyline.\n   */\n  public calculateTotalLength(points: IPoint[]): number {\n    return this.updatePoints(points);\n  }\n\n  /** Total length of the current polyline. */\n  public get totalLength(): number {\n    return this._polyline.totalLength;\n  }\n\n  /**\n   * Sample a point by normalized progress along the whole length.\n   *\n   * - `progress = 0` → start vertex\n   * - `progress = 1` → end vertex\n   *\n   * Uses a small edge threshold (0.5 units) to snap near-start/near-end queries to exact vertices,\n   * mirroring the behavior in the original implementation.\n   *\n   * @param progress Normalized value in [0..1]. Values are clamped to this range.\n   * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.\n   */\n  public getPointAtProgress(progress: number): ISamplerResult {\n    const { points, cumulativeLengths, segmentTangents, totalLength } = this._polyline;\n\n    const clamped = PolylineSampler._clamp(progress, 0, 1);\n    const target = clamped * totalLength;\n\n    const edgeThreshold = 0.5;\n    if (target <= edgeThreshold) {\n      return {\n        point: points[0],\n        tangent: segmentTangents[0] ?? { x: 1, y: 0 },\n        atEdge: true,\n      };\n    }\n    if (totalLength - target <= edgeThreshold) {\n      const last = points.length - 1;\n\n      return {\n        point: points[last],\n        tangent: segmentTangents[last - 1] ?? { x: 1, y: 0 },\n        atEdge: true,\n      };\n    }\n\n    const rightIndex = PolylineSampler._findRightIndex(cumulativeLengths, target);\n    const i = Math.max(1, rightIndex);\n\n    const leftLen = cumulativeLengths[i - 1];\n    const rightLen = cumulativeLengths[i];\n    const t = PolylineSampler._safeRatio(target - leftLen, rightLen - leftLen);\n\n    const a = points[i - 1];\n    const b = points[i];\n    const point = {\n      x: PolylineSampler._lerp(a.x, b.x, t),\n      y: PolylineSampler._lerp(a.y, b.y, t),\n    };\n    const tangent = segmentTangents[i - 1] ?? { x: 1, y: 0 };\n\n    return { point, tangent, atEdge: false };\n  }\n\n  /**\n   * Backward-compatible alias.\n   * Equivalent to {@link getPointAtProgress}.\n   */\n  public getPointAtLength(progress: number): ISamplerResult {\n    return this.getPointAtProgress(progress);\n  }\n\n  /**\n   * Sample a point by absolute distance from the start (in the same units as your points).\n   * This is a convenience wrapper over {@link getPointAtProgress}.\n   *\n   * @param distance Distance from 0 to {@link totalLength}. Values outside are clamped.\n   * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.\n   */\n  public getPointAtDistance(distance: number): ISamplerResult {\n    const progress = this._polyline.totalLength ? distance / this._polyline.totalLength : 0;\n\n    return this.getPointAtProgress(progress);\n  }\n\n  // =============== Internal utilities ===============\n\n  /** Binary-search the first index where cumulativeLengths[index] >= target. */\n  private static _findRightIndex(cumulativeLengths: number[], target: number): number {\n    let lo = 0;\n    let hi = cumulativeLengths.length - 1;\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n      if (cumulativeLengths[mid] < target) lo = mid + 1;\n      else hi = mid;\n    }\n\n    return lo;\n  }\n\n  /** Linear interpolation between `a` and `b`. */\n  private static _lerp(a: number, b: number, t: number): number {\n    return a + (b - a) * t;\n  }\n\n  /** Clamp `value` into [min, max]. */\n  private static _clamp(value: number, min: number, max: number): number {\n    return value < min ? min : value > max ? max : value;\n  }\n\n  /** Safe ratio `num / den` with tiny-denominator guard. */\n  private static _safeRatio(num: number, den: number): number {\n    const d = Math.abs(den) < 1e-6 ? 1e-6 : den;\n\n    return num / d;\n  }\n}\n\n/* ============================\n   Example\n===============================\nconst sampler = new PolylineSampler([\n  { x: 0, y: 0 },\n  { x: 10, y: 0 },\n  { x: 10, y: 10 },\n]);\n\nconsole.log('Total length:', sampler.totalLength); // -> 20\n\nconst s1 = sampler.getPointAtProgress(0.25);\nconsole.log(s1.point, s1.tangent, s1.atEdge);\n\nconst s2 = sampler.getPointAtDistance(15); // same as progress 0.75\nconsole.log(s2.point, s2.tangent, s2.atEdge);\n*/\n"]}

package/esm2022/f-connection-v2/components/connection-content/utils/polyline-sampler/polyline.mjs

@@ -0,0 +1,71 @@
+/**
+ * Immutable polyline geometry with precomputed cumulative lengths and segment tangents.
+ * Keep this class focused on geometry only; sampling/traversal lives in PolylineSampler.
+ */
+export class Polyline {
+    /** Cleaned points (with consecutive duplicates removed). */
+    points;
+    /** Cumulative length from start to each vertex. Same length as `points`. */
+    cumulativeLengths;
+    /** Unit tangent per segment `i` for segment [i -> i+1]. Length = points.length - 1. */
+    segmentTangents;
+    /** Total length of the polyline (>= 1 for the degenerate fallback). */
+    totalLength;
+    /**
+     * 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) {
+        const cleaned = Polyline._removeConsecutiveDuplicates(points);
+        if (cleaned.length < 2) {
+            // Fallback to a unit segment to avoid zero-length edge cases.
+            this.points = [
+                { x: 0, y: 0 },
+                { x: 1, y: 0 },
+            ];
+            this.cumulativeLengths = [0, 1];
+            this.segmentTangents = [{ x: 1, y: 0 }];
+            this.totalLength = 1;
+            return;
+        }
+        this.points = cleaned;
+        const vertexCount = this.points.length;
+        const segmentCount = vertexCount - 1;
+        const cumulative = new Array(vertexCount).fill(0);
+        const tangents = new Array(segmentCount);
+        let accumulated = 0;
+        for (let i = 0; i < segmentCount; i++) {
+            const dx = this.points[i + 1].x - this.points[i].x;
+            const dy = this.points[i + 1].y - this.points[i].y;
+            const length = Math.hypot(dx, dy);
+            const ux = length ? dx / length : 1;
+            const uy = length ? dy / length : 0;
+            tangents[i] = { x: ux, y: uy };
+            accumulated += length;
+            cumulative[i + 1] = accumulated;
+        }
+        this.cumulativeLengths = cumulative;
+        this.segmentTangents = tangents;
+        this.totalLength = accumulated || 1;
+    }
+    /**
+     * Create a polyline by cloning points (defensive copy).
+     * @param points Raw input points; they will be copied and cleaned.
+     */
+    static from(points) {
+        return new Polyline(points.map((p) => ({ x: p.x, y: p.y })));
+    }
+    /** Remove consecutive duplicate points. */
+    static _removeConsecutiveDuplicates(points) {
+        const result = [];
+        for (const p of points) {
+            const last = result[result.length - 1];
+            if (!last || last.x !== p.x || last.y !== p.y) {
+                result.push({ x: p.x, y: p.y });
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/components/connection-drag-handles/f-connection-drag-handle-end.mjs

@@ -0,0 +1,35 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { F_CONNECTION_DRAG_HANDLE_END, FConnectionDragHandleBase } from './models';
+import * as i0 from "@angular/core";
+export class FConnectionDragHandleEnd extends FConnectionDragHandleBase {
+    redraw(penultimatePoint, endPoint) {
+        this.point = this.calculateCircleCenter(penultimatePoint, endPoint, 8);
+        this.hostElement.setAttribute('cx', this.point.x.toString());
+        this.hostElement.setAttribute('cy', this.point.y.toString());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionDragHandleEnd, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FConnectionDragHandleEnd, selector: "circle[f-connection-drag-handle-end]", host: { properties: { "class": "class" } }, providers: [
+            {
+                provide: F_CONNECTION_DRAG_HANDLE_END,
+                useExisting: FConnectionDragHandleEnd,
+            },
+        ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionDragHandleEnd, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'circle[f-connection-drag-handle-end]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[class]': 'class',
+                    },
+                    providers: [
+                        {
+                            provide: F_CONNECTION_DRAG_HANDLE_END,
+                            useExisting: FConnectionDragHandleEnd,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jb25uZWN0aW9uLWRyYWctaGFuZGxlLWVuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uLXYyL2NvbXBvbmVudHMvY29ubmVjdGlvbi1kcmFnLWhhbmRsZXMvZi1jb25uZWN0aW9uLWRyYWctaGFuZGxlLWVuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRW5FLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSx5QkFBeUIsRUFBRSxNQUFNLFVBQVUsQ0FBQzs7QUFnQm5GLE1BQU0sT0FBTyx3QkFBeUIsU0FBUSx5QkFBeUI7SUFDckQsTUFBTSxDQUFDLGdCQUF3QixFQUFFLFFBQWdCO1FBQy9ELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLHFCQUFxQixDQUFDLGdCQUFnQixFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUN2RSxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztRQUM3RCxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUMvRCxDQUFDO3dHQUxVLHdCQUF3Qjs0RkFBeEIsd0JBQXdCLDJHQVB4QjtZQUNUO2dCQUNFLE9BQU8sRUFBRSw0QkFBNEI7Z0JBQ3JDLFdBQVcsRUFBRSx3QkFBd0I7YUFDdEM7U0FDRixpREFWUyxFQUFFOzs0RkFZRCx3QkFBd0I7a0JBZHBDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHNDQUFzQztvQkFDaEQsUUFBUSxFQUFFLEVBQUU7b0JBQ1osZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLElBQUksRUFBRTt3QkFDSixTQUFTLEVBQUUsT0FBTztxQkFDbkI7b0JBQ0QsU0FBUyxFQUFFO3dCQUNUOzRCQUNFLE9BQU8sRUFBRSw0QkFBNEI7NEJBQ3JDLFdBQVcsMEJBQTBCO3lCQUN0QztxQkFDRjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IElQb2ludCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuaW1wb3J0IHsgRl9DT05ORUNUSU9OX0RSQUdfSEFORExFX0VORCwgRkNvbm5lY3Rpb25EcmFnSGFuZGxlQmFzZSB9IGZyb20gJy4vbW9kZWxzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY2lyY2xlW2YtY29ubmVjdGlvbi1kcmFnLWhhbmRsZS1lbmRdJyxcbiAgdGVtcGxhdGU6ICcnLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgaG9zdDoge1xuICAgICdbY2xhc3NdJzogJ2NsYXNzJyxcbiAgfSxcbiAgcHJvdmlkZXJzOiBbXG4gICAge1xuICAgICAgcHJvdmlkZTogRl9DT05ORUNUSU9OX0RSQUdfSEFORExFX0VORCxcbiAgICAgIHVzZUV4aXN0aW5nOiBGQ29ubmVjdGlvbkRyYWdIYW5kbGVFbmQsXG4gICAgfSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgRkNvbm5lY3Rpb25EcmFnSGFuZGxlRW5kIGV4dGVuZHMgRkNvbm5lY3Rpb25EcmFnSGFuZGxlQmFzZSB7XG4gIHB1YmxpYyBvdmVycmlkZSByZWRyYXcocGVudWx0aW1hdGVQb2ludDogSVBvaW50LCBlbmRQb2ludDogSVBvaW50KTogdm9pZCB7XG4gICAgdGhpcy5wb2ludCA9IHRoaXMuY2FsY3VsYXRlQ2lyY2xlQ2VudGVyKHBlbnVsdGltYXRlUG9pbnQsIGVuZFBvaW50LCA4KTtcbiAgICB0aGlzLmhvc3RFbGVtZW50LnNldEF0dHJpYnV0ZSgnY3gnLCB0aGlzLnBvaW50LngudG9TdHJpbmcoKSk7XG4gICAgdGhpcy5ob3N0RWxlbWVudC5zZXRBdHRyaWJ1dGUoJ2N5JywgdGhpcy5wb2ludC55LnRvU3RyaW5nKCkpO1xuICB9XG59XG4iXX0=

package/esm2022/f-connection-v2/components/connection-drag-handles/f-connection-drag-handle-start.mjs

@@ -0,0 +1,35 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { F_CONNECTION_DRAG_HANDLE_START, FConnectionDragHandleBase } from './models';
+import * as i0 from "@angular/core";
+export class FConnectionDragHandleStart extends FConnectionDragHandleBase {
+    redraw(penultimatePoint, startPoint) {
+        this.point = this.calculateCircleCenter(penultimatePoint, startPoint, 8);
+        this.hostElement.setAttribute('cx', this.point.x.toString());
+        this.hostElement.setAttribute('cy', this.point.y.toString());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionDragHandleStart, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FConnectionDragHandleStart, selector: "circle[f-connection-drag-handle-start]", host: { properties: { "class": "class" } }, providers: [
+            {
+                provide: F_CONNECTION_DRAG_HANDLE_START,
+                useExisting: FConnectionDragHandleStart,
+            },
+        ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionDragHandleStart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'circle[f-connection-drag-handle-start]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[class]': 'class',
+                    },
+                    providers: [
+                        {
+                            provide: F_CONNECTION_DRAG_HANDLE_START,
+                            useExisting: FConnectionDragHandleStart,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jb25uZWN0aW9uLWRyYWctaGFuZGxlLXN0YXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvY29tcG9uZW50cy9jb25uZWN0aW9uLWRyYWctaGFuZGxlcy9mLWNvbm5lY3Rpb24tZHJhZy1oYW5kbGUtc3RhcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVuRSxPQUFPLEVBQUUsOEJBQThCLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxVQUFVLENBQUM7O0FBZ0JyRixNQUFNLE9BQU8sMEJBQTJCLFNBQVEseUJBQXlCO0lBQ3ZELE1BQU0sQ0FBQyxnQkFBd0IsRUFBRSxVQUFrQjtRQUNqRSxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxnQkFBZ0IsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDekUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDN0QsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDL0QsQ0FBQzt3R0FMVSwwQkFBMEI7NEZBQTFCLDBCQUEwQiw2R0FQMUI7WUFDVDtnQkFDRSxPQUFPLEVBQUUsOEJBQThCO2dCQUN2QyxXQUFXLEVBQUUsMEJBQTBCO2FBQ3hDO1NBQ0YsaURBVlMsRUFBRTs7NEZBWUQsMEJBQTBCO2tCQWR0QyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSx3Q0FBd0M7b0JBQ2xELFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO29CQUMvQyxJQUFJLEVBQUU7d0JBQ0osU0FBUyxFQUFFLE9BQU87cUJBQ25CO29CQUNELFNBQVMsRUFBRTt3QkFDVDs0QkFDRSxPQUFPLEVBQUUsOEJBQThCOzRCQUN2QyxXQUFXLDRCQUE0Qjt5QkFDeEM7cUJBQ0Y7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcbmltcG9ydCB7IEZfQ09OTkVDVElPTl9EUkFHX0hBTkRMRV9TVEFSVCwgRkNvbm5lY3Rpb25EcmFnSGFuZGxlQmFzZSB9IGZyb20gJy4vbW9kZWxzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY2lyY2xlW2YtY29ubmVjdGlvbi1kcmFnLWhhbmRsZS1zdGFydF0nLFxuICB0ZW1wbGF0ZTogJycsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBob3N0OiB7XG4gICAgJ1tjbGFzc10nOiAnY2xhc3MnLFxuICB9LFxuICBwcm92aWRlcnM6IFtcbiAgICB7XG4gICAgICBwcm92aWRlOiBGX0NPTk5FQ1RJT05fRFJBR19IQU5ETEVfU1RBUlQsXG4gICAgICB1c2VFeGlzdGluZzogRkNvbm5lY3Rpb25EcmFnSGFuZGxlU3RhcnQsXG4gICAgfSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgRkNvbm5lY3Rpb25EcmFnSGFuZGxlU3RhcnQgZXh0ZW5kcyBGQ29ubmVjdGlvbkRyYWdIYW5kbGVCYXNlIHtcbiAgcHVibGljIG92ZXJyaWRlIHJlZHJhdyhwZW51bHRpbWF0ZVBvaW50OiBJUG9pbnQsIHN0YXJ0UG9pbnQ6IElQb2ludCk6IHZvaWQge1xuICAgIHRoaXMucG9pbnQgPSB0aGlzLmNhbGN1bGF0ZUNpcmNsZUNlbnRlcihwZW51bHRpbWF0ZVBvaW50LCBzdGFydFBvaW50LCA4KTtcbiAgICB0aGlzLmhvc3RFbGVtZW50LnNldEF0dHJpYnV0ZSgnY3gnLCB0aGlzLnBvaW50LngudG9TdHJpbmcoKSk7XG4gICAgdGhpcy5ob3N0RWxlbWVudC5zZXRBdHRyaWJ1dGUoJ2N5JywgdGhpcy5wb2ludC55LnRvU3RyaW5nKCkpO1xuICB9XG59XG4iXX0=

package/esm2022/f-connection-v2/components/connection-drag-handles/index.mjs

@@ -0,0 +1,4 @@
+export * from './models';
+export * from './f-connection-drag-handle-start';
+export * from './f-connection-drag-handle-end';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tZHJhZy1oYW5kbGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBRXpCLGNBQWMsa0NBQWtDLENBQUM7QUFFakQsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLWNvbm5lY3Rpb24tZHJhZy1oYW5kbGUtc3RhcnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtY29ubmVjdGlvbi1kcmFnLWhhbmRsZS1lbmQnO1xuIl19

package/esm2022/f-connection-v2/components/connection-drag-handles/models/f-connection-drag-handle-base.mjs

@@ -0,0 +1,17 @@
+import { ElementRef, inject, InjectionToken } from '@angular/core';
+import { PointExtensions } from '@foblex/2d';
+export const F_CONNECTION_DRAG_HANDLE_END = new InjectionToken('F_CONNECTION_DRAG_HANDLE_END');
+export const F_CONNECTION_DRAG_HANDLE_START = new InjectionToken('F_CONNECTION_DRAG_HANDLE_START');
+export class FConnectionDragHandleBase {
+    hostElement = inject(ElementRef).nativeElement;
+    point = PointExtensions.initialize();
+    class = 'f-connection-drag-handle';
+    calculateCircleCenter(start, end, radius) {
+        const direction = { x: end.x - start.x, y: end.y - start.y };
+        const length = Math.sqrt(direction.x * direction.x + direction.y * direction.y) || 1;
+        const unitDirection = { x: direction.x / length, y: direction.y / length };
+        const scaledDirection = { x: unitDirection.x * radius, y: unitDirection.y * radius };
+        return { x: end.x - scaledDirection.x, y: end.y - scaledDirection.y };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/components/connection-drag-handles/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-connection-drag-handle-base';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tZHJhZy1oYW5kbGVzL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWNvbm5lY3Rpb24tZHJhZy1oYW5kbGUtYmFzZSc7XG4iXX0=

package/esm2022/f-connection-v2/components/connection-gradient/f-connection-gradient.mjs

@@ -0,0 +1,54 @@
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { Point } from '@foblex/2d';
+import { F_CONNECTION_GRADIENT, FConnectionGradientBase } from './models';
+import { F_CONNECTION_COMPONENTS_PARENT } from '../../models';
+import { createGradientDomIdentifier } from '../../utils';
+import * as i0 from "@angular/core";
+export class FConnectionGradient extends FConnectionGradientBase {
+    _connection = inject(F_CONNECTION_COMPONENTS_PARENT);
+    get gradientId() {
+        return createGradientDomIdentifier(this._connection.fId(), this._connection.fOutputId(), this._connection.fInputId());
+    }
+    get stop1Element() {
+        return this.hostElement.children.item(0);
+    }
+    get stop2Element() {
+        return this.hostElement.children.item(1);
+    }
+    initialize() {
+        this.stop1Element.setAttribute('offset', '0%');
+        this.stop2Element.setAttribute('offset', '100%');
+    }
+    _updateGradient() {
+        this._setFromColor(this._connection.fStartColor());
+        this._setToColor(this._connection.fEndColor());
+    }
+    _setFromColor(color) {
+        this.stop1Element.setAttribute('stop-color', color || 'transparent');
+    }
+    _setToColor(color) {
+        this.stop2Element.setAttribute('stop-color', color || 'transparent');
+    }
+    redraw(line) {
+        const x = line.point2.x - line.point1.x;
+        const y = line.point2.y - line.point1.y;
+        const distance = Math.sqrt(x * x + y * y) || 0.01;
+        const from = new Point(0.5 - (0.5 * x) / distance, 0.5 - (0.5 * y) / distance);
+        this.hostElement.setAttribute('x1', from.x.toString());
+        this.hostElement.setAttribute('y1', from.y.toString());
+        const to = new Point(0.5 + (0.5 * x) / distance, 0.5 + (0.5 * y) / distance);
+        this.hostElement.setAttribute('x2', to.x.toString());
+        this.hostElement.setAttribute('y2', to.y.toString());
+        this._updateGradient();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionGradient, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FConnectionGradient, selector: "linearGradient[fConnectionGradient]", host: { properties: { "attr.id": "gradientId" }, classAttribute: "f-component f-connection-gradient" }, providers: [{ provide: F_CONNECTION_GRADIENT, useExisting: FConnectionGradient }], usesInheritance: true, ngImport: i0, template: "<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n  <svg:stop />\n  <svg:stop />\n</ng-container>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionGradient, decorators: [{
+            type: Component,
+            args: [{ selector: 'linearGradient[fConnectionGradient]', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'f-component f-connection-gradient',
+                        '[attr.id]': 'gradientId',
+                    }, providers: [{ provide: F_CONNECTION_GRADIENT, useExisting: FConnectionGradient }], template: "<ng-container xmlns:svg=\"http://www.w3.org/2000/svg\">\n  <svg:stop />\n  <svg:stop />\n</ng-container>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/components/connection-gradient/index.mjs

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './f-connection-gradient';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tZ3JhZGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vZi1jb25uZWN0aW9uLWdyYWRpZW50JztcbiJdfQ==

package/esm2022/f-connection-v2/components/connection-gradient/models/f-connection-gradient-base.mjs

@@ -0,0 +1,6 @@
+import { ElementRef, inject, InjectionToken } from '@angular/core';
+export const F_CONNECTION_GRADIENT = new InjectionToken('F_CONNECTION_GRADIENT');
+export class FConnectionGradientBase {
+    hostElement = inject((ElementRef)).nativeElement;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jb25uZWN0aW9uLWdyYWRpZW50LWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tZ3JhZGllbnQvbW9kZWxzL2YtY29ubmVjdGlvbi1ncmFkaWVudC1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVuRSxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLGNBQWMsQ0FDckQsdUJBQXVCLENBQ3hCLENBQUM7QUFFRixNQUFNLE9BQWdCLHVCQUF1QjtJQUMzQixXQUFXLEdBQUcsTUFBTSxDQUFDLENBQUEsVUFBb0MsQ0FBQSxDQUFDLENBQUMsYUFBYSxDQUFDO0NBSzFGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUxpbmUgfSBmcm9tICdAZm9ibGV4LzJkJztcbmltcG9ydCB7IEVsZW1lbnRSZWYsIGluamVjdCwgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IEZfQ09OTkVDVElPTl9HUkFESUVOVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGQ29ubmVjdGlvbkdyYWRpZW50QmFzZT4oXG4gICdGX0NPTk5FQ1RJT05fR1JBRElFTlQnLFxuKTtcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZDb25uZWN0aW9uR3JhZGllbnRCYXNlIHtcbiAgcHVibGljIHJlYWRvbmx5IGhvc3RFbGVtZW50ID0gaW5qZWN0KEVsZW1lbnRSZWY8U1ZHTGluZWFyR3JhZGllbnRFbGVtZW50PikubmF0aXZlRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3QgaW5pdGlhbGl6ZSgpOiB2b2lkO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCByZWRyYXcobGluZTogSUxpbmUpOiB2b2lkO1xufVxuIl19

package/esm2022/f-connection-v2/components/connection-gradient/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-connection-gradient-base';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tZ3JhZGllbnQvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2YtY29ubmVjdGlvbi1ncmFkaWVudC1iYXNlJztcbiJdfQ==

package/esm2022/f-connection-v2/components/connection-marker/enums/e-f-marker-type.mjs

@@ -0,0 +1,8 @@
+export var EFMarkerType;
+(function (EFMarkerType) {
+    EFMarkerType["START"] = "f-connection-marker-start";
+    EFMarkerType["END"] = "f-connection-marker-end";
+    EFMarkerType["SELECTED_START"] = "f-connection-selected-marker-start";
+    EFMarkerType["SELECTED_END"] = "f-connection-selected-marker-end";
+})(EFMarkerType || (EFMarkerType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZS1mLW1hcmtlci10eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvY29tcG9uZW50cy9jb25uZWN0aW9uLW1hcmtlci9lbnVtcy9lLWYtbWFya2VyLXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksWUFRWDtBQVJELFdBQVksWUFBWTtJQUN0QixtREFBbUMsQ0FBQTtJQUVuQywrQ0FBK0IsQ0FBQTtJQUUvQixxRUFBcUQsQ0FBQTtJQUVyRCxpRUFBaUQsQ0FBQTtBQUNuRCxDQUFDLEVBUlcsWUFBWSxLQUFaLFlBQVksUUFRdkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBFRk1hcmtlclR5cGUge1xuICBTVEFSVCA9ICdmLWNvbm5lY3Rpb24tbWFya2VyLXN0YXJ0JyxcblxuICBFTkQgPSAnZi1jb25uZWN0aW9uLW1hcmtlci1lbmQnLFxuXG4gIFNFTEVDVEVEX1NUQVJUID0gJ2YtY29ubmVjdGlvbi1zZWxlY3RlZC1tYXJrZXItc3RhcnQnLFxuXG4gIFNFTEVDVEVEX0VORCA9ICdmLWNvbm5lY3Rpb24tc2VsZWN0ZWQtbWFya2VyLWVuZCcsXG59XG4iXX0=

package/esm2022/f-connection-v2/components/connection-marker/enums/index.mjs

@@ -0,0 +1,2 @@
+export * from './e-f-marker-type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tbWFya2VyL2VudW1zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2UtZi1tYXJrZXItdHlwZSc7XG4iXX0=

package/esm2022/f-connection-v2/components/connection-marker/f-connection-marker.mjs

@@ -0,0 +1,50 @@
+import { Directive, inject, Input } from '@angular/core';
+import { FMediator } from '@foblex/mediator';
+import { F_CONNECTION_MARKER, FConnectionMarkerBase } from './models';
+import { EFMarkerType } from './enums';
+import { AddConnectionMarkerToStoreRequest, RemoveConnectionMarkerFromStoreRequest, } from '../../../domain';
+import * as i0 from "@angular/core";
+export class FConnectionMarker extends FConnectionMarkerBase {
+    _mediator = inject(FMediator);
+    width = 0;
+    height = 0;
+    refX = 0;
+    refY = 0;
+    type = EFMarkerType.START;
+    orient = 'auto';
+    markerUnits = 'strokeWidth';
+    ngOnInit() {
+        this.hostElement.style.display = 'none';
+        this._mediator.execute(new AddConnectionMarkerToStoreRequest(this));
+    }
+    ngOnDestroy() {
+        this._mediator.execute(new RemoveConnectionMarkerFromStoreRequest(this));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionMarker, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FConnectionMarker, selector: "svg[fMarker]", inputs: { width: "width", height: "height", refX: "refX", refY: "refY", type: "type", orient: "orient", markerUnits: "markerUnits" }, host: { classAttribute: "f-component f-marker" }, providers: [{ provide: F_CONNECTION_MARKER, useExisting: FConnectionMarker }], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionMarker, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'svg[fMarker]',
+                    host: {
+                        class: 'f-component f-marker',
+                    },
+                    providers: [{ provide: F_CONNECTION_MARKER, useExisting: FConnectionMarker }],
+                }]
+        }], propDecorators: { width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], refX: [{
+                type: Input
+            }], refY: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], orient: [{
+                type: Input
+            }], markerUnits: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/components/connection-marker/index.mjs

@@ -0,0 +1,4 @@
+export * from './enums';
+export * from './models';
+export * from './f-connection-marker';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi9jb21wb25lbnRzL2Nvbm5lY3Rpb24tbWFya2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDO0FBRXhCLGNBQWMsVUFBVSxDQUFDO0FBRXpCLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VudW1zJztcblxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtY29ubmVjdGlvbi1tYXJrZXInO1xuIl19

package/esm2022/f-connection-v2/components/connection-marker/models/f-connection-marker-base.mjs

@@ -0,0 +1,6 @@
+import { ElementRef, inject, InjectionToken } from '@angular/core';
+export const F_CONNECTION_MARKER = new InjectionToken('F_CONNECTION_MARKER');
+export class FConnectionMarkerBase {
+    hostElement = inject((ElementRef)).nativeElement;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jb25uZWN0aW9uLW1hcmtlci1iYXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvY29tcG9uZW50cy9jb25uZWN0aW9uLW1hcmtlci9tb2RlbHMvZi1jb25uZWN0aW9uLW1hcmtlci1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVuRSxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLGNBQWMsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO0FBRTdFLE1BQU0sT0FBZ0IscUJBQXFCO0lBQ3pCLFdBQVcsR0FBRyxNQUFNLENBQUMsQ0FBQSxVQUF1QixDQUFBLENBQUMsQ0FBQyxhQUFhLENBQUM7Q0FlN0UiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbGVtZW50UmVmLCBpbmplY3QsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGX0NPTk5FQ1RJT05fTUFSS0VSID0gbmV3IEluamVjdGlvblRva2VuKCdGX0NPTk5FQ1RJT05fTUFSS0VSJyk7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGQ29ubmVjdGlvbk1hcmtlckJhc2Uge1xuICBwdWJsaWMgcmVhZG9ubHkgaG9zdEVsZW1lbnQgPSBpbmplY3QoRWxlbWVudFJlZjxIVE1MRWxlbWVudD4pLm5hdGl2ZUVsZW1lbnQ7XG5cbiAgcHVibGljIGFic3RyYWN0IHdpZHRoOiBudW1iZXI7XG5cbiAgcHVibGljIGFic3RyYWN0IGhlaWdodDogbnVtYmVyO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCByZWZYOiBudW1iZXI7XG5cbiAgcHVibGljIGFic3RyYWN0IHJlZlk6IG51bWJlcjtcblxuICBwdWJsaWMgYWJzdHJhY3QgdHlwZTogc3RyaW5nO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBvcmllbnQ6ICdhdXRvJyB8ICdhdXRvLXN0YXJ0LXJldmVyc2UnIHwgc3RyaW5nO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBtYXJrZXJVbml0czogJ3N0cm9rZVdpZHRoJyB8ICd1c2VyU3BhY2VPblVzZSc7XG59XG4iXX0=