gantt-lib 0.64.0 → 0.70.0

package/dist/index.js

@@ -530,6 +530,8 @@ __export(index_exports, {
   calculateDependencyPath: () => calculateDependencyPath,
   calculateGridLines: () => calculateGridLines,
   calculateGridWidth: () => calculateGridWidth,
+  calculateMilestoneConnectionBounds: () => calculateMilestoneConnectionBounds,
+  calculateMilestoneGeometry: () => calculateMilestoneGeometry,
   calculateMonthGridLines: () => calculateMonthGridLines,
   calculateOrthogonalPath: () => calculateOrthogonalPath,
   calculateSuccessorDate: () => calculateSuccessorDate,
@@ -581,6 +583,7 @@ __export(index_exports, {
   nameContains: () => nameContains,
   normalizeDependencyLag: () => normalizeDependencyLag,
   normalizeHierarchyTasks: () => normalizeHierarchyTasks,
+  normalizePredecessorDates: () => normalizePredecessorDates,
   normalizeTaskDates: () => normalizeTaskDates,
   normalizeUTCDate: () => normalizeUTCDate,
   not: () => not,
@@ -596,6 +599,7 @@ __export(index_exports, {
   removeDependenciesBetweenTasks: () => removeDependenciesBetweenTasks,
   resizeTaskWithCascade: () => resizeTaskWithCascade,
   resolveDateRangeFromPixels: () => resolveDateRangeFromPixels,
+  resolveTaskHorizontalGeometry: () => resolveTaskHorizontalGeometry,
   shiftBusinessDayOffset: () => shiftBusinessDayOffset,
   subtractBusinessDays: () => subtractBusinessDays2,
   universalCascade: () => universalCascade,
@@ -614,6 +618,12 @@ init_dateMath();
 
 // src/core/scheduling/dependencies.ts
 init_dateMath();
+function normalizePredecessorDates(predecessor, parseDateFn) {
+  const predStart = parseDateFn(predecessor.startDate);
+  const isMilestone = predecessor.type === "milestone";
+  const predEnd = isMilestone ? new Date(predStart.getTime() - DAY_MS) : parseDateFn(predecessor.endDate);
+  return { predStart, predEnd };
+}
 function getDependencyLag(dep) {
   return Number.isFinite(dep.lag) ? dep.lag : 0;
 }
@@ -889,8 +899,7 @@ function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks,
     if (!predecessor) {
       continue;
     }
-    const predecessorStart = parseDateOnly(predecessor.startDate);
-    const predecessorEnd = parseDateOnly(predecessor.endDate);
+    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
     const predecessorDuration = getTaskDuration(
       predecessorStart,
       predecessorEnd,
@@ -926,8 +935,10 @@ function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, busin
     if (!predecessor) {
       return { ...dep, lag: getDependencyLag(dep) };
     }
-    const predecessorStart = new Date(predecessor.startDate);
-    const predecessorEnd = new Date(predecessor.endDate);
+    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(
+      predecessor,
+      (d) => new Date(d instanceof Date ? d.getTime() : `${String(d).split("T")[0]}T00:00:00.000Z`)
+    );
     const nextLag = computeLagFromDates(
       dep.type,
       predecessorStart,
@@ -942,6 +953,12 @@ function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, busin
 }
 
 // src/core/scheduling/cascade.ts
+function parseCascadeDateInput(date) {
+  if (date instanceof Date) {
+    return normalizeUTCDate(date);
+  }
+  return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
+}
 function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
   const successorMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
@@ -1020,7 +1037,21 @@ function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascad
         const origStart = new Date(orig.startDate);
         const origEnd = new Date(orig.endDate);
         const duration = getTaskDuration(origStart, origEnd);
-        const constraintDate = calculateSuccessorDate(predStart, predEnd, dep.type, getDependencyLag(dep));
+        const currentTask = taskById.get(currentId);
+        const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
+          {
+            startDate: predStart,
+            endDate: predEnd,
+            type: currentTask.type
+          },
+          parseCascadeDateInput
+        );
+        const constraintDate = calculateSuccessorDate(
+          normalizedPredStart,
+          normalizedPredEnd,
+          dep.type,
+          getDependencyLag(dep)
+        );
         let newSuccStart;
         let newSuccEnd;
         if (dep.type === "FS" || dep.type === "SS") {
@@ -1175,9 +1206,17 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
       if (!dep) continue;
       const origStart = new Date(task.startDate);
       const origEnd = new Date(task.endDate);
+      const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
+        {
+          startDate: currStart,
+          endDate: currEnd,
+          type: currentOriginal.type
+        },
+        parseCascadeDateInput
+      );
       const constraintDate = calculateSuccessorDate(
-        currStart,
-        currEnd,
+        normalizedPredStart,
+        normalizedPredEnd,
         dep.type,
         getDependencyLag(dep),
         businessDays,
@@ -1394,8 +1433,7 @@ function recalculateTaskFromDependencies(taskId, snapshot, options) {
   for (const dep of task.dependencies) {
     const predecessor = snapshot.find((t) => t.id === dep.taskId);
     if (!predecessor) continue;
-    const predStart = parseDateOnly(predecessor.startDate);
-    const predEnd = parseDateOnly(predecessor.endDate);
+    const { predStart, predEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
     const constraintDate = calculateSuccessorDate(
       predStart,
       predEnd,
@@ -1511,8 +1549,7 @@ function recalculateProjectSchedule(snapshot, options) {
         if (!predecessor) {
           continue;
         }
-        const predecessorStart = parseDateOnly(predecessor.startDate);
-        const predecessorEnd = parseDateOnly(predecessor.endDate);
+        const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
         const constraintDate = calculateSuccessorDate(
           predecessorStart,
           predecessorEnd,
@@ -1931,6 +1968,45 @@ var calculateTaskBar = (taskStartDate, taskEndDate, monthStart, dayWidth) => {
   const width = Math.round((duration + 1) * dayWidth);
   return { left, width };
 };
+var calculateMilestoneGeometry = (taskDate, monthStart, dayWidth, size = 14) => {
+  const { left, width } = calculateTaskBar(taskDate, taskDate, monthStart, dayWidth);
+  const centerX = Math.round(left + width / 2);
+  const halfSize = Math.round(size / 2);
+  return {
+    centerX,
+    left: centerX - halfSize,
+    right: centerX + halfSize,
+    size
+  };
+};
+var calculateMilestoneConnectionBounds = (dayLeft, dayWidth, size = 14) => {
+  const halfDiagonal = Math.round(size / Math.SQRT2);
+  const visualNudge = 2;
+  return {
+    left: dayLeft + halfDiagonal + visualNudge,
+    right: dayLeft + dayWidth - halfDiagonal - visualNudge
+  };
+};
+var resolveTaskHorizontalGeometry = (task, monthStart, dayWidth, override) => {
+  const startDate = new Date(task.startDate);
+  const endDate = new Date(task.endDate);
+  if (task.type === "milestone") {
+    const size = 14;
+    if (override) {
+      return calculateMilestoneConnectionBounds(override.left, dayWidth, size);
+    }
+    const bar2 = calculateTaskBar(startDate, startDate, monthStart, dayWidth);
+    return calculateMilestoneConnectionBounds(bar2.left, dayWidth, size);
+  }
+  if (override) {
+    return {
+      left: override.left,
+      right: override.left + override.width
+    };
+  }
+  const bar = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
+  return { left: bar.left, right: bar.left + bar.width };
+};
 var pixelsToDate = (pixels, monthStart, dayWidth) => {
   const days = Math.round(pixels / dayWidth);
   return new Date(Date.UTC(
@@ -2034,6 +2110,9 @@ var calculateDependencyPath = (from, to, arrivesFromRight) => {
   if (fy === ty) {
     return `M ${fx} ${fy} H ${tx}`;
   }
+  if (fx === tx) {
+    return `M ${fx} ${fy} V ${ty}`;
+  }
   const C = 2;
   const goingDown = ty > fy;
   const dirY = goingDown ? 1 : -1;
@@ -2141,6 +2220,37 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
   return actualProgress < expectedProgress;
 };
 
+// src/utils/taskType.ts
+init_dateUtils();
+var TASK_TYPE_DEFAULT = "task";
+function getTaskType(task) {
+  return task.type ?? TASK_TYPE_DEFAULT;
+}
+function isMilestoneTask(task) {
+  return getTaskType(task) === "milestone";
+}
+function normalizeMilestoneStartDate(startDateInput) {
+  const parsedStartDate = parseUTCDate(startDateInput);
+  if (startDateInput instanceof Date) {
+    return new Date(Date.UTC(
+      parsedStartDate.getUTCFullYear(),
+      parsedStartDate.getUTCMonth(),
+      parsedStartDate.getUTCDate()
+    ));
+  }
+  return parsedStartDate.toISOString().split("T")[0];
+}
+function normalizeTaskDatesForType(task) {
+  if (!isMilestoneTask(task)) {
+    return task;
+  }
+  const startDate = normalizeMilestoneStartDate(task.startDate);
+  return {
+    ...task,
+    endDate: startDate
+  };
+}
+
 // src/hooks/useTaskDrag.ts
 var import_react2 = require("react");
 
@@ -2159,6 +2269,17 @@ function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, tas
     monthStart.getUTCMonth(),
     monthStart.getUTCDate() + rawEndOffset
   ));
+  const isMilestone = task.type === "milestone";
+  if (isMilestone) {
+    const anchorDate = mode === "resize-right" ? rawEndDate : rawStartDate;
+    if (businessDays && weekendPredicate) {
+      const originalAnchor = mode === "resize-right" ? new Date(task.endDate) : new Date(task.startDate);
+      const snapDirection2 = anchorDate.getTime() >= originalAnchor.getTime() ? 1 : -1;
+      const alignedDate = alignToWorkingDay(anchorDate, snapDirection2, weekendPredicate);
+      return { start: alignedDate, end: alignedDate };
+    }
+    return { start: anchorDate, end: anchorDate };
+  }
   if (!(businessDays && weekendPredicate)) {
     return { start: rawStartDate, end: rawEndDate };
   }
@@ -2249,8 +2370,10 @@ function handleGlobalMouseMove(e) {
     const activeDrag = globalActiveDrag;
     const { startX, initialLeft, initialWidth, mode, dayWidth, onProgress, allTasks } = activeDrag;
     const deltaX = e.clientX - startX;
+    const draggedTask = allTasks.find((t) => t.id === activeDrag.taskId);
+    const effectiveWidth = draggedTask && isMilestoneTask(draggedTask) ? dayWidth : initialWidth;
     let newLeft = initialLeft;
-    let newWidth = initialWidth;
+    let newWidth = effectiveWidth;
     switch (mode) {
       case "move":
         newLeft = snapToGrid(initialLeft + deltaX, dayWidth);
@@ -2266,7 +2389,6 @@ function handleGlobalMouseMove(e) {
         newWidth = Math.max(dayWidth, snappedWidth);
         break;
     }
-    const draggedTask = allTasks.find((t) => t.id === activeDrag.taskId);
     if (activeDrag.businessDays && activeDrag.weekendPredicate && draggedTask) {
       const previewRange = clampDateRangeForIncomingFS(
         draggedTask,
@@ -2308,6 +2430,9 @@ function handleGlobalMouseMove(e) {
       newLeft = Math.round(alignedStartDay * dayWidth);
       newWidth = Math.round((alignedEndDay - alignedStartDay + 1) * dayWidth);
     }
+    if (draggedTask && isMilestoneTask(draggedTask)) {
+      newWidth = dayWidth;
+    }
     if (!activeDrag.disableConstraints && activeDrag.onCascadeProgress) {
       const { dayWidth: dayWidth2, monthStart: mStart, taskId: dragId } = activeDrag;
       const originalDraggedTask = draggedTask ?? allTasks.find((t) => t.id === dragId);
@@ -2344,7 +2469,8 @@ function handleGlobalMouseMove(e) {
         };
       })();
       const previewStartDate = previewRange.start;
-      const previewEndDate = previewRange.end;
+      const isMilestone = originalDraggedTask ? isMilestoneTask(originalDraggedTask) : false;
+      const previewEndDate = isMilestone ? previewRange.start : previewRange.end;
       const movedTaskData = originalDraggedTask ?? { id: dragId, name: "", startDate: "", endDate: "" };
       const cascadeResult = universalCascade(
         { ...movedTaskData, startDate: previewStartDate.toISOString(), endDate: previewEndDate.toISOString() },
@@ -2434,6 +2560,9 @@ var useTaskDrag = (options) => {
     businessDays = true,
     weekendPredicate
   } = options;
+  const rawHookTask = allTasks.find((t) => t.id === taskId);
+  const hookTask = rawHookTask ? normalizeTaskDatesForType(rawHookTask) : void 0;
+  const hookTaskIsMilestone = hookTask ? isMilestoneTask(hookTask) : false;
   const isOwnerRef = (0, import_react2.useRef)(false);
   const effectiveLocked = locked || disableTaskDrag;
   const [isDragging, setIsDragging] = (0, import_react2.useState)(false);
@@ -2455,11 +2584,11 @@ var useTaskDrag = (options) => {
       return Math.round((ms1 - ms2) / (1e3 * 60 * 60 * 24));
     };
     const startOffset = getUTCDayDifference2(initialStartDate, monthStart);
-    const duration = getUTCDayDifference2(initialEndDate, initialStartDate);
+    const duration = hookTaskIsMilestone ? 0 : getUTCDayDifference2(initialEndDate, initialStartDate);
     const left = Math.round(startOffset * dayWidth);
     const width = Math.round((duration + 1) * dayWidth);
     return { left, width };
-  }, [initialStartDate, initialEndDate, monthStart, dayWidth]);
+  }, [initialStartDate, initialEndDate, monthStart, dayWidth, hookTaskIsMilestone]);
   (0, import_react2.useEffect)(() => {
     if (isOwnerRef.current && globalActiveDrag) return;
     const { left, width } = getInitialPosition();
@@ -2494,7 +2623,8 @@ var useTaskDrag = (options) => {
   const handleComplete = (0, import_react2.useCallback)((finalLeft, finalWidth, finalMode) => {
     const wasOwner = isOwnerRef.current;
     isOwnerRef.current = false;
-    const currentTask = allTasks.find((t) => t.id === taskId);
+    const currentTaskRaw = allTasks.find((t) => t.id === taskId);
+    const currentTask = currentTaskRaw ? normalizeTaskDatesForType(currentTaskRaw) : void 0;
     const finalRange = currentTask ? clampDateRangeForIncomingFS(
       currentTask,
       resolveDateRangeFromPixels(
@@ -2528,7 +2658,7 @@ var useTaskDrag = (options) => {
       };
     })();
     const newStartDate = finalRange.start;
-    const newEndDate = finalRange.end;
+    const newEndDate = currentTask && isMilestoneTask(currentTask) ? finalRange.start : finalRange.end;
     setIsDragging(false);
     setDragMode(null);
     if (onDragStateChange) {
@@ -2540,6 +2670,23 @@ var useTaskDrag = (options) => {
       });
     }
     if (wasOwner) {
+      const startUnchanged = newStartDate.getTime() === Date.UTC(
+        initialStartDate.getUTCFullYear(),
+        initialStartDate.getUTCMonth(),
+        initialStartDate.getUTCDate()
+      );
+      const baselineEndDate = hookTaskIsMilestone ? initialStartDate : initialEndDate;
+      const endUnchanged = newEndDate.getTime() === Date.UTC(
+        baselineEndDate.getUTCFullYear(),
+        baselineEndDate.getUTCMonth(),
+        baselineEndDate.getUTCDate()
+      );
+      if (startUnchanged && endUnchanged) {
+        const { left, width } = getInitialPosition();
+        setCurrentLeft(left);
+        setCurrentWidth(width);
+        return;
+      }
       if (!disableConstraints && onCascade && allTasks.length > 0) {
         const draggedTaskData = currentTask;
         const movedTask = {
@@ -2577,7 +2724,8 @@ var useTaskDrag = (options) => {
     businessDays,
     weekendPredicate,
     initialStartDate,
-    initialEndDate
+    initialEndDate,
+    hookTaskIsMilestone
   ]);
   const handleCancel = (0, import_react2.useCallback)(() => {
     isOwnerRef.current = false;
@@ -2620,6 +2768,9 @@ var useTaskDrag = (options) => {
       if (currentTask2 && isTaskParent(taskId, allTasks)) {
         mode = "move";
       }
+      if (currentTask2 && isMilestoneTask(currentTask2)) {
+        mode = "move";
+      }
     }
     if (!mode) {
       return;
@@ -2705,14 +2856,16 @@ var useTaskDrag = (options) => {
 // src/components/TaskRow/TaskRow.tsx
 var import_jsx_runtime2 = require("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.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 && prevProps.task.locked === nextProps.task.locked && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag;
+  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.type === nextProps.task.type && 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 && prevProps.task.locked === nextProps.task.locked && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag;
 };
 var TaskRow = import_react3.default.memo(
   ({ task, monthStart, dayWidth, rowHeight, onTasksChange, onDragStateChange, rowIndex, allTasks, enableAutoSchedule, disableConstraints, overridePosition, onCascadeProgress, onCascade, divider, highlightExpiredTasks, isFilterMatch = false, businessDays, customDays, isWeekend: isWeekend3, disableTaskDrag = false }) => {
     const defaultParentBarColor = "#782FC4";
     const { divider: taskDivider } = task;
-    const taskStartDate = (0, import_react3.useMemo)(() => parseUTCDate(task.startDate), [task.startDate]);
-    const taskEndDate = (0, import_react3.useMemo)(() => parseUTCDate(task.endDate), [task.endDate]);
+    const normalizedTask = (0, import_react3.useMemo)(() => normalizeTaskDatesForType(task), [task]);
+    const milestone = (0, import_react3.useMemo)(() => isMilestoneTask(normalizedTask), [normalizedTask]);
+    const taskStartDate = (0, import_react3.useMemo)(() => parseUTCDate(normalizedTask.startDate), [normalizedTask.startDate]);
+    const taskEndDate = (0, import_react3.useMemo)(() => parseUTCDate(normalizedTask.endDate), [normalizedTask.endDate]);
     const isParent = (0, import_react3.useMemo)(() => {
       return allTasks ? isTaskParent(task.id, allTasks) : false;
     }, [allTasks, task.id]);
@@ -2721,12 +2874,16 @@ var TaskRow = import_react3.default.memo(
     }, [allTasks, task.id]);
     const isExpired = (0, import_react3.useMemo)(() => {
       if (!highlightExpiredTasks) return false;
-      return isTaskExpired(task);
-    }, [task.startDate, task.endDate, task.progress, highlightExpiredTasks]);
+      return isTaskExpired(normalizedTask);
+    }, [normalizedTask.startDate, normalizedTask.endDate, normalizedTask.progress, highlightExpiredTasks]);
     const { left, width } = (0, import_react3.useMemo)(
       () => calculateTaskBar(taskStartDate, taskEndDate, monthStart, dayWidth),
       [taskStartDate, taskEndDate, monthStart, dayWidth]
     );
+    const milestoneGeometry = (0, import_react3.useMemo)(
+      () => calculateMilestoneGeometry(taskStartDate, monthStart, dayWidth),
+      [taskStartDate, monthStart, dayWidth]
+    );
     const barColor = isExpired ? "var(--gantt-expired-color)" : task.color || "var(--gantt-task-bar-default-color)";
     const progressWidth = (0, import_react3.useMemo)(() => {
       if (task.progress === void 0 || task.progress <= 0) return 0;
@@ -2765,7 +2922,7 @@ var TaskRow = import_react3.default.memo(
     }, [defaultParentBarColor, isExpired, isParent, progressWidth, barColor, progressColor, task.color]);
     const handleDragEnd = (result) => {
       const updatedTask = {
-        ...task,
+        ...normalizedTask,
         startDate: result.startDate.toISOString(),
         endDate: result.endDate.toISOString(),
         ...result.updatedDependencies !== void 0 && { dependencies: result.updatedDependencies }
@@ -2804,8 +2961,20 @@ var TaskRow = import_react3.default.memo(
     });
     const displayLeft = overridePosition?.left ?? (isDragging ? currentLeft : left);
     const displayWidth = overridePosition?.width ?? (isDragging ? currentWidth : width);
+    const displayMilestoneGeometry = (0, import_react3.useMemo)(() => {
+      const centerX = Math.round(displayLeft + dayWidth / 2);
+      const halfSize = Math.round(milestoneGeometry.size / 2);
+      return {
+        centerX,
+        left: centerX - halfSize,
+        right: centerX + halfSize,
+        size: milestoneGeometry.size
+      };
+    }, [displayLeft, dayWidth, milestoneGeometry.size]);
+    const visualLeft = milestone ? displayMilestoneGeometry.left : displayLeft;
+    const visualWidth = milestone ? displayMilestoneGeometry.size : displayWidth;
     const currentStartDate = isDragging ? pixelsToDate(displayLeft, monthStart, dayWidth) : taskStartDate;
-    const currentEndDate = isDragging ? pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
+    const currentEndDate = isDragging ? milestone ? pixelsToDate(displayLeft, monthStart, dayWidth) : pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
     const dateRangeLabel = formatDateRangeLabel(currentStartDate, currentEndDate);
     const durationDays = businessDays ? getBusinessDaysCount(currentStartDate, currentEndDate, weekendPredicate) : Math.round(
       (currentEndDate.getTime() - currentStartDate.getTime()) / (1e3 * 60 * 60 * 24)
@@ -2820,9 +2989,9 @@ var TaskRow = import_react3.default.memo(
       return `${count} \u0437\u0430\u0434\u0430\u0447`;
     };
     const estimatedTextWidth = isParent ? 120 : durationDays >= 10 ? 76 : 62;
-    const showProgressInside = progressWidth > 0 && displayWidth > estimatedTextWidth;
+    const showProgressInside = !milestone && progressWidth > 0 && displayWidth > estimatedTextWidth;
     const MIN_DURATION_WIDTH = isParent ? 80 : 50;
-    const showDurationInside = durationDays >= 2 && displayWidth > MIN_DURATION_WIDTH;
+    const showDurationInside = !milestone && durationDays >= 2 && displayWidth > MIN_DURATION_WIDTH;
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
       "div",
       {
@@ -2836,18 +3005,24 @@ var TaskRow = import_react3.default.memo(
               "div",
               {
                 "data-taskbar": true,
-                className: `gantt-tr-taskBar ${isDragging ? "gantt-tr-dragging" : ""} ${task.locked ? "gantt-tr-locked" : ""} ${isParent ? "gantt-tr-parentBar" : ""}`,
+                className: `gantt-tr-taskBar ${isDragging ? "gantt-tr-dragging" : ""} ${task.locked ? "gantt-tr-locked" : ""} ${isParent ? "gantt-tr-parentBar" : ""} ${milestone ? "gantt-tr-milestone" : ""}`,
                 style: {
-                  left: `${displayLeft}px`,
-                  width: `${displayWidth}px`,
+                  left: `${visualLeft}px`,
                   ...barStyle,
-                  height: isParent ? "var(--gantt-parent-bar-height, 14px)" : "var(--gantt-task-bar-height)",
+                  ...milestone ? {
+                    height: `${displayMilestoneGeometry.size}px`,
+                    width: `${displayMilestoneGeometry.size}px`,
+                    padding: 0
+                  } : {
+                    width: `${visualWidth}px`,
+                    height: isParent ? "var(--gantt-parent-bar-height, 14px)" : "var(--gantt-task-bar-height)"
+                  },
                   cursor: dragHandleProps.style.cursor,
                   userSelect: dragHandleProps.style.userSelect
                 },
                 onMouseDown: dragHandleProps.onMouseDown,
                 children: [
-                  progressWidth > 0 && progressWidth < 100 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  !milestone && progressWidth > 0 && progressWidth < 100 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
                     "div",
                     {
                       className: "gantt-tr-progressBar",
@@ -2860,13 +3035,13 @@ var TaskRow = import_react3.default.memo(
                       }
                     }
                   ),
-                  !isParent && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
+                  !isParent && !milestone && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
                   showDurationInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-taskDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && showProgressInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-progressText", children: [
                     progressWidth,
                     "%"
                   ] }),
-                  !isParent && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
+                  !isParent && !milestone && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
                 ]
               }
             ),
@@ -2875,7 +3050,7 @@ var TaskRow = import_react3.default.memo(
               {
                 className: `gantt-tr-leftLabels ${task.locked ? "gantt-tr-leftLabels-locked" : ""}`,
                 style: {
-                  left: `${displayLeft}px`
+                  left: `${visualLeft}px`
                 },
                 children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-dateLabel gantt-tr-dateLabelLeft", children: dateRangeLabel })
               }
@@ -2886,7 +3061,7 @@ var TaskRow = import_react3.default.memo(
                 className: "gantt-tr-lockIcon",
                 style: {
                   position: "absolute",
-                  left: `${displayLeft - 16}px`,
+                  left: `${visualLeft - 16}px`,
                   top: "50%",
                   transform: "translateY(-50%)",
                   width: "12px",
@@ -2906,11 +3081,11 @@ var TaskRow = import_react3.default.memo(
               {
                 className: "gantt-tr-rightLabels",
                 style: {
-                  left: `${displayLeft + Math.max(displayWidth, 20) - Math.min(6, Math.max(displayWidth, 20) / 2) + 8}px`,
+                  left: `${visualLeft + Math.max(visualWidth, 20) - Math.min(6, Math.max(visualWidth, 20) / 2) + 8}px`,
                   color: isParent ? task.color || defaultParentBarColor : barColor
                 },
                 children: [
-                  !showDurationInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-externalDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
+                  !showDurationInside && !milestone && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-externalDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && !showProgressInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-externalProgress", children: [
                     progressWidth,
                     "%"
@@ -3159,16 +3334,12 @@ var DependencyLines = import_react6.default.memo(({
     const taskMap = new Map(tasksForPositions.map((t) => [t.id, t]));
     const visibleTaskMap = new Map(tasks.map((t) => [t.id, t]));
     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;
+      const computed = resolveTaskHorizontalGeometry(task, monthStart, dayWidth, override);
       indices.set(task.id, index);
       positions.set(task.id, {
-        left: resolvedLeft,
-        right: resolvedLeft + resolvedWidth,
+        left: computed.left,
+        right: computed.right,
         rowTop: index * rowHeight,
         isVirtual: false
       });
@@ -3182,15 +3353,11 @@ var DependencyLines = import_react6.default.memo(({
         if (!visibleAncestor) continue;
         const ancestorPosition = positions.get(visibleAncestor.id);
         if (!ancestorPosition) continue;
-        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;
+        const computed = resolveTaskHorizontalGeometry(task, monthStart, dayWidth, override);
         positions.set(task.id, {
-          left: resolvedLeft,
-          right: resolvedLeft + resolvedWidth,
+          left: computed.left,
+          right: computed.right,
           rowTop: ancestorPosition.rowTop,
           isVirtual: true
         });
@@ -3206,6 +3373,7 @@ var DependencyLines = import_react6.default.memo(({
   }, [tasks, allTasks]);
   const lines = (0, import_react6.useMemo)(() => {
     const tasksForEdges = allTasks ?? tasks;
+    const taskMap = new Map(tasksForEdges.map((task) => [task.id, task]));
     const edges = getAllDependencyEdges(tasksForEdges);
     const lines2 = [];
     for (const edge of edges) {
@@ -3216,9 +3384,11 @@ var DependencyLines = import_react6.default.memo(({
       if (!predecessor || !successor) {
         continue;
       }
+      const predecessorTask = taskMap.get(edge.predecessorId);
+      const successorTask = taskMap.get(edge.successorId);
       if (allTasks && collapsedParentIds.size > 0) {
-        const taskMap = new Map(allTasks.map((t) => [t.id, t]));
-        if (areBothHiddenInSameParent(edge.predecessorId, edge.successorId, collapsedParentIds, taskMap)) {
+        const taskMap2 = new Map(allTasks.map((t) => [t.id, t]));
+        if (areBothHiddenInSameParent(edge.predecessorId, edge.successorId, collapsedParentIds, taskMap2)) {
           continue;
         }
       }
@@ -3238,11 +3408,18 @@ var DependencyLines = import_react6.default.memo(({
         fromY = predecessor.rowTop + rowHeight - 10;
         toY = successor.rowTop + 6;
       }
-      const fromX = edge.type === "SS" || edge.type === "SF" ? predecessor.left : predecessor.right;
+      let fromX = edge.type === "SS" || edge.type === "SF" ? predecessor.left : predecessor.right;
       const toX = edge.type === "FF" || edge.type === "SF" ? successor.right : successor.left;
+      const stackedMilestonesSameDay = Boolean(
+        predecessorTask && successorTask && isMilestoneTask(predecessorTask) && isMilestoneTask(successorTask) && edge.lag === 0 && new Date(predecessorTask.startDate).toISOString().split("T")[0] === new Date(successorTask.startDate).toISOString().split("T")[0] && predecessor.rowTop !== successor.rowTop && edge.type === "FS"
+      );
+      const finalToX = stackedMilestonesSameDay ? Math.round(((predecessor.left + predecessor.right) / 2 + (successor.left + successor.right) / 2) / 2) : toX;
+      if (stackedMilestonesSameDay) {
+        fromX = finalToX;
+      }
       const arrivesFromRight = edge.type === "FF" || edge.type === "SF";
       const from = { x: fromX, y: fromY };
-      const to = { x: toX, y: toY };
+      const to = { x: finalToX, y: toY };
       const path = calculateDependencyPath(from, to, arrivesFromRight);
       const hasCycle = cycleInfo.has(edge.predecessorId) || cycleInfo.has(edge.successorId);
       lines2.push({
@@ -3251,7 +3428,7 @@ var DependencyLines = import_react6.default.memo(({
         hasCycle,
         lag: edge.lag,
         fromX,
-        toX,
+        toX: finalToX,
         fromY,
         reverseOrder,
         isVirtual
@@ -3264,6 +3441,7 @@ var DependencyLines = import_react6.default.memo(({
     "svg",
     {
       className: "gantt-dependencies-svg",
+      "data-testid": "dependency-lines-svg",
       width: gridWidth,
       height: svgHeight,
       xmlns: "http://www.w3.org/2000/svg",
@@ -4238,7 +4416,7 @@ var DepChip = ({
       const predecessor = taskById.get(dep.taskId);
       if (!predecessor) return;
       const predStart = parseUTCDate(predecessor.startDate);
-      const predEnd = parseUTCDate(predecessor.endDate);
+      const predEnd = predecessor.type === "milestone" ? predStart : parseUTCDate(predecessor.endDate);
       const origStart = parseUTCDate(task.startDate);
       const origEnd = parseUTCDate(task.endDate);
       const durationMs = origEnd.getTime() - origStart.getTime();
@@ -4501,10 +4679,12 @@ var TaskListRow = import_react10.default.memo(
     const editingName = editingColumnId === "name";
     const editingDuration = editingColumnId === "duration";
     const editingProgress = editingColumnId === "progress";
+    const normalizedTask = (0, import_react10.useMemo)(() => normalizeTaskDatesForType(task), [task]);
+    const isMilestone = (0, import_react10.useMemo)(() => isMilestoneTask(normalizedTask), [normalizedTask]);
     const [nameValue, setNameValue] = (0, import_react10.useState)("");
     const nameInputRef = (0, import_react10.useRef)(null);
     const [durationValue, setDurationValue] = (0, import_react10.useState)(
-      () => getInclusiveDurationDays(task.startDate, task.endDate)
+      () => getInclusiveDurationDays(normalizedTask.startDate, normalizedTask.endDate)
     );
     const durationInputRef = (0, import_react10.useRef)(null);
     const dependencySearchInputRef = (0, import_react10.useRef)(null);
@@ -4705,14 +4885,14 @@ var TaskListRow = import_react10.default.memo(
         e.stopPropagation();
         durationConfirmedRef.current = false;
         setDurationValue(
-          getDuration(task.startDate, task.endDate)
+          isMilestone ? 0 : getDuration(normalizedTask.startDate, normalizedTask.endDate)
         );
         setEditingColumnId("duration");
       },
-      [task.locked, task.startDate, task.endDate, getDuration]
+      [task.locked, normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]
     );
     const applyDurationChange = (0, import_react10.useCallback)((nextDuration) => {
-      const normalizedDuration = Math.max(1, Math.round(nextDuration) || 1);
+      const normalizedDuration = Math.max(0, Math.round(nextDuration) || 0);
       setDurationValue(normalizedDuration);
     }, []);
     const handleDurationSave = (0, import_react10.useCallback)(() => {
@@ -4720,19 +4900,26 @@ var TaskListRow = import_react10.default.memo(
         durationConfirmedRef.current = false;
         return;
       }
-      const normalizedDuration = Math.max(1, Math.round(durationValue) || 1);
-      onTasksChange?.([
-        {
-          ...task,
-          endDate: getEndDate(task.startDate, normalizedDuration)
-        }
-      ]);
+      const rounded = Math.round(durationValue) || 0;
+      if (isMilestone && rounded > 0) {
+        onTasksChange?.([
+          { ...task, type: "task", endDate: getEndDate(task.startDate, rounded) }
+        ]);
+      } else if (!isMilestone && rounded === 0) {
+        onTasksChange?.([
+          { ...task, type: "milestone", endDate: task.startDate }
+        ]);
+      } else if (!isMilestone && rounded > 0) {
+        onTasksChange?.([
+          { ...task, endDate: getEndDate(task.startDate, rounded) }
+        ]);
+      }
       setEditingColumnId(null);
-    }, [durationValue, task, onTasksChange, getEndDate]);
+    }, [durationValue, task, onTasksChange, getEndDate, isMilestone]);
     const handleDurationCancel = (0, import_react10.useCallback)(() => {
-      setDurationValue(getDuration(task.startDate, task.endDate));
+      setDurationValue(isMilestone ? 0 : getDuration(normalizedTask.startDate, normalizedTask.endDate));
       setEditingColumnId(null);
-    }, [task.startDate, task.endDate, getDuration]);
+    }, [normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]);
     const handleDurationAdjust = (0, import_react10.useCallback)(
       (delta) => {
         applyDurationChange(durationValue + delta);
@@ -4744,25 +4931,26 @@ var TaskListRow = import_react10.default.memo(
         e.stopPropagation();
         if (e.key === "Enter") {
           durationConfirmedRef.current = true;
-          const normalizedDuration = Math.max(
-            1,
-            Math.round(durationValue) || 1
-          );
-          onTasksChange?.([
-            {
-              ...task,
-              endDate: getEndDate(
-                task.startDate,
-                normalizedDuration
-              )
-            }
-          ]);
+          const rounded = Math.round(durationValue) || 0;
+          if (isMilestone && rounded > 0) {
+            onTasksChange?.([
+              { ...task, type: "task", endDate: getEndDate(task.startDate, rounded) }
+            ]);
+          } else if (!isMilestone && rounded === 0) {
+            onTasksChange?.([
+              { ...task, type: "milestone", endDate: task.startDate }
+            ]);
+          } else if (!isMilestone && rounded > 0) {
+            onTasksChange?.([
+              { ...task, endDate: getEndDate(task.startDate, rounded) }
+            ]);
+          }
           setEditingColumnId(null);
         } else if (e.key === "Escape") {
           handleDurationCancel();
         }
       },
-      [durationValue, task, onTasksChange, handleDurationCancel, getEndDate]
+      [durationValue, task, onTasksChange, handleDurationCancel, getEndDate, isMilestone]
     );
     const handleProgressClick = (0, import_react10.useCallback)(
       (e) => {
@@ -4833,17 +5021,54 @@ var TaskListRow = import_react10.default.memo(
       }
     }, [editingProgress]);
     (0, import_react10.useEffect)(() => {
-      setDurationValue(getDuration(task.startDate, task.endDate));
-    }, [task.startDate, task.endDate, getDuration]);
+      setDurationValue(getDuration(normalizedTask.startDate, normalizedTask.endDate));
+    }, [normalizedTask.startDate, normalizedTask.endDate, getDuration]);
     (0, import_react10.useEffect)(() => {
       if (editingDuration && durationInputRef.current) {
         durationInputRef.current.focus();
         durationInputRef.current.select();
       }
     }, [editingDuration]);
+    const emitMilestoneDateChange = (0, import_react10.useCallback)((nextDateISO) => {
+      const alignedDate = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${nextDateISO}T00:00:00.000Z`), 1, weekendPredicate) : /* @__PURE__ */ new Date(`${nextDateISO}T00:00:00.000Z`);
+      const clampedRange = clampTaskRangeForIncomingFS(
+        task,
+        alignedDate,
+        alignedDate,
+        allTasks,
+        businessDays,
+        weekendPredicate
+      );
+      const normalized = normalizeTaskDatesForType({
+        ...task,
+        startDate: clampedRange.start.toISOString().split("T")[0],
+        endDate: clampedRange.end.toISOString().split("T")[0]
+      });
+      const startDate = parseUTCDate(normalized.startDate);
+      const endDate = parseUTCDate(normalized.endDate);
+      onTasksChange?.([
+        {
+          ...normalized,
+          ...task.dependencies && {
+            dependencies: recalculateIncomingLags(
+              task,
+              startDate,
+              endDate,
+              allTasks,
+              businessDays,
+              weekendPredicate
+            )
+          }
+        }
+      ]);
+    }, [task, onTasksChange, allTasks, businessDays, weekendPredicate]);
     const handleStartDateChange = (0, import_react10.useCallback)(
       (newDateISO) => {
         if (!newDateISO) return;
+        if (isMilestone) {
+          emitMilestoneDateChange(newDateISO);
+          return;
+        }
         let nextEndISO;
         const normalizedInputStart = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`), 1, weekendPredicate) : /* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`);
         if (businessDays) {
@@ -4890,11 +5115,15 @@ var TaskListRow = import_react10.default.memo(
           }
         ]);
       },
-      [task, onTasksChange, businessDays, getDuration, getEndDate, allTasks, weekendPredicate]
+      [task, onTasksChange, businessDays, getDuration, getEndDate, allTasks, weekendPredicate, isMilestone, emitMilestoneDateChange]
     );
     const handleEndDateChange = (0, import_react10.useCallback)(
       (newDateISO) => {
         if (!newDateISO) return;
+        if (isMilestone) {
+          emitMilestoneDateChange(newDateISO);
+          return;
+        }
         let nextStartISO;
         const normalizedInputEnd = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`), -1, weekendPredicate) : /* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`);
         if (businessDays) {
@@ -4941,7 +5170,7 @@ var TaskListRow = import_react10.default.memo(
           }
         ]);
       },
-      [task, onTasksChange, businessDays, getDuration, weekendPredicate, allTasks]
+      [task, onTasksChange, businessDays, getDuration, weekendPredicate, allTasks, isMilestone, emitMilestoneDateChange]
     );
     const handleRowClickInternal = (0, import_react10.useCallback)(() => {
       onRowClick?.(task.id);
@@ -5212,8 +5441,8 @@ var TaskListRow = import_react10.default.memo(
       },
       [selectedChip?.successorId, selectedChip?.predecessorId, selectedChip?.linkType, onRemoveDependency, onChipSelect]
     );
-    const startDateISO = toISODate(task.startDate);
-    const endDateISO = editingDuration ? getEndDate(task.startDate, durationValue) : toISODate(task.endDate);
+    const startDateISO = toISODate(normalizedTask.startDate);
+    const endDateISO = editingDuration ? getEndDate(normalizedTask.startDate, durationValue) : toISODate(normalizedTask.endDate);
     const numberCell = /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
       "div",
       {
@@ -5619,10 +5848,10 @@ var TaskListRow = import_react10.default.memo(
                   {
                     ref: durationInputRef,
                     type: "number",
-                    min: 1,
+                    min: 0,
                     step: 1,
                     value: durationValue,
-                    onChange: (e) => applyDurationChange(parseInt(e.target.value, 10) || 1),
+                    onChange: (e) => applyDurationChange(parseInt(e.target.value, 10) || 0),
                     onBlur: handleDurationSave,
                     onKeyDown: handleDurationKeyDown,
                     className: "gantt-tl-number-input"
@@ -5683,14 +5912,11 @@ var TaskListRow = import_react10.default.memo(
               ]
             }
           ),
-          /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
             "span",
             {
               style: editingDuration ? { visibility: "hidden", pointerEvents: "none" } : void 0,
-              children: [
-                getDuration(task.startDate, task.endDate),
-                "\u0434"
-              ]
+              children: isMilestone ? "0" : `${getDuration(normalizedTask.startDate, normalizedTask.endDate)}\u0434`
             }
           )
         ]
@@ -7180,7 +7406,8 @@ function GanttChartInner(props, ref) {
       }
       return;
     }
-    const cascadedTasks = disableConstraints ? [updatedTask] : universalCascade(updatedTask, newStart, newEnd, tasks, businessDays, isCustomWeekend);
+    const sourceTasks = tasks.map((task) => task.id === updatedTask.id ? updatedTask : task);
+    const cascadedTasks = disableConstraints ? [updatedTask] : universalCascade(updatedTask, newStart, newEnd, sourceTasks, businessDays, isCustomWeekend);
     onTasksChange?.(cascadedTasks);
   }, [tasks, onTasksChange, disableConstraints, editingTaskId, businessDays, isCustomWeekend]);
   const handleDelete = (0, import_react13.useCallback)((taskId) => {
@@ -7634,6 +7861,8 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   calculateDependencyPath,
   calculateGridLines,
   calculateGridWidth,
+  calculateMilestoneConnectionBounds,
+  calculateMilestoneGeometry,
   calculateMonthGridLines,
   calculateOrthogonalPath,
   calculateSuccessorDate,
@@ -7685,6 +7914,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   nameContains,
   normalizeDependencyLag,
   normalizeHierarchyTasks,
+  normalizePredecessorDates,
   normalizeTaskDates,
   normalizeUTCDate,
   not,
@@ -7700,6 +7930,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   removeDependenciesBetweenTasks,
   resizeTaskWithCascade,
   resolveDateRangeFromPixels,
+  resolveTaskHorizontalGeometry,
   shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,