@uipath/apollo-react 6.22.3 → 6.23.1

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

@@ -1,81 +1,56 @@
 import { useStoreApi } from "@xyflow/react";
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { flattenTasks, getProjection, reorderTasks } from "../StageNode.utils.js";
-const useStageTaskDragHandler = ({ sequentialTaskGroups, sequentialTasks, onTaskReorder })=>{
+const useStageTaskDragHandler = ({ taskGroups, onTaskReorder, allowRegrouping = true })=>{
     const storeApi = useStoreApi();
+    const offsetLeft = useRef(0);
     const [activeDragId, setActiveDragId] = useState(null);
-    const [offsetLeft, setOffsetLeft] = useState(0);
-    const [overId, setOverId] = useState(null);
-    const activeSequentialTask = useMemo(()=>sequentialTasks.find(({ task })=>task.id === activeDragId), [
-        sequentialTasks,
+    const activeTask = useMemo(()=>taskGroups.flat().find((task)=>task.id === activeDragId), [
+        taskGroups,
         activeDragId
     ]);
-    const isActiveTaskParallel = useMemo(()=>{
-        if (!activeDragId) return false;
-        const group = sequentialTaskGroups.find((g)=>g.some((t)=>t.id === activeDragId));
-        return group ? group.length > 1 : false;
-    }, [
-        sequentialTaskGroups,
+    const isActiveTaskParallel = useMemo(()=>(taskGroups.find((group)=>group.some((t)=>t.id === activeDragId))?.length ?? 0) > 1, [
+        taskGroups,
         activeDragId
     ]);
-    const projected = useMemo(()=>{
-        if (!activeDragId || !overId) return null;
-        return getProjection(sequentialTaskGroups, activeDragId, overId, offsetLeft);
-    }, [
-        sequentialTaskGroups,
-        activeDragId,
-        overId,
-        offsetLeft
-    ]);
-    const resetState = useCallback(()=>{
-        setActiveDragId(null);
-        setOffsetLeft(0);
-        setOverId(null);
-    }, []);
-    const handleDragStart = useCallback((event)=>{
-        setActiveDragId(event.active.id);
-    }, []);
+    const handleDragStart = useCallback((event)=>setActiveDragId(String(event.active.id)), []);
     const handleDragMove = useCallback((event)=>{
-        setOffsetLeft(event.delta.x / storeApi.getState().transform[2]);
+        offsetLeft.current = event.delta.x / storeApi.getState().transform[2];
     }, [
         storeApi
     ]);
-    const handleDragOver = useCallback((event)=>{
-        setOverId(event.over?.id ?? null);
-    }, []);
     const handleDragEnd = useCallback((event)=>{
         const { active, over } = event;
-        const currentOffsetLeft = offsetLeft;
-        resetState();
+        const currentOffsetLeft = offsetLeft.current;
+        offsetLeft.current = 0;
+        setActiveDragId(null);
         if (!over) return;
-        const projection = getProjection(sequentialTaskGroups, active.id, over.id, currentOffsetLeft);
-        if (!projection) return;
+        let depth = 0;
+        if (allowRegrouping) {
+            const projection = getProjection(taskGroups, active.id, over.id, currentOffsetLeft);
+            if (!projection) return;
+            depth = projection.depth;
+        }
         if (active.id === over.id) {
-            const flattened = flattenTasks(sequentialTaskGroups);
-            const activeTask = flattened.find((t)=>t.id === active.id);
-            if (activeTask && activeTask.depth === projection.depth) return;
+            const flattened = flattenTasks(taskGroups);
+            const draggedTask = flattened.find((t)=>t.id === active.id);
+            if (draggedTask && draggedTask.depth === depth) return;
         }
-        const newTasks = reorderTasks(sequentialTaskGroups, active.id, over.id, projection.depth);
-        onTaskReorder(newTasks);
+        onTaskReorder(reorderTasks(taskGroups, active.id, over.id, depth));
     }, [
-        sequentialTaskGroups,
+        taskGroups,
         onTaskReorder,
-        offsetLeft,
-        resetState
+        allowRegrouping
     ]);
     const handleDragCancel = useCallback(()=>{
-        resetState();
-    }, [
-        resetState
-    ]);
+        offsetLeft.current = 0;
+        setActiveDragId(null);
+    }, []);
     return {
-        activeDragId,
-        activeSequentialTask,
+        activeTask,
         isActiveTaskParallel,
-        projected,
-        handleDragMove,
-        handleDragOver,
         handleDragStart,
+        handleDragMove,
         handleDragEnd,
         handleDragCancel
     };

package/dist/canvas/components/StageNode/hooks/useStageTasksByGroups.cjs

@@ -27,55 +27,28 @@ __webpack_require__.d(__webpack_exports__, {
     useStageTasksByGroups: ()=>useStageTasksByGroups
 });
 const external_react_namespaceObject = require("react");
+const typeOf = (task)=>{
+    if (null != task.taskGroupType) return task.taskGroupType;
+    return task.isAdhoc ? 'adhoc' : 'sequential';
+};
 const useStageTasksByGroups = (allTasks)=>{
-    const sequentialTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.filter((group)=>group.some((t)=>{
-                if (null != t.taskGroupType) return 'sequential' === t.taskGroupType;
-                if (null != t.isAdhoc) return !t.isAdhoc;
-                return true;
-            })), [
+    const sequentialTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.map((group)=>group.filter((task)=>'sequential' === typeOf(task))).filter((group)=>group.length > 0), [
         allTasks
     ]);
-    const sequentialTasks = (0, external_react_namespaceObject.useMemo)(()=>sequentialTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        sequentialTaskGroups
-    ]);
-    const adhocTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.filter((group)=>group.every((t)=>{
-                if (null != t.taskGroupType) return 'adhoc' === t.taskGroupType;
-                if (null != t.isAdhoc) return t.isAdhoc;
-                return false;
-            })), [
+    const adhocTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.flat().filter((task)=>'adhoc' === typeOf(task)).map((task)=>[
+                task
+            ]), [
         allTasks
     ]);
-    const adhocTasks = (0, external_react_namespaceObject.useMemo)(()=>adhocTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        adhocTaskGroups
-    ]);
-    const eventDrivenTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.filter((group)=>group.every((t)=>{
-                if (null != t.taskGroupType) return 'event-driven' === t.taskGroupType;
-                return false;
-            })), [
+    const eventDrivenTaskGroups = (0, external_react_namespaceObject.useMemo)(()=>allTasks.flat().filter((task)=>'event-driven' === typeOf(task)).map((task)=>[
+                task
+            ]), [
         allTasks
     ]);
-    const eventDrivenTasks = (0, external_react_namespaceObject.useMemo)(()=>eventDrivenTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        eventDrivenTaskGroups
-    ]);
     return {
         sequentialTaskGroups,
-        sequentialTasks,
         adhocTaskGroups,
-        adhocTasks,
-        eventDrivenTaskGroups,
-        eventDrivenTasks
+        eventDrivenTaskGroups
     };
 };
 exports.useStageTasksByGroups = __webpack_exports__.useStageTasksByGroups;

package/dist/canvas/components/StageNode/hooks/useStageTasksByGroups.d.ts

@@ -1,22 +1,7 @@
 import type { StageTaskItem } from '../StageNode.types';
 export declare const useStageTasksByGroups: (allTasks: StageTaskItem[][]) => {
     sequentialTaskGroups: StageTaskItem[][];
-    sequentialTasks: {
-        task: StageTaskItem;
-        groupIndex: number;
-        taskIndex: number;
-    }[];
     adhocTaskGroups: StageTaskItem[][];
-    adhocTasks: {
-        task: StageTaskItem;
-        groupIndex: number;
-        taskIndex: number;
-    }[];
     eventDrivenTaskGroups: StageTaskItem[][];
-    eventDrivenTasks: {
-        task: StageTaskItem;
-        groupIndex: number;
-        taskIndex: number;
-    }[];
 };
 //# sourceMappingURL=useStageTasksByGroups.d.ts.map

package/dist/canvas/components/StageNode/hooks/useStageTasksByGroups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStageTasksByGroups.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/hooks/useStageTasksByGroups.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,eAAO,MAAM,qBAAqB,GAAI,UAAU,aAAa,EAAE,EAAE;;;;;;;;;;;;;;;;;;;CA2EhE,CAAC"}
+{"version":3,"file":"useStageTasksByGroups.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/hooks/useStageTasksByGroups.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAaxD,eAAO,MAAM,qBAAqB,GAAI,UAAU,aAAa,EAAE,EAAE;;;;CAiChE,CAAC"}

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

@@ -1,53 +1,26 @@
 import { useMemo } from "react";
+const typeOf = (task)=>{
+    if (null != task.taskGroupType) return task.taskGroupType;
+    return task.isAdhoc ? 'adhoc' : 'sequential';
+};
 const useStageTasksByGroups = (allTasks)=>{
-    const sequentialTaskGroups = useMemo(()=>allTasks.filter((group)=>group.some((t)=>{
-                if (null != t.taskGroupType) return 'sequential' === t.taskGroupType;
-                if (null != t.isAdhoc) return !t.isAdhoc;
-                return true;
-            })), [
+    const sequentialTaskGroups = useMemo(()=>allTasks.map((group)=>group.filter((task)=>'sequential' === typeOf(task))).filter((group)=>group.length > 0), [
         allTasks
     ]);
-    const sequentialTasks = useMemo(()=>sequentialTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        sequentialTaskGroups
-    ]);
-    const adhocTaskGroups = useMemo(()=>allTasks.filter((group)=>group.every((t)=>{
-                if (null != t.taskGroupType) return 'adhoc' === t.taskGroupType;
-                if (null != t.isAdhoc) return t.isAdhoc;
-                return false;
-            })), [
+    const adhocTaskGroups = useMemo(()=>allTasks.flat().filter((task)=>'adhoc' === typeOf(task)).map((task)=>[
+                task
+            ]), [
         allTasks
     ]);
-    const adhocTasks = useMemo(()=>adhocTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        adhocTaskGroups
-    ]);
-    const eventDrivenTaskGroups = useMemo(()=>allTasks.filter((group)=>group.every((t)=>{
-                if (null != t.taskGroupType) return 'event-driven' === t.taskGroupType;
-                return false;
-            })), [
+    const eventDrivenTaskGroups = useMemo(()=>allTasks.flat().filter((task)=>'event-driven' === typeOf(task)).map((task)=>[
+                task
+            ]), [
         allTasks
     ]);
-    const eventDrivenTasks = useMemo(()=>eventDrivenTaskGroups.flatMap((group, groupIndex)=>group.map((task, taskIndex)=>({
-                    task,
-                    groupIndex,
-                    taskIndex
-                }))), [
-        eventDrivenTaskGroups
-    ]);
     return {
         sequentialTaskGroups,
-        sequentialTasks,
         adhocTaskGroups,
-        adhocTasks,
-        eventDrivenTaskGroups,
-        eventDrivenTasks
+        eventDrivenTaskGroups
     };
 };
 export { useStageTasksByGroups };

package/dist/canvas/components/StageNode/tasks/DraggableTask.cjs

@@ -27,16 +27,14 @@ __webpack_require__.d(__webpack_exports__, {
     DraggableTask: ()=>DraggableTask
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const sortable_namespaceObject = require("@dnd-kit/sortable");
-const utilities_namespaceObject = require("@dnd-kit/utilities");
-const react_cjs_namespaceObject = require("../../../xyflow/react.cjs");
 const external_react_namespaceObject = require("react");
 const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const external_SortableTaskRow_cjs_namespaceObject = require("./SortableTaskRow.cjs");
 const external_TaskBreakpointDot_cjs_namespaceObject = require("./TaskBreakpointDot.cjs");
 const external_TaskContent_cjs_namespaceObject = require("./TaskContent.cjs");
 const external_TaskMenu_cjs_namespaceObject = require("./TaskMenu.cjs");
 const external_TaskMockedChip_cjs_namespaceObject = require("./TaskMockedChip.cjs");
-const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, projectedDepth, isTaskLoading, isReadOnly, onToggleBreakpoint })=>{
+const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, isTaskLoading, isReadOnly, onToggleBreakpoint })=>{
     const taskRef = (0, external_react_namespaceObject.useRef)(null);
     const menuRef = (0, external_react_namespaceObject.useRef)(null);
     const handleClick = (0, external_react_namespaceObject.useCallback)((e)=>{
@@ -48,44 +46,6 @@ const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, g
     const handleContextMenu = (0, external_react_namespaceObject.useCallback)((e)=>{
         menuRef.current?.handleContextMenu(e);
     }, []);
-    const { attributes, listeners, setNodeRef, transition, transform, isDragging } = (0, sortable_namespaceObject.useSortable)({
-        id: task.id,
-        disabled: isDragDisabled
-    });
-    const zoom = (0, react_cjs_namespaceObject.useStore)((s)=>transform ? s.transform[2] : 1);
-    const style = (0, external_react_namespaceObject.useMemo)(()=>{
-        const scaledTransform = transform ? {
-            ...transform,
-            x: transform.x / zoom,
-            y: transform.y / zoom
-        } : null;
-        let marginLeft;
-        if (isDragging && void 0 !== projectedDepth) if (1 !== projectedDepth || isParallel) {
-            if (0 === projectedDepth && isParallel) marginLeft = `-${external_StageNode_styles_cjs_namespaceObject.INDENTATION_WIDTH}px`;
-        } else marginLeft = `${external_StageNode_styles_cjs_namespaceObject.INDENTATION_WIDTH}px`;
-        return {
-            transition,
-            transform: utilities_namespaceObject.CSS.Transform.toString(scaledTransform),
-            marginLeft
-        };
-    }, [
-        transform,
-        zoom,
-        transition,
-        isDragging,
-        projectedDepth,
-        isParallel
-    ]);
-    if (isDragging) {
-        const isTargetParallel = 1 === projectedDepth;
-        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholderWrapper, {
-            ref: setNodeRef,
-            style: style,
-            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholder, {
-                isTargetParallel: isTargetParallel
-            })
-        });
-    }
     const taskElement = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_StageNode_styles_cjs_namespaceObject.StageItemPill, {
         ref: taskRef,
         "data-testid": `stage-task-card-${task.id}`,
@@ -123,12 +83,9 @@ const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, g
         ]
     });
     if (isDragDisabled) return taskElement;
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskWrapper, {
-        ref: setNodeRef,
-        style: style,
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_SortableTaskRow_cjs_namespaceObject.SortableTaskRow, {
+        taskId: task.id,
         isParallel: isParallel,
-        ...attributes,
-        ...listeners,
         children: taskElement
     });
 };

package/dist/canvas/components/StageNode/tasks/DraggableTask.d.ts

@@ -1,3 +1,3 @@
 import type { DraggableTaskProps } from './DraggableTask.types';
-export declare const DraggableTask: import("react").MemoExoticComponent<({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, projectedDepth, isTaskLoading, isReadOnly, onToggleBreakpoint, }: DraggableTaskProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const DraggableTask: import("react").MemoExoticComponent<({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, isTaskLoading, isReadOnly, onToggleBreakpoint, }: DraggableTaskProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=DraggableTask.d.ts.map

package/dist/canvas/components/StageNode/tasks/DraggableTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DraggableTask.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/tasks/DraggableTask.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAgIhE,eAAO,MAAM,aAAa,0MA9GvB,kBAAkB,6CA8GoC,CAAC"}
+{"version":3,"file":"DraggableTask.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/tasks/DraggableTask.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAiFhE,eAAO,MAAM,aAAa,0LA/DvB,kBAAkB,6CA+DoC,CAAC"}

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

@@ -1,14 +1,12 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useSortable } from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
-import { useStore } from "../../../xyflow/react.js";
-import { memo, useCallback, useMemo, useRef } from "react";
-import { INDENTATION_WIDTH, StageItemPill, StageTaskDragPlaceholder, StageTaskDragPlaceholderWrapper, StageTaskWrapper } from "../StageNode.styles.js";
+import { memo, useCallback, useRef } from "react";
+import { StageItemPill } from "../StageNode.styles.js";
+import { SortableTaskRow } from "./SortableTaskRow.js";
 import { TaskBreakpointDot } from "./TaskBreakpointDot.js";
 import { TaskContent } from "./TaskContent.js";
 import { TaskMenu } from "./TaskMenu.js";
 import { TaskMockedChip } from "./TaskMockedChip.js";
-const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, projectedDepth, isTaskLoading, isReadOnly, onToggleBreakpoint })=>{
+const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, getContextMenuItems, onTaskClick, isDragDisabled, isTaskLoading, isReadOnly, onToggleBreakpoint })=>{
     const taskRef = useRef(null);
     const menuRef = useRef(null);
     const handleClick = useCallback((e)=>{
@@ -20,44 +18,6 @@ const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, g
     const handleContextMenu = useCallback((e)=>{
         menuRef.current?.handleContextMenu(e);
     }, []);
-    const { attributes, listeners, setNodeRef, transition, transform, isDragging } = useSortable({
-        id: task.id,
-        disabled: isDragDisabled
-    });
-    const zoom = useStore((s)=>transform ? s.transform[2] : 1);
-    const style = useMemo(()=>{
-        const scaledTransform = transform ? {
-            ...transform,
-            x: transform.x / zoom,
-            y: transform.y / zoom
-        } : null;
-        let marginLeft;
-        if (isDragging && void 0 !== projectedDepth) if (1 !== projectedDepth || isParallel) {
-            if (0 === projectedDepth && isParallel) marginLeft = `-${INDENTATION_WIDTH}px`;
-        } else marginLeft = `${INDENTATION_WIDTH}px`;
-        return {
-            transition,
-            transform: CSS.Transform.toString(scaledTransform),
-            marginLeft
-        };
-    }, [
-        transform,
-        zoom,
-        transition,
-        isDragging,
-        projectedDepth,
-        isParallel
-    ]);
-    if (isDragging) {
-        const isTargetParallel = 1 === projectedDepth;
-        return /*#__PURE__*/ jsx(StageTaskDragPlaceholderWrapper, {
-            ref: setNodeRef,
-            style: style,
-            children: /*#__PURE__*/ jsx(StageTaskDragPlaceholder, {
-                isTargetParallel: isTargetParallel
-            })
-        });
-    }
     const taskElement = /*#__PURE__*/ jsxs(StageItemPill, {
         ref: taskRef,
         "data-testid": `stage-task-card-${task.id}`,
@@ -95,12 +55,9 @@ const DraggableTaskComponent = ({ task, taskExecution, isSelected, isParallel, g
         ]
     });
     if (isDragDisabled) return taskElement;
-    return /*#__PURE__*/ jsx(StageTaskWrapper, {
-        ref: setNodeRef,
-        style: style,
+    return /*#__PURE__*/ jsx(SortableTaskRow, {
+        taskId: task.id,
         isParallel: isParallel,
-        ...attributes,
-        ...listeners,
         children: taskElement
     });
 };

package/dist/canvas/components/StageNode/tasks/DraggableTask.types.d.ts

@@ -9,7 +9,6 @@ export interface DraggableTaskProps {
     onTaskClick: (e: React.MouseEvent, taskId: string) => void;
     onTaskPlay?: (taskId: string) => Promise<void>;
     isDragDisabled?: boolean;
-    projectedDepth?: number;
     isTaskLoading?: boolean;
     isReadOnly?: boolean;
     onToggleBreakpoint?: (taskId: string) => void;

package/dist/canvas/components/StageNode/tasks/DraggableTask.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DraggableTask.types.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/tasks/DraggableTask.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE5E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IAGpB,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,YAAY,EAAE,CAAC;IAC9D,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/C"}
+{"version":3,"file":"DraggableTask.types.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/tasks/DraggableTask.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE5E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IAGpB,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,YAAY,EAAE,CAAC;IAC9D,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/C"}

package/dist/canvas/components/StageNode/tasks/SortableTaskRow.cjs

@@ -0,0 +1,75 @@
+"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__, {
+    SortableTaskRow: ()=>SortableTaskRow
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const sortable_namespaceObject = require("@dnd-kit/sortable");
+const utilities_namespaceObject = require("@dnd-kit/utilities");
+const react_cjs_namespaceObject = require("../../../xyflow/react.cjs");
+const external_react_namespaceObject = require("react");
+const external_StageNode_styles_cjs_namespaceObject = require("../StageNode.styles.cjs");
+const SortableTaskRowComponent = ({ taskId, isParallel, children })=>{
+    const { attributes, listeners, setNodeRef, transition, transform, isDragging } = (0, sortable_namespaceObject.useSortable)({
+        id: taskId
+    });
+    const zoom = (0, react_cjs_namespaceObject.useStore)((s)=>transform ? s.transform[2] : 1);
+    const style = (0, external_react_namespaceObject.useMemo)(()=>({
+            transition,
+            transform: utilities_namespaceObject.CSS.Transform.toString(transform ? {
+                ...transform,
+                x: transform.x / zoom,
+                y: transform.y / zoom
+            } : null)
+        }), [
+        transform,
+        zoom,
+        transition
+    ]);
+    if (isDragging) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholderWrapper, {
+        ref: setNodeRef,
+        style: style,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskDragPlaceholder, {
+            isTargetParallel: isParallel
+        })
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_StageNode_styles_cjs_namespaceObject.StageTaskWrapper, {
+        ref: setNodeRef,
+        style: style,
+        isParallel: isParallel,
+        ...attributes,
+        ...listeners,
+        children: children
+    });
+};
+const SortableTaskRow = /*#__PURE__*/ (0, external_react_namespaceObject.memo)(SortableTaskRowComponent);
+exports.SortableTaskRow = __webpack_exports__.SortableTaskRow;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SortableTaskRow"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/StageNode/tasks/SortableTaskRow.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+export declare const SortableTaskRow: import("react").MemoExoticComponent<({ taskId, isParallel, children, }: {
+    taskId: string;
+    isParallel?: boolean;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=SortableTaskRow.d.ts.map

package/dist/canvas/components/StageNode/tasks/SortableTaskRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortableTaskRow.d.ts","sourceRoot":"","sources":["../../../../../src/canvas/components/StageNode/tasks/SortableTaskRow.tsx"],"names":[],"mappings":"AAGA,OAAO,EAA4B,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAyD1E,eAAO,MAAM,eAAe,0EA5CzB;IACD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;CACrB,6CAwC4D,CAAC"}

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

@@ -0,0 +1,41 @@
+import { jsx } from "react/jsx-runtime";
+import { useSortable } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { useStore } from "../../../xyflow/react.js";
+import { memo, useMemo } from "react";
+import { StageTaskDragPlaceholder, StageTaskDragPlaceholderWrapper, StageTaskWrapper } from "../StageNode.styles.js";
+const SortableTaskRowComponent = ({ taskId, isParallel, children })=>{
+    const { attributes, listeners, setNodeRef, transition, transform, isDragging } = useSortable({
+        id: taskId
+    });
+    const zoom = useStore((s)=>transform ? s.transform[2] : 1);
+    const style = useMemo(()=>({
+            transition,
+            transform: CSS.Transform.toString(transform ? {
+                ...transform,
+                x: transform.x / zoom,
+                y: transform.y / zoom
+            } : null)
+        }), [
+        transform,
+        zoom,
+        transition
+    ]);
+    if (isDragging) return /*#__PURE__*/ jsx(StageTaskDragPlaceholderWrapper, {
+        ref: setNodeRef,
+        style: style,
+        children: /*#__PURE__*/ jsx(StageTaskDragPlaceholder, {
+            isTargetParallel: isParallel
+        })
+    });
+    return /*#__PURE__*/ jsx(StageTaskWrapper, {
+        ref: setNodeRef,
+        style: style,
+        isParallel: isParallel,
+        ...attributes,
+        ...listeners,
+        children: children
+    });
+};
+const SortableTaskRow = /*#__PURE__*/ memo(SortableTaskRowComponent);
+export { SortableTaskRow };