zmdms-webui 2.2.9 → 2.3.1

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

@@ -0,0 +1,364 @@
+import { useMemo, isValidElement } from 'react';
+import { IS_SUMMARY } from '../../table/constant.js';
+import '../../_virtual/_tslib.js';
+import 'lodash/isEqual';
+import 'ahooks';
+import '../../node_modules/immutability-helper/index.js';
+import 'react/jsx-runtime';
+import 'zmdms-utils';
+import '../../node_modules/exceljs/dist/exceljs.min.js';
+import 'dayjs';
+
+/**
+ * 覆盖层管理 Hook - 统一管理所有覆盖层相关逻辑
+ *
+ * 包含功能：
+ * 1. 单元格覆盖层管理（useTableCellOverlay）
+ * 2. 表头覆盖层管理（useHeaderOverlay）
+ *
+ * 覆盖层用于在 Canvas 表格上方渲染自定义的 DOM 内容，支持用户交互
+ */
+// ==================== Hook 1: 单元格覆盖层管理 ====================
+/**
+ * 单元格覆盖层管理 Hook
+ *
+ * 功能：
+ * - 计算可见单元格的位置信息
+ * - 处理边界裁剪（上下左右）
+ * - 处理fixed列的遮挡
+ * - 只渲染React元素类型的内容（字符串和数字在Canvas中直接绘制）
+ */
+var useTableCellOverlay = function (params) {
+    var processedDataSource = params.processedDataSource, columnRenderInfos = params.columnRenderInfos, scrollState = params.scrollState, containerWidth = params.containerWidth, containerHeight = params.containerHeight, headerHeight = params.headerHeight, rowHeight = params.rowHeight, needHorizontalScrollbar = params.needHorizontalScrollbar, needVerticalScrollbar = params.needVerticalScrollbar, scrollbarSize = params.scrollbarSize, fixedRowsCount = params.fixedRowsCount, fixedRowsConfig = params.fixedRowsConfig, _a = params.hasSummaryRow, hasSummaryRow = _a === void 0 ? false : _a, _b = params.fixedSummaryRow, fixedSummaryRow = _b === void 0 ? false : _b;
+    // 计算可见的单元格覆盖层信息
+    var cellOverlays = useMemo(function () {
+        var overlays = [];
+        // 计算固定行数量
+        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;
+        // 计算fixed列的右边界，用于裁剪非fixed列的覆盖层
+        var fixedColumnsRightEdge = columnRenderInfos.reduce(function (maxEdge, info) {
+            if (info.fixed) {
+                var rightEdge = info.fixedLeft + info.width;
+                return Math.max(maxEdge, rightEdge);
+            }
+            return maxEdge;
+        }, 0);
+        // 计算有效容器尺寸
+        var effectiveWidth = needVerticalScrollbar
+            ? containerWidth - scrollbarSize
+            : containerWidth;
+        // 计算可用高度，需要为固定合计行预留空间
+        var fixedSummaryHeight = fixedSummaryRow && hasSummaryRow ? rowHeight : 0;
+        var effectiveHeight = (needHorizontalScrollbar
+            ? containerHeight - scrollbarSize
+            : containerHeight) - fixedSummaryHeight;
+        /**
+         * 通用的单元格覆盖层处理函数
+         */
+        var processCell = function (rowIndex, y, isFixedRow) {
+            if (isFixedRow === void 0) { isFixedRow = false; }
+            var record = processedDataSource[rowIndex];
+            if (!record)
+                return;
+            columnRenderInfos.forEach(function (info, colIndex) {
+                var column = info.column, x = info.x, width = info.width, fixed = info.fixed, fixedLeft = info.fixedLeft;
+                // 跳过选择框列
+                if (column.key === "__selection__") {
+                    return;
+                }
+                // 检查该列是否有 render 函数
+                if (!column.render) {
+                    return;
+                }
+                // 跳过合计行的 render 函数处理
+                if (record[IS_SUMMARY]) {
+                    return;
+                }
+                var drawX = fixed ? fixedLeft : x - scrollState.scrollLeft;
+                // 跳过不在可视区域的列
+                if (!fixed && (drawX + width < 0 || drawX > effectiveWidth)) {
+                    return;
+                }
+                // 对于非fixed列，检查是否被fixed列完全遮挡
+                if (!fixed &&
+                    fixedColumnsRightEdge > 0 &&
+                    drawX < fixedColumnsRightEdge) {
+                    // 如果完全被遮挡，跳过
+                    if (drawX + width <= fixedColumnsRightEdge) {
+                        return;
+                    }
+                }
+                // 需要处理左右边界的裁剪
+                var effectiveCellWidth = width;
+                var effectiveDrawX = drawX;
+                var offsetLeft = 0; // 记录左侧被裁剪的宽度
+                if (!fixed) {
+                    // 处理左边界：如果单元格部分在左边界外
+                    if (drawX < 0) {
+                        offsetLeft = -drawX; // 左侧被裁剪的宽度
+                        effectiveCellWidth = width + drawX; // 减少宽度
+                        effectiveDrawX = 0; // 从容器左边界开始绘制
+                        if (effectiveCellWidth <= 0)
+                            return;
+                    }
+                    // 处理被fixed列遮挡的情况
+                    if (fixedColumnsRightEdge > 0 &&
+                        effectiveDrawX < fixedColumnsRightEdge) {
+                        var overlap = fixedColumnsRightEdge - effectiveDrawX;
+                        if (overlap < effectiveCellWidth) {
+                            offsetLeft += overlap; // 增加左侧裁剪量
+                            effectiveCellWidth -= overlap; // 减少宽度
+                            effectiveDrawX = fixedColumnsRightEdge; // 从fixed列右边界开始绘制
+                        }
+                    }
+                }
+                // 处理右边界：如果单元格部分在右边界外（fixed 和非 fixed 列都需要处理）
+                if (effectiveDrawX + effectiveCellWidth > effectiveWidth) {
+                    effectiveCellWidth = effectiveWidth - effectiveDrawX;
+                    if (effectiveCellWidth <= 0)
+                        return;
+                }
+                // 获取单元格值
+                var dataIndex = column.dataIndex || column.key;
+                var cellValue = record[dataIndex];
+                // 调用 render 函数获取内容
+                var renderedContent = column.render(cellValue, record, rowIndex);
+                // 只有返回的不是字符串或数字时，才需要渲染到覆盖层
+                // 字符串和数字会在 Canvas 中直接绘制
+                if (typeof renderedContent !== "string" &&
+                    typeof renderedContent !== "number" &&
+                    renderedContent !== null &&
+                    renderedContent !== undefined) {
+                    // 处理 y 轴的边界裁剪，类似于 x 轴的处理
+                    var effectiveCellHeight = rowHeight;
+                    var effectiveDrawY = y;
+                    var offsetTop = 0; // 记录上方被裁剪的高度
+                    // 处理上边界：根据行类型进行不同的边界检查
+                    var minTopY = headerHeight; // 默认最小Y为表头高度
+                    if (!isFixedRow) {
+                        // 非固定行还需要避开固定顶部行区域
+                        minTopY = headerHeight + fixedTopRowsHeight;
+                    }
+                    if (y < minTopY) {
+                        offsetTop = minTopY - y; // 上方被裁剪的高度
+                        effectiveCellHeight = rowHeight - offsetTop; // 减少高度
+                        effectiveDrawY = minTopY; // 从允许的最小Y开始绘制
+                        if (effectiveCellHeight <= 0)
+                            return;
+                    }
+                    // 处理下边界：根据行类型进行不同的边界检查
+                    var maxBottomY = void 0;
+                    if (isFixedRow) {
+                        // 固定行使用完整的容器高度（减去滚动条）
+                        maxBottomY = needHorizontalScrollbar
+                            ? containerHeight - scrollbarSize
+                            : containerHeight;
+                    }
+                    else {
+                        // 非固定行需要严格避开所有固定行区域
+                        var currentFixedBottomHeight = fixedBottomRowsCount * rowHeight;
+                        var currentFixedSummaryHeight = fixedSummaryRow && hasSummaryRow ? rowHeight : 0;
+                        // 计算可滚动区域的严格边界
+                        var scrollableAreaBottom = containerHeight -
+                            (needHorizontalScrollbar ? scrollbarSize : 0) -
+                            currentFixedBottomHeight -
+                            currentFixedSummaryHeight;
+                        maxBottomY = Math.min(effectiveHeight, scrollableAreaBottom);
+                    }
+                    // 如果单元格部分在底部边界外
+                    if (effectiveDrawY + effectiveCellHeight > maxBottomY) {
+                        effectiveCellHeight = maxBottomY - effectiveDrawY;
+                        if (effectiveCellHeight <= 0)
+                            return;
+                    }
+                    overlays.push({
+                        rowIndex: rowIndex,
+                        colIndex: colIndex,
+                        x: effectiveDrawX,
+                        y: effectiveDrawY,
+                        width: effectiveCellWidth,
+                        height: effectiveCellHeight,
+                        content: renderedContent,
+                        record: record,
+                        columnKey: column.key,
+                        isFixed: fixed || false,
+                        isFixedRow: isFixedRow,
+                        offsetTop: offsetTop,
+                        offsetLeft: offsetLeft,
+                        originalHeight: rowHeight,
+                        originalWidth: width,
+                        align: column.align,
+                    });
+                }
+            });
+        };
+        // 1. 处理固定顶部行
+        if (fixedTopRowsCount > 0) {
+            for (var i = 0; i < fixedTopRowsCount; i++) {
+                var y = headerHeight + i * rowHeight;
+                processCell(i, y, true);
+            }
+        }
+        // 2. 处理可滚动区域的行
+        var fixedTopRowsHeight = fixedTopRowsCount * rowHeight;
+        var fixedBottomRowsHeight = fixedBottomRowsCount * rowHeight;
+        // 计算可滚动数据区域的高度
+        var scrollableAreaHeight = containerHeight -
+            headerHeight -
+            fixedTopRowsHeight -
+            fixedBottomRowsHeight -
+            fixedSummaryHeight -
+            (needHorizontalScrollbar ? scrollbarSize : 0);
+        // 计算可见的滚动行范围
+        var scrollStartRow = Math.floor(scrollState.scrollTop / rowHeight);
+        var scrollEndRow = Math.min(Math.ceil((scrollState.scrollTop + scrollableAreaHeight) / rowHeight), processedDataSource.length - fixedBottomRowsCount
+        // 注意：不再减去合计行数量，因为合计行的空间已在 scrollableAreaHeight 中考虑
+        );
+        // 调整行索引，从固定顶部行之后开始
+        var adjustedStartRow = fixedTopRowsCount + scrollStartRow;
+        var adjustedEndRow = fixedTopRowsCount + scrollEndRow;
+        for (var rowIndex = adjustedStartRow; rowIndex < adjustedEndRow; rowIndex++) {
+            if (rowIndex < 0 || rowIndex >= processedDataSource.length)
+                continue;
+            // 计算相对于滚动区域的位置
+            var relativeRowIndex = rowIndex - fixedTopRowsCount;
+            var y = headerHeight +
+                fixedTopRowsHeight +
+                relativeRowIndex * rowHeight -
+                scrollState.scrollTop;
+            // 检查是否在可见区域内，并确保不会与固定行重叠
+            var minVisibleY = headerHeight + fixedTopRowsHeight;
+            var maxVisibleY = minVisibleY + scrollableAreaHeight;
+            // 额外检查：确保不会延伸到固定底部行或固定合计行区域
+            var maxAllowedY = containerHeight -
+                (needHorizontalScrollbar ? scrollbarSize : 0) -
+                fixedBottomRowsHeight -
+                fixedSummaryHeight;
+            // 可见性检查：允许部分可见的行（被固定行遮挡的情况）
+            if (y + rowHeight <= minVisibleY ||
+                y >= maxVisibleY ||
+                y >= maxAllowedY // 只检查行顶部是否超出边界，允许底部被遮挡
+            ) {
+                continue;
+            }
+            processCell(rowIndex, y, false);
+        }
+        // 3. 处理固定底部行
+        if (fixedBottomRowsCount > 0) {
+            var bottomRowsStartIndex = processedDataSource.length -
+                fixedBottomRowsCount -
+                (fixedSummaryRow && hasSummaryRow ? 1 : 0);
+            for (var i = 0; i < fixedBottomRowsCount; i++) {
+                var rowIndex = bottomRowsStartIndex + i;
+                var y = containerHeight -
+                    (needHorizontalScrollbar ? scrollbarSize : 0) -
+                    fixedSummaryHeight -
+                    fixedBottomRowsCount * rowHeight +
+                    i * rowHeight;
+                processCell(rowIndex, y, true);
+            }
+        }
+        // 4. 处理固定合计行
+        if (fixedSummaryRow && hasSummaryRow) {
+            var summaryRowIndex = processedDataSource.length - 1;
+            var summaryY = containerHeight -
+                (needHorizontalScrollbar ? scrollbarSize : 0) -
+                rowHeight;
+            processCell(summaryRowIndex, summaryY, true);
+        }
+        // 排序覆盖层：优先级顺序 - 确保固定合计行有最高优先级
+        return overlays.sort(function (a, b) {
+            // 计算优先级（数值越大优先级越高）
+            var getPriority = function (overlay) {
+                // 检查是否是固定合计行（最后一行且固定合计行开启）
+                var isSummaryRow = fixedSummaryRow &&
+                    hasSummaryRow &&
+                    overlay.rowIndex === processedDataSource.length - 1;
+                if (isSummaryRow && overlay.isFixed)
+                    return 6; // 固定合计行固定列（最高优先级）
+                if (isSummaryRow && !overlay.isFixed)
+                    return 5; // 固定合计行非固定列
+                if (overlay.isFixedRow && overlay.isFixed)
+                    return 4; // 其他固定行固定列
+                if (overlay.isFixedRow && !overlay.isFixed)
+                    return 3; // 其他固定行非固定列
+                if (!overlay.isFixedRow && overlay.isFixed)
+                    return 2; // 非固定行固定列
+                return 1; // 非固定行非固定列（最低优先级）
+            };
+            return getPriority(a) - getPriority(b);
+        });
+    }, [
+        processedDataSource,
+        columnRenderInfos,
+        scrollState.scrollTop,
+        scrollState.scrollLeft,
+        containerWidth,
+        containerHeight,
+        headerHeight,
+        rowHeight,
+        needHorizontalScrollbar,
+        needVerticalScrollbar,
+        scrollbarSize,
+        fixedRowsCount,
+        fixedRowsConfig,
+        hasSummaryRow,
+        fixedSummaryRow,
+    ]);
+    return {
+        cellOverlays: cellOverlays,
+    };
+};
+// ==================== Hook 2: 表头覆盖层管理 ====================
+/**
+ * 表头覆盖层管理 Hook
+ *
+ * 功能：
+ * - 计算需要渲染为 React 组件的表头位置信息
+ * - 只处理 title 为 React 元素的列
+ * - 支持列宽调整时的临时宽度
+ */
+var useHeaderOverlay = function (params) {
+    var columnRenderInfos = params.columnRenderInfos, scrollLeft = params.scrollLeft, headerHeight = params.headerHeight, containerWidth = params.containerWidth, needVerticalScrollbar = params.needVerticalScrollbar, scrollbarSize = params.scrollbarSize, getColumnWidth = params.getColumnWidth;
+    var headerOverlays = useMemo(function () {
+        var overlays = [];
+        var displayWidth = needVerticalScrollbar
+            ? containerWidth - scrollbarSize
+            : containerWidth;
+        columnRenderInfos.forEach(function (info, index) {
+            var column = info.column, x = info.x, fixed = info.fixed, fixedLeft = info.fixedLeft;
+            // 只处理 title 为 React 元素的列
+            if (!isValidElement(column.title)) {
+                return;
+            }
+            // 使用 getColumnWidth 获取列宽（考虑拖拽时的临时宽度）
+            var width = getColumnWidth ? getColumnWidth(index) : info.width;
+            var drawX = fixed ? fixedLeft : x - scrollLeft;
+            // 跳过不在可视区域的列
+            if (!fixed && (drawX + width < 0 || drawX > displayWidth)) {
+                return;
+            }
+            overlays.push({
+                columnKey: column.key,
+                x: drawX,
+                y: 0,
+                width: width,
+                height: headerHeight,
+                content: column.title,
+            });
+        });
+        return overlays;
+    }, [
+        columnRenderInfos,
+        scrollLeft,
+        headerHeight,
+        containerWidth,
+        needVerticalScrollbar,
+        scrollbarSize,
+        getColumnWidth,
+    ]);
+    return { headerOverlays: headerOverlays };
+};
+
+export { useHeaderOverlay, useTableCellOverlay };

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

@@ -0,0 +1,93 @@
+import { __assign } from '../../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import { useCallback, useEffect, useMemo } from 'react';
+import 'dayjs';
+import { findColumnByKey } from '../utils/columnHelpers.js';
+import FilterPopover from '../components/FilterPopover.js';
+import '../../node_modules/react-contexify/dist/index.js';
+import '../../node_modules/screenfull/index.js';
+import 'ahooks';
+import '../components/ColumnDynamic.js';
+
+// ==================== Hook 1: Badge弹窗管理 ====================
+/**
+ * Badge弹窗管理 Hook
+ *
+ * 功能：
+ * - 提供关闭Badge弹窗的方法
+ * - 滚动时自动关闭Badge弹窗和Tooltip
+ */
+var useBadgePopover = function (params) {
+    var badgePopover = params.badgePopover, tooltip = params.tooltip, scrollTop = params.scrollTop, scrollLeft = params.scrollLeft, setState = params.setState;
+    // 关闭badge弹窗
+    var handleCloseBadgePopover = useCallback(function () {
+        setState(function (prev) { return (__assign(__assign({}, prev), { badgePopover: {
+                visible: false,
+                content: "",
+                position: { x: 0, y: 0 },
+            } })); });
+    }, [setState]);
+    // 滚动时关闭badge弹窗和tooltip
+    useEffect(function () {
+        if (badgePopover.visible || tooltip.visible) {
+            setState(function (prev) { return (__assign(__assign({}, prev), { badgePopover: {
+                    visible: false,
+                    content: "",
+                    position: { x: 0, y: 0 },
+                }, tooltip: {
+                    visible: false,
+                    content: "",
+                    position: { x: 0, y: 0 },
+                    cellInfo: null,
+                } })); });
+        }
+    }, [scrollTop, scrollLeft, setState, badgePopover.visible, tooltip.visible]);
+    return {
+        handleCloseBadgePopover: handleCloseBadgePopover,
+    };
+};
+// ==================== Hook 2: 筛选弹窗管理 ====================
+/**
+ * 筛选弹窗管理 Hook
+ *
+ * 功能：
+ * - 在多级表头中递归查找列配置
+ * - 处理筛选选项的优先级（用户配置 > 自动生成）
+ * - 渲染筛选弹窗组件
+ */
+var useFilterPopover = function (params) {
+    var filterPopover = params.filterPopover, filters = params.filters, columns = params.columns, autoGeneratedFilters = params.autoGeneratedFilters, onFilterChange = params.onFilterChange, onClose = params.onClose, popoverRef = params.popoverRef;
+    var filterPopoverElement = useMemo(function () {
+        var visible = filterPopover.visible, columnKey = filterPopover.columnKey, position = filterPopover.position;
+        if (!visible || !columnKey) {
+            return null;
+        }
+        // 在多级表头中递归查找列
+        var column = findColumnByKey(columns, columnKey);
+        if (!column) {
+            return null;
+        }
+        // 优先使用列配置的filters，如果为空则使用自动生成的
+        var filterOptions = column.filters && column.filters.length > 0
+            ? column.filters
+            : autoGeneratedFilters[columnKey];
+        if (!filterOptions || filterOptions.length === 0) {
+            return null;
+        }
+        var selectedValues = filters[columnKey] || [];
+        return (jsx(FilterPopover, { visible: visible, columnKey: columnKey, columnTitle: column.title, dataType: column.dataType, precision: column.precision, thousand: column.thousand, position: position, filterOptions: filterOptions, selectedValues: selectedValues, onConfirm: function (values) { return onFilterChange(columnKey, values); }, onReset: function () { return onFilterChange(columnKey, []); }, onClose: onClose, popoverRef: popoverRef }));
+    }, [
+        filterPopover,
+        filters,
+        columns,
+        autoGeneratedFilters,
+        onFilterChange,
+        onClose,
+        popoverRef,
+    ]);
+    return {
+        filterPopoverElement: filterPopoverElement,
+    };
+};
+
+export { useBadgePopover, useFilterPopover };

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

@@ -0,0 +1,94 @@
+import { __spreadArray } from '../../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { DEFAULT_SELECTION_COLUMN_WIDTH } from '../utils/constants.js';
+import 'dayjs';
+import { processColumnRender } from '../utils/columnHelpers.js';
+import { MERGE_INDEX } from '../../table/constant.js';
+import 'lodash/isEqual';
+import 'ahooks';
+import '../../node_modules/immutability-helper/index.js';
+import 'zmdms-utils';
+import '../../node_modules/exceljs/dist/exceljs.min.js';
+
+var useProcessedColumns = function (params) {
+    var columns = params.columns, dynamicColumns = params.dynamicColumns, mode = params.mode, rowSelection = params.rowSelection, internalColumnWidths = params.internalColumnWidths, dynamicKey = params.dynamicKey, _a = params.renderMode, renderMode = _a === void 0 ? "object" : _a, dynamicSettingRef = params.dynamicSettingRef;
+    return useMemo(function () {
+        var cols = __spreadArray([], (dynamicColumns || columns), true);
+        // 添加序号列
+        if (mode === "index") {
+            var title = "序号";
+            if (dynamicKey && dynamicSettingRef) {
+                // 动态引入ColumnDynamic组件，避免循环依赖
+                var ColumnDynamic = require("../components/ColumnDynamic").default;
+                title = jsx(ColumnDynamic, { dynamicSettingRef: dynamicSettingRef });
+            }
+            cols.unshift({
+                key: "__index__",
+                title: title,
+                dynamicTitle: "序号",
+                width: 60,
+                fixed: "left",
+                align: "center",
+                isOrder: false,
+                isFilter: false,
+                render: renderMode === "object"
+                    ? function (_a) {
+                        var index = _a.index, record = _a.record;
+                        var v = record[MERGE_INDEX] !== undefined
+                            ? record[MERGE_INDEX]
+                            : index;
+                        return "".concat(v + 1);
+                    }
+                    : function (_text, record, index) {
+                        var v = record[MERGE_INDEX] !== undefined
+                            ? record[MERGE_INDEX]
+                            : index;
+                        return "".concat(v + 1);
+                    },
+            });
+        }
+        // 添加选择框列
+        if (rowSelection) {
+            cols.unshift({
+                key: "__selection__",
+                title: "",
+                width: rowSelection.columnWidth || DEFAULT_SELECTION_COLUMN_WIDTH,
+                fixed: rowSelection.fixed ? rowSelection.fixed : "left",
+                align: "center",
+            });
+        }
+        // 应用内部列宽状态（未开启动态配置时）
+        if (!dynamicKey && Object.keys(internalColumnWidths).length > 0) {
+            cols.forEach(function (col) {
+                if (col.key && internalColumnWidths[col.key]) {
+                    col.width = internalColumnWidths[col.key];
+                }
+            });
+        }
+        // 验证动态列配置
+        if (dynamicKey) {
+            cols.forEach(function (col) {
+                var title = col.title, dynamicTitle = col.dynamicTitle, key = col.key, dataIndex = col.dataIndex;
+                if (title && !dynamicTitle && typeof title !== "string") {
+                    console.error("\u4F60\u4F20\u5165\u7684title\u4E0D\u662F\u4E00\u4E2A\u5B57\u7B26\u4E32,\u5E76\u4E14\u4F60\u6CA1\u6709\u4F20\u5165dynamicTitle\u7684\u914D\u7F6E\u3002\n\u95EE\u9898\u53EF\u80FD\u51FA\u73B0\u5728: ".concat(key || dataIndex, " \u5217\u3002\u8BF7\u4F20\u5165\u4E00\u4E2AdynamicTitle \u4F5C\u4E3A\u52A8\u6001\u5217\u914D\u7F6E\u7684title\u503C"));
+                }
+            });
+        }
+        // 处理render函数
+        return cols.map(function (col) {
+            return processColumnRender(col, renderMode);
+        });
+    }, [
+        dynamicColumns,
+        columns,
+        rowSelection,
+        mode,
+        dynamicKey,
+        internalColumnWidths,
+        renderMode,
+        dynamicSettingRef,
+    ]);
+};
+
+export { useProcessedColumns };