@uipath/apollo-react 3.63.0 → 3.64.0-pr431.76f87cc

package/dist/canvas/components/StageNode/StageNode.js

@@ -1,24 +1,74 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { DndContext, DragOverlay, KeyboardSensor, PointerSensor, closestCenter, useSensor, useSensors } from "@dnd-kit/core";
 import { SortableContext, sortableKeyboardCoordinates, verticalListSortingStrategy } from "@dnd-kit/sortable";
-import { FontVariantToken, Padding, Spacing } from "@uipath/apollo-core";
+import { FontVariantToken, Icon, Padding, Spacing } from "@uipath/apollo-core";
 import { Column, Row } from "../../layouts/index.js";
-import { Position, useStore, useViewport } from "../../xyflow/react.js";
+import { Position, useStore, useStoreApi, useViewport } from "../../xyflow/react.js";
 import { ApIcon, ApIconButton, ApLink, ApTooltip, ApTypography } from "../../../material/index.js";
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
+import { EntryConditionIcon, ExitConditionIcon, ReturnToOriginIcon } from "../../icons/index.js";
 import { useConnectedHandles } from "../BaseCanvas/ConnectedHandlesContext.js";
 import { useButtonHandles } from "../ButtonHandle/useButtonHandles.js";
 import { ExecutionStatusIcon } from "../ExecutionStatusIcon/index.js";
 import { FloatingCanvasPanel } from "../FloatingCanvasPanel/index.js";
 import { NodeContextMenu } from "../NodeContextMenu/index.js";
-import { useNodeSelection } from "../NodePropertiesPanel/hooks/index.js";
+import { useSetNodeSelection } from "../NodePropertiesPanel/hooks/index.js";
 import { Toolbox } from "../Toolbox/index.js";
 import { DraggableTask, TaskContent } from "./DraggableTask.js";
-import { INDENTATION_WIDTH, STAGE_CONTENT_INSET, StageContainer, StageContent, StageHeader, StageParallelBracket, StageParallelLabel, StageTask, StageTaskGroup, StageTaskList, StageTitleContainer, StageTitleInput } from "./StageNode.styles.js";
+import { INDENTATION_WIDTH, STAGE_CONTENT_INSET, StageChip, StageContainer, StageContent, StageHeader, StageHeaderChipsRow, StageParallelBracket, StageParallelLabel, StageTask, StageTaskGroup, StageTaskList, StageTitleContainer, StageTitleInput } from "./StageNode.styles.js";
+import { StageHeaderChipType } from "./StageNode.types.js";
 import { flattenTasks, getProjection, reorderTasks } from "./StageNode.utils.js";
 import { getContextMenuItems, getDivider, getMenuItem } from "./StageNodeTaskUtilities.js";
-const StageNodeComponent = (props)=>{
+const CHIP_ICONS = {
+    [StageHeaderChipType.Entry]: /*#__PURE__*/ jsx(EntryConditionIcon, {
+        w: Icon.IconXs,
+        h: Icon.IconXs
+    }),
+    [StageHeaderChipType.Exit]: /*#__PURE__*/ jsx(ExitConditionIcon, {
+        w: Icon.IconXs,
+        h: Icon.IconXs
+    }),
+    [StageHeaderChipType.ReturnToOrigin]: /*#__PURE__*/ jsx(ReturnToOriginIcon, {
+        w: Icon.IconXs,
+        h: Icon.IconXs
+    }),
+    [StageHeaderChipType.CaseExit]: /*#__PURE__*/ jsx(ApIcon, {
+        name: "close",
+        size: Icon.IconXs
+    }),
+    [StageHeaderChipType.CaseCompletion]: /*#__PURE__*/ jsx(ApIcon, {
+        name: "check-mark",
+        size: Icon.IconXs
+    })
+};
+const StageNode_StageTaskDragOverlay = /*#__PURE__*/ memo(function({ activeTask, isActiveTaskParallel, taskWidthStyle }) {
+    const { zoom } = useViewport();
+    const dragOverlayStyle = useMemo(()=>({
+            transform: `scale(${zoom})`,
+            transformOrigin: 'top left'
+        }), [
+        zoom
+    ]);
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx(DragOverlay, {
+        children: activeTask ? /*#__PURE__*/ jsx("div", {
+            style: dragOverlayStyle,
+            children: /*#__PURE__*/ jsx(StageTask, {
+                selected: true,
+                isParallel: isActiveTaskParallel,
+                style: {
+                    cursor: 'grabbing',
+                    ...taskWidthStyle
+                },
+                children: /*#__PURE__*/ jsx(TaskContent, {
+                    task: activeTask,
+                    isDragging: true
+                })
+            })
+        }) : null
+    }), document.body);
+});
+const StageNodeInner = (props)=>{
     const { dragging, selected, id, width, execution, stageDetails, addTaskLabel = 'Add task', addTaskLoading = false, replaceTaskLabel = 'Replace task', taskOptions = [], menuItems, pendingReplaceTask, onStageClick, onTaskAdd, onAddTaskFromToolbox, onTaskToolboxSearch, onTaskClick, onTaskGroupModification, onStageTitleChange, onTaskReorder, onReplaceTaskFromToolbox, onTaskPlay } = props;
     const taskWidth = width ? width - STAGE_CONTENT_INSET : void 0;
     const tasks = useMemo(()=>stageDetails?.tasks || [], [
@@ -38,9 +88,6 @@ const StageNodeComponent = (props)=>{
     const status = execution?.stageStatus?.status;
     const statusLabel = execution?.stageStatus?.label;
     const stageDuration = execution?.stageStatus?.duration;
-    const reGroupTaskFunction = useMemo(()=>onTaskGroupModification || (()=>{}), [
-        onTaskGroupModification
-    ]);
     const isStageTitleEditable = !!onStageTitleChange && !isReadOnly;
     const [isHovered, setIsHovered] = useState(false);
     const [label, setLabel] = useState(props.stageDetails.label);
@@ -57,6 +104,7 @@ const StageNodeComponent = (props)=>{
         taskIndex: -1
     });
     const isConnecting = useStore((state)=>!!state.connectionClickStartHandle);
+    const storeApi = useStoreApi();
     const connectedHandleIds = useConnectedHandles(id);
     const [isAddingTask, setIsAddingTask] = useState(false);
     const [isReplacingTask, setIsReplacingTask] = useState(false);
@@ -96,7 +144,6 @@ const StageNodeComponent = (props)=>{
         tasks,
         activeDragId
     ]);
-    const { zoom } = useViewport();
     const projected = useMemo(()=>{
         if (!activeDragId || !overId) return null;
         return getProjection(tasks, activeDragId, overId, offsetLeft);
@@ -179,18 +226,26 @@ const StageNodeComponent = (props)=>{
         handleStageTitleClickToSave,
         isStageTitleEditing
     ]);
-    const contextMenuItems = useCallback((isParallel, groupIndex, taskIndex, tasksLength, taskGroupLength, isAboveParallel, isBelowParallel)=>{
+    const hasContextMenu = !!(onReplaceTaskFromToolbox || onTaskGroupModification);
+    const buildContextMenuItems = useCallback((groupIndex, taskIndex)=>{
+        const taskGroup = tasks[groupIndex] ?? [];
+        const isParallel = taskGroup.length > 1;
         const items = [];
         if (onReplaceTaskFromToolbox) {
             items.push(getMenuItem('replace-task', 'Replace task', ()=>{
-                const taskId = tasks[groupIndex]?.[taskIndex]?.id;
+                taskStateReference.current = {
+                    isParallel,
+                    groupIndex,
+                    taskIndex
+                };
+                const taskId = taskGroup[taskIndex]?.id;
                 if (taskId) onTaskClick?.(taskId);
                 setIsReplacingTask(true);
             }));
             items.push(getDivider());
         }
         if (onTaskGroupModification) {
-            const reGroupOptions = getContextMenuItems(isParallel, groupIndex, tasksLength, taskIndex, taskGroupLength, isAboveParallel, isBelowParallel, reGroupTaskFunction);
+            const reGroupOptions = getContextMenuItems(isParallel, groupIndex, tasks.length, taskIndex, taskGroup.length, (tasks[groupIndex - 1]?.length ?? 0) > 1, (tasks[groupIndex + 1]?.length ?? 0) > 1, onTaskGroupModification);
             return [
                 ...items,
                 ...reGroupOptions
@@ -201,10 +256,9 @@ const StageNodeComponent = (props)=>{
         onReplaceTaskFromToolbox,
         onTaskClick,
         onTaskGroupModification,
-        reGroupTaskFunction,
         tasks
     ]);
-    const { setSelectedNodeId } = useNodeSelection();
+    const { setSelectedNodeId } = useSetNodeSelection();
     const handleStageClick = useCallback(()=>{
         onStageClick?.();
     }, [
@@ -327,9 +381,9 @@ const StageNodeComponent = (props)=>{
         setActiveDragId(event.active.id);
     }, []);
     const handleDragMove = useCallback((event)=>{
-        setOffsetLeft(event.delta.x / zoom);
+        setOffsetLeft(event.delta.x / storeApi.getState().transform[2]);
     }, [
-        zoom
+        storeApi
     ]);
     const handleDragOver = useCallback((event)=>{
         setOverId(event.over?.id ?? null);
@@ -365,12 +419,6 @@ const StageNodeComponent = (props)=>{
         } : void 0, [
         taskWidth
     ]);
-    const dragOverlayStyle = useMemo(()=>({
-            transform: `scale(${zoom})`,
-            transformOrigin: 'top left'
-        }), [
-        zoom
-    ]);
     return /*#__PURE__*/ jsxs("div", {
         "data-testid": `stage-${id}`,
         style: {
@@ -431,6 +479,31 @@ const StageNodeComponent = (props)=>{
                                                 variant: FontVariantToken.fontSizeS,
                                                 color: "var(--uix-canvas-foreground-de-emp)",
                                                 children: stageDuration
+                                            }),
+                                            stageDetails.headerChips && stageDetails.headerChips.length > 0 && /*#__PURE__*/ jsx(StageHeaderChipsRow, {
+                                                children: stageDetails.headerChips.map((chip)=>{
+                                                    const button = /*#__PURE__*/ jsxs(StageChip, {
+                                                        type: "button",
+                                                        "aria-label": 'string' == typeof chip.tooltip ? chip.tooltip : chip.type,
+                                                        onClick: (e)=>{
+                                                            e.stopPropagation();
+                                                            chip.onClick?.();
+                                                        },
+                                                        children: [
+                                                            CHIP_ICONS[chip.type],
+                                                            void 0 !== chip.count && /*#__PURE__*/ jsx(ApTypography, {
+                                                                variant: FontVariantToken.fontSizeS,
+                                                                children: chip.count
+                                                            })
+                                                        ]
+                                                    }, chip.type);
+                                                    if (chip.tooltip) return /*#__PURE__*/ jsx(ApTooltip, {
+                                                        placement: "bottom",
+                                                        content: chip.tooltip,
+                                                        children: button
+                                                    }, chip.type);
+                                                    return button;
+                                                })
                                             })
                                         ]
                                     })
@@ -510,20 +583,14 @@ const StageNodeComponent = (props)=>{
                                                                     taskExecution: taskExecution,
                                                                     isSelected: selectedTaskId === task.id,
                                                                     isParallel: isParallel,
-                                                                    contextMenuItems: contextMenuItems(isParallel, groupIndex, taskIndex, tasks.length, taskGroup.length, (tasks[groupIndex - 1]?.length ?? 0) > 1, (tasks[groupIndex + 1]?.length ?? 0) > 1),
+                                                                    groupIndex: groupIndex,
+                                                                    taskIndex: taskIndex,
                                                                     onTaskClick: handleTaskClick,
                                                                     projectedDepth: task.id === activeDragId && projected ? projected.depth : void 0,
                                                                     onTaskPlay: onTaskPlay,
                                                                     isDragDisabled: !onTaskReorder,
-                                                                    zoom: zoom,
-                                                                    ...(onTaskGroupModification || onReplaceTaskFromToolbox) && {
-                                                                        onMenuOpen: ()=>{
-                                                                            taskStateReference.current = {
-                                                                                isParallel,
-                                                                                groupIndex,
-                                                                                taskIndex
-                                                                            };
-                                                                        }
+                                                                    ...hasContextMenu && {
+                                                                        getContextMenuItems: buildContextMenuItems
                                                                     }
                                                                 }, task.id);
                                                             })
@@ -534,23 +601,11 @@ const StageNodeComponent = (props)=>{
                                         })
                                     })
                                 }),
-                                /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx(DragOverlay, {
-                                    children: activeTask ? /*#__PURE__*/ jsx("div", {
-                                        style: dragOverlayStyle,
-                                        children: /*#__PURE__*/ jsx(StageTask, {
-                                            selected: true,
-                                            isParallel: isActiveTaskParallel,
-                                            style: {
-                                                cursor: 'grabbing',
-                                                ...taskWidthStyle
-                                            },
-                                            children: /*#__PURE__*/ jsx(TaskContent, {
-                                                task: activeTask,
-                                                isDragging: true
-                                            })
-                                        })
-                                    }) : null
-                                }), document.body)
+                                /*#__PURE__*/ jsx(StageNode_StageTaskDragOverlay, {
+                                    activeTask: activeTask,
+                                    isActiveTaskParallel: isActiveTaskParallel,
+                                    taskWidthStyle: taskWidthStyle
+                                })
                             ]
                         }) : /*#__PURE__*/ jsx(Column, {
                             py: 2,
@@ -604,5 +659,30 @@ const StageNodeComponent = (props)=>{
         ]
     });
 };
+const StageNodeInnerMemo = /*#__PURE__*/ memo(StageNodeInner);
+const StageNodeComponent = ({ dragging, selected, id, width, execution, stageDetails, addTaskLabel, addTaskLoading, replaceTaskLabel, taskOptions, menuItems, pendingReplaceTask, onStageClick, onTaskAdd, onAddTaskFromToolbox, onTaskToolboxSearch, onTaskClick, onTaskGroupModification, onStageTitleChange, onTaskReorder, onReplaceTaskFromToolbox, onTaskPlay })=>/*#__PURE__*/ jsx(StageNodeInnerMemo, {
+        dragging: dragging,
+        selected: selected,
+        id: id,
+        width: width,
+        execution: execution,
+        stageDetails: stageDetails,
+        addTaskLabel: addTaskLabel,
+        addTaskLoading: addTaskLoading,
+        replaceTaskLabel: replaceTaskLabel,
+        taskOptions: taskOptions,
+        menuItems: menuItems,
+        pendingReplaceTask: pendingReplaceTask,
+        onStageClick: onStageClick,
+        onTaskAdd: onTaskAdd,
+        onAddTaskFromToolbox: onAddTaskFromToolbox,
+        onTaskToolboxSearch: onTaskToolboxSearch,
+        onTaskClick: onTaskClick,
+        onTaskGroupModification: onTaskGroupModification,
+        onStageTitleChange: onStageTitleChange,
+        onTaskReorder: onTaskReorder,
+        onReplaceTaskFromToolbox: onReplaceTaskFromToolbox,
+        onTaskPlay: onTaskPlay
+    });
 const StageNode = /*#__PURE__*/ memo(StageNodeComponent);
 export { StageNode };