@uipath/apollo-react 4.45.1 → 4.46.0

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

@@ -0,0 +1,158 @@
+import { snapToGrid } from "../../../utils/NodeUtils.js";
+import { EDGE_CONSTANTS } from "./constants.js";
+import { consolidateWaypoints, isHorizontalPosition, snapPointToGrid } from "./geometry.js";
+function materializePathWaypoints(vertices, stored) {
+    return vertices.slice(1, -1).map((vertex)=>{
+        const existing = vertex.waypointIndex >= 0 ? stored[vertex.waypointIndex] : void 0;
+        return existing ?? {
+            id: generateWaypointId(),
+            x: vertex.x,
+            y: vertex.y
+        };
+    });
+}
+function generateWaypointId() {
+    return `wp-${crypto.randomUUID()}`;
+}
+function waypointsEqual(a, b) {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++){
+        const wa = a[i];
+        const wb = b[i];
+        if (wa.x !== wb.x || wa.y !== wb.y || wa.id !== wb.id) return false;
+    }
+    return true;
+}
+function waypointsPositionallyEqual(a, b) {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++)if (a[i].x !== b[i].x || a[i].y !== b[i].y) return false;
+    return true;
+}
+function insertWaypoint(vertices, stored, segmentIndex, position) {
+    const newWaypoint = {
+        id: generateWaypointId(),
+        ...snapPointToGrid(position)
+    };
+    const materialized = materializePathWaypoints(vertices, stored);
+    materialized.splice(Math.max(0, segmentIndex), 0, newWaypoint);
+    return materialized;
+}
+function removeWaypoint(waypoints, index) {
+    return waypoints.filter((_, i)=>i !== index);
+}
+const REBALANCE_EPSILON = 0.5;
+function rebalanceWaypoints(waypoints, source, target) {
+    if (0 === waypoints.length) return waypoints;
+    const sourceDelta = waypoints_delta(source);
+    const targetDelta = waypoints_delta(target);
+    if (isMoved(sourceDelta) && deltasEqual(sourceDelta, targetDelta)) return waypoints.map((w)=>({
+            id: w.id,
+            x: w.x + sourceDelta.x,
+            y: w.y + sourceDelta.y
+        }));
+    const next = waypoints.map((w)=>({
+            ...w
+        }));
+    if (1 === next.length) {
+        const sourceMoved = isMoved(sourceDelta);
+        const targetMoved = isMoved(targetDelta);
+        if (sourceMoved && !targetMoved) shiftAdjacentWaypoint(next[0], source);
+        else if (targetMoved && !sourceMoved) shiftAdjacentWaypoint(next[0], target);
+        return next;
+    }
+    shiftAdjacentWaypoint(next[0], source);
+    shiftAdjacentWaypoint(next[next.length - 1], target);
+    return next;
+}
+function waypoints_delta(endpoint) {
+    return {
+        x: endpoint.to.x - endpoint.from.x,
+        y: endpoint.to.y - endpoint.from.y
+    };
+}
+function isMoved(d) {
+    return Math.abs(d.x) >= REBALANCE_EPSILON || Math.abs(d.y) >= REBALANCE_EPSILON;
+}
+function deltasEqual(a, b) {
+    return Math.abs(a.x - b.x) < REBALANCE_EPSILON && Math.abs(a.y - b.y) < REBALANCE_EPSILON;
+}
+function shiftAdjacentWaypoint(waypoint, endpoint) {
+    if (isHorizontalPosition(endpoint.position)) waypoint.y += endpoint.to.y - endpoint.from.y;
+    else waypoint.x += endpoint.to.x - endpoint.from.x;
+}
+function moveWaypoint(waypoints, index, newPosition) {
+    const snapped = snapPointToGrid(newPosition);
+    return waypoints.map((wp, i)=>i === index ? {
+            ...wp,
+            ...snapped
+        } : wp);
+}
+function moveSegmentByDelta(initialWaypoints, initialSegment, delta, initialPathPoints) {
+    const moveAxis = 'horizontal' === initialSegment.orientation ? 'y' : 'x';
+    const moveValue = 'y' === moveAxis ? delta.y : delta.x;
+    const working = initialWaypoints.map((wp)=>({
+            ...wp
+        }));
+    const isConnectedToSource = initialSegment.waypointIndexBefore < 0;
+    const isConnectedToTarget = initialSegment.waypointIndexAfter >= working.length;
+    let insertedAtStart = false;
+    const stubOffset = EDGE_CONSTANTS.STUB_OFFSET;
+    const orientation = initialSegment.orientation;
+    const segmentStart = initialSegment.start;
+    const segmentEnd = initialSegment.end;
+    const pathSource = initialPathPoints[0];
+    const pathTarget = initialPathPoints[initialPathPoints.length - 1];
+    const movedCoordinate = 'horizontal' === orientation ? snapToGrid(segmentStart.y + moveValue) : snapToGrid(segmentStart.x + moveValue);
+    if (isConnectedToSource) {
+        const stubCoord = snapToGrid(('horizontal' === orientation ? segmentStart.x : segmentStart.y) + stubOffset);
+        const [anchorStub, movedStub] = makeStubPair(segmentStart, orientation, stubCoord, movedCoordinate);
+        working.unshift(anchorStub, movedStub);
+        insertedAtStart = true;
+    }
+    if (isConnectedToTarget) {
+        const stubCoord = snapToGrid(('horizontal' === orientation ? segmentEnd.x : segmentEnd.y) - stubOffset);
+        const [anchorStub, movedStub] = makeStubPair(segmentEnd, orientation, stubCoord, movedCoordinate);
+        working.push(movedStub, anchorStub);
+    }
+    const indexOffset = insertedAtStart ? 2 : 0;
+    if (!isConnectedToSource && initialSegment.waypointIndexBefore >= 0) {
+        const idx = initialSegment.waypointIndexBefore + indexOffset;
+        const wp = working[idx];
+        if (wp) wp[moveAxis] = movedCoordinate;
+    }
+    if (!isConnectedToTarget && initialSegment.waypointIndexAfter < initialWaypoints.length) {
+        const idx = initialSegment.waypointIndexAfter + indexOffset;
+        const wp = working[idx];
+        if (wp) wp[moveAxis] = movedCoordinate;
+    }
+    return consolidateWaypoints(working, pathSource, pathTarget);
+}
+function makeStubPair(anchor, orientation, stubCoord, movedCoordinate) {
+    if ('horizontal' === orientation) return [
+        {
+            id: generateWaypointId(),
+            x: stubCoord,
+            y: anchor.y
+        },
+        {
+            id: generateWaypointId(),
+            x: stubCoord,
+            y: movedCoordinate
+        }
+    ];
+    return [
+        {
+            id: generateWaypointId(),
+            x: anchor.x,
+            y: stubCoord
+        },
+        {
+            id: generateWaypointId(),
+            x: movedCoordinate,
+            y: stubCoord
+        }
+    ];
+}
+export { generateWaypointId, insertWaypoint, materializePathWaypoints, moveSegmentByDelta, moveWaypoint, rebalanceWaypoints, removeWaypoint, waypointsEqual, waypointsPositionallyEqual };

package/dist/canvas/hooks/useEdgePath.cjs

@@ -28,32 +28,16 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const react_cjs_namespaceObject = require("../xyflow/react.cjs");
 const external_react_namespaceObject = require("react");
+const constants_cjs_namespaceObject = require("../components/Edges/shared/constants.cjs");
 const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const NodeUtils_cjs_namespaceObject = require("../utils/NodeUtils.cjs");
 const LOOP_HEIGHT = 6 * external_constants_cjs_namespaceObject.GRID_SPACING;
 const LOOP_SUCCESS_HEIGHT = 7 * external_constants_cjs_namespaceObject.GRID_SPACING;
 const LOOP_RIGHT_EXTENSION = 3 * external_constants_cjs_namespaceObject.GRID_SPACING;
 const LOOP_SUCCESS_RIGHT_EXTENSION = 4 * external_constants_cjs_namespaceObject.GRID_SPACING;
 const LOOP_LEFT_EXTENSION = 2 * external_constants_cjs_namespaceObject.GRID_SPACING;
 const LOOP_CORNER_RADIUS = external_constants_cjs_namespaceObject.GRID_SPACING;
-const SOURCE_OFFSETS = {
-    [react_cjs_namespaceObject.Position.Left]: {
-        x: 8,
-        y: 0
-    },
-    [react_cjs_namespaceObject.Position.Right]: {
-        x: -8,
-        y: 0
-    },
-    [react_cjs_namespaceObject.Position.Top]: {
-        x: 0,
-        y: 8
-    },
-    [react_cjs_namespaceObject.Position.Bottom]: {
-        x: 0,
-        y: -8
-    }
-};
-const snapToGrid = (value)=>Math.round(value / external_constants_cjs_namespaceObject.GRID_SPACING) * external_constants_cjs_namespaceObject.GRID_SPACING;
+const SOURCE_OFFSETS = constants_cjs_namespaceObject.ARROW_OFFSETS;
 const createLoopPath = ({ sourceX, sourceY, sourcePosition, targetX, targetY, sourceHandleId })=>{
     const offsets = SOURCE_OFFSETS[sourcePosition];
     const sourceOffsetX = sourceX + offsets.x;
@@ -61,8 +45,8 @@ const createLoopPath = ({ sourceX, sourceY, sourcePosition, targetX, targetY, so
     const loopHeight = 'success' === sourceHandleId ? LOOP_SUCCESS_HEIGHT : LOOP_HEIGHT;
     const bottomY = Math.max(sourceOffsetY, targetY) + loopHeight;
     const rightExtension = 'success' === sourceHandleId ? LOOP_SUCCESS_RIGHT_EXTENSION : LOOP_RIGHT_EXTENSION;
-    const rightPoint = snapToGrid(sourceX + rightExtension);
-    const leftPoint = snapToGrid(targetX - LOOP_LEFT_EXTENSION);
+    const rightPoint = (0, NodeUtils_cjs_namespaceObject.snapToGrid)(sourceX + rightExtension);
+    const leftPoint = (0, NodeUtils_cjs_namespaceObject.snapToGrid)(targetX - LOOP_LEFT_EXTENSION);
     const path = `
     M ${sourceOffsetX} ${sourceOffsetY}
     L ${rightPoint - LOOP_CORNER_RADIUS} ${sourceOffsetY}
@@ -116,7 +100,7 @@ function useEdgePath({ sourceNodeId, sourceHandleId, sourceX, sourceY, sourcePos
                 targetX,
                 targetY,
                 targetPosition,
-                borderRadius: 16
+                borderRadius: constants_cjs_namespaceObject.EDGE_CONSTANTS.BORDER_RADIUS
             });
         }
         return {

package/dist/canvas/hooks/useEdgePath.d.ts

@@ -1,4 +1,4 @@
-import { Position } from '../xyflow/react.ts';
+import { type Position } from '../xyflow/react.ts';
 export interface EdgePathParams {
     sourceNodeId: string;
     sourceHandleId: string | null | undefined;

package/dist/canvas/hooks/useEdgePath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEdgePath.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/useEdgePath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAgEvF,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,QAAQ,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,QAAQ,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAoBD,wBAAgB,WAAW,CAAC,EAC1B,YAAY,EACZ,cAAc,EACd,OAAO,EACP,OAAO,EACP,cAAc,EACd,YAAY,EACZ,cAAc,EACd,OAAO,EACP,OAAO,EACP,cAAc,GACf,EAAE,cAAc,GAAG,aAAa,CAkEhC"}
+{"version":3,"file":"useEdgePath.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/useEdgePath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAyD5F,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,QAAQ,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,QAAQ,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAoBD,wBAAgB,WAAW,CAAC,EAC1B,YAAY,EACZ,cAAc,EACd,OAAO,EACP,OAAO,EACP,cAAc,EACd,YAAY,EACZ,cAAc,EACd,OAAO,EACP,OAAO,EACP,cAAc,GACf,EAAE,cAAc,GAAG,aAAa,CAkEhC"}

package/dist/canvas/hooks/useEdgePath.js

@@ -1,31 +1,15 @@
-import { Position, getSmoothStepPath } from "../xyflow/react.js";
+import { getSmoothStepPath } from "../xyflow/react.js";
 import { useMemo } from "react";
+import { ARROW_OFFSETS, EDGE_CONSTANTS } from "../components/Edges/shared/constants.js";
 import { GRID_SPACING } from "../constants.js";
+import { snapToGrid } from "../utils/NodeUtils.js";
 const LOOP_HEIGHT = 6 * GRID_SPACING;
 const LOOP_SUCCESS_HEIGHT = 7 * GRID_SPACING;
 const LOOP_RIGHT_EXTENSION = 3 * GRID_SPACING;
 const LOOP_SUCCESS_RIGHT_EXTENSION = 4 * GRID_SPACING;
 const LOOP_LEFT_EXTENSION = 2 * GRID_SPACING;
 const LOOP_CORNER_RADIUS = GRID_SPACING;
-const SOURCE_OFFSETS = {
-    [Position.Left]: {
-        x: 8,
-        y: 0
-    },
-    [Position.Right]: {
-        x: -8,
-        y: 0
-    },
-    [Position.Top]: {
-        x: 0,
-        y: 8
-    },
-    [Position.Bottom]: {
-        x: 0,
-        y: -8
-    }
-};
-const snapToGrid = (value)=>Math.round(value / GRID_SPACING) * GRID_SPACING;
+const SOURCE_OFFSETS = ARROW_OFFSETS;
 const createLoopPath = ({ sourceX, sourceY, sourcePosition, targetX, targetY, sourceHandleId })=>{
     const offsets = SOURCE_OFFSETS[sourcePosition];
     const sourceOffsetX = sourceX + offsets.x;
@@ -88,7 +72,7 @@ function useEdgePath({ sourceNodeId, sourceHandleId, sourceX, sourceY, sourcePos
                 targetX,
                 targetY,
                 targetPosition,
-                borderRadius: 16
+                borderRadius: EDGE_CONSTANTS.BORDER_RADIUS
             });
         }
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/apollo-react",
-  "version": "4.45.1",
+  "version": "4.46.0",
   "description": "Apollo Design System - React component library with Material UI theming",
   "repository": {
     "type": "git",