@yy-common/shared 1.0.0-beta.6

package/utils/excel.js

@@ -0,0 +1,789 @@
+/* eslint-disable */
+
+// const XlsxPopulate = require('xlsx-populate/browser/xlsx-populate')
+import _ from "lodash";
+import XLSX from "xlsx";
+
+const titleStyle = {
+  // title style
+  bold: true,
+  fontSize: "14",
+  horizontalAlignment: "center",
+  verticalAlignment: "center",
+};
+const subTitleStyle = {
+  // title style
+  bold: false,
+  fontSize: "10",
+  horizontalAlignment: "center",
+  verticalAlignment: "center",
+};
+var subTitleHeight = 20; // 次标题行高设置为20
+const paramLeftStyle = {
+  fontSize: "10",
+  horizontalAlignment: "left",
+  verticalAlignment: "center",
+  topBorder: true,
+  bottomBorder: true,
+};
+
+const paramRightStyle = {
+  fontSize: "10",
+  horizontalAlignment: "right",
+  verticalAlignment: "center",
+  topBorder: true,
+  bottomBorder: true,
+};
+
+const columnTitleStyle = {
+  bold: true,
+  fontSize: "10",
+  horizontalAlignment: "center",
+  verticalAlignment: "center",
+  fill: "bdc3c7",
+  topBorder: true,
+  bottomBorder: true,
+  leftBorder: true,
+  rightBorder: true,
+};
+
+const dataCellStyle = {
+  fontSize: "10",
+  horizontalAlignment: "center",
+  verticalAlignment: "center",
+  topBorder: true,
+  bottomBorder: true,
+  leftBorder: true,
+  rightBorder: true,
+};
+
+const titleHeight = 27;
+
+const paramHeight = 18;
+
+const columnTitleHeight = 18;
+
+const dataRowHeight = 18;
+
+/**
+ * 根据agGrid的参数，获取导出Excel所需要的参数
+ * @param {*} param0
+ */
+function getAgColumnTitleAndData({ columns, datas }) {
+  // columns是个树形结构，要根据他的树形结构计算出表头的数据，然后通过这个表头的数据计算出columnTitle和data
+  var columnsClo = _.cloneDeep(columns);
+  var datasClo = _.cloneDeep(datas);
+
+  // 删掉编辑列
+  _.remove(columnsClo, (d) => {
+    return d.cellClass && d.cellClass.indexOf("button") != -1;
+  });
+
+  // 增加索引列
+  datasClo.forEach((dd, idx) => {
+    dd["__seq"] = idx + 1;
+  });
+
+  _.forEach(columnsClo, (d) => {
+    if (
+      d.type == "enum" ||
+      (d.cellClass && d.cellClass.indexOf("enum") != -1)
+    ) {
+      // 处理枚举值
+      datasClo.forEach((dd) => {
+        dd[d.field || d.key] =
+          _.find(
+            d.cellRendererParams.datas || d.cellRendererParams.enumList || [],
+            (item) => item.K == dd[d.field || d.key],
+          )?.V || dd[d.field || d.key];
+      });
+    }
+  });
+
+  // 根据列定义，取列定义的树深
+  const getDeepthOfCol = (col) => {
+    if (!col.children) {
+      return 1;
+    } else {
+      var deepthSingle =
+        1 +
+        Math.max(
+          ...col.children.map((d) => {
+            return getDeepthOfCol(d);
+          }),
+        );
+      col.deepth = deepthSingle;
+      return deepthSingle;
+    }
+  };
+  var deepth = Math.max(
+    ...columnsClo.map((d) => {
+      var deepthSingle = getDeepthOfCol(d);
+      d.deepth = deepthSingle;
+      return deepthSingle;
+    }),
+  );
+  console.log("calc deepth = ", deepth);
+
+  // 根据列定义，取列定义的宽度
+  const getWidthOfCol = (col) => {
+    if (!col.children) {
+      return 1;
+    } else {
+      var widthSingle = _.sum(
+        col.children.map((d) => {
+          return getWidthOfCol(d);
+        }),
+      );
+      col.width = widthSingle;
+      return widthSingle;
+    }
+  };
+  var width = _.sum(
+    columnsClo.map((d) => {
+      var widthSingle = getWidthOfCol(d);
+      d.width = widthSingle;
+      return widthSingle;
+    }),
+  );
+  console.log("calc width = ", width);
+
+  console.log("now columnsClo is ", columnsClo);
+
+  // 遍历树形数据，组织真正的待导出的表头数据
+  var columnTitle = [];
+  var curCol = 1; // 用于辅助定位单元格开始结束位置，即当前遍历到的列的位置
+  var curDeep = 0; // 用于辅助定位单元格开始结束位置，即递归调用深度
+  function calcTitle(src, dist) {
+    curDeep += 1;
+    src.reduce((rlt, col, idx) => {
+      if (col.children) {
+        rlt.push({
+          text: col.excelName || col.headerName || col.title, // 单元格数据
+          srow: curDeep, // 在excel开始行
+          scol: curCol, // 在excel开始列
+          erow: curDeep /* + 1*/, // 在excel结束行
+          ecol: curCol + col.width - 1, // 在excel结束列
+        });
+        calcTitle(col.children, rlt);
+      } else {
+        rlt.push({
+          text: col.excelName || col.headerName || col.title, // 单元格数据
+          srow: curDeep, // 在excel开始行
+          scol: curCol, // 在excel开始列
+          erow: deepth /* + 1*/, // 在excel结束行
+          ecol: curCol /* + 1*/, // 在excel结束列
+        });
+        curCol += 1;
+      }
+      return rlt;
+    }, dist);
+    curDeep -= 1;
+  }
+  calcTitle(columnsClo, columnTitle);
+
+  // 组织真正的列定义，即所有的叶子结点
+  var columnsCalc = [];
+  function calcColumns(src, dist) {
+    src.reduce((rlt, col) => {
+      if (col.children) {
+        calcColumns(col.children, rlt);
+      } else {
+        rlt.push(col);
+      }
+      return rlt;
+    }, dist);
+  }
+  calcColumns(columnsClo, columnsCalc);
+
+  var columnAlign = columnsCalc.map((d) => d.align || "left"); // 对齐方式
+  var columnType = columnsCalc.map((d) =>
+    d.align == "right" || d.align == "rightNum" ? "n" : "s",
+  ); // 数据类型
+  var columnWidth = columnsCalc.map((d) =>
+    d.excelWidth ? d.excelWidth : d.width ? Math.floor(d.width / 10) : 10,
+  ); // 列宽
+  var numberFormat = columnsCalc.map((d) => {
+    return d.numberFormat === undefined
+      ? d.align == "rightNum"
+        ? "#,##0.0000"
+        : d.align == "right"
+        ? "#,##0.00"
+        : ""
+      : d.numberFormat;
+  }); // 格式化信息
+  columnsCalc.map((d, idx) => {
+    d.field = d.field ? d.field : d.key;
+    var t = d.excelName || d.headerName || d.title;
+    t = t.replace(/<br\/>/g, "");
+    if (d.columnWidth !== undefined) {
+      columnWidth[idx] = d.columnWidth;
+    } else {
+      if (t && columnWidth[idx] < t.length * 2) {
+        columnWidth[idx] = t.length * 2;
+      }
+    }
+  });
+  var exportData = datasClo.map((d) => {
+    return columnsCalc.map((dd, idx) => {
+      if (dd.columnWidth !== undefined) {
+        columnWidth[idx] = dd.columnWidth;
+      } else {
+        if (d[dd.field] && columnWidth[idx] < ("" + d[dd.field]).length * 2) {
+          columnWidth[idx] = ("" + d[dd.field]).length * 2;
+        }
+      }
+      let cellStyle = null;
+      if (dd.cellStyle) {
+        if (dd.cellStyle instanceof Function) {
+          cellStyle = dd.cellStyle(d[dd.field], d, datasClo);
+        } else {
+          cellStyle = dd.cellStyle;
+        }
+      }
+
+      let formula = null;
+      if (dd.formula) {
+        if (dd.formula instanceof Function) {
+          formula = dd.formula(d[dd.field], d, datasClo);
+        } else {
+          formula = dd.formula;
+        }
+      }
+
+      return {
+        cellStyle,
+        formula,
+        value: d[dd.field],
+      };
+    });
+  });
+
+  return {
+    deepth,
+    columnAlign,
+    columnType,
+    columnWidth,
+    exportData,
+    numberFormat,
+    columnTitle,
+    columnsCalc,
+  };
+}
+
+var rowSpanExcelInfos = [];
+// 初始化表格跨行
+function initRowSpanInfos(options) {
+  // 配置了单元格表格跨行的情况才执行以下计算
+  if (!!options.rowSpanColumns) {
+    if (!!options.rowSpanIndexCol) {
+      options.rowSpanIndexCol = options.rowSpanColumns[0];
+    }
+
+    // 按列计算的合并结果
+    var rowSpanRlt = {};
+
+    var rowTmpMapping = {};
+
+    // 计算每一列的合并数据
+    function calcRowSpan(colId, followCol) {
+      // 用于excel导出计算
+      var colIdx = _.findIndex(options.columns, { field: colId });
+
+      // 已经计算过了
+      if (!!rowSpanRlt[colId]) {
+        return;
+      }
+
+      // 每一行数据的计算结果缓存变量
+      var rowSpansTmp = [];
+
+      // 遍历数据的临时变量
+      var curVal = "CUR_VAL";
+
+      // 当前值对应的缓存变量的第一行数据
+      var firstCurRow = {};
+
+      _.forEach(options.datas, function (d, idx) {
+        // 如果是首次计算跨行的主列，正常判断首行，否则要参考主列计算的值进行判断
+        var isFirstRow = !followCol
+          ? d[colId] != curVal
+          : d[colId] != curVal || idx == (rowTmpMapping["" + idx] || {}).first;
+        if (isFirstRow) {
+          // 如果是首次计算跨行的主列，需要缓存数据每一行的计算信息
+          if (!followCol && firstCurRow.first !== undefined) {
+            for (var j = firstCurRow.first; j <= firstCurRow.last; j++) {
+              rowTmpMapping["" + j] = {
+                first: firstCurRow.first,
+                last: firstCurRow.last,
+              };
+            }
+          }
+          curVal = d[colId];
+          firstCurRow = {
+            col: colId,
+            val: curVal,
+            first: idx,
+            last: idx,
+            rowSpan: 1,
+          };
+          rowSpansTmp.push(firstCurRow);
+        } else {
+          // 合并行
+          firstCurRow.last = idx;
+          // rowSpan大于1表示此单元格要跨行
+          firstCurRow.rowSpan = firstCurRow.last - firstCurRow.first + 1;
+          // rowspan 0表示要隐藏的cell
+          rowSpansTmp.push({ rowSpan: 0 });
+
+          // 最后一行没有放入firstCurRow数据里面，导致最后一个值的合并出了问题
+          if (!followCol && idx == options.datas.length - 1) {
+            for (var j = firstCurRow.first; j <= firstCurRow.last; j++) {
+              rowTmpMapping["" + j] = {
+                first: firstCurRow.first,
+                last: firstCurRow.last,
+              };
+            }
+          }
+        }
+      });
+      rowSpanRlt[colId] = rowSpansTmp;
+      _.forEach(rowSpansTmp, function (row, idx) {
+        if (row.rowSpan > 1) {
+          rowSpanExcelInfos.push({
+            mergeRowS: idx,
+            mergeRowE: idx + row.rowSpan - 1,
+            megerColS: colIdx,
+            megerColE: colIdx,
+          });
+        }
+      });
+    }
+
+    calcRowSpan(options.rowSpanIndexCol);
+
+    // console.log(rowTmpMapping)
+
+    _.forEach(options.rowSpanColumns, function (col) {
+      calcRowSpan(col, true);
+    });
+  }
+  // console.log(rowSpanInfos)
+}
+
+/**
+ * 根据参数导出excel，目前系统仅支持agGrid和iviewTable，这两个表格的columns定义都是树形的，所以这里仅支持树形的列定义即可
+ * 根据每个column的树形信息，可以计算出每个column定义的单元格跨行跨列信息，直接得出excel待导出的表头
+ * 再根据列定义树形的叶子结点，可以得出每一列对应的字段名，根据这个信息组织待导出的数据
+ * 合并单元格需要单独配置，哪一列需要传参数进来，应该有一个主合并列，否则后面值全0的合并成一个了（直接拷贝slickgrid的吧）
+ * @param {
+ *   title: '导出的excel名字，并excel内容的名字',
+ *   columnAlign: ['center', 'left', 'right'], //'对齐方式'
+ *   columnType: ['s', 'n', 'n'], // s String n Number
+ *   columns: [] //'表头，列定义的树形结构'，
+ *   columnWidth: ['20','10'], //宽度,数组
+ *   datas: [], // 数据，表格的原始数据
+ *   paramLeft: '查询时间：2022年01月-2022年05月',
+ *   paramRight: '箱、万元',
+ *   numberFormat: ['', '0.00', '0.00'], // 数组，设置数据格式
+ *   rowSpanColumns:[column1,column2……], // 需要跨行的列
+ *   rowSpanIndexCol:'', // 根据哪一列进行跨行计算，如根据卷烟ITEM_NAME
+ *   zeroValueFormat: '', // 导出时0值处理成何种格式的字符串
+ * } excelData
+ */
+export function exportJsonToExcel(excelData) {
+  rowSpanExcelInfos = []; // 每次导出都重置该对象为初始值
+  var calcExportDatas = getAgColumnTitleAndData(excelData);
+
+  console.log("calcExportDatas", calcExportDatas);
+
+  var title = excelData.title;
+  var subTitle = excelData.subTitle || "";
+
+  var titleDeepth = calcExportDatas.deepth;
+  var columnAlign = excelData.columnAlign || calcExportDatas.columnAlign;
+  var columnType = excelData.columnType || calcExportDatas.columnType;
+
+  var columnTitle = calcExportDatas.columnTitle;
+
+  var columnWidth = excelData.columnWidth || calcExportDatas.columnWidth;
+
+  var columnCount = columnAlign.length;
+
+  var paramLeft = excelData.paramLeft;
+
+  var paramRight = excelData.paramRight;
+
+  var jsonData = calcExportDatas.exportData;
+
+  var numberFormat = excelData.numberFormat || calcExportDatas.numberFormat;
+
+  XlsxPopulate.fromBlankAsync()
+    .then((workbook) => {
+      // Modify the workbook.
+      var sheet = workbook.sheet("Sheet1"); // 初始化的时候不能传中文进去
+      sheet.name(title);
+      // 设置列宽
+      for (var i = 0; i < columnCount; i++) {
+        sheet.column(i + 1).width(columnWidth[i] == 0 ? 10 : columnWidth[i]);
+      }
+
+      var titleRange = sheet.range(1, 1, 1, columnCount);
+      titleRange.merged(true);
+      titleRange.style(excelData.titleStyle || titleStyle);
+      titleRange.cell(0, 0).value(title);
+      sheet.row(1).height(titleHeight);
+
+      var rowsNow = 2;
+      // 添加次标题
+      if (subTitle) {
+        var subTitleRow = 2; // 次标题位于标题下方，所以行号为2
+        var subTitleRange = sheet.range(
+          subTitleRow,
+          1,
+          subTitleRow,
+          columnCount,
+        );
+        subTitleRange.merged(true); // 合并次标题单元格
+        subTitleRange.style(subTitleStyle || {}); // 应用次标题样式，需预先定义
+        subTitleRange.cell(0, 0).value(subTitle); // 设置次标题文本
+        sheet.row(subTitleRow).height(subTitleHeight); // 设置次标题行高，需预先定义
+        rowsNow = subTitleRow + 1; // 更新当前处理的行号
+      }
+      //自定义n多个副标题
+      if (excelData.subTitleList) {
+        excelData.subTitleList.forEach((d) => {
+          var subTitleRow = rowsNow; // 次标题位于标题下方，所以行号为2
+          var subTitleRange = sheet.range(
+            subTitleRow,
+            1,
+            subTitleRow,
+            columnCount,
+          );
+          subTitleRange.merged(true); // 合并次标题单元格
+          subTitleRange.style(excelData.subTitleListStyle || subTitleStyle); // 应用次标题样式，需预先定义
+          subTitleRange.cell(0, 0).value(d); // 设置次标题文本
+          sheet.row(subTitleRow).height(subTitleHeight); // 设置次标题行高，需预先定义
+          rowsNow = subTitleRow + 1; // 更新当前处理的行号
+        });
+      }
+
+      if (!!excelData.paramLeft || !!excelData.paramRight) {
+        var paramLeftRange = sheet.range(2, 1, 2, Math.round(columnCount / 2));
+        paramLeftRange.cell(0, 0).value(paramLeft || "");
+        paramLeftRange.merged(true);
+        paramLeftRange.style(paramLeftStyle);
+        var paramRightRange = sheet.range(
+          2,
+          Math.round(columnCount / 2) + 1,
+          2,
+          columnCount,
+        );
+        paramRightRange.cell(0, 0).value(paramRight || "");
+        paramRightRange.merged(true);
+        paramRightRange.style(paramRightStyle);
+        sheet.row(2).height(paramHeight);
+        rowsNow += 1;
+      }
+
+      columnTitle.forEach((d) => {
+        var columnTitleRange = sheet.range(
+          d.srow + rowsNow - 1,
+          d.scol,
+          d.erow + rowsNow - 1,
+          d.ecol,
+        );
+        columnTitleRange.merged(true);
+        columnTitleRange.style(columnTitleStyle);
+        columnTitleRange.cell(0, 0).value(d.text.replace(/<br\/>/g, ""));
+      });
+      for (let i = 0; i < titleDeepth; i++) {
+        sheet.row(rowsNow + i).height(columnTitleHeight);
+      }
+
+      // 处理表格里的数据，挨家挨户搜一下
+      rowsNow += titleDeepth;
+
+      for (var i = 0; i < jsonData.length; i++) {
+        var lineData = jsonData[i];
+        for (var j = 0; j < lineData.length; j++) {
+          if (columnType[j] === "s" && lineData[j]) {
+            if (lineData[j].value === "0") {
+              // 销售业务需要在一些业务场景中，将零值导出为配置的zeroValueFormat格式
+              sheet
+                .cell(rowsNow + i, j + 1)
+                .value(
+                  excelData.zeroValueFormat === undefined
+                    ? "0"
+                    : excelData.zeroValueFormat,
+                );
+            } else {
+              sheet.cell(rowsNow + i, j + 1).value(lineData[j].value);
+            }
+            dataCellStyle.numberFormat = "";
+          } else if (columnType[j] === "n" && lineData[j]) {
+            // 销售业务需要在一些业务场景中，将零值导出为配置的zeroValueFormat格式
+            if (lineData[j].value === 0) {
+              sheet
+                .cell(rowsNow + i, j + 1)
+                .value(
+                  excelData.zeroValueFormat === undefined
+                    ? 0
+                    : excelData.zeroValueFormat,
+                );
+            } else {
+              sheet
+                .cell(rowsNow + i, j + 1)
+                .value(
+                  isNaN(lineData[j].value)
+                    ? excelData.zeroValueFormat === undefined
+                      ? 0
+                      : excelData.zeroValueFormat
+                    : lineData[j].value === null ? '' : parseFloat(lineData[j].value),
+                );
+            }
+            dataCellStyle.numberFormat = numberFormat[j]; // 数字保留精度
+          } else {
+            // 预留一下，将来可能加别的样式
+            sheet.cell(rowsNow + i, j + 1).value("");
+          }
+
+          // 公式
+          if (lineData[j].formula) {
+            sheet.cell(rowsNow + i, j + 1).formula(lineData[j].formula);
+          }
+
+          // 样式
+          dataCellStyle.horizontalAlignment = columnAlign[j];
+          if (lineData[j].cellStyle) {
+            let cellStyle = _.merge({}, dataCellStyle, lineData[j].cellStyle);
+            sheet.cell(rowsNow + i, j + 1).style(cellStyle);
+          } else {
+            sheet.cell(rowsNow + i, j + 1).style(dataCellStyle);
+          }
+        }
+        if (excelData.rowColor && i % 2 != 0) {
+          var row = sheet.range(rowsNow + i, 1, rowsNow + i, columnCount);
+          row.style({ fill: "f8f8f9" });
+        }
+        sheet.row(rowsNow + i).height(dataRowHeight);
+      }
+
+      if (!!excelData.rowSpanColumns) {
+        initRowSpanInfos({
+          ...excelData,
+          columns: calcExportDatas.columnsCalc,
+        });
+        _.forEach(rowSpanExcelInfos, function (rowSpanInfo) {
+          var columnTitleRange = sheet.range(
+            rowSpanInfo.mergeRowS + rowsNow,
+            rowSpanInfo.megerColS + 1,
+            rowSpanInfo.mergeRowE + rowsNow,
+            rowSpanInfo.megerColE + 1,
+          );
+          columnTitleRange.merged(true);
+        });
+      }
+
+      // 表头无论如何都会有，都要固定，所以不需要加if判断
+      // if (excelData.leftColumns || excelData.topRows) {
+      sheet.freezePanes(
+        excelData.leftColumns || 0,
+        (excelData.topRows || 0) + rowsNow - 1,
+      );
+      // }
+
+      // Write to file.
+      workbook.outputAsync().then(function (blob) {
+        if (window.navigator && window.navigator.msSaveOrOpenBlob) {
+          // If IE, you must uses a different method.
+          window.navigator.msSaveOrOpenBlob(blob, title + ".xlsx");
+        } else {
+          var url = window.URL.createObjectURL(blob);
+          var a = document.createElement("a");
+          document.body.appendChild(a);
+          a.href = url;
+          a.download = title + ".xlsx";
+          a.click();
+          window.URL.revokeObjectURL(url);
+          document.body.removeChild(a);
+        }
+      });
+    })
+    .catch((err) => console.log(err));
+}
+
+/**
+ * 根据参数导出excel，目前系统仅支持agGrid和iviewTable，这两个表格的columns定义都是树形的，所以这里仅支持树形的列定义即可
+ * 根据每个column的树形信息，可以计算出每个column定义的单元格跨行跨列信息，直接得出excel待导出的表头
+ * 再根据列定义树形的叶子结点，可以得出每一列对应的字段名，根据这个信息组织待导出的数据
+ * 合并单元格需要单独配置，哪一列需要传参数进来，应该有一个主合并列，否则后面值全0的合并成一个了（直接拷贝slickgrid的吧）
+ * @param {
+ *   title: '导出的excel名字，并excel内容的名字',
+ *   noTitle: Boolean, // 读取数据的时候，忽略标题行
+ *   columnAlign: ['center', 'left', 'right'], //'对齐方式'
+ *   columnType: ['s', 'n', 'n'], // s String n Number
+ *   columns: [] //'表头，列定义的树形结构'，
+ *   columnWidth: ['20','10'], //宽度,数组
+ *   datas: [], // 数据，表格的原始数据
+ *   paramLeft: '查询时间：2022年01月-2022年05月',
+ *   paramRight: '箱、万元',
+ *   numberFormat: ['', '0.00', '0.00'], // 数组，设置数据格式
+ *   rowSpanColumns:[column1,column2……], // 需要跨行的列
+ *   rowSpanIndexCol:'', // 根据哪一列进行跨行计算，如根据卷烟ITEM_NAME
+ * } excelData
+ */
+export function importJsonFromExcel(excelData) {
+  return new Promise((resolve, reject) => {
+    var calcExportDatas = getAgColumnTitleAndData(excelData);
+
+    var titleDeepth = calcExportDatas.deepth;
+
+    var jsonData = calcExportDatas.exportData;
+
+    const reader = new FileReader();
+    reader.onload = async (event) => {
+      XlsxPopulate.fromDataAsync(event.target.result)
+        .then((workbook) => {
+          // Modify the workbook.
+          var sheet = workbook.sheet(0);
+
+          var rowsNow = 2; // 默认有标题行
+          if (excelData.noTitle) {
+            // 支持不要标题行
+            rowsNow = 1;
+          }
+
+          if (!!excelData.paramLeft || !!excelData.paramRight) {
+            rowsNow += 1;
+          }
+
+          // 处理表格里的数据，挨家挨户搜一下
+          rowsNow += titleDeepth;
+
+          let resutJson = [];
+          // for (var i = 0; i < jsonData.length; i++) {
+          for (let i = rowsNow; i < sheet._rows.length; i++) {
+            var lineData = sheet.row(i);
+            let tmpRow = {};
+            resutJson.push(tmpRow);
+            // excel列数据 这个索引从1开始
+            for (let j = 1; j < lineData._cells.length; j++) {
+              let val = lineData._cells[j] && lineData._cells[j]._value;
+              if (j > calcExportDatas.columnsCalc.length) {
+                continue;
+              }
+              let col = calcExportDatas.columnsCalc[j - 1];
+              tmpRow[col.field] = val;
+              // excelData.datas[i][col.field] = val
+            }
+          }
+
+          resolve(resutJson);
+        })
+        .catch((err) => console.log(err));
+    };
+
+    reader.readAsArrayBuffer(excelData.file);
+  });
+}
+
+export function importJsonFromLegacyExcel(excelData) {
+  console.log("正使用兼容模式处理 Excel 文件");
+  return new Promise((resolve, reject) => {
+    var calcExportDatas = getAgColumnTitleAndData(excelData);
+
+    var titleDeepth = calcExportDatas.deepth;
+
+    var jsonData = calcExportDatas.exportData;
+
+    const reader = new FileReader();
+    reader.onload = async (event) => {
+      try {
+        // 1. 使用 xlsx 库读取数据
+        const workbook = XLSX.read(event.target.result, { type: "buffer" });
+        const firstSheetName = workbook.SheetNames[0];
+        const worksheet = workbook.Sheets[firstSheetName];
+
+        // 2. 计算数据起始行（兼容原逻辑）
+        let dataStartRow = excelData.noTitle ? 0 : 1; // xlsx 行号从0开始
+        if (!!excelData.paramLeft || !!excelData.paramRight) {
+          dataStartRow += 1;
+        }
+        dataStartRow += calcExportDatas.deepth;
+
+        // 3. 转换数据为JSON格式
+        const jsonData = XLSX.utils.sheet_to_json(worksheet, {
+          header: 1, // 获取原始数组数据
+          range: dataStartRow, // 从数据区开始读取
+          raw: true, // 保持原始数据格式
+        });
+
+        // 4. 映射列字段
+        const result = jsonData.map((row) => {
+          return calcExportDatas.columnsCalc.reduce((obj, col, index) => {
+            obj[col.field] = row[index] || null;
+            return obj;
+          }, {});
+        });
+
+        resolve(result);
+      } catch (err) {
+        console.log("reader.onload= ~ err:", err);
+        reject(err);
+      }
+    };
+
+    reader.readAsArrayBuffer(excelData.file);
+  });
+}
+
+const ENGLISH_LETTER = [
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+];
+
+/**
+ * 根据列的数组下标返回excel对应的列号 (目前是按照.xlsx的定义计算的)
+ *
+ * @param {number} number 列的下标，从0开始计数
+ * @returns excel里的列号
+ */
+export function getExcelColumnIdx(number) {
+  if (!number) return "";
+
+  let rlt = "";
+  const length = ENGLISH_LETTER.length;
+
+  while (number >= 0) {
+    const idx = number % length;
+    rlt = ENGLISH_LETTER[idx] + rlt;
+
+    number = parseInt((number - idx) / length) - 1;
+  }
+  return rlt;
+}