gantt-lib 0.104.2 → 0.105.1

package/dist/index.mjs

@@ -3530,6 +3530,29 @@ function getDescendantIds(taskId, tasks) {
   collect(taskId);
   return descendants;
 }
+function isTaskParent2(taskId, tasks) {
+  return tasks.some((task) => task.parentId === taskId);
+}
+function getSubtreeEndIndex(taskId, tasks) {
+  const descendantIds = new Set(getDescendantIds(taskId, tasks));
+  const taskIndex = tasks.findIndex((task) => task.id === taskId);
+  if (taskIndex === -1) return -1;
+  let endIndex = taskIndex;
+  for (let index = taskIndex + 1; index < tasks.length; index += 1) {
+    if (!descendantIds.has(tasks[index].id)) break;
+    endIndex = index;
+  }
+  return endIndex;
+}
+function getNearestVisibleSiblingBefore(visibleTasks, movedIds, startIndex) {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    const candidate = visibleTasks[index];
+    if (candidate && !movedIds.has(candidate.id)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 function getVisibleReorderPosition(orderedTasks, visibleTasks, movedTaskId, originVisibleIndex, dropVisibleIndex) {
   const originOrderedIndex = orderedTasks.findIndex((task) => task.id === movedTaskId);
   if (originOrderedIndex === -1) {
@@ -3563,6 +3586,99 @@ function getVisibleReorderPosition(orderedTasks, visibleTasks, movedTaskId, orig
     insertIndex
   };
 }
+function getVisibleReorderPlan(orderedTasks, visibleTasks, movedTaskId, target) {
+  const originOrderedIndex = orderedTasks.findIndex((task) => task.id === movedTaskId);
+  if (originOrderedIndex === -1) {
+    return null;
+  }
+  const descendantIds = getDescendantIds(movedTaskId, orderedTasks);
+  const movedIds = /* @__PURE__ */ new Set([movedTaskId, ...descendantIds]);
+  const reorderedWithoutMoved = orderedTasks.filter((task) => !movedIds.has(task.id));
+  const movedTask = orderedTasks[originOrderedIndex];
+  if (target.placement === "end" || target.index >= visibleTasks.length) {
+    return {
+      originOrderedIndex,
+      insertIndex: reorderedWithoutMoved.length,
+      inferredParentId: void 0
+    };
+  }
+  const targetTask = visibleTasks[target.index];
+  const previousVisibleTask = getNearestVisibleSiblingBefore(
+    visibleTasks,
+    movedIds,
+    target.index - 1
+  );
+  if (!targetTask) {
+    return null;
+  }
+  if (movedIds.has(targetTask.id)) {
+    return null;
+  }
+  const targetIndex = reorderedWithoutMoved.findIndex((task) => task.id === targetTask.id);
+  if (targetIndex === -1) {
+    return null;
+  }
+  let insertIndex = targetIndex;
+  let inferredParentId;
+  switch (target.placement) {
+    case "before": {
+      insertIndex = targetIndex;
+      inferredParentId = targetTask.parentId || void 0;
+      if (!targetTask.parentId && previousVisibleTask?.parentId) {
+        const isDetachingFromSameGroup = movedTask.parentId === previousVisibleTask.parentId;
+        if (isDetachingFromSameGroup) {
+          const previousEndIndex = getSubtreeEndIndex(previousVisibleTask.id, reorderedWithoutMoved);
+          inferredParentId = void 0;
+          insertIndex = previousEndIndex === -1 ? targetIndex : previousEndIndex + 1;
+        }
+      }
+      break;
+    }
+    case "inside": {
+      if (isTaskParent2(targetTask.id, orderedTasks)) {
+        return null;
+      }
+      inferredParentId = targetTask.id;
+      if (!inferredParentId || movedIds.has(inferredParentId)) {
+        return null;
+      }
+      if (movedTask.parentId === inferredParentId) {
+        return null;
+      }
+      const anchorEndIndex = getSubtreeEndIndex(targetTask.id, reorderedWithoutMoved);
+      insertIndex = anchorEndIndex === -1 ? targetIndex + 1 : anchorEndIndex + 1;
+      break;
+    }
+    case "after": {
+      const nextVisibleTask = visibleTasks[target.index + 1];
+      const hasVisibleChildBelow = nextVisibleTask?.parentId === targetTask.id;
+      if (hasVisibleChildBelow) {
+        inferredParentId = targetTask.id;
+        insertIndex = targetIndex + 1;
+      } else {
+        inferredParentId = targetTask.parentId || void 0;
+        const targetEndIndex = getSubtreeEndIndex(targetTask.id, reorderedWithoutMoved);
+        insertIndex = targetEndIndex === -1 ? targetIndex + 1 : targetEndIndex + 1;
+      }
+      break;
+    }
+    default: {
+      return {
+        originOrderedIndex,
+        insertIndex: reorderedWithoutMoved.length,
+        inferredParentId: void 0
+      };
+    }
+  }
+  if (inferredParentId && movedIds.has(inferredParentId)) {
+    return null;
+  }
+  return {
+    originOrderedIndex,
+    insertIndex,
+    inferredParentId
+  };
+}
 
 // src/components/ui/Popover.tsx
 import * as RadixPopover from "@radix-ui/react-popover";
@@ -4705,6 +4821,9 @@ var TaskListRow = React9.memo(
     editingTaskId,
     isDragging = false,
     isDragOver = false,
+    dragOverPlacement = null,
+    isNestedDropTarget = false,
+    isDirectChildDropTarget = false,
     onDragStart,
     onDragOver,
     onDrop,
@@ -5579,7 +5698,7 @@ var TaskListRow = React9.memo(
     const numberCell = /* @__PURE__ */ jsxs9(
       "div",
       {
-        className: "gantt-tl-cell gantt-tl-cell-number",
+        className: `gantt-tl-cell gantt-tl-cell-number${onDragStart ? " gantt-tl-cell-number-reorderable" : ""}`,
         style: getColumnStyle("number", 40),
         onClick: handleNumberClick,
         children: [
@@ -5603,6 +5722,16 @@ var TaskListRow = React9.memo(
     );
     const nameTriggerPaddingLeft = isParent ? `${nestingDepth * 20 + 28}px` : nestingDepth > 0 ? `${nestingDepth * 20 + 8}px` : void 0;
     const nameInputPaddingLeft = nestingDepth > 0 ? `${nestingDepth * 20 + 8}px` : void 0;
+    const nestedDropIndicatorLeft = (() => {
+      const numberColumnWidth = resolvedColumns?.find((col) => col.id === "number")?.width ?? 40;
+      const nestedAxisDepth = Math.max(0, nestingDepth - 1);
+      return `${numberColumnWidth + nestedAxisDepth * 20 + 9}px`;
+    })();
+    const nestedInsideDropIndicatorLeft = (() => {
+      const numberColumnWidth = resolvedColumns?.find((col) => col.id === "number")?.width ?? 40;
+      const nestedAxisDepth = Math.max(0, nestingDepth);
+      return `${numberColumnWidth + nestedAxisDepth * 20 + 9}px`;
+    })();
     const nameCell = /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-cell gantt-tl-cell-name", style: getColumnStyle("name", 200), children: [
       isChild && !editingName && /* @__PURE__ */ jsxs9(Fragment2, { children: [
         !isFilterHideMode && /* @__PURE__ */ jsxs9(Fragment2, { children: [
@@ -6367,12 +6496,20 @@ var TaskListRow = React9.memo(
           isSourceRow ? "gantt-tl-row-picking-self" : "",
           isDragging ? "gantt-tl-row-dragging" : "",
           isDragOver ? "gantt-tl-row-drag-over" : "",
+          isDragOver && dragOverPlacement ? `gantt-tl-row-drag-over-${dragOverPlacement}` : "",
+          isDragOver && isNestedDropTarget ? "gantt-tl-row-drag-over-nested" : "",
+          isDragOver && isDirectChildDropTarget ? "gantt-tl-row-drag-over-direct-child" : "",
           isChild ? "gantt-tl-row-child" : "",
           isParent ? "gantt-tl-row-parent" : "",
           `gantt-tl-row-level-${rowFillLevel}`,
           isTotalRow ? "gantt-tl-row-total" : ""
         ].filter(Boolean).join(" "),
-        style: { height: `${rowHeight}px`, position: "relative" },
+        style: {
+          height: `${rowHeight}px`,
+          position: "relative",
+          "--gantt-tl-nested-drop-left": nestedDropIndicatorLeft,
+          "--gantt-tl-nested-inside-drop-left": nestedInsideDropIndicatorLeft
+        },
         "data-gantt-task-row-id": task.id,
         onClick: handleRowClickInternal,
         onKeyDown: handleRowKeyDown,
@@ -6728,6 +6865,23 @@ function duplicateTaskSubtree(anchorTaskId, orderedTasks) {
     ...orderedTasks.slice(insertIndex)
   ];
 }
+var DRAG_ZONE_EDGE_RATIO = 0.28;
+function getDropPlacementFromEvent(e) {
+  const rect = e.currentTarget.getBoundingClientRect();
+  const ratio = rect.height > 0 ? (e.clientY - rect.top) / rect.height : 0.5;
+  if (ratio <= DRAG_ZONE_EDGE_RATIO) return "before";
+  if (ratio >= 1 - DRAG_ZONE_EDGE_RATIO) return "after";
+  return "inside";
+}
+function getNearestVisibleDropAnchorBefore(visibleTasks, movedIds, startIndex) {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    const candidate = visibleTasks[index];
+    if (candidate && !movedIds.has(candidate.id)) {
+      return { task: candidate, index };
+    }
+  }
+  return null;
+}
 function getTaskNumber(tasks, taskIndex) {
   const task = tasks[taskIndex];
   if (!task) return "";
@@ -6814,6 +6968,7 @@ var TaskList = ({
   onInsertAfter,
   onReorder,
   disableTaskDrag = false,
+  disableTaskListReorder = false,
   editingTaskId: propEditingTaskId,
   enableAddTask = true,
   defaultTaskDurationDays = DEFAULT_TASK_DURATION_DAYS,
@@ -6843,6 +6998,7 @@ var TaskList = ({
   taskDateChangeMode = "preserve-duration",
   onTaskDateChangeModeChange
 }) => {
+  const reorderDisabled = disableTaskListReorder || disableTaskDrag;
   const [internalSelectedTaskIds, setInternalSelectedTaskIds] = useState6(/* @__PURE__ */ new Set());
   const [activeCustomCell, setActiveCustomCell] = useState6(null);
   const [columnWidthOverrides, setColumnWidthOverrides] = useState6(() => normalizeColumnWidthMap(taskListColumnWidths));
@@ -7139,9 +7295,15 @@ var TaskList = ({
   const [isCreating, setIsCreating] = useState6(false);
   const [pendingInsert, setPendingInsert] = useState6(null);
   const [draggingIndex, setDraggingIndex] = useState6(null);
-  const [dragOverIndex, setDragOverIndex] = useState6(null);
+  const [dragOverTarget, setDragOverTarget] = useState6(null);
   const dragOriginIndexRef = useRef6(null);
   const dragTaskIdRef = useRef6(null);
+  const clearDragState = useCallback5(() => {
+    setDraggingIndex(null);
+    setDragOverTarget(null);
+    dragOriginIndexRef.current = null;
+    dragTaskIdRef.current = null;
+  }, []);
   const isValidParentDrop = useCallback5((draggedTaskId, dropIndex) => {
     if (!isTaskParent(draggedTaskId, tasks)) {
       return true;
@@ -7166,59 +7328,129 @@ var TaskList = ({
     dragOriginIndexRef.current = index;
     dragTaskIdRef.current = visibleTasks[index]?.id ?? null;
   }, [visibleTasks]);
+  const normalizeDropTarget = useCallback5((movedTaskId, target) => {
+    if (target.placement !== "before" || target.index <= 0 || target.index >= visibleTasks.length) {
+      return target;
+    }
+    const descendantIds = new Set(getAllDescendants2(movedTaskId, orderedTasks).map((task) => task.id));
+    const movedIds = /* @__PURE__ */ new Set([movedTaskId, ...descendantIds]);
+    const targetTask = visibleTasks[target.index];
+    if (targetTask?.id === movedTaskId) {
+      return target;
+    }
+    const previousAnchor = getNearestVisibleDropAnchorBefore(visibleTasks, movedIds, target.index - 1);
+    if (!targetTask || !previousAnchor) {
+      return target;
+    }
+    const isEquivalentSiblingGap = (targetTask.parentId || void 0) === (previousAnchor.task.parentId || void 0);
+    if (isEquivalentSiblingGap) {
+      return {
+        index: previousAnchor.index,
+        placement: "after"
+      };
+    }
+    return target;
+  }, [orderedTasks, visibleTasks]);
   const handleDragOver = useCallback5((index, e) => {
     e.preventDefault();
     const draggedTaskId = dragTaskIdRef.current;
     if (!draggedTaskId) return;
-    if (!isValidParentDrop(draggedTaskId, index)) {
-      setDragOverIndex(null);
+    const rawPlacement = getDropPlacementFromEvent(e);
+    const isSelfTopBefore = visibleTasks[index]?.id === draggedTaskId && rawPlacement === "before";
+    if (isSelfTopBefore) {
+      setDragOverTarget(null);
+      e.dataTransfer.dropEffect = "none";
+      return;
+    }
+    const isFirstChildTopAfterParent = rawPlacement === "before" && visibleTasks[index]?.parentId === visibleTasks[index - 1]?.id;
+    if (isFirstChildTopAfterParent) {
+      setDragOverTarget(null);
+      e.dataTransfer.dropEffect = "none";
+      return;
+    }
+    const normalizedTarget = normalizeDropTarget(draggedTaskId, {
+      index,
+      placement: rawPlacement
+    });
+    const targetTask = visibleTasks[normalizedTarget.index];
+    if (!targetTask || !isValidParentDrop(draggedTaskId, normalizedTarget.index)) {
+      setDragOverTarget(null);
+      e.dataTransfer.dropEffect = "none";
+      return;
+    }
+    const reorderPlan = getVisibleReorderPlan(
+      orderedTasks,
+      visibleTasks,
+      draggedTaskId,
+      normalizedTarget
+    );
+    if (!reorderPlan) {
+      setDragOverTarget(null);
+      e.dataTransfer.dropEffect = "none";
+      return;
+    }
+    const moved = orderedTasks[reorderPlan.originOrderedIndex];
+    const currentParentId = moved?.parentId || void 0;
+    if (reorderPlan.insertIndex === reorderPlan.originOrderedIndex && reorderPlan.inferredParentId === currentParentId) {
+      setDragOverTarget(null);
       e.dataTransfer.dropEffect = "none";
       return;
     }
     e.dataTransfer.dropEffect = "move";
-    setDragOverIndex(index);
-  }, [isValidParentDrop]);
+    setDragOverTarget({
+      ...normalizedTarget,
+      inferredParentId: reorderPlan.inferredParentId,
+      isDirectChildDrop: normalizedTarget.placement === "after" && reorderPlan.inferredParentId === targetTask.id
+    });
+  }, [isValidParentDrop, normalizeDropTarget, orderedTasks, visibleTasks]);
   const handleDrop = useCallback5((dropIndex, e) => {
     e.preventDefault();
     const originVisibleIndex = dragOriginIndexRef.current;
     const movedTaskId = dragTaskIdRef.current;
-    if (originVisibleIndex === null || movedTaskId === null || originVisibleIndex === dropIndex) {
-      setDraggingIndex(null);
-      setDragOverIndex(null);
-      dragOriginIndexRef.current = null;
-      dragTaskIdRef.current = null;
+    if (originVisibleIndex === null || movedTaskId === null) {
+      clearDragState();
+      return;
+    }
+    const rawPlacement = dropIndex >= visibleTasks.length ? "end" : getDropPlacementFromEvent(e);
+    const isSelfTopBefore = dropIndex < visibleTasks.length && visibleTasks[dropIndex]?.id === movedTaskId && rawPlacement === "before";
+    if (isSelfTopBefore) {
+      clearDragState();
       return;
     }
-    if (!isValidParentDrop(movedTaskId, dropIndex)) {
-      setDraggingIndex(null);
-      setDragOverIndex(null);
-      dragOriginIndexRef.current = null;
-      dragTaskIdRef.current = null;
+    const isFirstChildTopAfterParent = dropIndex < visibleTasks.length && rawPlacement === "before" && visibleTasks[dropIndex]?.parentId === visibleTasks[dropIndex - 1]?.id;
+    if (isFirstChildTopAfterParent) {
+      clearDragState();
       return;
     }
-    const reorderPosition = getVisibleReorderPosition(
+    const normalizedTarget = dropIndex >= visibleTasks.length ? { index: dropIndex, placement: "end" } : normalizeDropTarget(movedTaskId, {
+      index: dropIndex,
+      placement: rawPlacement
+    });
+    if (originVisibleIndex === normalizedTarget.index && normalizedTarget.placement === "before") {
+      clearDragState();
+      return;
+    }
+    if (!isValidParentDrop(movedTaskId, normalizedTarget.index)) {
+      clearDragState();
+      return;
+    }
+    const reorderPlan = getVisibleReorderPlan(
       orderedTasks,
       visibleTasks,
       movedTaskId,
-      originVisibleIndex,
-      dropIndex
+      normalizedTarget
     );
-    if (!reorderPosition) {
-      setDraggingIndex(null);
-      setDragOverIndex(null);
-      dragOriginIndexRef.current = null;
-      dragTaskIdRef.current = null;
+    if (!reorderPlan) {
+      clearDragState();
       return;
     }
-    const { originOrderedIndex, insertIndex } = reorderPosition;
-    if (insertIndex === originOrderedIndex) {
-      setDraggingIndex(null);
-      setDragOverIndex(null);
-      dragOriginIndexRef.current = null;
-      dragTaskIdRef.current = null;
+    const { originOrderedIndex, insertIndex, inferredParentId } = reorderPlan;
+    const moved = orderedTasks[originOrderedIndex];
+    const currentParentId = moved.parentId || void 0;
+    if (insertIndex === originOrderedIndex && inferredParentId === currentParentId) {
+      clearDragState();
       return;
     }
-    const moved = orderedTasks[originOrderedIndex];
     const hasChildren = isTaskParent(moved.id, orderedTasks);
     let subtree;
     let subtreeCount;
@@ -7233,47 +7465,14 @@ var TaskList = ({
     const reordered = [...orderedTasks];
     reordered.splice(originOrderedIndex, subtreeCount);
     const adjustedInsertIndex = insertIndex;
-    let inferredParentId;
-    if (moved.parentId) {
-      const parentIndex = reordered.findIndex((t) => t.id === moved.parentId);
-      if (parentIndex === -1) {
-        inferredParentId = void 0;
-      } else {
-        const numSiblings = reordered.filter((t) => t.parentId === moved.parentId).length;
-        const groupEnd = parentIndex + numSiblings;
-        if (adjustedInsertIndex <= parentIndex || adjustedInsertIndex > groupEnd) {
-          inferredParentId = void 0;
-        } else {
-          inferredParentId = moved.parentId;
-        }
-      }
-    } else {
-    }
     reordered.splice(adjustedInsertIndex, 0, ...subtree);
-    if (!moved.parentId && !hasChildren) {
-      const taskAbove = adjustedInsertIndex > 0 ? reordered[adjustedInsertIndex - 1] : null;
-      const taskBelow = adjustedInsertIndex < reordered.length - 1 ? reordered[adjustedInsertIndex + 1] : null;
-      if (taskAbove && taskBelow && taskBelow.parentId === taskAbove.id) {
-        inferredParentId = taskAbove.id;
-      } else if (taskAbove && taskBelow && taskAbove.parentId && taskAbove.parentId === taskBelow.parentId) {
-        inferredParentId = taskAbove.parentId;
-      } else if (!taskAbove && taskBelow && taskBelow.parentId) {
-        inferredParentId = taskBelow.parentId;
-      }
-    }
     onReorder?.(reordered, moved.id, inferredParentId);
     onTaskSelect?.(moved.id);
-    setDraggingIndex(null);
-    setDragOverIndex(null);
-    dragOriginIndexRef.current = null;
-    dragTaskIdRef.current = null;
-  }, [orderedTasks, visibleTasks, onReorder, onTaskSelect]);
+    clearDragState();
+  }, [orderedTasks, visibleTasks, onReorder, onTaskSelect, isValidParentDrop, clearDragState, normalizeDropTarget]);
   const handleDragEnd = useCallback5(() => {
-    setDraggingIndex(null);
-    setDragOverIndex(null);
-    dragOriginIndexRef.current = null;
-    dragTaskIdRef.current = null;
-  }, []);
+    clearDragState();
+  }, [clearDragState]);
   const handleConfirmNewTask = useCallback5((name) => {
     const range = buildDefaultTaskDateRange(getTodayISODate(), {
       businessDays,
@@ -7667,12 +7866,15 @@ var TaskList = ({
                     onAdd,
                     onInsertAfter: handleStartInsertAfter,
                     editingTaskId: propEditingTaskId,
-                    isDragging: !disableTaskDrag && draggingIndex === index,
-                    isDragOver: !disableTaskDrag && dragOverIndex === index,
-                    onDragStart: disableTaskDrag ? void 0 : handleDragStart,
-                    onDragOver: disableTaskDrag ? void 0 : handleDragOver,
-                    onDrop: disableTaskDrag ? void 0 : handleDrop,
-                    onDragEnd: disableTaskDrag ? void 0 : handleDragEnd,
+                    isDragging: !reorderDisabled && draggingIndex === index,
+                    isDragOver: !reorderDisabled && dragOverTarget?.index === index,
+                    dragOverPlacement: !reorderDisabled && dragOverTarget?.index === index && dragOverTarget.placement !== "end" ? dragOverTarget.placement : null,
+                    isNestedDropTarget: !reorderDisabled && dragOverTarget?.index === index && !!dragOverTarget.inferredParentId,
+                    isDirectChildDropTarget: !reorderDisabled && dragOverTarget?.index === index && !!dragOverTarget.isDirectChildDrop,
+                    onDragStart: reorderDisabled ? void 0 : handleDragStart,
+                    onDragOver: reorderDisabled ? void 0 : handleDragOver,
+                    onDrop: reorderDisabled ? void 0 : handleDrop,
+                    onDragEnd: reorderDisabled ? void 0 : handleDragEnd,
                     collapsedParentIds,
                     onToggleCollapse: handleToggleCollapse,
                     onPromoteTask,
@@ -7726,25 +7928,25 @@ var TaskList = ({
         enableAddTask && onAdd && !isCreating && !pendingInsert && /* @__PURE__ */ jsx14(
           "button",
           {
-            className: `gantt-tl-add-btn${!disableTaskDrag && dragOverIndex === visibleTasks.length ? " gantt-tl-add-btn-drag-over" : ""}`,
+            className: `gantt-tl-add-btn${!reorderDisabled && dragOverTarget?.index === visibleTasks.length ? " gantt-tl-add-btn-drag-over" : ""}`,
             onClick: () => {
               setPendingInsert(null);
               setIsCreating(true);
             },
-            onDragEnter: disableTaskDrag ? void 0 : (e) => {
+            onDragEnter: reorderDisabled ? void 0 : (e) => {
               e.preventDefault();
-              setDragOverIndex(visibleTasks.length);
+              setDragOverTarget({ index: visibleTasks.length, placement: "end" });
             },
-            onDragOver: disableTaskDrag ? void 0 : (e) => {
+            onDragOver: reorderDisabled ? void 0 : (e) => {
               e.preventDefault();
               e.dataTransfer.dropEffect = "move";
-              setDragOverIndex(visibleTasks.length);
+              setDragOverTarget({ index: visibleTasks.length, placement: "end" });
             },
-            onDragLeave: disableTaskDrag ? void 0 : (e) => {
+            onDragLeave: reorderDisabled ? void 0 : (e) => {
               e.preventDefault();
-              setDragOverIndex(null);
+              setDragOverTarget(null);
             },
-            onDrop: disableTaskDrag ? void 0 : (e) => {
+            onDrop: reorderDisabled ? void 0 : (e) => {
               e.preventDefault();
               handleDrop(visibleTasks.length, e);
             },
@@ -10169,6 +10371,7 @@ function TaskGanttChartInner(props, ref) {
     onDelete,
     onInsertAfter,
     onReorder,
+    disableTaskListReorder = false,
     onPromoteTask,
     onDemoteTask,
     onUngroupTask,
@@ -10676,10 +10879,12 @@ function TaskGanttChartInner(props, ref) {
       onTasksChange?.([promotedTask]);
       return;
     }
+    const tasksWithoutPromoted = tasks.filter((t) => t.id !== taskId);
+    const insertIndex = lastSiblingIndex.index;
     const reorderedTasks = normalizeHierarchyTasks([
-      ...tasks.filter((t) => t.id !== taskId).slice(0, lastSiblingIndex.index + 1),
+      ...tasksWithoutPromoted.slice(0, insertIndex),
       promotedTask,
-      ...tasks.filter((t) => t.id !== taskId).slice(lastSiblingIndex.index + 1)
+      ...tasksWithoutPromoted.slice(insertIndex)
     ]);
     onTasksChange?.(reorderedTasks);
   }, [tasks, onTasksChange, onPromoteTask]);
@@ -10833,7 +11038,7 @@ function TaskGanttChartInner(props, ref) {
                     onDelete: handleDelete,
                     onInsertAfter: handleInsertAfter,
                     onReorder: handleReorder,
-                    disableTaskDrag,
+                    disableTaskDrag: disableTaskListReorder,
                     editingTaskId,
                     enableAddTask,
                     defaultTaskDurationDays,
@@ -11124,6 +11329,7 @@ export {
   getSuccessorChain,
   getTaskDuration,
   getTransitiveCascadeChain,
+  getVisibleReorderPlan,
   getVisibleReorderPosition,
   getWeekBlocks,
   getWeekSpans,