@uipath/apollo-react 3.44.0 → 3.44.2-pr255.af80ea0

package/dist/canvas/components/TaskNode/TaskNode.stories.js

@@ -0,0 +1,515 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ConnectionMode, Panel, ReactFlowProvider, useEdgesState, useNodesState } from "../../xyflow/react.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { CrossStageDragProvider } from "../../hooks/CrossStageDragContext.js";
+import { useCrossStageTaskDrag } from "../../hooks/useCrossStageTaskDrag.js";
+import { useTaskCopyPaste } from "../../hooks/useTaskCopyPaste.js";
+import { DefaultCanvasTranslations } from "../../types.js";
+import { BaseCanvas } from "../BaseCanvas/index.js";
+import { CanvasPositionControls } from "../CanvasPositionControls.js";
+import { StageConnectionEdge } from "../StageNode/StageConnectionEdge.js";
+import { StageEdge } from "../StageNode/StageEdge.js";
+import { StageNode } from "../StageNode/StageNode.js";
+import { TaskIcon, TaskItemTypeValues } from "../TaskIcon/index.js";
+import { PlaceholderTaskNode } from "./PlaceholderTaskNode.js";
+import { TaskNode } from "./TaskNode.js";
+import { reorderTaskIds } from "./taskReorderUtils.js";
+import { calculateTaskPositions } from "./useTaskPositions.js";
+const meta = {
+    title: 'Canvas/StageNode/TaskNode',
+    parameters: {
+        layout: 'fullscreen'
+    }
+};
+const TaskNode_stories = meta;
+const StageNodeWrapper = (props)=>/*#__PURE__*/ jsx(StageNode, {
+        ...props,
+        ...props.data
+    });
+const TaskNodeWrapper = (props)=>/*#__PURE__*/ jsx(TaskNode, {
+        ...props
+    });
+function createTaskNodes(stageId, taskIds, tasks, stageWidth, onTaskClick, onTaskSelect) {
+    const positions = calculateTaskPositions(taskIds, stageWidth, tasks);
+    const nodes = [];
+    taskIds.forEach((group, groupIndex)=>{
+        group.forEach((taskId, taskIndex)=>{
+            const taskInfo = tasks[taskId];
+            if (!taskInfo) return;
+            const position = positions.get(taskId);
+            if (!position) return;
+            nodes.push({
+                id: taskId,
+                type: 'task',
+                parentId: stageId,
+                extent: 'parent',
+                position: {
+                    x: position.x,
+                    y: position.y
+                },
+                width: position.width,
+                data: {
+                    taskType: taskInfo.taskType,
+                    label: taskInfo.label,
+                    iconElement: taskInfo.icon,
+                    groupIndex,
+                    taskIndex,
+                    execution: taskInfo.execution,
+                    onTaskClick,
+                    onTaskSelect,
+                    width: position.width
+                }
+            });
+        });
+    });
+    return nodes;
+}
+const InteractiveCanvas = ({ initialTaskIds, tasks: initialTasks, stageWidth, stageLabel, showInstructions = true })=>{
+    const [taskIds, setTaskIds] = useState(initialTaskIds);
+    const [tasks, setTasks] = useState(initialTasks);
+    const [selectedTaskId, setSelectedTaskId] = useState(null);
+    const [actionLog, setActionLog] = useState('');
+    const displayTaskIds = useMemo(()=>taskIds, [
+        taskIds
+    ]);
+    const stageNode = useMemo(()=>({
+            id: 'stage-1',
+            type: 'stage',
+            position: {
+                x: 250,
+                y: 100
+            },
+            style: {
+                width: stageWidth
+            },
+            data: {
+                nodeType: 'case-management:Stage',
+                stageDetails: {
+                    label: stageLabel,
+                    taskIds: displayTaskIds
+                },
+                onTaskClick: (taskId)=>{
+                    setSelectedTaskId(taskId);
+                    setActionLog(`Selected: ${taskId}`);
+                }
+            }
+        }), [
+        displayTaskIds,
+        stageLabel,
+        stageWidth
+    ]);
+    const handleTaskClick = useCallback((taskId)=>{
+        setSelectedTaskId(taskId);
+        setActionLog(`Selected: ${taskId}`);
+    }, []);
+    const taskNodes = useMemo(()=>createTaskNodes('stage-1', displayTaskIds, tasks, stageWidth, handleTaskClick, setSelectedTaskId), [
+        displayTaskIds,
+        tasks,
+        stageWidth,
+        handleTaskClick
+    ]);
+    const allNodes = useMemo(()=>[
+            stageNode,
+            ...taskNodes
+        ], [
+        stageNode,
+        taskNodes
+    ]);
+    const [nodes, setNodes, onNodesChange] = useNodesState(allNodes);
+    const [edges, , onEdgesChange] = useEdgesState([]);
+    useEffect(()=>{
+        setNodes(allNodes);
+    }, [
+        allNodes,
+        setNodes
+    ]);
+    const nodeTypes = useMemo(()=>({
+            stage: StageNodeWrapper,
+            task: TaskNodeWrapper,
+            placeholder: (props)=>/*#__PURE__*/ jsx(PlaceholderTaskNode, {
+                    ...props
+                })
+        }), []);
+    const edgeTypes = useMemo(()=>({
+            stage: StageEdge
+        }), []);
+    const handleTaskReorder = useCallback((params)=>{
+        const { taskId, position } = params;
+        const depthLabel = position.isParallel ? 'parallel' : 'sequential';
+        setActionLog(`Reordered ${taskId} to group ${position.groupIndex} (${depthLabel})`);
+        setTaskIds((prev)=>{
+            const depth = position.isParallel ? 1 : 0;
+            return reorderTaskIds(prev, taskId, position.groupIndex, position.taskIndex, depth);
+        });
+    }, []);
+    const handleTaskPaste = useCallback((params)=>{
+        const { newTaskId, originalData } = params;
+        setActionLog(`Pasted as ${newTaskId}`);
+        setTasks((prev)=>({
+                ...prev,
+                [newTaskId]: {
+                    label: `${originalData.label} (Copy)`,
+                    taskType: originalData.taskType,
+                    icon: originalData.iconElement ?? /*#__PURE__*/ jsx(TaskIcon, {
+                        type: TaskItemTypeValues.AgenticProcess,
+                        size: "sm"
+                    }),
+                    execution: originalData.execution
+                }
+            }));
+        setTaskIds((prev)=>[
+                ...prev,
+                [
+                    newTaskId
+                ]
+            ]);
+    }, []);
+    return /*#__PURE__*/ jsx(ReactFlowProvider, {
+        children: /*#__PURE__*/ jsx(InteractiveCanvasInner, {
+            nodes: nodes,
+            edges: edges,
+            onNodesChange: onNodesChange,
+            onEdgesChange: onEdgesChange,
+            nodeTypes: nodeTypes,
+            edgeTypes: edgeTypes,
+            onTaskReorder: handleTaskReorder,
+            onTaskPaste: handleTaskPaste,
+            selectedTaskId: selectedTaskId,
+            targetTaskIds: taskIds,
+            actionLog: actionLog,
+            showInstructions: showInstructions
+        })
+    });
+};
+const InteractiveCanvasInner = ({ nodes, edges, onNodesChange, onEdgesChange, nodeTypes, edgeTypes, onTaskReorder, onTaskPaste, selectedTaskId, targetTaskIds, actionLog, showInstructions })=>{
+    const { dragState, handlers } = useCrossStageTaskDrag({
+        onTaskReorder
+    });
+    useTaskCopyPaste({
+        onTaskPaste
+    }, {
+        selectedTaskId,
+        targetStageId: 'stage-1',
+        targetTaskIds,
+        enabled: true
+    });
+    return /*#__PURE__*/ jsx(CrossStageDragProvider, {
+        value: {
+            dragState
+        },
+        children: /*#__PURE__*/ jsxs(BaseCanvas, {
+            nodes: nodes,
+            edges: edges,
+            onNodesChange: onNodesChange,
+            onEdgesChange: onEdgesChange,
+            nodeTypes: nodeTypes,
+            edgeTypes: edgeTypes,
+            mode: "design",
+            connectionMode: ConnectionMode.Strict,
+            defaultEdgeOptions: {
+                type: 'stage'
+            },
+            connectionLineComponent: StageConnectionEdge,
+            elevateEdgesOnSelect: true,
+            onNodeDragStart: handlers.onNodeDragStart,
+            onNodeDrag: handlers.onNodeDrag,
+            onNodeDragStop: handlers.onNodeDragStop,
+            fitView: true,
+            children: [
+                /*#__PURE__*/ jsx(Panel, {
+                    position: "bottom-right",
+                    children: /*#__PURE__*/ jsx(CanvasPositionControls, {
+                        translations: DefaultCanvasTranslations
+                    })
+                }),
+                showInstructions && /*#__PURE__*/ jsx(Panel, {
+                    position: "bottom-left",
+                    children: /*#__PURE__*/ jsxs("div", {
+                        style: {
+                            background: 'var(--uix-palette-surface-paper)',
+                            padding: '8px 16px',
+                            borderRadius: '4px',
+                            boxShadow: '0 2px 4px rgba(0,0,0,0.1)',
+                            maxWidth: '300px'
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("strong", {
+                                children: "Instructions:"
+                            }),
+                            /*#__PURE__*/ jsxs("ul", {
+                                style: {
+                                    margin: '8px 0',
+                                    paddingLeft: '16px',
+                                    fontSize: '12px'
+                                },
+                                children: [
+                                    /*#__PURE__*/ jsx("li", {
+                                        children: "Click a task to select it"
+                                    }),
+                                    /*#__PURE__*/ jsx("li", {
+                                        children: "Drag tasks to reorder"
+                                    }),
+                                    /*#__PURE__*/ jsx("li", {
+                                        children: "Ctrl/Cmd+C to copy selected task"
+                                    }),
+                                    /*#__PURE__*/ jsx("li", {
+                                        children: "Ctrl/Cmd+V to paste task"
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                }),
+                actionLog && /*#__PURE__*/ jsx(Panel, {
+                    position: "top-left",
+                    children: /*#__PURE__*/ jsx("div", {
+                        style: {
+                            background: 'var(--uix-palette-surface-paper)',
+                            padding: '8px 16px',
+                            borderRadius: '4px',
+                            boxShadow: '0 2px 4px rgba(0,0,0,0.1)'
+                        },
+                        children: actionLog
+                    })
+                }),
+                dragState.isDragging && /*#__PURE__*/ jsx(Panel, {
+                    position: "top-right",
+                    children: /*#__PURE__*/ jsxs("div", {
+                        style: {
+                            background: 'var(--uix-palette-info-light)',
+                            padding: '8px 16px',
+                            borderRadius: '4px'
+                        },
+                        children: [
+                            "Dragging ",
+                            dragState.taskId,
+                            dragState.dropPosition && /*#__PURE__*/ jsxs("div", {
+                                style: {
+                                    fontSize: '12px'
+                                },
+                                children: [
+                                    "→ Group ",
+                                    dragState.dropPosition.groupIndex,
+                                    dragState.dropPosition.isParallel ? ' (Parallel)' : ' (Sequential)',
+                                    /*#__PURE__*/ jsx("div", {
+                                        style: {
+                                            fontSize: '10px',
+                                            marginTop: '4px'
+                                        },
+                                        children: "Drag right to make parallel"
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                })
+            ]
+        })
+    });
+};
+const Basic = {
+    render: ()=>{
+        const tasks = {
+            'task-1': {
+                label: 'Process Document',
+                taskType: 'uipath.case-management.process',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.AgenticProcess,
+                    size: "sm"
+                })
+            },
+            'task-2': {
+                label: 'Run Human Action',
+                taskType: 'uipath.case-management.run-human-action',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.User,
+                    size: "sm"
+                })
+            },
+            'task-3': {
+                label: 'Execute RPA',
+                taskType: 'uipath.case-management.rpa',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.Automation,
+                    size: "sm"
+                })
+            }
+        };
+        return /*#__PURE__*/ jsx("div", {
+            style: {
+                width: '100vw',
+                height: '100vh'
+            },
+            children: /*#__PURE__*/ jsx(InteractiveCanvas, {
+                initialTaskIds: [
+                    [
+                        'task-1'
+                    ],
+                    [
+                        'task-2'
+                    ],
+                    [
+                        'task-3'
+                    ]
+                ],
+                tasks: tasks,
+                stageWidth: 304,
+                stageLabel: "Processing Stage"
+            })
+        });
+    }
+};
+const WithExecutionStatus = {
+    render: ()=>{
+        const tasks = {
+            'task-1': {
+                label: 'Completed Task',
+                taskType: 'uipath.case-management.process',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.AgenticProcess,
+                    size: "sm"
+                }),
+                execution: {
+                    status: 'Completed',
+                    duration: '2m 30s'
+                }
+            },
+            'task-2': {
+                label: 'In Progress Task',
+                taskType: 'uipath.case-management.run-human-action',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.User,
+                    size: "sm"
+                }),
+                execution: {
+                    status: 'InProgress',
+                    duration: '1m 15s'
+                }
+            },
+            'task-3': {
+                label: 'Failed Task with Retries',
+                taskType: 'uipath.case-management.rpa',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.Automation,
+                    size: "sm"
+                }),
+                execution: {
+                    status: 'Failed',
+                    duration: '0m 45s',
+                    retryDuration: '0m 30s',
+                    message: 'Connection timeout',
+                    badge: 'Error',
+                    badgeStatus: 'error',
+                    retryCount: 2
+                }
+            },
+            'task-4': {
+                label: 'Pending Task',
+                taskType: 'uipath.case-management.action',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.Agent,
+                    size: "sm"
+                }),
+                execution: {
+                    status: 'NotExecuted'
+                }
+            }
+        };
+        return /*#__PURE__*/ jsx("div", {
+            style: {
+                width: '100vw',
+                height: '100vh'
+            },
+            children: /*#__PURE__*/ jsx(InteractiveCanvas, {
+                initialTaskIds: [
+                    [
+                        'task-1'
+                    ],
+                    [
+                        'task-2'
+                    ],
+                    [
+                        'task-3'
+                    ],
+                    [
+                        'task-4'
+                    ]
+                ],
+                tasks: tasks,
+                stageWidth: 304,
+                stageLabel: "Stage with Execution"
+            })
+        });
+    }
+};
+const ParallelTasks = {
+    render: ()=>{
+        const tasks = {
+            'task-1': {
+                label: 'Pre-check',
+                taskType: 'uipath.case-management.action',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.AgenticProcess,
+                    size: "sm"
+                })
+            },
+            'task-2': {
+                label: 'Address Verification',
+                taskType: 'uipath.case-management.process',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.User,
+                    size: "sm"
+                })
+            },
+            'task-3': {
+                label: 'Property Verification',
+                taskType: 'uipath.case-management.process',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.User,
+                    size: "sm"
+                })
+            },
+            'task-4': {
+                label: 'Background Check',
+                taskType: 'uipath.case-management.process',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.Automation,
+                    size: "sm"
+                })
+            },
+            'task-5': {
+                label: 'Final Review',
+                taskType: 'uipath.case-management.agent',
+                icon: /*#__PURE__*/ jsx(TaskIcon, {
+                    type: TaskItemTypeValues.Agent,
+                    size: "sm"
+                })
+            }
+        };
+        return /*#__PURE__*/ jsx("div", {
+            style: {
+                width: '100vw',
+                height: '100vh'
+            },
+            children: /*#__PURE__*/ jsx(InteractiveCanvas, {
+                initialTaskIds: [
+                    [
+                        'task-1'
+                    ],
+                    [
+                        'task-2',
+                        'task-3',
+                        'task-4'
+                    ],
+                    [
+                        'task-5'
+                    ]
+                ],
+                tasks: tasks,
+                stageWidth: 304,
+                stageLabel: "Parallel Task Demo"
+            })
+        });
+    }
+};
+export { Basic, ParallelTasks, WithExecutionStatus, TaskNode_stories as default };

package/dist/canvas/components/TaskNode/TaskNode.types.d.ts

@@ -0,0 +1,40 @@
+import type { Node, NodeProps } from '@xyflow/react';
+import type { NodeMenuItem } from '../NodeContextMenu';
+import type { StageTaskExecution } from '../StageNode/StageNode.types';
+export type TaskType = 'process' | 'agent' | 'external-agent' | 'rpa' | 'action' | 'api-workflow' | 'wait-for-timer' | 'wait-for-connector' | 'run-human-action' | 'execute-connector-activity';
+export interface TaskNodeData extends Record<string, unknown> {
+    taskType: string;
+    label: string;
+    icon?: string;
+    iconElement?: React.ReactElement;
+    groupIndex: number;
+    taskIndex: number;
+    execution?: StageTaskExecution;
+    onTaskClick?: (taskId: string) => void;
+    onTaskSelect?: (taskId: string) => void;
+    width?: number;
+    contextMenuItems?: NodeMenuItem[];
+    onMenuOpenChange?: (isOpen: boolean) => void;
+}
+export type TaskNode = Node<TaskNodeData, 'task'>;
+export interface TaskNodeProps extends NodeProps<TaskNode> {
+    dragging: boolean;
+    selected: boolean;
+}
+export interface TaskPosition {
+    x: number;
+    y: number;
+    width: number;
+}
+export interface TaskPositionConfig {
+    stageBorderThickness: number;
+    taskHeight: number;
+    taskGap: number;
+    parallelIndent: number;
+    contentPaddingTop: number;
+    contentPaddingBottom: number;
+    contentPaddingX: number;
+    headerHeight: number;
+    headerExecutionDescriptionHeight: number;
+}
+//# sourceMappingURL=TaskNode.types.d.ts.map

package/dist/canvas/components/TaskNode/TaskNode.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskNode.types.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/TaskNode/TaskNode.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAMvE,MAAM,MAAM,QAAQ,GAChB,SAAS,GACT,OAAO,GACP,gBAAgB,GAChB,KAAK,GACL,QAAQ,GACR,cAAc,GACd,gBAAgB,GAChB,oBAAoB,GACpB,kBAAkB,GAClB,4BAA4B,CAAC;AAMjC,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAE3D,QAAQ,EAAE,MAAM,CAAC;IAEjB,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,WAAW,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC;IAEjC,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAE/B,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEvC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAExC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC;IAElC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C;AAKD,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;AAKlD,MAAM,WAAW,aAAc,SAAQ,SAAS,CAAC,QAAQ,CAAC;IAExD,QAAQ,EAAE,OAAO,CAAC;IAElB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAKD,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,MAAM,WAAW,kBAAkB;IAEjC,oBAAoB,EAAE,MAAM,CAAC;IAE7B,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,MAAM,CAAC;IAEvB,iBAAiB,EAAE,MAAM,CAAC;IAE1B,oBAAoB,EAAE,MAAM,CAAC;IAE7B,eAAe,EAAE,MAAM,CAAC;IAExB,YAAY,EAAE,MAAM,CAAC;IAErB,gCAAgC,EAAE,MAAM,CAAC;CAC1C"}

package/dist/canvas/components/TaskNode/TaskNodeContext.cjs

@@ -0,0 +1,86 @@
+"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 ('undefined' != 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__, {
+    useIsTaskParallel: ()=>useIsTaskParallel,
+    useOptionalTaskNodeContext: ()=>useOptionalTaskNodeContext,
+    useTaskNodeContext: ()=>useTaskNodeContext,
+    TaskNodeProvider: ()=>TaskNodeProvider,
+    useTaskGroupInfo: ()=>useTaskGroupInfo
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const TaskNodeContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+function TaskNodeProvider({ children, value }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(TaskNodeContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+function useTaskNodeContext() {
+    const context = (0, external_react_namespaceObject.useContext)(TaskNodeContext);
+    if (!context) throw new Error('useTaskNodeContext must be used within a TaskNodeProvider');
+    return context;
+}
+function useIsTaskParallel(taskId) {
+    const context = (0, external_react_namespaceObject.useContext)(TaskNodeContext);
+    if (!context) return false;
+    for (const group of context.taskIds)if (group.includes(taskId)) return group.length > 1;
+    return false;
+}
+function useTaskGroupInfo(taskId) {
+    const context = (0, external_react_namespaceObject.useContext)(TaskNodeContext);
+    if (!context) return null;
+    for(let groupIndex = 0; groupIndex < context.taskIds.length; groupIndex++){
+        const group = context.taskIds[groupIndex];
+        if (!group) continue;
+        const taskIndex = group.indexOf(taskId);
+        if (-1 !== taskIndex) return {
+            groupIndex,
+            taskIndex,
+            isParallel: group.length > 1,
+            groupSize: group.length
+        };
+    }
+    return null;
+}
+function useOptionalTaskNodeContext() {
+    return (0, external_react_namespaceObject.useContext)(TaskNodeContext);
+}
+exports.TaskNodeProvider = __webpack_exports__.TaskNodeProvider;
+exports.useIsTaskParallel = __webpack_exports__.useIsTaskParallel;
+exports.useOptionalTaskNodeContext = __webpack_exports__.useOptionalTaskNodeContext;
+exports.useTaskGroupInfo = __webpack_exports__.useTaskGroupInfo;
+exports.useTaskNodeContext = __webpack_exports__.useTaskNodeContext;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "TaskNodeProvider",
+    "useIsTaskParallel",
+    "useOptionalTaskNodeContext",
+    "useTaskGroupInfo",
+    "useTaskNodeContext"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/TaskNode/TaskNodeContext.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+export interface TaskNodeContextValue {
+    stageId: string;
+    stageNodeType: string;
+    taskIds: string[][];
+    isReadOnly?: boolean;
+    onTaskClick?: (taskId: string) => void;
+    onTaskSelect?: (taskId: string) => void;
+}
+export interface TaskNodeProviderProps {
+    children: ReactNode;
+    value: TaskNodeContextValue;
+}
+export declare function TaskNodeProvider({ children, value }: TaskNodeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTaskNodeContext(): TaskNodeContextValue;
+export declare function useIsTaskParallel(taskId: string): boolean;
+export declare function useTaskGroupInfo(taskId: string): {
+    groupIndex: number;
+    taskIndex: number;
+    isParallel: boolean;
+    groupSize: number;
+} | null;
+export declare function useOptionalTaskNodeContext(): TaskNodeContextValue | null;
+//# sourceMappingURL=TaskNodeContext.d.ts.map

package/dist/canvas/components/TaskNode/TaskNodeContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskNodeContext.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/TaskNode/TaskNodeContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAKlE,MAAM,WAAW,oBAAoB;IAEnC,OAAO,EAAE,MAAM,CAAC;IAEhB,aAAa,EAAE,MAAM,CAAC;IAEtB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IAEpB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEvC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAOD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,oBAAoB,CAAC;CAC7B;AAED,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,qBAAqB,2CAM1E;AAMD,wBAAgB,kBAAkB,IAAI,oBAAoB,CAMzD;AAOD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAUzD;AAOD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,IAAI,CAkBP;AAKD,wBAAgB,0BAA0B,IAAI,oBAAoB,GAAG,IAAI,CAExE"}