gantt-lib 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -1,7 +1,7 @@
 "use client";
 
 // src/components/GanttChart/GanttChart.tsx
-import { useMemo as useMemo5, useCallback as useCallback2, useRef as useRef3, useState as useState3, useEffect as useEffect3 } from "react";
+import { useMemo as useMemo6, useCallback as useCallback2, useRef as useRef2, useState as useState2, useEffect as useEffect2 } from "react";
 
 // src/utils/dateUtils.ts
 var parseUTCDate = (date) => {
@@ -142,6 +142,148 @@ var formatDateLabel = (date) => {
   return `${day}.${month}`;
 };
 
+// src/utils/dependencyUtils.ts
+function buildAdjacencyList(tasks) {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const graph = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const successors = [];
+    for (const otherTask of tasks) {
+      if (otherTask.dependencies) {
+        for (const dep of otherTask.dependencies) {
+          if (dep.taskId === task.id) {
+            successors.push(otherTask.id);
+            break;
+          }
+        }
+      }
+    }
+    graph.set(task.id, successors);
+  }
+  return graph;
+}
+function detectCycles(tasks) {
+  const graph = buildAdjacencyList(tasks);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(taskId) {
+    if (visiting.has(taskId)) {
+      return true;
+    }
+    if (visited.has(taskId)) {
+      return false;
+    }
+    visiting.add(taskId);
+    path.push(taskId);
+    const successors = graph.get(taskId) || [];
+    for (const successor of successors) {
+      if (dfs(successor)) {
+        return true;
+      }
+    }
+    visiting.delete(taskId);
+    path.pop();
+    visited.add(taskId);
+    return false;
+  }
+  for (const task of tasks) {
+    if (dfs(task.id)) {
+      return { hasCycle: true, cyclePath: [...path] };
+    }
+  }
+  return { hasCycle: false };
+}
+function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0) {
+  const baseDate = linkType.startsWith("F") ? predecessorEnd : predecessorStart;
+  const lagMs = lag * 24 * 60 * 60 * 1e3;
+  const resultDate = new Date(baseDate.getTime() + lagMs);
+  return resultDate;
+}
+function validateDependencies(tasks) {
+  const errors = [];
+  const taskIds = new Set(tasks.map((t) => t.id));
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        if (!taskIds.has(dep.taskId)) {
+          errors.push({
+            type: "missing-task",
+            taskId: task.id,
+            message: `Dependency references non-existent task: ${dep.taskId}`,
+            relatedTaskIds: [dep.taskId]
+          });
+        }
+      }
+    }
+  }
+  const cycleResult = detectCycles(tasks);
+  if (cycleResult.hasCycle && cycleResult.cyclePath) {
+    errors.push({
+      type: "cycle",
+      taskId: cycleResult.cyclePath[0],
+      message: "Circular dependency detected",
+      relatedTaskIds: cycleResult.cyclePath
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function getSuccessorChain(draggedTaskId, allTasks) {
+  const successorMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    successorMap.set(task.id, []);
+  }
+  for (const task of allTasks) {
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      if (dep.type === "FS") {
+        const list = successorMap.get(dep.taskId) ?? [];
+        list.push(task.id);
+        successorMap.set(dep.taskId, list);
+      }
+    }
+  }
+  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [draggedTaskId];
+  const chain = [];
+  visited.add(draggedTaskId);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const successors = successorMap.get(current) ?? [];
+    for (const sid of successors) {
+      if (!visited.has(sid)) {
+        visited.add(sid);
+        const t = taskById.get(sid);
+        if (t) {
+          chain.push(t);
+          queue.push(sid);
+        }
+      }
+    }
+  }
+  return chain;
+}
+function getAllDependencyEdges(tasks) {
+  const edges = [];
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        edges.push({
+          predecessorId: dep.taskId,
+          successorId: task.id,
+          type: dep.type,
+          lag: dep.lag ?? 0
+        });
+      }
+    }
+  }
+  return edges;
+}
+
 // src/components/TimeScaleHeader/TimeScaleHeader.tsx
 import { useMemo } from "react";
 import { format } from "date-fns";
@@ -205,7 +347,7 @@ var TimeScaleHeader = ({
 var TimeScaleHeader_default = TimeScaleHeader;
 
 // src/components/TaskRow/TaskRow.tsx
-import React2, { useMemo as useMemo2, useState as useState2, useEffect as useEffect2, useRef as useRef2 } from "react";
+import React2, { useMemo as useMemo2 } from "react";
 
 // src/utils/geometry.ts
 var getUTCDayDifference = (date1, date2) => {
@@ -305,6 +447,43 @@ var calculateWeekendBlocks = (dateRange, dayWidth) => {
   }
   return blocks;
 };
+var calculateBezierPath = (from, to) => {
+  const verticalDistance = Math.abs(to.y - from.y);
+  const cpOffset = Math.max(verticalDistance * 0.5, 20);
+  if (from.y === to.y) {
+    const arcHeight = 20;
+    const midX = (from.x + to.x) / 2;
+    return `M ${from.x} ${from.y} Q ${midX} ${from.y - arcHeight} ${to.x} ${to.y}`;
+  }
+  const cp1x = from.x;
+  const cp1y = from.y + (to.y > from.y ? cpOffset : -cpOffset);
+  const cp2x = to.x;
+  const cp2y = to.y - (to.y > from.y ? cpOffset : -cpOffset);
+  return `M ${Math.round(from.x)} ${Math.round(from.y)} C ${Math.round(cp1x)} ${Math.round(cp1y)}, ${Math.round(cp2x)} ${Math.round(cp2y)}, ${Math.round(to.x)} ${Math.round(to.y)}`;
+};
+var calculateOrthogonalPath = (from, to) => {
+  const fx = Math.round(from.x);
+  const fy = Math.round(from.y);
+  const tx = Math.round(to.x);
+  const ty = Math.round(to.y);
+  if (fy === ty) {
+    return `M ${fx} ${fy} H ${tx}`;
+  }
+  const C = 2;
+  const goingDown = ty > fy;
+  const goingRight = tx >= fx;
+  const dirY = goingDown ? 1 : -1;
+  const dirX = goingRight ? 1 : -1;
+  if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
+    return [
+      `M ${fx} ${fy}`,
+      `H ${tx - dirX * C}`,
+      `L ${tx} ${fy + dirY * C}`,
+      `V ${ty}`
+    ].join(" ");
+  }
+  return `M ${fx} ${fy} H ${tx} V ${ty}`;
+};
 
 // src/hooks/useTaskDrag.ts
 import { useEffect, useRef, useState, useCallback } from "react";
@@ -316,8 +495,8 @@ function completeDrag() {
     globalRafId = null;
   }
   if (globalActiveDrag) {
+    globalActiveDrag.onCascadeProgress?.(/* @__PURE__ */ new Map());
     const { onComplete, currentLeft, currentWidth } = globalActiveDrag;
-    const drag = globalActiveDrag;
     globalActiveDrag = null;
     onComplete(currentLeft, currentWidth);
   }
@@ -336,6 +515,27 @@ function cancelDrag() {
 function snapToGrid(pixels, dayWidth) {
   return Math.round(pixels / dayWidth) * dayWidth;
 }
+function recalculateIncomingLags(task, newStartDate, allTasks) {
+  if (!task.dependencies) return [];
+  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  return task.dependencies.map((dep) => {
+    if (dep.type !== "FS") return dep;
+    const predecessor = taskById.get(dep.taskId);
+    if (!predecessor) return dep;
+    const predEnd = new Date(predecessor.endDate);
+    const lagMs = Date.UTC(
+      newStartDate.getUTCFullYear(),
+      newStartDate.getUTCMonth(),
+      newStartDate.getUTCDate()
+    ) - Date.UTC(
+      predEnd.getUTCFullYear(),
+      predEnd.getUTCMonth(),
+      predEnd.getUTCDate()
+    );
+    const lagDays = Math.round(lagMs / (24 * 60 * 60 * 1e3));
+    return { ...dep, lag: lagDays };
+  });
+}
 function handleGlobalMouseMove(e) {
   if (!globalActiveDrag || globalRafId !== null) {
     return;
@@ -345,7 +545,7 @@ function handleGlobalMouseMove(e) {
       globalRafId = null;
       return;
     }
-    const { startX, initialLeft, initialWidth, mode, dayWidth, onProgress } = globalActiveDrag;
+    const { startX, initialLeft, initialWidth, mode, dayWidth, onProgress, allTasks } = globalActiveDrag;
     const deltaX = e.clientX - startX;
     let newLeft = initialLeft;
     let newWidth = initialWidth;
@@ -364,6 +564,50 @@ function handleGlobalMouseMove(e) {
         newWidth = Math.max(dayWidth, snappedWidth);
         break;
     }
+    if (mode === "move" && allTasks.length > 0 && !globalActiveDrag.disableConstraints) {
+      const currentTask = allTasks.find((t) => t.id === globalActiveDrag?.taskId);
+      if (currentTask && currentTask.dependencies && currentTask.dependencies.length > 0) {
+        let minAllowedLeft = 0;
+        for (const dep of currentTask.dependencies) {
+          if (dep.type !== "FS") continue;
+          const predecessor = globalActiveDrag.allTasks.find((t) => t.id === dep.taskId);
+          if (!predecessor) continue;
+          const predStart = new Date(predecessor.startDate);
+          const predStartOffset = Math.round(
+            (Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate()) - Date.UTC(
+              globalActiveDrag.monthStart.getUTCFullYear(),
+              globalActiveDrag.monthStart.getUTCMonth(),
+              globalActiveDrag.monthStart.getUTCDate()
+            )) / (24 * 60 * 60 * 1e3)
+          );
+          const predStartLeft = Math.round(predStartOffset * globalActiveDrag.dayWidth);
+          minAllowedLeft = Math.max(minAllowedLeft, predStartLeft);
+        }
+        newLeft = Math.max(minAllowedLeft, newLeft);
+      }
+    }
+    if ((mode === "move" || mode === "resize-right") && !globalActiveDrag.disableConstraints && globalActiveDrag.cascadeChain.length > 0 && globalActiveDrag.onCascadeProgress) {
+      const deltaDays = mode === "resize-right" ? Math.round((newWidth - globalActiveDrag.initialWidth) / globalActiveDrag.dayWidth) : Math.round((newLeft - globalActiveDrag.initialLeft) / globalActiveDrag.dayWidth);
+      const overrides = /* @__PURE__ */ new Map();
+      for (const chainTask of globalActiveDrag.cascadeChain) {
+        const chainStart = new Date(chainTask.startDate);
+        const chainEnd = new Date(chainTask.endDate);
+        const chainStartOffset = Math.round(
+          (Date.UTC(chainStart.getUTCFullYear(), chainStart.getUTCMonth(), chainStart.getUTCDate()) - Date.UTC(
+            globalActiveDrag.monthStart.getUTCFullYear(),
+            globalActiveDrag.monthStart.getUTCMonth(),
+            globalActiveDrag.monthStart.getUTCDate()
+          )) / (24 * 60 * 60 * 1e3)
+        );
+        const chainDuration = Math.round(
+          (Date.UTC(chainEnd.getUTCFullYear(), chainEnd.getUTCMonth(), chainEnd.getUTCDate()) - Date.UTC(chainStart.getUTCFullYear(), chainStart.getUTCMonth(), chainStart.getUTCDate())) / (24 * 60 * 60 * 1e3)
+        );
+        const chainLeft = Math.round((chainStartOffset + deltaDays) * globalActiveDrag.dayWidth);
+        const chainWidth = Math.round((chainDuration + 1) * globalActiveDrag.dayWidth);
+        overrides.set(chainTask.id, { left: chainLeft, width: chainWidth });
+      }
+      globalActiveDrag.onCascadeProgress(overrides);
+    }
     globalActiveDrag.currentLeft = newLeft;
     globalActiveDrag.currentWidth = newWidth;
     onProgress(newLeft, newWidth);
@@ -392,7 +636,13 @@ var useTaskDrag = (options) => {
     dayWidth,
     onDragEnd,
     onDragStateChange,
-    edgeZoneWidth = 12
+    edgeZoneWidth = 12,
+    allTasks = [],
+    rowIndex,
+    enableAutoSchedule = false,
+    disableConstraints = false,
+    onCascadeProgress,
+    onCascade
   } = options;
   const isOwnerRef = useRef(false);
   const [isDragging, setIsDragging] = useState(false);
@@ -462,14 +712,60 @@ var useTaskDrag = (options) => {
         width: finalWidth
       });
     }
-    if (onDragEnd && wasOwner) {
-      onDragEnd({
-        id: taskId,
-        startDate: newStartDate,
-        endDate: newEndDate
-      });
+    if (wasOwner) {
+      if (!disableConstraints && onCascade && allTasks.length > 0) {
+        const chain = getSuccessorChain(taskId, allTasks);
+        if (chain.length > 0) {
+          const origEndMs = Date.UTC(
+            initialEndDate.getUTCFullYear(),
+            initialEndDate.getUTCMonth(),
+            initialEndDate.getUTCDate()
+          );
+          const newEndMs = Date.UTC(
+            newEndDate.getUTCFullYear(),
+            newEndDate.getUTCMonth(),
+            newEndDate.getUTCDate()
+          );
+          const deltaDays = Math.round((newEndMs - origEndMs) / (24 * 60 * 60 * 1e3));
+          const draggedTaskData = allTasks.find((t) => t.id === taskId);
+          const cascadedTasks = [
+            {
+              ...draggedTaskData ?? { id: taskId, name: "", startDate: "", endDate: "" },
+              startDate: newStartDate.toISOString(),
+              endDate: newEndDate.toISOString(),
+              ...draggedTaskData?.dependencies && {
+                dependencies: recalculateIncomingLags(draggedTaskData, newStartDate, allTasks)
+              }
+            },
+            ...chain.map((chainTask) => {
+              const origStart = new Date(chainTask.startDate);
+              const origEnd = new Date(chainTask.endDate);
+              const newStart = new Date(Date.UTC(
+                origStart.getUTCFullYear(),
+                origStart.getUTCMonth(),
+                origStart.getUTCDate() + deltaDays
+              ));
+              const newEnd = new Date(Date.UTC(
+                origEnd.getUTCFullYear(),
+                origEnd.getUTCMonth(),
+                origEnd.getUTCDate() + deltaDays
+              ));
+              return { ...chainTask, startDate: newStart.toISOString(), endDate: newEnd.toISOString() };
+            })
+          ];
+          onCascade(cascadedTasks);
+          return;
+        }
+      }
+      if (allTasks.length > 0 && onDragEnd) {
+        const currentTaskData = allTasks.find((t) => t.id === taskId);
+        const updatedDependencies = currentTaskData?.dependencies ? recalculateIncomingLags(currentTaskData, newStartDate, allTasks) : void 0;
+        onDragEnd({ id: taskId, startDate: newStartDate, endDate: newEndDate, updatedDependencies });
+      } else if (onDragEnd) {
+        onDragEnd({ id: taskId, startDate: newStartDate, endDate: newEndDate });
+      }
     }
-  }, [dayWidth, monthStart, onDragEnd, onDragStateChange, taskId]);
+  }, [dayWidth, monthStart, onDragEnd, onDragStateChange, taskId, disableConstraints, onCascade, allTasks, initialStartDate, initialEndDate]);
   const handleCancel = useCallback(() => {
     isOwnerRef.current = false;
     setIsDragging(false);
@@ -536,9 +832,13 @@ var useTaskDrag = (options) => {
       monthStart,
       onProgress: handleProgress,
       onComplete: handleComplete,
-      onCancel: handleCancel
+      onCancel: handleCancel,
+      allTasks,
+      disableConstraints,
+      cascadeChain: (mode === "move" || mode === "resize-right") && !disableConstraints ? getSuccessorChain(taskId, allTasks) : [],
+      onCascadeProgress
     };
-  }, [edgeZoneWidth, currentLeft, currentWidth, dayWidth, monthStart, taskId, onDragStateChange, handleProgress, handleComplete, handleCancel]);
+  }, [edgeZoneWidth, currentLeft, currentWidth, dayWidth, monthStart, taskId, onDragStateChange, handleProgress, handleComplete, handleCancel, allTasks, disableConstraints, onCascadeProgress, onCascade]);
   const getCursorStyle = useCallback(() => {
     if (isDragging) {
       return "grabbing";
@@ -563,10 +863,10 @@ var useTaskDrag = (options) => {
 // src/components/TaskRow/TaskRow.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var arePropsEqual = (prevProps, nextProps) => {
-  return prevProps.task.id === nextProps.task.id && prevProps.task.name === nextProps.task.name && prevProps.task.startDate === nextProps.task.startDate && prevProps.task.endDate === nextProps.task.endDate && prevProps.task.color === nextProps.task.color && prevProps.monthStart.getTime() === nextProps.monthStart.getTime() && prevProps.dayWidth === nextProps.dayWidth && prevProps.rowHeight === nextProps.rowHeight;
+  return prevProps.task.id === nextProps.task.id && prevProps.task.name === nextProps.task.name && prevProps.task.startDate === nextProps.task.startDate && prevProps.task.endDate === nextProps.task.endDate && prevProps.task.color === nextProps.task.color && prevProps.task.progress === nextProps.task.progress && prevProps.task.accepted === nextProps.task.accepted && prevProps.monthStart.getTime() === nextProps.monthStart.getTime() && prevProps.dayWidth === nextProps.dayWidth && prevProps.rowHeight === nextProps.rowHeight && prevProps.overridePosition?.left === nextProps.overridePosition?.left && prevProps.overridePosition?.width === nextProps.overridePosition?.width && prevProps.allTasks === nextProps.allTasks && prevProps.disableConstraints === nextProps.disableConstraints;
 };
 var TaskRow = React2.memo(
-  ({ task, monthStart, dayWidth, rowHeight, onChange, onDragStateChange }) => {
+  ({ task, monthStart, dayWidth, rowHeight, onChange, onDragStateChange, rowIndex, allTasks, enableAutoSchedule, disableConstraints, overridePosition, onCascadeProgress, onCascade }) => {
     const taskStartDate = useMemo2(() => parseUTCDate(task.startDate), [task.startDate]);
     const taskEndDate = useMemo2(() => parseUTCDate(task.endDate), [task.endDate]);
     const { left, width } = useMemo2(
@@ -574,11 +874,22 @@ var TaskRow = React2.memo(
       [taskStartDate, taskEndDate, monthStart, dayWidth]
     );
     const barColor = task.color || "var(--gantt-task-bar-default-color)";
+    const progressWidth = useMemo2(() => {
+      if (task.progress === void 0 || task.progress <= 0) return 0;
+      return Math.min(100, Math.max(0, Math.round(task.progress)));
+    }, [task.progress]);
+    const progressColor = useMemo2(() => {
+      if (progressWidth === 100) {
+        return task.accepted ? "var(--gantt-progress-accepted, #22c55e)" : "var(--gantt-progress-completed, #fbbf24)";
+      }
+      return task.color ? `color-mix(in srgb, ${task.color} 40%, black)` : "var(--gantt-progress-color, rgba(0, 0, 0, 0.2))";
+    }, [progressWidth, task.accepted, task.color]);
     const handleDragEnd = (result) => {
       const updatedTask = {
         ...task,
         startDate: result.startDate.toISOString(),
-        endDate: result.endDate.toISOString()
+        endDate: result.endDate.toISOString(),
+        ...result.updatedDependencies !== void 0 && { dependencies: result.updatedDependencies }
       };
       onChange?.(updatedTask);
     };
@@ -596,10 +907,16 @@ var TaskRow = React2.memo(
       dayWidth,
       onDragEnd: handleDragEnd,
       onDragStateChange,
-      edgeZoneWidth: 20
+      edgeZoneWidth: 20,
+      allTasks,
+      rowIndex,
+      enableAutoSchedule,
+      disableConstraints,
+      onCascadeProgress,
+      onCascade
     });
-    const displayLeft = isDragging ? currentLeft : left;
-    const displayWidth = isDragging ? currentWidth : width;
+    const displayLeft = overridePosition?.left ?? (isDragging ? currentLeft : left);
+    const displayWidth = overridePosition?.width ?? (isDragging ? currentWidth : width);
     const currentStartDate = isDragging ? pixelsToDate(displayLeft, monthStart, dayWidth) : taskStartDate;
     const currentEndDate = isDragging ? pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
     const startDateLabel = formatDateLabel(currentStartDate);
@@ -607,16 +924,6 @@ var TaskRow = React2.memo(
     const durationDays = Math.round(
       (currentEndDate.getTime() - currentStartDate.getTime()) / (1e3 * 60 * 60 * 24)
     ) + 1;
-    const [isNameOverflow, setIsNameOverflow] = useState2(false);
-    const taskNameRef = useRef2(null);
-    useEffect2(() => {
-      const nameEl = taskNameRef.current;
-      if (nameEl) {
-        const reservedWidth = 120;
-        const availableWidth = displayWidth - reservedWidth;
-        setIsNameOverflow(nameEl.scrollWidth > availableWidth);
-      }
-    }, [displayWidth, task.name]);
     return /* @__PURE__ */ jsx2(
       "div",
       {
@@ -638,22 +945,21 @@ var TaskRow = React2.memo(
               },
               onMouseDown: dragHandleProps.onMouseDown,
               children: [
+                progressWidth > 0 && /* @__PURE__ */ jsx2(
+                  "div",
+                  {
+                    className: "gantt-tr-progressBar",
+                    style: {
+                      width: `${progressWidth}%`,
+                      backgroundColor: progressColor
+                    }
+                  }
+                ),
                 /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
                 /* @__PURE__ */ jsxs2("span", { className: "gantt-tr-taskDuration", children: [
                   durationDays,
                   " \u0434"
                 ] }),
-                /* @__PURE__ */ jsxs2(
-                  "span",
-                  {
-                    ref: taskNameRef,
-                    className: `gantt-tr-taskName ${isNameOverflow ? "gantt-tr-taskNameHidden" : ""}`,
-                    children: [
-                      "\u2014 ",
-                      task.name
-                    ]
-                  }
-                ),
                 /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
               ]
             }
@@ -679,7 +985,7 @@ var TaskRow = React2.memo(
               style: {
                 left: `${displayLeft + displayWidth}px`
               },
-              children: isNameOverflow && /* @__PURE__ */ jsx2("span", { className: "gantt-tr-externalTaskName", children: task.name })
+              children: /* @__PURE__ */ jsx2("span", { className: "gantt-tr-externalTaskName", children: task.name })
             }
           )
         ] })
@@ -825,39 +1131,183 @@ var DragGuideLines = ({
 };
 var DragGuideLines_default = DragGuideLines;
 
-// src/components/GanttChart/GanttChart.tsx
+// src/components/DependencyLines/DependencyLines.tsx
+import React5, { useMemo as useMemo5 } from "react";
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var DependencyLines = React5.memo(({
+  tasks,
+  monthStart,
+  dayWidth,
+  rowHeight,
+  gridWidth,
+  dragOverrides
+}) => {
+  const { taskPositions, taskIndices } = useMemo5(() => {
+    const positions = /* @__PURE__ */ new Map();
+    const indices = /* @__PURE__ */ new Map();
+    tasks.forEach((task, index) => {
+      const startDate = new Date(task.startDate);
+      const endDate = new Date(task.endDate);
+      const computed = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
+      const override = dragOverrides?.get(task.id);
+      const resolvedLeft = override?.left ?? computed.left;
+      const resolvedWidth = override?.width ?? computed.width;
+      indices.set(task.id, index);
+      positions.set(task.id, {
+        left: resolvedLeft + 10,
+        right: resolvedLeft + resolvedWidth,
+        rowTop: index * rowHeight
+      });
+    });
+    return { taskPositions: positions, taskIndices: indices };
+  }, [tasks, monthStart, dayWidth, rowHeight, dragOverrides]);
+  const cycleInfo = useMemo5(() => {
+    const result = detectCycles(tasks);
+    const cycleTaskIds = new Set(result.cyclePath || []);
+    return cycleTaskIds;
+  }, [tasks]);
+  const lines = useMemo5(() => {
+    const edges = getAllDependencyEdges(tasks);
+    const lines2 = [];
+    for (const edge of edges) {
+      const predecessor = taskPositions.get(edge.predecessorId);
+      const successor = taskPositions.get(edge.successorId);
+      const predecessorIndex = taskIndices.get(edge.predecessorId);
+      const successorIndex = taskIndices.get(edge.successorId);
+      if (!predecessor || !successor || predecessorIndex === void 0 || successorIndex === void 0) {
+        continue;
+      }
+      const reverseOrder = predecessorIndex > successorIndex;
+      let fromY;
+      let toY;
+      if (reverseOrder) {
+        fromY = predecessor.rowTop + 10;
+        toY = successor.rowTop + rowHeight - 6;
+      } else {
+        fromY = predecessor.rowTop + rowHeight - 10;
+        toY = successor.rowTop + 6;
+      }
+      const from = { x: predecessor.right, y: fromY };
+      const to = { x: successor.left, y: toY };
+      const path = calculateOrthogonalPath(from, to);
+      const hasCycle = cycleInfo.has(edge.predecessorId) || cycleInfo.has(edge.successorId);
+      lines2.push({
+        id: `${edge.predecessorId}-${edge.successorId}`,
+        path,
+        hasCycle
+      });
+    }
+    return lines2;
+  }, [tasks, taskPositions, taskIndices, cycleInfo]);
+  return /* @__PURE__ */ jsxs5(
+    "svg",
+    {
+      className: "gantt-dependencies-svg",
+      width: gridWidth,
+      height: tasks.length * rowHeight,
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsxs5("defs", { children: [
+          /* @__PURE__ */ jsx6(
+            "marker",
+            {
+              id: "arrowhead",
+              markerWidth: "8",
+              markerHeight: "6",
+              markerUnits: "userSpaceOnUse",
+              refX: "7",
+              refY: "3",
+              orient: "auto",
+              children: /* @__PURE__ */ jsx6(
+                "polygon",
+                {
+                  points: "0 0, 8 3, 0 6",
+                  fill: "var(--gantt-dependency-line-color, #666666)"
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx6(
+            "marker",
+            {
+              id: "arrowhead-cycle",
+              markerWidth: "8",
+              markerHeight: "6",
+              markerUnits: "userSpaceOnUse",
+              refX: "7",
+              refY: "3",
+              orient: "auto",
+              children: /* @__PURE__ */ jsx6(
+                "polygon",
+                {
+                  points: "0 0, 8 3, 0 6",
+                  fill: "var(--gantt-dependency-cycle-color, #ef4444)"
+                }
+              )
+            }
+          )
+        ] }),
+        lines.map(({ id, path, hasCycle }) => /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: path,
+            className: hasCycle ? "gantt-dependency-path gantt-dependency-cycle" : "gantt-dependency-path",
+            markerEnd: hasCycle ? "url(#arrowhead-cycle)" : "url(#arrowhead)"
+          },
+          id
+        ))
+      ]
+    }
+  );
+});
+DependencyLines.displayName = "DependencyLines";
+var DependencyLines_default = DependencyLines;
+
+// src/components/GanttChart/GanttChart.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 var GanttChart = ({
   tasks,
   dayWidth = 40,
   rowHeight = 40,
   headerHeight = 40,
   containerHeight = 600,
-  onChange
+  onChange,
+  onValidateDependencies,
+  enableAutoSchedule,
+  disableConstraints,
+  onCascade
 }) => {
-  const scrollContainerRef = useRef3(null);
-  const dateRange = useMemo5(() => getMultiMonthDays(tasks), [tasks]);
-  const gridWidth = useMemo5(
+  const scrollContainerRef = useRef2(null);
+  const dateRange = useMemo6(() => getMultiMonthDays(tasks), [tasks]);
+  const [validationResult, setValidationResult] = useState2(null);
+  const [cascadeOverrides, setCascadeOverrides] = useState2(/* @__PURE__ */ new Map());
+  const gridWidth = useMemo6(
     () => Math.round(dateRange.length * dayWidth),
     [dateRange.length, dayWidth]
   );
-  const totalGridHeight = useMemo5(
+  const totalGridHeight = useMemo6(
     () => tasks.length * rowHeight,
     [tasks.length, rowHeight]
   );
-  const monthStart = useMemo5(() => {
+  const monthStart = useMemo6(() => {
     if (dateRange.length === 0) {
       return new Date(Date.UTC((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth(), 1));
     }
     const firstDay = dateRange[0];
     return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
   }, [dateRange]);
-  const todayInRange = useMemo5(() => {
+  const todayInRange = useMemo6(() => {
     const now = /* @__PURE__ */ new Date();
     const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
     return dateRange.some((day) => day.getTime() === today.getTime());
   }, [dateRange]);
-  const [dragGuideLines, setDragGuideLines] = useState3(null);
+  const [dragGuideLines, setDragGuideLines] = useState2(null);
+  const [draggedTaskOverride, setDraggedTaskOverride] = useState2(null);
+  useEffect2(() => {
+    const result = validateDependencies(tasks);
+    setValidationResult(result);
+    onValidateDependencies?.(result);
+  }, [tasks, onValidateDependencies]);
   const handleTaskChange = useCallback2((updatedTask) => {
     onChange?.(
       (currentTasks) => currentTasks.map(
@@ -865,14 +1315,27 @@ var GanttChart = ({
       )
     );
   }, [onChange]);
-  const handleDragStateChange = useCallback2((state) => {
-    if (state.isDragging) {
-      setDragGuideLines(state);
-    } else {
-      setDragGuideLines(null);
+  const dependencyOverrides = useMemo6(() => {
+    const map = new Map(cascadeOverrides);
+    if (draggedTaskOverride) {
+      map.set(draggedTaskOverride.taskId, {
+        left: draggedTaskOverride.left,
+        width: draggedTaskOverride.width
+      });
     }
+    return map;
+  }, [cascadeOverrides, draggedTaskOverride]);
+  const handleCascadeProgress = useCallback2((overrides) => {
+    setCascadeOverrides(new Map(overrides));
   }, []);
-  const panStateRef = useRef3(null);
+  const handleCascade = useCallback2((cascadedTasks) => {
+    onChange?.((currentTasks) => {
+      const cascadeMap = new Map(cascadedTasks.map((t) => [t.id, t]));
+      return currentTasks.map((t) => cascadeMap.get(t.id) ?? t);
+    });
+    onCascade?.(cascadedTasks);
+  }, [onChange, onCascade]);
+  const panStateRef = useRef2(null);
   const handlePanStart = useCallback2((e) => {
     if (e.button !== 0) return;
     const target = e.target;
@@ -889,7 +1352,7 @@ var GanttChart = ({
     container.style.cursor = "grabbing";
     e.preventDefault();
   }, []);
-  useEffect3(() => {
+  useEffect2(() => {
     const handlePanMove = (e) => {
       const pan = panStateRef.current;
       if (!pan?.active) return;
@@ -911,7 +1374,7 @@ var GanttChart = ({
       window.removeEventListener("mouseup", handlePanEnd);
     };
   }, []);
-  return /* @__PURE__ */ jsx6("div", { className: "gantt-container", children: /* @__PURE__ */ jsxs5(
+  return /* @__PURE__ */ jsx7("div", { className: "gantt-container", children: /* @__PURE__ */ jsxs6(
     "div",
     {
       ref: scrollContainerRef,
@@ -919,7 +1382,7 @@ var GanttChart = ({
       style: { height: `${containerHeight}px`, cursor: "grab" },
       onMouseDown: handlePanStart,
       children: [
-        /* @__PURE__ */ jsx6("div", { className: "gantt-stickyHeader", style: { width: `${gridWidth}px` }, children: /* @__PURE__ */ jsx6(
+        /* @__PURE__ */ jsx7("div", { className: "gantt-stickyHeader", style: { width: `${gridWidth}px` }, children: /* @__PURE__ */ jsx7(
           TimeScaleHeader_default,
           {
             days: dateRange,
@@ -927,7 +1390,7 @@ var GanttChart = ({
             headerHeight
           }
         ) }),
-        /* @__PURE__ */ jsxs5(
+        /* @__PURE__ */ jsxs6(
           "div",
           {
             className: "gantt-taskArea",
@@ -936,7 +1399,7 @@ var GanttChart = ({
               width: `${gridWidth}px`
             },
             children: [
-              /* @__PURE__ */ jsx6(
+              /* @__PURE__ */ jsx7(
                 GridBackground_default,
                 {
                   dateRange,
@@ -944,8 +1407,19 @@ var GanttChart = ({
                   totalHeight: totalGridHeight
                 }
               ),
-              todayInRange && /* @__PURE__ */ jsx6(TodayIndicator_default, { monthStart, dayWidth }),
-              dragGuideLines && /* @__PURE__ */ jsx6(
+              todayInRange && /* @__PURE__ */ jsx7(TodayIndicator_default, { monthStart, dayWidth }),
+              /* @__PURE__ */ jsx7(
+                DependencyLines_default,
+                {
+                  tasks,
+                  monthStart,
+                  dayWidth,
+                  rowHeight,
+                  gridWidth,
+                  dragOverrides: dependencyOverrides
+                }
+              ),
+              dragGuideLines && /* @__PURE__ */ jsx7(
                 DragGuideLines_default,
                 {
                   isDragging: dragGuideLines.isDragging,
@@ -955,7 +1429,7 @@ var GanttChart = ({
                   totalHeight: totalGridHeight
                 }
               ),
-              tasks.map((task) => /* @__PURE__ */ jsx6(
+              tasks.map((task, index) => /* @__PURE__ */ jsx7(
                 TaskRow_default,
                 {
                   task,
@@ -963,7 +1437,22 @@ var GanttChart = ({
                   dayWidth,
                   rowHeight,
                   onChange: handleTaskChange,
-                  onDragStateChange: handleDragStateChange
+                  onDragStateChange: (state) => {
+                    if (state.isDragging) {
+                      setDragGuideLines(state);
+                      setDraggedTaskOverride({ taskId: task.id, left: state.left, width: state.width });
+                    } else {
+                      setDragGuideLines(null);
+                      setDraggedTaskOverride(null);
+                    }
+                  },
+                  rowIndex: index,
+                  allTasks: tasks,
+                  enableAutoSchedule: enableAutoSchedule ?? false,
+                  disableConstraints: disableConstraints ?? false,
+                  overridePosition: cascadeOverrides.get(task.id),
+                  onCascadeProgress: handleCascadeProgress,
+                  onCascade: handleCascade
                 },
                 task.id
               ))
@@ -981,21 +1470,29 @@ export {
   TaskRow_default as TaskRow,
   TimeScaleHeader_default as TimeScaleHeader,
   TodayIndicator_default as TodayIndicator,
+  buildAdjacencyList,
+  calculateBezierPath,
   calculateGridLines,
   calculateGridWidth,
+  calculateOrthogonalPath,
+  calculateSuccessorDate,
   calculateTaskBar,
   calculateWeekendBlocks,
+  detectCycles,
   detectEdgeZone,
   formatDateLabel,
+  getAllDependencyEdges,
   getCursorForPosition,
   getDayOffset,
   getMonthDays,
   getMonthSpans,
   getMultiMonthDays,
+  getSuccessorChain,
   isToday,
   isWeekend,
   parseUTCDate,
   pixelsToDate,
-  useTaskDrag
+  useTaskDrag,
+  validateDependencies
 };
 //# sourceMappingURL=index.mjs.map