@foblex/flow 17.9.21 → 18.0.0

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/segment-line/calculate-segment-line-data.mjs

@@ -0,0 +1,106 @@
+import { PointExtensions } from '@foblex/2d';
+import { buildConnectionAnchors, calculateCenterBetweenPoints, calculatePolylineCandidates, mergePointChains, normalizePolyline, } from '../utils';
+import { createSegmentLinePath } from './create-segment-line-path';
+import { EFConnectableSide } from '../../../../enums';
+import { buildCornerMidPointsAndApplyOffsets } from './build-corner-mid-points-and-apply-offsets';
+const CONNECTOR_SIDE_POINT = {
+    [EFConnectableSide.LEFT]: PointExtensions.initialize(-1, 0),
+    [EFConnectableSide.RIGHT]: PointExtensions.initialize(1, 0),
+    [EFConnectableSide.TOP]: PointExtensions.initialize(0, -1),
+    [EFConnectableSide.BOTTOM]: PointExtensions.initialize(0, 1),
+    [EFConnectableSide.AUTO]: PointExtensions.initialize(0, 0),
+};
+export class CalculateSegmentLineData {
+    handle({ source, sourceSide, target, targetSide, waypoints, offset, radius, }) {
+        const anchors = buildConnectionAnchors(source, target, waypoints);
+        const chains = [];
+        const candidates = [];
+        for (let i = 0; i < anchors.length - 1; i++) {
+            const a = anchors[i];
+            const b = anchors[i + 1];
+            const points = this._getPathPoints(a, sourceSide, b, targetSide, offset ?? 0);
+            chains.push(points);
+            candidates.push(...calculatePolylineCandidates(points));
+        }
+        const polyline = normalizePolyline(mergePointChains(chains));
+        const penultimatePoint = polyline.length > 1 ? polyline[polyline.length - 2] : source;
+        const secondPoint = polyline.length > 1 ? polyline[1] : target;
+        return {
+            path: createSegmentLinePath(polyline, radius ?? 0),
+            penultimatePoint,
+            secondPoint,
+            points: polyline,
+            candidates,
+        };
+    }
+    _getPathPoints(source, sourceSide, target, targetSide, offset) {
+        const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];
+        const targetDirection = CONNECTOR_SIDE_POINT[targetSide];
+        const sourceGap = {
+            x: source.x + sourceDirection.x * offset,
+            y: source.y + sourceDirection.y * offset,
+        };
+        const targetGap = {
+            x: target.x + targetDirection.x * offset,
+            y: target.y + targetDirection.y * offset,
+        };
+        const direction = this._getDirection(sourceGap, sourceSide, targetGap);
+        const directionAccessor = direction.x !== 0 ? 'x' : 'y';
+        const currentDirection = direction[directionAccessor];
+        let points = [];
+        const sourceGapOffset = PointExtensions.initialize();
+        const targetGapOffset = PointExtensions.initialize();
+        const centerBetweenPoints = calculateCenterBetweenPoints(source, target);
+        if (sourceDirection[directionAccessor] * targetDirection[directionAccessor] === -1) {
+            const verticalSplit = [
+                { x: centerBetweenPoints.x, y: sourceGap.y },
+                { x: centerBetweenPoints.x, y: targetGap.y },
+            ];
+            const horizontalSplit = [
+                { x: sourceGap.x, y: centerBetweenPoints.y },
+                { x: targetGap.x, y: centerBetweenPoints.y },
+            ];
+            if (sourceDirection[directionAccessor] === currentDirection) {
+                points = directionAccessor === 'x' ? verticalSplit : horizontalSplit;
+            }
+            else {
+                points = directionAccessor === 'x' ? horizontalSplit : verticalSplit;
+            }
+        }
+        else {
+            points = buildCornerMidPointsAndApplyOffsets({
+                axis: directionAccessor,
+                source,
+                target,
+                sourceSide,
+                targetSide,
+                sourceGap,
+                targetGap,
+                sourceDir: sourceDirection,
+                targetDir: targetDirection,
+                currentDir: currentDirection,
+                offset,
+                sourceGapOffset,
+                targetGapOffset,
+            });
+        }
+        return [
+            source,
+            { x: sourceGap.x + sourceGapOffset.x, y: sourceGap.y + sourceGapOffset.y },
+            ...points,
+            { x: targetGap.x + targetGapOffset.x, y: targetGap.y + targetGapOffset.y },
+            target,
+        ];
+    }
+    _getDirection(source, sourceSide, target) {
+        if (sourceSide === EFConnectableSide.LEFT || sourceSide === EFConnectableSide.RIGHT) {
+            return source.x < target.x
+                ? PointExtensions.initialize(1, 0)
+                : PointExtensions.initialize(-1, 0);
+        }
+        return source.y < target.y
+            ? PointExtensions.initialize(0, 1)
+            : PointExtensions.initialize(0, -1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculate-segment-line-data.js","sourceRoot":"","sources":["../../../../../../../../projects/f-flow/src/f-connection-v2/utils/connection-line-builder/builders/segment-line/calculate-segment-line-data.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, PointExtensions } from '@foblex/2d';\nimport {\n  buildConnectionAnchors,\n  calculateCenterBetweenPoints,\n  calculatePolylineCandidates,\n  mergePointChains,\n  normalizePolyline,\n} from '../utils';\nimport { createSegmentLinePath } from './create-segment-line-path';\nimport {\n  IFConnectionBuilder,\n  IFConnectionBuilderRequest,\n  IFConnectionBuilderResponse,\n} from '../../models';\nimport { EFConnectableSide } from '../../../../enums';\nimport { buildCornerMidPointsAndApplyOffsets } from './build-corner-mid-points-and-apply-offsets';\n\nconst CONNECTOR_SIDE_POINT: Record<string, IPoint> = {\n  [EFConnectableSide.LEFT]: PointExtensions.initialize(-1, 0),\n\n  [EFConnectableSide.RIGHT]: PointExtensions.initialize(1, 0),\n\n  [EFConnectableSide.TOP]: PointExtensions.initialize(0, -1),\n\n  [EFConnectableSide.BOTTOM]: PointExtensions.initialize(0, 1),\n\n  [EFConnectableSide.AUTO]: PointExtensions.initialize(0, 0),\n};\n\nexport class CalculateSegmentLineData implements IFConnectionBuilder {\n  public handle({\n    source,\n    sourceSide,\n    target,\n    targetSide,\n    waypoints,\n    offset,\n    radius,\n  }: IFConnectionBuilderRequest): IFConnectionBuilderResponse {\n    const anchors = buildConnectionAnchors(source, target, waypoints);\n\n    const chains: IPoint[][] = [];\n    const candidates: IPoint[] = [];\n\n    for (let i = 0; i < anchors.length - 1; i++) {\n      const a = anchors[i];\n      const b = anchors[i + 1];\n\n      const points = this._getPathPoints(a, sourceSide, b, targetSide, offset ?? 0);\n\n      chains.push(points);\n      candidates.push(...calculatePolylineCandidates(points));\n    }\n\n    const polyline = normalizePolyline(mergePointChains(chains));\n\n    const penultimatePoint = polyline.length > 1 ? polyline[polyline.length - 2] : source;\n    const secondPoint = polyline.length > 1 ? polyline[1] : target;\n\n    return {\n      path: createSegmentLinePath(polyline, radius ?? 0),\n      penultimatePoint,\n      secondPoint,\n      points: polyline,\n      candidates,\n    };\n  }\n\n  private _getPathPoints(\n    source: IPoint,\n    sourceSide: EFConnectableSide,\n    target: IPoint,\n    targetSide: EFConnectableSide,\n    offset: number,\n  ): IPoint[] {\n    const sourceDirection = CONNECTOR_SIDE_POINT[sourceSide];\n    const targetDirection = CONNECTOR_SIDE_POINT[targetSide];\n\n    const sourceGap: IPoint = {\n      x: source.x + sourceDirection.x * offset,\n      y: source.y + sourceDirection.y * offset,\n    };\n    const targetGap: IPoint = {\n      x: target.x + targetDirection.x * offset,\n      y: target.y + targetDirection.y * offset,\n    };\n\n    const direction = this._getDirection(sourceGap, sourceSide, targetGap);\n    const directionAccessor: 'x' | 'y' = direction.x !== 0 ? 'x' : 'y';\n    const currentDirection = direction[directionAccessor];\n\n    let points: IPoint[] = [];\n    const sourceGapOffset = PointExtensions.initialize();\n    const targetGapOffset = PointExtensions.initialize();\n\n    const centerBetweenPoints = calculateCenterBetweenPoints(source, target);\n\n    if (sourceDirection[directionAccessor] * targetDirection[directionAccessor] === -1) {\n      const verticalSplit: IPoint[] = [\n        { x: centerBetweenPoints.x, y: sourceGap.y },\n        { x: centerBetweenPoints.x, y: targetGap.y },\n      ];\n      const horizontalSplit: IPoint[] = [\n        { x: sourceGap.x, y: centerBetweenPoints.y },\n        { x: targetGap.x, y: centerBetweenPoints.y },\n      ];\n\n      if (sourceDirection[directionAccessor] === currentDirection) {\n        points = directionAccessor === 'x' ? verticalSplit : horizontalSplit;\n      } else {\n        points = directionAccessor === 'x' ? horizontalSplit : verticalSplit;\n      }\n    } else {\n      points = buildCornerMidPointsAndApplyOffsets({\n        axis: directionAccessor,\n        source,\n        target,\n        sourceSide,\n        targetSide,\n        sourceGap,\n        targetGap,\n        sourceDir: sourceDirection,\n        targetDir: targetDirection,\n        currentDir: currentDirection,\n        offset,\n        sourceGapOffset,\n        targetGapOffset,\n      });\n    }\n\n    return [\n      source,\n      { x: sourceGap.x + sourceGapOffset.x, y: sourceGap.y + sourceGapOffset.y },\n      ...points,\n      { x: targetGap.x + targetGapOffset.x, y: targetGap.y + targetGapOffset.y },\n      target,\n    ];\n  }\n\n  private _getDirection(source: IPoint, sourceSide: EFConnectableSide, target: IPoint): IPoint {\n    if (sourceSide === EFConnectableSide.LEFT || sourceSide === EFConnectableSide.RIGHT) {\n      return source.x < target.x\n        ? PointExtensions.initialize(1, 0)\n        : PointExtensions.initialize(-1, 0);\n    }\n\n    return source.y < target.y\n      ? PointExtensions.initialize(0, 1)\n      : PointExtensions.initialize(0, -1);\n  }\n}\n"]}

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/segment-line/create-segment-line-path.mjs

@@ -0,0 +1,46 @@
+const EPS = 1e-6;
+const END_EPS = 0.0002;
+const MIN_VISIBLE = 0.75;
+export function createSegmentLinePath(points, borderRadius) {
+    const n = points.length;
+    const parts = [];
+    parts.push(`M ${points[0].x} ${points[0].y}`);
+    for (let i = 1; i < n - 1; i++) {
+        parts.push(getBend(points[i - 1], points[i], points[i + 1], borderRadius));
+    }
+    const last = points[n - 1];
+    parts.push(`L ${last.x + END_EPS} ${last.y + END_EPS}`);
+    return parts.join(' ');
+}
+function getBend(a, b, c, size) {
+    const x = b.x;
+    const y = b.y;
+    if (size <= 0) {
+        return `L ${x} ${y}`;
+    }
+    const collinearX = Math.abs(a.x - x) <= EPS && Math.abs(x - c.x) <= EPS;
+    const collinearY = Math.abs(a.y - y) <= EPS && Math.abs(y - c.y) <= EPS;
+    if (collinearX || collinearY) {
+        return `L ${x} ${y}`;
+    }
+    const ab = Math.hypot(x - a.x, y - a.y);
+    const bc = Math.hypot(c.x - x, c.y - y);
+    const bendSize = Math.min(ab * 0.5, bc * 0.5, size);
+    if (bendSize < MIN_VISIBLE) {
+        return `L ${x} ${y}`;
+    }
+    const incomingHorizontal = Math.abs(a.y - y) <= EPS;
+    if (incomingHorizontal) {
+        const xDir = a.x < c.x ? -1 : 1;
+        const yDir = a.y < c.y ? 1 : -1;
+        const lx = x + bendSize * xDir;
+        const qy = y + bendSize * yDir;
+        return `L ${lx} ${y} Q ${x} ${y} ${x} ${qy}`;
+    }
+    const xDir = a.x < c.x ? 1 : -1;
+    const yDir = a.y < c.y ? -1 : 1;
+    const ly = y + bendSize * yDir;
+    const qx = x + bendSize * xDir;
+    return `L ${x} ${ly} Q ${x} ${y} ${qx} ${y}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/segment-line/index.mjs

@@ -0,0 +1,4 @@
+export * from './build-corner-mid-points-and-apply-offsets';
+export * from './calculate-segment-line-data';
+export * from './create-segment-line-path';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9idWlsZGVycy9zZWdtZW50LWxpbmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2J1aWxkLWNvcm5lci1taWQtcG9pbnRzLWFuZC1hcHBseS1vZmZzZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vY2FsY3VsYXRlLXNlZ21lbnQtbGluZS1kYXRhJztcbmV4cG9ydCAqIGZyb20gJy4vY3JlYXRlLXNlZ21lbnQtbGluZS1wYXRoJztcbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/straight-line/calculate-straight-line-data.mjs

@@ -0,0 +1,28 @@
+import { buildConnectionAnchors } from '../utils';
+const EPS = 0.0002;
+export class CalculateStraightLineData {
+    handle(request) {
+        const anchors = buildConnectionAnchors(request.source, request.target, request.waypoints);
+        const n = anchors.length;
+        const p0 = anchors[0];
+        let d = `M ${p0.x} ${p0.y}`;
+        const candidates = new Array(n - 1);
+        for (let i = 0; i < n - 1; i++) {
+            const a = anchors[i];
+            const b = anchors[i + 1];
+            const isLast = i === n - 2;
+            const bx = isLast ? b.x + EPS : b.x;
+            const by = isLast ? b.y + EPS : b.y;
+            d += ` L ${bx} ${by}`;
+            candidates[i] = { x: (a.x + b.x) * 0.5, y: (a.y + b.y) * 0.5 };
+        }
+        return {
+            path: d,
+            candidates,
+            points: anchors,
+            secondPoint: anchors[1] ?? request.target,
+            penultimatePoint: anchors[n - 2] ?? request.source,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/straight-line/index.mjs

@@ -0,0 +1,2 @@
+export * from './calculate-straight-line-data';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9idWlsZGVycy9zdHJhaWdodC1saW5lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0NBQWdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NhbGN1bGF0ZS1zdHJhaWdodC1saW5lLWRhdGEnO1xuIl19

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/build-connection-anchors.mjs

@@ -0,0 +1,4 @@
+export function buildConnectionAnchors(source, target, waypoints) {
+    return [source, ...(waypoints ?? []), target];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtY29ubmVjdGlvbi1hbmNob3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvdXRpbHMvY29ubmVjdGlvbi1saW5lLWJ1aWxkZXIvYnVpbGRlcnMvdXRpbHMvYnVpbGQtY29ubmVjdGlvbi1hbmNob3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxzQkFBc0IsQ0FDcEMsTUFBYyxFQUNkLE1BQWMsRUFDZCxTQUFvQjtJQUVwQixPQUFPLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxTQUFTLElBQUksRUFBRSxDQUFDLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDaEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRDb25uZWN0aW9uQW5jaG9ycyhcbiAgc291cmNlOiBJUG9pbnQsXG4gIHRhcmdldDogSVBvaW50LFxuICB3YXlwb2ludHM/OiBJUG9pbnRbXSxcbik6IElQb2ludFtdIHtcbiAgcmV0dXJuIFtzb3VyY2UsIC4uLih3YXlwb2ludHMgPz8gW10pLCB0YXJnZXRdO1xufVxuIl19

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-center-between-points.mjs

@@ -0,0 +1,8 @@
+export function calculateCenterBetweenPoints(source, target) {
+    const offsetX = Math.abs(target.x - source.x) / 2;
+    const centerX = target.x < source.x ? target.x + offsetX : target.x - offsetX;
+    const offsetY = Math.abs(target.y - source.y) / 2;
+    const centerY = target.y < source.y ? target.y + offsetY : target.y - offsetY;
+    return { x: centerX, y: centerY };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLWNlbnRlci1iZXR3ZWVuLXBvaW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uLXYyL3V0aWxzL2Nvbm5lY3Rpb24tbGluZS1idWlsZGVyL2J1aWxkZXJzL3V0aWxzL2NhbGN1bGF0ZS1jZW50ZXItYmV0d2Vlbi1wb2ludHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLDRCQUE0QixDQUFDLE1BQWMsRUFBRSxNQUFjO0lBQ3pFLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDO0lBRTlFLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDO0lBRTlFLE9BQU8sRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUNwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50IH0gZnJvbSAnQGZvYmxleC8yZCc7XG5cbmV4cG9ydCBmdW5jdGlvbiBjYWxjdWxhdGVDZW50ZXJCZXR3ZWVuUG9pbnRzKHNvdXJjZTogSVBvaW50LCB0YXJnZXQ6IElQb2ludCk6IElQb2ludCB7XG4gIGNvbnN0IG9mZnNldFggPSBNYXRoLmFicyh0YXJnZXQueCAtIHNvdXJjZS54KSAvIDI7XG4gIGNvbnN0IGNlbnRlclggPSB0YXJnZXQueCA8IHNvdXJjZS54ID8gdGFyZ2V0LnggKyBvZmZzZXRYIDogdGFyZ2V0LnggLSBvZmZzZXRYO1xuXG4gIGNvbnN0IG9mZnNldFkgPSBNYXRoLmFicyh0YXJnZXQueSAtIHNvdXJjZS55KSAvIDI7XG4gIGNvbnN0IGNlbnRlclkgPSB0YXJnZXQueSA8IHNvdXJjZS55ID8gdGFyZ2V0LnkgKyBvZmZzZXRZIDogdGFyZ2V0LnkgLSBvZmZzZXRZO1xuXG4gIHJldHVybiB7IHg6IGNlbnRlclgsIHk6IGNlbnRlclkgfTtcbn1cbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-curve-candidates.mjs

@@ -0,0 +1,7 @@
+import { cubicBezierAtT } from './sample-cubic-bezier-uniform';
+export function calculateCurveCandidates(segments) {
+    return segments.map((s) => {
+        return cubicBezierAtT(s.p0, s.c1, s.c2, s.p3, 0.5);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLWN1cnZlLWNhbmRpZGF0ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9idWlsZGVycy91dGlscy9jYWxjdWxhdGUtY3VydmUtY2FuZGlkYXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFHL0QsTUFBTSxVQUFVLHdCQUF3QixDQUFDLFFBQXlCO0lBQ2hFLE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1FBQ3hCLE9BQU8sY0FBYyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDckQsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUN1YmljU2VnbWVudCB9IGZyb20gJy4vbXVsdGktY3ViaWMnO1xuaW1wb3J0IHsgY3ViaWNCZXppZXJBdFQgfSBmcm9tICcuL3NhbXBsZS1jdWJpYy1iZXppZXItdW5pZm9ybSc7XG5pbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcblxuZXhwb3J0IGZ1bmN0aW9uIGNhbGN1bGF0ZUN1cnZlQ2FuZGlkYXRlcyhzZWdtZW50czogSUN1YmljU2VnbWVudFtdKTogSVBvaW50W10ge1xuICByZXR1cm4gc2VnbWVudHMubWFwKChzKSA9PiB7XG4gICAgcmV0dXJuIGN1YmljQmV6aWVyQXRUKHMucDAsIHMuYzEsIHMuYzIsIHMucDMsIDAuNSk7XG4gIH0pO1xufVxuIl19

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/calculate-polyline-candidates.mjs

@@ -0,0 +1,39 @@
+export function calculatePolylineCandidates(polyline) {
+    if (polyline.length < 2) {
+        throw new Error('Polylines must be at least two points');
+    }
+    const total = polylineTotalLength(polyline);
+    if (total <= 0) {
+        return [{ ...polyline[0] }];
+    }
+    const mid = pointAtPolylineLength(polyline, total / 2);
+    return [mid];
+}
+function polylineTotalLength(points) {
+    let len = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        len += dist(points[i], points[i + 1]);
+    }
+    return len;
+}
+function pointAtPolylineLength(points, s) {
+    let acc = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const a = points[i];
+        const b = points[i + 1];
+        const segLen = dist(a, b);
+        if (segLen <= 0)
+            continue;
+        if (acc + segLen >= s) {
+            const t = (s - acc) / segLen;
+            return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+        }
+        acc += segLen;
+    }
+    const last = points[points.length - 1];
+    return { x: last.x, y: last.y };
+}
+function dist(a, b) {
+    return Math.hypot(b.x - a.x, b.y - a.y);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/index.mjs

@@ -0,0 +1,9 @@
+export * from './build-connection-anchors';
+export * from './calculate-center-between-points';
+export * from './calculate-curve-candidates';
+export * from './calculate-polyline-candidates';
+export * from './merge-point-chains';
+export * from './multi-cubic';
+export * from './normalize-polyline';
+export * from './sample-cubic-bezier-uniform';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9idWlsZGVycy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9idWlsZC1jb25uZWN0aW9uLWFuY2hvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jYWxjdWxhdGUtY2VudGVyLWJldHdlZW4tcG9pbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vY2FsY3VsYXRlLWN1cnZlLWNhbmRpZGF0ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jYWxjdWxhdGUtcG9seWxpbmUtY2FuZGlkYXRlcyc7XG5leHBvcnQgKiBmcm9tICcuL21lcmdlLXBvaW50LWNoYWlucyc7XG5leHBvcnQgKiBmcm9tICcuL211bHRpLWN1YmljJztcbmV4cG9ydCAqIGZyb20gJy4vbm9ybWFsaXplLXBvbHlsaW5lJztcbmV4cG9ydCAqIGZyb20gJy4vc2FtcGxlLWN1YmljLWJlemllci11bmlmb3JtJztcbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/merge-point-chains.mjs

@@ -0,0 +1,12 @@
+export function mergePointChains(chains) {
+    const out = [];
+    for (const chain of chains) {
+        for (const p of chain) {
+            const last = out[out.length - 1];
+            if (!last || last.x !== p.x || last.y !== p.y)
+                out.push(p);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2UtcG9pbnQtY2hhaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvdXRpbHMvY29ubmVjdGlvbi1saW5lLWJ1aWxkZXIvYnVpbGRlcnMvdXRpbHMvbWVyZ2UtcG9pbnQtY2hhaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxNQUFrQjtJQUNqRCxNQUFNLEdBQUcsR0FBYSxFQUFFLENBQUM7SUFDekIsS0FBSyxNQUFNLEtBQUssSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUMzQixLQUFLLE1BQU0sQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ3RCLE1BQU0sSUFBSSxHQUFHLEdBQUcsQ0FBQyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDO1lBQ2pDLElBQUksQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7Z0JBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM3RCxDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQb2ludCB9IGZyb20gJ0Bmb2JsZXgvMmQnO1xuXG5leHBvcnQgZnVuY3Rpb24gbWVyZ2VQb2ludENoYWlucyhjaGFpbnM6IElQb2ludFtdW10pOiBJUG9pbnRbXSB7XG4gIGNvbnN0IG91dDogSVBvaW50W10gPSBbXTtcbiAgZm9yIChjb25zdCBjaGFpbiBvZiBjaGFpbnMpIHtcbiAgICBmb3IgKGNvbnN0IHAgb2YgY2hhaW4pIHtcbiAgICAgIGNvbnN0IGxhc3QgPSBvdXRbb3V0Lmxlbmd0aCAtIDFdO1xuICAgICAgaWYgKCFsYXN0IHx8IGxhc3QueCAhPT0gcC54IHx8IGxhc3QueSAhPT0gcC55KSBvdXQucHVzaChwKTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gb3V0O1xufVxuIl19

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/multi-cubic.mjs

@@ -0,0 +1,28 @@
+import { sampleCubicBezierUniform } from './sample-cubic-bezier-uniform';
+export function createMultiCubicPath(segments) {
+    if (!segments.length)
+        return '';
+    let d = `M ${segments[0].p0.x} ${segments[0].p0.y}`;
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        const isLast = i === segments.length - 1;
+        const x = isLast ? s.p3.x + 0.0002 : s.p3.x;
+        const y = isLast ? s.p3.y + 0.0002 : s.p3.y;
+        d += ` C ${s.c1.x} ${s.c1.y}, ${s.c2.x} ${s.c2.y}, ${x} ${y}`;
+    }
+    return d;
+}
+export function sampleMultiCubicUniform(segments, samplesPerSegment = 16) {
+    if (!segments.length)
+        return [];
+    const out = [];
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        const pts = sampleCubicBezierUniform([s.p0, s.c1, s.c2, s.p3], samplesPerSegment);
+        if (i > 0)
+            pts.shift();
+        out.push(...pts);
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/normalize-polyline.mjs

@@ -0,0 +1,30 @@
+export function normalizePolyline(points, eps = 1e-6) {
+    const n = points.length;
+    if (n <= 2)
+        return points;
+    const tmp = [];
+    tmp.push(points[0]);
+    for (let i = 1; i < n; i++) {
+        const p = points[i];
+        const last = tmp[tmp.length - 1];
+        if (Math.abs(p.x - last.x) > eps || Math.abs(p.y - last.y) > eps) {
+            tmp.push(p);
+        }
+    }
+    if (tmp.length <= 2)
+        return tmp;
+    const out = [];
+    out.push(tmp[0]);
+    for (let i = 1; i < tmp.length - 1; i++) {
+        const a = out[out.length - 1];
+        const b = tmp[i];
+        const c = tmp[i + 1];
+        const collinearX = Math.abs(a.x - b.x) <= eps && Math.abs(b.x - c.x) <= eps;
+        const collinearY = Math.abs(a.y - b.y) <= eps && Math.abs(b.y - c.y) <= eps;
+        if (!collinearX && !collinearY)
+            out.push(b);
+    }
+    out.push(tmp[tmp.length - 1]);
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/builders/utils/sample-cubic-bezier-uniform.mjs

@@ -0,0 +1,37 @@
+/**
+ * Uniformly samples a cubic Bézier segment.
+ *
+ * @param points - Start point, First control point, Second control point, End point.
+ * @param samples - Number of sub-segments (default: 32). The function returns `samples + 1` points.
+ * @returns Array of sampled points including both endpoints.
+ * @remarks
+ * Sampling is uniform in parameter `t`, not in arc length. This is typically
+ * sufficient for hit-testing and bounding boxes; if you need error-bounded
+ * flattening, consider an adaptive subdivision strategy instead.
+ */
+export function sampleCubicBezierUniform(points, samples = 32) {
+    const out = new Array(samples + 1);
+    out[0] = { ...points[0] };
+    for (let i = 1; i <= samples; i++) {
+        out[i] = cubicBezierAtT(points[0], points[1], points[2], points[3], i / samples);
+    }
+    return out;
+}
+/**
+ * Evaluates a cubic Bézier at parameter `t` in [0, 1].
+ *
+ * @param p0 - Start point.
+ * @param p1 - First control point.
+ * @param p2 - Second control point.
+ * @param p3 - End point.
+ * @param t - Parameter in [0, 1].
+ * @returns Point on the curve at `t`.
+ */
+export function cubicBezierAtT(p0, p1, p2, p3, t) {
+    const u = 1 - t, tt = t * t, uu = u * u, uuu = uu * u, ttt = tt * t;
+    return {
+        x: uuu * p0.x + 3 * uu * t * p1.x + 3 * u * tt * p2.x + ttt * p3.x,
+        y: uuu * p0.y + 3 * uu * t * p1.y + 3 * u * tt * p2.y + ttt * p3.y,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/connection-line-builder-request.mjs

@@ -0,0 +1,9 @@
+export class ConnectionLineBuilderRequest {
+    type;
+    payload;
+    constructor(type, payload) {
+        this.type = type;
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi1saW5lLWJ1aWxkZXItcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1jb25uZWN0aW9uLXYyL3V0aWxzL2Nvbm5lY3Rpb24tbGluZS1idWlsZGVyL2Nvbm5lY3Rpb24tbGluZS1idWlsZGVyLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFPLDRCQUE0QjtJQUVyQjtJQUNBO0lBRmxCLFlBQ2tCLElBQStCLEVBQy9CLE9BQW1DO1FBRG5DLFNBQUksR0FBSixJQUFJLENBQTJCO1FBQy9CLFlBQU8sR0FBUCxPQUFPLENBQTRCO0lBQ2xELENBQUM7Q0FDTCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElGQ29ubmVjdGlvbkJ1aWxkZXJSZXF1ZXN0IH0gZnJvbSAnLi9tb2RlbHMnO1xuaW1wb3J0IHsgRUZDb25uZWN0aW9uVHlwZSB9IGZyb20gJy4uLy4uL2VudW1zJztcblxuZXhwb3J0IGNsYXNzIENvbm5lY3Rpb25MaW5lQnVpbGRlclJlcXVlc3Qge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgcmVhZG9ubHkgdHlwZTogc3RyaW5nIHwgRUZDb25uZWN0aW9uVHlwZSxcbiAgICBwdWJsaWMgcmVhZG9ubHkgcGF5bG9hZDogSUZDb25uZWN0aW9uQnVpbGRlclJlcXVlc3QsXG4gICkge31cbn1cbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/connection-line-builder.mjs

@@ -0,0 +1,50 @@
+import { CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateSegmentLineData, CalculateStraightLineData, } from './builders';
+import { inject, Injectable } from '@angular/core';
+import { F_CONNECTION_BUILDERS } from './providers';
+import { EFConnectionType } from '../../enums';
+import * as i0 from "@angular/core";
+export class ConnectionLineBuilder {
+    _builtinBuilders = {
+        [EFConnectionType.STRAIGHT]: new CalculateStraightLineData(),
+        [EFConnectionType.BEZIER]: new CalculateBezierCurveData(),
+        [EFConnectionType.ADAPTIVE_CURVE]: new CalculateAdaptiveCurveData(),
+        [EFConnectionType.SEGMENT]: new CalculateSegmentLineData(),
+    };
+    _providedBuilders;
+    _builders;
+    constructor() {
+        this._providedBuilders = inject(F_CONNECTION_BUILDERS, { optional: true }) || {};
+        this._builders = {
+            ...this._builtinBuilders,
+            ...this._providedBuilders,
+        };
+    }
+    handle({ type, payload }) {
+        const builder = this._builders[type];
+        if (!builder) {
+            throw this._createBuilderNotFoundError(type);
+        }
+        return builder.handle(payload);
+    }
+    _createBuilderNotFoundError(requestedType) {
+        const builtinTypes = Object.keys(this._builtinBuilders).sort();
+        const providedTypes = Object.keys(this._providedBuilders).sort();
+        const registeredTypes = Object.keys(this._builders).sort();
+        const overriddenBuiltins = builtinTypes.filter((t) => t in this._providedBuilders).sort();
+        const lines = [
+            `Connection Builder Error: builder type "${requestedType}" not found.`,
+            `Registered types: ${registeredTypes.length ? registeredTypes.join(', ') : '(none)'}`,
+            `Built-in types: ${builtinTypes.length ? builtinTypes.join(', ') : '(none)'}`,
+            `Provided (F_CONNECTION_BUILDERS) types: ${providedTypes.length ? providedTypes.join(', ') : '(none)'}`,
+            overriddenBuiltins.length ? `Overridden built-ins: ${overriddenBuiltins.join(', ')}` : null,
+            `Tip: ensure you pass a valid Connection Type or provide a builder via F_CONNECTION_BUILDERS.`,
+        ].filter(Boolean);
+        return new Error(lines.join('\n'));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionLineBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionLineBuilder });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConnectionLineBuilder, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-connection-v2/utils/connection-line-builder/index.mjs

@@ -0,0 +1,6 @@
+export * from './builders';
+export * from './models';
+export * from './providers';
+export * from './connection-line-builder';
+export * from './connection-line-builder-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUNBQW1DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2J1aWxkZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vY29ubmVjdGlvbi1saW5lLWJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder-request.mjs

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

package/esm2022/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder-response.mjs

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

package/esm2022/f-connection-v2/utils/connection-line-builder/models/i-f-connection-builder.mjs

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

package/esm2022/f-connection-v2/utils/connection-line-builder/models/index.mjs

@@ -0,0 +1,4 @@
+export * from './i-f-connection-builder-request';
+export * from './i-f-connection-builder-response';
+export * from './i-f-connection-builder';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jb25uZWN0aW9uLWxpbmUtYnVpbGRlci9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ktZi1jb25uZWN0aW9uLWJ1aWxkZXItcmVxdWVzdCc7XG5leHBvcnQgKiBmcm9tICcuL2ktZi1jb25uZWN0aW9uLWJ1aWxkZXItcmVzcG9uc2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pLWYtY29ubmVjdGlvbi1idWlsZGVyJztcbiJdfQ==

package/esm2022/f-connection-v2/utils/connection-line-builder/providers/f-connection-builders.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const F_CONNECTION_BUILDERS = new InjectionToken('F_CONNECTION_BUILDERS');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jb25uZWN0aW9uLWJ1aWxkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvdXRpbHMvY29ubmVjdGlvbi1saW5lLWJ1aWxkZXIvcHJvdmlkZXJzL2YtY29ubmVjdGlvbi1idWlsZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSy9DLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLElBQUksY0FBYyxDQUNyRCx1QkFBdUIsQ0FDeEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJRkNvbm5lY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi4vbW9kZWxzJztcblxuZXhwb3J0IHR5cGUgSUNvbm5lY3Rpb25CdWlsZGVycyA9IFJlY29yZDxzdHJpbmcsIElGQ29ubmVjdGlvbkJ1aWxkZXI+O1xuXG5leHBvcnQgY29uc3QgRl9DT05ORUNUSU9OX0JVSUxERVJTID0gbmV3IEluamVjdGlvblRva2VuPElDb25uZWN0aW9uQnVpbGRlcnM+KFxuICAnRl9DT05ORUNUSU9OX0JVSUxERVJTJyxcbik7XG4iXX0=

package/esm2022/f-connection-v2/utils/connection-line-builder/providers/index.mjs

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

package/esm2022/f-connection-v2/utils/create-connection-dom-identifier.mjs

@@ -0,0 +1,5 @@
+import { normalizeDomElementId } from '@foblex/utils';
+export function createConnectionDomIdentifier(componentId, sourceId, targetId) {
+    return normalizeDomElementId('connection_' + componentId + sourceId + targetId);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWNvbm5lY3Rpb24tZG9tLWlkZW50aWZpZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtY29ubmVjdGlvbi12Mi91dGlscy9jcmVhdGUtY29ubmVjdGlvbi1kb20taWRlbnRpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFdEQsTUFBTSxVQUFVLDZCQUE2QixDQUMzQyxXQUFtQixFQUNuQixRQUFnQixFQUNoQixRQUFnQjtJQUVoQixPQUFPLHFCQUFxQixDQUFDLGFBQWEsR0FBRyxXQUFXLEdBQUcsUUFBUSxHQUFHLFFBQVEsQ0FBQyxDQUFDO0FBQ2xGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBub3JtYWxpemVEb21FbGVtZW50SWQgfSBmcm9tICdAZm9ibGV4L3V0aWxzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZUNvbm5lY3Rpb25Eb21JZGVudGlmaWVyKFxuICBjb21wb25lbnRJZDogc3RyaW5nLFxuICBzb3VyY2VJZDogc3RyaW5nLFxuICB0YXJnZXRJZDogc3RyaW5nLFxuKTogc3RyaW5nIHtcbiAgcmV0dXJuIG5vcm1hbGl6ZURvbUVsZW1lbnRJZCgnY29ubmVjdGlvbl8nICsgY29tcG9uZW50SWQgKyBzb3VyY2VJZCArIHRhcmdldElkKTtcbn1cbiJdfQ==

package/esm2022/f-connection-v2/utils/create-connection-selection-dom-identifier.mjs

@@ -0,0 +1,5 @@
+import { normalizeDomElementId } from '@foblex/utils';
+export function createConnectionSelectionDomIdentifier(componentId, sourceId, targetId) {
+    return normalizeDomElementId('connection_for_selection_' + componentId + sourceId + targetId);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWNvbm5lY3Rpb24tc2VsZWN0aW9uLWRvbS1pZGVudGlmaWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvdXRpbHMvY3JlYXRlLWNvbm5lY3Rpb24tc2VsZWN0aW9uLWRvbS1pZGVudGlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV0RCxNQUFNLFVBQVUsc0NBQXNDLENBQ3BELFdBQW1CLEVBQ25CLFFBQWdCLEVBQ2hCLFFBQWdCO0lBRWhCLE9BQU8scUJBQXFCLENBQUMsMkJBQTJCLEdBQUcsV0FBVyxHQUFHLFFBQVEsR0FBRyxRQUFRLENBQUMsQ0FBQztBQUNoRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbm9ybWFsaXplRG9tRWxlbWVudElkIH0gZnJvbSAnQGZvYmxleC91dGlscyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVDb25uZWN0aW9uU2VsZWN0aW9uRG9tSWRlbnRpZmllcihcbiAgY29tcG9uZW50SWQ6IHN0cmluZyxcbiAgc291cmNlSWQ6IHN0cmluZyxcbiAgdGFyZ2V0SWQ6IHN0cmluZyxcbik6IHN0cmluZyB7XG4gIHJldHVybiBub3JtYWxpemVEb21FbGVtZW50SWQoJ2Nvbm5lY3Rpb25fZm9yX3NlbGVjdGlvbl8nICsgY29tcG9uZW50SWQgKyBzb3VyY2VJZCArIHRhcmdldElkKTtcbn1cbiJdfQ==

package/esm2022/f-connection-v2/utils/create-gradient-dom-identifier.mjs

@@ -0,0 +1,5 @@
+import { normalizeDomElementId } from '@foblex/utils';
+export function createGradientDomIdentifier(componentId, sourceId, targetId) {
+    return normalizeDomElementId('connection_gradient_' + componentId + sourceId + targetId);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLWdyYWRpZW50LWRvbS1pZGVudGlmaWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24tdjIvdXRpbHMvY3JlYXRlLWdyYWRpZW50LWRvbS1pZGVudGlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV0RCxNQUFNLFVBQVUsMkJBQTJCLENBQ3pDLFdBQW1CLEVBQ25CLFFBQWdCLEVBQ2hCLFFBQWdCO0lBRWhCLE9BQU8scUJBQXFCLENBQUMsc0JBQXNCLEdBQUcsV0FBVyxHQUFHLFFBQVEsR0FBRyxRQUFRLENBQUMsQ0FBQztBQUMzRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbm9ybWFsaXplRG9tRWxlbWVudElkIH0gZnJvbSAnQGZvYmxleC91dGlscyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVHcmFkaWVudERvbUlkZW50aWZpZXIoXG4gIGNvbXBvbmVudElkOiBzdHJpbmcsXG4gIHNvdXJjZUlkOiBzdHJpbmcsXG4gIHRhcmdldElkOiBzdHJpbmcsXG4pOiBzdHJpbmcge1xuICByZXR1cm4gbm9ybWFsaXplRG9tRWxlbWVudElkKCdjb25uZWN0aW9uX2dyYWRpZW50XycgKyBjb21wb25lbnRJZCArIHNvdXJjZUlkICsgdGFyZ2V0SWQpO1xufVxuIl19