zmdms-webui 2.4.8 → 2.5.0

package/dist/es/canvastable/canvasTable.js

@@ -28,7 +28,7 @@ import { useProcessedColumns } from './hooks/useProcessedColumns.js';
 import { useSummaryRow } from './hooks/useSummaryRow.js';
 import { useCanvasTableAutoHeight } from './hooks/useAutoHeight.js';
 import { SCROLLBAR_SIZE } from './utils/constants.js';
-import { calculateColumnRenderInfos, calculateTotalWidth, calculateTotalHeight } from './utils/tableCalculations.js';
+import { calculateColumnRenderInfos, calculateTotalHeight, calculateTotalWidth } from './utils/tableCalculations.js';
 import 'zmdms-utils';
 import 'dayjs';
 import { TABLE_DYNAMIC_KEY } from '../table/constant.js';
@@ -122,9 +122,31 @@ function CanvasTable(props) {
     var containerHeight = containerSize.height;
     // 计算列的渲染信息（使用容器宽度进行自适应填充）
     // 手动调整过宽度的列不参与自动宽度分配
+    // 注意：需要先预判是否会有垂直滚动条，如果有则预留滚动条宽度
     var columnRenderInfos = useMemo(function () {
-        return calculateColumnRenderInfos(processedColumns, containerWidth, manuallyResizedColumnKeys);
-    }, [processedColumns, containerWidth, manuallyResizedColumnKeys]);
+        // 第一步：先用原始列宽计算，判断是否需要垂直滚动条
+        calculateColumnRenderInfos(processedColumns, undefined, // 不进行自适应填充
+        manuallyResizedColumnKeys);
+        // 计算原始总高度
+        var tempTotalHeight = calculateTotalHeight(headerHeight, // 使用基础表头高度做粗略判断
+        finalDataSource.length, rowHeight);
+        // 判断是否需要垂直滚动条
+        var needVerticalScrollbar = tempTotalHeight > containerHeight;
+        // 第二步：计算实际可用宽度（如果需要垂直滚动条，减去滚动条宽度）
+        var availableWidth = needVerticalScrollbar
+            ? containerWidth - SCROLLBAR_SIZE
+            : containerWidth;
+        // 第三步：使用可用宽度进行自适应填充
+        return calculateColumnRenderInfos(processedColumns, availableWidth, manuallyResizedColumnKeys);
+    }, [
+        processedColumns,
+        containerWidth,
+        containerHeight,
+        headerHeight,
+        finalDataSource.length,
+        rowHeight,
+        manuallyResizedColumnKeys,
+    ]);
     // 计算表头动态高度（支持wrap换行）
     // 注意：必须在 columnRenderInfos 计算之后，以便使用实际的列宽
     var calculatedHeaderHeight = useHeaderHeight({

package/dist/es/canvastable/hooks/useScroll.js

@@ -111,37 +111,88 @@ var useTableScroll = function (params) {
                 // 允许过滤弹框内部滚动
                 return;
             }
-            e.preventDefault();
-            e.stopPropagation();
             // 当鼠标在容器内任何位置（包括CellOverlay）时都能滚动
             // 累积滚动增量
             // 支持 Shift + 鼠标滚轮进行水平滚动
+            var deltaX = 0;
+            var deltaY = 0;
             if (e.shiftKey) {
                 // 按住 Shift 键时，将垂直滚动转换为水平滚动
-                pendingDeltaRef.current.deltaX += e.deltaY;
-                pendingDeltaRef.current.deltaY += 0;
+                deltaX = e.deltaY;
+                deltaY = 0;
             }
             else {
                 // 正常滚动逻辑
-                pendingDeltaRef.current.deltaX += e.deltaX;
-                pendingDeltaRef.current.deltaY += e.deltaY;
+                deltaX = e.deltaX;
+                deltaY = e.deltaY;
+            }
+            // 检查是否需要支持父元素滚动
+            // 1. 如果没有滚动条（maxScrollTop 和 maxScrollLeft 都为 0）
+            // 2. 或者已经滚动到底部且继续向下滚动
+            // 3. 或者已经滚动到顶部且继续向上滚动
+            var hasNoVerticalScrollbar = maxScrollTop <= 0;
+            var hasNoHorizontalScrollbar = maxScrollLeft <= 0;
+            var isAtBottom = Math.abs(scrollState.scrollTop - maxScrollTop) < 1;
+            var isAtTop = scrollState.scrollTop <= 0;
+            var isAtRight = Math.abs(scrollState.scrollLeft - maxScrollLeft) < 1;
+            var isAtLeft = scrollState.scrollLeft <= 0;
+            var shouldAllowParentScroll = false;
+            // 垂直滚动检查
+            if (deltaY !== 0) {
+                if (hasNoVerticalScrollbar) {
+                    // 没有垂直滚动条，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
+                else if (deltaY > 0 && isAtBottom) {
+                    // 向下滚动且已在底部，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
+                else if (deltaY < 0 && isAtTop) {
+                    // 向上滚动且已在顶部，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
             }
+            // 水平滚动检查
+            if (deltaX !== 0) {
+                if (hasNoHorizontalScrollbar) {
+                    // 没有水平滚动条，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
+                else if (deltaX > 0 && isAtRight) {
+                    // 向右滚动且已在右边界，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
+                else if (deltaX < 0 && isAtLeft) {
+                    // 向左滚动且已在左边界，允许父元素滚动
+                    shouldAllowParentScroll = true;
+                }
+            }
+            // 如果需要支持父元素滚动，不阻止默认行为
+            if (shouldAllowParentScroll) {
+                return;
+            }
+            // 阻止默认行为和事件冒泡
+            e.preventDefault();
+            e.stopPropagation();
+            // 累积滚动增量
+            pendingDeltaRef.current.deltaX += deltaX;
+            pendingDeltaRef.current.deltaY += deltaY;
             // 如果已经有pending的动画帧，不需要再次请求
             if (rafIdRef.current !== null) {
                 return;
             }
             // 使用 requestAnimationFrame 节流更新
             rafIdRef.current = requestAnimationFrame(function () {
-                var deltaX = pendingDeltaRef.current.deltaX;
-                var deltaY = pendingDeltaRef.current.deltaY;
+                var accumulatedDeltaX = pendingDeltaRef.current.deltaX;
+                var accumulatedDeltaY = pendingDeltaRef.current.deltaY;
                 // 重置累积的增量
                 pendingDeltaRef.current.deltaX = 0;
                 pendingDeltaRef.current.deltaY = 0;
                 rafIdRef.current = null;
                 // 批量更新状态
                 setScrollState(function (prev) {
-                    var newScrollTop = Math.max(0, Math.min(maxScrollTop, prev.scrollTop + deltaY));
-                    var newScrollLeft = Math.max(0, Math.min(maxScrollLeft, prev.scrollLeft + deltaX));
+                    var newScrollTop = Math.max(0, Math.min(maxScrollTop, prev.scrollTop + accumulatedDeltaY));
+                    var newScrollLeft = Math.max(0, Math.min(maxScrollLeft, prev.scrollLeft + accumulatedDeltaX));
                     if (newScrollTop !== prev.scrollTop ||
                         newScrollLeft !== prev.scrollLeft) {
                         onScroll === null || onScroll === void 0 ? void 0 : onScroll(newScrollLeft, newScrollTop);
@@ -162,7 +213,7 @@ var useTableScroll = function (params) {
                 rafIdRef.current = null;
             }
         };
-    }, [containerRef, maxScrollTop, maxScrollLeft, onScroll, setScrollState]);
+    }, [containerRef, maxScrollTop, maxScrollLeft, onScroll, setScrollState, scrollState.scrollTop, scrollState.scrollLeft]);
     // 全局鼠标事件处理（拖拽滚动条）
     useEffect(function () {
         var handleGlobalMouseUp = function () {

package/dist/es/canvastable/hooks/useTableInteraction.js

@@ -35,6 +35,7 @@ var useTableInteraction = function (params) {
             displayHeight: containerHeight,
             needHorizontalScrollbar: needHorizontalScrollbar,
             scrollbarSize: scrollbarSize,
+            mergeCellMap: mergeCellMap,
         });
     });
     // 处理选择框列的全选点击

package/dist/es/canvastable/hooks/useTableRender.js

@@ -621,7 +621,7 @@ var useTableRender = function (params) {
                     // 合计行选择框列显示文本（比如"合计"）
                     var dataIndex = column.dataIndex || column.key;
                     var cellValue = record[dataIndex];
-                    var cellText = formatCellValue(cellValue, column);
+                    var cellText = formatCellValue(cellValue, column, true);
                     if (cellText) {
                         ctx.fillStyle = COLORS.text;
                         ctx.font = "bold ".concat(FONT_SIZE, "px ").concat(FONT_FAMILY);
@@ -656,7 +656,7 @@ var useTableRender = function (params) {
                     // 应用格式化（日期、精度、千分符）
                     var cellText = void 0;
                     // 对于合计行，直接使用格式化函数，不应用render
-                    if (isSummaryRow) {
+                    if (isSummaryRow && column.key !== "__index__") {
                         cellText = formatCellValue(cellValue, column);
                     }
                     else {
@@ -800,8 +800,24 @@ var useTableRender = function (params) {
             ctx.stroke();
             ctx.lineWidth = 1; // 恢复为1px
         }
-        // 计算实际数据区域的底部位置
-        var dataBottomY = Math.min(headerHeight + dataRowCount * rowHeight - scrollState.scrollTop, displayHeight);
+        // 计算固定行占用的高度
+        var fixedTopRowsCount = fixedRowsCount || (fixedRowsConfig === null || fixedRowsConfig === void 0 ? void 0 : fixedRowsConfig.topCount) || 0;
+        var fixedBottomRowsCount = (fixedRowsConfig === null || fixedRowsConfig === void 0 ? void 0 : fixedRowsConfig.bottomCount) || 0;
+        var fixedSummaryHeight = summaryFixed && hasSummaryRow ? rowHeight : 0;
+        var fixedBottomHeight = fixedBottomRowsCount * rowHeight;
+        // 计算可滚动数据行的数量（排除固定行和合计行）
+        var scrollableDataRowCount = dataRowCount -
+            fixedTopRowsCount -
+            fixedBottomRowsCount -
+            (summaryFixed && hasSummaryRow ? 1 : 0);
+        // 计算实际数据区域的底部位置（考虑固定底部行和固定合计行）
+        var dataBottomY = Math.min(headerHeight +
+            fixedTopRowsCount * rowHeight +
+            scrollableDataRowCount * rowHeight -
+            scrollState.scrollTop, displayHeight -
+            (needHorizontalScrollbar ? SCROLLBAR_SIZE : 0) -
+            fixedBottomHeight -
+            fixedSummaryHeight);
         // 绘制垂直边框（只绘制body部分，从headerHeight开始，表头边框在drawHeaderCell中绘制）
         columnRenderInfos.forEach(function (info, colIndex) {
             var x = info.x, width = info.width, fixed = info.fixed, fixedLeft = info.fixedLeft;
@@ -823,9 +839,17 @@ var useTableRender = function (params) {
                 ctx.stroke();
             }
         });
+        // 绘制水平边框（只绘制实际数据行的边框）
+        var maxRow = Math.min(endRow, dataRowCount, fixedTopRowsCount + scrollableDataRowCount);
         var _loop_1 = function (i) {
-            var y = headerHeight + i * rowHeight - scrollState.scrollTop;
-            if (y >= headerHeight && y <= displayHeight) {
+            // 计算Y坐标时需要考虑固定顶部行
+            var y = headerHeight +
+                fixedTopRowsCount * rowHeight +
+                (i - fixedTopRowsCount) * rowHeight -
+                scrollState.scrollTop;
+            // 只绘制在可滚动数据区域内的边框
+            if (y >= headerHeight + fixedTopRowsCount * rowHeight &&
+                y <= dataBottomY) {
                 // 分段绘制，只绘制当前范围（fixed或非fixed）的边框
                 columnRenderInfos.forEach(function (info, colIndex) {
                     // 根据 onlyFixed 参数过滤
@@ -856,8 +880,7 @@ var useTableRender = function (params) {
                 });
             }
         };
-        // 绘制水平边框（只绘制实际数据行的边框）
-        for (var i = startRow; i <= endRow && i <= dataRowCount; i++) {
+        for (var i = startRow; i <= maxRow; i++) {
             _loop_1(i);
         }
         // 为合并单元格绘制底部边框
@@ -865,8 +888,8 @@ var useTableRender = function (params) {
             mergeCellMap.forEach(function (mergeInfo, key) {
                 if (!mergeInfo.skip && mergeInfo.rowSpan > 1) {
                     var rowIndex = mergeInfo.rowIndex, colIndex = mergeInfo.colIndex, rowSpan = mergeInfo.rowSpan;
-                    // 只绘制在可视范围内的
-                    if (rowIndex >= startRow && rowIndex <= endRow) {
+                    // 只绘制在可视范围内的且在数据区域内的
+                    if (rowIndex >= startRow && rowIndex <= maxRow) {
                         var columnInfo = columnRenderInfos[colIndex];
                         if (!columnInfo)
                             return;
@@ -880,11 +903,14 @@ var useTableRender = function (params) {
                             ? getColumnWidth(colIndex)
                             : width;
                         var drawX = fixed ? fixedLeft : x - scrollState.scrollLeft;
-                        // 绘制合并单元格的底边框
+                        // 绘制合并单元格的底边框，考虑固定顶部行
                         var bottomY = headerHeight +
-                            (rowIndex + rowSpan) * rowHeight -
+                            fixedTopRowsCount * rowHeight +
+                            (rowIndex + rowSpan - fixedTopRowsCount) * rowHeight -
                             scrollState.scrollTop;
-                        if (bottomY >= headerHeight && bottomY <= displayHeight) {
+                        // 只在数据区域内绘制
+                        if (bottomY >= headerHeight + fixedTopRowsCount * rowHeight &&
+                            bottomY <= dataBottomY) {
                             ctx.beginPath();
                             ctx.moveTo(drawX, bottomY);
                             ctx.lineTo(drawX + actualWidth, bottomY);

package/dist/es/canvastable/utils/cellHelpers.js

@@ -5,7 +5,7 @@
  * 获取鼠标位置对应的单元格
  */
 var getCellFromMousePosition = function (params) {
-    var x = params.x, y = params.y, headerHeight = params.headerHeight, rowHeight = params.rowHeight, scrollTop = params.scrollTop, scrollLeft = params.scrollLeft, columnRenderInfos = params.columnRenderInfos, dataLength = params.dataLength, _a = params.fixedTopRowsCount, fixedTopRowsCount = _a === void 0 ? 0 : _a, _b = params.fixedBottomRowsCount, fixedBottomRowsCount = _b === void 0 ? 0 : _b, _c = params.hasSummaryRow, hasSummaryRow = _c === void 0 ? false : _c, _d = params.summaryFixed, summaryFixed = _d === void 0 ? false : _d, _e = params.displayHeight, displayHeight = _e === void 0 ? 0 : _e, _f = params.needHorizontalScrollbar, needHorizontalScrollbar = _f === void 0 ? false : _f, _g = params.scrollbarSize, scrollbarSize = _g === void 0 ? 12 : _g;
+    var x = params.x, y = params.y, headerHeight = params.headerHeight, rowHeight = params.rowHeight, scrollTop = params.scrollTop, scrollLeft = params.scrollLeft, columnRenderInfos = params.columnRenderInfos, dataLength = params.dataLength, _a = params.fixedTopRowsCount, fixedTopRowsCount = _a === void 0 ? 0 : _a, _b = params.fixedBottomRowsCount, fixedBottomRowsCount = _b === void 0 ? 0 : _b, _c = params.hasSummaryRow, hasSummaryRow = _c === void 0 ? false : _c, _d = params.summaryFixed, summaryFixed = _d === void 0 ? false : _d, _e = params.displayHeight, displayHeight = _e === void 0 ? 0 : _e, _f = params.needHorizontalScrollbar, needHorizontalScrollbar = _f === void 0 ? false : _f, _g = params.scrollbarSize, scrollbarSize = _g === void 0 ? 12 : _g, mergeCellMap = params.mergeCellMap;
     // 判断是否在表头区域（row=-1表示表头）
     var rowIndex;
     if (y < headerHeight) {
@@ -20,7 +20,7 @@ var getCellFromMousePosition = function (params) {
             rowIndex = Math.floor(relativeY / rowHeight);
             if (rowIndex < 0 || rowIndex >= fixedTopRowsCount)
                 return null;
-            return findColumn(x, scrollLeft, columnRenderInfos, rowIndex);
+            return findColumn(x, scrollLeft, columnRenderInfos, rowIndex, mergeCellMap);
         }
         // 检查是否在固定合计行区域
         if (summaryFixed && hasSummaryRow && displayHeight > 0) {
@@ -30,7 +30,7 @@ var getCellFromMousePosition = function (params) {
             if (y >= summaryRowY) {
                 // 在固定合计行区域
                 rowIndex = dataLength - 1; // 合计行是最后一行
-                return findColumn(x, scrollLeft, columnRenderInfos, rowIndex);
+                return findColumn(x, scrollLeft, columnRenderInfos, rowIndex, mergeCellMap);
             }
         }
         // 检查是否在固定底部行区域
@@ -54,7 +54,7 @@ var getCellFromMousePosition = function (params) {
                 rowIndex = bottomRowsStartIndex + relativeIndex;
                 if (rowIndex < 0 || rowIndex >= dataLength)
                     return null;
-                return findColumn(x, scrollLeft, columnRenderInfos, rowIndex);
+                return findColumn(x, scrollLeft, columnRenderInfos, rowIndex, mergeCellMap);
             }
         }
         // 在可滚动区域
@@ -71,12 +71,13 @@ var getCellFromMousePosition = function (params) {
             return null;
         }
     }
-    return findColumn(x, scrollLeft, columnRenderInfos, rowIndex);
+    return findColumn(x, scrollLeft, columnRenderInfos, rowIndex, mergeCellMap);
 };
 /**
  * 根据x坐标查找列索引
  */
-function findColumn(x, scrollLeft, columnRenderInfos, rowIndex) {
+function findColumn(x, scrollLeft, columnRenderInfos, rowIndex, mergeCellMap) {
+    var foundCell = null;
     // 优先查找fixed列（因为fixed列在上层，会遮挡下层的非fixed列）
     for (var i = 0; i < columnRenderInfos.length; i++) {
         var info = columnRenderInfos[i];
@@ -84,22 +85,58 @@ function findColumn(x, scrollLeft, columnRenderInfos, rowIndex) {
             var fixedLeft = info.fixedLeft, width = info.width;
             var drawX = fixedLeft;
             if (x >= drawX && x < drawX + width) {
-                return { row: rowIndex, col: i };
+                foundCell = { row: rowIndex, col: i };
+                break;
             }
         }
     }
     // 如果不在fixed列上，再查找非fixed列
-    for (var i = 0; i < columnRenderInfos.length; i++) {
-        var info = columnRenderInfos[i];
-        if (!info.fixed) {
-            var width = info.width;
-            var drawX = info.x - scrollLeft;
-            if (x >= drawX && x < drawX + width) {
-                return { row: rowIndex, col: i };
+    if (!foundCell) {
+        for (var i = 0; i < columnRenderInfos.length; i++) {
+            var info = columnRenderInfos[i];
+            if (!info.fixed) {
+                var width = info.width;
+                var drawX = info.x - scrollLeft;
+                if (x >= drawX && x < drawX + width) {
+                    foundCell = { row: rowIndex, col: i };
+                    break;
+                }
+            }
+        }
+    }
+    // 如果找到了单元格，检查它是否是被合并的单元格
+    if (foundCell && mergeCellMap) {
+        var mergeCellKey = "".concat(foundCell.row, "-").concat(foundCell.col);
+        var mergeInfo = mergeCellMap.get(mergeCellKey);
+        // 如果是被合并的单元格（skip=true），需要找到主单元格
+        if (mergeInfo && mergeInfo.skip) {
+            // 遍历所有可能的主单元格位置（从左上角开始，到当前位置）
+            // 找到覆盖当前位置的主单元格
+            for (var checkRow = 0; checkRow <= foundCell.row; checkRow++) {
+                for (var checkCol = 0; checkCol <= foundCell.col; checkCol++) {
+                    var mainCellKey = "".concat(checkRow, "-").concat(checkCol);
+                    var mainMergeInfo = mergeCellMap.get(mainCellKey);
+                    // 找到主单元格（skip=false且有合并）
+                    if (mainMergeInfo &&
+                        !mainMergeInfo.skip &&
+                        (mainMergeInfo.rowSpan > 1 || mainMergeInfo.colSpan > 1)) {
+                        // 计算主单元格覆盖的范围
+                        var mainCellEndRow = checkRow + mainMergeInfo.rowSpan - 1;
+                        var mainCellEndCol = checkCol + mainMergeInfo.colSpan - 1;
+                        // 检查当前位置是否在主单元格的覆盖范围内
+                        if (foundCell.row >= checkRow &&
+                            foundCell.row <= mainCellEndRow &&
+                            foundCell.col >= checkCol &&
+                            foundCell.col <= mainCellEndCol) {
+                            // 返回主单元格的坐标
+                            return { row: checkRow, col: checkCol };
+                        }
+                    }
+                }
             }
         }
     }
-    return null;
+    return foundCell;
 }
 /**
  * 提取单元格文本（处理 render 函数）

package/dist/es/canvastable/utils/formatHelpers.js

@@ -17,9 +17,11 @@ var formatDate = function (value, format) {
 /**
  * 格式化单元格值
  */
-var formatCellValue = function (value, column) {
+var formatCellValue = function (value, column, noEmptyText) {
     // 空值处理：null、undefined、空字符串
     if (value === null || value === undefined || value === "") {
+        if (noEmptyText)
+            return "";
         return column.emptyText !== undefined ? column.emptyText : "— —";
     }
     var formattedValue = value;
@@ -28,7 +30,7 @@ var formatCellValue = function (value, column) {
         formattedValue = formatDate(formattedValue, column.dateFormat);
     }
     // 数值精度
-    if (column.precision !== undefined && typeof formattedValue === "number") {
+    if (column.precision !== undefined) {
         formattedValue = exactRound(formattedValue, column.precision);
     }
     // 千分符

package/dist/es/canvastable/utils/tableCalculations.js

@@ -88,18 +88,26 @@ var calculateTotalHeight = function (headerHeight, dataLength, rowHeight) {
  */
 var calculateScrollbarMetrics = function (params) {
     var containerWidth = params.containerWidth, containerHeight = params.containerHeight, totalWidth = params.totalWidth, totalHeight = params.totalHeight, headerHeight = params.headerHeight, scrollbarSize = params.scrollbarSize, minScrollbarSize = params.minScrollbarSize, scrollTop = params.scrollTop, scrollLeft = params.scrollLeft;
-    // 是否需要显示滚动条
+    // 计算实际可用的内容区域尺寸
+    // 注意：需要先确定是否需要滚动条，这里采用两次判断的方式
+    // 第一次判断：基于原始容器尺寸
     var needVerticalScrollbar = totalHeight > containerHeight;
     var needHorizontalScrollbar = totalWidth > containerWidth;
-    // 计算可滚动的最大值
-    // maxScrollTop 需要考虑水平滚动条占用的空间
-    // 当有水平滚动条时，数据可视区域减少了 scrollbarSize 的高度
-    var maxScrollTop = Math.max(0, totalHeight -
-        containerHeight +
-        (needHorizontalScrollbar ? scrollbarSize : 0));
-    // maxScrollLeft 需要考虑垂直滚动条占用的空间
-    // 当有垂直滚动条时，数据可视区域减少了 scrollbarSize 的宽度
-    var maxScrollLeft = Math.max(0, totalWidth - containerWidth + (needVerticalScrollbar ? scrollbarSize : 0));
+    // 第二次判断：考虑滚动条互相影响
+    // 如果有垂直滚动条，可用宽度会减少，可能导致需要水平滚动条
+    if (needVerticalScrollbar && !needHorizontalScrollbar) {
+        needHorizontalScrollbar = totalWidth > containerWidth - scrollbarSize;
+    }
+    // 如果有水平滚动条，可用高度会减少，可能导致需要垂直滚动条
+    if (needHorizontalScrollbar && !needVerticalScrollbar) {
+        needVerticalScrollbar = totalHeight > containerHeight - scrollbarSize;
+    }
+    // 计算实际可用的内容区域尺寸（减去滚动条占用的空间）
+    var availableWidth = containerWidth - (needVerticalScrollbar ? scrollbarSize : 0);
+    var availableHeight = containerHeight - (needHorizontalScrollbar ? scrollbarSize : 0);
+    // 计算可滚动的最大值（基于实际可用空间）
+    var maxScrollTop = Math.max(0, totalHeight - availableHeight);
+    var maxScrollLeft = Math.max(0, totalWidth - availableWidth);
     // 计算数据区域高度（不包括表头和水平滚动条）
     var dataAreaHeight = containerHeight -
         headerHeight -

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zmdms-webui",
-  "version": "2.4.8",
+  "version": "2.5.0",
   "private": false,
   "main": "dist/index.es.js",
   "module": "dist/index.es.js",