vxe-table-plugin-export-xlsx/dist/index.js

(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define("vxe-table-plugin-export-xlsx", ["exports", "xe-utils", "xlsx"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("xe-utils"), require("xlsx"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.XEUtils, global.XLSX);
    global.VXETablePluginExportXLSX = mod.exports.default;
  }
})(this, function (_exports, _xeUtils, _xlsx) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports["default"] = _exports.VXETablePluginExportXLSX = void 0;
  _xeUtils = _interopRequireDefault(_xeUtils);
  _xlsx = _interopRequireDefault(_xlsx);

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

  function toBuffer(wbout) {
    var buf = new ArrayBuffer(wbout.length);
    var view = new Uint8Array(buf);

    for (var index = 0; index !== wbout.length; ++index) {
      view[index] = wbout.charCodeAt(index) & 0xFF;
    }

    return buf;
  }

  function exportXLSX(params) {
    var $table = params.$table,
        options = params.options,
        columns = params.columns,
        datas = params.datas;
    var sheetName = options.sheetName,
        type = options.type,
        isHeader = options.isHeader,
        isFooter = options.isFooter,
        original = options.original,
        message = options.message,
        footerFilterMethod = options.footerFilterMethod;
    var colHead = {};
    var footList = [];

    if (isHeader) {
      columns.forEach(function (column) {
        colHead[column.id] = _xeUtils["default"].toString(original ? column.property : column.getTitle());
      });
    }

    var rowList = datas.map(function (row, rowIndex) {
      var item = {};
      columns.forEach(function (column, columnIndex) {
        var cellValue;
        var property = column.property;
        var isIndex = column.type === 'index';

        if (!original || isIndex) {
          cellValue = isIndex ? column.indexMethod ? column.indexMethod({
            row: row,
            rowIndex: rowIndex,
            column: column,
            columnIndex: columnIndex
          }) : rowIndex + 1 : row[column.id];
        } else {
          cellValue = _xeUtils["default"].get(row, property);
        }

        item[column.id] = cellValue;
      });
      return item;
    });

    if (isFooter) {
      var footerData = $table.footerData;
      var footers = footerFilterMethod ? footerData.filter(footerFilterMethod) : footerData;
      footers.forEach(function (rows) {
        var item = {};
        columns.forEach(function (column) {
          item[column.id] = rows[$table.getColumnIndex(column)] || '';
        });
        footList.push(item);
      });
    }

    var book = _xlsx["default"].utils.book_new();

    var sheet = _xlsx["default"].utils.json_to_sheet((isHeader ? [colHead] : []).concat(rowList).concat(footList), {
      skipHeader: true
    }); // 转换数据


    _xlsx["default"].utils.book_append_sheet(book, sheet, sheetName);

    var wbout = _xlsx["default"].write(book, {
      bookType: type,
      bookSST: false,
      type: 'binary'
    });

    var blob = new Blob([toBuffer(wbout)], {
      type: 'application/octet-stream'
    }); // 保存导出

    downloadFile(blob, options);

    if (message !== false) {
      $table.$XModal.message({
        message: i18n('vxe.table.expSuccess'),
        status: 'success'
      });
    }
  }

  function downloadFile(blob, options) {
    if (window.Blob) {
      var filename = options.filename,
          type = options.type;

      if (navigator.msSaveBlob) {
        navigator.msSaveBlob(blob, "".concat(filename, ".").concat(type));
      } else {
        var linkElem = document.createElement('a');
        linkElem.target = '_blank';
        linkElem.download = "".concat(filename, ".").concat(type);
        linkElem.href = URL.createObjectURL(blob);
        document.body.appendChild(linkElem);
        linkElem.click();
        document.body.removeChild(linkElem);
      }
    } else {
      console.error(i18n('vxe.error.notExp'));
    }
  }

  function replaceDoubleQuotation(val) {
    return val.replace(/^"/, '').replace(/"$/, '');
  }

  function parseCsv(columns, content) {
    var list = content.split('\n');
    var fields = [];
    var rows = [];

    if (list.length) {
      var rList = list.slice(1);
      list[0].split(',').forEach(function (val) {
        var field = replaceDoubleQuotation(val);

        if (field) {
          fields.push(field);
        }
      });
      rList.forEach(function (r) {
        if (r) {
          var item = {};
          r.split(',').forEach(function (val, colIndex) {
            item[fields[colIndex]] = replaceDoubleQuotation(val);
          });
          rows.push(item);
        }
      });
    }

    return {
      fields: fields,
      rows: rows
    };
  }

  function checkImportData(columns, fields, rows) {
    var tableFields = [];
    columns.forEach(function (column) {
      var field = column.property;

      if (field) {
        tableFields.push(field);
      }
    });
    return tableFields.every(function (field) {
      return fields.includes(field);
    });
  }

  function importXLSX(params) {
    var $table = params.$table,
        columns = params.columns,
        options = params.options,
        file = params.file;
    var _importCallback = $table._importCallback,
        _importResolve = $table._importResolve;
    var fileReader = new FileReader();

    fileReader.onload = function (e) {
      var workbook = _xlsx["default"].read(e.target.result, {
        type: 'binary'
      });

      var csvData = _xlsx["default"].utils.sheet_to_csv(workbook.Sheets.Sheet1);

      var rest = parseCsv(columns, csvData);
      var fields = rest.fields,
          rows = rest.rows;
      var status = checkImportData(columns, fields, rows);

      if (status) {
        $table.createData(rows).then(function (data) {
          if (options.mode === 'append') {
            $table.insertAt(data, -1);
          } else {
            $table.reloadData(data);
          }
        });

        if (options.message !== false) {
          $table.$XModal.message({
            message: i18n('vxe.table.impSuccess'),
            status: 'success'
          });
        }
      } else if (options.message !== false) {
        $table.$XModal.message({
          message: i18n('vxe.error.impFields'),
          status: 'error'
        });
      }

      if (_importResolve) {
        _importResolve(status);

        $table._importResolve = null;
      } else if (_importCallback) {
        // 已废弃
        _importCallback(status);

        $table._importCallback = null;
      }
    };

    fileReader.readAsBinaryString(file);
  }

  function handleImportEvent(params) {
    if (params.options.type === 'xlsx') {
      importXLSX(params);
      return false;
    }
  }

  function handleExportEvent(params) {
    if (params.options.type === 'xlsx') {
      exportXLSX(params);
      return false;
    }
  }
  /**
   * 基于 vxe-table 表格的增强插件，支持导出 xlsx 格式
   */


  var VXETablePluginExportXLSX = {
    install: function install(xtable) {
      Object.assign(xtable.types, {
        xlsx: 1
      });
      xtable.interceptor.mixin({
        'event.import': handleImportEvent,
        'event.export': handleExportEvent
      });
      VXETablePluginExportXLSX.t = xtable.t;
    }
  };
  _exports.VXETablePluginExportXLSX = VXETablePluginExportXLSX;

  function i18n(key) {
    if (VXETablePluginExportXLSX.t) {
      return VXETablePluginExportXLSX.t(key);
    }
  }

  if (typeof window !== 'undefined' && window.VXETable) {
    window.VXETable.use(VXETablePluginExportXLSX);
  }

  var _default = VXETablePluginExportXLSX;
  _exports["default"] = _default;
});