@uipath/apollo-react 4.45.1 → 4.46.0

package/dist/canvas/components/Edges/shared/routing/useGraphRouter.cjs

@@ -0,0 +1,175 @@
+"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__, {
+    useGraphRouter: ()=>useGraphRouter,
+    defaultIsRoutable: ()=>defaultIsRoutable
+});
+const react_cjs_namespaceObject = require("../../../../xyflow/react.cjs");
+const external_react_namespaceObject = require("react");
+const container_cjs_namespaceObject = require("../../../../utils/container.cjs");
+const external_waypoints_cjs_namespaceObject = require("../waypoints.cjs");
+function defaultIsRoutable(edge) {
+    const data = edge.data;
+    return data?.routing === 'waypoint' && !data.waypoints?.length;
+}
+function useGraphRouter(router, isRoutable = defaultIsRoutable) {
+    const { getNodes, getEdges, setEdges } = (0, react_cjs_namespaceObject.useReactFlow)();
+    const signature = (0, react_cjs_namespaceObject.useStore)((0, external_react_namespaceObject.useCallback)((state)=>routeSignature(state, isRoutable), [
+        isRoutable
+    ]));
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!signature) return;
+        let cancelled = false;
+        const apply = (routes)=>{
+            if (cancelled) return;
+            const byId = new Map(routes.map((r)=>[
+                    r.edgeId,
+                    r
+                ]));
+            setEdges((current)=>{
+                let next = null;
+                for(let i = 0; i < current.length; i++){
+                    const edge = current[i];
+                    const reconciled = reconcileEdge(edge, byId, isRoutable);
+                    if (reconciled !== edge) {
+                        next ??= [
+                            ...current
+                        ];
+                        next[i] = reconciled;
+                    }
+                }
+                return next ?? current;
+            });
+        };
+        const edges = getEdges();
+        if (!edges.some(isRoutable)) {
+            const hasStale = edges.some((edge)=>edge.data?.routedWaypoints !== void 0);
+            if (hasStale) apply([]);
+            return;
+        }
+        const request = buildRequest(getNodes(), edges, isRoutable);
+        if (0 === request.edges.length) return void apply([]);
+        const result = router.route(request);
+        if (result instanceof Promise) result.then(apply).catch((err)=>{
+            if (cancelled) return;
+            console.error('[useGraphRouter] router.route() rejected:', err);
+        });
+        else apply(result);
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        signature,
+        router,
+        isRoutable,
+        getNodes,
+        getEdges,
+        setEdges
+    ]);
+}
+function reconcileEdge(edge, routesById, isRoutable) {
+    const data = edge.data;
+    if (!isRoutable(edge)) {
+        if (data?.routedWaypoints === void 0) return edge;
+        const { routedWaypoints: _removed, ...rest } = data;
+        return {
+            ...edge,
+            data: rest
+        };
+    }
+    const route = routesById.get(edge.id);
+    if (!route) return edge;
+    const prev = data?.routedWaypoints ?? [];
+    if ((0, external_waypoints_cjs_namespaceObject.waypointsPositionallyEqual)(prev, route.waypoints)) return edge;
+    return {
+        ...edge,
+        data: {
+            ...edge.data,
+            routedWaypoints: route.waypoints
+        }
+    };
+}
+function routeSignature(state, isRoutable) {
+    let sig = '';
+    for (const node of state.nodes){
+        const { width, height } = (0, container_cjs_namespaceObject.getNodeDimensions)(node);
+        sig += `${node.id}:${node.position.x},${node.position.y},${width},${height}|`;
+    }
+    for (const edge of state.edges)sig += `${edge.id}:${edge.source}/${edge.sourceHandle ?? ''}>${edge.target}/${edge.targetHandle ?? ''}:${isRoutable(edge) ? 'r' : 'm'}|`;
+    return sig;
+}
+function buildRequest(nodes, edges, isRoutable) {
+    const routeNodes = nodes.map((n)=>{
+        const { width, height } = (0, container_cjs_namespaceObject.getNodeDimensions)(n);
+        return {
+            id: n.id,
+            x: n.position.x,
+            y: n.position.y,
+            width,
+            height
+        };
+    });
+    const nodeMap = new Map(routeNodes.map((n)=>[
+            n.id,
+            n
+        ]));
+    const routeEdges = [];
+    for (const edge of edges){
+        if (!isRoutable(edge)) continue;
+        const source = nodeMap.get(edge.source);
+        const target = nodeMap.get(edge.target);
+        if (source && target) routeEdges.push({
+            edgeId: edge.id,
+            source: {
+                nodeId: edge.source,
+                handleId: edge.sourceHandle ?? null,
+                x: source.x + source.width,
+                y: source.y + source.height / 2,
+                position: react_cjs_namespaceObject.Position.Right
+            },
+            target: {
+                nodeId: edge.target,
+                handleId: edge.targetHandle ?? null,
+                x: target.x,
+                y: target.y + target.height / 2,
+                position: react_cjs_namespaceObject.Position.Left
+            }
+        });
+    }
+    return {
+        nodes: routeNodes,
+        edges: routeEdges
+    };
+}
+exports.defaultIsRoutable = __webpack_exports__.defaultIsRoutable;
+exports.useGraphRouter = __webpack_exports__.useGraphRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defaultIsRoutable",
+    "useGraphRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/routing/useGraphRouter.d.ts

@@ -0,0 +1,5 @@
+import { type Edge } from '../../../../xyflow/react.ts';
+import type { EdgeRouter } from './types';
+export declare function defaultIsRoutable(edge: Edge): boolean;
+export declare function useGraphRouter(router: EdgeRouter, isRoutable?: (edge: Edge) => boolean): void;
+//# sourceMappingURL=useGraphRouter.d.ts.map

package/dist/canvas/components/Edges/shared/routing/useGraphRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGraphRouter.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/routing/useGraphRouter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAMV,MAAM,0CAA0C,CAAC;AAKlD,OAAO,KAAK,EACV,UAAU,EAKX,MAAM,SAAS,CAAC;AAoBjB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAGrD;AA+BD,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,UAAU,GAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAA2B,GACtD,IAAI,CAmEN"}

package/dist/canvas/components/Edges/shared/routing/useGraphRouter.js

@@ -0,0 +1,138 @@
+import { Position, useReactFlow, useStore } from "../../../../xyflow/react.js";
+import { useCallback, useEffect } from "react";
+import { getNodeDimensions } from "../../../../utils/container.js";
+import { waypointsPositionallyEqual } from "../waypoints.js";
+function defaultIsRoutable(edge) {
+    const data = edge.data;
+    return data?.routing === 'waypoint' && !data.waypoints?.length;
+}
+function useGraphRouter(router, isRoutable = defaultIsRoutable) {
+    const { getNodes, getEdges, setEdges } = useReactFlow();
+    const signature = useStore(useCallback((state)=>routeSignature(state, isRoutable), [
+        isRoutable
+    ]));
+    useEffect(()=>{
+        if (!signature) return;
+        let cancelled = false;
+        const apply = (routes)=>{
+            if (cancelled) return;
+            const byId = new Map(routes.map((r)=>[
+                    r.edgeId,
+                    r
+                ]));
+            setEdges((current)=>{
+                let next = null;
+                for(let i = 0; i < current.length; i++){
+                    const edge = current[i];
+                    const reconciled = reconcileEdge(edge, byId, isRoutable);
+                    if (reconciled !== edge) {
+                        next ??= [
+                            ...current
+                        ];
+                        next[i] = reconciled;
+                    }
+                }
+                return next ?? current;
+            });
+        };
+        const edges = getEdges();
+        if (!edges.some(isRoutable)) {
+            const hasStale = edges.some((edge)=>edge.data?.routedWaypoints !== void 0);
+            if (hasStale) apply([]);
+            return;
+        }
+        const request = buildRequest(getNodes(), edges, isRoutable);
+        if (0 === request.edges.length) return void apply([]);
+        const result = router.route(request);
+        if (result instanceof Promise) result.then(apply).catch((err)=>{
+            if (cancelled) return;
+            console.error('[useGraphRouter] router.route() rejected:', err);
+        });
+        else apply(result);
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        signature,
+        router,
+        isRoutable,
+        getNodes,
+        getEdges,
+        setEdges
+    ]);
+}
+function reconcileEdge(edge, routesById, isRoutable) {
+    const data = edge.data;
+    if (!isRoutable(edge)) {
+        if (data?.routedWaypoints === void 0) return edge;
+        const { routedWaypoints: _removed, ...rest } = data;
+        return {
+            ...edge,
+            data: rest
+        };
+    }
+    const route = routesById.get(edge.id);
+    if (!route) return edge;
+    const prev = data?.routedWaypoints ?? [];
+    if (waypointsPositionallyEqual(prev, route.waypoints)) return edge;
+    return {
+        ...edge,
+        data: {
+            ...edge.data,
+            routedWaypoints: route.waypoints
+        }
+    };
+}
+function routeSignature(state, isRoutable) {
+    let sig = '';
+    for (const node of state.nodes){
+        const { width, height } = getNodeDimensions(node);
+        sig += `${node.id}:${node.position.x},${node.position.y},${width},${height}|`;
+    }
+    for (const edge of state.edges)sig += `${edge.id}:${edge.source}/${edge.sourceHandle ?? ''}>${edge.target}/${edge.targetHandle ?? ''}:${isRoutable(edge) ? 'r' : 'm'}|`;
+    return sig;
+}
+function buildRequest(nodes, edges, isRoutable) {
+    const routeNodes = nodes.map((n)=>{
+        const { width, height } = getNodeDimensions(n);
+        return {
+            id: n.id,
+            x: n.position.x,
+            y: n.position.y,
+            width,
+            height
+        };
+    });
+    const nodeMap = new Map(routeNodes.map((n)=>[
+            n.id,
+            n
+        ]));
+    const routeEdges = [];
+    for (const edge of edges){
+        if (!isRoutable(edge)) continue;
+        const source = nodeMap.get(edge.source);
+        const target = nodeMap.get(edge.target);
+        if (source && target) routeEdges.push({
+            edgeId: edge.id,
+            source: {
+                nodeId: edge.source,
+                handleId: edge.sourceHandle ?? null,
+                x: source.x + source.width,
+                y: source.y + source.height / 2,
+                position: Position.Right
+            },
+            target: {
+                nodeId: edge.target,
+                handleId: edge.targetHandle ?? null,
+                x: target.x,
+                y: target.y + target.height / 2,
+                position: Position.Left
+            }
+        });
+    }
+    return {
+        nodes: routeNodes,
+        edges: routeEdges
+    };
+}
+export { defaultIsRoutable, useGraphRouter };

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,36 @@
+import type { Edge, EdgeProps, XYPosition } from '../../../xyflow/react.ts';
+export type Point = XYPosition;
+export type Waypoint = Point & {
+    id: string;
+};
+export type PathVertex = Point & {
+    waypointIndex: number;
+};
+export type SegmentOrientation = 'horizontal' | 'vertical';
+export type Segment = {
+    id: string;
+    start: Point;
+    end: Point;
+    orientation: SegmentOrientation;
+    waypointIndexBefore: number;
+    waypointIndexAfter: number;
+};
+export type EdgeStrokeStyle = 'solid' | 'dashed';
+export type EdgeRouting = 'waypoint' | 'handle';
+export type CanvasEdgeData = {
+    strokeStyle?: EdgeStrokeStyle;
+    hideArrowHead?: boolean;
+    label?: string | null;
+    isInvalid?: boolean;
+    isDiffAdded?: boolean;
+    isDiffRemoved?: boolean;
+    routing?: EdgeRouting;
+    enableEditing?: boolean;
+    enableExecution?: boolean;
+    enableToolbar?: boolean;
+    waypoints?: Waypoint[];
+    routedWaypoints?: Waypoint[];
+    onWaypointsChange?: (next: Waypoint[]) => void;
+};
+export type CanvasEdgeProps = EdgeProps<Edge<CanvasEdgeData>>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Edges/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE5F,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC;AAE/B,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAQF,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG;IAC/B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,UAAU,CAAC;AAE3D,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,KAAK,CAAC;IACX,WAAW,EAAE,kBAAkB,CAAC;IAEhC,mBAAmB,EAAE,MAAM,CAAC;IAE5B,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,CAAC;AAajD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,QAAQ,CAAC;AAWhD,MAAM,MAAM,cAAc,GAAG;IAE3B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IAGxB,OAAO,CAAC,EAAE,WAAW,CAAC;IAGtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;IAGxB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAQvB,eAAe,CAAC,EAAE,QAAQ,EAAE,CAAC;IAS7B,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,216 @@
+"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__, {
+    moveWaypoint: ()=>moveWaypoint,
+    removeWaypoint: ()=>removeWaypoint,
+    materializePathWaypoints: ()=>materializePathWaypoints,
+    waypointsEqual: ()=>waypointsEqual,
+    rebalanceWaypoints: ()=>rebalanceWaypoints,
+    insertWaypoint: ()=>insertWaypoint,
+    waypointsPositionallyEqual: ()=>waypointsPositionallyEqual,
+    moveSegmentByDelta: ()=>moveSegmentByDelta,
+    generateWaypointId: ()=>generateWaypointId
+});
+const NodeUtils_cjs_namespaceObject = require("../../../utils/NodeUtils.cjs");
+const external_constants_cjs_namespaceObject = require("./constants.cjs");
+const external_geometry_cjs_namespaceObject = require("./geometry.cjs");
+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(),
+        ...(0, external_geometry_cjs_namespaceObject.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 ((0, external_geometry_cjs_namespaceObject.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 = (0, external_geometry_cjs_namespaceObject.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 = external_constants_cjs_namespaceObject.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 ? (0, NodeUtils_cjs_namespaceObject.snapToGrid)(segmentStart.y + moveValue) : (0, NodeUtils_cjs_namespaceObject.snapToGrid)(segmentStart.x + moveValue);
+    if (isConnectedToSource) {
+        const stubCoord = (0, NodeUtils_cjs_namespaceObject.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 = (0, NodeUtils_cjs_namespaceObject.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 (0, external_geometry_cjs_namespaceObject.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
+        }
+    ];
+}
+exports.generateWaypointId = __webpack_exports__.generateWaypointId;
+exports.insertWaypoint = __webpack_exports__.insertWaypoint;
+exports.materializePathWaypoints = __webpack_exports__.materializePathWaypoints;
+exports.moveSegmentByDelta = __webpack_exports__.moveSegmentByDelta;
+exports.moveWaypoint = __webpack_exports__.moveWaypoint;
+exports.rebalanceWaypoints = __webpack_exports__.rebalanceWaypoints;
+exports.removeWaypoint = __webpack_exports__.removeWaypoint;
+exports.waypointsEqual = __webpack_exports__.waypointsEqual;
+exports.waypointsPositionallyEqual = __webpack_exports__.waypointsPositionallyEqual;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateWaypointId",
+    "insertWaypoint",
+    "materializePathWaypoints",
+    "moveSegmentByDelta",
+    "moveWaypoint",
+    "rebalanceWaypoints",
+    "removeWaypoint",
+    "waypointsEqual",
+    "waypointsPositionallyEqual"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,17 @@
+import type { Position } from '../../../xyflow/react.ts';
+import type { PathVertex, Point, Segment, Waypoint } from './types';
+export declare function materializePathWaypoints(vertices: PathVertex[], stored: Waypoint[]): Waypoint[];
+export declare function generateWaypointId(): string;
+export declare function waypointsEqual(a: Waypoint[], b: Waypoint[]): boolean;
+export declare function waypointsPositionallyEqual(a: Waypoint[], b: Waypoint[]): boolean;
+export declare function insertWaypoint(vertices: PathVertex[], stored: Waypoint[], segmentIndex: number, position: Point): Waypoint[];
+export declare function removeWaypoint(waypoints: Waypoint[], index: number): Waypoint[];
+export type RebalanceEndpoint = {
+    position: Position;
+    from: Point;
+    to: Point;
+};
+export declare function rebalanceWaypoints(waypoints: Waypoint[], source: RebalanceEndpoint, target: RebalanceEndpoint): Waypoint[];
+export declare function moveWaypoint(waypoints: Waypoint[], index: number, newPosition: Point): Waypoint[];
+export declare function moveSegmentByDelta(initialWaypoints: Waypoint[], initialSegment: Segment, delta: Point, initialPathPoints: Point[]): Waypoint[];
+//# sourceMappingURL=waypoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"waypoints.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/Edges/shared/waypoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAIzE,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAUpE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAK/F;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAOD,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CASpE;AAOD,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAOhF;AASD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EAAE,EACtB,MAAM,EAAE,QAAQ,EAAE,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,KAAK,GACd,QAAQ,EAAE,CASZ;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAE/E;AAID,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;CACX,CAAC;AAqBF,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,QAAQ,EAAE,EACrB,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,iBAAiB,GACxB,QAAQ,EAAE,CA2BZ;AAwBD,wBAAgB,YAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,GAAG,QAAQ,EAAE,CAGjG;AAUD,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,QAAQ,EAAE,EAC5B,cAAc,EAAE,OAAO,EACvB,KAAK,EAAE,KAAK,EACZ,iBAAiB,EAAE,KAAK,EAAE,GACzB,QAAQ,EAAE,CAiEZ"}