gantt-task-react-v 1.3.2 → 1.3.4

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

@@ -11835,29 +11835,45 @@
     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
     );
@@ -13109,15 +13125,22 @@
           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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
                 TaskItem,
@@ -13125,14 +13148,14 @@
                   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,
@@ -13162,16 +13185,20 @@
           )
         );
         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) ? 10 : Math.max(comparisonDates.width, 1);
+          const safeComparisonHeight = isNaN(comparisonDates.height) || !isFinite(comparisonDates.height) ? 4 : Math.max(comparisonDates.height, 1);
           tasksRes.push(
             /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
                   BarComparison,
                   {
@@ -13180,8 +13207,8 @@
                     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,
@@ -13224,15 +13251,24 @@
               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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
                       Arrow,
@@ -13240,13 +13276,13 @@
                         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,
@@ -13289,15 +13325,24 @@
               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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
                       Arrow,
@@ -13305,13 +13350,13 @@
                         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,
@@ -13789,21 +13834,26 @@
     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,
@@ -13814,7 +13864,7 @@
         viewMode,
         columnWidth
       );
-      const cx2 = rtl ? svgWidth - taskComparisonXCoordinate(
+      let cx2 = rtl ? svgWidth - taskComparisonXCoordinate(
         task.comparisonDates.start,
         startDate,
         viewMode,
@@ -13825,10 +13875,13 @@
         viewMode,
         columnWidth
       );
+      cx1 = isNaN(cx1) || !isFinite(cx1) ? x1 : cx1;
+      cx2 = isNaN(cx2) || !isFinite(cx2) ? x2 : cx2;
       comparisonDates = {
         x: cx1,
         y: y + taskHeight,
-        width: Math.max(cx2 - cx1, 0),
+        width: Math.max(cx2 - cx1, 1),
+        // Ensure minimum width of 1px for visibility
         height: barComparisonTaskHeight
       };
     }
@@ -17503,308 +17556,6 @@
       scrollToRightStep
     ];
   };
-  const usePerformanceMonitor = (enabled = true) => {
-    const metricsRef = React.useRef([]);
-    const benchmarksRef = React.useRef(/* @__PURE__ */ new Map());
-    const frameTimesRef = React.useRef([]);
-    const lastFrameTimeRef = React.useRef(performance.now());
-    const updateFPS = React.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 = React.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 = React.useCallback(
-      (name, metadata) => {
-        if (!enabled)
-          return;
-        performance.mark(`${name}-start`);
-        benchmarksRef.current.set(name, {
-          name,
-          startTime: performance.now(),
-          metadata
-        });
-      },
-      [enabled]
-    );
-    const endMeasurement = React.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 = React.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 = React.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 = React.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 = React.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 = React.useCallback(() => {
-      performance.clearMarks();
-      performance.clearMeasures();
-      benchmarksRef.current.clear();
-      metricsRef.current.length = 0;
-      frameTimesRef.current.length = 0;
-    }, []);
-    const getMemoryUsage = React.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 = React.useRef("high");
-    const updatePerformanceLevel = React.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 = React.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 = React.useRef({
-      coordinates: /* @__PURE__ */ new Map(),
-      lastUpdateParams: null
-    });
-    return React.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) {
@@ -19424,11 +19175,6 @@
       () => getChildsAndRoots(sortedTasks, null),
       [sortedTasks]
     );
-    const adaptiveSettings = useAdaptivePerformance({
-      fpsThreshold: 30,
-      renderTimeThreshold: 16
-      // 60fps = 16ms per frame
-    });
     const minAndMaxChildsMap = React.useMemo(
       () => getMinAndMaxChildsMap(rootTasksMap, childTasksMap),
       [rootTasksMap, childTasksMap]
@@ -19602,7 +19348,7 @@
         svgWidth
       ]
     );
-    const originalMapTaskToCoordinates = React.useMemo(
+    const mapTaskToCoordinates = React.useMemo(
       () => getMapTaskToCoordinates(
         sortedTasks,
         visibleTasksMirror,
@@ -19630,24 +19376,6 @@
         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 = React.useCallback(
       (task) => {
         const { x1 } = getTaskCoordinates(task, mapTaskToCoordinates);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gantt-task-react-v",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Interactive Gantt Chart for React with TypeScript.",
   "author": "aguilanbon",
   "homepage": "https://github.com/aguilanbon/gantt-task-react-v",

package/dist/helpers/use-incremental-coordinates.d.ts

@@ -1,17 +0,0 @@
-import { Distances, MapTaskToCoordinates, TaskCoordinates, RenderTask, TaskToRowIndexMap, ViewMode } from "../types";
-import type { OptimizedListParams } from "./use-optimized-list";
-/**
- * Optimized hook for calculating task coordinates incrementally
- * Only recalculates coordinates for visible tasks and caches results
- */
-export declare const useIncrementalCoordinates: (visibleTasks: readonly RenderTask[], visibleTasksMirror: Readonly<Record<string, true>>, taskToRowIndexMap: TaskToRowIndexMap, startDate: Date, viewMode: ViewMode, rtl: boolean, fullRowHeight: number, taskHeight: number, taskYOffset: number, distances: Distances, svgWidth: number, renderedRowIndexes: OptimizedListParams | null, renderedColumnIndexes: OptimizedListParams | null) => MapTaskToCoordinates;
-/**
- * Hook for getting coordinates of tasks in a specific range only
- * Useful for virtual scrolling scenarios
- */
-export declare const useRangedCoordinates: (tasks: readonly RenderTask[], taskToRowIndexMap: TaskToRowIndexMap, startDate: Date, viewMode: ViewMode, rtl: boolean, fullRowHeight: number, taskHeight: number, taskYOffset: number, distances: Distances, svgWidth: number, startIndex: number, endIndex: number, comparisonLevel?: number) => Map<string, TaskCoordinates>;
-/**
- * Hook for smart coordinate invalidation
- * Tracks which tasks need coordinate recalculation based on their dependencies
- */
-export declare const useCoordinateInvalidation: (tasks: readonly RenderTask[], changedTaskIds: Set<string>) => Set<string>;