gantt-lib 0.0.6 → 0.0.7

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   TodayIndicator: () => TodayIndicator_default,
   buildAdjacencyList: () => buildAdjacencyList,
   calculateBezierPath: () => calculateBezierPath,
+  calculateDependencyPath: () => calculateDependencyPath,
   calculateGridLines: () => calculateGridLines,
   calculateGridWidth: () => calculateGridWidth,
   calculateOrthogonalPath: () => calculateOrthogonalPath,
@@ -295,7 +296,7 @@ function validateDependencies(tasks) {
     errors
   };
 }
-function getSuccessorChain(draggedTaskId, allTasks) {
+function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
   const successorMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
     successorMap.set(task.id, []);
@@ -303,7 +304,7 @@ function getSuccessorChain(draggedTaskId, allTasks) {
   for (const task of allTasks) {
     if (!task.dependencies) continue;
     for (const dep of task.dependencies) {
-      if (dep.type === "FS") {
+      if (linkTypes.includes(dep.type)) {
         const list = successorMap.get(dep.taskId) ?? [];
         list.push(task.id);
         successorMap.set(dep.taskId, list);
@@ -525,6 +526,43 @@ var calculateBezierPath = (from, to) => {
   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 calculateDependencyPath = (from, to, arrivesFromRight) => {
+  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 dirY = goingDown ? 1 : -1;
+  if (arrivesFromRight) {
+    const goingRight = tx >= fx;
+    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}`;
+  } else {
+    const goingRight = tx >= fx;
+    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}`;
+  }
+};
 var calculateOrthogonalPath = (from, to) => {
   const fx = Math.round(from.x);
   const fy = Math.round(from.y);
@@ -551,6 +589,36 @@ var calculateOrthogonalPath = (from, to) => {
 
 // src/hooks/useTaskDrag.ts
 var import_react2 = require("react");
+function getTransitiveCascadeChain(draggedTaskId, allTasks, firstLevelLinkTypes) {
+  const allTypesSuccessorMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    allTypesSuccessorMap.set(task.id, []);
+  }
+  for (const task of allTasks) {
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      const list = allTypesSuccessorMap.get(dep.taskId) ?? [];
+      list.push(task);
+      allTypesSuccessorMap.set(dep.taskId, list);
+    }
+  }
+  const directSuccessors = getSuccessorChain(draggedTaskId, allTasks, firstLevelLinkTypes);
+  const chain = [...directSuccessors];
+  const visited = /* @__PURE__ */ new Set([draggedTaskId, ...directSuccessors.map((t) => t.id)]);
+  const queue = [...directSuccessors];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const successors = allTypesSuccessorMap.get(current.id) ?? [];
+    for (const successor of successors) {
+      if (!visited.has(successor.id)) {
+        visited.add(successor.id);
+        chain.push(successor);
+        queue.push(successor);
+      }
+    }
+  }
+  return chain;
+}
 var globalActiveDrag = null;
 var globalRafId = null;
 function completeDrag() {
@@ -579,25 +647,43 @@ function cancelDrag() {
 function snapToGrid(pixels, dayWidth) {
   return Math.round(pixels / dayWidth) * dayWidth;
 }
-function recalculateIncomingLags(task, newStartDate, allTasks) {
+function recalculateIncomingLags(task, newStartDate, newEndDate, 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 };
+    if (dep.type === "FS") {
+      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 };
+    }
+    if (dep.type === "SS") {
+      const predecessor = taskById.get(dep.taskId);
+      if (!predecessor) return dep;
+      const predStart = new Date(predecessor.startDate);
+      const lagMs = Date.UTC(newStartDate.getUTCFullYear(), newStartDate.getUTCMonth(), newStartDate.getUTCDate()) - Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate());
+      const lagDays = Math.max(0, Math.round(lagMs / (24 * 60 * 60 * 1e3)));
+      return { ...dep, lag: lagDays };
+    }
+    if (dep.type === "FF") {
+      const predecessor = taskById.get(dep.taskId);
+      if (!predecessor) return dep;
+      const predEnd = new Date(predecessor.endDate);
+      const lagMs = Date.UTC(newEndDate.getUTCFullYear(), newEndDate.getUTCMonth(), newEndDate.getUTCDate()) - Date.UTC(predEnd.getUTCFullYear(), predEnd.getUTCMonth(), predEnd.getUTCDate());
+      const lagDays = Math.round(lagMs / (24 * 60 * 60 * 1e3));
+      return { ...dep, lag: lagDays };
+    }
+    if (dep.type === "SF") {
+      const predecessor = taskById.get(dep.taskId);
+      if (!predecessor) return dep;
+      const predStart = new Date(predecessor.startDate);
+      const lagMs = Date.UTC(newEndDate.getUTCFullYear(), newEndDate.getUTCMonth(), newEndDate.getUTCDate()) - Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate()) + 24 * 60 * 60 * 1e3;
+      const lagDays = Math.min(0, Math.round(lagMs / (24 * 60 * 60 * 1e3)));
+      return { ...dep, lag: lagDays };
+    }
+    return dep;
   });
 }
 function handleGlobalMouseMove(e) {
@@ -628,12 +714,12 @@ function handleGlobalMouseMove(e) {
         newWidth = Math.max(dayWidth, snappedWidth);
         break;
     }
-    if (mode === "move" && allTasks.length > 0 && !globalActiveDrag.disableConstraints) {
+    if ((mode === "move" || mode === "resize-left") && 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;
+          if (dep.type !== "FS" && dep.type !== "SS") continue;
           const predecessor = globalActiveDrag.allTasks.find((t) => t.id === dep.taskId);
           if (!predecessor) continue;
           const predStart = new Date(predecessor.startDate);
@@ -649,25 +735,91 @@ function handleGlobalMouseMove(e) {
         }
         newLeft = Math.max(minAllowedLeft, newLeft);
       }
+      if (mode === "resize-left") {
+        const rightEdge = globalActiveDrag.initialLeft + globalActiveDrag.initialWidth;
+        newWidth = Math.max(globalActiveDrag.dayWidth, rightEdge - newLeft);
+      }
+    }
+    if ((mode === "move" || mode === "resize-right") && allTasks.length > 0 && !globalActiveDrag.disableConstraints) {
+      const currentTask = allTasks.find((t) => t.id === globalActiveDrag?.taskId);
+      if (currentTask && currentTask.dependencies && currentTask.dependencies.length > 0) {
+        for (const dep of currentTask.dependencies) {
+          if (dep.type !== "SF") 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.getUTCDate(), globalActiveDrag.monthStart.getUTCDate())) / (24 * 60 * 60 * 1e3)
+          );
+          const predStartLeft = Math.round(predStartOffset * globalActiveDrag.dayWidth);
+          const sfBoundaryRight = predStartLeft;
+          if (mode === "move") {
+            const proposedEndRight = newLeft + globalActiveDrag.initialWidth;
+            if (proposedEndRight > sfBoundaryRight) {
+              newLeft = Math.max(globalActiveDrag.initialLeft, sfBoundaryRight - globalActiveDrag.initialWidth);
+            }
+          } else {
+            const currentEndRight = newLeft + newWidth;
+            if (currentEndRight > sfBoundaryRight) {
+              newWidth = Math.max(globalActiveDrag.dayWidth, sfBoundaryRight - newLeft);
+            }
+          }
+        }
+      }
     }
-    if ((mode === "move" || mode === "resize-right") && !globalActiveDrag.disableConstraints && globalActiveDrag.cascadeChain.length > 0 && globalActiveDrag.onCascadeProgress) {
+    const activeChain = mode === "resize-right" ? globalActiveDrag.cascadeChainEnd : (
+      // FS + FF
+      mode === "resize-left" ? globalActiveDrag.cascadeChainStart : (
+        // SS + SF
+        /* move */
+        globalActiveDrag.cascadeChain
+      )
+    );
+    if ((mode === "move" || mode === "resize-right" || mode === "resize-left" && globalActiveDrag.cascadeChainStart.length > 0) && !globalActiveDrag.disableConstraints && activeChain.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 draggedTaskId = globalActiveDrag.taskId;
+      const dayWidth2 = globalActiveDrag.dayWidth;
+      const monthStart = globalActiveDrag.monthStart;
+      for (const chainTask of activeChain) {
         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()
+            monthStart.getUTCFullYear(),
+            monthStart.getUTCMonth(),
+            monthStart.getUTCDate()
+          )) / (24 * 60 * 60 * 1e3)
+        );
+        const chainEndOffset = Math.round(
+          (Date.UTC(chainEnd.getUTCFullYear(), chainEnd.getUTCMonth(), chainEnd.getUTCDate()) - Date.UTC(
+            monthStart.getUTCFullYear(),
+            monthStart.getUTCMonth(),
+            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);
+        const hasFFDepOnDragged = chainTask.dependencies?.some(
+          (dep) => dep.taskId === draggedTaskId && dep.type === "FF"
+        );
+        const hasSFDepOnDragged = chainTask.dependencies?.some(
+          (dep) => dep.taskId === draggedTaskId && dep.type === "SF"
+        );
+        let chainLeft;
+        if (hasFFDepOnDragged || hasSFDepOnDragged) {
+          chainLeft = Math.round((chainEndOffset + deltaDays - chainDuration) * dayWidth2);
+        } else {
+          chainLeft = Math.round((chainStartOffset + deltaDays) * dayWidth2);
+        }
+        const chainWidth = Math.round((chainDuration + 1) * dayWidth2);
+        const hasSSDepOnDragged = chainTask.dependencies?.some(
+          (dep) => dep.taskId === draggedTaskId && dep.type === "SS"
+        );
+        if (hasSSDepOnDragged && (mode === "move" || mode === "resize-left")) {
+          chainLeft = Math.max(chainLeft, newLeft);
+        }
         overrides.set(chainTask.id, { left: chainLeft, width: chainWidth });
       }
       globalActiveDrag.onCascadeProgress(overrides);
@@ -778,19 +930,32 @@ var useTaskDrag = (options) => {
     }
     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 origStartMs = Date.UTC(
+          initialStartDate.getUTCFullYear(),
+          initialStartDate.getUTCMonth(),
+          initialStartDate.getUTCDate()
+        );
+        const newStartMs = Date.UTC(
+          newStartDate.getUTCFullYear(),
+          newStartDate.getUTCMonth(),
+          newStartDate.getUTCDate()
+        );
+        const deltaFromStart = Math.round((newStartMs - origStartMs) / (24 * 60 * 60 * 1e3));
+        const origEndMs = Date.UTC(
+          initialEndDate.getUTCFullYear(),
+          initialEndDate.getUTCMonth(),
+          initialEndDate.getUTCDate()
+        );
+        const newEndMs = Date.UTC(
+          newEndDate.getUTCFullYear(),
+          newEndDate.getUTCMonth(),
+          newEndDate.getUTCDate()
+        );
+        const deltaFromEnd = Math.round((newEndMs - origEndMs) / (24 * 60 * 60 * 1e3));
+        const deltaDays = deltaFromStart === 0 ? deltaFromEnd : deltaFromStart;
+        const isResizeLeft = deltaFromStart !== 0 && deltaFromEnd === 0;
+        const chainForCompletion = deltaFromStart === 0 ? getTransitiveCascadeChain(taskId, allTasks, ["FS", "FF"]) : isResizeLeft ? getTransitiveCascadeChain(taskId, allTasks, ["SS", "SF"]) : getTransitiveCascadeChain(taskId, allTasks, ["FS", "SS", "FF", "SF"]);
+        if (chainForCompletion.length > 0) {
           const draggedTaskData = allTasks.find((t) => t.id === taskId);
           const cascadedTasks = [
             {
@@ -798,10 +963,10 @@ var useTaskDrag = (options) => {
               startDate: newStartDate.toISOString(),
               endDate: newEndDate.toISOString(),
               ...draggedTaskData?.dependencies && {
-                dependencies: recalculateIncomingLags(draggedTaskData, newStartDate, allTasks)
+                dependencies: recalculateIncomingLags(draggedTaskData, newStartDate, newEndDate, allTasks)
               }
             },
-            ...chain.map((chainTask) => {
+            ...chainForCompletion.map((chainTask) => {
               const origStart = new Date(chainTask.startDate);
               const origEnd = new Date(chainTask.endDate);
               const newStart = new Date(Date.UTC(
@@ -823,7 +988,7 @@ var useTaskDrag = (options) => {
       }
       if (allTasks.length > 0 && onDragEnd) {
         const currentTaskData = allTasks.find((t) => t.id === taskId);
-        const updatedDependencies = currentTaskData?.dependencies ? recalculateIncomingLags(currentTaskData, newStartDate, allTasks) : void 0;
+        const updatedDependencies = currentTaskData?.dependencies ? recalculateIncomingLags(currentTaskData, newStartDate, newEndDate, allTasks) : void 0;
         onDragEnd({ id: taskId, startDate: newStartDate, endDate: newEndDate, updatedDependencies });
       } else if (onDragEnd) {
         onDragEnd({ id: taskId, startDate: newStartDate, endDate: newEndDate });
@@ -899,7 +1064,10 @@ var useTaskDrag = (options) => {
       onCancel: handleCancel,
       allTasks,
       disableConstraints,
-      cascadeChain: (mode === "move" || mode === "resize-right") && !disableConstraints ? getSuccessorChain(taskId, allTasks) : [],
+      cascadeChain: !disableConstraints ? getTransitiveCascadeChain(taskId, allTasks, ["FS", "SS", "FF", "SF"]) : [],
+      cascadeChainFS: !disableConstraints ? getTransitiveCascadeChain(taskId, allTasks, ["FS"]) : [],
+      cascadeChainStart: !disableConstraints ? getTransitiveCascadeChain(taskId, allTasks, ["SS", "SF"]) : [],
+      cascadeChainEnd: !disableConstraints ? getTransitiveCascadeChain(taskId, allTasks, ["FS", "FF"]) : [],
       onCascadeProgress
     };
   }, [edgeZoneWidth, currentLeft, currentWidth, dayWidth, monthStart, taskId, onDragStateChange, handleProgress, handleComplete, handleCancel, allTasks, disableConstraints, onCascadeProgress, onCascade]);
@@ -988,6 +1156,8 @@ var TaskRow = import_react3.default.memo(
     const durationDays = Math.round(
       (currentEndDate.getTime() - currentStartDate.getTime()) / (1e3 * 60 * 60 * 24)
     ) + 1;
+    const estimatedTextWidth = durationDays >= 10 ? 76 : 62;
+    const showProgressInside = progressWidth > 0 && displayWidth > estimatedTextWidth;
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       "div",
       {
@@ -1024,6 +1194,10 @@ var TaskRow = import_react3.default.memo(
                   durationDays,
                   " \u0434"
                 ] }),
+                progressWidth > 0 && showProgressInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-progressText", children: [
+                  progressWidth,
+                  "%"
+                ] }),
                 /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
               ]
             }
@@ -1042,14 +1216,20 @@ var TaskRow = import_react3.default.memo(
               ] })
             }
           ),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
             "div",
             {
               className: "gantt-tr-rightLabels",
               style: {
                 left: `${displayLeft + displayWidth}px`
               },
-              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-externalTaskName", children: task.name })
+              children: [
+                progressWidth > 0 && !showProgressInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-externalProgress", children: [
+                  progressWidth,
+                  "%"
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-externalTaskName", children: task.name })
+              ]
             }
           )
         ] })
@@ -1198,6 +1378,62 @@ var DragGuideLines_default = DragGuideLines;
 // src/components/DependencyLines/DependencyLines.tsx
 var import_react6 = __toESM(require("react"));
 var import_jsx_runtime6 = require("react/jsx-runtime");
+function calculateEffectiveLag(edge, predPosition, succPosition, monthStart, dayWidth) {
+  const predStartDate = pixelsToDate(predPosition.left, monthStart, dayWidth);
+  const predEndDate = pixelsToDate(predPosition.right - dayWidth, monthStart, dayWidth);
+  const succStartDate = pixelsToDate(succPosition.left, monthStart, dayWidth);
+  const succEndDate = pixelsToDate(succPosition.right - dayWidth, monthStart, dayWidth);
+  let lagMs = 0;
+  switch (edge.type) {
+    case "FS":
+      lagMs = Date.UTC(
+        succStartDate.getUTCFullYear(),
+        succStartDate.getUTCMonth(),
+        succStartDate.getUTCDate()
+      ) - Date.UTC(
+        predEndDate.getUTCFullYear(),
+        predEndDate.getUTCMonth(),
+        predEndDate.getUTCDate()
+      ) - 24 * 60 * 60 * 1e3;
+      break;
+    case "SS":
+      lagMs = Date.UTC(
+        succStartDate.getUTCFullYear(),
+        succStartDate.getUTCMonth(),
+        succStartDate.getUTCDate()
+      ) - Date.UTC(
+        predStartDate.getUTCFullYear(),
+        predStartDate.getUTCMonth(),
+        predStartDate.getUTCDate()
+      );
+      break;
+    case "FF":
+      lagMs = Date.UTC(
+        succEndDate.getUTCFullYear(),
+        succEndDate.getUTCMonth(),
+        succEndDate.getUTCDate()
+      ) - Date.UTC(
+        predEndDate.getUTCFullYear(),
+        predEndDate.getUTCMonth(),
+        predEndDate.getUTCDate()
+      );
+      break;
+    case "SF":
+      lagMs = Date.UTC(
+        succEndDate.getUTCFullYear(),
+        succEndDate.getUTCMonth(),
+        succEndDate.getUTCDate()
+      ) - Date.UTC(
+        predStartDate.getUTCFullYear(),
+        predStartDate.getUTCMonth(),
+        predStartDate.getUTCDate()
+      ) + 24 * 60 * 60 * 1e3;
+      break;
+    default:
+      return 0;
+  }
+  return Math.round(lagMs / (24 * 60 * 60 * 1e3));
+}
 var DependencyLines = import_react6.default.memo(({
   tasks,
   monthStart,
@@ -1218,7 +1454,7 @@ var DependencyLines = import_react6.default.memo(({
       const resolvedWidth = override?.width ?? computed.width;
       indices.set(task.id, index);
       positions.set(task.id, {
-        left: resolvedLeft + 10,
+        left: resolvedLeft,
         right: resolvedLeft + resolvedWidth,
         rowTop: index * rowHeight
       });
@@ -1251,18 +1487,27 @@ var DependencyLines = import_react6.default.memo(({
         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 fromX = edge.type === "SS" || edge.type === "SF" ? predecessor.left : predecessor.right;
+      const toX = edge.type === "FF" || edge.type === "SF" ? successor.right : successor.left;
+      const arrivesFromRight = edge.type === "FF" || edge.type === "SF";
+      const from = { x: fromX, y: fromY };
+      const to = { x: toX, y: toY };
+      const path = calculateDependencyPath(from, to, arrivesFromRight);
       const hasCycle = cycleInfo.has(edge.predecessorId) || cycleInfo.has(edge.successorId);
+      const lag = calculateEffectiveLag(edge, predecessor, successor, monthStart, dayWidth);
       lines2.push({
-        id: `${edge.predecessorId}-${edge.successorId}`,
+        id: `${edge.predecessorId}-${edge.successorId}-${edge.type}`,
         path,
-        hasCycle
+        hasCycle,
+        lag,
+        fromX,
+        toX,
+        fromY,
+        reverseOrder
       });
     }
     return lines2;
-  }, [tasks, taskPositions, taskIndices, cycleInfo]);
+  }, [tasks, taskPositions, taskIndices, cycleInfo, monthStart, dayWidth, dragOverrides]);
   return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(
     "svg",
     {
@@ -1311,15 +1556,28 @@ var DependencyLines = import_react6.default.memo(({
             }
           )
         ] }),
-        lines.map(({ id, path, hasCycle }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
-          "path",
-          {
-            d: path,
-            className: hasCycle ? "gantt-dependency-path gantt-dependency-cycle" : "gantt-dependency-path",
-            markerEnd: hasCycle ? "url(#arrowhead-cycle)" : "url(#arrowhead)"
-          },
-          id
-        ))
+        lines.map(({ id, path, hasCycle, lag, fromX, toX, fromY, reverseOrder }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_react6.default.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+            "path",
+            {
+              d: path,
+              className: hasCycle ? "gantt-dependency-path gantt-dependency-cycle" : "gantt-dependency-path",
+              markerEnd: hasCycle ? "url(#arrowhead-cycle)" : "url(#arrowhead)"
+            }
+          ),
+          lag !== 0 && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+            "text",
+            {
+              className: "gantt-dependency-lag-label",
+              x: lag < 0 ? toX + 14 : toX - 14,
+              y: reverseOrder ? fromY - 4 : fromY + 12,
+              textAnchor: "middle",
+              fontSize: "10",
+              fill: hasCycle ? "var(--gantt-dependency-cycle-color, #ef4444)" : "var(--gantt-dependency-line-color, #666666)",
+              children: lag > 0 ? `+${lag}` : `${lag}`
+            }
+          )
+        ] }, id))
       ]
     }
   );
@@ -1537,6 +1795,7 @@ var GanttChart = ({
   TodayIndicator,
   buildAdjacencyList,
   calculateBezierPath,
+  calculateDependencyPath,
   calculateGridLines,
   calculateGridWidth,
   calculateOrthogonalPath,