@fecp/mobile 1.1.49 → 1.1.51

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/export/hook.mjs

@@ -1,1455 +0,0 @@
-import { inject, nextTick } from "vue";
-import XEUtils from "../../../../../../../../../_virtual/index.mjs";
-import "../../../ui/index.mjs";
-import { isColumnInfo, getCellValue } from "../../src/util.mjs";
-import { parseFile, formatText, eqEmptyValue } from "../../../ui/src/utils.mjs";
-import { hasClass } from "../../../ui/src/dom.mjs";
-import { getExportBlobByContent, createHtmlPage } from "./util.mjs";
-import { errLog } from "../../../ui/src/log.mjs";
-import { VxeUI } from "../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.mjs";
-const { getI18n, hooks, renderer } = VxeUI;
-let htmlCellElem;
-const csvBOM = "\uFEFF";
-const enterSymbol = "\r\n";
-function defaultFilterExportColumn(column) {
-  return column.field || ["seq", "checkbox", "radio"].indexOf(column.type) > -1;
-}
-const getConvertColumns = (columns) => {
-  const result = [];
-  columns.forEach((column) => {
-    if (column.childNodes && column.childNodes.length) {
-      result.push(column);
-      result.push(...getConvertColumns(column.childNodes));
-    } else {
-      result.push(column);
-    }
-  });
-  return result;
-};
-const convertToRows = (originColumns) => {
-  let maxLevel = 1;
-  const traverse = (column, parent) => {
-    if (parent) {
-      column._level = parent._level + 1;
-      if (maxLevel < column._level) {
-        maxLevel = column._level;
-      }
-    }
-    if (column.childNodes && column.childNodes.length) {
-      let colSpan = 0;
-      column.childNodes.forEach((subColumn) => {
-        traverse(subColumn, column);
-        colSpan += subColumn._colSpan;
-      });
-      column._colSpan = colSpan;
-    } else {
-      column._colSpan = 1;
-    }
-  };
-  originColumns.forEach((column) => {
-    column._level = 1;
-    traverse(column);
-  });
-  const rows = [];
-  for (let i = 0; i < maxLevel; i++) {
-    rows.push([]);
-  }
-  const allColumns = getConvertColumns(originColumns);
-  allColumns.forEach((column) => {
-    if (column.childNodes && column.childNodes.length) {
-      column._rowSpan = 1;
-    } else {
-      column._rowSpan = maxLevel - column._level + 1;
-    }
-    rows[column._level - 1].push(column);
-  });
-  return rows;
-};
-function toTableBorder(border) {
-  if (border === true) {
-    return "full";
-  }
-  if (border) {
-    return border;
-  }
-  return "default";
-}
-function getBooleanValue(cellValue) {
-  return cellValue === "TRUE" || cellValue === "true" || cellValue === true;
-}
-function getFooterData(opts, footerTableData) {
-  const { footerFilterMethod } = opts;
-  return footerFilterMethod ? footerTableData.filter((items, index) => footerFilterMethod({ items, $rowIndex: index })) : footerTableData;
-}
-function getCsvCellTypeLabel(column, cellValue) {
-  if (cellValue) {
-    if (column.type === "seq") {
-      return `	${cellValue}`;
-    }
-    switch (column.cellType) {
-      case "string":
-        if (!isNaN(cellValue)) {
-          return `	${cellValue}`;
-        }
-        break;
-      case "number":
-        break;
-      default:
-        if (cellValue.length >= 12 && !isNaN(cellValue)) {
-          return `	${cellValue}`;
-        }
-        break;
-    }
-  }
-  return cellValue;
-}
-function toTxtCellLabel(val) {
-  if (/[",\s\n]/.test(val)) {
-    return `"${val.replace(/"/g, '""')}"`;
-  }
-  return val;
-}
-function getElementsByTagName(elem, qualifiedName) {
-  return elem.getElementsByTagName(qualifiedName);
-}
-function getTxtCellKey(now) {
-  return `#${now}@${XEUtils.uniqueId()}`;
-}
-function replaceTxtCell(cell, vMaps) {
-  return cell.replace(/#\d+@\d+/g, (key) => XEUtils.hasOwnProp(vMaps, key) ? vMaps[key] : key);
-}
-function getTxtCellValue(val, vMaps) {
-  const rest = replaceTxtCell(val, vMaps);
-  return rest.replace(/^"+$/g, (qVal) => '"'.repeat(Math.ceil(qVal.length / 2)));
-}
-function toExportField(tableConf, field) {
-  const { fieldMaps, titleMaps } = tableConf;
-  if (!fieldMaps[field]) {
-    const teCol = titleMaps[field];
-    if (teCol && teCol.field) {
-      field = teCol.field;
-    }
-  }
-  return field;
-}
-function parseCsvAndTxt(tableConf, content, cellSeparator) {
-  const list = content.split(enterSymbol);
-  const rows = [];
-  let fields = [];
-  if (list.length) {
-    const vMaps = {};
-    const now = Date.now();
-    list.forEach((rVal) => {
-      if (rVal) {
-        const item = {};
-        rVal = rVal.replace(/("")|(\n)/g, (text, dVal) => {
-          const key = getTxtCellKey(now);
-          vMaps[key] = dVal ? '"' : "\n";
-          return key;
-        }).replace(/"(.*?)"/g, (text, cVal) => {
-          const key = getTxtCellKey(now);
-          vMaps[key] = replaceTxtCell(cVal, vMaps);
-          return key;
-        });
-        const cells = rVal.split(cellSeparator);
-        if (!fields.length) {
-          fields = cells.map((val) => toExportField(tableConf, getTxtCellValue(val.trim(), vMaps)));
-        } else {
-          cells.forEach((val, colIndex) => {
-            if (colIndex < fields.length) {
-              item[fields[colIndex]] = getTxtCellValue(val.trim(), vMaps);
-            }
-          });
-          rows.push(item);
-        }
-      }
-    });
-  }
-  return { fields, rows };
-}
-function parseCsv(tableConf, content) {
-  return parseCsvAndTxt(tableConf, content, ",");
-}
-function parseTxt(tableConf, content) {
-  return parseCsvAndTxt(tableConf, content, "	");
-}
-function parseHTML(tableConf, content) {
-  const domParser = new DOMParser();
-  const xmlDoc = domParser.parseFromString(content, "text/html");
-  const bodyNodes = getElementsByTagName(xmlDoc, "body");
-  const rows = [];
-  const fields = [];
-  if (bodyNodes.length) {
-    const tableNodes = getElementsByTagName(bodyNodes[0], "table");
-    if (tableNodes.length) {
-      const theadNodes = getElementsByTagName(tableNodes[0], "thead");
-      if (theadNodes.length) {
-        XEUtils.arrayEach(getElementsByTagName(theadNodes[0], "tr"), (rowNode) => {
-          XEUtils.arrayEach(getElementsByTagName(rowNode, "th"), (cellNode) => {
-            fields.push(toExportField(tableConf, cellNode.textContent || ""));
-          });
-        });
-        const tbodyNodes = getElementsByTagName(tableNodes[0], "tbody");
-        if (tbodyNodes.length) {
-          XEUtils.arrayEach(getElementsByTagName(tbodyNodes[0], "tr"), (rowNode) => {
-            const item = {};
-            XEUtils.arrayEach(getElementsByTagName(rowNode, "td"), (cellNode, colIndex) => {
-              if (fields[colIndex]) {
-                item[fields[colIndex]] = cellNode.textContent || "";
-              }
-            });
-            rows.push(item);
-          });
-        }
-      }
-    }
-  }
-  return { fields, rows };
-}
-function parseXML(tableConf, content) {
-  const domParser = new DOMParser();
-  const xmlDoc = domParser.parseFromString(content, "application/xml");
-  const sheetNodes = getElementsByTagName(xmlDoc, "Worksheet");
-  const rows = [];
-  const fields = [];
-  if (sheetNodes.length) {
-    const tableNodes = getElementsByTagName(sheetNodes[0], "Table");
-    if (tableNodes.length) {
-      const rowNodes = getElementsByTagName(tableNodes[0], "Row");
-      if (rowNodes.length) {
-        XEUtils.arrayEach(getElementsByTagName(rowNodes[0], "Cell"), (cellNode) => {
-          fields.push(toExportField(tableConf, cellNode.textContent || ""));
-        });
-        XEUtils.arrayEach(rowNodes, (rowNode, index) => {
-          if (index) {
-            const item = {};
-            const cellNodes = getElementsByTagName(rowNode, "Cell");
-            XEUtils.arrayEach(cellNodes, (cellNode, colIndex) => {
-              if (fields[colIndex]) {
-                item[fields[colIndex]] = cellNode.textContent;
-              }
-            });
-            rows.push(item);
-          }
-        });
-      }
-    }
-  }
-  return { fields, rows };
-}
-function clearColumnConvert(columns) {
-  XEUtils.eachTree(columns, (column) => {
-    delete column._level;
-    delete column._colSpan;
-    delete column._rowSpan;
-    delete column._children;
-    delete column.childNodes;
-  }, { children: "children" });
-}
-const tableExportMethodKeys = ["exportData", "importByFile", "importData", "saveFile", "readFile", "print", "getPrintHtml", "openImport", "closeImport", "openExport", "closeExport", "openPrint", "closePrint"];
-hooks.add("tableExportModule", {
-  setupTable($xeTable) {
-    const { props, reactData, internalData } = $xeTable;
-    const { computeTreeOpts, computePrintOpts, computeExportOpts, computeImportOpts, computeCustomOpts, computeSeqOpts, computeRadioOpts, computeCheckboxOpts, computeColumnOpts } = $xeTable.getComputeMaps();
-    const $xeGrid = inject("$xeGrid", null);
-    const hasTreeChildren = (row) => {
-      const treeOpts = computeTreeOpts.value;
-      const childrenField = treeOpts.children || treeOpts.childrenField;
-      return row[childrenField] && row[childrenField].length;
-    };
-    const getSeq = (cellValue, row, $rowIndex, column, $columnIndex) => {
-      const seqOpts = computeSeqOpts.value;
-      const seqMethod = seqOpts.seqMethod || column.seqMethod;
-      if (seqMethod) {
-        return seqMethod({
-          row,
-          rowIndex: $xeTable.getRowIndex(row),
-          $rowIndex,
-          column,
-          columnIndex: $xeTable.getColumnIndex(column),
-          $columnIndex
-        });
-      }
-      return cellValue;
-    };
-    function getHeaderTitle(opts, column) {
-      const columnOpts = computeColumnOpts.value;
-      const headExportMethod = column.headerExportMethod || columnOpts.headerExportMethod;
-      return headExportMethod ? headExportMethod({ column, options: opts, $table: $xeTable }) : (opts.isTitle ? column.getTitle() : column.field) || "";
-    }
-    const toBooleanValue = (cellValue) => {
-      return XEUtils.isBoolean(cellValue) ? cellValue ? "TRUE" : "FALSE" : cellValue;
-    };
-    const toStringValue = (cellValue) => {
-      return eqEmptyValue(cellValue) ? "" : `${cellValue}`;
-    };
-    const getBodyLabelData = (opts, columns, datas) => {
-      const { isAllExpand, mode } = opts;
-      const { treeConfig } = props;
-      const radioOpts = computeRadioOpts.value;
-      const checkboxOpts = computeCheckboxOpts.value;
-      const treeOpts = computeTreeOpts.value;
-      const columnOpts = computeColumnOpts.value;
-      if (!htmlCellElem) {
-        htmlCellElem = document.createElement("div");
-      }
-      if (treeConfig) {
-        const childrenField = treeOpts.children || treeOpts.childrenField;
-        const rest = [];
-        const expandMaps = /* @__PURE__ */ new Map();
-        XEUtils.eachTree(datas, (item, $rowIndex, items, path, parent, nodes) => {
-          const row = item._row || item;
-          const parentRow = parent && parent._row ? parent._row : parent;
-          if (isAllExpand || !parentRow || expandMaps.has(parentRow) && $xeTable.isTreeExpandByRow(parentRow)) {
-            const hasRowChild = hasTreeChildren(row);
-            const item2 = {
-              _row: row,
-              _level: nodes.length - 1,
-              _hasChild: hasRowChild,
-              _expand: hasRowChild && $xeTable.isTreeExpandByRow(row)
-            };
-            columns.forEach((column, $columnIndex) => {
-              let cellValue = "";
-              const renderOpts = column.editRender || column.cellRender;
-              let bodyExportMethod = column.exportMethod || columnOpts.exportMethod;
-              if (!bodyExportMethod && renderOpts && renderOpts.name) {
-                const compConf = renderer.get(renderOpts.name);
-                if (compConf) {
-                  bodyExportMethod = compConf.tableExportMethod || compConf.exportMethod;
-                }
-              }
-              if (!bodyExportMethod) {
-                bodyExportMethod = columnOpts.exportMethod;
-              }
-              if (bodyExportMethod) {
-                cellValue = bodyExportMethod({ $table: $xeTable, row, column, options: opts });
-              } else {
-                switch (column.type) {
-                  case "seq": {
-                    const seqVal = path.map((num, i) => i % 2 === 0 ? Number(num) + 1 : ".").join("");
-                    cellValue = mode === "all" ? seqVal : getSeq(seqVal, row, $rowIndex, column, $columnIndex);
-                    break;
-                  }
-                  case "checkbox":
-                    cellValue = toBooleanValue($xeTable.isCheckedByCheckboxRow(row));
-                    item2._checkboxLabel = checkboxOpts.labelField ? XEUtils.get(row, checkboxOpts.labelField) : "";
-                    item2._checkboxDisabled = checkboxOpts.checkMethod && !checkboxOpts.checkMethod({ row });
-                    break;
-                  case "radio":
-                    cellValue = toBooleanValue($xeTable.isCheckedByRadioRow(row));
-                    item2._radioLabel = radioOpts.labelField ? XEUtils.get(row, radioOpts.labelField) : "";
-                    item2._radioDisabled = radioOpts.checkMethod && !radioOpts.checkMethod({ row });
-                    break;
-                  default:
-                    if (opts.original) {
-                      cellValue = getCellValue(row, column);
-                    } else {
-                      cellValue = $xeTable.getCellLabel(row, column);
-                      if (column.type === "html") {
-                        htmlCellElem.innerHTML = cellValue;
-                        cellValue = htmlCellElem.innerText.trim();
-                      } else {
-                        const cell = $xeTable.getCellElement(row, column);
-                        if (cell && !hasClass(cell, "is--progress")) {
-                          cellValue = cell.innerText.trim();
-                        }
-                      }
-                    }
-                }
-              }
-              item2[column.id] = toStringValue(cellValue);
-            });
-            expandMaps.set(row, 1);
-            rest.push(Object.assign(item2, row));
-          }
-        }, { children: childrenField });
-        return rest;
-      }
-      return datas.map((row, $rowIndex) => {
-        const item = {
-          _row: row
-        };
-        columns.forEach((column, $columnIndex) => {
-          let cellValue = "";
-          const renderOpts = column.editRender || column.cellRender;
-          let bodyExportMethod = column.exportMethod || columnOpts.exportMethod;
-          if (!bodyExportMethod && renderOpts && renderOpts.name) {
-            const compConf = renderer.get(renderOpts.name);
-            if (compConf) {
-              bodyExportMethod = compConf.tableExportMethod || compConf.exportMethod;
-            }
-          }
-          if (bodyExportMethod) {
-            cellValue = bodyExportMethod({ $table: $xeTable, row, column, options: opts });
-          } else {
-            switch (column.type) {
-              case "seq": {
-                const seqValue = $rowIndex + 1;
-                cellValue = mode === "all" ? seqValue : getSeq(seqValue, row, $rowIndex, column, $columnIndex);
-                break;
-              }
-              case "checkbox":
-                cellValue = toBooleanValue($xeTable.isCheckedByCheckboxRow(row));
-                item._checkboxLabel = checkboxOpts.labelField ? XEUtils.get(row, checkboxOpts.labelField) : "";
-                item._checkboxDisabled = checkboxOpts.checkMethod && !checkboxOpts.checkMethod({ row });
-                break;
-              case "radio":
-                cellValue = toBooleanValue($xeTable.isCheckedByRadioRow(row));
-                item._radioLabel = radioOpts.labelField ? XEUtils.get(row, radioOpts.labelField) : "";
-                item._radioDisabled = radioOpts.checkMethod && !radioOpts.checkMethod({ row });
-                break;
-              default:
-                if (opts.original) {
-                  cellValue = getCellValue(row, column);
-                } else {
-                  cellValue = $xeTable.getCellLabel(row, column);
-                  if (column.type === "html") {
-                    htmlCellElem.innerHTML = cellValue;
-                    cellValue = htmlCellElem.innerText.trim();
-                  } else {
-                    const cell = $xeTable.getCellElement(row, column);
-                    if (cell && !hasClass(cell, "is--progress")) {
-                      cellValue = cell.innerText.trim();
-                    }
-                  }
-                }
-            }
-          }
-          item[column.id] = toStringValue(cellValue);
-        });
-        return item;
-      });
-    };
-    const getExportData = (opts) => {
-      const { columns, dataFilterMethod } = opts;
-      let datas = opts.data;
-      if (dataFilterMethod) {
-        datas = datas.filter((row, index) => dataFilterMethod({ row, $rowIndex: index }));
-      }
-      return getBodyLabelData(opts, columns, datas);
-    };
-    const getFooterCellValue = (opts, row, column) => {
-      const columnOpts = computeColumnOpts.value;
-      const renderOpts = column.editRender || column.cellRender;
-      let footLabelMethod = column.footerExportMethod;
-      if (!footLabelMethod && renderOpts && renderOpts.name) {
-        const compConf = renderer.get(renderOpts.name);
-        if (compConf) {
-          footLabelMethod = compConf.tableFooterExportMethod || compConf.footerExportMethod;
-        }
-      }
-      if (!footLabelMethod) {
-        footLabelMethod = columnOpts.footerExportMethod;
-      }
-      const _columnIndex = $xeTable.getVTColumnIndex(column);
-      if (footLabelMethod) {
-        return footLabelMethod({ $table: $xeTable, items: row, itemIndex: _columnIndex, row, _columnIndex, column, options: opts });
-      }
-      if (XEUtils.isArray(row)) {
-        return XEUtils.toValueString(row[_columnIndex]);
-      }
-      return XEUtils.get(row, column.field);
-    };
-    const toCsv = (opts, columns, datas) => {
-      let content = csvBOM;
-      if (opts.isHeader) {
-        content += columns.map((column) => toTxtCellLabel(getHeaderTitle(opts, column))).join(",") + enterSymbol;
-      }
-      datas.forEach((row) => {
-        content += columns.map((column) => toTxtCellLabel(getCsvCellTypeLabel(column, row[column.id]))).join(",") + enterSymbol;
-      });
-      if (opts.isFooter) {
-        const { footerTableData } = reactData;
-        const footers = getFooterData(opts, footerTableData);
-        footers.forEach((row) => {
-          content += columns.map((column) => toTxtCellLabel(getFooterCellValue(opts, row, column))).join(",") + enterSymbol;
-        });
-      }
-      return content;
-    };
-    const toTxt = (opts, columns, datas) => {
-      let content = "";
-      if (opts.isHeader) {
-        content += columns.map((column) => toTxtCellLabel(getHeaderTitle(opts, column))).join("	") + enterSymbol;
-      }
-      datas.forEach((row) => {
-        content += columns.map((column) => toTxtCellLabel(row[column.id])).join("	") + enterSymbol;
-      });
-      if (opts.isFooter) {
-        const { footerTableData } = reactData;
-        const footers = getFooterData(opts, footerTableData);
-        footers.forEach((row) => {
-          content += columns.map((column) => toTxtCellLabel(getFooterCellValue(opts, row, column))).join("	") + enterSymbol;
-        });
-      }
-      return content;
-    };
-    const hasEllipsis = (column, property, allColumnOverflow) => {
-      const columnOverflow = column[property];
-      const headOverflow = XEUtils.isUndefined(columnOverflow) || XEUtils.isNull(columnOverflow) ? allColumnOverflow : columnOverflow;
-      const showEllipsis = headOverflow === "ellipsis";
-      const showTitle = headOverflow === "title";
-      const showTooltip = headOverflow === true || headOverflow === "tooltip";
-      let isEllipsis = showTitle || showTooltip || showEllipsis;
-      const { scrollXLoad, scrollYLoad } = reactData;
-      if ((scrollXLoad || scrollYLoad) && !isEllipsis) {
-        isEllipsis = true;
-      }
-      return isEllipsis;
-    };
-    const toHtml = (opts, columns, datas) => {
-      const { id, border, treeConfig, headerAlign: allHeaderAlign, align: allAlign, footerAlign: allFooterAlign, showOverflow: allColumnOverflow, showHeaderOverflow: allColumnHeaderOverflow } = props;
-      const { isAllSelected, isIndeterminate } = reactData;
-      const { mergeBodyCellMaps } = internalData;
-      const treeOpts = computeTreeOpts.value;
-      const { print: isPrint, isHeader, isFooter, isColgroup, isMerge, colgroups, original } = opts;
-      const allCls = "check-all";
-      const clss = [
-        "vxe-table",
-        `border--${toTableBorder(border)}`,
-        isPrint ? "is--print" : "",
-        isHeader ? "is--header" : ""
-      ].filter((cls) => cls);
-      const tables = [
-        `<table class="${clss.join(" ")}" border="0" cellspacing="0" cellpadding="0">`,
-        `<colgroup>${columns.map((column) => `<col style="width:${column.renderWidth}px">`).join("")}</colgroup>`
-      ];
-      if (isHeader) {
-        tables.push("<thead>");
-        if (isColgroup && !original) {
-          colgroups.forEach((cols) => {
-            tables.push(`<tr>${cols.map((column) => {
-              const headAlign = column.headerAlign || column.align || allHeaderAlign || allAlign;
-              const classNames = hasEllipsis(column, "showHeaderOverflow", allColumnHeaderOverflow) ? ["col--ellipsis"] : [];
-              const cellTitle = getHeaderTitle(opts, column);
-              let childWidth = 0;
-              let countChild = 0;
-              XEUtils.eachTree([column], (item) => {
-                if (!item.childNodes || !column.childNodes.length) {
-                  countChild++;
-                }
-                childWidth += item.renderWidth;
-              }, { children: "childNodes" });
-              const cellWidth = childWidth - countChild;
-              if (headAlign) {
-                classNames.push(`col--${headAlign}`);
-              }
-              if (column.type === "checkbox") {
-                return `<th class="${classNames.join(" ")}" colspan="${column._colSpan}" rowspan="${column._rowSpan}"><div ${isPrint ? "" : `style="width: ${cellWidth}px"`}><input type="checkbox" class="${allCls}" ${isAllSelected ? "checked" : ""}><span>${cellTitle}</span></div></th>`;
-              }
-              return `<th class="${classNames.join(" ")}" colspan="${column._colSpan}" rowspan="${column._rowSpan}" title="${cellTitle}"><div ${isPrint ? "" : `style="width: ${cellWidth}px"`}><span>${formatText(cellTitle, true)}</span></div></th>`;
-            }).join("")}</tr>`);
-          });
-        } else {
-          tables.push(`<tr>${columns.map((column) => {
-            const headAlign = column.headerAlign || column.align || allHeaderAlign || allAlign;
-            const classNames = hasEllipsis(column, "showHeaderOverflow", allColumnHeaderOverflow) ? ["col--ellipsis"] : [];
-            const cellTitle = getHeaderTitle(opts, column);
-            if (headAlign) {
-              classNames.push(`col--${headAlign}`);
-            }
-            if (column.type === "checkbox") {
-              return `<th class="${classNames.join(" ")}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><input type="checkbox" class="${allCls}" ${isAllSelected ? "checked" : ""}><span>${cellTitle}</span></div></th>`;
-            }
-            return `<th class="${classNames.join(" ")}" title="${cellTitle}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><span>${formatText(cellTitle, true)}</span></div></th>`;
-          }).join("")}</tr>`);
-        }
-        tables.push("</thead>");
-      }
-      if (datas.length) {
-        tables.push("<tbody>");
-        if (treeConfig) {
-          datas.forEach((item) => {
-            tables.push("<tr>" + columns.map((column) => {
-              const colid = column.id;
-              const cellAlign = column.align || allAlign;
-              const classNames = hasEllipsis(column, "showOverflow", allColumnOverflow) ? ["col--ellipsis"] : [];
-              const cellValue = item[colid];
-              if (cellAlign) {
-                classNames.push(`col--${cellAlign}`);
-              }
-              if (column.treeNode) {
-                let treeIcon = "";
-                if (item._hasChild) {
-                  treeIcon = `<i class="${item._expand ? "vxe-table--tree-fold-icon" : "vxe-table--tree-unfold-icon"}"></i>`;
-                }
-                classNames.push("vxe-table--tree-node");
-                if (column.type === "radio") {
-                  return `<td class="${classNames.join(" ")}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><div class="vxe-table--tree-node-wrapper" style="padding-left: ${item._level * treeOpts.indent}px"><div class="vxe-table--tree-icon-wrapper">${treeIcon}</div><div class="vxe-table--tree-cell"><input type="radio" name="radio_${id}" ${item._radioDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._radioLabel}</span></div></div></div></td>`;
-                } else if (column.type === "checkbox") {
-                  return `<td class="${classNames.join(" ")}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><div class="vxe-table--tree-node-wrapper" style="padding-left: ${item._level * treeOpts.indent}px"><div class="vxe-table--tree-icon-wrapper">${treeIcon}</div><div class="vxe-table--tree-cell"><input type="checkbox" ${item._checkboxDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._checkboxLabel}</span></div></div></div></td>`;
-                }
-                return `<td class="${classNames.join(" ")}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><div class="vxe-table--tree-node-wrapper" style="padding-left: ${item._level * treeOpts.indent}px"><div class="vxe-table--tree-icon-wrapper">${treeIcon}</div><div class="vxe-table--tree-cell">${cellValue}</div></div></div></td>`;
-              }
-              if (column.type === "radio") {
-                return `<td class="${classNames.join(" ")}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><input type="radio" name="radio_${id}" ${item._radioDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._radioLabel}</span></div></td>`;
-              } else if (column.type === "checkbox") {
-                return `<td class="${classNames.join(" ")}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><input type="checkbox" ${item._checkboxDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._checkboxLabel}</span></div></td>`;
-              }
-              return `<td class="${classNames.join(" ")}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}>${formatText(cellValue, true)}</div></td>`;
-            }).join("") + "</tr>");
-          });
-        } else {
-          datas.forEach((item) => {
-            tables.push("<tr>" + columns.map((column) => {
-              const cellAlign = column.align || allAlign;
-              const classNames = hasEllipsis(column, "showOverflow", allColumnOverflow) ? ["col--ellipsis"] : [];
-              const cellValue = item[column.id];
-              let rowSpan = 1;
-              let colSpan = 1;
-              if (isMerge) {
-                const _rowIndex = $xeTable.getVTRowIndex(item._row);
-                const _columnIndex = $xeTable.getVTColumnIndex(column);
-                const spanRest = mergeBodyCellMaps[`${_rowIndex}:${_columnIndex}`];
-                if (spanRest) {
-                  const { rowspan, colspan } = spanRest;
-                  if (!rowspan || !colspan) {
-                    return "";
-                  }
-                  if (rowspan > 1) {
-                    rowSpan = rowspan;
-                  }
-                  if (colspan > 1) {
-                    colSpan = colspan;
-                  }
-                }
-              }
-              if (cellAlign) {
-                classNames.push(`col--${cellAlign}`);
-              }
-              if (column.type === "radio") {
-                return `<td class="${classNames.join(" ")}" rowspan="${rowSpan}" colspan="${colSpan}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><input type="radio" name="radio_${id}" ${item._radioDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._radioLabel}</span></div></td>`;
-              } else if (column.type === "checkbox") {
-                return `<td class="${classNames.join(" ")}" rowspan="${rowSpan}" colspan="${colSpan}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}><input type="checkbox" ${item._checkboxDisabled ? "disabled " : ""}${getBooleanValue(cellValue) ? "checked" : ""}><span>${item._checkboxLabel}</span></div></td>`;
-              }
-              return `<td class="${classNames.join(" ")}" rowspan="${rowSpan}" colspan="${colSpan}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}>${formatText(cellValue, true)}</div></td>`;
-            }).join("") + "</tr>");
-          });
-        }
-        tables.push("</tbody>");
-      }
-      if (isFooter) {
-        const { footerTableData } = reactData;
-        const footers = getFooterData(opts, footerTableData);
-        if (footers.length) {
-          tables.push("<tfoot>");
-          footers.forEach((row) => {
-            tables.push(`<tr>${columns.map((column) => {
-              const footAlign = column.footerAlign || column.align || allFooterAlign || allAlign;
-              const classNames = hasEllipsis(column, "showOverflow", allColumnOverflow) ? ["col--ellipsis"] : [];
-              const cellValue = getFooterCellValue(opts, row, column);
-              if (footAlign) {
-                classNames.push(`col--${footAlign}`);
-              }
-              return `<td class="${classNames.join(" ")}" title="${cellValue}"><div ${isPrint ? "" : `style="width: ${column.renderWidth}px"`}>${formatText(cellValue, true)}</div></td>`;
-            }).join("")}</tr>`);
-          });
-          tables.push("</tfoot>");
-        }
-      }
-      const script = !isAllSelected && isIndeterminate ? `<script>(function(){var a=document.querySelector(".${allCls}");if(a){a.indeterminate=true}})()<\/script>` : "";
-      tables.push("</table>", script);
-      return isPrint ? tables.join("") : createHtmlPage(opts, tables.join(""));
-    };
-    const toXML = (opts, columns, datas) => {
-      let xml = [
-        '<?xml version="1.0"?>',
-        '<?mso-application progid="Excel.Sheet"?>',
-        '<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel" xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet" xmlns:html="http://www.w3.org/TR/REC-html40">',
-        '<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">',
-        "<Version>16.00</Version>",
-        "</DocumentProperties>",
-        '<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">',
-        "<WindowHeight>7920</WindowHeight>",
-        "<WindowWidth>21570</WindowWidth>",
-        "<WindowTopX>32767</WindowTopX>",
-        "<WindowTopY>32767</WindowTopY>",
-        "<ProtectStructure>False</ProtectStructure>",
-        "<ProtectWindows>False</ProtectWindows>",
-        "</ExcelWorkbook>",
-        `<Worksheet ss:Name="${opts.sheetName}">`,
-        "<Table>",
-        columns.map((column) => `<Column ss:Width="${column.renderWidth}"/>`).join("")
-      ].join("");
-      if (opts.isHeader) {
-        xml += `<Row>${columns.map((column) => `<Cell><Data ss:Type="String">${getHeaderTitle(opts, column)}</Data></Cell>`).join("")}</Row>`;
-      }
-      datas.forEach((row) => {
-        xml += "<Row>" + columns.map((column) => `<Cell><Data ss:Type="String">${row[column.id]}</Data></Cell>`).join("") + "</Row>";
-      });
-      if (opts.isFooter) {
-        const { footerTableData } = reactData;
-        const footers = getFooterData(opts, footerTableData);
-        footers.forEach((row) => {
-          xml += `<Row>${columns.map((column) => `<Cell><Data ss:Type="String">${getFooterCellValue(opts, row, column)}</Data></Cell>`).join("")}</Row>`;
-        });
-      }
-      return `${xml}</Table></Worksheet></Workbook>`;
-    };
-    const getContent = (opts, columns, datas) => {
-      if (columns.length) {
-        switch (opts.type) {
-          case "csv":
-            return toCsv(opts, columns, datas);
-          case "txt":
-            return toTxt(opts, columns, datas);
-          case "html":
-            return toHtml(opts, columns, datas);
-          case "xml":
-            return toXML(opts, columns, datas);
-        }
-      }
-      return "";
-    };
-    const downloadFile = (opts, content) => {
-      const { filename, type, download } = opts;
-      if (!download) {
-        const blob = getExportBlobByContent(content, opts);
-        return Promise.resolve({ type, content, blob });
-      }
-      if (VxeUI.saveFile) {
-        VxeUI.saveFile({ filename, type, content }).then(() => {
-          if (opts.message !== false) {
-            if (VxeUI.modal) {
-              VxeUI.modal.message({ content: getI18n("vxe.table.expSuccess"), status: "success" });
-            }
-          }
-        });
-      }
-    };
-    const handleExport = (opts) => {
-      const { remote, columns, colgroups, exportMethod, afterExportMethod } = opts;
-      return new Promise((resolve) => {
-        if (remote) {
-          const params = { options: opts, $table: $xeTable, $grid: $xeGrid };
-          resolve(exportMethod ? exportMethod(params) : params);
-        } else {
-          const datas = getExportData(opts);
-          resolve($xeTable.preventEvent(null, "event.export", { options: opts, columns, colgroups, datas }, () => {
-            return downloadFile(opts, getContent(opts, columns, datas));
-          }));
-        }
-      }).then((params) => {
-        clearColumnConvert(columns);
-        if (!opts.print) {
-          if (afterExportMethod) {
-            afterExportMethod({ status: true, options: opts, $table: $xeTable, $grid: $xeGrid });
-          }
-        }
-        return Object.assign({ status: true }, params);
-      }).catch(() => {
-        clearColumnConvert(columns);
-        if (!opts.print) {
-          if (afterExportMethod) {
-            afterExportMethod({ status: false, options: opts, $table: $xeTable, $grid: $xeGrid });
-          }
-        }
-        const params = { status: false };
-        return Promise.reject(params);
-      });
-    };
-    const handleImport = (content, opts) => {
-      const { tableFullColumn, _importResolve, _importReject } = internalData;
-      let rest = { fields: [], rows: [] };
-      const tableFieldMaps = {};
-      const tableTitleMaps = {};
-      tableFullColumn.forEach((column) => {
-        const field = column.field;
-        const title = column.getTitle();
-        if (field) {
-          tableFieldMaps[field] = column;
-        }
-        if (title) {
-          tableTitleMaps[column.getTitle()] = column;
-        }
-      });
-      const tableConf = {
-        fieldMaps: tableFieldMaps,
-        titleMaps: tableTitleMaps
-      };
-      switch (opts.type) {
-        case "csv":
-          rest = parseCsv(tableConf, content);
-          break;
-        case "txt":
-          rest = parseTxt(tableConf, content);
-          break;
-        case "html":
-          rest = parseHTML(tableConf, content);
-          break;
-        case "xml":
-          rest = parseXML(tableConf, content);
-          break;
-      }
-      const { fields, rows } = rest;
-      const status = fields.some((field) => tableFieldMaps[field] || tableTitleMaps[field]);
-      if (status) {
-        $xeTable.createData(rows).then((data) => {
-          let loadRest;
-          if (opts.mode === "insert" || opts.mode === "insertBottom") {
-            loadRest = $xeTable.insertAt(data, -1);
-          }
-          if (opts.mode === "insertTop") {
-            loadRest = $xeTable.insert(data);
-          } else {
-            loadRest = $xeTable.reloadData(data);
-          }
-          if (opts.message !== false) {
-            if (VxeUI.modal) {
-              VxeUI.modal.message({ content: getI18n("vxe.table.impSuccess", [rows.length]), status: "success" });
-            }
-          }
-          return loadRest.then(() => {
-            if (_importResolve) {
-              _importResolve({ status: true });
-            }
-          });
-        });
-      } else if (opts.message !== false) {
-        if (VxeUI.modal) {
-          VxeUI.modal.message({ content: getI18n("vxe.error.impFields"), status: "error" });
-        }
-        if (_importReject) {
-          _importReject({ status: false });
-        }
-      }
-    };
-    const handleFileImport = (file, opts) => {
-      const { importMethod, afterImportMethod } = opts;
-      const { type, filename } = parseFile(file);
-      const importOpts = computeImportOpts.value;
-      if (!importMethod && !XEUtils.includes(XEUtils.keys(importOpts._typeMaps), type)) {
-        if (opts.message !== false) {
-          if (VxeUI.modal) {
-            VxeUI.modal.message({ content: getI18n("vxe.error.notType", [type]), status: "error" });
-          }
-        }
-        const params = { status: false };
-        return Promise.reject(params);
-      }
-      const rest = new Promise((resolve, reject) => {
-        const _importResolve = (params) => {
-          resolve(params);
-          internalData._importResolve = null;
-          internalData._importReject = null;
-        };
-        const _importReject = (params) => {
-          reject(params);
-          internalData._importResolve = null;
-          internalData._importReject = null;
-        };
-        internalData._importResolve = _importResolve;
-        internalData._importReject = _importReject;
-        if (window.FileReader) {
-          const options = Object.assign({ mode: "insertTop" }, opts, { type, filename });
-          if (options.remote) {
-            if (importMethod) {
-              Promise.resolve(importMethod({ file, options, $table: $xeTable })).then(() => {
-                _importResolve({ status: true });
-              }).catch(() => {
-                _importResolve({ status: true });
-              });
-            } else {
-              _importResolve({ status: true });
-            }
-          } else {
-            const { tableFullColumn } = internalData;
-            $xeTable.preventEvent(null, "event.import", { file, options, columns: tableFullColumn }, () => {
-              const reader = new FileReader();
-              reader.onerror = () => {
-                errLog("vxe.error.notType", [type]);
-                _importReject({ status: false });
-              };
-              reader.onload = (e) => {
-                handleImport(e.target.result, options);
-              };
-              reader.readAsText(file, options.encoding || "UTF-8");
-            });
-          }
-        } else {
-          errLog("vxe.error.notExp");
-          _importResolve({ status: true });
-        }
-      });
-      return rest.then(() => {
-        if (afterImportMethod) {
-          afterImportMethod({ status: true, options: opts, $table: $xeTable });
-        }
-      }).catch((e) => {
-        if (afterImportMethod) {
-          afterImportMethod({ status: false, options: opts, $table: $xeTable });
-        }
-        return Promise.reject(e);
-      });
-    };
-    const handleFilterColumns = (exportOpts, column, columns) => {
-      return columns.some((item) => {
-        if (isColumnInfo(item)) {
-          return column.id === item.id;
-        } else if (XEUtils.isString(item)) {
-          return column.field === item;
-        } else {
-          const colid = item.id || item.colId;
-          const type = item.type;
-          const field = item.field;
-          if (colid) {
-            return column.id === colid;
-          } else if (field && type) {
-            return column.field === field && column.type === type;
-          } else if (field) {
-            return column.field === field;
-          } else if (type) {
-            return column.type === type;
-          }
-        }
-        return false;
-      });
-    };
-    const handleFilterFields = (exportOpts, column, includeFields, excludeFields) => {
-      if (excludeFields) {
-        if (XEUtils.includes(excludeFields, column.field)) {
-          return false;
-        }
-      }
-      if (includeFields) {
-        if (XEUtils.includes(includeFields, column.field)) {
-          return true;
-        }
-        return false;
-      }
-      return exportOpts.original ? column.field : defaultFilterExportColumn(column);
-    };
-    const handleExportAndPrint = (options, isPrint) => {
-      const { treeConfig, showHeader, showFooter } = props;
-      const { initStore, isGroup, footerTableData, exportStore, exportParams } = reactData;
-      const { collectColumn, mergeBodyList, mergeFooterList } = internalData;
-      const exportOpts = computeExportOpts.value;
-      const hasTree = treeConfig;
-      const customOpts = computeCustomOpts.value;
-      const selectRecords = $xeTable.getCheckboxRecords();
-      const proxyOpts = $xeGrid ? $xeGrid.getComputeMaps().computeProxyOpts.value : {};
-      const hasFooter = !!footerTableData.length;
-      const hasMerge = !!(mergeBodyList.length || mergeFooterList.length);
-      const defOpts = Object.assign({
-        message: true,
-        isHeader: showHeader,
-        isTitle: showHeader,
-        isFooter: showFooter,
-        isColgroup: isGroup,
-        isMerge: hasMerge,
-        useStyle: true,
-        current: "current",
-        modes: (proxyOpts.ajax && proxyOpts.ajax.queryAll ? ["all"] : []).concat(["current", "selected", "empty"])
-      }, options);
-      const types = defOpts.types || XEUtils.keys(exportOpts._typeMaps);
-      const modes = defOpts.modes || [];
-      const checkMethod = customOpts.checkMethod;
-      const exportColumns = collectColumn.slice(0);
-      const { columns, excludeFields, includeFields } = defOpts;
-      const typeList = types.map((value) => {
-        return {
-          value,
-          label: getI18n(`vxe.export.types.${value}`)
-        };
-      });
-      const modeList = modes.map((item) => {
-        if (item && item.value) {
-          return {
-            value: item.value,
-            label: item.label || item.value
-          };
-        }
-        return {
-          value: item,
-          label: getI18n(`vxe.export.modes.${item}`)
-        };
-      });
-      XEUtils.eachTree(exportColumns, (column, index, items, path, parent) => {
-        const isColGroup = column.children && column.children.length;
-        let isChecked = false;
-        if (columns && columns.length) {
-          isChecked = handleFilterColumns(defOpts, column, columns);
-        } else if (excludeFields || includeFields) {
-          isChecked = handleFilterFields(defOpts, column, includeFields, excludeFields);
-        } else {
-          isChecked = column.visible && (isColGroup || defaultFilterExportColumn(column));
-        }
-        column.checked = isChecked;
-        column.halfChecked = false;
-        column.disabled = parent && parent.disabled || (checkMethod ? !checkMethod({ column }) : false);
-      });
-      Object.assign(exportStore, {
-        columns: exportColumns,
-        typeList,
-        modeList,
-        hasFooter,
-        hasMerge,
-        hasTree,
-        isPrint,
-        hasColgroup: isGroup,
-        visible: true
-      });
-      Object.assign(exportParams, {
-        mode: selectRecords.length ? "selected" : "current"
-      }, defOpts);
-      const { filename, sheetName, mode, type } = exportParams;
-      if (filename) {
-        if (XEUtils.isFunction(filename)) {
-          exportParams.filename = filename({
-            options: defOpts,
-            $table: $xeTable,
-            $grid: $xeGrid
-          });
-        } else {
-          exportParams.filename = `${filename}`;
-        }
-      }
-      if (sheetName) {
-        if (XEUtils.isFunction(sheetName)) {
-          exportParams.sheetName = sheetName({
-            options: defOpts,
-            $table: $xeTable,
-            $grid: $xeGrid
-          });
-        } else {
-          exportParams.sheetName = `${sheetName}`;
-        }
-      }
-      if (!modeList.some((item) => item.value === mode)) {
-        exportParams.mode = modeList[0].value;
-      }
-      if (!typeList.some((item) => item.value === type)) {
-        exportParams.type = typeList[0].value;
-      }
-      initStore.export = true;
-      return nextTick();
-    };
-    const handleCloseExport = () => {
-      if (VxeUI.modal) {
-        return VxeUI.modal.close("VXE_EXPORT_MODAL");
-      }
-      return Promise.resolve();
-    };
-    const exportMethods = {
-      /**
-       * 导出文件，支持 csv/html/xml/txt
-       * 如果是树表格，则默认是导出所有节点
-       * 如果是启用了虚拟滚动，则只能导出数据源，可以配合 dataFilterMethod 函数转换数据
-       * @param {Object} options 参数
-       */
-      exportData(options) {
-        const { treeConfig, showHeader, showFooter } = props;
-        const { isGroup } = reactData;
-        const { tableFullColumn, afterFullData, collectColumn, mergeBodyList, mergeFooterList } = internalData;
-        const exportOpts = computeExportOpts.value;
-        const treeOpts = computeTreeOpts.value;
-        const proxyOpts = $xeGrid ? $xeGrid.getComputeMaps().computeProxyOpts.value : {};
-        const hasMerge = !!(mergeBodyList.length || mergeFooterList.length);
-        const opts = Object.assign({
-          message: true,
-          isHeader: showHeader,
-          isTitle: showHeader,
-          isFooter: showFooter,
-          isColgroup: isGroup,
-          isMerge: hasMerge,
-          useStyle: true,
-          current: "current",
-          modes: (proxyOpts.ajax && proxyOpts.ajax.queryAll ? ["all"] : []).concat(["current", "selected", "empty"]),
-          download: true,
-          type: "csv"
-          // filename: '',
-          // sheetName: '',
-          // original: false,
-          // isAllExpand: false,
-          // data: null,
-          // remote: false,
-          // dataFilterMethod: null,
-          // footerFilterMethod: null,
-          // exportMethod: null,
-          // columnFilterMethod: null,
-          // beforeExportMethod: null,
-          // afterExportMethod: null
-        }, exportOpts, options);
-        let { filename, sheetName, type, mode, columns, original, columnFilterMethod, beforeExportMethod, includeFields, excludeFields } = opts;
-        let groups = [];
-        const selectRecords = $xeTable.getCheckboxRecords();
-        if (!mode) {
-          mode = selectRecords.length ? "selected" : "current";
-        }
-        const customCols = columns && columns.length ? columns : XEUtils.searchTree(collectColumn, (column) => {
-          const isColGroup = column.children && column.children.length;
-          let isChecked = false;
-          if (columns && columns.length) {
-            isChecked = handleFilterColumns(opts, column, columns);
-          } else if (excludeFields || includeFields) {
-            isChecked = handleFilterFields(opts, column, includeFields, excludeFields);
-          } else {
-            isChecked = column.visible && (isColGroup || defaultFilterExportColumn(column));
-          }
-          return isChecked;
-        }, { children: "children", mapChildren: "childNodes", original: true });
-        const handleOptions = Object.assign({}, opts, { filename: "", sheetName: "" });
-        if (!customCols && !columnFilterMethod) {
-          handleOptions.columnFilterMethod = ({ column }) => {
-            if (excludeFields) {
-              if (XEUtils.includes(excludeFields, column.field)) {
-                return false;
-              }
-            }
-            if (includeFields) {
-              if (XEUtils.includes(includeFields, column.field)) {
-                return true;
-              }
-              return false;
-            }
-            return original ? column.field : defaultFilterExportColumn(column);
-          };
-        }
-        if (customCols) {
-          handleOptions._isCustomColumn = true;
-          groups = XEUtils.searchTree(XEUtils.mapTree(customCols, (item) => {
-            let targetColumn;
-            if (item) {
-              if (isColumnInfo(item)) {
-                targetColumn = item;
-              } else if (XEUtils.isString(item)) {
-                targetColumn = $xeTable.getColumnByField(item);
-              } else {
-                const colid = item.id || item.colId;
-                const type2 = item.type;
-                const field = item.field;
-                if (colid) {
-                  targetColumn = $xeTable.getColumnById(colid);
-                } else if (field && type2) {
-                  targetColumn = tableFullColumn.find((column) => column.field === field && column.type === type2);
-                } else if (field) {
-                  targetColumn = $xeTable.getColumnByField(field);
-                } else if (type2) {
-                  targetColumn = tableFullColumn.find((column) => column.type === type2);
-                }
-              }
-              return targetColumn || {};
-            }
-          }, {
-            children: "childNodes",
-            mapChildren: "_children"
-          }), (column, index) => isColumnInfo(column) && (!columnFilterMethod || columnFilterMethod({ column, $columnIndex: index })), {
-            children: "_children",
-            mapChildren: "childNodes",
-            original: true
-          });
-        } else {
-          groups = XEUtils.searchTree(isGroup ? collectColumn : tableFullColumn, (column, index) => column.visible && (!columnFilterMethod || columnFilterMethod({ column, $columnIndex: index })), { children: "children", mapChildren: "childNodes", original: true });
-        }
-        const cols = [];
-        XEUtils.eachTree(groups, (column) => {
-          const isColGroup = column.children && column.children.length;
-          if (!isColGroup) {
-            cols.push(column);
-          }
-        }, { children: "childNodes" });
-        handleOptions.columns = cols;
-        handleOptions.colgroups = convertToRows(groups);
-        if (filename) {
-          if (XEUtils.isFunction(filename)) {
-            handleOptions.filename = filename({
-              options: opts,
-              $table: $xeTable,
-              $grid: $xeGrid
-            });
-          } else {
-            handleOptions.filename = `${filename}`;
-          }
-        }
-        if (!handleOptions.filename) {
-          handleOptions.filename = getI18n(handleOptions.original ? "vxe.table.expOriginFilename" : "vxe.table.expFilename", [XEUtils.toDateString(Date.now(), "yyyyMMddHHmmss")]);
-        }
-        if (sheetName) {
-          if (XEUtils.isFunction(sheetName)) {
-            handleOptions.sheetName = sheetName({
-              options: opts,
-              $table: $xeTable,
-              $grid: $xeGrid
-            });
-          } else {
-            handleOptions.sheetName = `${sheetName}`;
-          }
-        }
-        if (!handleOptions.sheetName) {
-          handleOptions.sheetName = document.title || "";
-        }
-        if (!handleOptions.exportMethod && !XEUtils.includes(XEUtils.keys(exportOpts._typeMaps), type)) {
-          errLog("vxe.error.notType", [type]);
-          const params = { status: false };
-          return Promise.reject(params);
-        }
-        if (!handleOptions.print) {
-          if (beforeExportMethod) {
-            beforeExportMethod({ options: handleOptions, $table: $xeTable, $grid: $xeGrid });
-          }
-        }
-        if (!handleOptions.data) {
-          handleOptions.data = [];
-          if (mode === "selected") {
-            if (["html", "pdf"].indexOf(type) > -1 && treeConfig) {
-              handleOptions.data = XEUtils.searchTree($xeTable.getTableData().fullData, (item) => $xeTable.findRowIndexOf(selectRecords, item) > -1, Object.assign({}, treeOpts, { data: "_row" }));
-            } else {
-              handleOptions.data = selectRecords;
-            }
-          } else if (mode === "all") {
-            if ($xeGrid && !handleOptions.remote) {
-              const gridReactData = $xeGrid.reactData;
-              const { computeProxyOpts } = $xeGrid.getComputeMaps();
-              const proxyOpts2 = computeProxyOpts.value;
-              const { sortData } = gridReactData;
-              const { beforeQueryAll, afterQueryAll, ajax = {} } = proxyOpts2;
-              const resConfigs = proxyOpts2.response || proxyOpts2.props || {};
-              const ajaxMethods = ajax.queryAll;
-              const queryAllSuccessMethods = ajax.queryAllSuccess;
-              const queryAllErrorMethods = ajax.queryAllError;
-              if (ajaxMethods) {
-                const params = {
-                  $table: $xeTable,
-                  $grid: $xeGrid,
-                  sort: sortData.length ? sortData[0] : {},
-                  sorts: sortData,
-                  filters: gridReactData.filterData,
-                  form: gridReactData.formData,
-                  options: handleOptions
-                };
-                return Promise.resolve((beforeQueryAll || ajaxMethods)(params)).then((rest) => {
-                  const listProp = resConfigs.list;
-                  handleOptions.data = (listProp ? XEUtils.isFunction(listProp) ? listProp({ data: rest, $grid: $xeGrid }) : XEUtils.get(rest, listProp) : rest) || [];
-                  if (afterQueryAll) {
-                    afterQueryAll(params);
-                  }
-                  if (queryAllSuccessMethods) {
-                    queryAllSuccessMethods(Object.assign(Object.assign({}, params), { response: rest }));
-                  }
-                  return handleExport(handleOptions);
-                }).catch((rest) => {
-                  if (queryAllErrorMethods) {
-                    queryAllErrorMethods(Object.assign(Object.assign({}, params), { response: rest }));
-                  }
-                });
-              }
-            }
-          }
-          if (mode === "current") {
-            handleOptions.data = afterFullData;
-          }
-        }
-        return handleExport(handleOptions);
-      },
-      importByFile(file, options) {
-        const opts = Object.assign({}, options);
-        const { beforeImportMethod } = opts;
-        if (beforeImportMethod) {
-          beforeImportMethod({ options: opts, $table: $xeTable });
-        }
-        return handleFileImport(file, opts);
-      },
-      importData(options) {
-        const importOpts = computeImportOpts.value;
-        const opts = Object.assign({
-          types: XEUtils.keys(importOpts._typeMaps)
-          // beforeImportMethod: null,
-          // afterImportMethod: null
-        }, importOpts, options);
-        const { beforeImportMethod, afterImportMethod } = opts;
-        if (beforeImportMethod) {
-          beforeImportMethod({ options: opts, $table: $xeTable });
-        }
-        return VxeUI.readFile(opts).catch((e) => {
-          if (afterImportMethod) {
-            afterImportMethod({ status: false, options: opts, $table: $xeTable });
-          }
-          return Promise.reject(e);
-        }).then((params) => {
-          const { file } = params;
-          return handleFileImport(file, opts);
-        });
-      },
-      saveFile(options) {
-        return VxeUI.saveFile(options);
-      },
-      readFile(options) {
-        return VxeUI.readFile(options);
-      },
-      print(options) {
-        const printOpts = computePrintOpts.value;
-        const opts = Object.assign({
-          original: false
-          // beforePrintMethod
-        }, printOpts, options, {
-          type: "html",
-          download: false,
-          remote: false,
-          print: true
-        });
-        const { sheetName } = opts;
-        let printTitle = "";
-        if (sheetName) {
-          if (XEUtils.isFunction(sheetName)) {
-            printTitle = sheetName({
-              options: opts,
-              $table: $xeTable,
-              $grid: $xeGrid
-            });
-          } else {
-            printTitle = `${sheetName}`;
-          }
-        }
-        if (!printTitle) {
-          printTitle = document.title || "";
-        }
-        const beforePrintMethod = opts.beforePrintMethod;
-        const tableHtml = opts.html || opts.content;
-        return new Promise((resolve, reject) => {
-          if (VxeUI.print) {
-            if (tableHtml) {
-              resolve(VxeUI.print({
-                title: printTitle,
-                html: tableHtml,
-                customStyle: opts.style,
-                beforeMethod: beforePrintMethod ? ({ html }) => {
-                  return beforePrintMethod({
-                    html,
-                    content: html,
-                    options: opts,
-                    $table: $xeTable
-                  });
-                } : void 0
-              }));
-            } else {
-              resolve(exportMethods.exportData(opts).then(({ content }) => {
-                return VxeUI.print({
-                  title: printTitle,
-                  html: content,
-                  customStyle: opts.style,
-                  beforeMethod: beforePrintMethod ? ({ html }) => {
-                    return beforePrintMethod({
-                      html,
-                      content: html,
-                      options: opts,
-                      $table: $xeTable
-                    });
-                  } : void 0
-                });
-              }));
-            }
-          } else {
-            const e = { status: false };
-            reject(e);
-          }
-        });
-      },
-      getPrintHtml(options) {
-        const printOpts = computePrintOpts.value;
-        const opts = Object.assign({
-          original: false
-          // beforePrintMethod
-        }, printOpts, options, {
-          type: "html",
-          download: false,
-          remote: false,
-          print: true
-        });
-        return $xeTable.exportData(opts).then(({ content }) => {
-          return {
-            html: content
-          };
-        });
-      },
-      closeImport() {
-        if (VxeUI.modal) {
-          return VxeUI.modal.close("VXE_IMPORT_MODAL");
-        }
-        return Promise.resolve();
-      },
-      openImport(options) {
-        const { treeConfig, importConfig } = props;
-        const { initStore, importStore, importParams } = reactData;
-        const importOpts = computeImportOpts.value;
-        const defOpts = Object.assign({
-          mode: "insertTop",
-          message: true,
-          types: XEUtils.keys(importOpts._typeMaps),
-          modes: ["insertTop", "covering"]
-        }, importOpts, options);
-        const types = defOpts.types || [];
-        const modes = defOpts.modes || [];
-        const isTree = !!treeConfig;
-        if (isTree) {
-          if (defOpts.message) {
-            if (VxeUI.modal) {
-              VxeUI.modal.message({ content: getI18n("vxe.error.treeNotImp"), status: "error" });
-            }
-          }
-          return;
-        }
-        if (!importConfig) {
-          errLog("vxe.error.reqProp", ["import-config"]);
-        }
-        const typeList = types.map((value) => {
-          return {
-            value,
-            label: getI18n(`vxe.export.types.${value}`)
-          };
-        });
-        const modeList = modes.map((item) => {
-          if (item && item.value) {
-            return {
-              value: item.value,
-              label: item.label || item.value
-            };
-          }
-          return {
-            value: item,
-            label: getI18n(`vxe.import.modes.${item}`)
-          };
-        });
-        Object.assign(importStore, {
-          file: null,
-          type: "",
-          filename: "",
-          modeList,
-          typeList,
-          visible: true
-        });
-        Object.assign(importParams, defOpts);
-        if (!modeList.some((item) => item.value === importParams.mode)) {
-          importParams.mode = modeList[0].value;
-        }
-        initStore.import = true;
-      },
-      closeExport: handleCloseExport,
-      openExport(options) {
-        const exportOpts = computeExportOpts.value;
-        const defOpts = Object.assign({
-          message: true,
-          types: XEUtils.keys(exportOpts._typeMaps)
-        }, exportOpts, options);
-        if (!props.exportConfig) {
-          errLog("vxe.error.reqProp", ["export-config"]);
-        }
-        handleExportAndPrint(defOpts);
-      },
-      closePrint: handleCloseExport,
-      openPrint(options) {
-        const printOpts = computePrintOpts.value;
-        const defOpts = Object.assign({
-          message: true
-        }, printOpts, options);
-        if (!props.printConfig) {
-          errLog("vxe.error.reqProp", ["print-config"]);
-        }
-        handleExportAndPrint(defOpts, true);
-      }
-    };
-    return exportMethods;
-  },
-  setupGrid($xeGrid) {
-    return $xeGrid.extendTableMethods(tableExportMethodKeys);
-  }
-});