zmdms-webui 2.2.9 → 2.3.1

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

@@ -0,0 +1,150 @@
+import { useEffect } from 'react';
+import { useMemoizedFn } from 'ahooks';
+import { getLeafColumns } from '../utils/multiHeaderHelpers.js';
+import { extractCellText } from '../utils/cellHelpers.js';
+import { formatCellValue } from '../utils/formatHelpers.js';
+import '../../_virtual/_tslib.js';
+
+/**
+ * 复制到剪贴板 Hook
+ */
+var useCopyToClipboard = function (params) {
+    var cellSelection = params.cellSelection, processedDataSource = params.processedDataSource, columns = params.columns, containerRef = params.containerRef;
+    // 获取叶子列（用于实际数据渲染和复制的列）
+    var leafColumns = getLeafColumns(columns);
+    // 获取选中单元格的文本数据
+    var getSelectedCellsText = useMemoizedFn(function () {
+        if (!cellSelection)
+            return "";
+        var startRow = cellSelection.startRow, endRow = cellSelection.endRow, startCol = cellSelection.startCol, endCol = cellSelection.endCol;
+        var minRow = Math.min(startRow, endRow);
+        var maxRow = Math.max(startRow, endRow);
+        var minCol = Math.min(startCol, endCol);
+        var maxCol = Math.max(startCol, endCol);
+        var rows = [];
+        for (var row = minRow; row <= maxRow; row++) {
+            var cells = [];
+            for (var col = minCol; col <= maxCol; col++) {
+                // 使用叶子列而不是原始列数组
+                var column = leafColumns[col];
+                if (!column)
+                    continue;
+                // 跳过选择框列和序号列
+                if (column.key === "__selection__" || column.key === "__index__")
+                    continue;
+                var text = void 0;
+                // row=-1 表示表头
+                if (row === -1) {
+                    // 复制表头标题
+                    if (column.dynamicTitle) {
+                        text = column.dynamicTitle;
+                    }
+                    else {
+                        text = typeof column.title === "string" ? column.title : column.key;
+                    }
+                }
+                else {
+                    // 复制数据行
+                    var rowData = processedDataSource[row];
+                    if (!rowData)
+                        continue;
+                    var cellValue = column.dataIndex
+                        ? rowData[column.dataIndex]
+                        : "";
+                    // 优先使用 getCopyValue
+                    if (column.getCopyValue) {
+                        text = column.getCopyValue(cellValue, rowData, row);
+                    }
+                    else if (column.render) {
+                        // 如果有自定义 render 函数，先尝试提取文本
+                        var extractedText = extractCellText({
+                            cellValue: cellValue,
+                            record: rowData,
+                            rowIndex: row,
+                            renderFn: column.render,
+                        });
+                        // 如果 render 返回的是 React 元素（extractCellText 返回原始值）
+                        // 且列配置了格式化选项，则应用格式化
+                        var hasFormatConfig = !!(column.dateFormat ||
+                            column.precision !== undefined ||
+                            column.thousand);
+                        if (hasFormatConfig && extractedText === String(cellValue !== null && cellValue !== void 0 ? cellValue : "")) {
+                            // render 返回的是原始值，应用格式化
+                            text = formatCellValue(cellValue, column);
+                        }
+                        else {
+                            // render 返回的是已处理的字符串，直接使用
+                            text = extractedText;
+                        }
+                    }
+                    else {
+                        // 没有自定义 render，直接使用格式化后的值（支持日期、精度、千分符等）
+                        text = formatCellValue(cellValue, column);
+                    }
+                }
+                cells.push(text);
+            }
+            if (cells.length > 0) {
+                rows.push(cells.join("\t"));
+            }
+        }
+        return rows.join("\n");
+    });
+    // 处理复制事件
+    var handleCopy = useMemoizedFn(function (e) {
+        var _a;
+        if (!cellSelection)
+            return;
+        var text = getSelectedCellsText();
+        if (text) {
+            e.preventDefault();
+            (_a = e.clipboardData) === null || _a === void 0 ? void 0 : _a.setData("text/plain", text);
+        }
+    });
+    // 监听复制事件
+    useEffect(function () {
+        var container = containerRef.current;
+        if (!container)
+            return;
+        container.addEventListener("copy", handleCopy);
+        return function () {
+            container.removeEventListener("copy", handleCopy);
+        };
+    }, [handleCopy, containerRef]);
+    // 监听键盘事件（Ctrl+C / Cmd+C）- 只在表格容器内部处理
+    useEffect(function () {
+        var container = containerRef.current;
+        if (!container)
+            return;
+        var handleKeyDown = function (e) {
+            // 检查是否为复制快捷键且有选中的单元格
+            if ((e.ctrlKey || e.metaKey) && e.key === "c" && cellSelection) {
+                // 检查当前焦点是否在表格容器内，或者事件目标是否在表格容器内
+                var isInContainer = container.contains(document.activeElement) ||
+                    container.contains(e.target);
+                if (isInContainer) {
+                    e.preventDefault(); // 阻止默认复制行为
+                    var text = getSelectedCellsText();
+                    if (text && navigator.clipboard) {
+                        navigator.clipboard.writeText(text).catch(function (err) {
+                            console.error("Failed to copy:", err);
+                        });
+                    }
+                }
+            }
+        };
+        // 监听容器的keydown事件，而不是全局window事件
+        container.addEventListener("keydown", handleKeyDown);
+        // 同时也监听全局事件，但会检查焦点位置
+        document.addEventListener("keydown", handleKeyDown);
+        return function () {
+            container.removeEventListener("keydown", handleKeyDown);
+            document.removeEventListener("keydown", handleKeyDown);
+        };
+    }, [cellSelection, getSelectedCellsText, containerRef]);
+    return {
+        getSelectedCellsText: getSelectedCellsText,
+    };
+};
+
+export { useCopyToClipboard };

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

@@ -0,0 +1,103 @@
+import { __spreadArray } from '../../_virtual/_tslib.js';
+import { useState, useEffect } from 'react';
+import { getMaxDepth } from '../utils/multiHeaderHelpers.js';
+
+var FONT_SIZE = 14;
+var FONT_FAMILY = "Arial, sans-serif";
+var LINE_HEIGHT = 20;
+var FILTER_ICON_WIDTH = 15;
+var SORT_ICON_WIDTH = 15;
+var ICON_SPACING = 4;
+var TEXT_PADDING = 16;
+/**
+ * 计算文本在给定宽度下需要的行数
+ */
+var calculateTextLines = function (ctx, text, maxWidth) {
+    var lines = text.split("\n");
+    var totalLines = 0;
+    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+        var line = lines_1[_i];
+        if (line === "") {
+            totalLines += 1;
+            continue;
+        }
+        var currentLine = "";
+        var lineCount = 0;
+        var chars = line.split("");
+        for (var _a = 0, chars_1 = chars; _a < chars_1.length; _a++) {
+            var char = chars_1[_a];
+            var testLine = currentLine + char;
+            var metrics = ctx.measureText(testLine);
+            if (metrics.width > maxWidth && currentLine.length > 0) {
+                lineCount += 1;
+                currentLine = char;
+            }
+            else {
+                currentLine = testLine;
+            }
+        }
+        if (currentLine.length > 0) {
+            lineCount += 1;
+        }
+        totalLines += lineCount;
+    }
+    return totalLines;
+};
+/**
+ * 计算单个列标题需要的行数
+ */
+var calculateColumnLines = function (ctx, column) {
+    if (!column.wrap || !column.title) {
+        return 1;
+    }
+    var titleText = String(column.title);
+    var columnWidth = column.width || 100;
+    // 计算图标占用的宽度
+    var hasOrder = column.isOrder !== false;
+    var hasFilter = column.isFilter !== false;
+    var iconsWidth = 0;
+    if (hasFilter)
+        iconsWidth += FILTER_ICON_WIDTH;
+    if (hasOrder) {
+        iconsWidth += SORT_ICON_WIDTH;
+        if (hasFilter)
+            iconsWidth += ICON_SPACING;
+    }
+    // 计算文本可用宽度
+    var textMaxWidth = columnWidth - TEXT_PADDING - iconsWidth;
+    return calculateTextLines(ctx, titleText, textMaxWidth);
+};
+/**
+ * Hook: 计算表头动态高度
+ * 支持多级表头
+ */
+var useHeaderHeight = function (params) {
+    var columns = params.columns, headerHeight = params.headerHeight;
+    var _a = useState(headerHeight), calculatedHeight = _a[0], setCalculatedHeight = _a[1];
+    useEffect(function () {
+        var calculateHeight = function () {
+            // 获取多级表头的最大深度
+            var maxDepth = getMaxDepth(columns);
+            // 如果是多级表头，每层使用基础表头高度
+            if (maxDepth > 1) {
+                return headerHeight * maxDepth;
+            }
+            // 单层表头，考虑文本换行
+            var tempCanvas = document.createElement("canvas");
+            var ctx = tempCanvas.getContext("2d");
+            if (!ctx)
+                return headerHeight;
+            ctx.font = "".concat(FONT_SIZE, "px ").concat(FONT_FAMILY);
+            // 计算所有列需要的最大行数
+            var maxLines = Math.max.apply(Math, __spreadArray([1], columns.map(function (column) { return calculateColumnLines(ctx, column); }), false));
+            // 基础高度 + (额外行数 * 行高)
+            return maxLines > 1
+                ? headerHeight + (maxLines - 1) * LINE_HEIGHT
+                : headerHeight;
+        };
+        setCalculatedHeight(calculateHeight());
+    }, [columns, headerHeight]);
+    return calculatedHeight;
+};
+
+export { useHeaderHeight };

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

@@ -0,0 +1,111 @@
+import { useMemo } from 'react';
+
+/**
+ * 合并单元格管理 Hook
+ * 根据 processedColumns 的 onCell 和 finalDataSource 里面的 rowSpan 来判断合并
+ * 通过 isIndexMerge 和 isSelectionMerge 判断是否合并序号和勾选框
+ */
+/**
+ * 根据 onCell 返回的 rowSpan 和 colSpan 计算合并单元格信息
+ */
+var calculateMergeCellsFromOnCell = function (dataSource, columns, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.isIndexMerge, isIndexMerge = _a === void 0 ? true : _a, _b = options.isSelectionMerge, isSelectionMerge = _b === void 0 ? false : _b;
+    var mergeCellMap = new Map();
+    // 遍历所有数据行
+    dataSource.forEach(function (record, rowIndex) {
+        // 遍历所有列
+        columns.forEach(function (column, colIndex) {
+            var _a, _b;
+            // 特殊列处理：序号列和勾选框列
+            var isIndexColumn = column.key === "__index__";
+            var isSelectionColumn = column.key === "__selection__";
+            // 如果是序号列但不参与合并，或者是勾选框列但不参与合并，则跳过
+            if ((isIndexColumn && !isIndexMerge) ||
+                (isSelectionColumn && !isSelectionMerge)) {
+                return;
+            }
+            // 获取单元格属性
+            var cellProps = {};
+            // 对于序号列和勾选框列，如果允许合并，需要基于第一个业务列的合并信息
+            if (isIndexColumn || isSelectionColumn) {
+                // 找到第一个有 onCell 的业务列
+                var referenceColumn = columns.find(function (col) {
+                    return col.onCell && col.key !== "__index__" && col.key !== "__selection__";
+                });
+                if (referenceColumn === null || referenceColumn === void 0 ? void 0 : referenceColumn.onCell) {
+                    cellProps = referenceColumn.onCell(record, rowIndex) || {};
+                }
+            }
+            else if (column.onCell) {
+                // 业务列直接调用 onCell
+                cellProps = column.onCell(record, rowIndex) || {};
+            }
+            var rowSpan = (_a = cellProps.rowSpan) !== null && _a !== void 0 ? _a : 1;
+            var colSpan = (_b = cellProps.colSpan) !== null && _b !== void 0 ? _b : 1;
+            // 处理 rowSpan 或 colSpan 为 0 的情况（表示该单元格被合并）
+            if (rowSpan === 0 || colSpan === 0) {
+                // 标记为被合并的单元格
+                var key = "".concat(rowIndex, "-").concat(colIndex);
+                mergeCellMap.set(key, {
+                    rowIndex: rowIndex,
+                    colIndex: colIndex,
+                    rowSpan: 0,
+                    colSpan: 0,
+                    skip: true,
+                });
+                return;
+            }
+            // 处理合并单元格（rowSpan > 1 或 colSpan > 1）
+            if (rowSpan > 1 || colSpan > 1) {
+                // 设置主单元格信息
+                var key = "".concat(rowIndex, "-").concat(colIndex);
+                mergeCellMap.set(key, {
+                    rowIndex: rowIndex,
+                    colIndex: colIndex,
+                    rowSpan: rowSpan,
+                    colSpan: colSpan,
+                    skip: false,
+                });
+                // 标记被合并的单元格区域
+                for (var r = 0; r < rowSpan; r++) {
+                    for (var c = 0; c < colSpan; c++) {
+                        // 跳过主单元格自身
+                        if (r === 0 && c === 0)
+                            continue;
+                        var mergedRowIndex = rowIndex + r;
+                        var mergedColIndex = colIndex + c;
+                        // 确保不越界
+                        if (mergedRowIndex < dataSource.length &&
+                            mergedColIndex < columns.length) {
+                            var skipKey = "".concat(mergedRowIndex, "-").concat(mergedColIndex);
+                            mergeCellMap.set(skipKey, {
+                                rowIndex: mergedRowIndex,
+                                colIndex: mergedColIndex,
+                                rowSpan: 0,
+                                colSpan: 0,
+                                skip: true,
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    });
+    return mergeCellMap;
+};
+/**
+ * 合并单元格 Hook
+ */
+var useMergeCells = function (params) {
+    var dataSource = params.dataSource, columns = params.columns, _a = params.isIndexMerge, isIndexMerge = _a === void 0 ? true : _a, _b = params.isSelectionMerge, isSelectionMerge = _b === void 0 ? false : _b;
+    var mergeCellMap = useMemo(function () {
+        return calculateMergeCellsFromOnCell(dataSource, columns, {
+            isIndexMerge: isIndexMerge,
+            isSelectionMerge: isSelectionMerge,
+        });
+    }, [dataSource, columns, isIndexMerge, isSelectionMerge]);
+    return { mergeCellMap: mergeCellMap };
+};
+
+export { useMergeCells };