@uipath/apollo-react 4.45.1 → 4.47.0

package/dist/canvas/components/Edges/shared/constants.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ARROW_ANGLE_MAP: ()=>ARROW_ANGLE_MAP,
+    ARROW_OFFSETS: ()=>ARROW_OFFSETS,
+    EDGE_DASHARRAY: ()=>EDGE_DASHARRAY,
+    EDGE_CONSTANTS: ()=>EDGE_CONSTANTS,
+    EDGE_PATH_TRANSITION: ()=>EDGE_PATH_TRANSITION,
+    EMPTY_WAYPOINTS: ()=>EMPTY_WAYPOINTS,
+    EDGE_COLORS: ()=>EDGE_COLORS
+});
+const react_cjs_namespaceObject = require("../../../xyflow/react.cjs");
+const external_constants_cjs_namespaceObject = require("../../../constants.cjs");
+const EMPTY_WAYPOINTS = [];
+const EDGE_CONSTANTS = {
+    BORDER_RADIUS: external_constants_cjs_namespaceObject.GRID_SPACING,
+    ARROW_SIZE: 10,
+    ARROW_HALF_ANGLE: Math.PI / 6,
+    STROKE_WIDTH: 2,
+    SELECTED_STROKE_WIDTH: 3,
+    INTERACTION_STROKE_WIDTH: 20,
+    SELECTED_OUTLINE_STROKE_WIDTH: 10,
+    SELECTED_OUTLINE_OPACITY: 0.3,
+    MIN_SEGMENT_LENGTH: 32,
+    COLLINEAR_TOLERANCE: 1,
+    ARROW_OFFSET: 8,
+    STUB_OFFSET: 2 * external_constants_cjs_namespaceObject.GRID_SPACING
+};
+const EDGE_PATH_TRANSITION = 'stroke 0.2s ease, opacity 0.2s ease';
+const EDGE_DASHARRAY = {
+    solid: '0',
+    dashed: '5,5'
+};
+const EDGE_COLORS = {
+    default: 'var(--canvas-border)',
+    hover: 'var(--canvas-primary-hover)',
+    selected: 'var(--canvas-primary)',
+    invalid: 'var(--canvas-error-icon)',
+    diffAdded: 'var(--canvas-success-icon)',
+    diffRemoved: 'var(--canvas-error-icon)'
+};
+const ARROW_ANGLE_MAP = {
+    [react_cjs_namespaceObject.Position.Left]: 0,
+    [react_cjs_namespaceObject.Position.Right]: Math.PI,
+    [react_cjs_namespaceObject.Position.Top]: Math.PI / 2,
+    [react_cjs_namespaceObject.Position.Bottom]: -Math.PI / 2
+};
+const ARROW_OFFSETS = {
+    [react_cjs_namespaceObject.Position.Left]: {
+        x: EDGE_CONSTANTS.ARROW_OFFSET,
+        y: 0
+    },
+    [react_cjs_namespaceObject.Position.Right]: {
+        x: -EDGE_CONSTANTS.ARROW_OFFSET,
+        y: 0
+    },
+    [react_cjs_namespaceObject.Position.Top]: {
+        x: 0,
+        y: EDGE_CONSTANTS.ARROW_OFFSET
+    },
+    [react_cjs_namespaceObject.Position.Bottom]: {
+        x: 0,
+        y: -EDGE_CONSTANTS.ARROW_OFFSET
+    }
+};
+exports.ARROW_ANGLE_MAP = __webpack_exports__.ARROW_ANGLE_MAP;
+exports.ARROW_OFFSETS = __webpack_exports__.ARROW_OFFSETS;
+exports.EDGE_COLORS = __webpack_exports__.EDGE_COLORS;
+exports.EDGE_CONSTANTS = __webpack_exports__.EDGE_CONSTANTS;
+exports.EDGE_DASHARRAY = __webpack_exports__.EDGE_DASHARRAY;
+exports.EDGE_PATH_TRANSITION = __webpack_exports__.EDGE_PATH_TRANSITION;
+exports.EMPTY_WAYPOINTS = __webpack_exports__.EMPTY_WAYPOINTS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ARROW_ANGLE_MAP",
+    "ARROW_OFFSETS",
+    "EDGE_COLORS",
+    "EDGE_CONSTANTS",
+    "EDGE_DASHARRAY",
+    "EDGE_PATH_TRANSITION",
+    "EMPTY_WAYPOINTS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/constants.d.ts

@@ -0,0 +1,33 @@
+import { Position } from '../../../xyflow/react.ts';
+import type { Point, Waypoint } from './types';
+export declare const EMPTY_WAYPOINTS: Waypoint[];
+export declare const EDGE_CONSTANTS: {
+    readonly BORDER_RADIUS: 16;
+    readonly ARROW_SIZE: 10;
+    readonly ARROW_HALF_ANGLE: number;
+    readonly STROKE_WIDTH: 2;
+    readonly SELECTED_STROKE_WIDTH: 3;
+    readonly INTERACTION_STROKE_WIDTH: 20;
+    readonly SELECTED_OUTLINE_STROKE_WIDTH: 10;
+    readonly SELECTED_OUTLINE_OPACITY: 0.3;
+    readonly MIN_SEGMENT_LENGTH: 32;
+    readonly COLLINEAR_TOLERANCE: 1;
+    readonly ARROW_OFFSET: 8;
+    readonly STUB_OFFSET: number;
+};
+export declare const EDGE_PATH_TRANSITION = "stroke 0.2s ease, opacity 0.2s ease";
+export declare const EDGE_DASHARRAY: {
+    readonly solid: "0";
+    readonly dashed: "5,5";
+};
+export declare const EDGE_COLORS: {
+    readonly default: "var(--canvas-border)";
+    readonly hover: "var(--canvas-primary-hover)";
+    readonly selected: "var(--canvas-primary)";
+    readonly invalid: "var(--canvas-error-icon)";
+    readonly diffAdded: "var(--canvas-success-icon)";
+    readonly diffRemoved: "var(--canvas-error-icon)";
+};
+export declare const ARROW_ANGLE_MAP: Record<Position, number>;
+export declare const ARROW_OFFSETS: Record<Position, Point>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/canvas/components/Edges/shared/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Edges/shared/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAEpE,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI/C,eAAO,MAAM,eAAe,EAAE,QAAQ,EAAO,CAAC;AAE9C,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAiCjB,CAAC;AAGX,eAAO,MAAM,oBAAoB,wCAAwC,CAAC;AAG1E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAMX,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAC;AAOX,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAKpD,CAAC;AASF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,QAAQ,EAAE,KAAK,CAKjD,CAAC"}

package/dist/canvas/components/Edges/shared/constants.js

@@ -0,0 +1,55 @@
+import { Position } from "../../../xyflow/react.js";
+import { GRID_SPACING } from "../../../constants.js";
+const EMPTY_WAYPOINTS = [];
+const EDGE_CONSTANTS = {
+    BORDER_RADIUS: GRID_SPACING,
+    ARROW_SIZE: 10,
+    ARROW_HALF_ANGLE: Math.PI / 6,
+    STROKE_WIDTH: 2,
+    SELECTED_STROKE_WIDTH: 3,
+    INTERACTION_STROKE_WIDTH: 20,
+    SELECTED_OUTLINE_STROKE_WIDTH: 10,
+    SELECTED_OUTLINE_OPACITY: 0.3,
+    MIN_SEGMENT_LENGTH: 32,
+    COLLINEAR_TOLERANCE: 1,
+    ARROW_OFFSET: 8,
+    STUB_OFFSET: 2 * GRID_SPACING
+};
+const EDGE_PATH_TRANSITION = 'stroke 0.2s ease, opacity 0.2s ease';
+const EDGE_DASHARRAY = {
+    solid: '0',
+    dashed: '5,5'
+};
+const EDGE_COLORS = {
+    default: 'var(--canvas-border)',
+    hover: 'var(--canvas-primary-hover)',
+    selected: 'var(--canvas-primary)',
+    invalid: 'var(--canvas-error-icon)',
+    diffAdded: 'var(--canvas-success-icon)',
+    diffRemoved: 'var(--canvas-error-icon)'
+};
+const ARROW_ANGLE_MAP = {
+    [Position.Left]: 0,
+    [Position.Right]: Math.PI,
+    [Position.Top]: Math.PI / 2,
+    [Position.Bottom]: -Math.PI / 2
+};
+const ARROW_OFFSETS = {
+    [Position.Left]: {
+        x: EDGE_CONSTANTS.ARROW_OFFSET,
+        y: 0
+    },
+    [Position.Right]: {
+        x: -EDGE_CONSTANTS.ARROW_OFFSET,
+        y: 0
+    },
+    [Position.Top]: {
+        x: 0,
+        y: EDGE_CONSTANTS.ARROW_OFFSET
+    },
+    [Position.Bottom]: {
+        x: 0,
+        y: -EDGE_CONSTANTS.ARROW_OFFSET
+    }
+};
+export { ARROW_ANGLE_MAP, ARROW_OFFSETS, EDGE_COLORS, EDGE_CONSTANTS, EDGE_DASHARRAY, EDGE_PATH_TRANSITION, EMPTY_WAYPOINTS };

package/dist/canvas/components/Edges/shared/geometry.cjs

@@ -0,0 +1,489 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    snapPointToGrid: ()=>snapPointToGrid,
+    isSegmentPerpendicular: ()=>isSegmentPerpendicular,
+    calculateAutoWaypoints: ()=>calculateAutoWaypoints,
+    consolidateWaypoints: ()=>consolidateWaypoints,
+    getSegmentLength: ()=>getSegmentLength,
+    isSegmentInteractable: ()=>isSegmentInteractable,
+    getSegmentOrientation: ()=>getSegmentOrientation,
+    buildPathVertices: ()=>buildPathVertices,
+    createRoundedPath: ()=>createRoundedPath,
+    extractSegments: ()=>extractSegments,
+    getPathArcMidpoint: ()=>getPathArcMidpoint,
+    getSegmentMidpoint: ()=>getSegmentMidpoint,
+    isHorizontalPosition: ()=>isHorizontalPosition,
+    routeAnchorToPoint: ()=>routeAnchorToPoint
+});
+const NodeUtils_cjs_namespaceObject = require("../../../utils/NodeUtils.cjs");
+const external_constants_cjs_namespaceObject = require("./constants.cjs");
+const { BORDER_RADIUS, MIN_SEGMENT_LENGTH, COLLINEAR_TOLERANCE: TOL } = external_constants_cjs_namespaceObject.EDGE_CONSTANTS;
+function snapPointToGrid(point) {
+    return {
+        x: (0, NodeUtils_cjs_namespaceObject.snapToGrid)(point.x),
+        y: (0, NodeUtils_cjs_namespaceObject.snapToGrid)(point.y)
+    };
+}
+function getDirection(position) {
+    switch(position){
+        case 'left':
+            return {
+                dx: -1,
+                dy: 0
+            };
+        case 'right':
+            return {
+                dx: 1,
+                dy: 0
+            };
+        case 'top':
+            return {
+                dx: 0,
+                dy: -1
+            };
+        case 'bottom':
+            return {
+                dx: 0,
+                dy: 1
+            };
+        default:
+            return {
+                dx: 1,
+                dy: 0
+            };
+    }
+}
+function isHorizontalPosition(position) {
+    return 0 !== getDirection(position).dx;
+}
+function calculateAutoWaypoints(sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition) {
+    const sourceOffset = external_constants_cjs_namespaceObject.ARROW_OFFSETS[sourcePosition];
+    const targetOffset = external_constants_cjs_namespaceObject.ARROW_OFFSETS[targetPosition];
+    const startX = sourceX + sourceOffset.x;
+    const startY = sourceY + sourceOffset.y;
+    const endX = targetX + targetOffset.x;
+    const endY = targetY + targetOffset.y;
+    const isSourceHorizontal = isHorizontalPosition(sourcePosition);
+    const isTargetHorizontal = isHorizontalPosition(targetPosition);
+    const waypoints = [];
+    if (isSourceHorizontal && isTargetHorizontal) {
+        const midX = (0, NodeUtils_cjs_namespaceObject.snapToGrid)((startX + endX) / 2);
+        if (Math.abs(startY - endY) > MIN_SEGMENT_LENGTH / 2) {
+            waypoints.push({
+                x: midX,
+                y: startY
+            });
+            waypoints.push({
+                x: midX,
+                y: endY
+            });
+        }
+    } else if (isSourceHorizontal || isTargetHorizontal) if (isSourceHorizontal && !isTargetHorizontal) waypoints.push({
+        x: endX,
+        y: startY
+    });
+    else waypoints.push({
+        x: startX,
+        y: endY
+    });
+    else {
+        const midY = (0, NodeUtils_cjs_namespaceObject.snapToGrid)((startY + endY) / 2);
+        if (Math.abs(startX - endX) > MIN_SEGMENT_LENGTH / 2) {
+            waypoints.push({
+                x: startX,
+                y: midY
+            });
+            waypoints.push({
+                x: endX,
+                y: midY
+            });
+        }
+    }
+    return waypoints;
+}
+function routeAnchorToPoint(anchor, anchorPosition, point) {
+    const dir = getDirection(anchorPosition);
+    const isHorizontal = 0 !== dir.dx;
+    const forward = isHorizontal ? (point.x - anchor.x) * dir.dx : (point.y - anchor.y) * dir.dy;
+    let elbows;
+    if (forward >= 0) elbows = isHorizontal ? [
+        {
+            x: point.x,
+            y: anchor.y
+        }
+    ] : [
+        {
+            x: anchor.x,
+            y: point.y
+        }
+    ];
+    else {
+        const { STUB_OFFSET } = external_constants_cjs_namespaceObject.EDGE_CONSTANTS;
+        elbows = isHorizontal ? [
+            {
+                x: anchor.x + dir.dx * STUB_OFFSET,
+                y: anchor.y
+            },
+            {
+                x: anchor.x + dir.dx * STUB_OFFSET,
+                y: point.y
+            }
+        ] : [
+            {
+                x: anchor.x,
+                y: anchor.y + dir.dy * STUB_OFFSET
+            },
+            {
+                x: point.x,
+                y: anchor.y + dir.dy * STUB_OFFSET
+            }
+        ];
+    }
+    const result = [];
+    let prev = anchor;
+    for (const elbow of elbows){
+        const samePrev = Math.abs(elbow.x - prev.x) < TOL && Math.abs(elbow.y - prev.y) < TOL;
+        const samePoint = Math.abs(elbow.x - point.x) < TOL && Math.abs(elbow.y - point.y) < TOL;
+        if (!samePrev && !samePoint) {
+            result.push(elbow);
+            prev = elbow;
+        }
+    }
+    return result;
+}
+function connectorElbow(from, to, incoming) {
+    const alignedX = Math.abs(from.x - to.x) < TOL;
+    const alignedY = Math.abs(from.y - to.y) < TOL;
+    if (alignedX || alignedY) return null;
+    return 'horizontal' === incoming ? {
+        x: from.x,
+        y: to.y
+    } : {
+        x: to.x,
+        y: from.y
+    };
+}
+function buildPathVertices(sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition, waypoints = []) {
+    const sourceOffset = external_constants_cjs_namespaceObject.ARROW_OFFSETS[sourcePosition];
+    const targetOffset = external_constants_cjs_namespaceObject.ARROW_OFFSETS[targetPosition];
+    const start = {
+        x: sourceX + sourceOffset.x,
+        y: sourceY + sourceOffset.y
+    };
+    const end = {
+        x: targetX + targetOffset.x,
+        y: targetY + targetOffset.y
+    };
+    const derived = (p)=>({
+            x: p.x,
+            y: p.y,
+            waypointIndex: -1
+        });
+    if (0 === waypoints.length) {
+        const autoWaypoints = calculateAutoWaypoints(sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition);
+        return [
+            start,
+            ...autoWaypoints,
+            end
+        ].map(derived);
+    }
+    const startVertex = derived(start);
+    const endVertex = derived(end);
+    const path = [
+        startVertex
+    ];
+    for (const elbow of routeAnchorToPoint(start, sourcePosition, waypoints[0]))path.push(derived(elbow));
+    path.push({
+        x: waypoints[0].x,
+        y: waypoints[0].y,
+        waypointIndex: 0
+    });
+    for(let i = 1; i < waypoints.length; i++){
+        const from = path[path.length - 1];
+        const incoming = path.length >= 2 ? getSegmentOrientation(path[path.length - 2], from) : null;
+        const elbow = connectorElbow(from, waypoints[i], incoming);
+        if (elbow) path.push(derived(elbow));
+        path.push({
+            x: waypoints[i].x,
+            y: waypoints[i].y,
+            waypointIndex: i
+        });
+    }
+    const targetStub = routeAnchorToPoint(end, targetPosition, waypoints[waypoints.length - 1]);
+    for(let j = targetStub.length - 1; j >= 0; j--)path.push(derived(targetStub[j]));
+    const interior = consolidateWaypoints(path.slice(1), start, end, (v)=>v.waypointIndex >= 0);
+    return [
+        startVertex,
+        ...interior,
+        endVertex
+    ];
+}
+function consolidateWaypoints(points, pathStart, pathEnd, isProtected = ()=>false) {
+    let current = points;
+    let changed = true;
+    while(changed && current.length > 0){
+        changed = false;
+        const before = current.length;
+        if (current.length > 1) {
+            const deduped = [
+                current[0]
+            ];
+            for(let i = 1; i < current.length; i++){
+                const prev = deduped[deduped.length - 1];
+                const curr = current[i];
+                if (Math.abs(curr.x - prev.x) > TOL || Math.abs(curr.y - prev.y) > TOL) deduped.push(curr);
+                else if (isProtected(curr) && !isProtected(prev)) deduped[deduped.length - 1] = curr;
+            }
+            current = deduped;
+        }
+        if (current.length > 2) {
+            const result = [
+                current[0]
+            ];
+            for(let i = 1; i < current.length - 1; i++){
+                const prev = result[result.length - 1];
+                const curr = current[i];
+                const next = current[i + 1];
+                const horizontalLine = Math.abs(prev.y - curr.y) <= TOL && Math.abs(curr.y - next.y) <= TOL;
+                const verticalLine = Math.abs(prev.x - curr.x) <= TOL && Math.abs(curr.x - next.x) <= TOL;
+                if (!horizontalLine && !verticalLine || isProtected(curr)) result.push(curr);
+            }
+            result.push(current[current.length - 1]);
+            current = result;
+        }
+        if (current.length >= 2) {
+            const first = current[0];
+            const second = current[1];
+            const collinearH = Math.abs(pathStart.y - first.y) <= TOL && Math.abs(first.y - second.y) <= TOL;
+            const collinearV = Math.abs(pathStart.x - first.x) <= TOL && Math.abs(first.x - second.x) <= TOL;
+            if ((collinearH || collinearV) && !isProtected(first)) current = current.slice(1);
+        }
+        if (current.length >= 2) {
+            const last = current[current.length - 1];
+            const secondLast = current[current.length - 2];
+            const collinearH = Math.abs(secondLast.y - last.y) <= TOL && Math.abs(last.y - pathEnd.y) <= TOL;
+            const collinearV = Math.abs(secondLast.x - last.x) <= TOL && Math.abs(last.x - pathEnd.x) <= TOL;
+            if ((collinearH || collinearV) && !isProtected(last)) current = current.slice(0, -1);
+        }
+        if (1 === current.length) {
+            const wp = current[0];
+            const collinearH = Math.abs(pathStart.y - wp.y) <= TOL && Math.abs(wp.y - pathEnd.y) <= TOL;
+            const collinearV = Math.abs(pathStart.x - wp.x) <= TOL && Math.abs(wp.x - pathEnd.x) <= TOL;
+            if ((collinearH || collinearV) && !isProtected(wp)) current = [];
+        }
+        if (current.length >= 2) {
+            const cleaned = [];
+            for(let i = 0; i < current.length; i++){
+                const curr = current[i];
+                const prev = cleaned[cleaned.length - 1];
+                const next = current[i + 1];
+                if (!isProtected(curr)) {
+                    if (prev && Math.abs(curr.x - prev.x) <= TOL && Math.abs(curr.y - prev.y) <= TOL) continue;
+                    if (next && Math.abs(curr.x - next.x) <= TOL && Math.abs(curr.y - next.y) <= TOL) continue;
+                }
+                cleaned.push(curr);
+            }
+            current = cleaned;
+        }
+        changed = current.length !== before;
+    }
+    return current;
+}
+function getSegmentOrientation(start, end) {
+    return Math.abs(end.x - start.x) > Math.abs(end.y - start.y) ? 'horizontal' : 'vertical';
+}
+function isSegmentPerpendicular(segment) {
+    const dx = Math.abs(segment.end.x - segment.start.x);
+    const dy = Math.abs(segment.end.y - segment.start.y);
+    return dx < TOL || dy < TOL;
+}
+function extractSegments(pathPoints) {
+    const segments = [];
+    const interiorCount = Math.max(0, pathPoints.length - 2);
+    for(let i = 0; i < pathPoints.length - 1; i++){
+        const start = pathPoints[i];
+        const end = pathPoints[i + 1];
+        segments.push({
+            id: `seg-${i}`,
+            start: {
+                x: start.x,
+                y: start.y
+            },
+            end: {
+                x: end.x,
+                y: end.y
+            },
+            orientation: getSegmentOrientation(start, end),
+            waypointIndexBefore: i - 1,
+            waypointIndexAfter: i < interiorCount ? i : interiorCount
+        });
+    }
+    return segments;
+}
+function createRoundedPath(points, borderRadius = BORDER_RADIUS) {
+    if (points.length < 2) return '';
+    const firstPoint = points[0];
+    const path = [
+        `M ${firstPoint.x} ${firstPoint.y}`
+    ];
+    if (2 === points.length) {
+        const secondPoint = points[1];
+        path.push(`L ${secondPoint.x} ${secondPoint.y}`);
+        return path.join(' ');
+    }
+    for(let i = 1; i < points.length - 1; i++){
+        const prev = points[i - 1];
+        const curr = points[i];
+        const next = points[i + 1];
+        const v1 = {
+            x: curr.x - prev.x,
+            y: curr.y - prev.y
+        };
+        const v2 = {
+            x: next.x - curr.x,
+            y: next.y - curr.y
+        };
+        const len1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
+        const len2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
+        const radius = Math.min(borderRadius, Math.min(len1, len2) / 2);
+        if (radius < 1) {
+            path.push(`L ${curr.x} ${curr.y}`);
+            continue;
+        }
+        const n1 = {
+            x: v1.x / len1,
+            y: v1.y / len1
+        };
+        const n2 = {
+            x: v2.x / len2,
+            y: v2.y / len2
+        };
+        const cornerStart = {
+            x: curr.x - n1.x * radius,
+            y: curr.y - n1.y * radius
+        };
+        const cornerEnd = {
+            x: curr.x + n2.x * radius,
+            y: curr.y + n2.y * radius
+        };
+        path.push(`L ${cornerStart.x} ${cornerStart.y}`);
+        path.push(`Q ${curr.x} ${curr.y} ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const lastPoint = points[points.length - 1];
+    path.push(`L ${lastPoint.x} ${lastPoint.y}`);
+    return path.join(' ');
+}
+function getSegmentMidpoint(segment) {
+    return {
+        x: (segment.start.x + segment.end.x) / 2,
+        y: (segment.start.y + segment.end.y) / 2
+    };
+}
+function getSegmentLength(segment) {
+    const dx = segment.end.x - segment.start.x;
+    const dy = segment.end.y - segment.start.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+function isSegmentInteractable(segment) {
+    return getSegmentLength(segment) >= MIN_SEGMENT_LENGTH;
+}
+function getPathArcMidpoint(points) {
+    if (0 === points.length) return {
+        x: 0,
+        y: 0
+    };
+    if (1 === points.length) return {
+        x: points[0].x,
+        y: points[0].y
+    };
+    const lengths = [];
+    let total = 0;
+    for(let i = 0; i < points.length - 1; i++){
+        const dx = points[i + 1].x - points[i].x;
+        const dy = points[i + 1].y - points[i].y;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        lengths.push(len);
+        total += len;
+    }
+    if (0 === total) return {
+        x: points[0].x,
+        y: points[0].y
+    };
+    const target = total / 2;
+    let acc = 0;
+    for(let i = 0; i < lengths.length; i++){
+        const segLen = lengths[i];
+        if (acc + segLen >= target) {
+            const t = (target - acc) / segLen;
+            const start = points[i];
+            const end = points[i + 1];
+            return {
+                x: start.x + t * (end.x - start.x),
+                y: start.y + t * (end.y - start.y)
+            };
+        }
+        acc += segLen;
+    }
+    const last = points[points.length - 1];
+    return {
+        x: last.x,
+        y: last.y
+    };
+}
+exports.buildPathVertices = __webpack_exports__.buildPathVertices;
+exports.calculateAutoWaypoints = __webpack_exports__.calculateAutoWaypoints;
+exports.consolidateWaypoints = __webpack_exports__.consolidateWaypoints;
+exports.createRoundedPath = __webpack_exports__.createRoundedPath;
+exports.extractSegments = __webpack_exports__.extractSegments;
+exports.getPathArcMidpoint = __webpack_exports__.getPathArcMidpoint;
+exports.getSegmentLength = __webpack_exports__.getSegmentLength;
+exports.getSegmentMidpoint = __webpack_exports__.getSegmentMidpoint;
+exports.getSegmentOrientation = __webpack_exports__.getSegmentOrientation;
+exports.isHorizontalPosition = __webpack_exports__.isHorizontalPosition;
+exports.isSegmentInteractable = __webpack_exports__.isSegmentInteractable;
+exports.isSegmentPerpendicular = __webpack_exports__.isSegmentPerpendicular;
+exports.routeAnchorToPoint = __webpack_exports__.routeAnchorToPoint;
+exports.snapPointToGrid = __webpack_exports__.snapPointToGrid;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildPathVertices",
+    "calculateAutoWaypoints",
+    "consolidateWaypoints",
+    "createRoundedPath",
+    "extractSegments",
+    "getPathArcMidpoint",
+    "getSegmentLength",
+    "getSegmentMidpoint",
+    "getSegmentOrientation",
+    "isHorizontalPosition",
+    "isSegmentInteractable",
+    "isSegmentPerpendicular",
+    "routeAnchorToPoint",
+    "snapPointToGrid"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});