gantt-task-react-v 1.3.2 → 1.3.3

package/dist/gantt-task-react.es.js

@@ -11818,29 +11818,45 @@ const taskXCoordinate = (xDate, startDate, viewMode, columnWidth) => {
   const currentDate = getDateByOffset(startDate, index2, viewMode);
   const nextDate = getDateByOffset(startDate, index2 + 1, viewMode);
   const remainderMillis = xDate.getTime() - currentDate.getTime();
-  const percentOfInterval = remainderMillis / (nextDate.getTime() - currentDate.getTime());
-  return index2 * columnWidth + percentOfInterval * columnWidth;
+  const intervalDuration = nextDate.getTime() - currentDate.getTime();
+  const percentOfInterval = intervalDuration === 0 ? 0 : remainderMillis / intervalDuration;
+  const result = index2 * columnWidth + percentOfInterval * columnWidth;
+  return isNaN(result) || !isFinite(result) ? 0 : result;
 };
 const taskComparisonXCoordinate = (xDate, startDate, viewMode, columnWidth) => {
   const index2 = getDatesDiff(xDate, startDate, viewMode);
   const currentDate = getDateByOffset(startDate, index2, viewMode);
   const nextDate = getDateByOffset(startDate, index2 + 1, viewMode);
   const remainderMillis = xDate.getTime() - currentDate.getTime();
-  const percentOfInterval = remainderMillis / (nextDate.getTime() - currentDate.getTime());
-  return index2 * columnWidth + percentOfInterval * columnWidth;
+  const intervalDuration = nextDate.getTime() - currentDate.getTime();
+  const percentOfInterval = intervalDuration === 0 ? 0 : remainderMillis / intervalDuration;
+  const result = index2 * columnWidth + percentOfInterval * columnWidth;
+  return isNaN(result) || !isFinite(result) ? 0 : result;
 };
 const progressWithByParams = (taskX1, taskX2, progress, rtl) => {
-  const progressWidth = Math.max((taskX2 - taskX1) * progress * 0.01, 0);
+  const safeTaskX1 = isNaN(taskX1) || !isFinite(taskX1) ? 0 : taskX1;
+  const safeTaskX2 = isNaN(taskX2) || !isFinite(taskX2) ? 0 : taskX2;
+  const safeProgress = isNaN(progress) || !isFinite(progress) ? 0 : progress;
+  const progressWidth = Math.max(
+    (safeTaskX2 - safeTaskX1) * safeProgress * 0.01,
+    0
+  );
   let progressX;
   if (rtl) {
-    progressX = taskX2 - progressWidth;
+    progressX = safeTaskX2 - progressWidth;
   } else {
-    progressX = taskX1;
+    progressX = safeTaskX1;
   }
   return [progressWidth, progressX];
 };
 const dateByX = (x, taskX, taskDate, xStep, timeStep) => {
-  let newDate = new Date((x - taskX) / xStep * timeStep + taskDate.getTime());
+  const safeX = isNaN(x) || !isFinite(x) ? 0 : x;
+  const safeTaskX = isNaN(taskX) || !isFinite(taskX) ? 0 : taskX;
+  const safeXStep = isNaN(xStep) || !isFinite(xStep) || xStep === 0 ? 1 : xStep;
+  const safeTimeStep = isNaN(timeStep) || !isFinite(timeStep) ? 0 : timeStep;
+  let newDate = new Date(
+    (safeX - safeTaskX) / safeXStep * safeTimeStep + taskDate.getTime()
+  );
   newDate = new Date(
     newDate.getTime() + (newDate.getTimezoneOffset() - taskDate.getTimezoneOffset()) * 6e4
   );
@@ -13092,15 +13108,22 @@ const TaskGanttContentInner = (props) => {
         x2: taskX2,
         comparisonDates
       } = getTaskCoordinates2(task);
+      const safeContainerX = isNaN(containerX) || !isFinite(containerX) ? 0 : containerX;
+      const safeContainerWidth = isNaN(containerWidth) || !isFinite(containerWidth) ? 0 : Math.max(containerWidth, 0);
+      const safeWidth = isNaN(width) || !isFinite(width) ? 10 : Math.max(width, 1);
+      const safeLevelY = isNaN(levelY) || !isFinite(levelY) ? 0 : levelY;
+      const safeProgressWidth = isNaN(progressWidth) || !isFinite(progressWidth) ? 0 : Math.max(progressWidth, 0);
+      const safeInnerX1 = isNaN(innerX1) || !isFinite(innerX1) ? 0 : innerX1;
+      const safeInnerX2 = isNaN(innerX2) || !isFinite(innerX2) ? safeInnerX1 + safeWidth : innerX2;
       tasksRes.push(
         /* @__PURE__ */ jsx(
           "svg",
           {
             id: task.id,
             className: `${styles$4.TaskItemWrapper} TaskItemWrapper`,
-            x: Math.max(containerX + (additionalLeftSpace || 0), 0),
-            y: levelY,
-            width: Math.max(containerWidth, 0),
+            x: Math.max(safeContainerX + (additionalLeftSpace || 0), 0),
+            y: safeLevelY,
+            width: Math.max(safeContainerWidth, 0),
             height: fullRowHeight,
             children: /* @__PURE__ */ jsx(
               TaskItem,
@@ -13108,14 +13131,14 @@ const TaskGanttContentInner = (props) => {
                 movingAction: taskBarMovingAction(task),
                 allowMoveTaskBar,
                 hasChildren: checkHasChildren(task, childTasksMap),
-                progressWidth,
-                progressX: rtl ? innerX2 : innerX1,
+                progressWidth: safeProgressWidth,
+                progressX: rtl ? safeInnerX2 : safeInnerX1,
                 onSelectTaskOnMouseDown: selectTaskOnMouseDown,
                 task,
                 taskYOffset,
-                width,
-                x1: innerX1,
-                x2: innerX2,
+                width: safeWidth,
+                x1: safeInnerX1,
+                x2: safeInnerX2,
                 distances,
                 taskHeight,
                 taskHalfHeight,
@@ -13145,16 +13168,20 @@ const TaskGanttContentInner = (props) => {
         )
       );
       if (task.comparisonDates && comparisonDates) {
+        const safeComparisonX = isNaN(comparisonDates.x) || !isFinite(comparisonDates.x) ? 0 : comparisonDates.x;
+        const safeComparisonY = isNaN(comparisonDates.y) || !isFinite(comparisonDates.y) ? safeLevelY : comparisonDates.y;
+        const safeComparisonWidth = isNaN(comparisonDates.width) || !isFinite(comparisonDates.width) ? 0 : Math.max(comparisonDates.width, 0);
+        const safeComparisonHeight = isNaN(comparisonDates.height) || !isFinite(comparisonDates.height) ? 0 : Math.max(comparisonDates.height, 0);
         tasksRes.push(
           /* @__PURE__ */ jsx(
             "svg",
             {
               id: task.id + "_comparison",
               className: "TaskItemWrapperComparison",
-              x: Math.max(comparisonDates.x + (additionalLeftSpace || 0), 0),
-              y: comparisonDates.y,
-              width: comparisonDates.width,
-              height: comparisonDates.height * 2,
+              x: Math.max(safeComparisonX + (additionalLeftSpace || 0), 0),
+              y: safeComparisonY,
+              width: safeComparisonWidth,
+              height: safeComparisonHeight * 2,
               children: /* @__PURE__ */ jsx(
                 BarComparison,
                 {
@@ -13163,8 +13190,8 @@ const TaskGanttContentInner = (props) => {
                   isWarning: !!task.comparisonDates.end && task.comparisonDates.end.getTime() >= task.end.getTime(),
                   isCritical: task.comparisonDates.start.getTime() > task.start.getTime(),
                   barCornerRadius: distances.barCornerRadius,
-                  height: comparisonDates.height,
-                  width: comparisonDates.width,
+                  height: safeComparisonHeight,
+                  width: safeComparisonWidth,
                   borderHeight: distances.barComparisonTaskBorderHeight,
                   yOffset: distances.barComparisonTaskYOffset,
                   task,
@@ -13207,15 +13234,24 @@ const TaskGanttContentInner = (props) => {
             addedDependenciesAtTask[source.id] = true;
             const isCritical2 = criticalPathForTask ? criticalPathForTask.has(source.id) : false;
             const { x1: fromX1, x2: fromX2 } = getTaskCoordinates2(source);
-            const containerX2 = Math.min(fromX1, taskX1) - DELTA_RELATION_WIDTH;
-            const containerWidth2 = Math.max(fromX2, taskX2) - containerX2 + DELTA_RELATION_WIDTH;
+            const safeFromX1 = isNaN(fromX1) || !isFinite(fromX1) ? 0 : fromX1;
+            const safeFromX2 = isNaN(fromX2) || !isFinite(fromX2) ? safeFromX1 + 10 : fromX2;
+            const safeTaskX1 = isNaN(taskX1) || !isFinite(taskX1) ? 0 : taskX1;
+            const safeTaskX2 = isNaN(taskX2) || !isFinite(taskX2) ? safeTaskX1 + 10 : taskX2;
+            const containerX2 = Math.min(safeFromX1, safeTaskX1) - DELTA_RELATION_WIDTH;
+            const containerWidth2 = Math.max(safeFromX2, safeTaskX2) - containerX2 + DELTA_RELATION_WIDTH;
+            const safeArrowContainerX = isNaN(containerX2) || !isFinite(containerX2) ? 0 : containerX2;
+            const safeArrowContainerWidth = isNaN(containerWidth2) || !isFinite(containerWidth2) ? 100 : Math.max(containerWidth2, 0);
             arrowsRes.push(
               /* @__PURE__ */ jsx(
                 "svg",
                 {
-                  x: Math.max(containerX2 + (additionalLeftSpace || 0), 0),
+                  x: Math.max(
+                    safeArrowContainerX + (additionalLeftSpace || 0),
+                    0
+                  ),
                   y: containerY,
-                  width: containerWidth2,
+                  width: safeArrowContainerWidth,
                   height: containerHeight,
                   children: /* @__PURE__ */ jsx(
                     Arrow,
@@ -13223,13 +13259,13 @@ const TaskGanttContentInner = (props) => {
                       distances,
                       taskFrom: source,
                       targetFrom: sourceTarget,
-                      fromX1: fromX1 - containerX2,
-                      fromX2: fromX2 - containerX2,
+                      fromX1: safeFromX1 - safeArrowContainerX,
+                      fromX2: safeFromX2 - safeArrowContainerX,
                       fromY: innerFromY,
                       taskTo: task,
                       targetTo: ownTarget,
-                      toX1: taskX1 - containerX2,
-                      toX2: taskX2 - containerX2,
+                      toX1: safeTaskX1 - safeArrowContainerX,
+                      toX2: safeTaskX2 - safeArrowContainerX,
                       toY: innerToY,
                       fullRowHeight,
                       taskHeight,
@@ -13272,15 +13308,24 @@ const TaskGanttContentInner = (props) => {
             const criticalPathForTask = criticalPathOnLevel ? criticalPathOnLevel.dependencies.get(dependent.id) : void 0;
             const isCritical2 = criticalPathForTask ? criticalPathForTask.has(task.id) : false;
             const { x1: toX1, x2: toX2 } = getTaskCoordinates2(dependent);
-            const containerX2 = Math.min(toX1, taskX1) - DELTA_RELATION_WIDTH;
-            const containerWidth2 = Math.max(toX2, taskX2) - containerX2 + DELTA_RELATION_WIDTH;
+            const safeToX1 = isNaN(toX1) || !isFinite(toX1) ? 0 : toX1;
+            const safeToX2 = isNaN(toX2) || !isFinite(toX2) ? safeToX1 + 10 : toX2;
+            const safeTaskX1 = isNaN(taskX1) || !isFinite(taskX1) ? 0 : taskX1;
+            const safeTaskX2 = isNaN(taskX2) || !isFinite(taskX2) ? safeTaskX1 + 10 : taskX2;
+            const containerX2 = Math.min(safeToX1, safeTaskX1) - DELTA_RELATION_WIDTH;
+            const containerWidth2 = Math.max(safeToX2, safeTaskX2) - containerX2 + DELTA_RELATION_WIDTH;
+            const safeArrowContainerX = isNaN(containerX2) || !isFinite(containerX2) ? 0 : containerX2;
+            const safeArrowContainerWidth = isNaN(containerWidth2) || !isFinite(containerWidth2) ? 100 : Math.max(containerWidth2, 0);
             arrowsRes.push(
               /* @__PURE__ */ jsx(
                 "svg",
                 {
-                  x: Math.max(containerX2 + (additionalLeftSpace || 0), 0),
+                  x: Math.max(
+                    safeArrowContainerX + (additionalLeftSpace || 0),
+                    0
+                  ),
                   y: containerY,
-                  width: containerWidth2,
+                  width: safeArrowContainerWidth,
                   height: containerHeight,
                   children: /* @__PURE__ */ jsx(
                     Arrow,
@@ -13288,13 +13333,13 @@ const TaskGanttContentInner = (props) => {
                       distances,
                       taskFrom: task,
                       targetFrom: ownTarget,
-                      fromX1: taskX1 - containerX2,
-                      fromX2: taskX2 - containerX2,
+                      fromX1: safeTaskX1 - safeArrowContainerX,
+                      fromX2: safeTaskX2 - safeArrowContainerX,
                       fromY: innerFromY,
                       taskTo: dependent,
                       targetTo: dependentTarget,
-                      toX1: toX1 - containerX2,
-                      toX2: toX2 - containerX2,
+                      toX1: safeToX1 - safeArrowContainerX,
+                      toX2: safeToX2 - safeArrowContainerX,
                       toY: innerToY,
                       fullRowHeight,
                       taskHeight,
@@ -13772,21 +13817,26 @@ const countTaskCoordinates = (task, taskToRowIndexMap, startDate, viewMode, rtl,
   if (typeof rowIndex !== "number") {
     throw new Error(`Row index for task ${id} is not found`);
   }
-  const x1 = rtl ? svgWidth - taskXCoordinate(task.end, startDate, viewMode, columnWidth) : taskXCoordinate(task.start, startDate, viewMode, columnWidth);
-  const x2 = rtl ? svgWidth - taskXCoordinate(task.start, startDate, viewMode, columnWidth) : taskXCoordinate(task.end, startDate, viewMode, columnWidth);
+  let x1 = rtl ? svgWidth - taskXCoordinate(task.end, startDate, viewMode, columnWidth) : taskXCoordinate(task.start, startDate, viewMode, columnWidth);
+  let x2 = rtl ? svgWidth - taskXCoordinate(task.start, startDate, viewMode, columnWidth) : taskXCoordinate(task.end, startDate, viewMode, columnWidth);
+  x1 = isNaN(x1) || !isFinite(x1) ? 0 : x1;
+  x2 = isNaN(x2) || !isFinite(x2) ? Math.max(x1, 10) : x2;
   const levelY = rowIndex * fullRowHeight + rowHeight * (comparisonLevel - 1);
   const y = levelY + taskYOffset;
   const [progressWidth, progressX] = type === "milestone" ? [0, x1] : progressWithByParams(x1, x2, progress, rtl);
   const taskX1 = type === "milestone" ? x1 - taskHeight * 0.5 : x1;
   const taskX2 = type === "milestone" ? x2 + taskHeight * 0.5 : x2;
-  const taskWidth = type === "milestone" ? taskHeight : Math.max(taskX2 - taskX1, 10);
-  const containerX = taskX1 - columnWidth;
-  const containerWidth = svgWidth - containerX;
+  let taskWidth = type === "milestone" ? taskHeight : Math.max(taskX2 - taskX1, 10);
+  taskWidth = isNaN(taskWidth) || !isFinite(taskWidth) ? 10 : Math.max(taskWidth, 1);
+  let containerX = taskX1 - columnWidth;
+  containerX = isNaN(containerX) || !isFinite(containerX) ? 0 : containerX;
+  let containerWidth = svgWidth - containerX;
+  containerWidth = isNaN(containerWidth) || !isFinite(containerWidth) ? svgWidth : Math.max(containerWidth, 0);
   const innerX1 = columnWidth;
   const innerX2 = columnWidth + taskWidth;
   let comparisonDates;
   if (task.comparisonDates) {
-    const cx1 = rtl ? svgWidth - taskComparisonXCoordinate(
+    let cx1 = rtl ? svgWidth - taskComparisonXCoordinate(
       task.comparisonDates.end || task.end,
       startDate,
       viewMode,
@@ -13797,7 +13847,7 @@ const countTaskCoordinates = (task, taskToRowIndexMap, startDate, viewMode, rtl,
       viewMode,
       columnWidth
     );
-    const cx2 = rtl ? svgWidth - taskComparisonXCoordinate(
+    let cx2 = rtl ? svgWidth - taskComparisonXCoordinate(
       task.comparisonDates.start,
       startDate,
       viewMode,
@@ -13808,6 +13858,8 @@ const countTaskCoordinates = (task, taskToRowIndexMap, startDate, viewMode, rtl,
       viewMode,
       columnWidth
     );
+    cx1 = isNaN(cx1) || !isFinite(cx1) ? x1 : cx1;
+    cx2 = isNaN(cx2) || !isFinite(cx2) ? x2 : cx2;
     comparisonDates = {
       x: cx1,
       y: y + taskHeight,
@@ -17486,308 +17538,6 @@ const useHorizontalScrollbars = () => {
     scrollToRightStep
   ];
 };
-const usePerformanceMonitor = (enabled = true) => {
-  const metricsRef = useRef([]);
-  const benchmarksRef = useRef(/* @__PURE__ */ new Map());
-  const frameTimesRef = useRef([]);
-  const lastFrameTimeRef = useRef(performance.now());
-  const updateFPS = useCallback(() => {
-    if (!enabled)
-      return;
-    const now = performance.now();
-    const deltaTime = now - lastFrameTimeRef.current;
-    lastFrameTimeRef.current = now;
-    frameTimesRef.current.push(deltaTime);
-    if (frameTimesRef.current.length > 60) {
-      frameTimesRef.current.shift();
-    }
-  }, [enabled]);
-  const getFPS = useCallback(() => {
-    if (frameTimesRef.current.length === 0)
-      return 0;
-    const avgFrameTime = frameTimesRef.current.reduce((sum, time) => sum + time, 0) / frameTimesRef.current.length;
-    return Math.round(1e3 / avgFrameTime);
-  }, []);
-  const startMeasurement = useCallback(
-    (name, metadata) => {
-      if (!enabled)
-        return;
-      performance.mark(`${name}-start`);
-      benchmarksRef.current.set(name, {
-        name,
-        startTime: performance.now(),
-        metadata
-      });
-    },
-    [enabled]
-  );
-  const endMeasurement = useCallback(
-    (name) => {
-      if (!enabled)
-        return 0;
-      const benchmark = benchmarksRef.current.get(name);
-      if (!benchmark) {
-        console.warn(`No benchmark found for ${name}`);
-        return 0;
-      }
-      const endTime = performance.now();
-      const duration = endTime - benchmark.startTime;
-      performance.mark(`${name}-end`);
-      performance.measure(name, `${name}-start`, `${name}-end`);
-      benchmark.endTime = endTime;
-      benchmark.duration = duration;
-      return duration;
-    },
-    [enabled]
-  );
-  const measureFunction = useCallback(
-    (name, fn, metadata) => {
-      return (...args) => {
-        if (!enabled)
-          return fn(...args);
-        startMeasurement(name, metadata);
-        try {
-          const result = fn(...args);
-          return result;
-        } finally {
-          endMeasurement(name);
-        }
-      };
-    },
-    [enabled, startMeasurement, endMeasurement]
-  );
-  const measureAsyncFunction = useCallback(
-    (name, fn, metadata) => {
-      return async (...args) => {
-        if (!enabled)
-          return fn(...args);
-        startMeasurement(name, metadata);
-        try {
-          const result = await fn(...args);
-          return result;
-        } finally {
-          endMeasurement(name);
-        }
-      };
-    },
-    [enabled, startMeasurement, endMeasurement]
-  );
-  const getPerformanceReport = useCallback(() => {
-    const entries = performance.getEntriesByType(
-      "measure"
-    );
-    const report = {};
-    entries.forEach((entry) => {
-      if (!report[entry.name]) {
-        report[entry.name] = {
-          count: 0,
-          totalTime: 0,
-          avgTime: 0,
-          maxTime: 0,
-          minTime: Infinity
-        };
-      }
-      const stat = report[entry.name];
-      stat.count++;
-      stat.totalTime += entry.duration;
-      stat.maxTime = Math.max(stat.maxTime, entry.duration);
-      stat.minTime = Math.min(stat.minTime, entry.duration);
-      stat.avgTime = stat.totalTime / stat.count;
-    });
-    return {
-      measurements: report,
-      fps: getFPS(),
-      currentMetrics: metricsRef.current[metricsRef.current.length - 1],
-      allMetrics: [...metricsRef.current]
-    };
-  }, [getFPS]);
-  const addMetrics = useCallback(
-    (metrics) => {
-      if (!enabled)
-        return;
-      const fullMetrics = {
-        ...metrics,
-        timestamp: Date.now()
-      };
-      metricsRef.current.push(fullMetrics);
-      if (metricsRef.current.length > 100) {
-        metricsRef.current.shift();
-      }
-    },
-    [enabled]
-  );
-  const clearMeasurements = useCallback(() => {
-    performance.clearMarks();
-    performance.clearMeasures();
-    benchmarksRef.current.clear();
-    metricsRef.current.length = 0;
-    frameTimesRef.current.length = 0;
-  }, []);
-  const getMemoryUsage = useCallback(() => {
-    if ("memory" in performance) {
-      const memory = performance.memory;
-      return memory ? memory.usedJSHeapSize : 0;
-    }
-    return 0;
-  }, []);
-  return {
-    startMeasurement,
-    endMeasurement,
-    measureFunction,
-    measureAsyncFunction,
-    getPerformanceReport,
-    addMetrics,
-    clearMeasurements,
-    updateFPS,
-    getFPS,
-    getMemoryUsage,
-    enabled
-  };
-};
-const useAdaptivePerformance = (thresholds) => {
-  const { getFPS, getPerformanceReport } = usePerformanceMonitor();
-  const performanceLevelRef = useRef("high");
-  const updatePerformanceLevel = useCallback(() => {
-    var _a;
-    const fps = getFPS();
-    const report = getPerformanceReport();
-    const renderTime = ((_a = report.measurements["render"]) == null ? void 0 : _a.avgTime) || 0;
-    if (fps < thresholds.fpsThreshold * 0.5 || renderTime > thresholds.renderTimeThreshold * 2) {
-      performanceLevelRef.current = "low";
-    } else if (fps < thresholds.fpsThreshold || renderTime > thresholds.renderTimeThreshold) {
-      performanceLevelRef.current = "medium";
-    } else {
-      performanceLevelRef.current = "high";
-    }
-    return performanceLevelRef.current;
-  }, [getFPS, getPerformanceReport, thresholds]);
-  const getQualitySettings = useCallback(() => {
-    const level = performanceLevelRef.current;
-    switch (level) {
-      case "low":
-        return {
-          enableAnimations: false,
-          renderQuality: "low",
-          maxVisibleTasks: 100,
-          updateFrequency: 500
-          // ms
-        };
-      case "medium":
-        return {
-          enableAnimations: true,
-          renderQuality: "medium",
-          maxVisibleTasks: 500,
-          updateFrequency: 100
-        };
-      case "high":
-      default:
-        return {
-          enableAnimations: true,
-          renderQuality: "high",
-          maxVisibleTasks: 1e3,
-          updateFrequency: 16
-          // 60fps
-        };
-    }
-  }, []);
-  return {
-    performanceLevel: performanceLevelRef.current,
-    updatePerformanceLevel,
-    getQualitySettings
-  };
-};
-const useIncrementalCoordinates = (visibleTasks, visibleTasksMirror, taskToRowIndexMap, startDate, viewMode, rtl, fullRowHeight, taskHeight, taskYOffset, distances, svgWidth, renderedRowIndexes, renderedColumnIndexes) => {
-  const cacheRef = useRef({
-    coordinates: /* @__PURE__ */ new Map(),
-    lastUpdateParams: null
-  });
-  return useMemo(() => {
-    const cache = cacheRef.current;
-    const currentParams = {
-      startDate,
-      viewMode,
-      rtl,
-      fullRowHeight,
-      taskHeight,
-      taskYOffset,
-      svgWidth,
-      distances
-    };
-    const needsFullRecalc = !cache.lastUpdateParams || cache.lastUpdateParams.startDate.getTime() !== startDate.getTime() || cache.lastUpdateParams.viewMode !== viewMode || cache.lastUpdateParams.rtl !== rtl || cache.lastUpdateParams.fullRowHeight !== fullRowHeight || cache.lastUpdateParams.taskHeight !== taskHeight || cache.lastUpdateParams.taskYOffset !== taskYOffset || cache.lastUpdateParams.svgWidth !== svgWidth || JSON.stringify(cache.lastUpdateParams.distances) !== JSON.stringify(distances);
-    if (needsFullRecalc) {
-      cache.coordinates.clear();
-    }
-    const tasksToCalculate = /* @__PURE__ */ new Set();
-    if (renderedRowIndexes && renderedColumnIndexes) {
-      const [startRow, endRow] = renderedRowIndexes;
-      const rowBuffer = Math.max(5, Math.ceil((endRow - startRow) * 0.5));
-      const bufferedStartRow = Math.max(0, startRow - rowBuffer);
-      const bufferedEndRow = endRow + rowBuffer;
-      visibleTasks.forEach((task, index2) => {
-        if (task.type === "empty" || !visibleTasksMirror[task.id])
-          return;
-        if (index2 >= bufferedStartRow && index2 <= bufferedEndRow) {
-          tasksToCalculate.add(task.id);
-        }
-      });
-    } else {
-      visibleTasks.forEach((task) => {
-        if (task.type !== "empty" && visibleTasksMirror[task.id]) {
-          tasksToCalculate.add(task.id);
-        }
-      });
-    }
-    if (!needsFullRecalc) {
-      for (const [taskId] of cache.coordinates) {
-        if (!tasksToCalculate.has(taskId)) {
-          cache.coordinates.delete(taskId);
-        }
-      }
-    }
-    const res = /* @__PURE__ */ new Map();
-    visibleTasks.forEach((task) => {
-      if (task.type === "empty" || !tasksToCalculate.has(task.id))
-        return;
-      const { id, comparisonLevel = 1 } = task;
-      const cacheKey = `${id}_${comparisonLevel}`;
-      let taskCoordinates = cache.coordinates.get(cacheKey);
-      if (!taskCoordinates || needsFullRecalc) {
-        taskCoordinates = countTaskCoordinates(
-          task,
-          taskToRowIndexMap,
-          startDate,
-          viewMode,
-          rtl,
-          fullRowHeight,
-          taskHeight,
-          taskYOffset,
-          distances,
-          svgWidth
-        );
-        cache.coordinates.set(cacheKey, taskCoordinates);
-      }
-      const resByLevel = res.get(comparisonLevel) || /* @__PURE__ */ new Map();
-      resByLevel.set(id, taskCoordinates);
-      res.set(comparisonLevel, resByLevel);
-    });
-    cache.lastUpdateParams = currentParams;
-    return res;
-  }, [
-    visibleTasks,
-    visibleTasksMirror,
-    taskToRowIndexMap,
-    startDate,
-    viewMode,
-    rtl,
-    fullRowHeight,
-    taskHeight,
-    taskYOffset,
-    distances,
-    svgWidth,
-    renderedRowIndexes,
-    renderedColumnIndexes
-  ]);
-};
 const fillMinAndMaxChildsMap = (resOnLevel, task, childTasksOnLevel) => {
   const childs = childTasksOnLevel.get(task.id);
   if (!childs || childs.length === 0) {
@@ -19407,11 +19157,6 @@ const Gantt = (props) => {
     () => getChildsAndRoots(sortedTasks, null),
     [sortedTasks]
   );
-  const adaptiveSettings = useAdaptivePerformance({
-    fpsThreshold: 30,
-    renderTimeThreshold: 16
-    // 60fps = 16ms per frame
-  });
   const minAndMaxChildsMap = useMemo(
     () => getMinAndMaxChildsMap(rootTasksMap, childTasksMap),
     [rootTasksMap, childTasksMap]
@@ -19585,7 +19330,7 @@ const Gantt = (props) => {
       svgWidth
     ]
   );
-  const originalMapTaskToCoordinates = useMemo(
+  const mapTaskToCoordinates = useMemo(
     () => getMapTaskToCoordinates(
       sortedTasks,
       visibleTasksMirror,
@@ -19613,24 +19358,6 @@ const Gantt = (props) => {
       visibleTasksMirror
     ]
   );
-  const optimizedMapTaskToCoordinates = useIncrementalCoordinates(
-    visibleTasks,
-    visibleTasksMirror,
-    taskToRowIndexMap,
-    startDate,
-    viewMode,
-    rtl,
-    fullRowHeight,
-    taskHeight,
-    taskYOffset,
-    distances,
-    svgWidth,
-    null,
-    // renderedRowIndexes - can be integrated later with virtualization
-    null
-    // renderedColumnIndexes - can be integrated later with virtualization
-  );
-  const mapTaskToCoordinates = adaptiveSettings.performanceLevel === "high" ? optimizedMapTaskToCoordinates : originalMapTaskToCoordinates;
   const scrollToTask = useCallback(
     (task) => {
       const { x1 } = getTaskCoordinates(task, mapTaskToCoordinates);