gantt-lib 0.74.0 → 0.75.1

package/dist/index.mjs

@@ -492,7 +492,7 @@ var init_dateUtils = __esm({
 
 // src/components/GanttChart/GanttChart.tsx
 init_dateUtils();
-import { useMemo as useMemo9, useCallback as useCallback6, useRef as useRef7, useState as useState7, useEffect as useEffect7, useImperativeHandle, forwardRef } from "react";
+import { useMemo as useMemo10, useCallback as useCallback8, useRef as useRef9, useState as useState8, useEffect as useEffect9, useImperativeHandle, forwardRef } from "react";
 
 // src/core/scheduling/index.ts
 init_dateMath();
@@ -637,13 +637,13 @@ function computeParentProgress(parentId, tasks) {
   if (children.length === 0) {
     return 0;
   }
-  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  const DAY_MS4 = 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_MS3) / DAY_MS3;
+    const duration = (end - start + DAY_MS4) / DAY_MS4;
     const progress = child.progress ?? 0;
     totalWeight += duration;
     weightedSum += duration * progress;
@@ -738,10 +738,10 @@ function buildTaskRangeFromStart(startDate, duration, businessDays = false, week
       end: parseDateOnly(addBusinessDays(normalizedStart, duration, weekendPredicate))
     };
   }
-  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  const DAY_MS4 = 24 * 60 * 60 * 1e3;
   return {
     start: normalizedStart,
-    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS3)
+    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS4)
   };
 }
 function buildTaskRangeFromEnd(endDate, duration, businessDays = false, weekendPredicate, snapDirection = -1) {
@@ -752,9 +752,9 @@ function buildTaskRangeFromEnd(endDate, duration, businessDays = false, weekendP
       end: normalizedEnd
     };
   }
-  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  const DAY_MS4 = 24 * 60 * 60 * 1e3;
   return {
-    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS3),
+    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS4),
     end: normalizedEnd
   };
 }
@@ -4088,21 +4088,56 @@ var LINK_TYPE_LABELS = {
   SF: "\u041D\u0430\u0447\u0430\u043B\u043E-\u043E\u043A\u043E\u043D\u0447\u0430\u043D\u0438\u0435"
 };
 
+// src/components/TaskList/defaultTaskDates.ts
+init_dateUtils();
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DEFAULT_TASK_DURATION_DAYS = 5;
+function toISODate(date) {
+  return date.toISOString().split("T")[0];
+}
+function getTodayISODate() {
+  const now = /* @__PURE__ */ new Date();
+  return toISODate(new Date(Date.UTC(
+    now.getUTCFullYear(),
+    now.getUTCMonth(),
+    now.getUTCDate()
+  )));
+}
+function buildDefaultTaskDateRange(startDate, {
+  businessDays,
+  defaultTaskDurationDays = DEFAULT_TASK_DURATION_DAYS,
+  weekendPredicate
+} = {}) {
+  const durationDays = Math.max(1, Math.round(defaultTaskDurationDays));
+  const start = parseUTCDate(startDate);
+  if (businessDays && weekendPredicate) {
+    const range = buildTaskRangeFromStart(start, durationDays, true, weekendPredicate);
+    return {
+      startDate: toISODate(range.start),
+      endDate: toISODate(range.end)
+    };
+  }
+  return {
+    startDate: toISODate(start),
+    endDate: toISODate(new Date(start.getTime() + (durationDays - 1) * DAY_MS2))
+  };
+}
+
 // src/components/TaskList/TaskListRow.tsx
 import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
-var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DAY_MS3 = 24 * 60 * 60 * 1e3;
 var LINK_TYPE_ORDER = ["FS", "SS", "FF", "SF"];
 var getInclusiveDurationDays = (startDate, endDate) => {
   const start = parseUTCDate(startDate);
   const end = parseUTCDate(endDate);
   return Math.max(
     1,
-    Math.round((end.getTime() - start.getTime()) / DAY_MS2) + 1
+    Math.round((end.getTime() - start.getTime()) / DAY_MS3) + 1
   );
 };
 var getEndDateFromDuration = (startDate, durationDays) => {
   const start = parseUTCDate(startDate);
-  return new Date(start.getTime() + (durationDays - 1) * DAY_MS2).toISOString().split("T")[0];
+  return new Date(start.getTime() + (durationDays - 1) * DAY_MS3).toISOString().split("T")[0];
 };
 var TrashIcon = () => /* @__PURE__ */ jsxs9(
   "svg",
@@ -4587,7 +4622,7 @@ var DepChip = ({
     )
   ] });
 };
-var toISODate = (value) => {
+var toISODate2 = (value) => {
   if (value instanceof Date) return value.toISOString().split("T")[0];
   if (typeof value === "string" && value.includes("T"))
     return value.split("T")[0];
@@ -4641,6 +4676,7 @@ var TaskListRow = React9.memo(
     customDays,
     isWeekend: isWeekend3,
     businessDays,
+    defaultTaskDurationDays = DEFAULT_TASK_DURATION_DAYS,
     isFilterMatch = false,
     isFilterHideMode = false,
     resolvedColumns,
@@ -5448,8 +5484,8 @@ var TaskListRow = React9.memo(
       },
       [selectedChip?.successorId, selectedChip?.predecessorId, selectedChip?.linkType, onRemoveDependency, onChipSelect]
     );
-    const startDateISO = toISODate(normalizedTask.startDate);
-    const endDateISO = editingDuration ? getEndDate(normalizedTask.startDate, durationValue) : toISODate(normalizedTask.endDate);
+    const startDateISO = toISODate2(normalizedTask.startDate);
+    const endDateISO = editingDuration ? getEndDate(normalizedTask.startDate, durationValue) : toISODate2(normalizedTask.endDate);
     const numberCell = /* @__PURE__ */ jsxs9(
       "div",
       {
@@ -5667,26 +5703,16 @@ var TaskListRow = React9.memo(
             className: "gantt-tl-name-action-btn gantt-tl-action-insert",
             onClick: (e) => {
               e.stopPropagation();
-              const now = /* @__PURE__ */ new Date();
-              const todayISO = new Date(
-                Date.UTC(
-                  now.getUTCFullYear(),
-                  now.getUTCMonth(),
-                  now.getUTCDate()
-                )
-              ).toISOString().split("T")[0];
-              const endISO = new Date(
-                Date.UTC(
-                  now.getUTCFullYear(),
-                  now.getUTCMonth(),
-                  now.getUTCDate() + 7
-                )
-              ).toISOString().split("T")[0];
+              const range = buildDefaultTaskDateRange(getTodayISODate(), {
+                businessDays,
+                defaultTaskDurationDays,
+                weekendPredicate
+              });
               const newTask = {
                 id: crypto.randomUUID(),
                 name: "\u041D\u043E\u0432\u0430\u044F \u0437\u0430\u0434\u0430\u0447\u0430",
-                startDate: todayISO,
-                endDate: endISO,
+                startDate: range.startDate,
+                endDate: range.endDate,
                 parentId: task.parentId
               };
               onInsertAfter(task.id, newTask);
@@ -6515,6 +6541,7 @@ var TaskList = ({
   onReorder,
   editingTaskId: propEditingTaskId,
   enableAddTask = true,
+  defaultTaskDurationDays = DEFAULT_TASK_DURATION_DAYS,
   collapsedParentIds: externalCollapsedParentIds,
   onToggleCollapse: externalOnToggleCollapse,
   onPromoteTask,
@@ -6917,26 +6944,20 @@ var TaskList = ({
     dragTaskIdRef.current = null;
   }, []);
   const handleConfirmNewTask = useCallback5((name) => {
-    const now = /* @__PURE__ */ new Date();
-    const todayISO = new Date(Date.UTC(
-      now.getUTCFullYear(),
-      now.getUTCMonth(),
-      now.getUTCDate()
-    )).toISOString().split("T")[0];
-    const endISO = new Date(Date.UTC(
-      now.getUTCFullYear(),
-      now.getUTCMonth(),
-      now.getUTCDate() + 7
-    )).toISOString().split("T")[0];
+    const range = buildDefaultTaskDateRange(getTodayISODate(), {
+      businessDays,
+      defaultTaskDurationDays,
+      weekendPredicate
+    });
     const newTask = {
       id: crypto.randomUUID(),
       name,
-      startDate: todayISO,
-      endDate: endISO
+      startDate: range.startDate,
+      endDate: range.endDate
     };
     onAdd?.(newTask);
     setIsCreating(false);
-  }, [onAdd]);
+  }, [businessDays, defaultTaskDurationDays, onAdd, weekendPredicate]);
   const handleCancelNewTask = useCallback5(() => setIsCreating(false), []);
   const findInsertAfterTaskId = useCallback5((anchorTaskId) => {
     const anchorIndex = orderedTasks.findIndex((task) => task.id === anchorTaskId);
@@ -7202,6 +7223,7 @@ var TaskList = ({
                 customDays,
                 isWeekend: isWeekend3,
                 businessDays,
+                defaultTaskDurationDays,
                 isFilterMatch: filterMode === "highlight" ? highlightedTaskIds.has(task.id) : false,
                 isFilterHideMode: filterMode === "hide" && isFilterActive,
                 resolvedColumns,
@@ -7262,6 +7284,522 @@ var TaskList = ({
   );
 };
 
+// src/components/ResourceTimelineChart/ResourceTimelineChart.tsx
+init_dateUtils();
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo9, useRef as useRef8 } from "react";
+
+// src/utils/resourceTimelineLayout.ts
+init_dateUtils();
+var isInvalidDate = (date) => Number.isNaN(date.getTime());
+var getUTCDayNumber = (date) => {
+  return Math.floor(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) / 864e5);
+};
+var compareParsedItems = (a, b) => {
+  const startDiff = getUTCDayNumber(a.startDate) - getUTCDayNumber(b.startDate);
+  if (startDiff !== 0) {
+    return startDiff;
+  }
+  const endDiff = getUTCDayNumber(a.endDate) - getUTCDayNumber(b.endDate);
+  if (endDiff !== 0) {
+    return endDiff;
+  }
+  return a.item.id.localeCompare(b.item.id);
+};
+var layoutResourceTimelineItems = (resources, options) => {
+  const rows = [];
+  const items = [];
+  const diagnostics = [];
+  let currentTop = 0;
+  for (const resource of resources) {
+    const parsedItems = [];
+    for (const item of resource.items) {
+      try {
+        const startDate = parseUTCDate(item.startDate);
+        const endDate = parseUTCDate(item.endDate);
+        if (isInvalidDate(startDate) || isInvalidDate(endDate)) {
+          throw new Error("Invalid date");
+        }
+        parsedItems.push({ item, startDate, endDate });
+      } catch {
+        diagnostics.push({
+          itemId: item.id,
+          resourceId: resource.id,
+          reason: "invalid-date"
+        });
+      }
+    }
+    parsedItems.sort(compareParsedItems);
+    const laneEndDays = [];
+    const laidOutItems = [];
+    for (const parsed of parsedItems) {
+      const startDay = getUTCDayNumber(parsed.startDate);
+      const endDay = getUTCDayNumber(parsed.endDate);
+      let laneIndex = laneEndDays.findIndex((laneEndDay) => laneEndDay < startDay);
+      if (laneIndex === -1) {
+        laneIndex = laneEndDays.length;
+        laneEndDays.push(endDay);
+      } else {
+        laneEndDays[laneIndex] = endDay;
+      }
+      const { left, width } = calculateTaskBar(parsed.startDate, parsed.endDate, options.monthStart, options.dayWidth);
+      laidOutItems.push({
+        item: parsed.item,
+        itemId: parsed.item.id,
+        resourceId: resource.id,
+        laneIndex,
+        left,
+        width,
+        resourceRowTop: currentTop,
+        resourceRowHeight: 0,
+        top: currentTop + laneIndex * options.laneHeight,
+        height: options.laneHeight,
+        startDate: parsed.startDate,
+        endDate: parsed.endDate
+      });
+    }
+    const laneCount = Math.max(1, laneEndDays.length);
+    const resourceRowHeight = laneCount * options.laneHeight;
+    const row = {
+      resource,
+      resourceId: resource.id,
+      laneCount,
+      resourceRowTop: currentTop,
+      resourceRowHeight
+    };
+    rows.push(row);
+    items.push(...laidOutItems.map((item) => ({
+      ...item,
+      resourceRowHeight
+    })));
+    currentTop += resourceRowHeight;
+  }
+  return {
+    rows,
+    items,
+    diagnostics,
+    totalHeight: currentTop
+  };
+};
+
+// src/hooks/useResourceItemDrag.ts
+import { useCallback as useCallback6, useEffect as useEffect7, useRef as useRef7, useState as useState7 } from "react";
+var snapToDay = (pixels, dayWidth) => {
+  return Math.round(pixels / dayWidth) * dayWidth;
+};
+var addUTCDays = (date, days) => {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days));
+};
+var resolveTargetResource = (rows, clientY, gridTop) => {
+  const localY = clientY - gridTop;
+  return rows.find(
+    (row) => localY >= row.resourceRowTop && localY < row.resourceRowTop + row.resourceRowHeight
+  )?.resource ?? null;
+};
+var useResourceItemDrag = ({
+  dayWidth,
+  rows,
+  gridElementRef,
+  readonly,
+  disableResourceReassignment,
+  onResourceItemMove
+}) => {
+  const activeDragRef = useRef7(null);
+  const rowsRef = useRef7(rows);
+  const onResourceItemMoveRef = useRef7(onResourceItemMove);
+  const rafRef = useRef7(null);
+  const [preview, setPreview] = useState7(null);
+  useEffect7(() => {
+    rowsRef.current = rows;
+  }, [rows]);
+  useEffect7(() => {
+    onResourceItemMoveRef.current = onResourceItemMove;
+  }, [onResourceItemMove]);
+  const clearRaf = useCallback6(() => {
+    if (rafRef.current !== null) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
+  }, []);
+  const cancelDrag2 = useCallback6(() => {
+    clearRaf();
+    activeDragRef.current = null;
+    setPreview(null);
+  }, [clearRaf]);
+  useEffect7(() => {
+    const handleMouseMove = (event) => {
+      const activeDrag = activeDragRef.current;
+      if (!activeDrag || rafRef.current !== null) {
+        return;
+      }
+      rafRef.current = requestAnimationFrame(() => {
+        rafRef.current = null;
+        const latestDrag = activeDragRef.current;
+        if (!latestDrag) {
+          return;
+        }
+        const nextLeft = latestDrag.initialLeft + snapToDay(event.clientX - latestDrag.startX, latestDrag.dayWidth);
+        const nextTop = disableResourceReassignment ? latestDrag.initialTop : latestDrag.initialTop + (event.clientY - latestDrag.startY);
+        latestDrag.currentLeft = nextLeft;
+        latestDrag.currentTop = nextTop;
+        setPreview({
+          itemId: latestDrag.itemId,
+          left: nextLeft,
+          top: nextTop
+        });
+      });
+    };
+    const handleMouseUp = (event) => {
+      const activeDrag = activeDragRef.current;
+      if (!activeDrag) {
+        return;
+      }
+      clearRaf();
+      activeDragRef.current = null;
+      setPreview(null);
+      const gridTop = gridElementRef?.current?.getBoundingClientRect().top ?? 0;
+      const targetResource = disableResourceReassignment ? rowsRef.current.find((row) => row.resourceId === activeDrag.fromResourceId)?.resource ?? null : resolveTargetResource(rowsRef.current, event.clientY, gridTop);
+      if (!targetResource) {
+        return;
+      }
+      const dayDelta = Math.round((activeDrag.currentLeft - activeDrag.initialLeft) / activeDrag.dayWidth);
+      onResourceItemMoveRef.current?.({
+        item: activeDrag.item,
+        itemId: activeDrag.itemId,
+        fromResourceId: activeDrag.fromResourceId,
+        toResourceId: targetResource.id,
+        startDate: addUTCDays(activeDrag.startDate, dayDelta),
+        endDate: addUTCDays(activeDrag.endDate, dayDelta)
+      });
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+      cancelDrag2();
+    };
+  }, [cancelDrag2, clearRaf, disableResourceReassignment, gridElementRef]);
+  const startDrag = useCallback6((event, layoutItem) => {
+    if (readonly || layoutItem.item.locked || event.button !== 0) {
+      return;
+    }
+    event.preventDefault();
+    activeDragRef.current = {
+      item: layoutItem.item,
+      itemId: layoutItem.itemId,
+      fromResourceId: layoutItem.resourceId,
+      startX: event.clientX,
+      startY: event.clientY,
+      initialLeft: layoutItem.left,
+      initialTop: layoutItem.top,
+      currentLeft: layoutItem.left,
+      currentTop: layoutItem.top,
+      dayWidth,
+      startDate: layoutItem.startDate,
+      endDate: layoutItem.endDate
+    };
+    setPreview({
+      itemId: layoutItem.itemId,
+      left: layoutItem.left,
+      top: layoutItem.top
+    });
+  }, [dayWidth, readonly]);
+  return {
+    preview,
+    startDrag,
+    cancelDrag: cancelDrag2
+  };
+};
+
+// src/components/ResourceTimelineChart/ResourceTimelineChart.tsx
+import { Fragment as Fragment3, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+var DEFAULT_DAY_WIDTH = 40;
+var DEFAULT_HEADER_HEIGHT = 40;
+var DEFAULT_LANE_HEIGHT = 40;
+var DEFAULT_ROW_HEADER_WIDTH = 240;
+var ITEM_OUTER_VERTICAL_INSET = 2;
+var ITEM_INNER_VERTICAL_INSET = 1;
+var ITEM_HORIZONTAL_INSET = 1;
+var isValidDate = (date) => !Number.isNaN(date.getTime());
+var getResourceTimelineDays = (items) => {
+  if (items.length === 0) {
+    return getMonthDays(/* @__PURE__ */ new Date());
+  }
+  let minDate = null;
+  let maxDate = null;
+  for (const item of items) {
+    const startDate = parseUTCDate(item.startDate);
+    const endDate = parseUTCDate(item.endDate);
+    if (!minDate || startDate.getTime() < minDate.getTime()) {
+      minDate = startDate;
+    }
+    if (!maxDate || endDate.getTime() > maxDate.getTime()) {
+      maxDate = endDate;
+    }
+  }
+  if (!minDate || !maxDate) {
+    return getMonthDays(/* @__PURE__ */ new Date());
+  }
+  const startOfMonth2 = new Date(Date.UTC(minDate.getUTCFullYear(), minDate.getUTCMonth(), 1));
+  const endOfMonth = new Date(Date.UTC(maxDate.getUTCFullYear(), maxDate.getUTCMonth() + 1, 0));
+  const days = [];
+  const current = new Date(startOfMonth2);
+  while (current.getTime() <= endOfMonth.getTime()) {
+    days.push(new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), current.getUTCDate())));
+    current.setUTCDate(current.getUTCDate() + 1);
+  }
+  return days;
+};
+var collectValidItems = (resources) => {
+  return resources.flatMap(
+    (resource) => resource.items.flatMap((item) => {
+      try {
+        const startDate = parseUTCDate(item.startDate);
+        const endDate = parseUTCDate(item.endDate);
+        if (!isValidDate(startDate) || !isValidDate(endDate)) {
+          return [];
+        }
+        return [{ startDate, endDate }];
+      } catch {
+        return [];
+      }
+    })
+  );
+};
+var getVisualItemGeometry = (geometry, laneIndex, laneCount) => {
+  const topInset = laneIndex === 0 ? ITEM_OUTER_VERTICAL_INSET : ITEM_INNER_VERTICAL_INSET;
+  const bottomInset = laneIndex === laneCount - 1 ? ITEM_OUTER_VERTICAL_INSET : ITEM_INNER_VERTICAL_INSET;
+  return {
+    left: geometry.left + ITEM_HORIZONTAL_INSET,
+    top: geometry.top + topInset,
+    width: Math.max(0, geometry.width - ITEM_HORIZONTAL_INSET * 2),
+    height: Math.max(0, geometry.height - topInset - bottomInset)
+  };
+};
+function ResourceTimelineChart({
+  resources,
+  dayWidth = DEFAULT_DAY_WIDTH,
+  rowHeaderWidth = DEFAULT_ROW_HEADER_WIDTH,
+  laneHeight = DEFAULT_LANE_HEIGHT,
+  headerHeight = DEFAULT_HEADER_HEIGHT,
+  readonly,
+  disableResourceReassignment,
+  renderItem,
+  getItemClassName,
+  onResourceItemMove
+}) {
+  const scrollContainerRef = useRef8(null);
+  const gridRef = useRef8(null);
+  const panStateRef = useRef8(null);
+  const validItems = useMemo9(() => collectValidItems(resources), [resources]);
+  const dateRange = useMemo9(() => {
+    return getResourceTimelineDays(validItems);
+  }, [validItems]);
+  const monthStart = useMemo9(() => {
+    const firstDay = dateRange[0] ?? /* @__PURE__ */ new Date();
+    return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
+  }, [dateRange]);
+  const gridWidth = useMemo9(() => Math.round(dateRange.length * dayWidth), [dateRange.length, dayWidth]);
+  const layout = useMemo9(
+    () => layoutResourceTimelineItems(resources, { monthStart, dayWidth, laneHeight }),
+    [resources, monthStart, dayWidth, laneHeight]
+  );
+  const todayInRange = useMemo9(() => {
+    const now = /* @__PURE__ */ new Date();
+    const today = new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()));
+    return dateRange.some((day) => day.getTime() === today.getTime());
+  }, [dateRange]);
+  const itemsByResourceId = useMemo9(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of layout.items) {
+      const next = map.get(item.resourceId) ?? [];
+      next.push(item);
+      map.set(item.resourceId, next);
+    }
+    return map;
+  }, [layout.items]);
+  const { preview, startDrag } = useResourceItemDrag({
+    dayWidth,
+    rows: layout.rows,
+    gridElementRef: gridRef,
+    readonly,
+    disableResourceReassignment,
+    onResourceItemMove
+  });
+  const handlePanStart = useCallback7((event) => {
+    if (event.button !== 0) {
+      return;
+    }
+    const target = event.target;
+    if (target.closest("[data-resource-item-id]")) {
+      return;
+    }
+    if (target.closest("input, button, textarea, [contenteditable]")) {
+      return;
+    }
+    const container = scrollContainerRef.current;
+    if (!container) {
+      return;
+    }
+    panStateRef.current = {
+      active: true,
+      startX: event.clientX,
+      startY: event.clientY,
+      scrollX: container.scrollLeft,
+      scrollY: container.scrollTop
+    };
+    if (document.activeElement instanceof HTMLElement) {
+      document.activeElement.blur();
+    }
+    container.style.cursor = "grabbing";
+    event.preventDefault();
+  }, []);
+  useEffect8(() => {
+    const handlePanMove = (event) => {
+      const pan = panStateRef.current;
+      const container = scrollContainerRef.current;
+      if (!pan?.active || !container) {
+        return;
+      }
+      container.scrollLeft = pan.scrollX - (event.clientX - pan.startX);
+      container.scrollTop = pan.scrollY - (event.clientY - pan.startY);
+    };
+    const handlePanEnd = () => {
+      if (!panStateRef.current?.active) {
+        return;
+      }
+      panStateRef.current = null;
+      const container = scrollContainerRef.current;
+      if (container) {
+        container.style.cursor = "";
+      }
+    };
+    window.addEventListener("mousemove", handlePanMove);
+    window.addEventListener("mouseup", handlePanEnd);
+    return () => {
+      window.removeEventListener("mousemove", handlePanMove);
+      window.removeEventListener("mouseup", handlePanEnd);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx15("div", { className: "gantt-container gantt-resourceTimeline", children: /* @__PURE__ */ jsx15(
+    "div",
+    {
+      ref: scrollContainerRef,
+      className: "gantt-resourceTimeline-scrollContainer",
+      style: { cursor: "grab" },
+      onMouseDown: handlePanStart,
+      children: /* @__PURE__ */ jsxs12("div", { className: "gantt-resourceTimeline-scrollContent", children: [
+        /* @__PURE__ */ jsxs12(
+          "div",
+          {
+            className: "gantt-resourceTimeline-resourceColumn",
+            style: { width: `${rowHeaderWidth}px`, minWidth: `${rowHeaderWidth}px` },
+            children: [
+              /* @__PURE__ */ jsx15(
+                "div",
+                {
+                  className: "gantt-resourceTimeline-corner",
+                  style: { height: `${headerHeight}px` }
+                }
+              ),
+              layout.rows.map((row) => /* @__PURE__ */ jsx15(
+                "div",
+                {
+                  className: "gantt-resourceTimeline-resourceHeader",
+                  "data-resource-row-id": row.resourceId,
+                  style: { height: `${row.resourceRowHeight}px` },
+                  children: /* @__PURE__ */ jsx15("span", { className: "gantt-resourceTimeline-resourceName", children: row.resource.name })
+                },
+                row.resourceId
+              ))
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs12(
+          "div",
+          {
+            className: "gantt-resourceTimeline-chartSurface",
+            style: { minWidth: `${gridWidth}px` },
+            children: [
+              /* @__PURE__ */ jsx15("div", { className: "gantt-resourceTimeline-stickyHeader", style: { width: `${gridWidth}px` }, children: /* @__PURE__ */ jsx15(TimeScaleHeader_default, { days: dateRange, dayWidth, headerHeight }) }),
+              /* @__PURE__ */ jsxs12(
+                "div",
+                {
+                  ref: gridRef,
+                  className: "gantt-resourceTimeline-grid",
+                  style: { width: `${gridWidth}px`, height: `${layout.totalHeight}px` },
+                  children: [
+                    /* @__PURE__ */ jsx15(GridBackground_default, { dateRange, dayWidth, totalHeight: layout.totalHeight }),
+                    todayInRange && /* @__PURE__ */ jsx15(TodayIndicator_default, { monthStart, dayWidth }),
+                    layout.rows.map((row) => /* @__PURE__ */ jsx15(
+                      "div",
+                      {
+                        className: "gantt-resourceTimeline-row",
+                        "data-resource-row-id": row.resourceId,
+                        style: {
+                          top: `${row.resourceRowTop}px`,
+                          height: `${row.resourceRowHeight}px`
+                        }
+                      },
+                      row.resourceId
+                    )),
+                    Array.from(itemsByResourceId.values()).flatMap(
+                      (resourceItems) => resourceItems.map((layoutItem) => {
+                        const customClassName = getItemClassName?.(layoutItem.item);
+                        const className = [
+                          "gantt-resourceTimeline-item",
+                          preview?.itemId === layoutItem.itemId && "gantt-resourceTimeline-itemDragging",
+                          (readonly || layoutItem.item.locked) && "gantt-resourceTimeline-itemDisabled",
+                          customClassName
+                        ].filter(Boolean).join(" ");
+                        const laneCount = Math.max(1, Math.round(layoutItem.resourceRowHeight / layoutItem.height));
+                        const previewStyle = preview?.itemId === layoutItem.itemId ? getVisualItemGeometry({
+                          left: preview.left,
+                          top: preview.top,
+                          width: layoutItem.width,
+                          height: layoutItem.height
+                        }, layoutItem.laneIndex, laneCount) : void 0;
+                        const itemGeometry = getVisualItemGeometry({
+                          left: layoutItem.left,
+                          top: layoutItem.top,
+                          width: layoutItem.width,
+                          height: layoutItem.height
+                        }, layoutItem.laneIndex, laneCount);
+                        return /* @__PURE__ */ jsx15(
+                          "div",
+                          {
+                            className,
+                            "data-resource-item-id": layoutItem.itemId,
+                            onMouseDown: (event) => startDrag(event, layoutItem),
+                            style: {
+                              left: `${itemGeometry.left}px`,
+                              top: `${itemGeometry.top}px`,
+                              ...previewStyle,
+                              width: `${itemGeometry.width}px`,
+                              height: `${itemGeometry.height}px`,
+                              backgroundColor: layoutItem.item.color ?? "var(--gantt-task-bar-default-color, #3b82f6)"
+                            },
+                            children: /* @__PURE__ */ jsx15("div", { className: "gantt-resourceTimeline-itemInner", children: renderItem ? renderItem(layoutItem.item) : /* @__PURE__ */ jsxs12(Fragment3, { children: [
+                              /* @__PURE__ */ jsx15("span", { className: "gantt-resourceTimeline-itemTitle", children: layoutItem.item.title }),
+                              layoutItem.item.subtitle && /* @__PURE__ */ jsx15("span", { className: "gantt-resourceTimeline-itemSubtitle", children: layoutItem.item.subtitle }),
+                              /* @__PURE__ */ jsx15("span", { className: "gantt-resourceTimeline-itemDates", children: formatDateRangeLabel(layoutItem.startDate, layoutItem.endDate) })
+                            ] }) })
+                          },
+                          layoutItem.itemId
+                        );
+                      })
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        )
+      ] })
+    }
+  ) });
+}
+
 // src/components/GanttChart/print.ts
 function getPrintDocumentTitle({
   header,
@@ -7600,9 +8138,21 @@ async function printGanttChart({
 }
 
 // src/components/GanttChart/GanttChart.tsx
-import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
 var SCROLL_TO_ROW_CONTEXT_ROWS = 2;
 function GanttChartInner(props, ref) {
+  if (props.mode === "resource-planner") {
+    return /* @__PURE__ */ jsx16(ResourceTimelineChart, { ...props });
+  }
+  return /* @__PURE__ */ jsx16(
+    TaskGanttChart,
+    {
+      ...props,
+      ref
+    }
+  );
+}
+function TaskGanttChartInner(props, ref) {
   const {
     tasks,
     dayWidth = 40,
@@ -7628,6 +8178,7 @@ function GanttChartInner(props, ref) {
     onDemoteTask,
     onUngroupTask,
     enableAddTask = true,
+    defaultTaskDurationDays,
     viewMode = "day",
     customDays,
     isWeekend: isWeekend3,
@@ -7642,28 +8193,28 @@ function GanttChartInner(props, ref) {
     additionalColumns,
     taskListMenuCommands
   } = props;
-  const containerRef = useRef7(null);
-  const scrollContainerRef = useRef7(null);
-  const scrollContentRef = useRef7(null);
-  const [selectedTaskId, setSelectedTaskId] = useState7(null);
-  const [taskListHasRightShadow, setTaskListHasRightShadow] = useState7(false);
-  const [selectedChip, setSelectedChip] = useState7(null);
-  const [internalCollapsedParentIds, setInternalCollapsedParentIds] = useState7(/* @__PURE__ */ new Set());
+  const containerRef = useRef9(null);
+  const scrollContainerRef = useRef9(null);
+  const scrollContentRef = useRef9(null);
+  const [selectedTaskId, setSelectedTaskId] = useState8(null);
+  const [taskListHasRightShadow, setTaskListHasRightShadow] = useState8(false);
+  const [selectedChip, setSelectedChip] = useState8(null);
+  const [internalCollapsedParentIds, setInternalCollapsedParentIds] = useState8(/* @__PURE__ */ new Set());
   const collapsedParentIds = externalCollapsedParentIds ?? internalCollapsedParentIds;
-  const [editingTaskId, setEditingTaskId] = useState7(null);
-  const normalizedTasks = useMemo9(() => normalizeHierarchyTasks(tasks), [tasks]);
-  const isCustomWeekend = useMemo9(
+  const [editingTaskId, setEditingTaskId] = useState8(null);
+  const normalizedTasks = useMemo10(() => normalizeHierarchyTasks(tasks), [tasks]);
+  const isCustomWeekend = useMemo10(
     () => createCustomDayPredicate({ customDays, isWeekend: isWeekend3 }),
     [customDays, isWeekend3]
   );
-  const dateRange = useMemo9(() => getMultiMonthDays(normalizedTasks), [normalizedTasks]);
-  const [validationResult, setValidationResult] = useState7(null);
-  const [cascadeOverrides, setCascadeOverrides] = useState7(/* @__PURE__ */ new Map());
-  const gridWidth = useMemo9(
+  const dateRange = useMemo10(() => getMultiMonthDays(normalizedTasks), [normalizedTasks]);
+  const [validationResult, setValidationResult] = useState8(null);
+  const [cascadeOverrides, setCascadeOverrides] = useState8(/* @__PURE__ */ new Map());
+  const gridWidth = useMemo10(
     () => Math.round(dateRange.length * dayWidth),
     [dateRange.length, dayWidth]
   );
-  const visibleTasks = useMemo9(() => {
+  const visibleTasks = useMemo10(() => {
     const parentMap = new Map(normalizedTasks.map((t) => [t.id, t.parentId]));
     function isAnyAncestorCollapsed(parentId) {
       let current = parentId;
@@ -7679,11 +8230,11 @@ function GanttChartInner(props, ref) {
     }
     return tasks2;
   }, [normalizedTasks, collapsedParentIds, filterMode, taskFilter]);
-  const matchedTaskIds = useMemo9(() => {
+  const matchedTaskIds = useMemo10(() => {
     if (!taskFilter) return /* @__PURE__ */ new Set();
     return new Set(visibleTasks.filter(taskFilter).map((task) => task.id));
   }, [visibleTasks, taskFilter]);
-  const taskListHighlightedTaskIds = useMemo9(() => {
+  const taskListHighlightedTaskIds = useMemo10(() => {
     if (filterMode === "hide") {
       return /* @__PURE__ */ new Set();
     }
@@ -7694,23 +8245,23 @@ function GanttChartInner(props, ref) {
     matchedTaskIds.forEach((taskId) => mergedHighlightedTaskIds.add(taskId));
     return mergedHighlightedTaskIds;
   }, [filterMode, highlightedTaskIds, matchedTaskIds]);
-  const totalGridHeight = useMemo9(
+  const totalGridHeight = useMemo10(
     () => visibleTasks.length * rowHeight,
     [visibleTasks.length, rowHeight]
   );
-  const monthStart = useMemo9(() => {
+  const monthStart = useMemo10(() => {
     if (dateRange.length === 0) {
       return new Date(Date.UTC((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth(), 1));
     }
     const firstDay = dateRange[0];
     return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
   }, [dateRange]);
-  const todayInRange = useMemo9(() => {
+  const todayInRange = useMemo10(() => {
     const now = /* @__PURE__ */ new Date();
     const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
     return dateRange.some((day) => day.getTime() === today.getTime());
   }, [dateRange]);
-  useEffect7(() => {
+  useEffect9(() => {
     const container = scrollContainerRef.current;
     if (!container || dateRange.length === 0) return;
     const now = /* @__PURE__ */ new Date();
@@ -7722,7 +8273,7 @@ function GanttChartInner(props, ref) {
     const scrollLeft = Math.round(todayOffset + dayWidth / 2 - containerWidth * 0.3);
     container.scrollLeft = Math.max(0, scrollLeft);
   }, []);
-  useEffect7(() => {
+  useEffect9(() => {
     const container = scrollContainerRef.current;
     if (!container) return;
     const updateShadow = () => {
@@ -7734,7 +8285,7 @@ function GanttChartInner(props, ref) {
       container.removeEventListener("scroll", updateShadow);
     };
   }, []);
-  const scrollToToday = useCallback6(() => {
+  const scrollToToday = useCallback8(() => {
     const container = scrollContainerRef.current;
     if (!container || dateRange.length === 0) return;
     const now = /* @__PURE__ */ new Date();
@@ -7746,7 +8297,7 @@ function GanttChartInner(props, ref) {
     const scrollLeft = Math.round(todayOffset + dayWidth / 2 - containerWidth * 0.3);
     container.scrollTo({ left: Math.max(0, scrollLeft), behavior: "smooth" });
   }, [dateRange, dayWidth]);
-  const scrollToTask = useCallback6((taskId) => {
+  const scrollToTask = useCallback8((taskId) => {
     const container = scrollContainerRef.current;
     if (!container || dateRange.length === 0) return;
     const task = tasks.find((t) => t.id === taskId);
@@ -7763,7 +8314,7 @@ function GanttChartInner(props, ref) {
     const scrollLeft = Math.round(taskOffset - dayWidth * 2);
     container.scrollTo({ left: Math.max(0, scrollLeft), behavior: "smooth" });
   }, [tasks, dateRange, dayWidth]);
-  const scrollToRow = useCallback6((taskId) => {
+  const scrollToRow = useCallback8((taskId) => {
     const container = scrollContainerRef.current;
     if (!container) return;
     const task = tasks.find((t) => t.id === taskId);
@@ -7775,15 +8326,15 @@ function GanttChartInner(props, ref) {
     setSelectedTaskId(taskId);
     container.scrollTo({ top: scrollTop, behavior: "smooth" });
   }, [tasks, visibleTasks, rowHeight]);
-  const [dragGuideLines, setDragGuideLines] = useState7(null);
-  const [draggedTaskOverride, setDraggedTaskOverride] = useState7(null);
-  const [previewTasksById, setPreviewTasksById] = useState7(/* @__PURE__ */ new Map());
-  useEffect7(() => {
+  const [dragGuideLines, setDragGuideLines] = useState8(null);
+  const [draggedTaskOverride, setDraggedTaskOverride] = useState8(null);
+  const [previewTasksById, setPreviewTasksById] = useState8(/* @__PURE__ */ new Map());
+  useEffect9(() => {
     const result = validateDependencies(tasks);
     setValidationResult(result);
     onValidateDependencies?.(result);
   }, [tasks, onValidateDependencies]);
-  const handleTaskChange = useCallback6((updatedTasks) => {
+  const handleTaskChange = useCallback8((updatedTasks) => {
     const updatedTask = updatedTasks[0];
     if (!updatedTask) return;
     const originalTask = tasks.find((t) => t.id === updatedTask.id);
@@ -7829,7 +8380,7 @@ function GanttChartInner(props, ref) {
     const cascadedTasks = disableConstraints ? [updatedTask] : universalCascade(updatedTask, newStart, newEnd, sourceTasks, businessDays, isCustomWeekend);
     onTasksChange?.(cascadedTasks);
   }, [tasks, onTasksChange, disableConstraints, editingTaskId, businessDays, isCustomWeekend]);
-  const handleDelete = useCallback6((taskId) => {
+  const handleDelete = useCallback8((taskId) => {
     const toDelete = /* @__PURE__ */ new Set([taskId]);
     function collectDescendants(parentId) {
       const children = getChildren(parentId, tasks);
@@ -7854,10 +8405,10 @@ function GanttChartInner(props, ref) {
     }
     toDelete.forEach((id) => onDelete?.(id));
   }, [tasks, onTasksChange, onDelete]);
-  const handleInsertAfter = useCallback6((taskId, newTask) => {
+  const handleInsertAfter = useCallback8((taskId, newTask) => {
     onInsertAfter?.(taskId, newTask);
   }, [onInsertAfter]);
-  const handleReorder = useCallback6((reorderedTasks, movedTaskId, inferredParentId) => {
+  const handleReorder = useCallback8((reorderedTasks, movedTaskId, inferredParentId) => {
     let updated = reorderedTasks;
     if (movedTaskId) {
       updated = updated.map((t) => {
@@ -7874,7 +8425,7 @@ function GanttChartInner(props, ref) {
     }
     onTasksChange?.(normalized);
   }, [onTasksChange, onReorder]);
-  const dependencyOverrides = useMemo9(() => {
+  const dependencyOverrides = useMemo10(() => {
     const map = new Map(cascadeOverrides);
     if (draggedTaskOverride) {
       map.set(draggedTaskOverride.taskId, {
@@ -7884,25 +8435,25 @@ function GanttChartInner(props, ref) {
     }
     return map;
   }, [cascadeOverrides, draggedTaskOverride]);
-  const handleCascadeProgress = useCallback6((overrides, previewTasks = []) => {
+  const handleCascadeProgress = useCallback8((overrides, previewTasks = []) => {
     setCascadeOverrides(new Map(overrides));
     setPreviewTasksById(new Map(previewTasks.map((task) => [task.id, task])));
   }, []);
-  const previewNormalizedTasks = useMemo9(() => {
+  const previewNormalizedTasks = useMemo10(() => {
     if (previewTasksById.size === 0) return normalizedTasks;
     return normalizedTasks.map((task) => previewTasksById.get(task.id) ?? task);
   }, [normalizedTasks, previewTasksById]);
-  const previewVisibleTasks = useMemo9(() => {
+  const previewVisibleTasks = useMemo10(() => {
     if (previewTasksById.size === 0) return visibleTasks;
     return visibleTasks.map((task) => previewTasksById.get(task.id) ?? task);
   }, [visibleTasks, previewTasksById]);
-  const handleCascade = useCallback6((cascadedTasks) => {
+  const handleCascade = useCallback8((cascadedTasks) => {
     onTasksChange?.(cascadedTasks);
   }, [tasks, onTasksChange]);
-  const handleTaskSelect = useCallback6((taskId) => {
+  const handleTaskSelect = useCallback8((taskId) => {
     setSelectedTaskId(taskId);
   }, []);
-  const handleToggleCollapse = externalOnToggleCollapse ?? useCallback6((parentId) => {
+  const handleToggleCollapse = externalOnToggleCollapse ?? useCallback8((parentId) => {
     setInternalCollapsedParentIds((prev) => {
       const next = new Set(prev);
       if (next.has(parentId)) {
@@ -7913,20 +8464,20 @@ function GanttChartInner(props, ref) {
       return next;
     });
   }, []);
-  const allParentIds = useMemo9(() => {
+  const allParentIds = useMemo10(() => {
     return new Set(
       normalizedTasks.filter((t) => isTaskParent(t.id, normalizedTasks)).map((t) => t.id)
     );
   }, [normalizedTasks]);
-  const handleCollapseAll = useCallback6(() => {
+  const handleCollapseAll = useCallback8(() => {
     if (externalCollapsedParentIds) return;
     setInternalCollapsedParentIds(allParentIds);
   }, [allParentIds, externalCollapsedParentIds]);
-  const handleExpandAll = useCallback6(() => {
+  const handleExpandAll = useCallback8(() => {
     if (externalCollapsedParentIds) return;
     setInternalCollapsedParentIds(/* @__PURE__ */ new Set());
   }, [externalCollapsedParentIds]);
-  const exportToPdf = useCallback6(async (options) => {
+  const exportToPdf = useCallback8(async (options) => {
     const sourceContainer = containerRef.current;
     const sourceContent = scrollContentRef.current;
     if (!sourceContainer || !sourceContent || typeof window === "undefined" || typeof document === "undefined") {
@@ -7985,7 +8536,7 @@ function GanttChartInner(props, ref) {
     }
     return depth;
   }
-  const handlePromoteTask = useCallback6((taskId) => {
+  const handlePromoteTask = useCallback8((taskId) => {
     if (onPromoteTask) {
       onPromoteTask(taskId);
       return;
@@ -8015,7 +8566,7 @@ function GanttChartInner(props, ref) {
     ]);
     onTasksChange?.(reorderedTasks);
   }, [tasks, onTasksChange, onPromoteTask]);
-  const handleDemoteTask = useCallback6((taskId, newParentId) => {
+  const handleDemoteTask = useCallback8((taskId, newParentId) => {
     if (onDemoteTask) {
       onDemoteTask(taskId, newParentId);
       return;
@@ -8056,7 +8607,7 @@ function GanttChartInner(props, ref) {
     };
     onTasksChange?.([updatedDemotedTask]);
   }, [tasks, onTasksChange, onDemoteTask]);
-  const handleUngroupTask = useCallback6((taskId) => {
+  const handleUngroupTask = useCallback8((taskId) => {
     if (onUngroupTask) {
       onUngroupTask(taskId);
       return;
@@ -8083,8 +8634,8 @@ function GanttChartInner(props, ref) {
     }
     onDelete?.(taskId);
   }, [tasks, onTasksChange, onDelete, onUngroupTask]);
-  const panStateRef = useRef7(null);
-  const handlePanStart = useCallback6((e) => {
+  const panStateRef = useRef9(null);
+  const handlePanStart = useCallback8((e) => {
     if (e.button !== 0) return;
     const target = e.target;
     if (target.closest("[data-taskbar]")) return;
@@ -8105,7 +8656,7 @@ function GanttChartInner(props, ref) {
     container.style.cursor = "grabbing";
     e.preventDefault();
   }, []);
-  useEffect7(() => {
+  useEffect9(() => {
     const handlePanMove = (e) => {
       const pan = panStateRef.current;
       if (!pan?.active) return;
@@ -8127,15 +8678,15 @@ function GanttChartInner(props, ref) {
       window.removeEventListener("mouseup", handlePanEnd);
     };
   }, []);
-  return /* @__PURE__ */ jsx15("div", { ref: containerRef, className: "gantt-container", children: /* @__PURE__ */ jsx15(
+  return /* @__PURE__ */ jsx16("div", { ref: containerRef, className: "gantt-container", children: /* @__PURE__ */ jsx16(
     "div",
     {
       ref: scrollContainerRef,
       className: "gantt-scrollContainer",
       style: { height: containerHeight ?? "auto", cursor: "grab" },
       onMouseDown: handlePanStart,
-      children: /* @__PURE__ */ jsxs12("div", { ref: scrollContentRef, className: "gantt-scrollContent", children: [
-        /* @__PURE__ */ jsx15(
+      children: /* @__PURE__ */ jsxs13("div", { ref: scrollContentRef, className: "gantt-scrollContent", children: [
+        /* @__PURE__ */ jsx16(
           TaskList,
           {
             tasks: normalizedTasks,
@@ -8157,6 +8708,7 @@ function GanttChartInner(props, ref) {
             onReorder: handleReorder,
             editingTaskId,
             enableAddTask,
+            defaultTaskDurationDays,
             collapsedParentIds,
             onToggleCollapse: handleToggleCollapse,
             onPromoteTask: onPromoteTask ?? handlePromoteTask,
@@ -8173,13 +8725,13 @@ function GanttChartInner(props, ref) {
             taskListMenuCommands
           }
         ),
-        /* @__PURE__ */ jsxs12(
+        /* @__PURE__ */ jsxs13(
           "div",
           {
             className: showChart ? "gantt-chartSurface" : "gantt-chartSurface gantt-chart-hidden",
             style: { minWidth: `${gridWidth}px`, flex: 1, display: showChart ? void 0 : "none" },
             children: [
-              /* @__PURE__ */ jsx15("div", { className: "gantt-stickyHeader", style: { width: `${gridWidth}px` }, children: /* @__PURE__ */ jsx15(
+              /* @__PURE__ */ jsx16("div", { className: "gantt-stickyHeader", style: { width: `${gridWidth}px` }, children: /* @__PURE__ */ jsx16(
                 TimeScaleHeader_default,
                 {
                   days: dateRange,
@@ -8189,7 +8741,7 @@ function GanttChartInner(props, ref) {
                   isCustomWeekend
                 }
               ) }),
-              /* @__PURE__ */ jsxs12(
+              /* @__PURE__ */ jsxs13(
                 "div",
                 {
                   className: "gantt-taskArea",
@@ -8198,7 +8750,7 @@ function GanttChartInner(props, ref) {
                     width: `${gridWidth}px`
                   },
                   children: [
-                    /* @__PURE__ */ jsx15(
+                    /* @__PURE__ */ jsx16(
                       GridBackground_default,
                       {
                         dateRange,
@@ -8208,8 +8760,8 @@ function GanttChartInner(props, ref) {
                         isCustomWeekend
                       }
                     ),
-                    todayInRange && /* @__PURE__ */ jsx15(TodayIndicator_default, { monthStart, dayWidth }),
-                    /* @__PURE__ */ jsx15(
+                    todayInRange && /* @__PURE__ */ jsx16(TodayIndicator_default, { monthStart, dayWidth }),
+                    /* @__PURE__ */ jsx16(
                       DependencyLines_default,
                       {
                         tasks: previewVisibleTasks,
@@ -8225,7 +8777,7 @@ function GanttChartInner(props, ref) {
                         weekendPredicate: isCustomWeekend
                       }
                     ),
-                    dragGuideLines && /* @__PURE__ */ jsx15(
+                    dragGuideLines && /* @__PURE__ */ jsx16(
                       DragGuideLines_default,
                       {
                         isDragging: dragGuideLines.isDragging,
@@ -8235,7 +8787,7 @@ function GanttChartInner(props, ref) {
                         totalHeight: totalGridHeight
                       }
                     ),
-                    visibleTasks.map((task, index) => /* @__PURE__ */ jsx15(
+                    visibleTasks.map((task, index) => /* @__PURE__ */ jsx16(
                       TaskRow_default,
                       {
                         task,
@@ -8279,13 +8831,14 @@ function GanttChartInner(props, ref) {
     }
   ) });
 }
+var TaskGanttChart = forwardRef(TaskGanttChartInner);
 var GanttChart = forwardRef(GanttChartInner);
 GanttChart.displayName = "GanttChart";
 
 // src/components/ui/Button.tsx
-import React13 from "react";
-import { jsx as jsx16 } from "react/jsx-runtime";
-var Button = React13.forwardRef(
+import React14 from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var Button = React14.forwardRef(
   ({ className, variant = "default", size = "default", children, ...props }, ref) => {
     const classes = [
       "gantt-btn",
@@ -8293,7 +8846,7 @@ var Button = React13.forwardRef(
       size !== "default" ? `gantt-btn-${size}` : "",
       className || ""
     ].filter(Boolean).join(" ");
-    return /* @__PURE__ */ jsx16("button", { ref, className: classes, ...props, children });
+    return /* @__PURE__ */ jsx17("button", { ref, className: classes, ...props, children });
   }
 );
 Button.displayName = "Button";
@@ -8338,6 +8891,7 @@ export {
   Popover,
   PopoverContent,
   PopoverTrigger,
+  ResourceTimelineChart,
   TaskList,
   TaskRow_default as TaskRow,
   TimeScaleHeader_default as TimeScaleHeader,
@@ -8401,6 +8955,7 @@ export {
   isTaskParent,
   isToday,
   isWeekend,
+  layoutResourceTimelineItems,
   moveTaskRange,
   moveTaskWithCascade,
   nameContains,