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

package/dist/canvas/hooks/useCrossStageTaskDrag.js

@@ -0,0 +1,312 @@
+import { useReactFlow } from "@xyflow/react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { insertTaskAtPosition, removeTaskFromTaskIds } from "../components/TaskNode/taskReorderUtils.js";
+import { DEFAULT_TASK_POSITION_CONFIG, calculateTaskPositions } from "../components/TaskNode/useTaskPositions.js";
+import { calculateDropPosition, convertToGroupPosition } from "./calculateTaskDropPosition.js";
+function isPointInStage(x, y, stageX, stageY, stageWidth, stageHeight) {
+    return x >= stageX && x <= stageX + stageWidth && y >= stageY && y <= stageY + stageHeight;
+}
+function useCrossStageTaskDrag(callbacks = {}) {
+    const { setNodes, getNodes } = useReactFlow();
+    const { onTaskMove, onTaskCopy, onTaskReorder } = callbacks;
+    const [dragState, setDragState] = useState({
+        isDragging: false,
+        taskId: null,
+        sourceStageId: null,
+        targetStageId: null,
+        isCopyMode: false,
+        dropPosition: null
+    });
+    const isCopyModeRef = useRef(false);
+    const isDraggingRef = useRef(false);
+    const draggedTaskIdRef = useRef(null);
+    const sourceStageIdRef = useRef(null);
+    const currentDropPositionRef = useRef(null);
+    const currentTargetStageRef = useRef(null);
+    const lastDropPositionRef = useRef(null);
+    useEffect(()=>{
+        if (!dragState.isDragging || !dragState.dropPosition || !dragState.taskId || !dragState.targetStageId) {
+            lastDropPositionRef.current = null;
+            return;
+        }
+        const { groupIndex, taskIndex, isParallel } = dragState.dropPosition;
+        const lastPos = lastDropPositionRef.current;
+        if (lastPos && lastPos.groupIndex === groupIndex && lastPos.taskIndex === taskIndex && lastPos.isParallel === isParallel && lastPos.targetStageId === dragState.targetStageId) return;
+        lastDropPositionRef.current = {
+            groupIndex,
+            taskIndex,
+            isParallel,
+            targetStageId: dragState.targetStageId
+        };
+        const allNodes = getNodes();
+        const targetStage = allNodes.find((n)=>n.id === dragState.targetStageId);
+        if (!targetStage) return;
+        const targetStageData = targetStage.data;
+        const stageDetails = targetStageData?.stageDetails;
+        const taskIds = stageDetails?.taskIds || [];
+        const filteredTaskIds = removeTaskFromTaskIds(taskIds, dragState.taskId);
+        const placeholderId = '__placeholder__';
+        const taskIdsWithPlaceholder = insertTaskAtPosition(filteredTaskIds, placeholderId, {
+            groupIndex,
+            taskIndex,
+            isParallel
+        });
+        const stageWidth = targetStage.style?.width || 304;
+        setNodes((currentNodes)=>{
+            const positions = calculateTaskPositions(taskIdsWithPlaceholder, stageWidth, currentNodes);
+            const getOriginalPositions = (stageId)=>{
+                const stage = currentNodes.find((s)=>s.id === stageId);
+                if (!stage) return null;
+                const stageData = stage.data;
+                const details = stageData?.stageDetails;
+                const stageTaskIds = details?.taskIds || [];
+                const filteredIds = dragState.taskId ? removeTaskFromTaskIds(stageTaskIds, dragState.taskId) : stageTaskIds;
+                const width = stage.style?.width || 304;
+                return calculateTaskPositions(filteredIds, width, currentNodes);
+            };
+            let updatedNodes = currentNodes.map((n)=>{
+                if ('task' === n.type && n.id !== dragState.taskId && n.parentId === dragState.targetStageId) {
+                    const pos = positions.get(n.id);
+                    if (pos) return {
+                        ...n,
+                        position: {
+                            x: pos.x,
+                            y: pos.y
+                        }
+                    };
+                }
+                if ('task' === n.type && n.id !== dragState.taskId && dragState.sourceStageId && dragState.sourceStageId !== dragState.targetStageId && n.parentId === dragState.sourceStageId) {
+                    const sourcePositions = getOriginalPositions(dragState.sourceStageId);
+                    if (sourcePositions) {
+                        const pos = sourcePositions.get(n.id);
+                        if (pos) return {
+                            ...n,
+                            position: {
+                                x: pos.x,
+                                y: pos.y
+                            }
+                        };
+                    }
+                }
+                if ('task' === n.type && n.id !== dragState.taskId && n.parentId !== dragState.targetStageId && n.parentId !== dragState.sourceStageId) {
+                    const otherPositions = getOriginalPositions(n.parentId);
+                    if (otherPositions) {
+                        const pos = otherPositions.get(n.id);
+                        if (pos) return {
+                            ...n,
+                            position: {
+                                x: pos.x,
+                                y: pos.y
+                            }
+                        };
+                    }
+                }
+                return n;
+            });
+            updatedNodes = updatedNodes.filter((n)=>'__placeholder__' !== n.id);
+            const placeholderPos = positions.get(placeholderId);
+            if (placeholderPos && dragState.targetStageId) updatedNodes.push({
+                id: '__placeholder__',
+                type: 'placeholder',
+                parentId: dragState.targetStageId,
+                extent: 'parent',
+                position: {
+                    x: placeholderPos.x,
+                    y: placeholderPos.y
+                },
+                width: placeholderPos.width,
+                data: {
+                    isParallel
+                },
+                draggable: false,
+                selectable: false,
+                focusable: false
+            });
+            return updatedNodes;
+        });
+    }, [
+        dragState,
+        setNodes,
+        getNodes
+    ]);
+    const handleKeyDown = useCallback((e)=>{
+        if (e.altKey || e.metaKey) {
+            isCopyModeRef.current = true;
+            setDragState((prev)=>({
+                    ...prev,
+                    isCopyMode: true
+                }));
+        }
+    }, []);
+    const handleKeyUp = useCallback((e)=>{
+        if (!e.altKey && !e.metaKey) {
+            isCopyModeRef.current = false;
+            setDragState((prev)=>({
+                    ...prev,
+                    isCopyMode: false
+                }));
+        }
+    }, []);
+    const onNodeDragStart = useCallback((_event, node, _nodes)=>{
+        if ('task' !== node.type) return;
+        const sourceStageId = node.parentId;
+        if (!sourceStageId) return;
+        isDraggingRef.current = true;
+        draggedTaskIdRef.current = node.id;
+        sourceStageIdRef.current = sourceStageId;
+        currentTargetStageRef.current = sourceStageId;
+        setDragState({
+            isDragging: true,
+            taskId: node.id,
+            sourceStageId,
+            targetStageId: sourceStageId,
+            isCopyMode: isCopyModeRef.current,
+            dropPosition: null
+        });
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+    }, [
+        handleKeyDown,
+        handleKeyUp
+    ]);
+    const onNodeDrag = useCallback((_event, node, _nodes)=>{
+        if ('task' !== node.type || !dragState.isDragging) return;
+        const allNodes = getNodes();
+        const nodeWidth = node.width || DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+        const nodeHeight = node.measured?.height || DEFAULT_TASK_POSITION_CONFIG.taskHeight;
+        const parentStage = allNodes.find((n)=>n.id === node.parentId);
+        const absoluteX = (parentStage?.position.x || 0) + node.position.x;
+        const absoluteY = (parentStage?.position.y || 0) + node.position.y;
+        const nodeCenterX = absoluteX + nodeWidth / 2;
+        const nodeCenterY = absoluteY + nodeHeight / 2;
+        const stageNodes = allNodes.filter((n)=>{
+            const nodeType = n.data?.nodeType;
+            return 'stage' === n.type || 'stageV2' === n.type || 'string' == typeof nodeType && nodeType.includes('Stage');
+        });
+        let targetStage;
+        for (const stage of stageNodes){
+            const stageWidth = stage.style?.width || stage.width || 304;
+            const stageHeight = stage.style?.height || stage.measured?.height || 200;
+            if (isPointInStage(nodeCenterX, nodeCenterY, stage.position.x, stage.position.y, stageWidth, stageHeight)) {
+                targetStage = stage;
+                break;
+            }
+        }
+        if (targetStage) {
+            const targetStageData = targetStage.data;
+            const stageDetails = targetStageData?.stageDetails;
+            const taskIds = stageDetails?.taskIds || [];
+            const stageWidth = targetStage.style?.width || 304;
+            const relativeX = absoluteX - targetStage.position.x;
+            const relativeY = absoluteY - targetStage.position.y;
+            const dropPos = calculateDropPosition(relativeY, nodeHeight, relativeX, nodeWidth, stageWidth, taskIds, node.id);
+            const filteredTaskIds = taskIds.map((g)=>g.filter((id)=>id !== node.id)).filter((g)=>g.length > 0);
+            const { groupIndex, taskIndex } = convertToGroupPosition(dropPos.index, dropPos.isParallel, filteredTaskIds, dropPos.draggedYCenter, taskIds);
+            currentDropPositionRef.current = {
+                groupIndex,
+                taskIndex,
+                isParallel: dropPos.isParallel
+            };
+            currentTargetStageRef.current = targetStage.id;
+            setDragState((prev)=>({
+                    ...prev,
+                    targetStageId: targetStage.id,
+                    dropPosition: {
+                        groupIndex,
+                        taskIndex,
+                        isParallel: dropPos.isParallel
+                    }
+                }));
+        }
+    }, [
+        dragState.isDragging,
+        getNodes
+    ]);
+    const onNodeDragStop = useCallback((_event, node, _nodes)=>{
+        if ('task' !== node.type || !isDraggingRef.current) return;
+        window.removeEventListener('keydown', handleKeyDown);
+        window.removeEventListener('keyup', handleKeyUp);
+        const taskId = draggedTaskIdRef.current;
+        const sourceStageId = sourceStageIdRef.current;
+        const isCopyMode = isCopyModeRef.current;
+        const dropPosition = currentDropPositionRef.current;
+        const targetStageId = currentTargetStageRef.current;
+        if (taskId && sourceStageId && targetStageId && dropPosition) {
+            const isCrossStage = sourceStageId !== targetStageId;
+            if (isCrossStage) if (isCopyMode) {
+                const newTaskId = `task-${crypto.randomUUID()}`;
+                onTaskCopy?.({
+                    taskId,
+                    newTaskId,
+                    sourceStageId,
+                    targetStageId,
+                    position: dropPosition
+                });
+            } else onTaskMove?.({
+                taskId,
+                sourceStageId,
+                targetStageId,
+                position: dropPosition
+            });
+            else onTaskReorder?.({
+                taskId,
+                stageId: sourceStageId,
+                position: dropPosition
+            });
+        }
+        isDraggingRef.current = false;
+        draggedTaskIdRef.current = null;
+        sourceStageIdRef.current = null;
+        currentDropPositionRef.current = null;
+        currentTargetStageRef.current = null;
+        setNodes((nodes)=>{
+            const filteredNodes = nodes.filter((n)=>'__placeholder__' !== n.id);
+            const draggedNode = filteredNodes.find((n)=>n.id === taskId);
+            if (!draggedNode || !draggedNode.parentId) return filteredNodes;
+            const parentStage = filteredNodes.find((n)=>n.id === draggedNode.parentId);
+            if (!parentStage) return filteredNodes;
+            const stageData = parentStage.data;
+            const stageDetails = stageData?.stageDetails;
+            const stageTaskIds = stageDetails?.taskIds || [];
+            const stageWidth = parentStage.style?.width || 304;
+            const positions = calculateTaskPositions(stageTaskIds, stageWidth, filteredNodes);
+            return filteredNodes.map((n)=>{
+                if ('task' === n.type && n.parentId === draggedNode.parentId) {
+                    const pos = positions.get(n.id);
+                    if (pos) return {
+                        ...n,
+                        position: {
+                            x: pos.x,
+                            y: pos.y
+                        }
+                    };
+                }
+                return n;
+            });
+        });
+        setDragState({
+            isDragging: false,
+            taskId: null,
+            sourceStageId: null,
+            targetStageId: null,
+            isCopyMode: false,
+            dropPosition: null
+        });
+    }, [
+        handleKeyDown,
+        handleKeyUp,
+        onTaskCopy,
+        onTaskMove,
+        onTaskReorder,
+        setNodes
+    ]);
+    return {
+        dragState,
+        handlers: {
+            onNodeDragStart,
+            onNodeDrag,
+            onNodeDragStop
+        }
+    };
+}
+export { useCrossStageTaskDrag };

package/dist/canvas/hooks/useTaskCopyPaste.cjs

@@ -0,0 +1,155 @@
+"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__, {
+    useTaskCopyPaste: ()=>useTaskCopyPaste
+});
+const react_namespaceObject = require("@xyflow/react");
+const external_react_namespaceObject = require("react");
+function useTaskCopyPaste(callbacks = {}, options = {}) {
+    const { getNode } = (0, react_namespaceObject.useReactFlow)();
+    const { onTaskPaste, onTaskCopy } = callbacks;
+    const { selectedTaskId = null, targetStageId = null, targetTaskIds = [], enabled = true } = options;
+    const [clipboard, setClipboard] = (0, external_react_namespaceObject.useState)(null);
+    const selectedTaskIdRef = (0, external_react_namespaceObject.useRef)(selectedTaskId);
+    const targetStageIdRef = (0, external_react_namespaceObject.useRef)(targetStageId);
+    const targetTaskIdsRef = (0, external_react_namespaceObject.useRef)(targetTaskIds);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        selectedTaskIdRef.current = selectedTaskId;
+        targetStageIdRef.current = targetStageId;
+        targetTaskIdsRef.current = targetTaskIds;
+    }, [
+        selectedTaskId,
+        targetStageId,
+        targetTaskIds
+    ]);
+    const copyTask = (0, external_react_namespaceObject.useCallback)(()=>{
+        const taskId = selectedTaskIdRef.current;
+        if (!taskId) return false;
+        const taskNode = getNode(taskId);
+        if (!taskNode || 'task' !== taskNode.type) return false;
+        const taskData = taskNode.data;
+        const sourceStageId = taskNode.parentId;
+        if (!sourceStageId) return false;
+        const clipboardTask = {
+            originalId: taskId,
+            sourceStageId,
+            data: {
+                taskType: taskData.taskType,
+                label: taskData.label,
+                icon: taskData.icon,
+                iconElement: taskData.iconElement,
+                execution: taskData.execution
+            }
+        };
+        setClipboard(clipboardTask);
+        onTaskCopy?.(clipboardTask);
+        return true;
+    }, [
+        getNode,
+        onTaskCopy
+    ]);
+    const pasteTask = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (!clipboard) return false;
+        const targetId = targetStageIdRef.current;
+        if (!targetId) return false;
+        const targetNode = getNode(targetId);
+        if (!targetNode) return false;
+        const nodeType = targetNode.type;
+        const nodeData = targetNode.data;
+        const dataNodeType = nodeData?.nodeType;
+        const isStage = 'stage' === nodeType || 'stageV2' === nodeType || 'string' == typeof dataNodeType && dataNodeType.includes('Stage');
+        if (!isStage) return false;
+        const newTaskId = `task-${crypto.randomUUID()}`;
+        const currentTaskIds = targetTaskIdsRef.current;
+        const position = {
+            groupIndex: currentTaskIds.length,
+            taskIndex: 0
+        };
+        onTaskPaste?.({
+            newTaskId,
+            originalData: clipboard.data,
+            sourceStageId: clipboard.sourceStageId,
+            targetStageId: targetId,
+            position
+        });
+        return true;
+    }, [
+        clipboard,
+        getNode,
+        onTaskPaste
+    ]);
+    const hasClipboardContent = null !== clipboard;
+    const clearClipboard = (0, external_react_namespaceObject.useCallback)(()=>{
+        setClipboard(null);
+    }, []);
+    const handleKeyDown = (0, external_react_namespaceObject.useCallback)((event)=>{
+        if (!enabled) return;
+        const isModifierPressed = event.ctrlKey || event.metaKey;
+        if (!isModifierPressed) return;
+        const target = event.target;
+        if ('INPUT' === target.tagName || 'TEXTAREA' === target.tagName || target.isContentEditable) return;
+        switch(event.key.toLowerCase()){
+            case 'c':
+                if (copyTask()) event.preventDefault();
+                break;
+            case 'v':
+                if (pasteTask()) event.preventDefault();
+                break;
+        }
+    }, [
+        enabled,
+        copyTask,
+        pasteTask
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled) return;
+        window.addEventListener('keydown', handleKeyDown, {
+            capture: true
+        });
+        return ()=>{
+            window.removeEventListener('keydown', handleKeyDown, {
+                capture: true
+            });
+        };
+    }, [
+        enabled,
+        handleKeyDown
+    ]);
+    return {
+        clipboard,
+        hasClipboardContent,
+        copyTask,
+        pasteTask,
+        clearClipboard
+    };
+}
+exports.useTaskCopyPaste = __webpack_exports__.useTaskCopyPaste;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useTaskCopyPaste"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,34 @@
+import type { TaskNodeData } from '../components/TaskNode/TaskNode.types';
+export interface ClipboardTask {
+    originalId: string;
+    sourceStageId: string;
+    data: Omit<TaskNodeData, 'groupIndex' | 'taskIndex'>;
+}
+export interface TaskPasteParams {
+    newTaskId: string;
+    originalData: Omit<TaskNodeData, 'groupIndex' | 'taskIndex'>;
+    sourceStageId: string;
+    targetStageId: string;
+    position: {
+        groupIndex: number;
+        taskIndex: number;
+    };
+}
+export interface TaskCopyPasteCallbacks {
+    onTaskPaste?: (params: TaskPasteParams) => void;
+    onTaskCopy?: (task: ClipboardTask) => void;
+}
+export interface UseTaskCopyPasteOptions {
+    selectedTaskId?: string | null;
+    targetStageId?: string | null;
+    targetTaskIds?: string[][];
+    enabled?: boolean;
+}
+export declare function useTaskCopyPaste(callbacks?: TaskCopyPasteCallbacks, options?: UseTaskCopyPasteOptions): {
+    clipboard: ClipboardTask | null;
+    hasClipboardContent: boolean;
+    copyTask: () => boolean;
+    pasteTask: () => boolean;
+    clearClipboard: () => void;
+};
+//# sourceMappingURL=useTaskCopyPaste.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTaskCopyPaste.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/useTaskCopyPaste.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAK1E,MAAM,WAAW,aAAa;IAE5B,UAAU,EAAE,MAAM,CAAC;IAEnB,aAAa,EAAE,MAAM,CAAC;IAEtB,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,WAAW,CAAC,CAAC;CACtD;AAKD,MAAM,WAAW,eAAe;IAE9B,SAAS,EAAE,MAAM,CAAC;IAElB,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,WAAW,CAAC,CAAC;IAE7D,aAAa,EAAE,MAAM,CAAC;IAEtB,aAAa,EAAE,MAAM,CAAC;IAEtB,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAKD,MAAM,WAAW,sBAAsB;IAErC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IAEhD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;CAC5C;AAKD,MAAM,WAAW,uBAAuB;IAEtC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAE3B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAKD,wBAAgB,gBAAgB,CAC9B,SAAS,GAAE,sBAA2B,EACtC,OAAO,GAAE,uBAA4B;;;;;;EA2KtC"}

package/dist/canvas/hooks/useTaskCopyPaste.js

@@ -0,0 +1,121 @@
+import { useReactFlow } from "@xyflow/react";
+import { useCallback, useEffect, useRef, useState } from "react";
+function useTaskCopyPaste(callbacks = {}, options = {}) {
+    const { getNode } = useReactFlow();
+    const { onTaskPaste, onTaskCopy } = callbacks;
+    const { selectedTaskId = null, targetStageId = null, targetTaskIds = [], enabled = true } = options;
+    const [clipboard, setClipboard] = useState(null);
+    const selectedTaskIdRef = useRef(selectedTaskId);
+    const targetStageIdRef = useRef(targetStageId);
+    const targetTaskIdsRef = useRef(targetTaskIds);
+    useEffect(()=>{
+        selectedTaskIdRef.current = selectedTaskId;
+        targetStageIdRef.current = targetStageId;
+        targetTaskIdsRef.current = targetTaskIds;
+    }, [
+        selectedTaskId,
+        targetStageId,
+        targetTaskIds
+    ]);
+    const copyTask = useCallback(()=>{
+        const taskId = selectedTaskIdRef.current;
+        if (!taskId) return false;
+        const taskNode = getNode(taskId);
+        if (!taskNode || 'task' !== taskNode.type) return false;
+        const taskData = taskNode.data;
+        const sourceStageId = taskNode.parentId;
+        if (!sourceStageId) return false;
+        const clipboardTask = {
+            originalId: taskId,
+            sourceStageId,
+            data: {
+                taskType: taskData.taskType,
+                label: taskData.label,
+                icon: taskData.icon,
+                iconElement: taskData.iconElement,
+                execution: taskData.execution
+            }
+        };
+        setClipboard(clipboardTask);
+        onTaskCopy?.(clipboardTask);
+        return true;
+    }, [
+        getNode,
+        onTaskCopy
+    ]);
+    const pasteTask = useCallback(()=>{
+        if (!clipboard) return false;
+        const targetId = targetStageIdRef.current;
+        if (!targetId) return false;
+        const targetNode = getNode(targetId);
+        if (!targetNode) return false;
+        const nodeType = targetNode.type;
+        const nodeData = targetNode.data;
+        const dataNodeType = nodeData?.nodeType;
+        const isStage = 'stage' === nodeType || 'stageV2' === nodeType || 'string' == typeof dataNodeType && dataNodeType.includes('Stage');
+        if (!isStage) return false;
+        const newTaskId = `task-${crypto.randomUUID()}`;
+        const currentTaskIds = targetTaskIdsRef.current;
+        const position = {
+            groupIndex: currentTaskIds.length,
+            taskIndex: 0
+        };
+        onTaskPaste?.({
+            newTaskId,
+            originalData: clipboard.data,
+            sourceStageId: clipboard.sourceStageId,
+            targetStageId: targetId,
+            position
+        });
+        return true;
+    }, [
+        clipboard,
+        getNode,
+        onTaskPaste
+    ]);
+    const hasClipboardContent = null !== clipboard;
+    const clearClipboard = useCallback(()=>{
+        setClipboard(null);
+    }, []);
+    const handleKeyDown = useCallback((event)=>{
+        if (!enabled) return;
+        const isModifierPressed = event.ctrlKey || event.metaKey;
+        if (!isModifierPressed) return;
+        const target = event.target;
+        if ('INPUT' === target.tagName || 'TEXTAREA' === target.tagName || target.isContentEditable) return;
+        switch(event.key.toLowerCase()){
+            case 'c':
+                if (copyTask()) event.preventDefault();
+                break;
+            case 'v':
+                if (pasteTask()) event.preventDefault();
+                break;
+        }
+    }, [
+        enabled,
+        copyTask,
+        pasteTask
+    ]);
+    useEffect(()=>{
+        if (!enabled) return;
+        window.addEventListener('keydown', handleKeyDown, {
+            capture: true
+        });
+        return ()=>{
+            window.removeEventListener('keydown', handleKeyDown, {
+                capture: true
+            });
+        };
+    }, [
+        enabled,
+        handleKeyDown
+    ]);
+    return {
+        clipboard,
+        hasClipboardContent,
+        copyTask,
+        pasteTask,
+        clearClipboard
+    };
+}
+export { useTaskCopyPaste };

package/dist/canvas/schema/index.cjs

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./node-instance": function(module) {
         module.exports = require("./node-instance/index.cjs");
     },
+    "./task-definition": function(module) {
+        module.exports = require("./task-definition/index.cjs");
+    },
     "./toolbar": function(module) {
         module.exports = require("./toolbar.cjs");
     }
@@ -65,10 +68,16 @@ var __webpack_exports__ = {};
         return _node_instance__WEBPACK_IMPORTED_MODULE_1__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _toolbar__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./toolbar");
+    var _task_definition__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./task-definition");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _task_definition__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _task_definition__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _toolbar__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./toolbar");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _toolbar__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _toolbar__WEBPACK_IMPORTED_MODULE_2__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _toolbar__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _toolbar__WEBPACK_IMPORTED_MODULE_3__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/canvas/schema/index.d.ts

@@ -1,4 +1,5 @@
 export * from './node-definition';
 export * from './node-instance';
+export * from './task-definition';
 export * from './toolbar';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC"}

package/dist/canvas/schema/index.js

@@ -1,3 +1,4 @@
 export * from "./node-definition/index.js";
 export * from "./node-instance/index.js";
+export * from "./task-definition/index.js";
 export * from "./toolbar.js";