@foblex/flow 17.8.0 → 17.8.2

package/esm2022/f-connection/f-connection-content/polyline-content-engine/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/f-connection-content/polyline-content-engine/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/f-connection-content/polyline-content-engine/polyline-sampler/polyline.mjs

@@ -0,0 +1,68 @@
+/**
+ * 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/f-connection-for-create/f-connection-for-create.component.mjs

@@ -1,4 +1,4 @@
-import { ChangeDetectionStrategy, Component, inject, Input, numberAttribute, signal, } from "@angular/core";
+import { ChangeDetectionStrategy, Component, inject, Input, numberAttribute, signal, } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
 import { NotifyDataChangedRequest } from '../../f-storage';
@@ -9,22 +9,21 @@ import { F_CONNECTION } from '../common/f-connection.injection-token';
 import { FConnectionBase } from '../common/f-connection-base';
 import { castToEnum } from '@foblex/utils';
 import { FMediator } from '@foblex/mediator';
-import { AddConnectionForCreateToStoreRequest, RemoveConnectionForCreateFromStoreRequest } from '../../domain';
+import { AddConnectionForCreateToStoreRequest, RemoveConnectionForCreateFromStoreRequest, } from '../../domain';
 import * as i0 from "@angular/core";
-import * as i1 from "../f-connection-builder";
-import * as i2 from "../common/f-connection-text/f-connection-text.component";
-import * as i3 from "../common/f-drag-handle/f-connection-drag-handle-start.component";
-import * as i4 from "../common/f-drag-handle/f-connection-drag-handle-end.component";
-import * as i5 from "../common/f-gradient/f-connection-gradient.component";
-import * as i6 from "../common/f-path/f-connection-path.component";
-import * as i7 from "../common/f-selection/f-connection-selection.component";
+import * as i1 from "../common/f-connection-text/f-connection-text.component";
+import * as i2 from "../common/f-drag-handle/f-connection-drag-handle-start.component";
+import * as i3 from "../common/f-drag-handle/f-connection-drag-handle-end.component";
+import * as i4 from "../common/f-gradient/f-connection-gradient.component";
+import * as i5 from "../common/f-path/f-connection-path.component";
+import * as i6 from "../common/f-selection/f-connection-selection.component";
 let uniqueId = 0;
 export class FConnectionForCreateComponent extends FConnectionBase {
     fId = signal(`f-connection-for-create-${uniqueId++}`);
     fText = '';
     fTextStartOffset = '';
-    fOutputId;
-    fInputId;
+    fOutputId = signal('');
+    fInputId = signal('');
     fRadius = 8;
     fOffset = 12;
     fBehavior = EFConnectionBehavior.FIXED;
@@ -33,9 +32,6 @@ export class FConnectionForCreateComponent extends FConnectionBase {
         return this.fPath().hostElement;
     }
     _mediator = inject(FMediator);
-    constructor(elementReference, fConnectionFactory) {
-        super(elementReference, fConnectionFactory);
-    }
     ngOnInit() {
         this._mediator.execute(new AddConnectionForCreateToStoreRequest(this));
     }
@@ -48,15 +44,15 @@ export class FConnectionForCreateComponent extends FConnectionBase {
     ngOnDestroy() {
         this._mediator.execute(new RemoveConnectionForCreateFromStoreRequest());
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionForCreateComponent, deps: [{ token: i0.ElementRef }, { token: i1.FConnectionFactory }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path\n            [attr.d]=\"path\">\n      </path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i2.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i3.FConnectionDragHandleStartComponent, selector: "circle[f-connection-drag-handle-start]" }, { kind: "component", type: i4.FConnectionDragHandleEndComponent, selector: "circle[f-connection-drag-handle-end]" }, { kind: "component", type: i5.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i6.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i7.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionForCreateComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FConnectionForCreateComponent, selector: "f-connection-for-create", inputs: { fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-connection-for-create" }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path [attr.d]=\"path\"></path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n@if (fConnectionContents().length) {\n  <ng-content select=\"[fConnectionContent]\"></ng-content>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center,:host .f-connection-content{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i1.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i2.FConnectionDragHandleStartComponent, selector: "circle[f-connection-drag-handle-start]" }, { kind: "component", type: i3.FConnectionDragHandleEndComponent, selector: "circle[f-connection-drag-handle-end]" }, { kind: "component", type: i4.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i5.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i6.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FConnectionForCreateComponent, decorators: [{
             type: Component,
-            args: [{ selector: "f-connection-for-create", changeDetection: ChangeDetectionStrategy.OnPush, host: {
-                        class: "f-component f-connection f-connection-for-create",
-                    }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path\n            [attr.d]=\"path\">\n      </path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.FConnectionFactory }], propDecorators: { fRadius: [{
+            args: [{ selector: 'f-connection-for-create', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'f-component f-connection f-connection-for-create',
+                    }, providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path [attr.d]=\"path\"></path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n@if (fConnectionContents().length) {\n  <ng-content select=\"[fConnectionContent]\"></ng-content>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center,:host .f-connection-content{pointer-events:all}\n"] }]
+        }], propDecorators: { fRadius: [{
                 type: Input,
                 args: [{ transform: numberAttribute }]
             }], fOffset: [{
@@ -68,4 +64,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], fType: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-connection-for-create.component.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-connection/f-connection-for-create/f-connection-for-create.component.ts","../../../../../projects/f-flow/src/f-connection/f-connection-for-create/f-connection-for-create.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EACvB,SAAS,EAET,MAAM,EACN,KAAK,EACL,eAAe,EAIf,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AACtE,gHAAgH;AAChH,wEAAwE;AACxE,gDAAgD;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,oCAAoC,EAAE,yCAAyC,EAAE,MAAM,cAAc,CAAC;;;;;;;;;AAE/G,IAAI,QAAQ,GAAG,CAAC,CAAC;AAYjB,MAAM,OAAO,6BACX,SAAQ,eAAe;IAEP,GAAG,GAAG,MAAM,CAAS,2BAA2B,QAAQ,EAAE,EAAE,CAAC,CAAC;IAE9D,KAAK,GAAW,EAAE,CAAC;IAEnB,gBAAgB,GAAW,EAAE,CAAC;IAE9B,SAAS,CAAU;IAEnB,QAAQ,CAAU;IAGlB,OAAO,GAAW,CAAC,CAAC;IAGpB,OAAO,GAAW,EAAE,CAAC;IAGrB,SAAS,GAAyB,oBAAoB,CAAC,KAAK,CAAC;IAG7D,KAAK,GAA8B,gBAAgB,CAAC,QAAQ,CAAC;IAG7E,IAAoB,eAAe;QACjC,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC;IAClC,CAAC;IAEgB,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAE/C,YACE,gBAAyC,EACzC,kBAAsC;QAEtC,KAAK,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;IAC9C,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,oCAAoC,CAAC,IAAI,CAAC,CAAC,CAAC;IACzE,CAAC;IAEM,eAAe;QACpB,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,wBAAwB,EAAE,CAAC,CAAC;IACzD,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,yCAAyC,EAAE,CAAC,CAAC;IAC1E,CAAC;wGArDU,6BAA6B;4FAA7B,6BAA6B,iFAapB,eAAe,mCAGf,eAAe,yCAGf,CAAC,KAAc,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,oBAAoB,CAAC,8GArBjF,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,6BAA6B,EAAE,CAAC,sECpCpF,yrBAqBA;;4FDiBa,6BAA6B;kBAVzC,SAAS;+BACE,yBAAyB,mBAGlB,uBAAuB,CAAC,MAAM,QACzC;wBACJ,KAAK,EAAE,kDAAkD;qBAC1D,aACU,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,+BAA+B,EAAE,CAAC;gHAgBlE,OAAO;sBADtB,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAIrB,OAAO;sBADtB,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAIrB,SAAS;sBADxB,KAAK;uBAAC,EAAE,SAAS,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,oBAAoB,CAAC,EAAE;gBAI9E,KAAK;sBADpB,KAAK","sourcesContent":["import {\n  AfterViewInit, booleanAttribute,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  inject, input,\n  Input,\n  numberAttribute,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  signal,\n} from \"@angular/core\";\nimport { EFConnectionBehavior } from '../common';\nimport { EFConnectionType } from '../common';\nimport { FConnectionFactory } from '../f-connection-builder';\nimport { NotifyDataChangedRequest } from '../../f-storage';\nimport { F_CONNECTION } from '../common/f-connection.injection-token';\n//TODO: Need to deal with cyclic dependencies, since in some cases an error occurs when importing them ../common\n// TypeError: Class extends value undefined is not a constructor or null\n// at f-connection-for-create.component.ts:34:11\nimport { FConnectionBase } from '../common/f-connection-base';\nimport { castToEnum } from '@foblex/utils';\nimport { FMediator } from '@foblex/mediator';\nimport { AddConnectionForCreateToStoreRequest, RemoveConnectionForCreateFromStoreRequest } from '../../domain';\n\nlet uniqueId = 0;\n\n@Component({\n  selector: \"f-connection-for-create\",\n  templateUrl: \"./f-connection-for-create.component.html\",\n  styleUrls: [\"./f-connection-for-create.component.scss\"],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    class: \"f-component f-connection f-connection-for-create\",\n  },\n  providers: [{ provide: F_CONNECTION, useExisting: FConnectionForCreateComponent }],\n})\nexport class FConnectionForCreateComponent\n  extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {\n\n  public override fId = signal<string>(`f-connection-for-create-${uniqueId++}`);\n\n  public override fText: string = '';\n\n  public override fTextStartOffset: string = '';\n\n  public override fOutputId!: string;\n\n  public override fInputId!: string;\n\n  @Input({ transform: numberAttribute })\n  public override fRadius: number = 8;\n\n  @Input({ transform: numberAttribute })\n  public override fOffset: number = 12;\n\n  @Input({ transform: (value: unknown) => castToEnum(value, 'fBehavior', EFConnectionBehavior) })\n  public override fBehavior: EFConnectionBehavior = EFConnectionBehavior.FIXED;\n\n  @Input()\n  public override fType: EFConnectionType | string = EFConnectionType.STRAIGHT;\n\n\n  public override get boundingElement(): HTMLElement | SVGElement {\n    return this.fPath().hostElement;\n  }\n\n  private readonly _mediator = inject(FMediator);\n\n  constructor(\n    elementReference: ElementRef<HTMLElement>,\n    fConnectionFactory: FConnectionFactory,\n  ) {\n    super(elementReference, fConnectionFactory);\n  }\n\n  public ngOnInit(): void {\n    this._mediator.execute(new AddConnectionForCreateToStoreRequest(this));\n  }\n\n  public ngAfterViewInit(): void {\n    this.hide();\n  }\n\n  public ngOnChanges(): void {\n    this._mediator.execute(new NotifyDataChangedRequest());\n  }\n\n  public ngOnDestroy(): void {\n    this._mediator.execute(new RemoveConnectionForCreateFromStoreRequest());\n  }\n}\n","<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path\n            [attr.d]=\"path\">\n      </path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection/f-marker/f-marker-base.mjs

@@ -1,11 +1,5 @@
-import { Directive, InjectionToken } from '@angular/core';
-import * as i0 from "@angular/core";
+import { InjectionToken } from '@angular/core';
 export const F_MARKER = new InjectionToken('F_MARKER');
 export class FMarkerBase {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkerBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FMarkerBase, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkerBase, decorators: [{
-            type: Directive
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1tYXJrZXItYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uL2YtbWFya2VyL2YtbWFya2VyLWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRzFELE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUd2RCxNQUFNLE9BQWdCLFdBQVc7d0dBQVgsV0FBVzs0RkFBWCxXQUFXOzs0RkFBWCxXQUFXO2tCQURoQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSUhhc0hvc3RFbGVtZW50IH0gZnJvbSAnLi4vLi4vaS1oYXMtaG9zdC1lbGVtZW50JztcblxuZXhwb3J0IGNvbnN0IEZfTUFSS0VSID0gbmV3IEluamVjdGlvblRva2VuKCdGX01BUktFUicpO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGTWFya2VyQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3Qgd2lkdGg6IG51bWJlcjtcblxuICBwdWJsaWMgYWJzdHJhY3QgaGVpZ2h0OiBudW1iZXI7XG5cbiAgcHVibGljIGFic3RyYWN0IHJlZlg6IG51bWJlcjtcblxuICBwdWJsaWMgYWJzdHJhY3QgcmVmWTogbnVtYmVyO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCB0eXBlOiBzdHJpbmc7XG5cbiAgcHVibGljIGFic3RyYWN0IG9yaWVudDogJ2F1dG8nIHwgJ2F1dG8tc3RhcnQtcmV2ZXJzZScgfCBzdHJpbmc7XG5cbiAgcHVibGljIGFic3RyYWN0IG1hcmtlclVuaXRzOiAnc3Ryb2tlV2lkdGgnIHwgJ3VzZXJTcGFjZU9uVXNlJztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1tYXJrZXItYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uL2YtbWFya2VyL2YtbWFya2VyLWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQyxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsSUFBSSxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUM7QUFFdkQsTUFBTSxPQUFnQixXQUFXO0NBZ0JoQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQgfSBmcm9tICcuLi8uLi9pLWhhcy1ob3N0LWVsZW1lbnQnO1xuXG5leHBvcnQgY29uc3QgRl9NQVJLRVIgPSBuZXcgSW5qZWN0aW9uVG9rZW4oJ0ZfTUFSS0VSJyk7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGTWFya2VyQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG4gIHB1YmxpYyBhYnN0cmFjdCBob3N0RWxlbWVudDogSFRNTEVsZW1lbnQ7XG5cbiAgcHVibGljIGFic3RyYWN0IHdpZHRoOiBudW1iZXI7XG5cbiAgcHVibGljIGFic3RyYWN0IGhlaWdodDogbnVtYmVyO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCByZWZYOiBudW1iZXI7XG5cbiAgcHVibGljIGFic3RyYWN0IHJlZlk6IG51bWJlcjtcblxuICBwdWJsaWMgYWJzdHJhY3QgdHlwZTogc3RyaW5nO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBvcmllbnQ6ICdhdXRvJyB8ICdhdXRvLXN0YXJ0LXJldmVyc2UnIHwgc3RyaW5nO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBtYXJrZXJVbml0czogJ3N0cm9rZVdpZHRoJyB8ICd1c2VyU3BhY2VPblVzZSc7XG59XG4iXX0=

package/esm2022/f-connection/f-marker/f-marker.directive.mjs

@@ -1,14 +1,12 @@
-import { Directive, inject, Input, } from "@angular/core";
+import { Directive, ElementRef, inject, Input } from '@angular/core';
 import { F_MARKER, FMarkerBase } from './f-marker-base';
 import { EFMarkerType } from './e-f-marker-type';
 import { FMediator } from '@foblex/mediator';
-import { AddConnectionMarkerToStoreRequest, RemoveConnectionMarkerFromStoreRequest } from '../../domain';
+import { AddConnectionMarkerToStoreRequest, RemoveConnectionMarkerFromStoreRequest, } from '../../domain';
 import * as i0 from "@angular/core";
 export class FMarkerDirective extends FMarkerBase {
-    elementReference;
-    get hostElement() {
-        return this.elementReference.nativeElement;
-    }
+    hostElement = inject((ElementRef)).nativeElement;
+    _mediator = inject(FMediator);
     width = 0;
     height = 0;
     refX = 0;
@@ -16,33 +14,26 @@ export class FMarkerDirective extends FMarkerBase {
     type = EFMarkerType.START;
     orient = 'auto';
     markerUnits = 'strokeWidth';
-    _fMediator = inject(FMediator);
-    constructor(elementReference) {
-        super();
-        this.elementReference = elementReference;
-        this.hostElement.style.display = 'none';
-    }
     ngOnInit() {
-        this._fMediator.execute(new AddConnectionMarkerToStoreRequest(this));
+        this.hostElement.style.display = 'none';
+        this._mediator.execute(new AddConnectionMarkerToStoreRequest(this));
     }
     ngOnDestroy() {
-        this._fMediator.execute(new RemoveConnectionMarkerFromStoreRequest(this));
+        this._mediator.execute(new RemoveConnectionMarkerFromStoreRequest(this));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FMarkerDirective, selector: "svg[fMarker]", inputs: { hostElement: "hostElement", width: "width", height: "height", refX: "refX", refY: "refY", type: "type", orient: "orient", markerUnits: "markerUnits" }, host: { classAttribute: "f-component f-marker" }, providers: [{ provide: F_MARKER, useExisting: FMarkerDirective }], usesInheritance: true, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkerDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FMarkerDirective, 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_MARKER, useExisting: FMarkerDirective }], usesInheritance: true, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkerDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: "svg[fMarker]",
+                    selector: 'svg[fMarker]',
                     host: {
-                        class: "f-component f-marker",
+                        class: 'f-component f-marker',
                     },
                     providers: [{ provide: F_MARKER, useExisting: FMarkerDirective }],
                 }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { hostElement: [{
-                type: Input
-            }], width: [{
+        }], propDecorators: { width: [{
                 type: Input
             }], height: [{
                 type: Input
@@ -57,4 +48,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], markerUnits: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1tYXJrZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24vZi1tYXJrZXIvZi1tYXJrZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQXFCLE1BQU0sZUFBZSxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM3QyxPQUFPLEVBQ0wsaUNBQWlDLEVBQ2pDLHNDQUFzQyxHQUN2QyxNQUFNLGNBQWMsQ0FBQzs7QUFTdEIsTUFBTSxPQUFPLGdCQUFpQixTQUFRLFdBQVc7SUFDL0IsV0FBVyxHQUFHLE1BQU0sQ0FBQyxDQUFBLFVBQXVCLENBQUEsQ0FBQyxDQUFDLGFBQWEsQ0FBQztJQUMzRCxTQUFTLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBRy9CLEtBQUssR0FBVyxDQUFDLENBQUM7SUFHbEIsTUFBTSxHQUFXLENBQUMsQ0FBQztJQUduQixJQUFJLEdBQVcsQ0FBQyxDQUFDO0lBR2pCLElBQUksR0FBVyxDQUFDLENBQUM7SUFHakIsSUFBSSxHQUFXLFlBQVksQ0FBQyxLQUFLLENBQUM7SUFHbEMsTUFBTSxHQUEwRCxNQUFNLENBQUM7SUFHdkUsV0FBVyxHQUFxQyxhQUFhLENBQUM7SUFFdkUsUUFBUTtRQUNiLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDeEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsSUFBSSxpQ0FBaUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFTSxXQUFXO1FBQ2hCLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksc0NBQXNDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUMzRSxDQUFDO3dHQWhDVSxnQkFBZ0I7NEZBQWhCLGdCQUFnQiwrTkFGaEIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLENBQUM7OzRGQUV0RCxnQkFBZ0I7a0JBUDVCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGNBQWM7b0JBQ3hCLElBQUksRUFBRTt3QkFDSixLQUFLLEVBQUUsc0JBQXNCO3FCQUM5QjtvQkFDRCxTQUFTLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsV0FBVyxrQkFBa0IsRUFBRSxDQUFDO2lCQUNsRTs4QkFNaUIsS0FBSztzQkFEcEIsS0FBSztnQkFJVSxNQUFNO3NCQURyQixLQUFLO2dCQUlVLElBQUk7c0JBRG5CLEtBQUs7Z0JBSVUsSUFBSTtzQkFEbkIsS0FBSztnQkFJVSxJQUFJO3NCQURuQixLQUFLO2dCQUlVLE1BQU07c0JBRHJCLEtBQUs7Z0JBSVUsV0FBVztzQkFEMUIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgaW5qZWN0LCBJbnB1dCwgT25EZXN0cm95LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZfTUFSS0VSLCBGTWFya2VyQmFzZSB9IGZyb20gJy4vZi1tYXJrZXItYmFzZSc7XG5pbXBvcnQgeyBFRk1hcmtlclR5cGUgfSBmcm9tICcuL2UtZi1tYXJrZXItdHlwZSc7XG5pbXBvcnQgeyBGTWVkaWF0b3IgfSBmcm9tICdAZm9ibGV4L21lZGlhdG9yJztcbmltcG9ydCB7XG4gIEFkZENvbm5lY3Rpb25NYXJrZXJUb1N0b3JlUmVxdWVzdCxcbiAgUmVtb3ZlQ29ubmVjdGlvbk1hcmtlckZyb21TdG9yZVJlcXVlc3QsXG59IGZyb20gJy4uLy4uL2RvbWFpbic7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ3N2Z1tmTWFya2VyXScsXG4gIGhvc3Q6IHtcbiAgICBjbGFzczogJ2YtY29tcG9uZW50IGYtbWFya2VyJyxcbiAgfSxcbiAgcHJvdmlkZXJzOiBbeyBwcm92aWRlOiBGX01BUktFUiwgdXNlRXhpc3Rpbmc6IEZNYXJrZXJEaXJlY3RpdmUgfV0sXG59KVxuZXhwb3J0IGNsYXNzIEZNYXJrZXJEaXJlY3RpdmUgZXh0ZW5kcyBGTWFya2VyQmFzZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcbiAgcHVibGljIHJlYWRvbmx5IGhvc3RFbGVtZW50ID0gaW5qZWN0KEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+KS5uYXRpdmVFbGVtZW50O1xuICBwcml2YXRlIHJlYWRvbmx5IF9tZWRpYXRvciA9IGluamVjdChGTWVkaWF0b3IpO1xuXG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBvdmVycmlkZSB3aWR0aDogbnVtYmVyID0gMDtcblxuICBASW5wdXQoKVxuICBwdWJsaWMgb3ZlcnJpZGUgaGVpZ2h0OiBudW1iZXIgPSAwO1xuXG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBvdmVycmlkZSByZWZYOiBudW1iZXIgPSAwO1xuXG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBvdmVycmlkZSByZWZZOiBudW1iZXIgPSAwO1xuXG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBvdmVycmlkZSB0eXBlOiBzdHJpbmcgPSBFRk1hcmtlclR5cGUuU1RBUlQ7XG5cbiAgQElucHV0KClcbiAgcHVibGljIG92ZXJyaWRlIG9yaWVudDogJ2F1dG8nIHwgJ2F1dG8tc3RhcnQtcmV2ZXJzZScgfCAnY2FsY3VsYXRlZCcgfCBzdHJpbmcgPSAnYXV0byc7XG5cbiAgQElucHV0KClcbiAgcHVibGljIG92ZXJyaWRlIG1hcmtlclVuaXRzOiAnc3Ryb2tlV2lkdGgnIHwgJ3VzZXJTcGFjZU9uVXNlJyA9ICdzdHJva2VXaWR0aCc7XG5cbiAgcHVibGljIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHRoaXMuaG9zdEVsZW1lbnQuc3R5bGUuZGlzcGxheSA9ICdub25lJztcbiAgICB0aGlzLl9tZWRpYXRvci5leGVjdXRlKG5ldyBBZGRDb25uZWN0aW9uTWFya2VyVG9TdG9yZVJlcXVlc3QodGhpcykpO1xuICB9XG5cbiAgcHVibGljIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMuX21lZGlhdG9yLmV4ZWN1dGUobmV3IFJlbW92ZUNvbm5lY3Rpb25NYXJrZXJGcm9tU3RvcmVSZXF1ZXN0KHRoaXMpKTtcbiAgfVxufVxuIl19

package/esm2022/f-connection/f-snap-connection/f-snap-connection.component.mjs

@@ -1,4 +1,4 @@
-import { ChangeDetectionStrategy, Component, inject, Input, numberAttribute, signal, } from "@angular/core";
+import { ChangeDetectionStrategy, Component, inject, Input, numberAttribute, signal, } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
 import { NotifyDataChangedRequest } from '../../f-storage';
@@ -6,23 +6,22 @@ import { F_CONNECTION } from '../common/f-connection.injection-token';
 import { FConnectionBase } from '../common/f-connection-base';
 import { castToEnum } from '@foblex/utils';
 import { FMediator } from '@foblex/mediator';
-import { AddSnapConnectionToStoreRequest, RemoveSnapConnectionFromStoreRequest } from '../../domain';
+import { AddSnapConnectionToStoreRequest, RemoveSnapConnectionFromStoreRequest, } from '../../domain';
 import * as i0 from "@angular/core";
-import * as i1 from "../f-connection-builder";
-import * as i2 from "../common/f-connection-text/f-connection-text.component";
-import * as i3 from "../common/f-drag-handle/f-connection-drag-handle-start.component";
-import * as i4 from "../common/f-drag-handle/f-connection-drag-handle-end.component";
-import * as i5 from "../common/f-gradient/f-connection-gradient.component";
-import * as i6 from "../common/f-path/f-connection-path.component";
-import * as i7 from "../common/f-selection/f-connection-selection.component";
+import * as i1 from "../common/f-connection-text/f-connection-text.component";
+import * as i2 from "../common/f-drag-handle/f-connection-drag-handle-start.component";
+import * as i3 from "../common/f-drag-handle/f-connection-drag-handle-end.component";
+import * as i4 from "../common/f-gradient/f-connection-gradient.component";
+import * as i5 from "../common/f-path/f-connection-path.component";
+import * as i6 from "../common/f-selection/f-connection-selection.component";
 let uniqueId = 0;
 export class FSnapConnectionComponent extends FConnectionBase {
     fId = signal(`f-snap-connection-${uniqueId++}`);
     fText = '';
     fTextStartOffset = '';
     fSnapThreshold = 20;
-    fOutputId;
-    fInputId;
+    fOutputId = signal('');
+    fInputId = signal('');
     fRadius = 8;
     fOffset = 12;
     fBehavior = EFConnectionBehavior.FIXED;
@@ -31,9 +30,6 @@ export class FSnapConnectionComponent extends FConnectionBase {
         return this.fPath().hostElement;
     }
     _mediator = inject(FMediator);
-    constructor(elementReference, fConnectionFactory) {
-        super(elementReference, fConnectionFactory);
-    }
     ngOnInit() {
         this._mediator.execute(new AddSnapConnectionToStoreRequest(this));
     }
@@ -46,15 +42,15 @@ export class FSnapConnectionComponent extends FConnectionBase {
     ngOnDestroy() {
         this._mediator.execute(new RemoveSnapConnectionFromStoreRequest());
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FSnapConnectionComponent, deps: [{ token: i0.ElementRef }, { token: i1.FConnectionFactory }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FSnapConnectionComponent, selector: "f-snap-connection", inputs: { fSnapThreshold: ["fSnapThreshold", "fSnapThreshold", numberAttribute], fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-snap-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FSnapConnectionComponent }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path\n            [attr.d]=\"path\">\n      </path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i2.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i3.FConnectionDragHandleStartComponent, selector: "circle[f-connection-drag-handle-start]" }, { kind: "component", type: i4.FConnectionDragHandleEndComponent, selector: "circle[f-connection-drag-handle-end]" }, { kind: "component", type: i5.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i6.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i7.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FSnapConnectionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FSnapConnectionComponent, selector: "f-snap-connection", inputs: { fSnapThreshold: ["fSnapThreshold", "fSnapThreshold", numberAttribute], fRadius: ["fRadius", "fRadius", numberAttribute], fOffset: ["fOffset", "fOffset", numberAttribute], fBehavior: ["fBehavior", "fBehavior", (value) => castToEnum(value, 'fBehavior', EFConnectionBehavior)], fType: "fType" }, host: { classAttribute: "f-component f-connection f-snap-connection" }, providers: [{ provide: F_CONNECTION, useExisting: FSnapConnectionComponent }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path [attr.d]=\"path\"></path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n@if (fConnectionContents().length) {\n  <ng-content select=\"[fConnectionContent]\"></ng-content>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center,:host .f-connection-content{pointer-events:all}\n"], dependencies: [{ kind: "component", type: i1.FConnectionTextComponent, selector: "text[f-connection-text]" }, { kind: "component", type: i2.FConnectionDragHandleStartComponent, selector: "circle[f-connection-drag-handle-start]" }, { kind: "component", type: i3.FConnectionDragHandleEndComponent, selector: "circle[f-connection-drag-handle-end]" }, { kind: "component", type: i4.FConnectionGradientComponent, selector: "linearGradient[fConnectionGradient]" }, { kind: "component", type: i5.FConnectionPathComponent, selector: "path[f-connection-path]" }, { kind: "component", type: i6.FConnectionSelectionComponent, selector: "path[fConnectionSelection]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FSnapConnectionComponent, decorators: [{
             type: Component,
-            args: [{ selector: "f-snap-connection", changeDetection: ChangeDetectionStrategy.OnPush, host: {
-                        class: "f-component f-connection f-snap-connection",
-                    }, providers: [{ provide: F_CONNECTION, useExisting: FSnapConnectionComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path\n            [attr.d]=\"path\">\n      </path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center{pointer-events:all}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.FConnectionFactory }], propDecorators: { fSnapThreshold: [{
+            args: [{ selector: 'f-snap-connection', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'f-component f-connection f-snap-connection',
+                    }, providers: [{ provide: F_CONNECTION, useExisting: FSnapConnectionComponent }], template: "<svg xmlns=\"http://www.w3.org/2000/svg\">\n  <defs #defs></defs>\n  <g class=\"f-connection-group\">\n    <linearGradient fConnectionGradient></linearGradient>\n    <path fConnectionSelection [attr.d]=\"path\"></path>\n    <g>\n      <path f-connection-path [attr.d]=\"path\"></path>\n      <circle f-connection-drag-handle-start r=\"8\"></circle>\n      <circle f-connection-drag-handle-end r=\"8\"></circle>\n    </g>\n    <text f-connection-text></text>\n  </g>\n  <ng-content></ng-content>\n</svg>\n@if (fConnectionCenters().length) {\n  <div #fConnectionCenter class=\"f-connection-center\">\n    <ng-content select=\"[fConnectionCenter]\"></ng-content>\n  </div>\n}\n\n@if (fConnectionContents().length) {\n  <ng-content select=\"[fConnectionContent]\"></ng-content>\n}\n", styles: [":host{pointer-events:none;position:absolute}:host svg{overflow:visible}:host svg .f-connection-group{pointer-events:all}:host .f-connection-center,:host .f-connection-content{pointer-events:all}\n"] }]
+        }], propDecorators: { fSnapThreshold: [{
                 type: Input,
                 args: [{ transform: numberAttribute }]
             }], fRadius: [{
@@ -69,4 +65,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], fType: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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