@cfmm/umi-plugins-ui-v2 0.0.1

package/dist/cjs/utils/excelHelper.tpl

@@ -0,0 +1,825 @@
+import { ColumnsState, ProColumns } from '@ant-design/pro-components';
+import ExcelJS, { Worksheet } from 'exceljs';
+import React from 'react';
+import { fileDownloadFromBlob } from './fileHelper';
+
+// 类型定义
+export interface ExportResult<T> {
+  flatColumns: ProColumns<T>[];
+  headers: string[][];
+  mergeCells: string[];
+}
+
+export interface ColumnProcessOptions<T> {
+  columns: ProColumns<T>[];
+  columnsStateMap?: Record<string, ColumnsState>;
+  filters?: any[];
+}
+
+export type DataRowGenerator = () => Promise<any[]>;
+
+// 延时函数
+// eslint-disable-next-line no-promise-executor-return
+export const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * 获取jsx中的文本
+ * @param {React.ReactNode | string} jsx
+ * @returns 返回文本和各个节点文本的数组 { text, textArray }
+ */
+export const extractTextFromJSX = (
+  jsx: React.ReactNode | string | number,
+): { text: string | number; textArray: (string | number)[] } => {
+  if (typeof jsx === 'string' || typeof jsx === 'number') {
+    return { text: jsx, textArray: [jsx] };
+  }
+  const textArray: (string | number)[] = [];
+
+  React.Children.forEach(jsx, (child) => {
+    if (React.isValidElement(child)) {
+      if (typeof child.props.children === 'string' || typeof jsx === 'number' || Array.isArray(child.props.children)) {
+        if(Array.isArray(child.props.children)) {
+          textArray.push(child.props.children.join(' '));
+        }else {
+          textArray.push(child.props.children);
+        }
+      } else {
+        const { textArray: nestedArray } = extractTextFromJSX(child.props.children);
+        textArray.push(...nestedArray);
+      }
+    }
+  });
+
+  const text = textArray.join(' ');
+  return { text, textArray };
+};
+
+/**
+ * 设置列头（带样式）
+ * @param workSheet Excel工作表对象
+ * @param headerTitleArray 表头标题数组
+ * @returns Promise
+ */
+export const setWorksheetHeader = (
+  workSheet: ExcelJS.Worksheet,
+  headerTitleArray: string[],
+): Promise<ExcelJS.Worksheet> => {
+  return new Promise((resolve, reject) => {
+    try {
+      if (!workSheet) {
+        throw new Error('parameter workSheet is null');
+      }
+
+      // 设置列的基本配置
+      const headerColumns: Partial<ExcelJS.Column>[] = headerTitleArray.map((item) => ({
+        header: item,
+        width: 15, // 与genExcelWithMutilHeader保持一致的列宽
+      }));
+
+      workSheet.columns = headerColumns;
+
+      // 获取表头行并设置样式
+      const headerRow = workSheet.getRow(1);
+      if (headerRow) {
+        headerRow.eachCell({ includeEmpty: true }, (cell: ExcelJS.Cell) => {
+          // 设置与genExcelWithMutilHeader相同的样式
+          cell.font = { bold: true };
+          cell.alignment = {
+            vertical: 'middle',
+            horizontal: 'center',
+          };
+          cell.border = {
+            top: { style: 'thin' },
+            left: { style: 'thin' },
+            bottom: { style: 'thin' },
+            right: { style: 'thin' },
+          };
+        });
+      }
+
+      resolve(workSheet);
+    } catch (err) {
+      reject(err);
+    }
+  });
+};
+
+/**
+ * 导出Excel（单级表头）
+ * @param fileName 文件名
+ * @param workSheetName Sheet名
+ * @param headerColumns 列名数组
+ * @param genRowFun 创建行的函数
+ */
+export const genExcel = (
+  fileName: string,
+  workSheetName: string,
+  headerColumns: string[],
+  genRowFun: DataRowGenerator,
+): void => {
+  // 参数验证
+  if (!fileName || !workSheetName || !headerColumns.length) {
+    console.error('genExcel: 缺少必要参数');
+    return;
+  }
+
+  const workBook = new ExcelJS.Workbook();
+
+  // 设置工作簿元数据
+  workBook.created = new Date();
+  workBook.modified = new Date();
+  workBook.lastPrinted = new Date();
+
+  const workSheet = workBook.addWorksheet(workSheetName, {
+    properties: { tabColor: { argb: 'FF00FF00' } },
+  });
+
+  setWorksheetHeader(workSheet, headerColumns)
+    .then(() => {
+      // 调用外部方法，生成数据行
+      return genRowFun();
+    })
+    .then((newRows: any[]) => {
+      try {
+        // 批量添加数据行
+        if (newRows?.length > 0) {
+          newRows.forEach((row) => {
+            workSheet.addRow(row);
+          });
+        }
+        return true;
+      } catch (error) {
+        console.error('添加数据行时发生错误:', error);
+        throw error;
+      }
+    })
+    .then(() => {
+      // 调用xlsx的方法写成文件
+      return workBook.xlsx.writeBuffer();
+    })
+    .then((buffer: any) => {
+      // 下载文件
+      fileDownloadFromBlob(fileName, buffer);
+    })
+    .catch((error) => {
+      console.error('生成Excel文件时发生错误:', error);
+      // 可以在这里添加用户友好的错误提示
+    });
+};
+
+type RowStyleType = {
+  height?: number;
+  fontSize?: number;
+  bold?: boolean;
+  color?: string;
+  bgColor?: string;
+};
+
+/**
+ * Excel导出统一配置选项
+ */
+export interface ExcelExportOptions {
+  /** 第一行：表头标题 */
+  title?: string;
+  /** 第一行样式配置 */
+  titleStyle?: RowStyleType;
+  /** 注意事项（支持字符串或数组，数组每项为一行） */
+  notice?: string | string[];
+  /** 注意事项样式配置 */
+  noticeStyle?: RowStyleType;
+  /** 编号行（用于匹配字段，会隐藏） */
+  codeColumns?: string[];
+  /** 列配置 */
+  worksheetColumns?: Worksheet['columns'];
+  /** 锁定的列索引数组（从0开始），这些列不允许修改 */
+  lockedColumns?: number[];
+  /** 工作表保护密码（可选） */
+  sheetPassword?: string;
+  /** 是否锁定基础行（数据行前的行），默认为 true */
+  lockHeaderRows?: boolean;
+  /** 自定义合并单元格范围数组（如 ['A1:B2', 'C1:D1']） */
+  mergeCells?: string[];
+  /** 数据行高度，默认 22 */
+  dataRowHeight?: number;
+}
+
+// 兼容旧版本的类型别名
+export type ExcelHeaderOptions = ExcelExportOptions;
+
+/**
+ * 通用Excel导出方法
+ * @param fileName 文件名
+ * @param workSheetName Sheet名
+ * @param headerColumns 列名数组（一维数组）或多级表头（二维数组）
+ * @param data 数据行数组或生成数据的函数
+ * @param options 配置选项
+ */
+export const genExcelAdvanced = async (
+  fileName: string,
+  workSheetName: string,
+  headerColumns: string[] | string[][],
+  data: any[] | (() => Promise<any[]>) | (() => any[]),
+  options?: ExcelExportOptions,
+): Promise<void> => {
+  // 参数验证
+  if (!fileName || !workSheetName || !headerColumns.length) {
+    console.error('genExcelAdvanced: 缺少必要参数');
+    return;
+  }
+
+  const workBook = new ExcelJS.Workbook();
+  workBook.created = new Date();
+  workBook.modified = new Date();
+  workBook.lastPrinted = new Date();
+
+  const workSheet = workBook.addWorksheet(workSheetName, {
+    properties: { tabColor: { argb: 'FF00FF00' } },
+  });
+
+  // 判断是否为多级表头
+  const isMultiHeader = Array.isArray(headerColumns[0]);
+  // 获取最后一行表头（用于确定列数）
+  const lastHeaderRow = isMultiHeader
+    ? (headerColumns as string[][])[headerColumns.length - 1]
+    : (headerColumns as string[]);
+  const colCount = lastHeaderRow.length;
+
+  // 设置列宽
+  workSheet.columns = options?.worksheetColumns ?? lastHeaderRow.map(() => ({ width: 20 }));
+
+  // 是否锁定基础行（默认为 true）
+  const lockHeaderRows = options?.lockHeaderRows !== false;
+  let currentRowIndex = 0;
+
+  // ========== 第一行：标题（可选） ==========
+  if (options?.title !== undefined) {
+    currentRowIndex++;
+    const titleRow = workSheet.addRow([options.title]);
+    if (colCount > 1) {
+      workSheet.mergeCells(currentRowIndex, 1, currentRowIndex, colCount);
+    }
+    const titleCell = titleRow.getCell(1);
+    titleCell.font = {
+      size: options?.titleStyle?.fontSize ?? 16,
+      bold: options?.titleStyle?.bold ?? true,
+      color: { argb: options?.titleStyle?.color ?? 'FF000000' },
+    };
+    if (options?.titleStyle?.bgColor) {
+      titleCell.fill = {
+        type: 'pattern',
+        pattern: 'solid',
+        fgColor: { argb: options.titleStyle.bgColor },
+      };
+    }
+    titleCell.alignment = { horizontal: 'left', vertical: 'middle' };
+    titleRow.height = options?.titleStyle?.height ?? 40;
+    titleCell.border = {
+      top: { style: 'thin' },
+      left: { style: 'thin' },
+      bottom: { style: 'thin' },
+      right: { style: 'thin' },
+    };
+    if (lockHeaderRows) {
+      titleRow.eachCell((cell) => {
+        cell.protection = { locked: true };
+      });
+    }
+  }
+
+  // ========== 第二行：注意事项（可选） ==========
+  if (options?.notice) {
+    currentRowIndex++;
+    const noticeText = Array.isArray(options.notice)
+      ? options.notice.join('\n')
+      : options.notice;
+    const noticeRow = workSheet.addRow([noticeText]);
+    if (colCount > 1) {
+      workSheet.mergeCells(currentRowIndex, 1, currentRowIndex, colCount);
+    }
+    const noticeCell = noticeRow.getCell(1);
+    noticeCell.font = {
+      size: options?.noticeStyle?.fontSize ?? 10,
+      bold: options?.noticeStyle?.bold ?? false,
+      color: { argb: options?.noticeStyle?.color ?? 'FFFF0000' },
+    };
+    if (options?.noticeStyle?.bgColor) {
+      noticeCell.fill = {
+        type: 'pattern',
+        pattern: 'solid',
+        fgColor: { argb: options.noticeStyle.bgColor },
+      };
+    }
+    noticeCell.alignment = { horizontal: 'left', vertical: 'middle', wrapText: true };
+    noticeRow.height = options?.noticeStyle?.height ?? 30;
+    noticeCell.border = {
+      top: { style: 'thin' },
+      left: { style: 'thin' },
+      bottom: { style: 'thin' },
+      right: { style: 'thin' },
+    };
+    if (lockHeaderRows) {
+      noticeRow.eachCell((cell) => {
+        cell.protection = { locked: true };
+      });
+    }
+  }
+
+  // ========== 编号行（可选，隐藏） ==========
+  if (options?.codeColumns && options.codeColumns.length > 0) {
+    currentRowIndex++;
+    const codeColumnRow = workSheet.addRow(options.codeColumns);
+    codeColumnRow.eachCell((cell) => {
+      cell.border = {
+        top: { style: 'thin' },
+        left: { style: 'thin' },
+        bottom: { style: 'thin' },
+        right: { style: 'thin' },
+      };
+      if (lockHeaderRows) {
+        cell.protection = { locked: true };
+      }
+    });
+    codeColumnRow.alignment = { horizontal: 'center', vertical: 'middle' };
+    codeColumnRow.hidden = true;
+  }
+
+  // ========== 列名行（支持多级表头） ==========
+  if (isMultiHeader) {
+    // 多级表头
+    (headerColumns as string[][]).forEach((headerRow) => {
+      currentRowIndex++;
+      const processedRow = headerRow.map((cell) => (cell === '' ? undefined : cell));
+      const row = workSheet.addRow(processedRow);
+      row.eachCell({ includeEmpty: true }, (cell) => {
+        cell.font = { bold: true };
+        cell.alignment = { vertical: 'middle', horizontal: 'center' };
+        cell.border = {
+          top: { style: 'thin' },
+          left: { style: 'thin' },
+          bottom: { style: 'thin' },
+          right: { style: 'thin' },
+        };
+        if (lockHeaderRows) {
+          cell.protection = { locked: true };
+        }
+      });
+    });
+  } else {
+    // 单级表头
+    currentRowIndex++;
+    const columnHeaderRow = workSheet.addRow(headerColumns as string[]);
+    columnHeaderRow.eachCell((cell) => {
+      cell.font = { bold: true, color: { argb: '00000000' } };
+      cell.fill = {
+        type: 'pattern',
+        pattern: 'solid',
+        fgColor: { argb: 'FFD9D9D9' },
+      };
+      cell.alignment = { horizontal: 'center', vertical: 'middle' };
+      cell.border = {
+        top: { style: 'thin' },
+        left: { style: 'thin' },
+        bottom: { style: 'thin' },
+        right: { style: 'thin' },
+      };
+      if (lockHeaderRows) {
+        cell.protection = { locked: true };
+      }
+    });
+    columnHeaderRow.height = 25;
+  }
+
+  // ========== 处理自定义合并单元格 ==========
+  if (options?.mergeCells && options.mergeCells.length > 0) {
+    options.mergeCells.forEach((cellRange) => {
+      try {
+        workSheet.mergeCells(cellRange);
+      } catch (error) {
+        console.warn(`合并单元格失败: ${cellRange}`, error);
+      }
+    });
+  }
+
+  // ========== 锁定列配置 ==========
+  const lockedColumns = options?.lockedColumns ?? [];
+  const hasLockedColumns = lockedColumns.length > 0;
+
+  // ========== 获取数据行 ==========
+  const rows = typeof data === 'function' ? await data() : data;
+
+  // ========== 添加数据行 ==========
+  if (rows?.length > 0) {
+    rows.forEach((row) => {
+      const dataRow = workSheet.addRow(row);
+      dataRow.eachCell({ includeEmpty: true }, (cell, colNumber) => {
+        if (colNumber <= colCount) {
+          cell.border = {
+            top: { style: 'thin' },
+            left: { style: 'thin' },
+            bottom: { style: 'thin' },
+            right: { style: 'thin' },
+          };
+          cell.alignment = { horizontal: 'center', vertical: 'middle' };
+          if (hasLockedColumns) {
+            cell.protection = { locked: lockedColumns.includes(colNumber - 1) };
+          }
+        }
+      });
+      dataRow.height = options?.dataRowHeight ?? 22;
+    });
+  }
+
+  // ========== 启用工作表保护 ==========
+  if (lockHeaderRows || hasLockedColumns) {
+    workSheet.protect(options?.sheetPassword ?? '', {
+      selectLockedCells: true,
+      selectUnlockedCells: true,
+      formatColumns: true,
+      formatRows: true,
+      insertRows: true,
+      deleteRows: true,
+    });
+  }
+
+  // ========== 生成并下载文件 ==========
+  try {
+    const buffer = await workBook.xlsx.writeBuffer();
+    fileDownloadFromBlob(fileName, buffer as unknown as Blob);
+  } catch (error) {
+    console.error('生成Excel文件时发生错误:', error);
+  }
+};
+
+/**
+ * 创建Excel，支持多级表头及单元格合并（兼容旧版本）
+ * @deprecated 请使用 genExcelAdvanced 代替
+ */
+export const genExcelWithMutilHeader = (
+  fileName: string,
+  workSheetName: string,
+  headerColumns: string[][],
+  mergeCellArray: string[],
+  genRowFun: DataRowGenerator,
+): void => {
+  genExcelAdvanced(fileName, workSheetName, headerColumns, genRowFun, {
+    mergeCells: mergeCellArray,
+    lockHeaderRows: false,
+  });
+};
+
+/**
+ * 导出Excel（扩展版，兼容旧版本）
+ * @deprecated 请使用 genExcelAdvanced 代替
+ */
+export const genExcelWithHeader = async (
+  fileName: string,
+  workSheetName: string,
+  headerColumns: string[],
+  genRowFun: any,
+  codeColumns: string[],
+  options?: ExcelHeaderOptions,
+) => {
+  return genExcelAdvanced(fileName, workSheetName, headerColumns, genRowFun, {
+    ...options,
+    codeColumns,
+  });
+};
+
+/**
+ * 将数字索引转换为Excel列名（A, B, C, ..., Z, AA, AB, ...）
+ * @param cellIndex 从0开始的列索引
+ * @returns Excel列名
+ */
+export const convertNumberToCellName = (cellIndex: number): string => {
+  let cellName = '';
+  let index = cellIndex;
+
+  while (index >= 0) {
+    cellName = String.fromCharCode(65 + (index % 26)) + cellName;
+    index = Math.floor(index / 26) - 1;
+  }
+
+  return cellName;
+};
+
+/**
+ * 根据表格columns，获取过滤且排序后的columns
+ * @param param 列，变更属性，过滤值
+ * @returns
+ */
+export const getExportColumns = <T>({
+  columns = [],
+  columnsStateMap = {},
+  filters = [],
+}: {
+  columns: ProColumns<T>[];
+  columnsStateMap?: Record<string, ColumnsState>;
+  filters?: any[];
+}): ProColumns<T>[] => {
+  const filterList = columns.filter((item) => {
+    return (
+      // 排除隐藏在表格的列
+      !item.hideInTable &&
+      // 排除主动过滤的列
+      !filters.includes(item.dataIndex) &&
+      // 排除在于columnsStateMap中且columnsStateMapp[item.dataIndex].show为false的列(排除表格右上角工具隐藏的列)
+      (!columnsStateMap[item.dataIndex as string] || (columnsStateMap[item.dataIndex as string]?.show ?? true))
+    );
+  });
+
+  // 根据拖动的顺序排序
+  const orderList = filterList
+    .map((item) => {
+      let title: any = item.title;
+
+      // 如果title是函数，则取返回值
+      if (typeof title === 'function') {
+        title = title(item, 'table', React.createElement('div'));
+      }
+
+      // 如果title是jsx或者函数返回jsx，去节点中的文本
+      if (React.isValidElement(title)) {
+        title = extractTextFromJSX(title)?.text ?? title;
+      }
+
+      return {
+        ...item,
+        title,
+        order: columnsStateMap[item.dataIndex as string]?.order,
+      };
+    })
+    .sort((a, b) => {
+      if ((a.order || a.order === 0) && (b.order || b.order === 0)) {
+        return a.order - b.order;
+      }
+      return 1;
+    });
+  return orderList || [];
+};
+
+/**
+ * 处理组合列，将多级表头展开为平级列，并生成表头结构
+ * @param columns 原始列配置
+ * @param columnsStateMap 列状态映射
+ * @param filters 过滤条件
+ * @returns 返回展开后的列配置、表头结构和合并单元格信息
+ */
+export const getExportColumnsWithGroupSupport = <T>(options: ColumnProcessOptions<T>): ExportResult<T> => {
+  const { columns = [], columnsStateMap = {}, filters = [] } = options;
+  const flatColumns: ProColumns<T>[] = [];
+  const mergeCells: string[] = [];
+  const firstLevelHeaders: string[] = [];
+  const secondLevelHeaders: string[] = [];
+
+  let columnIndex = 0;
+
+  /**
+   * 处理列标题，支持函数和JSX格式
+   */
+  const processTitle = (title: any, column: ProColumns<T>): string => {
+    if (typeof title === 'function') {
+      title = title(column, 'table', React.createElement('div'));
+    }
+    if (React.isValidElement(title)) {
+      title = extractTextFromJSX(title)?.text ?? title;
+    }
+    return title || '';
+  };
+
+  /**
+   * 检查列是否应该显示
+   */
+  const shouldShowColumn = (column: ProColumns<T>): boolean => {
+    return (
+      !column.hideInTable &&
+      !filters.includes(column.dataIndex) &&
+      (!columnsStateMap[column.dataIndex as string] || (columnsStateMap[column.dataIndex as string]?.show ?? true))
+    );
+  };
+
+  /**
+   * 处理单个列
+   */
+  const processColumn = (column: ProColumns<T>): void => {
+    const title = processTitle(column.title, column);
+
+    if (column.children && column.children.length > 0) {
+      // 组合列：处理子列
+      const childrenStart = columnIndex;
+      let childrenCount = 0;
+
+      // 只处理显示的子列
+      const visibleChildren = column.children.filter(shouldShowColumn);
+
+      visibleChildren.forEach((child) => {
+        const childTitle = processTitle(child.title, child);
+
+        // 添加到扁平列表
+        flatColumns.push({
+          ...child,
+          title: childTitle,
+          order: columnsStateMap[child.dataIndex as string]?.order,
+        });
+
+        // 第一级表头：父列标题
+        firstLevelHeaders.push(title);
+        // 第二级表头：子列标题
+        secondLevelHeaders.push(childTitle);
+
+        childrenCount++;
+        columnIndex++;
+      });
+
+      // 生成合并单元格信息（父列标题跨越所有子列）
+      if (childrenCount > 1) {
+        const startCell = convertNumberToCellName(childrenStart);
+        const endCell = convertNumberToCellName(childrenStart + childrenCount - 1);
+        mergeCells.push(`${startCell}1:${endCell}1`);
+      } else if (childrenCount === 1) {
+        // 只有一个子列时，仍需要在第一行显示父标题
+        const cellName = convertNumberToCellName(childrenStart);
+        mergeCells.push(`${cellName}1:${cellName}1`);
+      }
+    } else if (shouldShowColumn(column)) {
+      // 普通列
+      flatColumns.push({
+        ...column,
+        title,
+        order: columnsStateMap[column.dataIndex as string]?.order,
+      });
+
+      // 普通列需要跨两行显示
+      firstLevelHeaders.push(title);
+      secondLevelHeaders.push('');
+
+      // 生成跨行合并信息
+      const cellName = convertNumberToCellName(columnIndex);
+      mergeCells.push(`${cellName}1:${cellName}2`);
+
+      columnIndex++;
+    }
+  };
+
+  // 过滤显示的列并处理排序
+  const visibleColumns = columns.filter((column) => {
+    // 组合列：检查是否至少有一个子列可见
+    if (column.children && column.children.length > 0) {
+      return column.children.some(shouldShowColumn);
+    }
+    // 普通列：直接检查可见性
+    return shouldShowColumn(column);
+  });
+
+  // 按order排序（如果有的话）
+  const sortedColumns = visibleColumns.sort((a, b) => {
+    const aOrder = columnsStateMap[a.dataIndex as string]?.order;
+    const bOrder = columnsStateMap[b.dataIndex as string]?.order;
+
+    if ((aOrder || aOrder === 0) && (bOrder || bOrder === 0)) {
+      return aOrder - bOrder;
+    }
+    return 0;
+  });
+
+  // 处理所有列
+  sortedColumns.forEach(processColumn);
+
+  return {
+    flatColumns,
+    headers: [firstLevelHeaders, secondLevelHeaders],
+    mergeCells,
+  };
+};
+
+const getFormatValue = (value: any, type: ProColumns<any>['valueType'], getLocalDate?: any) => {
+  let newValue = value;
+  if (value && type) {
+    if (type === 'percent') {
+      newValue = (value * 100).toFixed(2) + '%';
+    } else if (type === 'dateTime' || type === 'date') {
+      newValue = getLocalDate?.(value);
+    }
+  }
+  return newValue;
+};
+
+/**
+ * 根据取值的columns，获取需要导出的数据
+ * @param columns 取值的列（过滤排序后）特殊类型如百分比，日期需要定义valueType
+ * @param data 表格的数据
+ * @param getLocalDate hooks中的方法，用于转换日期时间
+ * @param textArrJoin 获取render中的节点文本Arr，使用textArrJoin字符拼接
+ * @param batchSize 每次切割条数
+ * @param progressUpdateInterval 进度更新间隔，默认每1000条数据更新一次
+ * @param delayMs 批处理间的延迟时间，避免UI阻塞
+ * @returns
+ * @description 需要dataIndex对应到字段名，如果是嵌套对象，格式为'aa.bb' 以 . 分割
+ * @description 如果查询条件是id，比如select组件，又没有render的情况，可以直接取到的数据请使用dataIndex对应到导出数据，key作为查询id，有逻辑请用renderText
+ * @description 注意：如果依赖外部状态，可能有异常
+ * @description 注意：如果有render或者renderText会获取文本使用空格，自定义拼接传入textArrJoin，render使用自定义组件时无法获取节点文本，因为props.children并没有，而是props[自定义组件的参数]，该情况请定义renderText
+ */
+export const getExportValueForColumns = async <T = any>({
+  columns,
+  data,
+  getLocalDate,
+  handlePercentChange,
+  textArrJoin,
+  batchSize = 500,
+  progressUpdateInterval = batchSize * 2, // 进度更新间隔，默认每次切割条数的2倍
+  delayMs = 30, // 批处理间的延迟时间
+}: {
+  columns: ProColumns<T>[];
+  data: readonly T[];
+  getLocalDate?: (date: any) => string | undefined;
+  handlePercentChange?: (percent: number) => void;
+  textArrJoin?: string;
+  batchSize?: number;
+  progressUpdateInterval?: number;
+  delayMs?: number;
+}): Promise<any[]> => {
+  // 1. 参数校验
+  if (!columns.length || !data.length) return Promise.resolve([]);
+
+  // 2. 预处理列，提取dataIndex路径，避免在循环中重复计算
+  const colInfos = columns.map((col) => ({
+    col,
+    paths: typeof col.dataIndex === 'string' ? col.dataIndex.split('.') : [],
+    hasRenderText: Boolean(col.renderText),
+    hasRender: Boolean(col.render),
+    valueType: col.valueType,
+  }));
+
+  // 3. 批处理相关变量
+  const dataCopy = [...data];
+  const allRows: any[] = [];
+  const totalItems = data.length;
+  const totalBatches = Math.ceil(totalItems / batchSize);
+
+  // 4. 进度追踪
+  let processedCount = 0;
+  let lastProgressUpdate = 0;
+  const updateProgress = (count: number) => {
+    if (!handlePercentChange) return;
+
+    // 只在达到特定间隔或处理完所有数据时更新进度
+    if (count === totalItems || count - lastProgressUpdate >= progressUpdateInterval) {
+      const percent = ((count / totalItems) * 100).toFixed(2);
+      handlePercentChange(Number(percent));
+      lastProgressUpdate = count;
+    }
+  };
+
+  // 5. 处理单条数据的函数
+  const processItem = (item: T, idx: number): any[] => {
+    const rowValues: any[] = [];
+
+    for (const { col, paths, hasRenderText, hasRender, valueType } of colInfos) {
+      // 5.1 获取原始值（处理嵌套对象）
+      const rawValue = paths.length
+        ? paths.reduce((obj: any, key: string) => obj && obj[key], item)
+        : item[col.dataIndex as keyof T];
+
+      // 5.2 应用渲染函数或默认格式化
+      let value;
+      if (hasRenderText) {
+        value = col.renderText!(rawValue, item, idx, {} as any);
+      } else if (hasRender) {
+        value = col.render!(rawValue, item, idx, undefined, {} as any);
+      } else {
+        value = getFormatValue(rawValue, valueType, getLocalDate);
+      }
+
+      // 5.3 从JSX中提取文本
+      if ((hasRenderText || hasRender) && value) {
+        const { text, textArray } = extractTextFromJSX(value);
+        value = textArrJoin ? textArray.join(textArrJoin) : text;
+      }
+
+      rowValues.push(value);
+    }
+
+    // 5.4 更新进度
+    processedCount++;
+    updateProgress(processedCount);
+
+    return rowValues;
+  };
+
+  // 6. 批处理
+  for (let batchIndex = 0; batchIndex < totalBatches; batchIndex++) {
+    const start = batchIndex * batchSize;
+    const end = Math.min(start + batchSize, totalItems);
+    const batch = dataCopy.slice(start, end);
+
+    // 6.1 处理当前批次数据
+    const batchRows = batch.map((item, idx) => processItem(item, start + idx));
+    allRows.push(...batchRows);
+
+    // 6.2 批处理间添加延迟，避免UI阻塞
+    if (batchIndex < totalBatches - 1 && delayMs > 0) {
+      await delay(delayMs);
+    }
+  }
+
+  return Promise.resolve(allRows);
+};