@uipath/apollo-react 4.45.0 → 4.46.0

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
+});

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

@@ -0,0 +1,20 @@
+import type { Position } from '../../../xyflow/react.ts';
+import type { PathVertex, Point, Segment, SegmentOrientation, Waypoint } from './types';
+export declare function snapPointToGrid(point: Point): Point;
+export declare function isHorizontalPosition(position: Position): boolean;
+export declare function calculateAutoWaypoints(sourceX: number, sourceY: number, sourcePosition: Position, targetX: number, targetY: number, targetPosition: Position): Point[];
+export declare function routeAnchorToPoint(anchor: Point, anchorPosition: Position, point: Point): Point[];
+export declare function buildPathVertices(sourceX: number, sourceY: number, sourcePosition: Position, targetX: number, targetY: number, targetPosition: Position, waypoints?: Waypoint[]): PathVertex[];
+export declare function consolidateWaypoints<T extends Point>(points: T[], pathStart: Point, pathEnd: Point, isProtected?: (point: T) => boolean): T[];
+export declare function getSegmentOrientation(start: Point, end: Point): SegmentOrientation;
+export declare function isSegmentPerpendicular(segment: {
+    start: Point;
+    end: Point;
+}): boolean;
+export declare function extractSegments(pathPoints: PathVertex[]): Segment[];
+export declare function createRoundedPath(points: Point[], borderRadius?: number): string;
+export declare function getSegmentMidpoint(segment: Segment): Point;
+export declare function getSegmentLength(segment: Segment): number;
+export declare function isSegmentInteractable(segment: Segment): boolean;
+export declare function getPathArcMidpoint(points: Point[]): Point;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Edges/shared/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAGzE,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxF,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAEnD;AAmBD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAEhE;AAMD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,QAAQ,GACvB,KAAK,EAAE,CAiCT;AAyBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,CAoCjG;AAkCD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,QAAQ,EACxB,SAAS,GAAE,QAAQ,EAAO,GACzB,UAAU,EAAE,CAwDd;AAiBD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,KAAK,EAClD,MAAM,EAAE,CAAC,EAAE,EACX,SAAS,EAAE,KAAK,EAChB,OAAO,EAAE,KAAK,EACd,WAAW,GAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAqB,GAC/C,CAAC,EAAE,CAsFL;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,kBAAkB,CAElF;AAKD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,KAAK,CAAA;CAAE,GAAG,OAAO,CAIrF;AAUD,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,CAgBnE;AAMD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,MAAsB,GAAG,MAAM,CAyC/F;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,CAK1D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAIzD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE/D;AAOD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAkCzD"}