gantt-lib 0.6.2 → 0.7.0

package/dist/index.mjs

@@ -196,33 +196,33 @@ function detectCycles(tasks) {
   return { hasCycle: false };
 }
 function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd) {
-  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
   const pS = Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate());
   const pE = Date.UTC(predEnd.getUTCFullYear(), predEnd.getUTCMonth(), predEnd.getUTCDate());
   const sS = Date.UTC(succStart.getUTCFullYear(), succStart.getUTCMonth(), succStart.getUTCDate());
   const sE = Date.UTC(succEnd.getUTCFullYear(), succEnd.getUTCMonth(), succEnd.getUTCDate());
   switch (linkType) {
     case "FS":
-      return Math.round((sS - pE) / DAY_MS) - 1;
+      return Math.round((sS - pE) / DAY_MS2) - 1;
     case "SS":
-      return Math.round((sS - pS) / DAY_MS);
+      return Math.round((sS - pS) / DAY_MS2);
     case "FF":
-      return Math.round((sE - pE) / DAY_MS);
+      return Math.round((sE - pE) / DAY_MS2);
     case "SF":
-      return Math.round((sE - pS) / DAY_MS) + 1;
+      return Math.round((sE - pS) / DAY_MS2) + 1;
   }
 }
 function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0) {
-  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
   switch (linkType) {
     case "FS":
-      return new Date(predecessorEnd.getTime() + (lag + 1) * DAY_MS);
+      return new Date(predecessorEnd.getTime() + (lag + 1) * DAY_MS2);
     case "SS":
-      return new Date(predecessorStart.getTime() + lag * DAY_MS);
+      return new Date(predecessorStart.getTime() + lag * DAY_MS2);
     case "FF":
-      return new Date(predecessorEnd.getTime() + lag * DAY_MS);
+      return new Date(predecessorEnd.getTime() + lag * DAY_MS2);
     case "SF":
-      return new Date(predecessorStart.getTime() + (lag - 1) * DAY_MS);
+      return new Date(predecessorStart.getTime() + (lag - 1) * DAY_MS2);
   }
 }
 function validateDependencies(tasks) {
@@ -454,13 +454,13 @@ function computeParentProgress(parentId, tasks) {
   if (children.length === 0) {
     return 0;
   }
-  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
   let totalWeight = 0;
   let weightedSum = 0;
   for (const child of children) {
     const start = new Date(child.startDate).getTime();
     const end = new Date(child.endDate).getTime();
-    const duration = (end - start + DAY_MS) / DAY_MS;
+    const duration = (end - start + DAY_MS2) / DAY_MS2;
     const progress = child.progress ?? 0;
     totalWeight += duration;
     weightedSum += duration * progress;
@@ -1997,6 +1997,36 @@ var DependencyLines_default = DependencyLines;
 // src/components/TaskList/TaskList.tsx
 import React11, { useMemo as useMemo8, useCallback as useCallback5, useState as useState6, useEffect as useEffect5, useRef as useRef5 } from "react";
 
+// src/utils/taskListReorder.ts
+function getVisibleReorderPosition(orderedTasks, visibleTasks, movedTaskId, originVisibleIndex, dropVisibleIndex) {
+  const originOrderedIndex = orderedTasks.findIndex((task) => task.id === movedTaskId);
+  if (originOrderedIndex === -1) {
+    return null;
+  }
+  const reorderedWithoutMoved = orderedTasks.filter((task) => task.id !== movedTaskId);
+  const visibleWithoutMoved = visibleTasks.filter((task) => task.id !== movedTaskId);
+  const visibleInsertIndex = originVisibleIndex < dropVisibleIndex ? dropVisibleIndex - 1 : dropVisibleIndex;
+  if (visibleWithoutMoved.length === 0) {
+    return { originOrderedIndex, insertIndex: 0 };
+  }
+  if (visibleInsertIndex <= 0) {
+    return {
+      originOrderedIndex,
+      insertIndex: reorderedWithoutMoved.findIndex((task) => task.id === visibleWithoutMoved[0].id)
+    };
+  }
+  if (visibleInsertIndex >= visibleWithoutMoved.length) {
+    return {
+      originOrderedIndex,
+      insertIndex: reorderedWithoutMoved.length
+    };
+  }
+  return {
+    originOrderedIndex,
+    insertIndex: reorderedWithoutMoved.findIndex((task) => task.id === visibleWithoutMoved[visibleInsertIndex].id)
+  };
+}
+
 // src/components/ui/Popover.tsx
 import * as RadixPopover from "@radix-ui/react-popover";
 import { jsx as jsx7 } from "react/jsx-runtime";
@@ -2352,6 +2382,16 @@ var LINK_TYPE_LABELS = {
 
 // src/components/TaskList/TaskListRow.tsx
 import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var getInclusiveDurationDays = (startDate, endDate) => {
+  const start = parseUTCDate(startDate);
+  const end = parseUTCDate(endDate);
+  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
+};
+var getEndDateFromDuration = (startDate, durationDays) => {
+  const start = parseUTCDate(startDate);
+  return new Date(start.getTime() + (durationDays - 1) * DAY_MS).toISOString().split("T")[0];
+};
 var TrashIcon = () => /* @__PURE__ */ jsxs9("svg", { xmlns: "http://www.w3.org/2000/svg", width: "12", height: "12", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
   /* @__PURE__ */ jsx12("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }),
   /* @__PURE__ */ jsx12("path", { d: "M3 6h18" }),
@@ -2366,6 +2406,7 @@ var DragHandleIcon = () => /* @__PURE__ */ jsxs9("svg", { width: "10", height: "
   /* @__PURE__ */ jsx12("circle", { cx: "2", cy: "12", r: "1.5" }),
   /* @__PURE__ */ jsx12("circle", { cx: "8", cy: "12", r: "1.5" })
 ] });
+var ChevronRightIcon = () => /* @__PURE__ */ jsx12("svg", { xmlns: "http://www.w3.org/2000/svg", width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx12("path", { d: "m9 18 6-6-6-6" }) });
 var HierarchyButton = ({
   isChild,
   isParent,
@@ -2534,11 +2575,16 @@ var TaskListRow = React9.memo(
     const [editingName, setEditingName] = useState4(false);
     const [nameValue, setNameValue] = useState4("");
     const nameInputRef = useRef3(null);
+    const [editingDuration, setEditingDuration] = useState4(false);
+    const [durationValue, setDurationValue] = useState4(getInclusiveDurationDays(task.startDate, task.endDate));
+    const durationInputRef = useRef3(null);
     const [editingProgress, setEditingProgress] = useState4(false);
     const [progressValue, setProgressValue] = useState4(0);
     const progressInputRef = useRef3(null);
     const [overflowOpen, setOverflowOpen] = useState4(false);
-    const confirmedRef = useRef3(false);
+    const nameConfirmedRef = useRef3(false);
+    const durationConfirmedRef = useRef3(false);
+    const progressConfirmedRef = useRef3(false);
     const autoEditedForRef = useRef3(null);
     const editTriggerRef = useRef3("doubleclick");
     const [deletePending, setDeletePending] = useState4(false);
@@ -2593,7 +2639,7 @@ var TaskListRow = React9.memo(
     useEffect3(() => {
       if (editingTaskId === task.id && !disableTaskNameEditing && autoEditedForRef.current !== editingTaskId) {
         autoEditedForRef.current = editingTaskId;
-        confirmedRef.current = false;
+        nameConfirmedRef.current = false;
         editTriggerRef.current = "autoedit";
         setNameValue(task.name);
         setEditingName(true);
@@ -2608,7 +2654,7 @@ var TaskListRow = React9.memo(
     const handleNameDoubleClick = useCallback4((e) => {
       if (disableTaskNameEditing) return;
       e.stopPropagation();
-      confirmedRef.current = false;
+      nameConfirmedRef.current = false;
       editTriggerRef.current = "doubleclick";
       setNameValue(task.name);
       setEditingName(true);
@@ -2617,7 +2663,7 @@ var TaskListRow = React9.memo(
       if (editingProgress) return;
       if (!editingName && !disableTaskNameEditing && e.key === "F2") {
         e.preventDefault();
-        confirmedRef.current = false;
+        nameConfirmedRef.current = false;
         editTriggerRef.current = "keypress";
         setNameValue(task.name);
         setEditingName(true);
@@ -2625,15 +2671,15 @@ var TaskListRow = React9.memo(
       }
       if (!editingName && !disableTaskNameEditing && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
         e.preventDefault();
-        confirmedRef.current = false;
+        nameConfirmedRef.current = false;
         editTriggerRef.current = "keypress";
         setNameValue(e.key);
         setEditingName(true);
       }
     }, [editingName, disableTaskNameEditing, task.name]);
     const handleNameSave = useCallback4(() => {
-      if (confirmedRef.current) {
-        confirmedRef.current = false;
+      if (nameConfirmedRef.current) {
+        nameConfirmedRef.current = false;
         return;
       }
       if (nameValue.trim()) {
@@ -2646,7 +2692,7 @@ var TaskListRow = React9.memo(
     }, []);
     const handleNameKeyDown = useCallback4((e) => {
       if (e.key === "Enter") {
-        confirmedRef.current = true;
+        nameConfirmedRef.current = true;
         if (nameValue.trim()) {
           onTaskChange?.({ ...task, name: nameValue.trim() });
         }
@@ -2655,15 +2701,54 @@ var TaskListRow = React9.memo(
         handleNameCancel();
       }
     }, [nameValue, task, onTaskChange, handleNameCancel]);
+    const handleDurationClick = useCallback4((e) => {
+      if (task.locked) return;
+      e.stopPropagation();
+      durationConfirmedRef.current = false;
+      setDurationValue(getInclusiveDurationDays(task.startDate, task.endDate));
+      setEditingDuration(true);
+    }, [task.locked, task.startDate, task.endDate]);
+    const applyDurationChange = useCallback4((nextDuration) => {
+      const normalizedDuration = Math.max(1, Math.round(nextDuration) || 1);
+      setDurationValue(normalizedDuration);
+    }, []);
+    const handleDurationSave = useCallback4(() => {
+      if (durationConfirmedRef.current) {
+        durationConfirmedRef.current = false;
+        return;
+      }
+      const normalizedDuration = Math.max(1, Math.round(durationValue) || 1);
+      onTaskChange?.({ ...task, endDate: getEndDateFromDuration(task.startDate, normalizedDuration) });
+      setEditingDuration(false);
+    }, [durationValue, task, onTaskChange]);
+    const handleDurationCancel = useCallback4(() => {
+      setDurationValue(getInclusiveDurationDays(task.startDate, task.endDate));
+      setEditingDuration(false);
+    }, [task.startDate, task.endDate]);
+    const handleDurationAdjust = useCallback4((delta) => {
+      applyDurationChange(durationValue + delta);
+    }, [applyDurationChange, durationValue]);
+    const handleDurationKeyDown = useCallback4((e) => {
+      e.stopPropagation();
+      if (e.key === "Enter") {
+        durationConfirmedRef.current = true;
+        const normalizedDuration = Math.max(1, Math.round(durationValue) || 1);
+        onTaskChange?.({ ...task, endDate: getEndDateFromDuration(task.startDate, normalizedDuration) });
+        setEditingDuration(false);
+      } else if (e.key === "Escape") {
+        handleDurationCancel();
+      }
+    }, [durationValue, task, onTaskChange, handleDurationCancel]);
     const handleProgressClick = useCallback4((e) => {
+      if (task.locked) return;
       e.stopPropagation();
-      confirmedRef.current = false;
+      progressConfirmedRef.current = false;
       setProgressValue(task.progress ?? 0);
       setEditingProgress(true);
-    }, [task.progress]);
+    }, [task.progress, task.locked]);
     const handleProgressSave = useCallback4(() => {
-      if (confirmedRef.current) {
-        confirmedRef.current = false;
+      if (progressConfirmedRef.current) {
+        progressConfirmedRef.current = false;
         return;
       }
       const clampedValue = Math.max(0, Math.min(100, progressValue));
@@ -2673,10 +2758,13 @@ var TaskListRow = React9.memo(
     const handleProgressCancel = useCallback4(() => {
       setEditingProgress(false);
     }, []);
+    const handleProgressAdjust = useCallback4((delta) => {
+      setProgressValue((current) => Math.max(0, Math.min(100, current + delta)));
+    }, []);
     const handleProgressKeyDown = useCallback4((e) => {
       e.stopPropagation();
       if (e.key === "Enter") {
-        confirmedRef.current = true;
+        progressConfirmedRef.current = true;
         const clampedValue = Math.max(0, Math.min(100, progressValue));
         onTaskChange?.({ ...task, progress: clampedValue });
         setEditingProgress(false);
@@ -2690,6 +2778,15 @@ var TaskListRow = React9.memo(
         progressInputRef.current.select();
       }
     }, [editingProgress]);
+    useEffect3(() => {
+      setDurationValue(getInclusiveDurationDays(task.startDate, task.endDate));
+    }, [task.startDate, task.endDate]);
+    useEffect3(() => {
+      if (editingDuration && durationInputRef.current) {
+        durationInputRef.current.focus();
+        durationInputRef.current.select();
+      }
+    }, [editingDuration]);
     const handleStartDateChange = useCallback4((newDateISO) => {
       if (!newDateISO) return;
       const origStart = parseUTCDate(task.startDate);
@@ -2754,7 +2851,7 @@ var TaskListRow = React9.memo(
       onChipSelect?.(null);
     }, [selectedChip, onRemoveDependency, onChipSelect]);
     const startDateISO = toISODate(task.startDate);
-    const endDateISO = toISODate(task.endDate);
+    const endDateISO = editingDuration ? getEndDateFromDuration(task.startDate, durationValue) : toISODate(task.endDate);
     return /* @__PURE__ */ jsxs9(
       "div",
       {
@@ -2780,21 +2877,12 @@ var TaskListRow = React9.memo(
         },
         tabIndex: isSelected ? 0 : -1,
         children: [
-          /* @__PURE__ */ jsx12(
+          /* @__PURE__ */ jsxs9(
             "div",
             {
               className: "gantt-tl-cell gantt-tl-cell-number",
               onClick: handleNumberClick,
-              children: isParent ? /* @__PURE__ */ jsx12(
-                "button",
-                {
-                  type: "button",
-                  className: "gantt-tl-collapse-btn",
-                  onClick: handleToggleCollapse,
-                  "aria-label": isCollapsed ? "\u0420\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u0442\u044C" : "\u0421\u0432\u0435\u0440\u043D\u0443\u0442\u044C",
-                  children: isCollapsed ? "+" : "-"
-                }
-              ) : /* @__PURE__ */ jsxs9(Fragment2, { children: [
+              children: [
                 /* @__PURE__ */ jsx12(
                   "span",
                   {
@@ -2810,10 +2898,20 @@ var TaskListRow = React9.memo(
                   }
                 ),
                 /* @__PURE__ */ jsx12("span", { className: "gantt-tl-num-label", children: rowIndex + 1 })
-              ] })
+              ]
             }
           ),
           /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-cell gantt-tl-cell-name", children: [
+            isParent && !editingName && /* @__PURE__ */ jsx12(
+              "button",
+              {
+                type: "button",
+                className: `gantt-tl-collapse-btn ${isCollapsed ? "gantt-tl-collapse-btn-collapsed" : ""}`,
+                onClick: handleToggleCollapse,
+                "aria-label": isCollapsed ? "Expand children" : "Collapse children",
+                children: /* @__PURE__ */ jsx12(ChevronRightIcon, {})
+              }
+            ),
             editingName && /* @__PURE__ */ jsx12(
               Input,
               {
@@ -2823,7 +2921,7 @@ var TaskListRow = React9.memo(
                 onChange: (e) => setNameValue(e.target.value),
                 onBlur: handleNameSave,
                 onKeyDown: handleNameKeyDown,
-                className: "gantt-tl-name-input",
+                className: ["gantt-tl-name-input", isChild ? "gantt-tl-name-input-child" : ""].filter(Boolean).join(" "),
                 onClick: (e) => e.stopPropagation()
               }
             ),
@@ -2831,7 +2929,13 @@ var TaskListRow = React9.memo(
               "button",
               {
                 type: "button",
-                className: `gantt-tl-name-trigger ${disableTaskNameEditing ? "gantt-tl-name-locked" : ""}`,
+                className: [
+                  "gantt-tl-name-trigger",
+                  disableTaskNameEditing ? "gantt-tl-name-locked" : "",
+                  isParent ? "gantt-tl-name-trigger-parent" : "",
+                  isChild ? "gantt-tl-name-trigger-child" : ""
+                ].filter(Boolean).join(" "),
+                title: task.name,
                 onClick: handleNameClick,
                 onDoubleClick: handleNameDoubleClick,
                 style: editingName ? { visibility: "hidden", pointerEvents: "none" } : void 0,
@@ -2920,22 +3024,91 @@ var TaskListRow = React9.memo(
               disabled: task.locked
             }
           ) }),
+          /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-cell gantt-tl-cell-duration", onClick: handleDurationClick, children: [
+            editingDuration && /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-number-editor", onClick: (e) => e.stopPropagation(), children: [
+              /* @__PURE__ */ jsx12(
+                Input,
+                {
+                  ref: durationInputRef,
+                  type: "number",
+                  min: 1,
+                  step: 1,
+                  value: durationValue,
+                  onChange: (e) => applyDurationChange(parseInt(e.target.value, 10) || 1),
+                  onBlur: handleDurationSave,
+                  onKeyDown: handleDurationKeyDown,
+                  className: "gantt-tl-number-input"
+                }
+              ),
+              /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-number-steppers", "aria-hidden": "true", children: [
+                /* @__PURE__ */ jsx12(
+                  "button",
+                  {
+                    type: "button",
+                    className: "gantt-tl-number-stepper",
+                    tabIndex: -1,
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: () => handleDurationAdjust(1),
+                    children: /* @__PURE__ */ jsx12("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx12("path", { d: "m18 15-6-6-6 6" }) })
+                  }
+                ),
+                /* @__PURE__ */ jsx12(
+                  "button",
+                  {
+                    type: "button",
+                    className: "gantt-tl-number-stepper",
+                    tabIndex: -1,
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: () => handleDurationAdjust(-1),
+                    children: /* @__PURE__ */ jsx12("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx12("path", { d: "m6 9 6 6 6-6" }) })
+                  }
+                )
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx12("span", { style: editingDuration ? { visibility: "hidden", pointerEvents: "none" } : void 0, children: getInclusiveDurationDays(task.startDate, task.endDate) })
+          ] }),
           /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-cell gantt-tl-cell-progress", onClick: handleProgressClick, children: [
-            editingProgress && /* @__PURE__ */ jsx12(
-              Input,
-              {
-                ref: progressInputRef,
-                type: "number",
-                min: 0,
-                max: 100,
-                value: progressValue,
-                onChange: (e) => setProgressValue(parseInt(e.target.value) || 0),
-                onBlur: handleProgressSave,
-                onKeyDown: handleProgressKeyDown,
-                className: "gantt-tl-progress-input",
-                onClick: (e) => e.stopPropagation()
-              }
-            ),
+            editingProgress && /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-number-editor", onClick: (e) => e.stopPropagation(), children: [
+              /* @__PURE__ */ jsx12(
+                Input,
+                {
+                  ref: progressInputRef,
+                  type: "number",
+                  min: 0,
+                  max: 100,
+                  step: 1,
+                  value: progressValue,
+                  onChange: (e) => setProgressValue(parseInt(e.target.value, 10) || 0),
+                  onBlur: handleProgressSave,
+                  onKeyDown: handleProgressKeyDown,
+                  className: "gantt-tl-number-input"
+                }
+              ),
+              /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-number-steppers", "aria-hidden": "true", children: [
+                /* @__PURE__ */ jsx12(
+                  "button",
+                  {
+                    type: "button",
+                    className: "gantt-tl-number-stepper",
+                    tabIndex: -1,
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: () => handleProgressAdjust(1),
+                    children: /* @__PURE__ */ jsx12("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx12("path", { d: "m18 15-6-6-6 6" }) })
+                  }
+                ),
+                /* @__PURE__ */ jsx12(
+                  "button",
+                  {
+                    type: "button",
+                    className: "gantt-tl-number-stepper",
+                    tabIndex: -1,
+                    onMouseDown: (e) => e.preventDefault(),
+                    onClick: () => handleProgressAdjust(-1),
+                    children: /* @__PURE__ */ jsx12("svg", { xmlns: "http://www.w3.org/2000/svg", width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx12("path", { d: "m6 9 6 6 6-6" }) })
+                  }
+                )
+              ] })
+            ] }),
             /* @__PURE__ */ jsx12("span", { style: editingProgress ? { visibility: "hidden", pointerEvents: "none" } : void 0, children: task.progress ? `${Math.round(task.progress)}%` : "0%" })
           ] }),
           /* @__PURE__ */ jsx12(
@@ -3092,15 +3265,17 @@ var NewTaskRow = ({ rowHeight, onConfirm, onCancel }) => {
 // src/components/TaskList/TaskList.tsx
 import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
 var LINK_TYPE_ORDER = ["FS", "SS", "FF", "SF"];
+var MIN_TASK_LIST_WIDTH = 640;
 var TaskList = ({
   tasks,
   rowHeight,
   headerHeight,
-  taskListWidth = 542,
+  taskListWidth = 640,
   onTaskChange,
   selectedTaskId,
   onTaskSelect,
   show = true,
+  hasRightShadow = false,
   disableTaskNameEditing = false,
   disableDependencyEditing = false,
   onScrollToTask,
@@ -3239,11 +3414,13 @@ var TaskList = ({
   const [draggingIndex, setDraggingIndex] = useState6(null);
   const [dragOverIndex, setDragOverIndex] = useState6(null);
   const dragOriginIndexRef = useRef5(null);
+  const dragTaskIdRef = useRef5(null);
   const handleDragStart = useCallback5((index, e) => {
     e.dataTransfer.effectAllowed = "move";
     setDraggingIndex(index);
     dragOriginIndexRef.current = index;
-  }, []);
+    dragTaskIdRef.current = visibleTasks[index]?.id ?? null;
+  }, [visibleTasks]);
   const handleDragOver = useCallback5((index, e) => {
     e.preventDefault();
     e.dataTransfer.dropEffect = "move";
@@ -3251,16 +3428,32 @@ var TaskList = ({
   }, []);
   const handleDrop = useCallback5((dropIndex, e) => {
     e.preventDefault();
-    const originIndex = dragOriginIndexRef.current;
-    if (originIndex === null || originIndex === dropIndex) {
+    const originVisibleIndex = dragOriginIndexRef.current;
+    const movedTaskId = dragTaskIdRef.current;
+    if (originVisibleIndex === null || movedTaskId === null || originVisibleIndex === dropIndex) {
+      setDraggingIndex(null);
+      setDragOverIndex(null);
+      dragOriginIndexRef.current = null;
+      dragTaskIdRef.current = null;
+      return;
+    }
+    const reorderPosition = getVisibleReorderPosition(
+      orderedTasks,
+      visibleTasks,
+      movedTaskId,
+      originVisibleIndex,
+      dropIndex
+    );
+    if (!reorderPosition) {
       setDraggingIndex(null);
       setDragOverIndex(null);
       dragOriginIndexRef.current = null;
+      dragTaskIdRef.current = null;
       return;
     }
+    const { originOrderedIndex, insertIndex } = reorderPosition;
     const reordered = [...orderedTasks];
-    const [moved] = reordered.splice(originIndex, 1);
-    const insertIndex = dropIndex === visibleTasks.length ? visibleTasks.length - 1 : originIndex < dropIndex ? dropIndex - 1 : dropIndex;
+    const [moved] = reordered.splice(originOrderedIndex, 1);
     const isChild = !!moved.parentId;
     const isParent = tasks.some((t) => t.parentId === moved.id);
     const taskType = isParent ? "PARENT" : isChild ? "CHILD" : "ROOT";
@@ -3270,10 +3463,11 @@ var TaskList = ({
       name: moved.name,
       type: taskType,
       parentId: moved.parentId,
-      originIndex,
+      originIndex: originOrderedIndex,
+      originVisibleIndex,
       dropIndex,
       insertIndex,
-      direction: originIndex < dropIndex ? "DOWN" : "UP"
+      direction: originVisibleIndex < dropIndex ? "DOWN" : "UP"
     });
     console.log("[TASKS ARRAY LENGTH]", orderedTasks.length);
     let inferredParentId;
@@ -3360,11 +3554,13 @@ var TaskList = ({
     setDraggingIndex(null);
     setDragOverIndex(null);
     dragOriginIndexRef.current = null;
-  }, [orderedTasks, visibleTasks.length, onReorder, onTaskSelect]);
+    dragTaskIdRef.current = null;
+  }, [orderedTasks, visibleTasks, onReorder, onTaskSelect]);
   const handleDragEnd = useCallback5(() => {
     setDraggingIndex(null);
     setDragOverIndex(null);
     dragOriginIndexRef.current = null;
+    dragTaskIdRef.current = null;
   }, []);
   const handleConfirmNewTask = useCallback5((name) => {
     const now = /* @__PURE__ */ new Date();
@@ -3388,18 +3584,20 @@ var TaskList = ({
     setIsCreating(false);
   }, [onAdd]);
   const handleCancelNewTask = useCallback5(() => setIsCreating(false), []);
+  const effectiveTaskListWidth = Math.max(taskListWidth, MIN_TASK_LIST_WIDTH);
   return /* @__PURE__ */ jsx14(
     "div",
     {
       ref: overlayRef,
-      className: `gantt-tl-overlay${show ? "" : " gantt-tl-hidden"}`,
-      style: { width: `${taskListWidth}px` },
+      className: `gantt-tl-overlay${show ? "" : " gantt-tl-hidden"}${hasRightShadow ? " gantt-tl-overlay-shadowed" : ""}`,
+      style: { width: `${effectiveTaskListWidth}px`, minWidth: `${MIN_TASK_LIST_WIDTH}px` },
       children: /* @__PURE__ */ jsxs11("div", { className: "gantt-tl-table", children: [
         /* @__PURE__ */ jsxs11("div", { className: "gantt-tl-header", style: { height: `${headerHeight + 0.5}px` }, children: [
           /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-number", children: "\u2116" }),
           /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-name", children: "\u0418\u043C\u044F" }),
           /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-date", children: "\u041D\u0430\u0447\u0430\u043B\u043E" }),
           /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-date", children: "\u041E\u043A\u043E\u043D\u0447\u0430\u043D\u0438\u0435" }),
+          /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-duration", children: "\u0414\u043D." }),
           /* @__PURE__ */ jsx14("div", { className: "gantt-tl-headerCell gantt-tl-cell-progress", children: "%" }),
           /* @__PURE__ */ jsxs11("div", { className: "gantt-tl-headerCell gantt-tl-cell-deps", style: { position: "relative" }, children: [
             /* @__PURE__ */ jsxs11(Popover, { open: typeMenuOpen, onOpenChange: setTypeMenuOpen, children: [
@@ -3525,7 +3723,7 @@ var GanttChart = forwardRef(({
   disableConstraints,
   onCascade,
   showTaskList = false,
-  taskListWidth = 520,
+  taskListWidth = 660,
   disableTaskNameEditing = false,
   disableDependencyEditing = false,
   highlightExpiredTasks = false,
@@ -3537,6 +3735,7 @@ var GanttChart = forwardRef(({
 }, ref) => {
   const scrollContainerRef = useRef6(null);
   const [selectedTaskId, setSelectedTaskId] = useState7(null);
+  const [taskListHasRightShadow, setTaskListHasRightShadow] = useState7(false);
   const [selectedChip, setSelectedChip] = useState7(null);
   const [collapsedParentIds, setCollapsedParentIds] = useState7(/* @__PURE__ */ new Set());
   const [editingTaskId, setEditingTaskId] = useState7(null);
@@ -3583,6 +3782,18 @@ var GanttChart = forwardRef(({
     const scrollLeft = Math.round(todayOffset - containerWidth / 2 + dayWidth / 2);
     container.scrollLeft = Math.max(0, scrollLeft);
   }, []);
+  useEffect6(() => {
+    const container = scrollContainerRef.current;
+    if (!container) return;
+    const updateShadow = () => {
+      setTaskListHasRightShadow(container.scrollLeft > 0);
+    };
+    updateShadow();
+    container.addEventListener("scroll", updateShadow, { passive: true });
+    return () => {
+      container.removeEventListener("scroll", updateShadow);
+    };
+  }, []);
   const scrollToToday = useCallback6(() => {
     const container = scrollContainerRef.current;
     if (!container || dateRange.length === 0) return;
@@ -3986,6 +4197,7 @@ var GanttChart = forwardRef(({
             selectedTaskId: selectedTaskId ?? void 0,
             onTaskSelect: handleTaskSelect,
             show: showTaskList,
+            hasRightShadow: taskListHasRightShadow,
             disableTaskNameEditing,
             disableDependencyEditing,
             onScrollToTask: scrollToTask,
@@ -4148,6 +4360,7 @@ export {
   getMultiMonthDays,
   getSuccessorChain,
   getTransitiveCascadeChain,
+  getVisibleReorderPosition,
   isTaskParent,
   isToday,
   isWeekend,