gantt-lib 0.62.0 → 0.63.0

package/dist/index.mjs

@@ -5342,7 +5342,8 @@ var TaskListRow = React9.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);
             },
@@ -5910,10 +5911,17 @@ TaskListRow.displayName = "TaskListRow";
 // src/components/TaskList/NewTaskRow.tsx
 import { useState as useState5, useRef as useRef5, useEffect as useEffect5 } from "react";
 import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
-var NewTaskRow = ({ rowHeight, onConfirm, onCancel }) => {
+var NewTaskRow = ({
+  rowHeight,
+  onConfirm,
+  onCancel,
+  nestingDepth = 0
+}) => {
   const [nameValue, setNameValue] = useState5("");
   const inputRef = useRef5(null);
   const confirmedRef = useRef5(false);
+  const inputInnerPadding = 4;
+  const levelOffset = nestingDepth > 0 ? nestingDepth * 20 + 8 : 0;
   useEffect5(() => {
     if (inputRef.current) {
       inputRef.current.focus();
@@ -5952,7 +5960,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__ */ jsx13("div", { className: "gantt-tl-cell" }),
@@ -6376,6 +6389,7 @@ var TaskList = ({
     onTasksChange?.([{ ...task, dependencies: updatedDeps }]);
   }, [tasks, onTasksChange]);
   const [isCreating, setIsCreating] = useState6(false);
+  const [pendingInsert, setPendingInsert] = useState6(null);
   const [draggingIndex, setDraggingIndex] = useState6(null);
   const [dragOverIndex, setDragOverIndex] = useState6(null);
   const dragOriginIndexRef = useRef6(null);
@@ -6534,6 +6548,81 @@ var TaskList = ({
     setIsCreating(false);
   }, [onAdd]);
   const handleCancelNewTask = useCallback5(() => setIsCreating(false), []);
+  const findInsertAfterTaskId = useCallback5((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 = useMemo8(() => {
+    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 = useCallback5((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 = useCallback5((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 = useCallback5(() => setPendingInsert(null), []);
   function getTaskDepth(task, tasks2) {
     if (!task) return 0;
     let depth = 0;
@@ -6673,73 +6762,87 @@ var TaskList = ({
         /* @__PURE__ */ jsx14("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__ */ jsx14(
-            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__ */ jsxs11(React11.Fragment, { children: [
+            /* @__PURE__ */ jsx14(
+              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__ */ jsx14(
+              NewTaskRow,
+              {
+                rowHeight,
+                onConfirm: handleConfirmInsertedTask,
+                onCancel: handleCancelInsertedTask,
+                nestingDepth: pendingInsert?.nestingDepth ?? 0
+              }
+            )
+          ] }, task.id);
         }) }),
-        isCreating && /* @__PURE__ */ jsx14(
+        isCreating && !pendingInsert && /* @__PURE__ */ jsx14(
           NewTaskRow,
           {
             rowHeight,
             onConfirm: handleConfirmNewTask,
-            onCancel: handleCancelNewTask
+            onCancel: handleCancelNewTask,
+            nestingDepth: 0
           }
         ),
-        enableAddTask && onAdd && !isCreating && /* @__PURE__ */ jsx14(
+        enableAddTask && onAdd && !isCreating && !pendingInsert && /* @__PURE__ */ jsx14(
           "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);
@@ -7016,7 +7119,6 @@ function GanttChartInner(props, ref) {
     toDelete.forEach((id) => onDelete?.(id));
   }, [tasks, onTasksChange, onDelete]);
   const handleInsertAfter = useCallback6((taskId, newTask) => {
-    setEditingTaskId(newTask.id);
     onInsertAfter?.(taskId, newTask);
   }, [onInsertAfter]);
   const handleReorder = useCallback6((reorderedTasks, movedTaskId, inferredParentId) => {