gantt-lib 0.74.0 → 0.75.0

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();
@@ -7262,6 +7262,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 +8116,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,
@@ -7642,28 +8170,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 +8207,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 +8222,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 +8250,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 +8262,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 +8274,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 +8291,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 +8303,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 +8357,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 +8382,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 +8402,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 +8412,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 +8441,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 +8513,7 @@ function GanttChartInner(props, ref) {
     }
     return depth;
   }
-  const handlePromoteTask = useCallback6((taskId) => {
+  const handlePromoteTask = useCallback8((taskId) => {
     if (onPromoteTask) {
       onPromoteTask(taskId);
       return;
@@ -8015,7 +8543,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 +8584,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 +8611,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 +8633,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 +8655,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,
@@ -8173,13 +8701,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 +8717,7 @@ function GanttChartInner(props, ref) {
                   isCustomWeekend
                 }
               ) }),
-              /* @__PURE__ */ jsxs12(
+              /* @__PURE__ */ jsxs13(
                 "div",
                 {
                   className: "gantt-taskArea",
@@ -8198,7 +8726,7 @@ function GanttChartInner(props, ref) {
                     width: `${gridWidth}px`
                   },
                   children: [
-                    /* @__PURE__ */ jsx15(
+                    /* @__PURE__ */ jsx16(
                       GridBackground_default,
                       {
                         dateRange,
@@ -8208,8 +8736,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 +8753,7 @@ function GanttChartInner(props, ref) {
                         weekendPredicate: isCustomWeekend
                       }
                     ),
-                    dragGuideLines && /* @__PURE__ */ jsx15(
+                    dragGuideLines && /* @__PURE__ */ jsx16(
                       DragGuideLines_default,
                       {
                         isDragging: dragGuideLines.isDragging,
@@ -8235,7 +8763,7 @@ function GanttChartInner(props, ref) {
                         totalHeight: totalGridHeight
                       }
                     ),
-                    visibleTasks.map((task, index) => /* @__PURE__ */ jsx15(
+                    visibleTasks.map((task, index) => /* @__PURE__ */ jsx16(
                       TaskRow_default,
                       {
                         task,
@@ -8279,13 +8807,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 +8822,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 +8867,7 @@ export {
   Popover,
   PopoverContent,
   PopoverTrigger,
+  ResourceTimelineChart,
   TaskList,
   TaskRow_default as TaskRow,
   TimeScaleHeader_default as TimeScaleHeader,
@@ -8401,6 +8931,7 @@ export {
   isTaskParent,
   isToday,
   isWeekend,
+  layoutResourceTimelineItems,
   moveTaskRange,
   moveTaskWithCascade,
   nameContains,