gantt-lib 0.6.0 → 0.6.2

package/dist/index.mjs

@@ -492,6 +492,55 @@ function findParentId(taskId, tasks) {
   return task?.parentId;
 }
 
+// src/utils/hierarchyOrder.ts
+function flattenHierarchy(tasks) {
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const byParent = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const normalizedParentId = task.parentId && byId.has(task.parentId) ? task.parentId : void 0;
+    const siblings = byParent.get(normalizedParentId) ?? [];
+    siblings.push(task);
+    byParent.set(normalizedParentId, siblings);
+  }
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (parentId) => {
+    const children = byParent.get(parentId) ?? [];
+    for (const task of children) {
+      if (visited.has(task.id)) continue;
+      visited.add(task.id);
+      result.push(task);
+      walk(task.id);
+    }
+  };
+  walk(void 0);
+  for (const task of tasks) {
+    if (!visited.has(task.id)) {
+      result.push(task);
+    }
+  }
+  return result;
+}
+function normalizeHierarchyTasks(tasks) {
+  const orderedTasks = flattenHierarchy(tasks).map((task) => ({ ...task }));
+  for (const task of [...orderedTasks].reverse()) {
+    if (!isTaskParent(task.id, orderedTasks)) continue;
+    const { startDate, endDate } = computeParentDates(task.id, orderedTasks);
+    const progress = computeParentProgress(task.id, orderedTasks);
+    const normalizedStartDate = startDate.toISOString().split("T")[0];
+    const normalizedEndDate = endDate.toISOString().split("T")[0];
+    const parentIndex = orderedTasks.findIndex((candidate) => candidate.id === task.id);
+    if (parentIndex === -1) continue;
+    orderedTasks[parentIndex] = {
+      ...orderedTasks[parentIndex],
+      startDate: normalizedStartDate,
+      endDate: normalizedEndDate,
+      progress
+    };
+  }
+  return orderedTasks;
+}
+
 // src/components/TimeScaleHeader/TimeScaleHeader.tsx
 import { useMemo } from "react";
 import { format } from "date-fns";
@@ -3080,13 +3129,14 @@ var TaskList = ({
       return next;
     });
   }, []);
+  const orderedTasks = useMemo8(() => normalizeHierarchyTasks(tasks), [tasks]);
   const visibleTasks = useMemo8(() => {
-    return tasks.filter((task) => {
+    return orderedTasks.filter((task) => {
       if (!task.parentId) return true;
       const parentCollapsed = collapsedParentIds.has(task.parentId);
       return !parentCollapsed;
     });
-  }, [tasks, collapsedParentIds]);
+  }, [orderedTasks, collapsedParentIds]);
   const totalHeight = useMemo8(
     () => visibleTasks.length * rowHeight,
     [visibleTasks.length, rowHeight]
@@ -3208,9 +3258,9 @@ var TaskList = ({
       dragOriginIndexRef.current = null;
       return;
     }
-    const reordered = [...tasks];
+    const reordered = [...orderedTasks];
     const [moved] = reordered.splice(originIndex, 1);
-    const insertIndex = dropIndex === tasks.length ? tasks.length - 1 : originIndex < dropIndex ? dropIndex - 1 : dropIndex;
+    const insertIndex = dropIndex === visibleTasks.length ? visibleTasks.length - 1 : originIndex < dropIndex ? dropIndex - 1 : dropIndex;
     const isChild = !!moved.parentId;
     const isParent = tasks.some((t) => t.parentId === moved.id);
     const taskType = isParent ? "PARENT" : isChild ? "CHILD" : "ROOT";
@@ -3225,7 +3275,7 @@ var TaskList = ({
       insertIndex,
       direction: originIndex < dropIndex ? "DOWN" : "UP"
     });
-    console.log("[TASKS ARRAY LENGTH]", tasks.length);
+    console.log("[TASKS ARRAY LENGTH]", orderedTasks.length);
     let inferredParentId;
     if (moved.parentId) {
       const parentIndex = reordered.findIndex((t) => t.id === moved.parentId);
@@ -3310,7 +3360,7 @@ var TaskList = ({
     setDraggingIndex(null);
     setDragOverIndex(null);
     dragOriginIndexRef.current = null;
-  }, [tasks, onReorder, onTaskSelect]);
+  }, [orderedTasks, visibleTasks.length, onReorder, onTaskSelect]);
   const handleDragEnd = useCallback5(() => {
     setDraggingIndex(null);
     setDragOverIndex(null);
@@ -3433,16 +3483,16 @@ var TaskList = ({
         enableAddTask && onAdd && !isCreating && /* @__PURE__ */ jsx14(
           "button",
           {
-            className: `gantt-tl-add-btn${dragOverIndex === tasks.length ? " gantt-tl-add-btn-drag-over" : ""}`,
+            className: `gantt-tl-add-btn${dragOverIndex === visibleTasks.length ? " gantt-tl-add-btn-drag-over" : ""}`,
             onClick: () => setIsCreating(true),
             onDragEnter: (e) => {
               e.preventDefault();
-              setDragOverIndex(tasks.length);
+              setDragOverIndex(visibleTasks.length);
             },
             onDragOver: (e) => {
               e.preventDefault();
               e.dataTransfer.dropEffect = "move";
-              setDragOverIndex(tasks.length);
+              setDragOverIndex(visibleTasks.length);
             },
             onDragLeave: (e) => {
               e.preventDefault();
@@ -3450,7 +3500,7 @@ var TaskList = ({
             },
             onDrop: (e) => {
               e.preventDefault();
-              handleDrop(tasks.length, e);
+              handleDrop(visibleTasks.length, e);
             },
             type: "button",
             children: "+ \u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0443"
@@ -3490,7 +3540,8 @@ var GanttChart = forwardRef(({
   const [selectedChip, setSelectedChip] = useState7(null);
   const [collapsedParentIds, setCollapsedParentIds] = useState7(/* @__PURE__ */ new Set());
   const [editingTaskId, setEditingTaskId] = useState7(null);
-  const dateRange = useMemo9(() => getMultiMonthDays(tasks), [tasks]);
+  const normalizedTasks = useMemo9(() => normalizeHierarchyTasks(tasks), [tasks]);
+  const dateRange = useMemo9(() => getMultiMonthDays(normalizedTasks), [normalizedTasks]);
   const [validationResult, setValidationResult] = useState7(null);
   const [cascadeOverrides, setCascadeOverrides] = useState7(/* @__PURE__ */ new Map());
   const gridWidth = useMemo9(
@@ -3498,12 +3549,12 @@ var GanttChart = forwardRef(({
     [dateRange.length, dayWidth]
   );
   const filteredTasks = useMemo9(() => {
-    return tasks.filter((task) => {
+    return normalizedTasks.filter((task) => {
       if (!task.parentId) return true;
       const parentCollapsed = collapsedParentIds.has(task.parentId);
       return !parentCollapsed;
     });
-  }, [tasks, collapsedParentIds]);
+  }, [normalizedTasks, collapsedParentIds]);
   const totalGridHeight = useMemo9(
     () => filteredTasks.length * rowHeight,
     [filteredTasks.length, rowHeight]
@@ -3749,9 +3800,9 @@ var GanttChart = forwardRef(({
         updatedCount: updated.length
       });
       console.log("=== GANTT CHART handleReorder END ===\n");
-      return updated;
+      return normalizeHierarchyTasks(updated);
     });
-    onReorder?.(reorderedTasks, movedTaskId, inferredParentId);
+    onReorder?.(normalizeHierarchyTasks(reorderedTasks), movedTaskId, inferredParentId);
   }, [onChange, onReorder]);
   const dependencyOverrides = useMemo9(() => {
     const map = new Map(cascadeOverrides);
@@ -3818,15 +3869,15 @@ var GanttChart = forwardRef(({
       const parentId = taskToPromote.parentId;
       const siblings = currentTasks.filter((t) => t.parentId === parentId);
       if (siblings.length <= 1) {
-        return currentTasks.map(
+        return normalizeHierarchyTasks(currentTasks.map(
           (t) => t.id === taskId ? { ...t, parentId: void 0 } : t
-        );
+        ));
       }
       const lastSiblingIndex = currentTasks.map((t, i) => ({ task: t, index: i })).filter(({ task }) => task.parentId === parentId).sort((a, b) => b.index - a.index)[0];
       if (!lastSiblingIndex) {
-        return currentTasks.map(
+        return normalizeHierarchyTasks(currentTasks.map(
           (t) => t.id === taskId ? { ...t, parentId: void 0 } : t
-        );
+        ));
       }
       const withoutPromotedTask = currentTasks.filter((t) => t.id !== taskId);
       const insertIndex = lastSiblingIndex.index + 1;
@@ -3836,7 +3887,7 @@ var GanttChart = forwardRef(({
         promotedTask,
         ...withoutPromotedTask.slice(insertIndex)
       ];
-      return newTasks;
+      return normalizeHierarchyTasks(newTasks);
     });
   }, [onChange]);
   const handleDemoteTask = useCallback6((taskId, newParentId) => {
@@ -3869,7 +3920,7 @@ var GanttChart = forwardRef(({
       updatedTasks = updatedTasks.map(
         (t) => t.id === newParentId ? { ...t, startDate: parentDates.startDate.toISOString().split("T")[0], endDate: parentDates.endDate.toISOString().split("T")[0], progress: parentProgress } : t
       );
-      return updatedTasks;
+      return normalizeHierarchyTasks(updatedTasks);
     });
   }, [onChange]);
   const panStateRef = useRef6(null);
@@ -3927,7 +3978,7 @@ var GanttChart = forwardRef(({
         /* @__PURE__ */ jsx15(
           TaskList,
           {
-            tasks,
+            tasks: normalizedTasks,
             rowHeight,
             headerHeight,
             taskListWidth,
@@ -3982,7 +4033,7 @@ var GanttChart = forwardRef(({
                   DependencyLines_default,
                   {
                     tasks: filteredTasks,
-                    allTasks: tasks,
+                    allTasks: normalizedTasks,
                     collapsedParentIds,
                     monthStart,
                     dayWidth,
@@ -4020,7 +4071,7 @@ var GanttChart = forwardRef(({
                       }
                     },
                     rowIndex: index,
-                    allTasks: tasks,
+                    allTasks: normalizedTasks,
                     enableAutoSchedule: enableAutoSchedule ?? false,
                     disableConstraints: disableConstraints ?? false,
                     overridePosition: cascadeOverrides.get(task.id),
@@ -4086,6 +4137,7 @@ export {
   detectCycles,
   detectEdgeZone,
   findParentId,
+  flattenHierarchy,
   formatDateLabel,
   getAllDependencyEdges,
   getChildren,
@@ -4099,6 +4151,7 @@ export {
   isTaskParent,
   isToday,
   isWeekend,
+  normalizeHierarchyTasks,
   parseUTCDate,
   pixelsToDate,
   recalculateIncomingLags,