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

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

@@ -0,0 +1,40 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const TaskNodeContext = /*#__PURE__*/ createContext(null);
+function TaskNodeProvider({ children, value }) {
+    return /*#__PURE__*/ jsx(TaskNodeContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+function useTaskNodeContext() {
+    const context = useContext(TaskNodeContext);
+    if (!context) throw new Error('useTaskNodeContext must be used within a TaskNodeProvider');
+    return context;
+}
+function useIsTaskParallel(taskId) {
+    const context = 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 = 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 useContext(TaskNodeContext);
+}
+export { TaskNodeProvider, useIsTaskParallel, useOptionalTaskNodeContext, useTaskGroupInfo, useTaskNodeContext };

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

@@ -0,0 +1,82 @@
+"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__, {
+    calculateTaskPositions: ()=>external_useTaskPositions_cjs_namespaceObject.calculateTaskPositions,
+    useTaskGroupInfo: ()=>external_TaskNodeContext_cjs_namespaceObject.useTaskGroupInfo,
+    useTaskPositions: ()=>external_useTaskPositions_cjs_namespaceObject.useTaskPositions,
+    PlaceholderTaskNode: ()=>external_PlaceholderTaskNode_cjs_namespaceObject.PlaceholderTaskNode,
+    useIsTaskParallel: ()=>external_TaskNodeContext_cjs_namespaceObject.useIsTaskParallel,
+    flattenTaskIds: ()=>external_taskReorderUtils_cjs_namespaceObject.flattenTaskIds,
+    useTaskNodeContext: ()=>external_TaskNodeContext_cjs_namespaceObject.useTaskNodeContext,
+    TaskNodeProvider: ()=>external_TaskNodeContext_cjs_namespaceObject.TaskNodeProvider,
+    useOptionalTaskNodeContext: ()=>external_TaskNodeContext_cjs_namespaceObject.useOptionalTaskNodeContext,
+    TaskNodeContent: ()=>external_TaskNode_cjs_namespaceObject.TaskNodeContent,
+    DEFAULT_TASK_POSITION_CONFIG: ()=>external_useTaskPositions_cjs_namespaceObject.DEFAULT_TASK_POSITION_CONFIG,
+    TaskNode: ()=>external_TaskNode_cjs_namespaceObject.TaskNode,
+    reorderTaskIds: ()=>external_taskReorderUtils_cjs_namespaceObject.reorderTaskIds,
+    buildTaskIdGroups: ()=>external_taskReorderUtils_cjs_namespaceObject.buildTaskIdGroups,
+    calculateStageContentHeight: ()=>external_useTaskPositions_cjs_namespaceObject.calculateStageContentHeight
+});
+const external_TaskNode_cjs_namespaceObject = require("./TaskNode.cjs");
+const external_PlaceholderTaskNode_cjs_namespaceObject = require("./PlaceholderTaskNode.cjs");
+const external_useTaskPositions_cjs_namespaceObject = require("./useTaskPositions.cjs");
+const external_TaskNodeContext_cjs_namespaceObject = require("./TaskNodeContext.cjs");
+const external_taskReorderUtils_cjs_namespaceObject = require("./taskReorderUtils.cjs");
+exports.DEFAULT_TASK_POSITION_CONFIG = __webpack_exports__.DEFAULT_TASK_POSITION_CONFIG;
+exports.PlaceholderTaskNode = __webpack_exports__.PlaceholderTaskNode;
+exports.TaskNode = __webpack_exports__.TaskNode;
+exports.TaskNodeContent = __webpack_exports__.TaskNodeContent;
+exports.TaskNodeProvider = __webpack_exports__.TaskNodeProvider;
+exports.buildTaskIdGroups = __webpack_exports__.buildTaskIdGroups;
+exports.calculateStageContentHeight = __webpack_exports__.calculateStageContentHeight;
+exports.calculateTaskPositions = __webpack_exports__.calculateTaskPositions;
+exports.flattenTaskIds = __webpack_exports__.flattenTaskIds;
+exports.reorderTaskIds = __webpack_exports__.reorderTaskIds;
+exports.useIsTaskParallel = __webpack_exports__.useIsTaskParallel;
+exports.useOptionalTaskNodeContext = __webpack_exports__.useOptionalTaskNodeContext;
+exports.useTaskGroupInfo = __webpack_exports__.useTaskGroupInfo;
+exports.useTaskNodeContext = __webpack_exports__.useTaskNodeContext;
+exports.useTaskPositions = __webpack_exports__.useTaskPositions;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_TASK_POSITION_CONFIG",
+    "PlaceholderTaskNode",
+    "TaskNode",
+    "TaskNodeContent",
+    "TaskNodeProvider",
+    "buildTaskIdGroups",
+    "calculateStageContentHeight",
+    "calculateTaskPositions",
+    "flattenTaskIds",
+    "reorderTaskIds",
+    "useIsTaskParallel",
+    "useOptionalTaskNodeContext",
+    "useTaskGroupInfo",
+    "useTaskNodeContext",
+    "useTaskPositions"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,8 @@
+export { TaskNode, TaskNodeContent } from './TaskNode';
+export { PlaceholderTaskNode } from './PlaceholderTaskNode';
+export { calculateTaskPositions, calculateStageContentHeight, useTaskPositions, DEFAULT_TASK_POSITION_CONFIG, } from './useTaskPositions';
+export { TaskNodeProvider, useTaskNodeContext, useOptionalTaskNodeContext, useIsTaskParallel, useTaskGroupInfo, } from './TaskNodeContext';
+export type { TaskType, TaskNodeData, TaskNode as TaskNodeType, TaskNodeProps, TaskPosition, TaskPositionConfig, } from './TaskNode.types';
+export type { TaskNodeContextValue, TaskNodeProviderProps } from './TaskNodeContext';
+export { flattenTaskIds, buildTaskIdGroups, reorderTaskIds } from './taskReorderUtils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/TaskNode/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EACL,sBAAsB,EACtB,2BAA2B,EAC3B,gBAAgB,EAChB,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,IAAI,YAAY,EACxB,aAAa,EACb,YAAY,EACZ,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

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

@@ -0,0 +1,6 @@
+import { TaskNode, TaskNodeContent } from "./TaskNode.js";
+import { PlaceholderTaskNode } from "./PlaceholderTaskNode.js";
+import { DEFAULT_TASK_POSITION_CONFIG, calculateStageContentHeight, calculateTaskPositions, useTaskPositions } from "./useTaskPositions.js";
+import { TaskNodeProvider, useIsTaskParallel, useOptionalTaskNodeContext, useTaskGroupInfo, useTaskNodeContext } from "./TaskNodeContext.js";
+import { buildTaskIdGroups, flattenTaskIds, reorderTaskIds } from "./taskReorderUtils.js";
+export { DEFAULT_TASK_POSITION_CONFIG, PlaceholderTaskNode, TaskNode, TaskNodeContent, TaskNodeProvider, buildTaskIdGroups, calculateStageContentHeight, calculateTaskPositions, flattenTaskIds, reorderTaskIds, useIsTaskParallel, useOptionalTaskNodeContext, useTaskGroupInfo, useTaskNodeContext, useTaskPositions };

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

@@ -0,0 +1,206 @@
+"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__, {
+    buildTaskIdGroups: ()=>buildTaskIdGroups,
+    flattenTaskIds: ()=>flattenTaskIds,
+    insertTaskAtPosition: ()=>insertTaskAtPosition,
+    moveTaskBetweenStages: ()=>moveTaskBetweenStages,
+    moveTaskWithinStage: ()=>moveTaskWithinStage,
+    removeTaskFromTaskIds: ()=>removeTaskFromTaskIds,
+    reorderTaskIds: ()=>reorderTaskIds
+});
+function flattenTaskIds(taskIds) {
+    const flattened = [];
+    for (const [groupIndex, group] of taskIds.entries()){
+        if (!group) continue;
+        const depth = group.length > 1 ? 1 : 0;
+        for (const [taskIndex, id] of group.entries())if (id) flattened.push({
+            id,
+            groupIndex,
+            taskIndex,
+            depth
+        });
+    }
+    return flattened;
+}
+function buildTaskIdGroups(flattenedTaskIds) {
+    const groups = [];
+    let currentGroup = [];
+    let previousDepth = null;
+    let previousGroupIndex = null;
+    for (const item of flattenedTaskIds){
+        if (null === previousDepth) currentGroup.push(item.id);
+        else if (1 === item.depth && 1 === previousDepth && item.groupIndex === previousGroupIndex) currentGroup.push(item.id);
+        else {
+            if (currentGroup.length > 0) groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        }
+        previousDepth = item.depth;
+        previousGroupIndex = item.groupIndex;
+    }
+    if (currentGroup.length > 0) groups.push(currentGroup);
+    return groups;
+}
+function reorderTaskIds(taskIds, activeId, targetGroupIndex, targetTaskIndex, projectedDepth) {
+    const flattened = flattenTaskIds(taskIds);
+    const activeIndex = flattened.findIndex((t)=>t.id === activeId);
+    if (-1 === activeIndex) return taskIds;
+    const filteredFlattened = flattened.filter((t)=>t.id !== activeId);
+    const filteredTaskIds = taskIds.map((group)=>group.filter((id)=>id !== activeId)).filter((group)=>group.length > 0);
+    const filteredWithIndices = flattenTaskIds(filteredTaskIds);
+    let targetFilteredIndex = filteredWithIndices.length;
+    for(let i = 0; i < filteredWithIndices.length; i++){
+        const item = filteredWithIndices[i];
+        if (item) {
+            if (item.groupIndex === targetGroupIndex && item.taskIndex === targetTaskIndex) {
+                targetFilteredIndex = i;
+                break;
+            }
+            if (item.groupIndex > targetGroupIndex) {
+                targetFilteredIndex = i;
+                break;
+            }
+        }
+    }
+    const activeItem = flattened[activeIndex];
+    if (!activeItem) return taskIds;
+    let newGroupIndex = targetGroupIndex;
+    let newDepth = projectedDepth;
+    if (1 === projectedDepth) {
+        const prevItem = filteredFlattened[targetFilteredIndex - 1];
+        if (prevItem) {
+            const prevOriginal = filteredWithIndices[targetFilteredIndex - 1];
+            const prevGroupLength = prevOriginal ? filteredTaskIds[prevOriginal.groupIndex]?.length : 0;
+            if (prevOriginal && prevGroupLength && prevGroupLength > 0) {
+                for (const originalGroup of taskIds)if (originalGroup.includes(prevItem.id) && originalGroup.length > 1) {
+                    newGroupIndex = prevOriginal.groupIndex;
+                    break;
+                }
+            }
+        }
+    }
+    const result = [
+        ...filteredFlattened
+    ];
+    result.splice(targetFilteredIndex, 0, {
+        ...activeItem,
+        depth: newDepth,
+        groupIndex: newGroupIndex
+    });
+    return buildTaskIdGroupsFromReorder(result, projectedDepth, targetFilteredIndex);
+}
+function buildTaskIdGroupsFromReorder(flattenedTaskIds, movedItemDepth, movedItemIndex) {
+    const groups = [];
+    let currentGroup = [];
+    for(let i = 0; i < flattenedTaskIds.length; i++){
+        const item = flattenedTaskIds[i];
+        if (!item) continue;
+        const isMovedItem = i === movedItemIndex;
+        const prevItem = flattenedTaskIds[i - 1];
+        if (0 === currentGroup.length) currentGroup.push(item.id);
+        else if (isMovedItem && 1 === movedItemDepth) currentGroup.push(item.id);
+        else if (isMovedItem && 0 === movedItemDepth) {
+            if (currentGroup.length > 0) groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        } else if (1 !== item.depth || prevItem?.depth !== 1 || isMovedItem) {
+            groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        } else if (item.groupIndex === prevItem.groupIndex) currentGroup.push(item.id);
+        else {
+            groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        }
+    }
+    if (currentGroup.length > 0) groups.push(currentGroup);
+    return groups;
+}
+function removeTaskFromTaskIds(taskIds, taskId) {
+    return taskIds.map((group)=>group.filter((id)=>id !== taskId)).filter((group)=>group.length > 0);
+}
+function insertTaskAtPosition(taskIds, taskId, position) {
+    const { groupIndex, taskIndex, isParallel } = position;
+    const newTaskIds = taskIds.map((group)=>[
+            ...group
+        ]);
+    if (groupIndex >= newTaskIds.length) if (isParallel && newTaskIds.length > 0) {
+        const lastGroup = newTaskIds[newTaskIds.length - 1];
+        if (lastGroup && lastGroup.length > 0) lastGroup.push(taskId);
+        else newTaskIds.push([
+            taskId
+        ]);
+    } else newTaskIds.push([
+        taskId
+    ]);
+    else if (isParallel) {
+        const targetGroup = newTaskIds[groupIndex];
+        if (targetGroup) targetGroup.splice(taskIndex, 0, taskId);
+        else newTaskIds.splice(groupIndex, 0, [
+            taskId
+        ]);
+    } else newTaskIds.splice(groupIndex, 0, [
+        taskId
+    ]);
+    return newTaskIds;
+}
+function moveTaskWithinStage(taskIds, taskId, position) {
+    const withoutTask = removeTaskFromTaskIds(taskIds, taskId);
+    return insertTaskAtPosition(withoutTask, taskId, position);
+}
+function moveTaskBetweenStages(sourceTaskIds, targetTaskIds, taskId, position) {
+    const newSourceTaskIds = removeTaskFromTaskIds(sourceTaskIds, taskId);
+    const newTargetTaskIds = insertTaskAtPosition(targetTaskIds, taskId, position);
+    return {
+        sourceTaskIds: newSourceTaskIds,
+        targetTaskIds: newTargetTaskIds
+    };
+}
+exports.buildTaskIdGroups = __webpack_exports__.buildTaskIdGroups;
+exports.flattenTaskIds = __webpack_exports__.flattenTaskIds;
+exports.insertTaskAtPosition = __webpack_exports__.insertTaskAtPosition;
+exports.moveTaskBetweenStages = __webpack_exports__.moveTaskBetweenStages;
+exports.moveTaskWithinStage = __webpack_exports__.moveTaskWithinStage;
+exports.removeTaskFromTaskIds = __webpack_exports__.removeTaskFromTaskIds;
+exports.reorderTaskIds = __webpack_exports__.reorderTaskIds;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "buildTaskIdGroups",
+    "flattenTaskIds",
+    "insertTaskAtPosition",
+    "moveTaskBetweenStages",
+    "moveTaskWithinStage",
+    "removeTaskFromTaskIds",
+    "reorderTaskIds"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,23 @@
+export interface TaskInsertPosition {
+    groupIndex: number;
+    taskIndex: number;
+    isParallel: boolean;
+}
+interface FlattenedTaskId {
+    id: string;
+    groupIndex: number;
+    taskIndex: number;
+    depth: number;
+}
+export declare function flattenTaskIds(taskIds: string[][]): FlattenedTaskId[];
+export declare function buildTaskIdGroups(flattenedTaskIds: FlattenedTaskId[]): string[][];
+export declare function reorderTaskIds(taskIds: string[][], activeId: string, targetGroupIndex: number, targetTaskIndex: number, projectedDepth: number): string[][];
+export declare function removeTaskFromTaskIds(taskIds: string[][], taskId: string): string[][];
+export declare function insertTaskAtPosition(taskIds: string[][], taskId: string, position: TaskInsertPosition): string[][];
+export declare function moveTaskWithinStage(taskIds: string[][], taskId: string, position: TaskInsertPosition): string[][];
+export declare function moveTaskBetweenStages(sourceTaskIds: string[][], targetTaskIds: string[][], taskId: string, position: TaskInsertPosition): {
+    sourceTaskIds: string[][];
+    targetTaskIds: string[][];
+};
+export {};
+//# sourceMappingURL=taskReorderUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taskReorderUtils.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/TaskNode/taskReorderUtils.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,eAAe,EAAE,CAmBrE;AAKD,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,eAAe,EAAE,GAAG,MAAM,EAAE,EAAE,CA4BjF;AAcD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,MAAM,EAAE,EAAE,CAyEZ;AA+DD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAIrF;AAWD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,EAAE,EAAE,CAgCZ;AAWD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,EAAE,EAAE,CAKZ;AAYD,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EAAE,EAAE,EACzB,aAAa,EAAE,MAAM,EAAE,EAAE,EACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,GAC3B;IAAE,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,EAAE,CAAA;CAAE,CAQ1D"}

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

@@ -0,0 +1,154 @@
+function flattenTaskIds(taskIds) {
+    const flattened = [];
+    for (const [groupIndex, group] of taskIds.entries()){
+        if (!group) continue;
+        const depth = group.length > 1 ? 1 : 0;
+        for (const [taskIndex, id] of group.entries())if (id) flattened.push({
+            id,
+            groupIndex,
+            taskIndex,
+            depth
+        });
+    }
+    return flattened;
+}
+function buildTaskIdGroups(flattenedTaskIds) {
+    const groups = [];
+    let currentGroup = [];
+    let previousDepth = null;
+    let previousGroupIndex = null;
+    for (const item of flattenedTaskIds){
+        if (null === previousDepth) currentGroup.push(item.id);
+        else if (1 === item.depth && 1 === previousDepth && item.groupIndex === previousGroupIndex) currentGroup.push(item.id);
+        else {
+            if (currentGroup.length > 0) groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        }
+        previousDepth = item.depth;
+        previousGroupIndex = item.groupIndex;
+    }
+    if (currentGroup.length > 0) groups.push(currentGroup);
+    return groups;
+}
+function reorderTaskIds(taskIds, activeId, targetGroupIndex, targetTaskIndex, projectedDepth) {
+    const flattened = flattenTaskIds(taskIds);
+    const activeIndex = flattened.findIndex((t)=>t.id === activeId);
+    if (-1 === activeIndex) return taskIds;
+    const filteredFlattened = flattened.filter((t)=>t.id !== activeId);
+    const filteredTaskIds = taskIds.map((group)=>group.filter((id)=>id !== activeId)).filter((group)=>group.length > 0);
+    const filteredWithIndices = flattenTaskIds(filteredTaskIds);
+    let targetFilteredIndex = filteredWithIndices.length;
+    for(let i = 0; i < filteredWithIndices.length; i++){
+        const item = filteredWithIndices[i];
+        if (item) {
+            if (item.groupIndex === targetGroupIndex && item.taskIndex === targetTaskIndex) {
+                targetFilteredIndex = i;
+                break;
+            }
+            if (item.groupIndex > targetGroupIndex) {
+                targetFilteredIndex = i;
+                break;
+            }
+        }
+    }
+    const activeItem = flattened[activeIndex];
+    if (!activeItem) return taskIds;
+    let newGroupIndex = targetGroupIndex;
+    let newDepth = projectedDepth;
+    if (1 === projectedDepth) {
+        const prevItem = filteredFlattened[targetFilteredIndex - 1];
+        if (prevItem) {
+            const prevOriginal = filteredWithIndices[targetFilteredIndex - 1];
+            const prevGroupLength = prevOriginal ? filteredTaskIds[prevOriginal.groupIndex]?.length : 0;
+            if (prevOriginal && prevGroupLength && prevGroupLength > 0) {
+                for (const originalGroup of taskIds)if (originalGroup.includes(prevItem.id) && originalGroup.length > 1) {
+                    newGroupIndex = prevOriginal.groupIndex;
+                    break;
+                }
+            }
+        }
+    }
+    const result = [
+        ...filteredFlattened
+    ];
+    result.splice(targetFilteredIndex, 0, {
+        ...activeItem,
+        depth: newDepth,
+        groupIndex: newGroupIndex
+    });
+    return buildTaskIdGroupsFromReorder(result, projectedDepth, targetFilteredIndex);
+}
+function buildTaskIdGroupsFromReorder(flattenedTaskIds, movedItemDepth, movedItemIndex) {
+    const groups = [];
+    let currentGroup = [];
+    for(let i = 0; i < flattenedTaskIds.length; i++){
+        const item = flattenedTaskIds[i];
+        if (!item) continue;
+        const isMovedItem = i === movedItemIndex;
+        const prevItem = flattenedTaskIds[i - 1];
+        if (0 === currentGroup.length) currentGroup.push(item.id);
+        else if (isMovedItem && 1 === movedItemDepth) currentGroup.push(item.id);
+        else if (isMovedItem && 0 === movedItemDepth) {
+            if (currentGroup.length > 0) groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        } else if (1 !== item.depth || prevItem?.depth !== 1 || isMovedItem) {
+            groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        } else if (item.groupIndex === prevItem.groupIndex) currentGroup.push(item.id);
+        else {
+            groups.push(currentGroup);
+            currentGroup = [
+                item.id
+            ];
+        }
+    }
+    if (currentGroup.length > 0) groups.push(currentGroup);
+    return groups;
+}
+function removeTaskFromTaskIds(taskIds, taskId) {
+    return taskIds.map((group)=>group.filter((id)=>id !== taskId)).filter((group)=>group.length > 0);
+}
+function insertTaskAtPosition(taskIds, taskId, position) {
+    const { groupIndex, taskIndex, isParallel } = position;
+    const newTaskIds = taskIds.map((group)=>[
+            ...group
+        ]);
+    if (groupIndex >= newTaskIds.length) if (isParallel && newTaskIds.length > 0) {
+        const lastGroup = newTaskIds[newTaskIds.length - 1];
+        if (lastGroup && lastGroup.length > 0) lastGroup.push(taskId);
+        else newTaskIds.push([
+            taskId
+        ]);
+    } else newTaskIds.push([
+        taskId
+    ]);
+    else if (isParallel) {
+        const targetGroup = newTaskIds[groupIndex];
+        if (targetGroup) targetGroup.splice(taskIndex, 0, taskId);
+        else newTaskIds.splice(groupIndex, 0, [
+            taskId
+        ]);
+    } else newTaskIds.splice(groupIndex, 0, [
+        taskId
+    ]);
+    return newTaskIds;
+}
+function moveTaskWithinStage(taskIds, taskId, position) {
+    const withoutTask = removeTaskFromTaskIds(taskIds, taskId);
+    return insertTaskAtPosition(withoutTask, taskId, position);
+}
+function moveTaskBetweenStages(sourceTaskIds, targetTaskIds, taskId, position) {
+    const newSourceTaskIds = removeTaskFromTaskIds(sourceTaskIds, taskId);
+    const newTargetTaskIds = insertTaskAtPosition(targetTaskIds, taskId, position);
+    return {
+        sourceTaskIds: newSourceTaskIds,
+        targetTaskIds: newTargetTaskIds
+    };
+}
+export { buildTaskIdGroups, flattenTaskIds, insertTaskAtPosition, moveTaskBetweenStages, moveTaskWithinStage, removeTaskFromTaskIds, reorderTaskIds };