gantt-lib 0.77.0 → 0.78.0

package/dist/index.js

@@ -8,9 +8,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,474 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/core/scheduling/dateMath.ts
-function normalizeUTCDate(date) {
-  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-}
-function parseDateOnly(date) {
-  const parsed = typeof date === "string" ? /* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(date);
-  return normalizeUTCDate(parsed);
-}
-function getBusinessDayOffset(fromDate, toDate, weekendPredicate) {
-  const from = normalizeUTCDate(fromDate);
-  const to = normalizeUTCDate(toDate);
-  if (from.getTime() === to.getTime()) {
-    return 0;
-  }
-  const step = to.getTime() > from.getTime() ? 1 : -1;
-  const current = new Date(from);
-  let offset = 0;
-  while (current.getTime() !== to.getTime()) {
-    current.setUTCDate(current.getUTCDate() + step);
-    if (!weekendPredicate(current)) {
-      offset += step;
-    }
-  }
-  return offset;
-}
-function shiftBusinessDayOffset(date, offset, weekendPredicate) {
-  const current = normalizeUTCDate(date);
-  if (offset === 0) {
-    return current;
-  }
-  const step = offset > 0 ? 1 : -1;
-  let remaining = Math.abs(offset);
-  while (remaining > 0) {
-    current.setUTCDate(current.getUTCDate() + step);
-    if (!weekendPredicate(current)) {
-      remaining--;
-    }
-  }
-  return current;
-}
-function getBusinessDaysCount(startDate, endDate, weekendPredicate) {
-  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
-  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
-  let count = 0;
-  const current = new Date(start);
-  while (current.getTime() <= end.getTime()) {
-    if (!weekendPredicate(current)) {
-      count++;
-    }
-    current.setUTCDate(current.getUTCDate() + 1);
-  }
-  return Math.max(1, count);
-}
-function addBusinessDays(startDate, businessDays, weekendPredicate) {
-  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
-  const current = new Date(start);
-  let targetDays = Math.max(1, businessDays);
-  let businessDaysCounted = 0;
-  while (businessDaysCounted < targetDays) {
-    if (!weekendPredicate(current)) {
-      businessDaysCounted++;
-    }
-    if (businessDaysCounted < targetDays) {
-      current.setUTCDate(current.getUTCDate() + 1);
-    }
-  }
-  return current;
-}
-function subtractBusinessDays(endDate, businessDays, weekendPredicate) {
-  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
-  const current = new Date(end);
-  let targetDays = Math.max(1, businessDays);
-  let businessDaysCounted = 0;
-  while (businessDaysCounted < targetDays) {
-    if (!weekendPredicate(current)) {
-      businessDaysCounted++;
-    }
-    if (businessDaysCounted < targetDays) {
-      current.setUTCDate(current.getUTCDate() - 1);
-    }
-  }
-  return current;
-}
-function alignToWorkingDay(date, direction, weekendPredicate) {
-  const current = normalizeUTCDate(date);
-  while (weekendPredicate(current)) {
-    current.setUTCDate(current.getUTCDate() + direction);
-  }
-  return current;
-}
-function getTaskDuration(startDate, endDate, businessDays = false, weekendPredicate) {
-  const start = parseDateOnly(startDate);
-  const end = parseDateOnly(endDate);
-  if (businessDays && weekendPredicate) {
-    return getBusinessDaysCount(start, end, weekendPredicate);
-  }
-  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
-}
-var DAY_MS;
-var init_dateMath = __esm({
-  "src/core/scheduling/dateMath.ts"() {
-    "use strict";
-    DAY_MS = 24 * 60 * 60 * 1e3;
-  }
-});
-
-// src/utils/dateUtils.ts
-var dateUtils_exports = {};
-__export(dateUtils_exports, {
-  addBusinessDays: () => addBusinessDays2,
-  createCustomDayPredicate: () => createCustomDayPredicate,
-  createDateKey: () => createDateKey,
-  formatDateLabel: () => formatDateLabel,
-  formatDateRangeLabel: () => formatDateRangeLabel,
-  getBusinessDaysCount: () => getBusinessDaysCount2,
-  getDayOffset: () => getDayOffset,
-  getMonthBlocks: () => getMonthBlocks,
-  getMonthDays: () => getMonthDays,
-  getMonthSpans: () => getMonthSpans,
-  getMultiMonthDays: () => getMultiMonthDays,
-  getWeekBlocks: () => getWeekBlocks,
-  getWeekSpans: () => getWeekSpans,
-  getYearSpans: () => getYearSpans,
-  isToday: () => isToday,
-  isWeekend: () => isWeekend,
-  normalizeTaskDates: () => normalizeTaskDates,
-  parseUTCDate: () => parseUTCDate,
-  subtractBusinessDays: () => subtractBusinessDays2
-});
-function getBusinessDaysCount2(startDate, endDate, weekendPredicate) {
-  return getBusinessDaysCount(startDate, endDate, weekendPredicate);
-}
-function addBusinessDays2(startDate, businessDays, weekendPredicate) {
-  const result = addBusinessDays(startDate, businessDays, weekendPredicate);
-  return result.toISOString().split("T")[0];
-}
-function subtractBusinessDays2(endDate, businessDays, weekendPredicate) {
-  const result = subtractBusinessDays(endDate, businessDays, weekendPredicate);
-  return result.toISOString().split("T")[0];
-}
-var parseUTCDate, getMonthDays, getDayOffset, isToday, isWeekend, createDateKey, createCustomDayPredicate, getMultiMonthDays, getMonthSpans, formatDateLabel, MONTH_ABBR, formatDateRangeLabel, getWeekBlocks, getWeekSpans, getMonthBlocks, getYearSpans, normalizeTaskDates;
-var init_dateUtils = __esm({
-  "src/utils/dateUtils.ts"() {
-    "use strict";
-    init_dateMath();
-    parseUTCDate = (date) => {
-      if (typeof date === "string") {
-        const dateStr = date.includes("T") ? date : `${date}T00:00:00Z`;
-        const parsed = new Date(dateStr);
-        if (isNaN(parsed.getTime())) {
-          throw new Error(`Invalid date string: ${date}`);
-        }
-        return parsed;
-      }
-      return date;
-    };
-    getMonthDays = (date) => {
-      const utcDate = parseUTCDate(date);
-      const year = utcDate.getUTCFullYear();
-      const month = utcDate.getUTCMonth();
-      const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-      const days = [];
-      for (let day = 1; day <= daysInMonth; day++) {
-        days.push(new Date(Date.UTC(year, month, day)));
-      }
-      return days;
-    };
-    getDayOffset = (date, monthStart) => {
-      const dateMs = Date.UTC(
-        date.getUTCFullYear(),
-        date.getUTCMonth(),
-        date.getUTCDate()
-      );
-      const startMs = Date.UTC(
-        monthStart.getUTCFullYear(),
-        monthStart.getUTCMonth(),
-        monthStart.getUTCDate()
-      );
-      return Math.round((dateMs - startMs) / (1e3 * 60 * 60 * 24));
-    };
-    isToday = (date) => {
-      const now = /* @__PURE__ */ new Date();
-      const today = new Date(Date.UTC(
-        now.getFullYear(),
-        now.getMonth(),
-        now.getDate()
-      ));
-      const compareDate = new Date(Date.UTC(
-        date.getUTCFullYear(),
-        date.getUTCMonth(),
-        date.getUTCDate()
-      ));
-      return today.getTime() === compareDate.getTime();
-    };
-    isWeekend = (date) => {
-      const day = date.getUTCDay();
-      return day === 0 || day === 6;
-    };
-    createDateKey = (date) => {
-      return `${date.getUTCFullYear()}-${date.getUTCMonth()}-${date.getUTCDate()}`;
-    };
-    createCustomDayPredicate = (config) => {
-      const { customDays, isWeekend: basePredicate } = config;
-      const workdaySet = /* @__PURE__ */ new Set();
-      const weekendSet = /* @__PURE__ */ new Set();
-      if (customDays && customDays.length > 0) {
-        for (const item of customDays) {
-          const key = createDateKey(item.date);
-          if (item.type === "workday") {
-            workdaySet.add(key);
-          } else {
-            weekendSet.add(key);
-          }
-        }
-      }
-      return (date) => {
-        const key = createDateKey(date);
-        if (workdaySet.has(key)) {
-          return false;
-        }
-        if (weekendSet.has(key)) {
-          return true;
-        }
-        if (basePredicate) {
-          return basePredicate(date);
-        }
-        const dayOfWeek = date.getUTCDay();
-        return dayOfWeek === 0 || dayOfWeek === 6;
-      };
-    };
-    getMultiMonthDays = (tasks) => {
-      if (!tasks || tasks.length === 0) {
-        return getMonthDays(/* @__PURE__ */ new Date());
-      }
-      let minDate = null;
-      let maxDate = null;
-      for (const task of tasks) {
-        const start = parseUTCDate(task.startDate);
-        const end = parseUTCDate(task.endDate);
-        if (!minDate || start.getTime() < minDate.getTime()) {
-          minDate = start;
-        }
-        if (!maxDate || end.getTime() > maxDate.getTime()) {
-          maxDate = end;
-        }
-      }
-      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 + 2,
-        // Original + 2 months padding after
-        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;
-    };
-    getMonthSpans = (dateRange) => {
-      if (dateRange.length === 0) {
-        return [];
-      }
-      const spans = [];
-      let currentMonthYear = `${dateRange[0].getUTCFullYear()}-${dateRange[0].getUTCMonth()}`;
-      let startOfMonthIndex = 0;
-      for (let i = 0; i < dateRange.length; i++) {
-        const date = dateRange[i];
-        const monthYear = `${date.getUTCFullYear()}-${date.getUTCMonth()}`;
-        if (monthYear !== currentMonthYear) {
-          spans.push({
-            month: new Date(Date.UTC(
-              dateRange[startOfMonthIndex].getUTCFullYear(),
-              dateRange[startOfMonthIndex].getUTCMonth(),
-              1
-            )),
-            days: i - startOfMonthIndex,
-            startIndex: startOfMonthIndex
-          });
-          currentMonthYear = monthYear;
-          startOfMonthIndex = i;
-        }
-        if (i === dateRange.length - 1) {
-          spans.push({
-            month: new Date(Date.UTC(
-              date.getUTCFullYear(),
-              date.getUTCMonth(),
-              1
-            )),
-            days: i - startOfMonthIndex + 1,
-            startIndex: startOfMonthIndex
-          });
-        }
-      }
-      return spans;
-    };
-    formatDateLabel = (date) => {
-      const parsed = parseUTCDate(date);
-      const day = String(parsed.getUTCDate()).padStart(2, "0");
-      const month = String(parsed.getUTCMonth() + 1).padStart(2, "0");
-      return `${day}.${month}`;
-    };
-    MONTH_ABBR = [
-      "\u044F\u043D\u0432",
-      "\u0444\u0435\u0432",
-      "\u043C\u0430\u0440",
-      "\u0430\u043F\u0440",
-      "\u043C\u0430\u044F",
-      "\u0438\u044E\u043D",
-      "\u0438\u044E\u043B",
-      "\u0430\u0432\u0433",
-      "\u0441\u0435\u043D",
-      "\u043E\u043A\u0442",
-      "\u043D\u043E\u044F",
-      "\u0434\u0435\u043A"
-    ];
-    formatDateRangeLabel = (startDate, endDate) => {
-      const start = parseUTCDate(startDate);
-      const end = parseUTCDate(endDate);
-      const startDay = start.getUTCDate();
-      const endDay = end.getUTCDate();
-      const startMonth = start.getUTCMonth();
-      const endMonth = end.getUTCMonth();
-      const startYear = start.getUTCFullYear();
-      const endYear = end.getUTCFullYear();
-      if (startMonth === endMonth && startYear === endYear) {
-        if (startDay === endDay) {
-          return `${startDay} ${MONTH_ABBR[startMonth]}`;
-        }
-        return `${startDay}\u2013${endDay} ${MONTH_ABBR[startMonth]}`;
-      }
-      if (startYear === endYear) {
-        return `${startDay} ${MONTH_ABBR[startMonth]}\u2013${endDay} ${MONTH_ABBR[endMonth]}`;
-      }
-      return `${startDay} ${MONTH_ABBR[startMonth]} ${startYear}\u2013${endDay} ${MONTH_ABBR[endMonth]} ${endYear}`;
-    };
-    getWeekBlocks = (days) => {
-      if (days.length === 0) return [];
-      const blocks = [];
-      let blockStart = 0;
-      while (blockStart < days.length) {
-        const maxBlockEnd = Math.min(blockStart + 7, days.length);
-        const startMonthYear = `${days[blockStart].getUTCFullYear()}-${days[blockStart].getUTCMonth()}`;
-        let actualBlockEnd = blockStart + 7;
-        if (actualBlockEnd > days.length) {
-          actualBlockEnd = days.length;
-        }
-        for (let i = blockStart + 1; i < maxBlockEnd; i++) {
-          const monthYear = `${days[i].getUTCFullYear()}-${days[i].getUTCMonth()}`;
-          if (monthYear !== startMonthYear) {
-            actualBlockEnd = i;
-            break;
-          }
-        }
-        blocks.push({
-          startDate: days[blockStart],
-          days: actualBlockEnd - blockStart
-        });
-        blockStart = actualBlockEnd;
-      }
-      return blocks;
-    };
-    getWeekSpans = (days) => {
-      const blocks = getWeekBlocks(days);
-      if (blocks.length === 0) return [];
-      const spans = [];
-      let currentMonthYear = `${blocks[0].startDate.getUTCFullYear()}-${blocks[0].startDate.getUTCMonth()}`;
-      let startIndex = 0;
-      let totalDays = 0;
-      for (let i = 0; i < blocks.length; i++) {
-        const block = blocks[i];
-        const monthYear = `${block.startDate.getUTCFullYear()}-${block.startDate.getUTCMonth()}`;
-        if (monthYear !== currentMonthYear) {
-          spans.push({
-            month: new Date(Date.UTC(
-              blocks[startIndex].startDate.getUTCFullYear(),
-              blocks[startIndex].startDate.getUTCMonth(),
-              1
-            )),
-            days: totalDays,
-            startIndex
-          });
-          currentMonthYear = monthYear;
-          startIndex = i;
-          totalDays = 0;
-        }
-        totalDays += block.days;
-        if (i === blocks.length - 1) {
-          spans.push({
-            month: new Date(Date.UTC(
-              block.startDate.getUTCFullYear(),
-              block.startDate.getUTCMonth(),
-              1
-            )),
-            days: totalDays,
-            startIndex
-          });
-        }
-      }
-      return spans;
-    };
-    getMonthBlocks = (days) => {
-      if (days.length === 0) return [];
-      return getMonthSpans(days).map((span) => ({
-        startDate: span.month,
-        days: span.days
-      }));
-    };
-    getYearSpans = (days) => {
-      const blocks = getMonthBlocks(days);
-      if (blocks.length === 0) return [];
-      const spans = [];
-      let currentYear = blocks[0].startDate.getUTCFullYear();
-      let startIndex = 0;
-      let totalDays = 0;
-      for (let i = 0; i < blocks.length; i++) {
-        const blockYear = blocks[i].startDate.getUTCFullYear();
-        if (blockYear !== currentYear) {
-          spans.push({
-            year: new Date(Date.UTC(currentYear, 0, 1)),
-            days: totalDays,
-            startIndex
-          });
-          currentYear = blockYear;
-          startIndex = i;
-          totalDays = 0;
-        }
-        totalDays += blocks[i].days;
-        if (i === blocks.length - 1) {
-          spans.push({
-            year: new Date(Date.UTC(currentYear, 0, 1)),
-            days: totalDays,
-            startIndex
-          });
-        }
-      }
-      return spans;
-    };
-    normalizeTaskDates = (startDate, endDate) => {
-      const start = parseUTCDate(startDate);
-      const end = parseUTCDate(endDate);
-      if (end.getTime() < start.getTime()) {
-        return {
-          startDate: end.toISOString().split("T")[0],
-          endDate: start.toISOString().split("T")[0]
-        };
-      }
-      return {
-        startDate: start.toISOString().split("T")[0],
-        endDate: end.toISOString().split("T")[0]
-      };
-    };
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -613,13 +142,441 @@ module.exports = __toCommonJS(index_exports);
 
 // src/components/GanttChart/GanttChart.tsx
 var import_react15 = require("react");
-init_dateUtils();
 
-// src/core/scheduling/index.ts
-init_dateMath();
+// src/core/scheduling/dateMath.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function normalizeUTCDate(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function parseDateOnly(date) {
+  const parsed = typeof date === "string" ? /* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(date);
+  return normalizeUTCDate(parsed);
+}
+function getBusinessDayOffset(fromDate, toDate, weekendPredicate) {
+  const from = normalizeUTCDate(fromDate);
+  const to = normalizeUTCDate(toDate);
+  if (from.getTime() === to.getTime()) {
+    return 0;
+  }
+  const step = to.getTime() > from.getTime() ? 1 : -1;
+  const current = new Date(from);
+  let offset = 0;
+  while (current.getTime() !== to.getTime()) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      offset += step;
+    }
+  }
+  return offset;
+}
+function shiftBusinessDayOffset(date, offset, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  if (offset === 0) {
+    return current;
+  }
+  const step = offset > 0 ? 1 : -1;
+  let remaining = Math.abs(offset);
+  while (remaining > 0) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      remaining--;
+    }
+  }
+  return current;
+}
+function getBusinessDaysCount(startDate, endDate, weekendPredicate) {
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
+  let count = 0;
+  const current = new Date(start);
+  while (current.getTime() <= end.getTime()) {
+    if (!weekendPredicate(current)) {
+      count++;
+    }
+    current.setUTCDate(current.getUTCDate() + 1);
+  }
+  return Math.max(1, count);
+}
+function addBusinessDays(startDate, businessDays, weekendPredicate) {
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
+  const current = new Date(start);
+  let targetDays = Math.max(1, businessDays);
+  let businessDaysCounted = 0;
+  while (businessDaysCounted < targetDays) {
+    if (!weekendPredicate(current)) {
+      businessDaysCounted++;
+    }
+    if (businessDaysCounted < targetDays) {
+      current.setUTCDate(current.getUTCDate() + 1);
+    }
+  }
+  return current;
+}
+function subtractBusinessDays(endDate, businessDays, weekendPredicate) {
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
+  const current = new Date(end);
+  let targetDays = Math.max(1, businessDays);
+  let businessDaysCounted = 0;
+  while (businessDaysCounted < targetDays) {
+    if (!weekendPredicate(current)) {
+      businessDaysCounted++;
+    }
+    if (businessDaysCounted < targetDays) {
+      current.setUTCDate(current.getUTCDate() - 1);
+    }
+  }
+  return current;
+}
+function alignToWorkingDay(date, direction, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  while (weekendPredicate(current)) {
+    current.setUTCDate(current.getUTCDate() + direction);
+  }
+  return current;
+}
+function getTaskDuration(startDate, endDate, businessDays = false, weekendPredicate) {
+  const start = parseDateOnly(startDate);
+  const end = parseDateOnly(endDate);
+  if (businessDays && weekendPredicate) {
+    return getBusinessDaysCount(start, end, weekendPredicate);
+  }
+  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
+}
+
+// src/utils/dateUtils.ts
+var parseUTCDate = (date) => {
+  if (typeof date === "string") {
+    const dateStr = date.includes("T") ? date : `${date}T00:00:00Z`;
+    const parsed = new Date(dateStr);
+    if (isNaN(parsed.getTime())) {
+      throw new Error(`Invalid date string: ${date}`);
+    }
+    return parsed;
+  }
+  return date;
+};
+var getMonthDays = (date) => {
+  const utcDate = parseUTCDate(date);
+  const year = utcDate.getUTCFullYear();
+  const month = utcDate.getUTCMonth();
+  const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+  const days = [];
+  for (let day = 1; day <= daysInMonth; day++) {
+    days.push(new Date(Date.UTC(year, month, day)));
+  }
+  return days;
+};
+var getDayOffset = (date, monthStart) => {
+  const dateMs = Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate()
+  );
+  const startMs = Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate()
+  );
+  return Math.round((dateMs - startMs) / (1e3 * 60 * 60 * 24));
+};
+var isToday = (date) => {
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(Date.UTC(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate()
+  ));
+  const compareDate = new Date(Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate()
+  ));
+  return today.getTime() === compareDate.getTime();
+};
+var isWeekend = (date) => {
+  const day = date.getUTCDay();
+  return day === 0 || day === 6;
+};
+var createDateKey = (date) => {
+  return `${date.getUTCFullYear()}-${date.getUTCMonth()}-${date.getUTCDate()}`;
+};
+var createCustomDayPredicate = (config) => {
+  const { customDays, isWeekend: basePredicate } = config;
+  const workdaySet = /* @__PURE__ */ new Set();
+  const weekendSet = /* @__PURE__ */ new Set();
+  if (customDays && customDays.length > 0) {
+    for (const item of customDays) {
+      const key = createDateKey(item.date);
+      if (item.type === "workday") {
+        workdaySet.add(key);
+      } else {
+        weekendSet.add(key);
+      }
+    }
+  }
+  return (date) => {
+    const key = createDateKey(date);
+    if (workdaySet.has(key)) {
+      return false;
+    }
+    if (weekendSet.has(key)) {
+      return true;
+    }
+    if (basePredicate) {
+      return basePredicate(date);
+    }
+    const dayOfWeek = date.getUTCDay();
+    return dayOfWeek === 0 || dayOfWeek === 6;
+  };
+};
+var getMultiMonthDays = (tasks) => {
+  if (!tasks || tasks.length === 0) {
+    return getMonthDays(/* @__PURE__ */ new Date());
+  }
+  let minDate = null;
+  let maxDate = null;
+  for (const task of tasks) {
+    const start = parseUTCDate(task.startDate);
+    const end = parseUTCDate(task.endDate);
+    if (!minDate || start.getTime() < minDate.getTime()) {
+      minDate = start;
+    }
+    if (!maxDate || end.getTime() > maxDate.getTime()) {
+      maxDate = end;
+    }
+  }
+  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 + 2,
+    // Original + 2 months padding after
+    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 getMonthSpans = (dateRange) => {
+  if (dateRange.length === 0) {
+    return [];
+  }
+  const spans = [];
+  let currentMonthYear = `${dateRange[0].getUTCFullYear()}-${dateRange[0].getUTCMonth()}`;
+  let startOfMonthIndex = 0;
+  for (let i = 0; i < dateRange.length; i++) {
+    const date = dateRange[i];
+    const monthYear = `${date.getUTCFullYear()}-${date.getUTCMonth()}`;
+    if (monthYear !== currentMonthYear) {
+      spans.push({
+        month: new Date(Date.UTC(
+          dateRange[startOfMonthIndex].getUTCFullYear(),
+          dateRange[startOfMonthIndex].getUTCMonth(),
+          1
+        )),
+        days: i - startOfMonthIndex,
+        startIndex: startOfMonthIndex
+      });
+      currentMonthYear = monthYear;
+      startOfMonthIndex = i;
+    }
+    if (i === dateRange.length - 1) {
+      spans.push({
+        month: new Date(Date.UTC(
+          date.getUTCFullYear(),
+          date.getUTCMonth(),
+          1
+        )),
+        days: i - startOfMonthIndex + 1,
+        startIndex: startOfMonthIndex
+      });
+    }
+  }
+  return spans;
+};
+var formatDateLabel = (date) => {
+  const parsed = parseUTCDate(date);
+  const day = String(parsed.getUTCDate()).padStart(2, "0");
+  const month = String(parsed.getUTCMonth() + 1).padStart(2, "0");
+  return `${day}.${month}`;
+};
+var MONTH_ABBR = [
+  "\u044F\u043D\u0432",
+  "\u0444\u0435\u0432",
+  "\u043C\u0430\u0440",
+  "\u0430\u043F\u0440",
+  "\u043C\u0430\u044F",
+  "\u0438\u044E\u043D",
+  "\u0438\u044E\u043B",
+  "\u0430\u0432\u0433",
+  "\u0441\u0435\u043D",
+  "\u043E\u043A\u0442",
+  "\u043D\u043E\u044F",
+  "\u0434\u0435\u043A"
+];
+var formatDateRangeLabel = (startDate, endDate) => {
+  const start = parseUTCDate(startDate);
+  const end = parseUTCDate(endDate);
+  const startDay = start.getUTCDate();
+  const endDay = end.getUTCDate();
+  const startMonth = start.getUTCMonth();
+  const endMonth = end.getUTCMonth();
+  const startYear = start.getUTCFullYear();
+  const endYear = end.getUTCFullYear();
+  if (startMonth === endMonth && startYear === endYear) {
+    if (startDay === endDay) {
+      return `${startDay} ${MONTH_ABBR[startMonth]}`;
+    }
+    return `${startDay}\u2013${endDay} ${MONTH_ABBR[startMonth]}`;
+  }
+  if (startYear === endYear) {
+    return `${startDay} ${MONTH_ABBR[startMonth]}\u2013${endDay} ${MONTH_ABBR[endMonth]}`;
+  }
+  return `${startDay} ${MONTH_ABBR[startMonth]} ${startYear}\u2013${endDay} ${MONTH_ABBR[endMonth]} ${endYear}`;
+};
+var getWeekBlocks = (days) => {
+  if (days.length === 0) return [];
+  const blocks = [];
+  let blockStart = 0;
+  while (blockStart < days.length) {
+    const maxBlockEnd = Math.min(blockStart + 7, days.length);
+    const startMonthYear = `${days[blockStart].getUTCFullYear()}-${days[blockStart].getUTCMonth()}`;
+    let actualBlockEnd = blockStart + 7;
+    if (actualBlockEnd > days.length) {
+      actualBlockEnd = days.length;
+    }
+    for (let i = blockStart + 1; i < maxBlockEnd; i++) {
+      const monthYear = `${days[i].getUTCFullYear()}-${days[i].getUTCMonth()}`;
+      if (monthYear !== startMonthYear) {
+        actualBlockEnd = i;
+        break;
+      }
+    }
+    blocks.push({
+      startDate: days[blockStart],
+      days: actualBlockEnd - blockStart
+    });
+    blockStart = actualBlockEnd;
+  }
+  return blocks;
+};
+var getWeekSpans = (days) => {
+  const blocks = getWeekBlocks(days);
+  if (blocks.length === 0) return [];
+  const spans = [];
+  let currentMonthYear = `${blocks[0].startDate.getUTCFullYear()}-${blocks[0].startDate.getUTCMonth()}`;
+  let startIndex = 0;
+  let totalDays = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const monthYear = `${block.startDate.getUTCFullYear()}-${block.startDate.getUTCMonth()}`;
+    if (monthYear !== currentMonthYear) {
+      spans.push({
+        month: new Date(Date.UTC(
+          blocks[startIndex].startDate.getUTCFullYear(),
+          blocks[startIndex].startDate.getUTCMonth(),
+          1
+        )),
+        days: totalDays,
+        startIndex
+      });
+      currentMonthYear = monthYear;
+      startIndex = i;
+      totalDays = 0;
+    }
+    totalDays += block.days;
+    if (i === blocks.length - 1) {
+      spans.push({
+        month: new Date(Date.UTC(
+          block.startDate.getUTCFullYear(),
+          block.startDate.getUTCMonth(),
+          1
+        )),
+        days: totalDays,
+        startIndex
+      });
+    }
+  }
+  return spans;
+};
+var getMonthBlocks = (days) => {
+  if (days.length === 0) return [];
+  return getMonthSpans(days).map((span) => ({
+    startDate: span.month,
+    days: span.days
+  }));
+};
+var getYearSpans = (days) => {
+  const blocks = getMonthBlocks(days);
+  if (blocks.length === 0) return [];
+  const spans = [];
+  let currentYear = blocks[0].startDate.getUTCFullYear();
+  let startIndex = 0;
+  let totalDays = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const blockYear = blocks[i].startDate.getUTCFullYear();
+    if (blockYear !== currentYear) {
+      spans.push({
+        year: new Date(Date.UTC(currentYear, 0, 1)),
+        days: totalDays,
+        startIndex
+      });
+      currentYear = blockYear;
+      startIndex = i;
+      totalDays = 0;
+    }
+    totalDays += blocks[i].days;
+    if (i === blocks.length - 1) {
+      spans.push({
+        year: new Date(Date.UTC(currentYear, 0, 1)),
+        days: totalDays,
+        startIndex
+      });
+    }
+  }
+  return spans;
+};
+var normalizeTaskDates = (startDate, endDate) => {
+  const start = parseUTCDate(startDate);
+  const end = parseUTCDate(endDate);
+  if (end.getTime() < start.getTime()) {
+    return {
+      startDate: end.toISOString().split("T")[0],
+      endDate: start.toISOString().split("T")[0]
+    };
+  }
+  return {
+    startDate: start.toISOString().split("T")[0],
+    endDate: end.toISOString().split("T")[0]
+  };
+};
+function getBusinessDaysCount2(startDate, endDate, weekendPredicate) {
+  return getBusinessDaysCount(startDate, endDate, weekendPredicate);
+}
+function addBusinessDays2(startDate, businessDays, weekendPredicate) {
+  const result = addBusinessDays(startDate, businessDays, weekendPredicate);
+  return result.toISOString().split("T")[0];
+}
+function subtractBusinessDays2(endDate, businessDays, weekendPredicate) {
+  const result = subtractBusinessDays(endDate, businessDays, weekendPredicate);
+  return result.toISOString().split("T")[0];
+}
 
 // src/core/scheduling/dependencies.ts
-init_dateMath();
 function normalizePredecessorDates(predecessor, parseDateFn) {
   const predStart = parseDateFn(predecessor.startDate);
   const isMilestone = predecessor.type === "milestone";
@@ -726,9 +683,6 @@ function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag
   return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
 }
 
-// src/core/scheduling/cascade.ts
-init_dateMath();
-
 // src/core/scheduling/hierarchy.ts
 function getChildren(parentId, tasks) {
   return tasks.filter((t) => t.parentId === parentId);
@@ -850,7 +804,6 @@ function areTasksHierarchicallyRelated(taskId1, taskId2, tasks) {
 }
 
 // src/core/scheduling/commands.ts
-init_dateMath();
 function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
   const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
   if (businessDays && weekendPredicate) {
@@ -1258,11 +1211,7 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
   return Array.from(resultMap.values());
 }
 
-// src/core/scheduling/modeSwitch.ts
-init_dateMath();
-
 // src/core/scheduling/execute.ts
-init_dateMath();
 function toIsoDate(date) {
   return date.toISOString().split("T")[0];
 }
@@ -1704,7 +1653,6 @@ function validateDependencies(tasks) {
 }
 
 // src/utils/hierarchyOrder.ts
-init_dateUtils();
 function flattenHierarchy(tasks) {
   const byId = new Map(tasks.map((task) => [task.id, task]));
   const byParent = /* @__PURE__ */ new Map();
@@ -1760,7 +1708,6 @@ function normalizeHierarchyTasks(tasks) {
 var import_react = require("react");
 var import_date_fns = require("date-fns");
 var import_locale = require("date-fns/locale");
-init_dateUtils();
 var import_jsx_runtime = require("react/jsx-runtime");
 var TimeScaleHeader = ({
   days,
@@ -1949,7 +1896,6 @@ var TimeScaleHeader_default = TimeScaleHeader;
 
 // src/components/TaskRow/TaskRow.tsx
 var import_react3 = __toESM(require("react"));
-init_dateUtils();
 
 // src/utils/geometry.ts
 var getUTCDayDifference = (date1, date2) => {
@@ -2160,8 +2106,7 @@ var calculateDependencyPath = (from, to, arrivesFromRight) => {
   }
 };
 var calculateWeekGridLines = (dateRange, dayWidth) => {
-  const { getWeekBlocks: getWeekBlocks2 } = (init_dateUtils(), __toCommonJS(dateUtils_exports));
-  const blocks = getWeekBlocks2(dateRange);
+  const blocks = getWeekBlocks(dateRange);
   const lines = [];
   let currentDayIndex = 0;
   for (let i = 0; i < blocks.length; i++) {
@@ -2217,7 +2162,6 @@ var calculateOrthogonalPath = (from, to) => {
 };
 
 // src/utils/expired.ts
-init_dateUtils();
 var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
   if (!task) return false;
   const actualProgress = task.progress ?? 0;
@@ -2238,7 +2182,6 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
 };
 
 // src/utils/taskType.ts
-init_dateUtils();
 var TASK_TYPE_DEFAULT = "task";
 function getTaskType(task) {
   return task.type ?? TASK_TYPE_DEFAULT;
@@ -2272,7 +2215,6 @@ function normalizeTaskDatesForType(task) {
 var import_react2 = require("react");
 
 // src/adapters/scheduling/drag.ts
-init_dateMath();
 function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
   const dayOffset = Math.round(left / dayWidth);
   const rawStartDate = new Date(Date.UTC(
@@ -3157,7 +3099,6 @@ var TaskRow_default = TaskRow;
 
 // src/components/TodayIndicator/TodayIndicator.tsx
 var import_react4 = require("react");
-init_dateUtils();
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var TodayIndicator = ({ monthStart, dayWidth }) => {
   const today = /* @__PURE__ */ new Date();
@@ -3593,7 +3534,6 @@ var DependencyLines_default = DependencyLines;
 
 // src/components/TaskList/TaskList.tsx
 var import_react12 = __toESM(require("react"));
-init_dateUtils();
 
 // src/utils/taskListReorder.ts
 function getDescendantIds(taskId, tasks) {
@@ -3682,7 +3622,6 @@ var PopoverContent = ({
 
 // src/components/TaskList/TaskListRow.tsx
 var import_react10 = __toESM(require("react"));
-init_dateUtils();
 
 // src/components/ui/Input.tsx
 var import_react7 = __toESM(require("react"));
@@ -4186,7 +4125,6 @@ var LINK_TYPE_LABELS = {
 };
 
 // src/components/TaskList/defaultTaskDates.ts
-init_dateUtils();
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var DEFAULT_TASK_DURATION_DAYS = 5;
 function toISODate(date) {
@@ -7383,10 +7321,8 @@ var TaskList = ({
 
 // src/components/ResourceTimelineChart/ResourceTimelineChart.tsx
 var import_react14 = require("react");
-init_dateUtils();
 
 // 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);
@@ -7781,35 +7717,6 @@ 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) => {
@@ -7882,9 +7789,11 @@ var getDurationValue = (startDate, endDate, businessDays, weekendPredicate) => b
 function ResourceTimelineChart({
   resources,
   dayWidth = DEFAULT_DAY_WIDTH,
+  viewMode = "day",
   rowHeaderWidth = DEFAULT_ROW_HEADER_WIDTH,
   laneHeight = DEFAULT_LANE_HEIGHT,
   headerHeight = DEFAULT_HEADER_HEIGHT,
+  containerHeight,
   allowVerticalPan = false,
   customDays,
   isWeekend: isWeekend3,
@@ -7900,9 +7809,7 @@ function ResourceTimelineChart({
   const gridRef = (0, import_react14.useRef)(null);
   const panStateRef = (0, import_react14.useRef)(null);
   const validItems = (0, import_react14.useMemo)(() => collectValidItems(resources), [resources]);
-  const dateRange = (0, import_react14.useMemo)(() => {
-    return getResourceTimelineDays(validItems);
-  }, [validItems]);
+  const dateRange = (0, import_react14.useMemo)(() => getMultiMonthDays(validItems), [validItems]);
   const monthStart = (0, import_react14.useMemo)(() => {
     const firstDay = dateRange[0] ?? /* @__PURE__ */ new Date();
     return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
@@ -8008,7 +7915,11 @@ function ResourceTimelineChart({
     {
       ref: scrollContainerRef,
       className: "gantt-resourceTimeline-scrollContainer",
-      style: { cursor: "grab" },
+      style: {
+        cursor: "grab",
+        height: containerHeight ?? "auto",
+        overflowY: containerHeight === void 0 ? void 0 : "auto"
+      },
       "data-allow-vertical-pan": allowVerticalPan ? "true" : "false",
       onMouseDown: handlePanStart,
       children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "gantt-resourceTimeline-scrollContent", children: [
@@ -8063,6 +7974,7 @@ function ResourceTimelineChart({
                   days: dateRange,
                   dayWidth,
                   headerHeight,
+                  viewMode,
                   isCustomWeekend: weekendPredicate
                 }
               ) }),
@@ -8079,6 +7991,7 @@ function ResourceTimelineChart({
                         dateRange,
                         dayWidth,
                         totalHeight: layout.totalHeight,
+                        viewMode,
                         isCustomWeekend: weekendPredicate
                       }
                     ),
@@ -9275,11 +9188,7 @@ var Button = import_react16.default.forwardRef(
 );
 Button.displayName = "Button";
 
-// src/utils/index.ts
-init_dateUtils();
-
 // src/filters/index.ts
-init_dateUtils();
 var and = (...predicates) => (task) => predicates.every((p) => p(task));
 var or = (...predicates) => (task) => predicates.some((p) => p(task));
 var not = (predicate) => (task) => !predicate(task);