gantt-lib 0.61.0 → 0.63.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import React$1, { ReactNode } from 'react';
-import { T as Task$1, V as ValidationResult } from './index-BlUshzVg.js';
-export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampDateRangeForIncomingFS, m as clampTaskRangeForIncomingFS, n as computeLagFromDates, o as computeParentDates, p as computeParentProgress, q as detectCycles, r as findParentId, s as getAllDependencyEdges, t as getAllDescendants, u as getBusinessDayOffset, v as getChildren, w as getDependencyLag, x as getSuccessorChain, y as getTaskDuration, z as getTransitiveCascadeChain, A as isAncestorTask, B as isTaskParent, C as moveTaskRange, E as moveTaskWithCascade, F as normalizeDependencyLag, H as normalizeUTCDate, I as parseDateOnly, J as recalculateIncomingLags, K as recalculateProjectSchedule, N as recalculateTaskFromDependencies, O as reflowTasksOnModeSwitch, P as removeDependenciesBetweenTasks, Q as resizeTaskWithCascade, R as resolveDateRangeFromPixels, S as shiftBusinessDayOffset, U as universalCascade, X as validateDependencies } from './index-BlUshzVg.js';
+import { T as Task$1, V as ValidationResult } from './index-DMA7NbWe.js';
+export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampTaskRangeForIncomingFS, m as computeLagFromDates, n as computeParentDates, o as computeParentProgress, p as detectCycles, q as findParentId, r as getAllDependencyEdges, s as getAllDescendants, t as getBusinessDayOffset, u as getChildren, v as getDependencyLag, w as getSuccessorChain, x as getTaskDuration, y as getTransitiveCascadeChain, z as isAncestorTask, A as isTaskParent, B as moveTaskRange, C as moveTaskWithCascade, E as normalizeDependencyLag, F as normalizeUTCDate, H as parseDateOnly, I as recalculateIncomingLags, J as recalculateProjectSchedule, K as recalculateTaskFromDependencies, N as reflowTasksOnModeSwitch, O as removeDependenciesBetweenTasks, P as resizeTaskWithCascade, Q as shiftBusinessDayOffset, R as universalCascade, S as validateDependencies } from './index-DMA7NbWe.js';
 import * as RadixPopover from '@radix-ui/react-popover';
 
 /**
@@ -863,6 +863,40 @@ interface UseTaskDragReturn {
  */
 declare const useTaskDrag: (options: UseTaskDragOptions) => UseTaskDragReturn;
 
+/**
+ * UI adapter: converts pixel coordinates to date ranges for drag interactions.
+ * @module adapters/scheduling
+ *
+ * These functions bridge the chart's pixel-space (left, width, dayWidth)
+ * with the scheduling domain's date-space. They depend on core scheduling
+ * primitives but are NOT part of the domain core themselves.
+ */
+
+/**
+ * Convert pixel coordinates to a date range, applying business-day alignment
+ * when businessDays mode is active. This is the pure scheduling core of
+ * drag-to-date conversion.
+ *
+ * Extracted from useTaskDrag.ts resolveDraggedRange.
+ */
+declare function resolveDateRangeFromPixels(mode: 'move' | 'resize-left' | 'resize-right', left: number, width: number, monthStart: Date, dayWidth: number, task: Task$1, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Clamp a proposed date range based on incoming FS dependencies.
+ * For resize-right mode, returns range unchanged (only start is clamped).
+ *
+ * Extracted from useTaskDrag.ts clampDraggedRangeForIncomingFS.
+ */
+declare function clampDateRangeForIncomingFS(task: Task$1, range: {
+    start: Date;
+    end: Date;
+}, allTasks: Task$1[], mode: 'move' | 'resize-left' | 'resize-right', businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+
 /**
  * Checks whether a task is behind the expected progress for the current date.
  * Uses the same progress-based rule as expired task highlighting in TaskRow.
@@ -1051,4 +1085,4 @@ interface VisibleReorderPosition {
  */
 declare function getVisibleReorderPosition(orderedTasks: TaskLike[], visibleTasks: TaskLike[], movedTaskId: string, originVisibleIndex: number, dropVisibleIndex: number): VisibleReorderPosition | null;
 
-export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, subtractBusinessDays, useTaskDrag, withoutDeps };
+export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, clampDateRangeForIncomingFS, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, resolveDateRangeFromPixels, subtractBusinessDays, useTaskDrag, withoutDeps };

package/dist/index.js

@@ -1662,65 +1662,6 @@ function validateDependencies(tasks) {
   };
 }
 
-// src/adapters/scheduling/drag.ts
-init_dateMath();
-function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
-  const dayOffset = Math.round(left / dayWidth);
-  const rawStartDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + dayOffset
-  ));
-  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
-  const rawEndDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + rawEndOffset
-  ));
-  if (!(businessDays && weekendPredicate)) {
-    return { start: rawStartDate, end: rawEndDate };
-  }
-  if (mode === "move") {
-    const originalStart2 = new Date(task.startDate);
-    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
-    return moveTaskRange(
-      task.startDate,
-      task.endDate,
-      rawStartDate,
-      true,
-      weekendPredicate,
-      snapDirection2
-    );
-  }
-  if (mode === "resize-right") {
-    const fixedStart = new Date(task.startDate);
-    const originalEnd = new Date(task.endDate);
-    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
-    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
-    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
-    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
-  }
-  const fixedEnd = new Date(task.endDate);
-  const originalStart = new Date(task.startDate);
-  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
-  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
-  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
-  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
-}
-function clampDateRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
-  if (mode === "resize-right") {
-    return range;
-  }
-  return clampTaskRangeForIncomingFS(
-    task,
-    range.start,
-    range.end,
-    allTasks,
-    businessDays,
-    weekendPredicate
-  );
-}
-
 // src/utils/hierarchyOrder.ts
 init_dateUtils();
 function flattenHierarchy(tasks) {
@@ -2202,6 +2143,67 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
 
 // src/hooks/useTaskDrag.ts
 var import_react2 = require("react");
+
+// src/adapters/scheduling/drag.ts
+init_dateMath();
+function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
+  const dayOffset = Math.round(left / dayWidth);
+  const rawStartDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + dayOffset
+  ));
+  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
+  const rawEndDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + rawEndOffset
+  ));
+  if (!(businessDays && weekendPredicate)) {
+    return { start: rawStartDate, end: rawEndDate };
+  }
+  if (mode === "move") {
+    const originalStart2 = new Date(task.startDate);
+    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
+    return moveTaskRange(
+      task.startDate,
+      task.endDate,
+      rawStartDate,
+      true,
+      weekendPredicate,
+      snapDirection2
+    );
+  }
+  if (mode === "resize-right") {
+    const fixedStart = new Date(task.startDate);
+    const originalEnd = new Date(task.endDate);
+    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
+    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
+    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
+    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
+  }
+  const fixedEnd = new Date(task.endDate);
+  const originalStart = new Date(task.startDate);
+  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
+  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
+  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
+  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
+}
+function clampDateRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
+  if (mode === "resize-right") {
+    return range;
+  }
+  return clampTaskRangeForIncomingFS(
+    task,
+    range.start,
+    range.end,
+    allTasks,
+    businessDays,
+    weekendPredicate
+  );
+}
+
+// src/hooks/useTaskDrag.ts
 var globalActiveDrag = null;
 var globalRafId = null;
 function getDayOffsetFromMonthStart(date, monthStart) {
@@ -5431,7 +5433,8 @@ var TaskListRow = import_react10.default.memo(
                 id: crypto.randomUUID(),
                 name: "\u041D\u043E\u0432\u0430\u044F \u0437\u0430\u0434\u0430\u0447\u0430",
                 startDate: todayISO,
-                endDate: endISO
+                endDate: endISO,
+                parentId: task.parentId
               };
               onInsertAfter(task.id, newTask);
             },
@@ -5999,10 +6002,17 @@ TaskListRow.displayName = "TaskListRow";
 // src/components/TaskList/NewTaskRow.tsx
 var import_react11 = require("react");
 var import_jsx_runtime13 = require("react/jsx-runtime");
-var NewTaskRow = ({ rowHeight, onConfirm, onCancel }) => {
+var NewTaskRow = ({
+  rowHeight,
+  onConfirm,
+  onCancel,
+  nestingDepth = 0
+}) => {
   const [nameValue, setNameValue] = (0, import_react11.useState)("");
   const inputRef = (0, import_react11.useRef)(null);
   const confirmedRef = (0, import_react11.useRef)(false);
+  const inputInnerPadding = 4;
+  const levelOffset = nestingDepth > 0 ? nestingDepth * 20 + 8 : 0;
   (0, import_react11.useEffect)(() => {
     if (inputRef.current) {
       inputRef.current.focus();
@@ -6041,7 +6051,12 @@ var NewTaskRow = ({ rowHeight, onConfirm, onCancel }) => {
         onKeyDown: handleKeyDown,
         onBlur: handleBlur,
         placeholder: "\u041D\u0430\u0437\u0432\u0430\u043D\u0438\u0435",
-        className: "gantt-tl-name-input"
+        className: "gantt-tl-name-input",
+        style: {
+          left: `${Math.max(0, levelOffset - inputInnerPadding)}px`,
+          width: levelOffset > 0 ? `calc(100% - ${Math.max(0, levelOffset - inputInnerPadding)}px)` : "100%",
+          paddingLeft: `${inputInnerPadding}px`
+        }
       }
     ) }),
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "gantt-tl-cell" }),
@@ -6465,6 +6480,7 @@ var TaskList = ({
     onTasksChange?.([{ ...task, dependencies: updatedDeps }]);
   }, [tasks, onTasksChange]);
   const [isCreating, setIsCreating] = (0, import_react12.useState)(false);
+  const [pendingInsert, setPendingInsert] = (0, import_react12.useState)(null);
   const [draggingIndex, setDraggingIndex] = (0, import_react12.useState)(null);
   const [dragOverIndex, setDragOverIndex] = (0, import_react12.useState)(null);
   const dragOriginIndexRef = (0, import_react12.useRef)(null);
@@ -6623,6 +6639,81 @@ var TaskList = ({
     setIsCreating(false);
   }, [onAdd]);
   const handleCancelNewTask = (0, import_react12.useCallback)(() => setIsCreating(false), []);
+  const findInsertAfterTaskId = (0, import_react12.useCallback)((anchorTaskId) => {
+    const anchorIndex = orderedTasks.findIndex((task) => task.id === anchorTaskId);
+    if (anchorIndex === -1) {
+      return anchorTaskId;
+    }
+    const taskById = new Map(orderedTasks.map((task) => [task.id, task]));
+    let insertAfterTaskId = anchorTaskId;
+    for (let index = anchorIndex + 1; index < orderedTasks.length; index += 1) {
+      let currentParentId = orderedTasks[index]?.parentId;
+      let isDescendant = false;
+      while (currentParentId) {
+        if (currentParentId === anchorTaskId) {
+          isDescendant = true;
+          break;
+        }
+        currentParentId = taskById.get(currentParentId)?.parentId;
+      }
+      if (!isDescendant) {
+        break;
+      }
+      insertAfterTaskId = orderedTasks[index].id;
+    }
+    return insertAfterTaskId;
+  }, [orderedTasks]);
+  const pendingInsertDisplayTaskId = (0, import_react12.useMemo)(() => {
+    if (!pendingInsert) {
+      return null;
+    }
+    const taskById = new Map(visibleTasks.map((task) => [task.id, task]));
+    if (!taskById.has(pendingInsert.anchorTaskId)) {
+      return null;
+    }
+    let displayTaskId = pendingInsert.anchorTaskId;
+    for (const task of visibleTasks) {
+      let currentParentId = task.parentId;
+      while (currentParentId) {
+        if (currentParentId === pendingInsert.anchorTaskId) {
+          displayTaskId = task.id;
+          break;
+        }
+        currentParentId = taskById.get(currentParentId)?.parentId;
+      }
+    }
+    return displayTaskId;
+  }, [pendingInsert, visibleTasks]);
+  const handleStartInsertAfter = (0, import_react12.useCallback)((taskId, newTask) => {
+    const anchorTask = orderedTasks.find((task) => task.id === taskId);
+    if (!anchorTask) {
+      return;
+    }
+    setIsCreating(false);
+    setPendingInsert({
+      anchorTaskId: taskId,
+      insertAfterTaskId: findInsertAfterTaskId(taskId),
+      parentId: anchorTask.parentId,
+      startDate: newTask.startDate,
+      endDate: newTask.endDate,
+      nestingDepth: nestingDepthMap.get(taskId) ?? 0
+    });
+  }, [findInsertAfterTaskId, nestingDepthMap, orderedTasks]);
+  const handleConfirmInsertedTask = (0, import_react12.useCallback)((name) => {
+    if (!pendingInsert) {
+      return;
+    }
+    const newTask = {
+      id: crypto.randomUUID(),
+      name,
+      startDate: pendingInsert.startDate,
+      endDate: pendingInsert.endDate,
+      parentId: pendingInsert.parentId
+    };
+    onInsertAfter?.(pendingInsert.insertAfterTaskId, newTask);
+    setPendingInsert(null);
+  }, [onInsertAfter, pendingInsert]);
+  const handleCancelInsertedTask = (0, import_react12.useCallback)(() => setPendingInsert(null), []);
   function getTaskDepth(task, tasks2) {
     if (!task) return 0;
     let depth = 0;
@@ -6762,73 +6853,87 @@ var TaskList = ({
         /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "gantt-tl-body", style: { height: `${totalHeight}px` }, children: visibleTasks.map((task, index) => {
           const previousVisibleTask = index > 0 ? visibleTasks[index - 1] : void 0;
           const canDemoteTask = index === 0 || !task.parentId || previousVisibleTask?.id !== task.parentId;
-          return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
-            TaskListRow,
-            {
-              task,
-              rowIndex: index,
-              taskNumber: originalTaskNumberMap[task.id] || "",
-              taskNumberMap: originalTaskNumberMap,
-              rowHeight,
-              onTasksChange,
-              selectedTaskId,
-              onRowClick: handleRowClick,
-              disableTaskNameEditing,
-              disableDependencyEditing,
-              allTasks: tasks,
-              activeLinkType,
-              onSetActiveLinkType: setActiveLinkType,
-              selectingPredecessorFor,
-              dependencyPickMode,
-              onSetDependencyPickMode: setDependencyPickMode,
-              onSetSelectingPredecessorFor: setSelectingPredecessorFor,
-              onAddDependency: handleAddDependency,
-              onRemoveDependency: handleRemoveDependency,
-              selectedChip,
-              onChipSelect: handleChipSelect,
-              onScrollToTask,
-              onDelete,
-              onAdd,
-              onInsertAfter,
-              editingTaskId: propEditingTaskId,
-              isDragging: draggingIndex === index,
-              isDragOver: dragOverIndex === index,
-              onDragStart: handleDragStart,
-              onDragOver: handleDragOver,
-              onDrop: handleDrop,
-              onDragEnd: handleDragEnd,
-              collapsedParentIds,
-              onToggleCollapse: handleToggleCollapse,
-              onPromoteTask,
-              onDemoteTask: onDemoteTask ? handleDemoteWrapper : void 0,
-              onDuplicateTask: onReorder ? handleDuplicateTask : void 0,
-              canDemoteTask,
-              isLastChild: lastChildIds.has(task.id),
-              nestingDepth: nestingDepthMap.get(task.id) ?? 0,
-              ancestorContinues: ancestorContinuesMap.get(task.id) ?? [],
-              customDays,
-              isWeekend: isWeekend3,
-              businessDays,
-              isFilterMatch: filterMode === "highlight" ? highlightedTaskIds.has(task.id) : false,
-              isFilterHideMode: filterMode === "hide" && isFilterActive,
-              resolvedColumns
-            },
-            task.id
-          );
+          return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react12.default.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+              TaskListRow,
+              {
+                task,
+                rowIndex: index,
+                taskNumber: originalTaskNumberMap[task.id] || "",
+                taskNumberMap: originalTaskNumberMap,
+                rowHeight,
+                onTasksChange,
+                selectedTaskId,
+                onRowClick: handleRowClick,
+                disableTaskNameEditing,
+                disableDependencyEditing,
+                allTasks: tasks,
+                activeLinkType,
+                onSetActiveLinkType: setActiveLinkType,
+                selectingPredecessorFor,
+                dependencyPickMode,
+                onSetDependencyPickMode: setDependencyPickMode,
+                onSetSelectingPredecessorFor: setSelectingPredecessorFor,
+                onAddDependency: handleAddDependency,
+                onRemoveDependency: handleRemoveDependency,
+                selectedChip,
+                onChipSelect: handleChipSelect,
+                onScrollToTask,
+                onDelete,
+                onAdd,
+                onInsertAfter: handleStartInsertAfter,
+                editingTaskId: propEditingTaskId,
+                isDragging: draggingIndex === index,
+                isDragOver: dragOverIndex === index,
+                onDragStart: handleDragStart,
+                onDragOver: handleDragOver,
+                onDrop: handleDrop,
+                onDragEnd: handleDragEnd,
+                collapsedParentIds,
+                onToggleCollapse: handleToggleCollapse,
+                onPromoteTask,
+                onDemoteTask: onDemoteTask ? handleDemoteWrapper : void 0,
+                onDuplicateTask: onReorder ? handleDuplicateTask : void 0,
+                canDemoteTask,
+                isLastChild: lastChildIds.has(task.id),
+                nestingDepth: nestingDepthMap.get(task.id) ?? 0,
+                ancestorContinues: ancestorContinuesMap.get(task.id) ?? [],
+                customDays,
+                isWeekend: isWeekend3,
+                businessDays,
+                isFilterMatch: filterMode === "highlight" ? highlightedTaskIds.has(task.id) : false,
+                isFilterHideMode: filterMode === "hide" && isFilterActive,
+                resolvedColumns
+              }
+            ),
+            pendingInsertDisplayTaskId === task.id && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+              NewTaskRow,
+              {
+                rowHeight,
+                onConfirm: handleConfirmInsertedTask,
+                onCancel: handleCancelInsertedTask,
+                nestingDepth: pendingInsert?.nestingDepth ?? 0
+              }
+            )
+          ] }, task.id);
         }) }),
-        isCreating && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+        isCreating && !pendingInsert && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
           NewTaskRow,
           {
             rowHeight,
             onConfirm: handleConfirmNewTask,
-            onCancel: handleCancelNewTask
+            onCancel: handleCancelNewTask,
+            nestingDepth: 0
           }
         ),
-        enableAddTask && onAdd && !isCreating && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+        enableAddTask && onAdd && !isCreating && !pendingInsert && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
           "button",
           {
             className: `gantt-tl-add-btn${dragOverIndex === visibleTasks.length ? " gantt-tl-add-btn-drag-over" : ""}`,
-            onClick: () => setIsCreating(true),
+            onClick: () => {
+              setPendingInsert(null);
+              setIsCreating(true);
+            },
             onDragEnter: (e) => {
               e.preventDefault();
               setDragOverIndex(visibleTasks.length);
@@ -7105,7 +7210,6 @@ function GanttChartInner(props, ref) {
     toDelete.forEach((id) => onDelete?.(id));
   }, [tasks, onTasksChange, onDelete]);
   const handleInsertAfter = (0, import_react13.useCallback)((taskId, newTask) => {
-    setEditingTaskId(newTask.id);
     onInsertAfter?.(taskId, newTask);
   }, [onInsertAfter]);
   const handleReorder = (0, import_react13.useCallback)((reorderedTasks, movedTaskId, inferredParentId) => {
@@ -7119,8 +7223,11 @@ function GanttChartInner(props, ref) {
       });
     }
     const normalized = normalizeHierarchyTasks(updated);
+    if (onReorder) {
+      onReorder(normalized, movedTaskId, inferredParentId);
+      return;
+    }
     onTasksChange?.(normalized);
-    onReorder?.(normalized, movedTaskId, inferredParentId);
   }, [onTasksChange, onReorder]);
   const dependencyOverrides = (0, import_react13.useMemo)(() => {
     const map = new Map(cascadeOverrides);