zmdms-webui 2.3.6 → 2.3.8

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

@@ -9,8 +9,9 @@ import { getLeafColumns } from './multiHeaderHelpers.js';
  * 注意：多级表头时，只处理叶子列（用于渲染数据）
  * @param columns 列配置
  * @param containerWidth 容器宽度（可选），如果提供且总宽度小于容器宽度，会自动填充
+ * @param manuallyResizedColumns 用户手动调整过宽度的列的key集合（可选），这些列不参与自动宽度分配
  */
-var calculateColumnRenderInfos = function (columns, containerWidth) {
+var calculateColumnRenderInfos = function (columns, containerWidth, manuallyResizedColumns) {
     // 获取叶子列（多级表头时只有叶子列才渲染数据）
     var leafColumns = getLeafColumns(columns);
     // 第一次计算：使用原始宽度
@@ -27,13 +28,21 @@ var calculateColumnRenderInfos = function (columns, containerWidth) {
         totalWidth += columnWidth;
     });
     // 如果提供了容器宽度且总宽度小于容器宽度，将剩余宽度平分到各列
-    // 注意：序号列和勾选框列除外，保持原宽度
+    // 注意：序号列、勾选框列、手动调整过的列除外，保持原宽度
     if (containerWidth && totalWidth < containerWidth) {
         var remainingWidth = containerWidth - totalWidth;
-        // 统计需要平分宽度的列（排除序号列和勾选框列）
+        // 统计需要平分宽度的列（排除序号列、勾选框列和手动调整过的列）
         var columnsToExpand = tempInfos.filter(function (info) {
             var key = info.column.key;
-            return key !== "__index__" && key !== "__selection__";
+            // 排除序号列和勾选框列
+            if (key === "__index__" || key === "__selection__") {
+                return false;
+            }
+            // 排除用户手动调整过宽度的列
+            if (manuallyResizedColumns && manuallyResizedColumns.has(key)) {
+                return false;
+            }
+            return true;
         });
         if (columnsToExpand.length > 0) {
             var additionalWidthPerColumn_1 = remainingWidth / columnsToExpand.length;

package/dist/es/table/hooks.js

@@ -423,7 +423,8 @@ function useAutoMerge(dataSource, columns, _a) {
             if (!mergeKeys)
                 return dataSource;
             else {
-                var newDataSource_2 = flattenRecordsOptimized(__spreadArray([], (dataSource || []), true), mergeKeys, dimensionSummaryKeys, summaryKeys, isDimensionDynamic, order, dimensionCustomSumKeys);
+                var newDataSource_2 = flattenRecordsOptimized(__spreadArray([], (dataSource || []), true), mergeKeys, dimensionSummaryKeys, summaryKeys, isDimensionDynamic, order, dimensionCustomSumKeys, columns // 添加 columns 参数，支持自定义排序
+                );
                 return newDataSource_2;
             }
         }
@@ -436,6 +437,7 @@ function useAutoMerge(dataSource, columns, _a) {
         isDimensionDynamic,
         order,
         dimensionCustomSumKeys,
+        columns, // 添加 columns 依赖
     ]);
     var newColumns = useMemo(function () {
         var _columns = columns;

package/dist/es/table/utils.js

@@ -449,7 +449,7 @@ function startColumnInsertTableData(options) {
  * @param summaryKeys 合计字段
  * @param isDimensionDynamic 维度合并
  */
-function flattenRecordsOptimized(records, mergeKeys, dimensionSummaryKeys, summaryKeys, isDimensionDynamic, order, dimensionCustomSumKeys) {
+function flattenRecordsOptimized(records, mergeKeys, dimensionSummaryKeys, summaryKeys, isDimensionDynamic, order, dimensionCustomSumKeys, columns) {
     var _a;
     if (!records ||
         records.length === 0 ||
@@ -461,7 +461,7 @@ function flattenRecordsOptimized(records, mergeKeys, dimensionSummaryKeys, summa
     var result = [];
     // 如果order没有排序方向，但isDimensionDynamic为true，则按维度字段排序
     if (isDimensionDynamic) {
-        result = sortByDimensions(__spreadArray([], records, true), mergeKeys);
+        result = sortByDimensions(__spreadArray([], records, true), mergeKeys, undefined, columns);
     }
     // 否则保持原样
     else {
@@ -478,6 +478,7 @@ function flattenRecordsOptimized(records, mergeKeys, dimensionSummaryKeys, summa
         // 开启自定义维度后因为最后一个维度字段会合并为一行，所以可以不排序最后一个维度字段
         mergeKeys: isDimensionDynamic ? mergeKeys.slice(0, -1) : mergeKeys,
         order: order,
+        columns: columns,
     });
     // 2. 首先插入维度合计行
     if (dimensionSummaryKeys &&
@@ -579,10 +580,10 @@ function flattenRecordsOptimized(records, mergeKeys, dimensionSummaryKeys, summa
     return result;
 }
 function sortRecords(_a) {
-    var records = _a.records, mergeKeys = _a.mergeKeys, order = _a.order;
+    var records = _a.records, mergeKeys = _a.mergeKeys, order = _a.order, columns = _a.columns;
     var result = [];
     if (order && order.order) {
-        result = sortByDimensions(__spreadArray([], records, true), mergeKeys, order);
+        result = sortByDimensions(__spreadArray([], records, true), mergeKeys, order, columns);
     }
     // 否则保持原样
     else {
@@ -597,92 +598,145 @@ function sortRecords(_a) {
  * @param dimensionKeys 维度字段
  * @param order 排序配置
  */
-function sortByDimensions(records, dimensionKeys, order) {
-    return records.sort(function (a, b) {
-        // 如果有排序配置且有排序方向
-        if (order && order.order && order.field) {
-            var field = order.field, sortOrder = order.order;
-            // 找到排序字段在维度字段中的位置
-            var sortFieldIndex = dimensionKeys.indexOf(field);
-            if (sortFieldIndex !== -1) {
-                // 先按维度字段排序到排序字段之前的字段
-                for (var i = 0; i < sortFieldIndex; i++) {
-                    var key = dimensionKeys[i];
-                    var valueA_1 = a[key] || "";
-                    var valueB_1 = b[key] || "";
-                    // 字符串比较
-                    if (valueA_1 < valueB_1)
-                        return -1;
-                    if (valueA_1 > valueB_1)
-                        return 1;
-                    // 如果当前字段相等，继续比较下一个字段
-                }
-                // 按排序字段进行排序
-                var valueA = a[field] || "";
-                var valueB = b[field] || "";
-                var compareResult = 0;
-                if (valueA < valueB)
-                    compareResult = -1;
-                else if (valueA > valueB)
-                    compareResult = 1;
-                if (compareResult !== 0) {
-                    return sortOrder === "ascend" ? compareResult : -compareResult;
+function sortByDimensions(records, dimensionKeys, order, columns) {
+    // 根据字段名查找对应的列配置
+    var findColumnByKey = function (field) {
+        if (!columns)
+            return null;
+        var findInColumns = function (cols) {
+            for (var _i = 0, cols_1 = cols; _i < cols_1.length; _i++) {
+                var col = cols_1[_i];
+                if (col.key === field || col.dataIndex === field) {
+                    return col;
                 }
-                // 如果排序字段相等，继续按后面的维度字段排序
-                for (var i = sortFieldIndex + 1; i < dimensionKeys.length; i++) {
-                    var key = dimensionKeys[i];
-                    var valueA_2 = a[key] || "";
-                    var valueB_2 = b[key] || "";
-                    // 字符串比较
-                    if (valueA_2 < valueB_2)
-                        return -1;
-                    if (valueA_2 > valueB_2)
-                        return 1;
-                    // 如果当前字段相等，继续比较下一个字段
+                // 如果有子列，递归查找
+                if (col.children && Array.isArray(col.children)) {
+                    var found = findInColumns(col.children);
+                    if (found)
+                        return found;
                 }
             }
+            return null;
+        };
+        return findInColumns(columns);
+    };
+    // 通用排序比较函数
+    var compareValues = function (valueA, valueB, order, recordA, recordB, field) {
+        // 处理 null/undefined
+        if (valueA === valueB)
+            return 0;
+        if (valueA === null || valueA === undefined)
+            return 1;
+        if (valueB === null || valueB === undefined)
+            return -1;
+        var compareResult = 0;
+        // 如果提供了字段名，尝试获取自定义排序函数
+        if (field && recordA && recordB) {
+            var column = findColumnByKey(field);
+            if (column && typeof column.sorter === "function") {
+                // 使用列配置中的自定义排序函数
+                compareResult = column.sorter(recordA, recordB);
+            }
             else {
-                // 如果排序字段不在维度字段中，按原逻辑排序维度字段
-                for (var i = 0; i < dimensionKeys.length; i++) {
-                    var key = dimensionKeys[i];
-                    var valueA_3 = a[key] || "";
-                    var valueB_3 = b[key] || "";
-                    // 字符串比较
-                    if (valueA_3 < valueB_3)
-                        return -1;
-                    if (valueA_3 > valueB_3)
-                        return 1;
-                    // 如果当前字段相等，继续比较下一个字段
-                }
-                // 最后按排序字段排序
-                var valueA = a[field] || "";
-                var valueB = b[field] || "";
-                var compareResult = 0;
-                if (valueA < valueB)
-                    compareResult = -1;
-                else if (valueA > valueB)
-                    compareResult = 1;
-                if (compareResult !== 0) {
-                    return sortOrder === "ascend" ? compareResult : -compareResult;
-                }
+                // 使用默认排序逻辑
+                compareResult = getDefaultCompareResult(valueA, valueB);
             }
         }
         else {
-            // 没有排序配置，按原逻辑排序
-            for (var i = 0; i < dimensionKeys.length; i++) {
-                var key = dimensionKeys[i];
-                var valueA = a[key] || "";
-                var valueB = b[key] || "";
-                // 字符串比较
-                if (valueA < valueB)
-                    return -1;
-                if (valueA > valueB)
-                    return 1;
-                // 如果当前字段相等，继续比较下一个字段
+            // 使用默认排序逻辑
+            compareResult = getDefaultCompareResult(valueA, valueB);
+        }
+        return compareResult !== 0
+            ? order === "ascend"
+                ? compareResult
+                : -compareResult
+            : 0;
+    };
+    // 默认排序比较逻辑
+    var getDefaultCompareResult = function (valueA, valueB) {
+        // 数字比较
+        if (typeof valueA === "number" && typeof valueB === "number") {
+            return valueA - valueB;
+        }
+        // 字符串比较（使用 localeCompare 支持中文等）
+        else {
+            return String(valueA).localeCompare(String(valueB), "zh-CN", {
+                numeric: true,
+                sensitivity: "base", // 忽略大小写和重音符号
+            });
+        }
+    };
+    // 通用的分层分组函数
+    var groupByDimensionsHierarchical = function (data, dimensions, currentDimensionIndex, sortConfig) {
+        if (currentDimensionIndex === void 0) { currentDimensionIndex = 0; }
+        if (currentDimensionIndex >= dimensions.length) {
+            // 到达叶子节点，如果排序字段不是维度字段，在这里排序
+            if (sortConfig && !dimensions.includes(sortConfig.field)) {
+                return data.sort(function (a, b) {
+                    var valueA = a[sortConfig.field];
+                    var valueB = b[sortConfig.field];
+                    return compareValues(valueA, valueB, sortConfig.order, a, b, sortConfig.field);
+                });
+            }
+            else {
+                // 无排序配置或排序字段是维度字段，直接返回
+                return data;
             }
         }
-        return 0; // 所有字段都相等
-    });
+        var currentDimension = dimensions[currentDimensionIndex];
+        // 按当前维度分组，同时记录原始值用于排序
+        var groupData = new Map();
+        var groupOrder = []; // 记录分组出现的顺序
+        data.forEach(function (item) {
+            var value = item[currentDimension];
+            var key = String(value || "");
+            if (!groupData.has(key)) {
+                groupData.set(key, { items: [], originalValue: value });
+                groupOrder.push(key); // 记录第一次出现的顺序
+            }
+            groupData.get(key).items.push(item);
+        });
+        // 如果当前维度是排序字段，对分组的key进行排序
+        var finalGroupOrder = groupOrder;
+        if (sortConfig && sortConfig.field === currentDimension) {
+            finalGroupOrder = __spreadArray([], groupOrder, true).sort(function (keyA, keyB) {
+                // 使用保存的原始值进行比较
+                var valueA = groupData.get(keyA).originalValue;
+                var valueB = groupData.get(keyB).originalValue;
+                // 获取对应的记录用于自定义排序
+                var recordA = groupData.get(keyA).items[0];
+                var recordB = groupData.get(keyB).items[0];
+                return compareValues(valueA, valueB, sortConfig.order, recordA, recordB, sortConfig.field);
+            });
+        }
+        // 递归处理每个分组的子维度，并按排序后的顺序合并结果
+        var result = [];
+        for (var _i = 0, finalGroupOrder_1 = finalGroupOrder; _i < finalGroupOrder_1.length; _i++) {
+            var groupKey = finalGroupOrder_1[_i];
+            var group = groupData.get(groupKey);
+            var sortedGroupData = groupByDimensionsHierarchical(group.items, dimensions, currentDimensionIndex + 1, sortConfig);
+            result.push.apply(result, sortedGroupData);
+        }
+        return result;
+    };
+    // 根据是否有排序配置调用分组函数
+    var sortConfig;
+    if (order && order.order && order.field) {
+        // 如果有明确的排序配置，使用它
+        sortConfig = { field: order.field, order: order.order };
+    }
+    else {
+        // 如果没有明确排序，检查维度字段是否有自定义sorter，优先使用第一个有sorter的字段
+        for (var _i = 0, dimensionKeys_1 = dimensionKeys; _i < dimensionKeys_1.length; _i++) {
+            var dimensionKey = dimensionKeys_1[_i];
+            var column = findColumnByKey(dimensionKey);
+            if (column && typeof column.sorter === "function") {
+                sortConfig = { field: dimensionKey, order: "ascend" };
+                break; // 找到第一个有sorter的字段就使用，按维度顺序优先
+            }
+        }
+    }
+    return groupByDimensionsHierarchical(records, dimensionKeys, 0, sortConfig);
 }
 /**
  * 插入维度合计行

package/dist/index.build.d.ts

@@ -49,7 +49,7 @@ export { default as Sortable } from './es/sortable/sortable.js';
 export { default as ElectronSignatures } from './es/electronsignatures/index.js';
 export { default as message } from './es/message/index.js';
 export { default as CanvasTable } from './es/canvastable/canvasTable.js';
-export { ICanvasColumnType, ICanvasColumnsType, ICanvasTableProps } from './es/canvastable/interface.js';
+export { ICanvasColumnType, ICanvasColumnsType, ICanvasTableProps, ICanvasTableRefHandle } from './es/canvastable/interface.js';
 export { Affix, Anchor, AutoComplete, Avatar, BackTop, Badge, Breadcrumb, Card, Carousel, Cascader, Checkbox, Col, Comment, ConfigProvider, Divider, Drawer, Dropdown, Empty, Grid, Image, Layout, List, Mentions, Menu, PageHeader, Popconfirm, Popover, Progress, Radio, Rate, Result, Row, Segmented, Skeleton, Slider, Space, Spin, Statistic, Steps, Switch, Timeline, Tooltip, Transfer, Typography, Upload, notification } from 'antd';
 export { IButtonProps } from './es/button/interface.js';
 export { IButtonDownloadProps } from './es/button/buttonDownload.js';

package/package.json

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