@uipath/apollo-react 4.45.1 → 4.47.0

package/dist/canvas/components/Edges/shared/hooks/useWaypointEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWaypointEditor.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/hooks/useWaypointEditor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAS,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAqBrE,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,UAAU,EAAE,UAAU,EAAE,CAAC;IAMzB,OAAO,EAAE,OAAO,CAAC;IAKjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC1D,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC7D,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;CACpE,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,OAAO,CAAC;IAEpB,gBAAgB,EAAE,gBAAgB,CAAC;IAEnC,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAaF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,CAoJ7E"}

package/dist/canvas/components/Edges/shared/hooks/useWaypointEditor.js

@@ -0,0 +1,150 @@
+import { useReactFlow } from "../../../../xyflow/react.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { snapPointToGrid } from "../geometry.js";
+import { insertWaypoint, materializePathWaypoints, moveSegmentByDelta, moveWaypoint, removeWaypoint, waypointsEqual } from "../waypoints.js";
+import { useEdgeWaypointWriter } from "./useEdgeWaypointWriter.js";
+function useWaypointEditor(args) {
+    const { edgeId, waypoints, pathPoints, enabled, onChange } = args;
+    const { screenToFlowPosition } = useReactFlow();
+    const writeWaypoints = useEdgeWaypointWriter(edgeId, onChange);
+    const [dragState, setDragState] = useState({
+        type: 'none'
+    });
+    const dragStartRef = useRef(null);
+    const rafRef = useRef(null);
+    const waypointsRef = useRef(waypoints);
+    const pathPointsRef = useRef(pathPoints);
+    useEffect(()=>{
+        waypointsRef.current = waypoints;
+        pathPointsRef.current = pathPoints;
+    });
+    const updateWaypoints = useCallback((next)=>{
+        if (waypointsEqual(waypointsRef.current, next)) return;
+        writeWaypoints(next);
+    }, [
+        writeWaypoints
+    ]);
+    useEffect(()=>{
+        if (!enabled || 'none' === dragState.type) return;
+        const handleMouseMove = (e)=>{
+            if (!dragStartRef.current) return;
+            if (null !== rafRef.current) cancelAnimationFrame(rafRef.current);
+            rafRef.current = requestAnimationFrame(()=>{
+                const start = screenToFlowPosition(dragStartRef.current, {
+                    snapToGrid: false
+                });
+                const current = screenToFlowPosition({
+                    x: e.clientX,
+                    y: e.clientY
+                }, {
+                    snapToGrid: false
+                });
+                const delta = {
+                    x: current.x - start.x,
+                    y: current.y - start.y
+                };
+                if ('waypoint' === dragState.type) {
+                    const initial = dragState.initialWaypoints[dragState.waypointIndex];
+                    if (!initial) return;
+                    updateWaypoints(moveWaypoint(dragState.initialWaypoints, dragState.waypointIndex, {
+                        x: initial.x + delta.x,
+                        y: initial.y + delta.y
+                    }));
+                } else if ('segment' === dragState.type) updateWaypoints(moveSegmentByDelta(dragState.initialWaypoints, dragState.segment, delta, dragState.initialPathPoints));
+            });
+        };
+        const handleMouseUp = ()=>{
+            if (null !== rafRef.current) {
+                cancelAnimationFrame(rafRef.current);
+                rafRef.current = null;
+            }
+            setDragState({
+                type: 'none'
+            });
+            dragStartRef.current = null;
+        };
+        window.addEventListener('mousemove', handleMouseMove);
+        window.addEventListener('mouseup', handleMouseUp);
+        return ()=>{
+            window.removeEventListener('mousemove', handleMouseMove);
+            window.removeEventListener('mouseup', handleMouseUp);
+            if (null !== rafRef.current) cancelAnimationFrame(rafRef.current);
+        };
+    }, [
+        enabled,
+        dragState,
+        updateWaypoints,
+        screenToFlowPosition
+    ]);
+    const waypointHandlers = useMemo(()=>({
+            onMouseDown: (index, e)=>{
+                if (!enabled) return;
+                e.stopPropagation();
+                e.preventDefault();
+                dragStartRef.current = {
+                    x: e.clientX,
+                    y: e.clientY
+                };
+                setDragState({
+                    type: 'waypoint',
+                    waypointIndex: index,
+                    initialWaypoints: [
+                        ...waypointsRef.current
+                    ]
+                });
+            },
+            onDoubleClick: (index)=>{
+                if (!enabled) return;
+                updateWaypoints(removeWaypoint(waypointsRef.current, index));
+            }
+        }), [
+        enabled,
+        updateWaypoints
+    ]);
+    const segmentHandlers = useMemo(()=>({
+            onMouseDown: (segment, e)=>{
+                if (!enabled) return;
+                e.stopPropagation();
+                e.preventDefault();
+                dragStartRef.current = {
+                    x: e.clientX,
+                    y: e.clientY
+                };
+                const materialized = materializePathWaypoints(pathPointsRef.current, waypointsRef.current);
+                setDragState({
+                    type: 'segment',
+                    segment,
+                    initialWaypoints: materialized,
+                    initialPathPoints: [
+                        ...pathPointsRef.current
+                    ]
+                });
+            },
+            onDoubleClick: (segmentIndex, e)=>{
+                if (!enabled) return;
+                e.stopPropagation();
+                e.preventDefault();
+                const flowPoint = screenToFlowPosition({
+                    x: e.clientX,
+                    y: e.clientY
+                });
+                const snapped = snapPointToGrid(flowPoint);
+                updateWaypoints(insertWaypoint(pathPointsRef.current, waypointsRef.current, segmentIndex, snapped));
+            }
+        }), [
+        enabled,
+        screenToFlowPosition,
+        updateWaypoints
+    ]);
+    const isDragging = enabled && 'none' !== dragState.type;
+    return useMemo(()=>({
+            isDragging,
+            waypointHandlers,
+            segmentHandlers
+        }), [
+        isDragging,
+        waypointHandlers,
+        segmentHandlers
+    ]);
+}
+export { useWaypointEditor };

package/dist/canvas/components/Edges/shared/primitives/EdgeArrow.cjs

@@ -0,0 +1,57 @@
+"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__, {
+    EdgeArrow: ()=>EdgeArrow
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const { ARROW_SIZE, ARROW_HALF_ANGLE } = external_constants_cjs_namespaceObject.EDGE_CONSTANTS;
+const ARROW_TRANSITION = 'fill 0.2s ease, opacity 0.2s ease';
+function EdgeArrow({ target, angle, offset, color, opacity = 1 }) {
+    const tipX = target.x;
+    const tipY = target.y;
+    const leftX = tipX - ARROW_SIZE * Math.cos(angle - ARROW_HALF_ANGLE);
+    const leftY = tipY - ARROW_SIZE * Math.sin(angle - ARROW_HALF_ANGLE);
+    const rightX = tipX - ARROW_SIZE * Math.cos(angle + ARROW_HALF_ANGLE);
+    const rightY = tipY - ARROW_SIZE * Math.sin(angle + ARROW_HALF_ANGLE);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("polygon", {
+        points: `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`,
+        fill: color,
+        style: {
+            pointerEvents: 'none',
+            opacity,
+            transition: ARROW_TRANSITION,
+            transform: `translate(${offset.x}px, ${offset.y}px)`
+        }
+    });
+}
+exports.EdgeArrow = __webpack_exports__.EdgeArrow;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EdgeArrow"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/primitives/EdgeArrow.d.ts

@@ -0,0 +1,10 @@
+import type { Point } from '../types';
+export type EdgeArrowProps = {
+    target: Point;
+    angle: number;
+    offset: Point;
+    color: string;
+    opacity?: number;
+};
+export declare function EdgeArrow({ target, angle, offset, color, opacity }: EdgeArrowProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=EdgeArrow.d.ts.map

package/dist/canvas/components/Edges/shared/primitives/EdgeArrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeArrow.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/primitives/EdgeArrow.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAKtC,MAAM,MAAM,cAAc,GAAG;IAE3B,MAAM,EAAE,KAAK,CAAC;IAEd,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,SAAS,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAW,EAAE,EAAE,cAAc,2CAoBtF"}

package/dist/canvas/components/Edges/shared/primitives/EdgeArrow.js

@@ -0,0 +1,23 @@
+import { jsx } from "react/jsx-runtime";
+import { EDGE_CONSTANTS } from "../constants.js";
+const { ARROW_SIZE, ARROW_HALF_ANGLE } = EDGE_CONSTANTS;
+const ARROW_TRANSITION = 'fill 0.2s ease, opacity 0.2s ease';
+function EdgeArrow({ target, angle, offset, color, opacity = 1 }) {
+    const tipX = target.x;
+    const tipY = target.y;
+    const leftX = tipX - ARROW_SIZE * Math.cos(angle - ARROW_HALF_ANGLE);
+    const leftY = tipY - ARROW_SIZE * Math.sin(angle - ARROW_HALF_ANGLE);
+    const rightX = tipX - ARROW_SIZE * Math.cos(angle + ARROW_HALF_ANGLE);
+    const rightY = tipY - ARROW_SIZE * Math.sin(angle + ARROW_HALF_ANGLE);
+    return /*#__PURE__*/ jsx("polygon", {
+        points: `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`,
+        fill: color,
+        style: {
+            pointerEvents: 'none',
+            opacity,
+            transition: ARROW_TRANSITION,
+            transform: `translate(${offset.x}px, ${offset.y}px)`
+        }
+    });
+}
+export { EdgeArrow };

package/dist/canvas/components/Edges/shared/primitives/EdgeLabel.cjs

@@ -0,0 +1,66 @@
+"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__, {
+    EdgeLabel: ()=>EdgeLabel
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+function EdgeLabel({ x, y, text, selected }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("foreignObject", {
+        x: x,
+        y: y,
+        width: 1,
+        height: 1,
+        overflow: "visible",
+        style: {
+            pointerEvents: 'none'
+        },
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            className: "react-flow__edge-label nodrag nopan",
+            style: {
+                position: 'absolute',
+                transform: 'translate(-50%, -50%)',
+                whiteSpace: 'nowrap',
+                pointerEvents: 'none',
+                color: 'var(--canvas-foreground)',
+                background: 'var(--canvas-background)',
+                padding: '4px 8px',
+                borderRadius: '4px',
+                fontSize: '12px',
+                fontWeight: 500,
+                border: `1px solid ${selected ? 'var(--canvas-primary)' : 'var(--canvas-border)'}`,
+                boxShadow: '0 1px 3px 0 rgba(0, 0, 0, 0.1)'
+            },
+            children: text
+        })
+    });
+}
+exports.EdgeLabel = __webpack_exports__.EdgeLabel;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EdgeLabel"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/primitives/EdgeLabel.d.ts

@@ -0,0 +1,8 @@
+export type EdgeLabelProps = {
+    x: number;
+    y: number;
+    text: string;
+    selected?: boolean;
+};
+export declare function EdgeLabel({ x, y, text, selected }: EdgeLabelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=EdgeLabel.d.ts.map

package/dist/canvas/components/Edges/shared/primitives/EdgeLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeLabel.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/primitives/EdgeLabel.tsx"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAgB,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,cAAc,2CA+BjE"}

package/dist/canvas/components/Edges/shared/primitives/EdgeLabel.js

@@ -0,0 +1,32 @@
+import { jsx } from "react/jsx-runtime";
+function EdgeLabel({ x, y, text, selected }) {
+    return /*#__PURE__*/ jsx("foreignObject", {
+        x: x,
+        y: y,
+        width: 1,
+        height: 1,
+        overflow: "visible",
+        style: {
+            pointerEvents: 'none'
+        },
+        children: /*#__PURE__*/ jsx("div", {
+            className: "react-flow__edge-label nodrag nopan",
+            style: {
+                position: 'absolute',
+                transform: 'translate(-50%, -50%)',
+                whiteSpace: 'nowrap',
+                pointerEvents: 'none',
+                color: 'var(--canvas-foreground)',
+                background: 'var(--canvas-background)',
+                padding: '4px 8px',
+                borderRadius: '4px',
+                fontSize: '12px',
+                fontWeight: 500,
+                border: `1px solid ${selected ? 'var(--canvas-primary)' : 'var(--canvas-border)'}`,
+                boxShadow: '0 1px 3px 0 rgba(0, 0, 0, 0.1)'
+            },
+            children: text
+        })
+    });
+}
+export { EdgeLabel };

package/dist/canvas/components/Edges/shared/primitives/EdgePath.cjs

@@ -0,0 +1,84 @@
+"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__, {
+    EdgePath: ()=>EdgePath
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const { INTERACTION_STROKE_WIDTH, STROKE_WIDTH, SELECTED_STROKE_WIDTH, SELECTED_OUTLINE_STROKE_WIDTH, SELECTED_OUTLINE_OPACITY } = external_constants_cjs_namespaceObject.EDGE_CONSTANTS;
+function EdgePath(props) {
+    const { d, color, selected, animated, strokeStyle, isReadOnly, pathRef, id, style, opacity = 1 } = props;
+    const dasharray = animated ? void 0 : 'dashed' === strokeStyle ? external_constants_cjs_namespaceObject.EDGE_DASHARRAY.dashed : external_constants_cjs_namespaceObject.EDGE_DASHARRAY.solid;
+    const strokeWidth = style?.strokeWidth ?? (selected ? SELECTED_STROKE_WIDTH : STROKE_WIDTH);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("path", {
+                className: "react-flow__edge-interaction",
+                d: d,
+                fill: "none",
+                stroke: "transparent",
+                strokeWidth: INTERACTION_STROKE_WIDTH,
+                style: {
+                    pointerEvents: 'stroke',
+                    cursor: isReadOnly ? 'default' : 'pointer'
+                }
+            }),
+            selected && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("path", {
+                className: "react-flow__edge-outline",
+                d: d,
+                fill: "none",
+                stroke: external_constants_cjs_namespaceObject.EDGE_COLORS.selected,
+                strokeWidth: SELECTED_OUTLINE_STROKE_WIDTH,
+                opacity: SELECTED_OUTLINE_OPACITY,
+                style: {
+                    pointerEvents: 'none',
+                    transition: 'opacity 0.2s ease'
+                }
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("path", {
+                id: id,
+                ref: pathRef,
+                className: "react-flow__edge-path",
+                d: d,
+                fill: "none",
+                strokeWidth: strokeWidth,
+                style: {
+                    stroke: color,
+                    strokeDasharray: dasharray,
+                    opacity,
+                    transition: external_constants_cjs_namespaceObject.EDGE_PATH_TRANSITION
+                }
+            })
+        ]
+    });
+}
+exports.EdgePath = __webpack_exports__.EdgePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EdgePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/primitives/EdgePath.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties } from 'react';
+import type { EdgeStrokeStyle } from '../types';
+export type EdgePathProps = {
+    d: string;
+    color: string;
+    selected?: boolean;
+    animated?: boolean;
+    strokeStyle?: EdgeStrokeStyle;
+    isReadOnly?: boolean;
+    pathRef?: React.Ref<SVGPathElement>;
+    id?: string;
+    style?: CSSProperties;
+    opacity?: number;
+};
+export declare function EdgePath(props: EdgePathProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=EdgePath.d.ts.map

package/dist/canvas/components/Edges/shared/primitives/EdgePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgePath.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/primitives/EdgePath.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAUhD,MAAM,MAAM,aAAa,GAAG;IAE1B,CAAC,EAAE,MAAM,CAAC;IAEV,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IAMnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAEpC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,aAAa,CAAC;IAEtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAQF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CA2D5C"}

package/dist/canvas/components/Edges/shared/primitives/EdgePath.js

@@ -0,0 +1,50 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { EDGE_COLORS, EDGE_CONSTANTS, EDGE_DASHARRAY, EDGE_PATH_TRANSITION } from "../constants.js";
+const { INTERACTION_STROKE_WIDTH, STROKE_WIDTH, SELECTED_STROKE_WIDTH, SELECTED_OUTLINE_STROKE_WIDTH, SELECTED_OUTLINE_OPACITY } = EDGE_CONSTANTS;
+function EdgePath(props) {
+    const { d, color, selected, animated, strokeStyle, isReadOnly, pathRef, id, style, opacity = 1 } = props;
+    const dasharray = animated ? void 0 : 'dashed' === strokeStyle ? EDGE_DASHARRAY.dashed : EDGE_DASHARRAY.solid;
+    const strokeWidth = style?.strokeWidth ?? (selected ? SELECTED_STROKE_WIDTH : STROKE_WIDTH);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("path", {
+                className: "react-flow__edge-interaction",
+                d: d,
+                fill: "none",
+                stroke: "transparent",
+                strokeWidth: INTERACTION_STROKE_WIDTH,
+                style: {
+                    pointerEvents: 'stroke',
+                    cursor: isReadOnly ? 'default' : 'pointer'
+                }
+            }),
+            selected && /*#__PURE__*/ jsx("path", {
+                className: "react-flow__edge-outline",
+                d: d,
+                fill: "none",
+                stroke: EDGE_COLORS.selected,
+                strokeWidth: SELECTED_OUTLINE_STROKE_WIDTH,
+                opacity: SELECTED_OUTLINE_OPACITY,
+                style: {
+                    pointerEvents: 'none',
+                    transition: 'opacity 0.2s ease'
+                }
+            }),
+            /*#__PURE__*/ jsx("path", {
+                id: id,
+                ref: pathRef,
+                className: "react-flow__edge-path",
+                d: d,
+                fill: "none",
+                strokeWidth: strokeWidth,
+                style: {
+                    stroke: color,
+                    strokeDasharray: dasharray,
+                    opacity,
+                    transition: EDGE_PATH_TRANSITION
+                }
+            })
+        ]
+    });
+}
+export { EdgePath };

package/dist/canvas/components/Edges/shared/primitives/SegmentDragHandle.cjs

@@ -0,0 +1,117 @@
+"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__, {
+    SegmentDragHandle: ()=>SegmentDragHandle_SegmentDragHandle
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const external_geometry_cjs_namespaceObject = require("../geometry.cjs");
+const { INTERACTION_STROKE_WIDTH } = external_constants_cjs_namespaceObject.EDGE_CONSTANTS;
+const SEGMENT_CURSOR = {
+    horizontal: 'ns-resize',
+    vertical: 'ew-resize'
+};
+const HANDLE_RECT = {
+    horizontal: {
+        x: -12,
+        y: -5,
+        width: 24,
+        height: 10
+    },
+    vertical: {
+        x: -5,
+        y: -12,
+        width: 10,
+        height: 24
+    }
+};
+const SegmentDragHandle_SegmentDragHandle = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(function({ segment, segmentIndex, handlers }) {
+    const [isHovered, setIsHovered] = (0, external_react_namespaceObject.useState)(false);
+    const midpoint = (0, external_geometry_cjs_namespaceObject.getSegmentMidpoint)(segment);
+    const cursor = SEGMENT_CURSOR[segment.orientation];
+    const rect = HANDLE_RECT[segment.orientation];
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("line", {
+                className: "nopan",
+                x1: segment.start.x,
+                y1: segment.start.y,
+                x2: segment.end.x,
+                y2: segment.end.y,
+                stroke: "transparent",
+                strokeWidth: INTERACTION_STROKE_WIDTH,
+                style: {
+                    cursor,
+                    pointerEvents: 'stroke'
+                },
+                onMouseEnter: ()=>setIsHovered(true),
+                onMouseLeave: ()=>setIsHovered(false),
+                onMouseDown: (e)=>handlers.onMouseDown(segment, e),
+                onDoubleClick: (e)=>handlers.onDoubleClick(segmentIndex, e)
+            }),
+            isHovered && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("line", {
+                        x1: segment.start.x,
+                        y1: segment.start.y,
+                        x2: segment.end.x,
+                        y2: segment.end.y,
+                        stroke: external_constants_cjs_namespaceObject.EDGE_COLORS.selected,
+                        strokeWidth: 4,
+                        opacity: 0.4,
+                        style: {
+                            pointerEvents: 'none'
+                        }
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("g", {
+                        transform: `translate(${midpoint.x}, ${midpoint.y})`,
+                        style: {
+                            pointerEvents: 'none'
+                        },
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
+                            x: rect.x,
+                            y: rect.y,
+                            width: rect.width,
+                            height: rect.height,
+                            rx: 5,
+                            fill: external_constants_cjs_namespaceObject.EDGE_COLORS.selected,
+                            stroke: "white",
+                            strokeWidth: 2
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+});
+exports.SegmentDragHandle = __webpack_exports__.SegmentDragHandle;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SegmentDragHandle"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/Edges/shared/primitives/SegmentDragHandle.d.ts

@@ -0,0 +1,9 @@
+import type { SegmentHandlers } from '../hooks/useWaypointEditor';
+import type { Segment } from '../types';
+export type SegmentDragHandleProps = {
+    segment: Segment;
+    segmentIndex: number;
+    handlers: SegmentHandlers;
+};
+export declare const SegmentDragHandle: import("react").NamedExoticComponent<SegmentDragHandleProps>;
+//# sourceMappingURL=SegmentDragHandle.d.ts.map

package/dist/canvas/components/Edges/shared/primitives/SegmentDragHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentDragHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/canvas/components/Edges/shared/primitives/SegmentDragHandle.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,UAAU,CAAC;AAiB5D,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,OAAO,CAAC;IAEjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,8DA4D5B,CAAC"}