@opentiny/vue-renderless 3.1.0-alpha.0

package/file-upload/index.js

@@ -0,0 +1,1940 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { extend } from '@opentiny/vue-renderless/common/object';
+import { xss, log } from '@opentiny/vue-renderless/common/xss';
+import uploadAjax from '@opentiny/vue-renderless/common/deps/upload-ajax';
+var initTokenPromise = null;
+var shaMap = {
+  sHA256: 'SHA256'
+};
+export var initService = function initService(_ref) {
+  var props = _ref.props,
+    service = _ref.service;
+  var noopFnCreator = function noopFnCreator(propName) {
+    return function () {
+      if (propName) {
+        return Promise.reject(new Error("[TINY Error][FileUpload] Prop ".concat(propName, " is not configured")));
+      } else {
+        return Promise.reject(new Error('[TINY Error][FileUpload] This component depends on @opentiny/vue-service'));
+      }
+    };
+  };
+  var _ref2 = service || {},
+    _ref2$network = _ref2.network,
+    network = _ref2$network === void 0 ? {} : _ref2$network,
+    _ref2$common = _ref2.common,
+    common = _ref2$common === void 0 ? {} : _ref2$common;
+  var request = network.request,
+    get = network.get,
+    post = network.post,
+    all = network.all,
+    spread = network.spread,
+    _network$CancelToken = network.CancelToken,
+    CancelToken = _network$CancelToken === void 0 ? {} : _network$CancelToken;
+  var noopFn = noopFnCreator();
+  var httpRequestFn = noopFnCreator('httpRequest');
+  return {
+    get: get || noopFn,
+    post: post || noopFn,
+    request: request || noopFn,
+    all: all || noopFn,
+    spread: spread || noopFn,
+    cancelToken: CancelToken.source || noopFn,
+    getSingleUploadUrl: common.getSingleUploadUrl || noopFn,
+    getFileUploadUrl: common.getFileUploadUrl || noopFn,
+    getFileDownloadUrl: common.getFileDownloadUrl || noopFn,
+    getSingleDownloadUrl: common.getSingleDownloadUrl || noopFn,
+    getPackageDownloadUrl: common.getPackageDownloadUrl || noopFn,
+    getLargeFileInitUrl: common.getLargeFileInitUrl || noopFn,
+    getChunkUploadUrl: common.getChunkUploadUrl || noopFn,
+    getPreviewUrl: common.getPreviewUrl || noopFn,
+    getDocumentInfoUrl: common.getDocumentInfoUrl || noopFn,
+    httpRequest: props.httpRequest || request || uploadAjax
+  };
+};
+export var computedUploadDisabled = function computedUploadDisabled(_ref3) {
+  var props = _ref3.props,
+    state = _ref3.state;
+  return function () {
+    return props.disabled || (state.elForm || {}).disabled;
+  };
+};
+export var computedUploadingSize = function computedUploadingSize(state) {
+  return function () {
+    return state.uploadingFiles.reduce(function (total, file) {
+      return total + file.size;
+    }, 0);
+  };
+};
+export var watchListType = function watchListType(_ref4) {
+  var constants = _ref4.constants,
+    state = _ref4.state;
+  return function (type) {
+    if (type === constants.LIST_TYPE.PICTURE_CARD || type === constants.LIST_TYPE.PICTURE) {
+      state.uploadFiles = state.uploadFiles.map(function (file) {
+        if (!file.url && file.raw) {
+          try {
+            file.url = URL.createObjectURL(file.raw);
+          } catch (err) {}
+        }
+        return file;
+      });
+    }
+  };
+};
+export var watchFileList = function watchFileList(_ref5) {
+  var constants = _ref5.constants,
+    state = _ref5.state;
+  return function (fileList) {
+    state.uploadFiles = fileList && fileList.map(function (item) {
+      item.uid = item.uid || Date.now() + state.tempIndex++;
+      item.status = item.status || constants.FILE_STATUS.SUCESS;
+      return item;
+    });
+  };
+};
+var isNonFuncPropBeforeUpload = function isNonFuncPropBeforeUpload(_ref6) {
+  var flag = _ref6.flag,
+    doUpload = _ref6.doUpload,
+    file = _ref6.file;
+  return !flag && doUpload(file);
+};
+var onBeforeIsPromise = function onBeforeIsPromise(_ref7) {
+  var before = _ref7.before,
+    rawFile = _ref7.rawFile,
+    file = _ref7.file,
+    doUpload = _ref7.doUpload,
+    autoRemove = _ref7.autoRemove,
+    api = _ref7.api;
+  before.then(function (processedFile) {
+    var fileType = Object.prototype.toString.call(processedFile);
+    if (fileType === '[object File]' || fileType === '[object Blob]') {
+      if (fileType === '[object Blob]') {
+        processedFile = new File([processedFile], rawFile.name, {
+          type: rawFile.type
+        });
+      }
+      for (var p in rawFile) {
+        if (Object.prototype.hasOwnProperty.call(rawFile, p)) {
+          processedFile[p] = rawFile[p];
+        }
+      }
+      file.raw = processedFile;
+    }
+    doUpload(file);
+  }, function () {
+    if (autoRemove) {
+      if (!Array.isArray(rawFile)) {
+        api.handleRemove(null, rawFile);
+      } else {
+        rawFile.forEach(function (raw) {
+          return api.handleRemove(null, raw);
+        });
+      }
+    }
+  });
+};
+export var beforeUpload = function beforeUpload(_ref8) {
+  var props = _ref8.props,
+    api = _ref8.api,
+    Modal = _ref8.Modal,
+    constants = _ref8.constants,
+    t = _ref8.t,
+    state = _ref8.state;
+  return function (file, autoRemove, doUpload) {
+    if (state.isEdm && file.name.length > 255) {
+      if (autoRemove) {
+        var rawFile = file.raw;
+        if (Array.isArray(rawFile)) {
+          rawFile.forEach(function (raw) {
+            return api.handleRemove(null, raw);
+          });
+        } else {
+          api.handleRemove(null, rawFile);
+        }
+      }
+      return Modal.message({
+        message: "".concat(t(constants.EDM.THEFILENAME), "\"").concat(file.name, "\"").concat(t(constants.EDM.FILENAMEEXCEEDS)),
+        status: 'warning'
+      });
+    }
+    var flag = typeof props.beforeUpload === 'function';
+    isNonFuncPropBeforeUpload({
+      flag: flag,
+      doUpload: doUpload,
+      file: file
+    });
+    if (flag) {
+      var _ref9 = {},
+        _ref9$rawFile = _ref9.rawFile,
+        _rawFile = _ref9$rawFile === void 0 ? file.raw : _ref9$rawFile,
+        _ref9$before = _ref9.before,
+        before = _ref9$before === void 0 ? props.beforeUpload(_rawFile) : _ref9$before;
+      if (before && before.then) {
+        onBeforeIsPromise({
+          before: before,
+          rawFile: _rawFile,
+          file: file,
+          doUpload: doUpload,
+          autoRemove: autoRemove,
+          api: api
+        });
+      } else if (before !== false) {
+        doUpload(file);
+      } else {
+        if (autoRemove) {
+          if (Array.isArray(_rawFile)) {
+            _rawFile.forEach(function (raw) {
+              return api.handleRemove(null, raw);
+            });
+          } else {
+            api.handleRemove(null, _rawFile);
+          }
+        }
+      }
+    }
+  };
+};
+export var startUpload = function startUpload(_ref10) {
+  var state = _ref10.state,
+    constants = _ref10.constants,
+    refs = _ref10.refs,
+    Modal = _ref10.Modal,
+    api = _ref10.api,
+    t = _ref10.t;
+  return function (file, isList) {
+    if (file.size > state.docSize && file.size > state.chunkSize) {
+      file.isLargeFile = true;
+      isList && state.uploadFiles.forEach(function (f) {
+        if (f.cacheSign === file.cacheSign) {
+          f.percentage = 0;
+        }
+      });
+      api.largeDocumentUpload(file);
+      Modal.message({
+        message: "".concat(file.name).concat(t(constants.EDM.LARGEFILEKEY)),
+        status: 'warning'
+      });
+    } else {
+      refs[constants.UPLOAD_INNER].upload(file.raw);
+    }
+  };
+};
+var calcFileForMobile = function calcFileForMobile(rawFile, file) {
+  var fileName = rawFile.name.lastIndexOf('.');
+  var fileNameLen = rawFile.name.length;
+  file.fileType = rawFile.name.substring(fileName + 1, fileNameLen);
+  var size = rawFile.size / 1024;
+  if (size < 1024) {
+    file.size = Math.round(size * Math.pow(10, 1)) / Math.pow(10, 1) + 'KB';
+  } else {
+    var fileSize = size / 1024;
+    file.size = Math.round(fileSize * Math.pow(10, 1)) / Math.pow(10, 1) + 'MB';
+  }
+};
+export var properFileSize = function properFileSize(_ref11) {
+  var props = _ref11.props,
+    state = _ref11.state,
+    constants = _ref11.constants,
+    Modal = _ref11.Modal,
+    t = _ref11.t;
+  return function (file) {
+    var maxSize = 0;
+    if (Array.isArray(props.fileSize) && props.fileSize[1]) {
+      maxSize = Math.min(state.singleMaxSize, props.fileSize[1] / 1024).toFixed(2);
+    } else {
+      maxSize = Math.min(state.singleMaxSize);
+    }
+    if (file.size > maxSize * 1024 * 1024) {
+      Modal.message({
+        message: "".concat(file.name, " ").concat(t(constants.EDM.EXCEED), " ").concat(maxSize, " MB"),
+        status: 'warning'
+      });
+      return false;
+    }
+    if (file.size <= 0) {
+      Modal.message({
+        message: "".concat(file.name, " ").concat(t(constants.EDM.FILEEMPTY)),
+        status: 'warning'
+      });
+      return false;
+    }
+    var userMin = props.fileSize && (props.fileSize[0] || props.fileSize) || 0;
+    if (file.size <= userMin * 1024) {
+      Modal.message({
+        message: "".concat(t(constants.EDM.SIZE).replace(/{name}/, file.name), " ").concat(userMin, " KB"),
+        status: 'waring'
+      });
+      return false;
+    }
+    return true;
+  };
+};
+export var addFileToList = function addFileToList(_ref12) {
+  var api = _ref12.api,
+    constants = _ref12.constants,
+    emit = _ref12.emit,
+    props = _ref12.props,
+    state = _ref12.state,
+    mode = _ref12.mode;
+  return function (rawFile, updateId) {
+    rawFile.uid = Date.now() + state.tempIndex++;
+    var file = {
+      status: constants.FILE_STATUS.READY,
+      name: rawFile.name,
+      size: rawFile.size
+    };
+    Object.assign(file, {
+      percentage: 0,
+      uid: rawFile.uid,
+      raw: rawFile,
+      response: {}
+    });
+    if (state.isEdm) {
+      var fileBase = {
+        serverName: '',
+        docRelativePath: '',
+        docId: '',
+        docVersion: '',
+        cacheSign: rawFile.uid
+      };
+      file = Object.assign(file, fileBase);
+      props.edm.upload.isFolder && (file.path = rawFile.webkitRelativePath.match(/.*\//g)[0]);
+    }
+    state.cacheDocuments[file.uid] = file;
+    mode === 'mobile' && calcFileForMobile(rawFile, file);
+    if (~[constants.LIST_TYPE.PICTURE_CARD, constants.LIST_TYPE.PICTURE].indexOf(props.listType)) {
+      try {
+        file.url = URL.createObjectURL(rawFile);
+      } catch (err) {
+        return;
+      }
+    }
+    if (state.isEdm && state.isSuccess) {
+      var proper = api.properFileSize(file);
+      if (!proper) {
+        return;
+      }
+      state.updateId = updateId || props.edm.updateId || '';
+      if (state.updateId) {
+        var index = state.uploadFiles.findIndex(function (item) {
+          return item.docId === updateId;
+        });
+        state.uploadFiles.splice(index, 1, file);
+        emit('change', file, state.uploadFiles);
+        return;
+      }
+    }
+    state.uploadFiles.push(file);
+    state.currentUploadingFileUids.push(file.uid);
+    emit('change', file, state.uploadFiles);
+  };
+};
+export var handleStart = function handleStart(_ref13) {
+  var api = _ref13.api,
+    constants = _ref13.constants,
+    props = _ref13.props,
+    state = _ref13.state,
+    refs = _ref13.refs;
+  return function (rawFiles, updateId) {
+    state.currentUploadingFileUids = [];
+    rawFiles.forEach(function (rawFile) {
+      return api.addFileToList(rawFile, updateId);
+    });
+    var _constants$FILE_STATU = constants.FILE_STATUS,
+      UPLOADING = _constants$FILE_STATU.UPLOADING,
+      READY = _constants$FILE_STATU.READY;
+    state.uploadingFiles = state.uploadFiles.filter(function (file) {
+      return [UPLOADING, READY].indexOf(file.status) > -1;
+    });
+    if (state.isEdm && state.isSuccess) {
+      rawFiles.forEach(function (rawFile) {
+        var file = api.getFile(rawFile);
+        if (!file) return;
+        api.beforeUpload(file, true, function (file) {
+          typeof props.edm.upload.loading === 'function' && props.edm.upload.loading(file);
+          new Promise(function (resolve) {
+            if (props.edm.isCheckCode !== true) return resolve();
+            if (file.size > state.docSize && file.size > state.chunkSize && !state.isEntireCheckCode) return resolve();
+            var reader = new FileReader();
+            reader.readAsArrayBuffer(file.raw);
+            reader.onload = function (e) {
+              var cryptoJS = props.edm.upload.plugin();
+              var wordArray = cryptoJS.lib.WordArray.create(e.target.result);
+              var hash = cryptoJS[shaMap.shaMap](wordArray).toString();
+              file.hash = file.raw.hash = hash;
+              resolve(hash);
+            };
+          }).then(function () {
+            if (props.autoUpload) {
+              var tokenParams = {
+                token: props.edm.upload.token,
+                file: file,
+                type: 'upload'
+              };
+              api.getToken(tokenParams).then(function (data) {
+                if (data) {
+                  file.status = constants.FILE_STATUS.UPLOADING;
+                  api.startUpload(file, true);
+                }
+              });
+            }
+          });
+        });
+      });
+    }
+    if (!state.isEdm && props.autoUpload) {
+      if (props.multiple && props.mergeService) {
+        var handler = function handler(file) {
+          return refs[constants.UPLOAD_INNER].upload(file.raw);
+        };
+        rawFiles.length && api.beforeUpload({
+          raw: rawFiles
+        }, true, handler);
+      } else {
+        rawFiles.forEach(function (rawFile) {
+          var file = api.getFile(rawFile);
+          var handler = function handler(file) {
+            return refs[constants.UPLOAD_INNER].upload(file.raw);
+          };
+          api.beforeUpload(file, true, handler);
+        });
+      }
+    }
+  };
+};
+export var calcUploadingFilesInfo = function calcUploadingFilesInfo(_ref14) {
+  var state = _ref14.state;
+  return function () {
+    var totalLoadedSize = state.uploadingFiles.reduce(function (loadedSize, file) {
+      var loaded = file.size * file.percentage / 100;
+      return loadedSize + loaded;
+    }, 0);
+    var uploadedFiles = state.uploadingFiles.filter(function (file) {
+      return file.percentage === 100;
+    });
+    var percentage = Math.floor(totalLoadedSize / state.uploadingSize * 100);
+    percentage = Math.min(percentage, 100);
+    return {
+      percentage: percentage,
+      uploadList: state.uploadingFiles,
+      uploadedCount: uploadedFiles.length
+    };
+  };
+};
+export var handleProgress = function handleProgress(_ref15) {
+  var api = _ref15.api,
+    constants = _ref15.constants,
+    emit = _ref15.emit,
+    state = _ref15.state;
+  return function (event, rawFile) {
+    if (Array.isArray(rawFile)) {
+      state.uploadFiles.forEach(function (file) {
+        if (rawFile.some(function (raw) {
+          return file.uid === raw.uid;
+        })) {
+          file.status = constants.FILE_STATUS.UPLOADING;
+          if (event.lengthComputable) {
+            file.percentage = Math.floor(event.loaded * 100 / event.total) || 0;
+          }
+          emit('progress', file, state.uploadFiles, api.calcUploadingFilesInfo());
+        }
+      });
+    } else {
+      var file = api.getFile(rawFile);
+      if (file) {
+        file.status = constants.FILE_STATUS.UPLOADING;
+        if (event.lengthComputable && !file.isLargeFile) {
+          file.percentage = Math.floor(event.loaded * 100 / event.total) || 0;
+          if (file.percentage >= 100) {
+            file.isFinished = true;
+          }
+          emit('progress', file, state.uploadFiles, api.calcUploadingFilesInfo());
+        }
+      }
+    }
+  };
+};
+export var handleSuccess = function handleSuccess(_ref16) {
+  var api = _ref16.api,
+    constants = _ref16.constants,
+    emit = _ref16.emit,
+    state = _ref16.state,
+    props = _ref16.props;
+  return function (res, rawFile) {
+    var currentUploadFiles = state.uploadFiles.filter(function (file) {
+      return state.currentUploadingFileUids.includes(file.uid);
+    });
+    if (Array.isArray(rawFile)) {
+      state.uploadFiles.forEach(function (file) {
+        if (rawFile.some(function (raw) {
+          return file.uid === raw.uid;
+        })) {
+          file.status = constants.FILE_STATUS.SUCESS;
+          file.percentage = 100;
+          file.response = res;
+          emit('success', res, file, currentUploadFiles);
+          emit('change', file, state.uploadFiles);
+          delete file.cancelToken;
+        }
+      });
+    } else {
+      var file = api.getFile(rawFile);
+      delete file.cancelToken;
+      if (props.edm.upload && file && res.data && res.data.status !== 200) {
+        file.status = constants.FILE_STATUS.FAIL;
+        emit('error', res, file, state.uploadFiles);
+        return;
+      }
+      if (file) {
+        file.status = constants.FILE_STATUS.SUCESS;
+        file.percentage = 100;
+        if (!file.isFinished) {
+          emit('progress', file, state.uploadFiles, api.calcUploadingFilesInfo());
+        }
+        file.isLargeFile && delete res.config;
+        file.response = res;
+        if (state.isEdm && res.data.result) {
+          file.serverName = res.data.result.serverName;
+          file.docRelativePath = res.data.result.docRelativePath;
+          file.docId = res.data.result.docId;
+          file.docVersion = res.data.result.version;
+          file.docSize = res.data.result.docSize;
+          file.isLargeFile && delete file.raw;
+          Object.assign(file, res.data.result);
+        }
+        emit('success', res, file, currentUploadFiles);
+        emit('change', file, state.uploadFiles);
+      }
+    }
+    api.clearUploadingFiles();
+  };
+};
+export var handleError = function handleError(_ref17) {
+  var api = _ref17.api,
+    constants = _ref17.constants,
+    emit = _ref17.emit,
+    state = _ref17.state;
+  return function (err, rawFile) {
+    var file = api.getFile(rawFile);
+    if (file) {
+      file.status = constants.FILE_STATUS.FAIL;
+      file.percentage = 100;
+      if (!state.isEdm) {
+        state.uploadFiles.splice(state.uploadFiles.indexOf(file), 1);
+      }
+      api.clearUploadingFiles();
+      emit('error', err, file, state.uploadFiles);
+      emit('change', file, state.uploadFiles);
+    }
+  };
+};
+export var handleRemove = function handleRemove(_ref18) {
+  var api = _ref18.api,
+    emit = _ref18.emit,
+    props = _ref18.props,
+    state = _ref18.state;
+  return function (file, raw) {
+    if (raw) {
+      file = api.getFile(raw);
+    }
+    var doRemove = function doRemove() {
+      api.abort(file);
+      var fileList = state.uploadFiles;
+      fileList.splice(fileList.indexOf(file), 1);
+      emit('remove', file, fileList);
+    };
+    if (!props.beforeRemove) {
+      doRemove();
+    } else if (typeof props.beforeRemove === 'function') {
+      var before = props.beforeRemove(file, state.uploadFiles);
+      if (before && before.then) {
+        before.then(function () {
+          doRemove();
+        }, function () {
+          return undefined;
+        });
+      } else if (before !== false) {
+        doRemove();
+      }
+    }
+  };
+};
+export var clearUploadingFiles = function clearUploadingFiles(_ref19) {
+  var constants = _ref19.constants,
+    state = _ref19.state;
+  return function () {
+    var _constants$FILE_STATU2 = constants.FILE_STATUS,
+      SUCESS = _constants$FILE_STATU2.SUCESS,
+      FAIL = _constants$FILE_STATU2.FAIL;
+    var isUploadComplete = state.uploadingFiles.every(function (file) {
+      return [SUCESS, FAIL].indexOf(file.status) > -1;
+    });
+    if (isUploadComplete) {
+      state.uploadingFiles = [];
+    }
+  };
+};
+export var getFile = function getFile(state) {
+  return function (rawFile) {
+    var fileList = state.uploadFiles;
+    var target;
+    fileList.every(function (item) {
+      target = rawFile.uid === item.uid ? item : null;
+      return !target;
+    });
+    return target;
+  };
+};
+export var abort = function abort(_ref20) {
+  var constants = _ref20.constants,
+    refs = _ref20.refs;
+  return function (file) {
+    return refs[constants.UPLOAD_INNER].abort(file);
+  };
+};
+export var clearFiles = function clearFiles(state) {
+  return function () {
+    state.uploadFiles = [];
+  };
+};
+export var submit = function submit(_ref21) {
+  var api = _ref21.api,
+    constants = _ref21.constants,
+    refs = _ref21.refs,
+    state = _ref21.state,
+    props = _ref21.props;
+  return function () {
+    var files = state.uploadFiles.filter(function (file) {
+      return file.status === constants.FILE_STATUS.READY;
+    });
+    if (state.isEdm && state.isSuccess) {
+      files.forEach(function (file) {
+        api.getToken({
+          token: props.edm.upload.token,
+          file: file,
+          type: 'upload'
+        }).then(function (data) {
+          if (data) {
+            api.beforeUpload(file, false, function (file) {
+              api.startUpload(file);
+            });
+          }
+        });
+      });
+    } else {
+      if (props.multiple && props.mergeService) {
+        var rawFiles = files.map(function (file) {
+          return file.raw;
+        });
+        rawFiles.length && api.beforeUpload({
+          raw: rawFiles
+        }, false, function (file) {
+          refs[constants.UPLOAD_INNER].upload(file.raw);
+        });
+      } else {
+        files.forEach(function (file) {
+          api.beforeUpload(file, false, function (file) {
+            refs[constants.UPLOAD_INNER].upload(file.raw);
+          });
+        });
+      }
+    }
+  };
+};
+export var handleClick = function handleClick(_ref22) {
+  var constants = _ref22.constants,
+    refs = _ref22.refs;
+  return function () {
+    return refs[constants.UPLOAD_INNER].handleClick();
+  };
+};
+export var getFileUploadUrl = function getFileUploadUrl(service) {
+  return function () {
+    return service.getFileUploadUrl();
+  };
+};
+export var updateUrl = function updateUrl(_ref23) {
+  var api = _ref23.api,
+    props = _ref23.props,
+    state = _ref23.state;
+  return function () {
+    if (props.action) {
+      state.url = props.action;
+    } else {
+      api.getFileUploadUrl().then(function (url) {
+        return state.url = url;
+      });
+    }
+  };
+};
+var getTranslateFile = function getTranslateFile(_ref24) {
+  var api = _ref24.api,
+    isChunk = _ref24.isChunk;
+  return function (data, type, index) {
+    if (isChunk) {
+      if (index === 0) {
+        api.setWriterFile({
+          data: data,
+          index: index
+        });
+      }
+    } else {
+      var content = data.headers['content-disposition'];
+      var name = content.match(/fileName.?=(.*)/)[1] || content.match(/fileName=(.*)/)[1];
+      var blob = new Blob([data.data], {
+        type: type !== 'zip' ? 'application / x - xls' : 'application/zip'
+      });
+      if (window && window.navigator.msSaveOrOpenBlob) {
+        window.navigator.msSaveOrOpenBlob(blob, decodeURIComponent(name));
+        return;
+      }
+      var url = window.URL || window.webkitURL || window.moxURL;
+      var downloadHref = xss.filterUrl(url.createObjectURL(blob));
+      var downloadLink = document.createElement('a');
+      downloadLink.href = downloadHref;
+      downloadLink.download = decodeURIComponent(name);
+      downloadLink.click();
+    }
+  };
+};
+var getHandleSuccess = function getHandleSuccess(_ref25) {
+  var downloadOps = _ref25.downloadOps,
+    file = _ref25.file,
+    translateFile = _ref25.translateFile,
+    isChunk = _ref25.isChunk,
+    state = _ref25.state;
+  return function (data, type, index) {
+    if (isChunk) {
+      state.dowuloadChunkFile.set(index, new Uint8Array(data.data));
+      translateFile(data, type, index);
+    } else {
+      if (data.data.type.indexOf('application/json') > -1) {
+        var reader = new FileReader();
+        reader.onload = function (e) {
+          if (typeof downloadOps.fail === 'function') {
+            downloadOps.fail(JSON.parse(e.target.result), file);
+          }
+        };
+        reader.readAsText(data.data);
+      } else {
+        typeof downloadOps.loading === 'function' && downloadOps.loading(file);
+        translateFile(data, type);
+      }
+    }
+  };
+};
+var getCalcProgress = function getCalcProgress() {
+  return function (evt) {
+    var total = Number(evt.target.getResponseHeader('Content-Size'));
+    total = Math.max(total, evt.loaded);
+    var progress = Math.ceil(evt.loaded / total * 100) || 0;
+    progress = Math.max(progress, 0);
+    progress = Math.min(progress, 100);
+    return progress;
+  };
+};
+var modifyServiceUrlSingle = function modifyServiceUrlSingle(_ref26) {
+  var file = _ref26.file,
+    serviceUrl = _ref26.serviceUrl,
+    range = _ref26.range,
+    constants = _ref26.constants;
+  if (_typeof(file) === 'object') {
+    var tempFile = _objectSpread(_objectSpread({}, file), range);
+    delete tempFile.docId;
+    delete tempFile.docVersion;
+    delete tempFile['x-download-sign'];
+    for (var key in tempFile) {
+      if (Object.prototype.hasOwnProperty.call(tempFile, key)) {
+        var value = tempFile[key];
+        var dataType = _typeof(value);
+        if (!~['undefined', 'object', 'function'].indexOf(dataType)) {
+          serviceUrl += "&".concat(key, "=").concat(value);
+        }
+      }
+    }
+    file.status = constants.FILE_STATUS.DOWNLOADING;
+    file.percentage = 0;
+  }
+  return serviceUrl;
+};
+var getKiaScanTip = function getKiaScanTip(_ref27) {
+  var data = _ref27.data,
+    t = _ref27.t,
+    Modal = _ref27.Modal,
+    constants = _ref27.constants;
+  if (data.status === '12079') {
+    return Modal.message({
+      message: "".concat(t(constants.EDM.KIASCANTIP)),
+      status: 'waring'
+    });
+  }
+};
+var downloadFileSingle = function downloadFileSingle(args) {
+  var file = args.file,
+    service = args.service,
+    constants = args.constants,
+    props = args.props,
+    state = args.state,
+    batchIndex = args.batchIndex,
+    isChunk = args.isChunk,
+    api = args.api;
+  var calcProgress = args.calcProgress,
+    emit = args.emit,
+    handleSuccess = args.handleSuccess,
+    t = args.t,
+    Modal = args.Modal,
+    _args$range = args.range,
+    range = _args$range === void 0 ? {} : _args$range,
+    isBatch = args.isBatch;
+  var getServiceUrl = function getServiceUrl(_ref28) {
+    var url = _ref28.url,
+      file = _ref28.file;
+    return url.replace(/{docId}/, file.docId || file) + "".concat(~url.indexOf('?') ? '&' : '?', "x-download-sign=true&docVersion=").concat(file.docVersion || '');
+  };
+  var sdResolver = function sdResolver(url) {
+    var serviceUrl = getServiceUrl({
+      url: url,
+      file: file
+    });
+    serviceUrl = modifyServiceUrlSingle({
+      file: file,
+      serviceUrl: serviceUrl,
+      range: range,
+      constants: constants
+    });
+    serviceUrl = xss.filterUrl(serviceUrl);
+    var params = {
+      withCredentials: props.withCredentials,
+      headers: Object.assign(props.headers, state.headers),
+      responseType: isChunk ? 'arraybuffer' : 'blob',
+      hideErr: true,
+      onDownloadProgress: function onDownloadProgress(evt) {
+        var progress = calcProgress(evt, isChunk);
+        if (progress !== 100) {
+          !isChunk && emit('download', progress, evt);
+        }
+        if (_typeof(file) === 'object') {
+          file.percentage = progress;
+        }
+      }
+    };
+    service.get(serviceUrl, params).then(function (data) {
+      if (getKiaScanTip({
+        data: data,
+        t: t,
+        Modal: Modal,
+        constants: constants
+      })) return;
+      var _data$headers = data.headers,
+        checkcode = _data$headers.checkcode,
+        fileSize = _data$headers['content-size'];
+      !isChunk && emit('download', 100, {
+        checkcode: checkcode,
+        fileSize: fileSize
+      });
+      handleSuccess(data, '', range.index);
+      if (_typeof(file) === 'object') {
+        file.percentage = 100;
+        setTimeout(function () {
+          return file.status = constants.FILE_STATUS.SUCESS;
+        }, 1000);
+      }
+      api.afterDownload({
+        batchIndex: batchIndex,
+        data: data,
+        file: file
+      });
+    })["catch"](function (data) {
+      if (data.response && data.response.status === 401) {
+        var downloadOps = props.edm.download || {};
+        var tokenParams = {
+          token: downloadOps.token,
+          file: file,
+          type: 'download'
+        };
+        api.getToken(tokenParams).then(function (data) {
+          api.afterDownload({
+            batchIndex: batchIndex,
+            data: data,
+            file: file,
+            range: range,
+            isChunk: isChunk,
+            isBatch: isBatch
+          });
+        });
+      }
+    });
+  };
+  service.getSingleDownloadUrl().then(sdResolver);
+};
+var downloadFileBatch = function downloadFileBatch(args) {
+  var api = args.api,
+    downloadOps = args.downloadOps,
+    file = args.file,
+    service = args.service,
+    props = args.props,
+    state = args.state,
+    calcProgress = args.calcProgress,
+    emit = args.emit,
+    handleSuccess = args.handleSuccess;
+  var t = args.t,
+    Modal = args.Modal,
+    constants = args.constants,
+    _args$range2 = args.range,
+    range = _args$range2 === void 0 ? {} : _args$range2;
+  var tokenParams = {
+    token: downloadOps.packageToken,
+    file: file,
+    type: 'download'
+  };
+  api.getToken(tokenParams).then(function (data) {
+    if (!data) {
+      return;
+    }
+    var params = {
+      downloadTOs: [],
+      attachdownloadTOs: [],
+      isZip: 'true',
+      transformType: 'sync',
+      type: 'package'
+    };
+    var hasWmType = file.some(function (item) {
+      return Boolean(item.wmType);
+    });
+    if (hasWmType) {
+      params.attachdownloadTOs = file;
+    } else {
+      params.downloadTOs = file;
+    }
+    service.getPackageDownloadUrl().then(function (url) {
+      url += "".concat(~url.indexOf('?') ? '&' : '?', "x-download-sign=true");
+      url = xss.filterUrl(url);
+      service.post(url, _objectSpread(_objectSpread({}, params), range), {
+        withCredentials: props.withCredentials,
+        headers: Object.assign(props.headers, state.headers),
+        responseType: 'blob',
+        onDownloadProgress: function onDownloadProgress(evt) {
+          var progress = calcProgress(evt);
+          if (progress !== 100) {
+            emit('download', progress, evt);
+          }
+        }
+      }).then(function (data) {
+        if (getKiaScanTip({
+          data: data,
+          t: t,
+          Modal: Modal,
+          constants: constants
+        })) return;
+        var fileSize = data.headers['content-size'];
+        emit('download', 100, {
+          fileSize: fileSize
+        });
+        handleSuccess(data, 'zip');
+      });
+    });
+  });
+};
+export var downloadFile = function downloadFile(_ref29) {
+  var api = _ref29.api,
+    state = _ref29.state,
+    props = _ref29.props;
+  return function (file) {
+    if (!state.isEdm) {
+      api.ordinaryDownload(file);
+      return;
+    }
+    var isBatch = Array.isArray(file);
+    if (isBatch) {
+      return api.downloadFileInner({
+        file: file,
+        isBatch: isBatch
+      });
+    }
+    var downloadOps = props.edm.download || {};
+    var tokenParams = {
+      token: downloadOps.token,
+      file: file,
+      type: 'download'
+    };
+    api.getToken(tokenParams).then(function (data) {
+      if (!data) return;
+      api.getDownloadFileInfo({
+        docId: file.docId
+      }).then(function (res) {
+        var fileInfo;
+        if (res && res.outDocQueryList[0].verInfo[0]) {
+          fileInfo = res.outDocQueryList[0].verInfo[0].docInfo[0];
+        }
+        var _fileInfo = fileInfo,
+          fileSize = _fileInfo.fileSize;
+        var isLargeFile = fileSize > state.docSize && fileSize > state.chunkSize && fileSize > 10 * 1024 * 1024 * 1024;
+        if (isLargeFile) {
+          api.largeDocumentDownload({
+            file: fileInfo,
+            isBatch: isBatch
+          });
+        } else {
+          api.downloadFileInner({
+            file: file,
+            isBatch: isBatch
+          });
+        }
+      });
+    });
+  };
+};
+export var getDownloadFileInfo = function getDownloadFileInfo(_ref30) {
+  var state = _ref30.state,
+    props = _ref30.props,
+    service = _ref30.service;
+  return function (_ref31) {
+    var docId = _ref31.docId;
+    return service.getDocumentInfoUrl().then(function (url) {
+      return new Promise(function (resolve, reject) {
+        service.request({
+          method: 'post',
+          url: xss.filterUrl(url),
+          withCredentials: props.withCredentials,
+          headers: Object.assign(props.headers, state.headers),
+          data: {
+            docInfoVO: {
+              ids: [docId],
+              docType: '',
+              docVersion: ''
+            }
+          }
+        }).then(function (res) {
+          if (res.data.status === 200) {
+            resolve(res.data.result);
+          } else {
+            reject(res);
+          }
+        });
+      });
+    });
+  };
+};
+export var largeDocumentDownload = function largeDocumentDownload(_ref32) {
+  var api = _ref32.api,
+    state = _ref32.state;
+  return function (_ref33) {
+    var file = _ref33.file,
+      isBatch = _ref33.isBatch;
+    var chunkSize = Math.ceil(file.fileSize / state.chunkSize);
+    state.dowuloadChunkFile.set('chunkSize', chunkSize);
+    state.dowuloadChunkFile.set('fileSize', file.fileSize);
+    state.dowuloadChunkFile.set('docName', file.docName);
+    file.chunkSize = chunkSize;
+    var batches = api.sliceDownloadChunk(file);
+    api.batchSegmentDownload({
+      batchIndex: 0,
+      batches: batches,
+      docId: file.docId,
+      isBatch: isBatch
+    });
+  };
+};
+export var sliceDownloadChunk = function sliceDownloadChunk(_ref34) {
+  var state = _ref34.state;
+  return function (file) {
+    var chunkSize = file.chunkSize;
+    var downloadChunkArray = [[]];
+    state.downloadBatchQueue[file.docId + '-0'] = 0;
+    state.downloadBatchQueueListen[file.docId + '-0'] = 0;
+    for (var i = 0; i < chunkSize; i++) {
+      var startRange = i * state.chunkSize;
+      var endRange = Math.min(file.fileSize, startRange + state.chunkSize);
+      var lastIndex = downloadChunkArray.length - 1;
+      if (downloadChunkArray[lastIndex].length < state.downloadChunkLimit) {
+        downloadChunkArray[lastIndex].push({
+          startRange: startRange,
+          endRange: endRange,
+          index: i
+        });
+      } else {
+        state.downloadBatchQueue[file.docId + '-' + downloadChunkArray.length] = 0;
+        state.downloadBatchQueueListen[file.docId + '-' + downloadChunkArray.length] = 0;
+        downloadChunkArray.push([]);
+        downloadChunkArray[lastIndex + 1].push({
+          startRange: startRange,
+          endRange: endRange,
+          index: i
+        });
+      }
+    }
+    return downloadChunkArray;
+  };
+};
+export var batchSegmentDownload = function batchSegmentDownload(_ref35) {
+  var state = _ref35.state,
+    api = _ref35.api;
+  return function (_ref36) {
+    var batchIndex = _ref36.batchIndex,
+      batches = _ref36.batches,
+      docId = _ref36.docId,
+      isBatch = _ref36.isBatch;
+    if (batchIndex < batches.length) {
+      var batch = batches[batchIndex];
+      var key = docId + '-' + batchIndex;
+      Object.defineProperty(state.downloadBatchQueue, key, {
+        get: function get() {
+          return state.downloadBatchQueueListen[key];
+        },
+        set: function set(value) {
+          state.downloadBatchQueueListen[key] = value;
+          if (value >= batch.length) {
+            api.batchSegmentDownload({
+              docId: docId,
+              batchIndex: ++batchIndex,
+              batches: batches,
+              isBatch: isBatch
+            });
+          }
+        }
+      });
+      var index = 0;
+      while (batch.length - index > 0) {
+        api.downloadFileInner({
+          batchIndex: batchIndex,
+          range: batch[index++],
+          file: {
+            docId: docId
+          },
+          isBatch: isBatch,
+          isChunk: true
+        });
+      }
+    }
+  };
+};
+export var downloadFileInner = function downloadFileInner(_ref37) {
+  var api = _ref37.api,
+    props = _ref37.props,
+    service = _ref37.service,
+    state = _ref37.state,
+    emit = _ref37.emit,
+    constants = _ref37.constants,
+    t = _ref37.t,
+    Modal = _ref37.Modal;
+  return function (_ref38) {
+    var batchIndex = _ref38.batchIndex,
+      file = _ref38.file,
+      range = _ref38.range,
+      isBatch = _ref38.isBatch,
+      isChunk = _ref38.isChunk;
+    var downloadOps = props.edm.download || {};
+    var translateFile = getTranslateFile({
+      api: api,
+      isChunk: isChunk
+    });
+    var handleSuccess = getHandleSuccess({
+      downloadOps: downloadOps,
+      file: file,
+      translateFile: translateFile,
+      isChunk: isChunk,
+      state: state
+    });
+    var calcProgress = getCalcProgress();
+    var _ref39 = {},
+      _ref39$isFinished = _ref39.isFinished,
+      isFinished = _ref39$isFinished === void 0 ? false : _ref39$isFinished;
+    if (!isBatch) {
+      var args = {
+        api: api,
+        downloadOps: downloadOps,
+        file: file,
+        service: service,
+        constants: constants,
+        props: props,
+        state: state,
+        t: t,
+        Modal: Modal,
+        isChunk: isChunk
+      };
+      Object.assign(args, {
+        calcProgress: calcProgress,
+        isFinished: isFinished,
+        emit: emit,
+        handleSuccess: handleSuccess,
+        range: range,
+        batchIndex: batchIndex,
+        isBatch: isBatch
+      });
+      downloadFileSingle(args);
+      return;
+    }
+    var params = {
+      api: api,
+      downloadOps: downloadOps,
+      file: file,
+      service: service,
+      props: props,
+      state: state,
+      calcProgress: calcProgress,
+      emit: emit,
+      handleSuccess: handleSuccess,
+      t: t,
+      Modal: Modal,
+      range: range
+    };
+    isBatch && downloadFileBatch(params);
+  };
+};
+export var afterDownload = function afterDownload(_ref40) {
+  var api = _ref40.api,
+    state = _ref40.state;
+  return function (_ref41) {
+    var batchIndex = _ref41.batchIndex,
+      range = _ref41.range,
+      data = _ref41.data,
+      file = _ref41.file,
+      isBatch = _ref41.isBatch,
+      isChunk = _ref41.isChunk;
+    if (data.status === 200) {
+      var key = file.docId + '-' + batchIndex;
+      var count = state.downloadBatchQueue[key];
+      state.downloadBatchQueue[key] = count + 1;
+    } else {
+      var countDownloadReplay = state.downloadReplayAtoms[file.docId + '-' + range.index];
+      if (countDownloadReplay && countDownloadReplay >= 2) {
+        var msgArray = ['The number of retry times exceeds the threshold! [docId:', file.docId, ', chunk:', range.index, ']'];
+        log.logger.warn(msgArray.join(''));
+        delete state.downloadReplayAtoms[file.docId + '-' + range.index];
+      } else {
+        var _msgArray = ['replay ', countDownloadReplay, '! [docId:', file.docId, ', chunk:', range.index, ']'];
+        log.logger.warn(_msgArray.join(''));
+        state.downloadReplayAtoms[file.docId + '-' + range.index] = countDownloadReplay + 1;
+        api.downloadFileInner({
+          batchIndex: batchIndex,
+          range: range,
+          file: file,
+          isBatch: isBatch,
+          isChunk: isChunk
+        });
+      }
+    }
+  };
+};
+export var setWriterFile = function setWriterFile(_ref42) {
+  var state = _ref42.state,
+    emit = _ref42.emit,
+    props = _ref42.props;
+  return function (_ref43) {
+    var data = _ref43.data,
+      index = _ref43.index;
+    var fileStream = props.plugin && props.plugin.createWriteStream(state.dowuloadChunkFile.get('docName'), {
+      size: data.byteLength
+    });
+    var writer = fileStream.getWriter();
+    var downloaded = 0;
+    var fileSize = state.dowuloadChunkFile.get('fileSize');
+    var writerStreamSaver = function writerStreamSaver() {
+      var chunk = state.dowuloadChunkFile.get(index);
+      if (chunk) {
+        writer.write(chunk).then(function () {
+          downloaded += chunk.byteLength;
+          state.dowuloadChunkFile["delete"](index);
+          if (index + 1 === state.dowuloadChunkFile.get('chunkSize')) {
+            emit('download', 100);
+            writer.close();
+          } else {
+            var progress = Math.ceil(downloaded / fileSize * 100) || 0;
+            if (progress !== 100) {
+              emit('download', progress);
+            }
+            index++;
+            writerStreamSaver();
+          }
+          chunk = null;
+        });
+      } else {
+        setTimeout(function () {
+          writerStreamSaver();
+        }, 1000);
+      }
+    };
+    writerStreamSaver();
+  };
+};
+export var getFormData = function getFormData(_ref44) {
+  var constants = _ref44.constants,
+    props = _ref44.props,
+    state = _ref44.state;
+  return function (_ref45) {
+    var formData = _ref45.formData,
+      file = _ref45.file,
+      type = _ref45.type;
+    if (state.isEdm && props.edm.upload) {
+      var propData = props.data || {};
+      var edmData = props.edm.upload.params || {};
+      var params = _objectSpread(_objectSpread({}, propData), edmData);
+      for (var key in params) {
+        if (Object.prototype.hasOwnProperty.call(params, key)) {
+          formData.set(key, params[key] || '');
+        }
+      }
+    }
+    if (props.edm.isCheckCode === true) {
+      formData.append(constants.EDM.ISCHECKCODE, 'Y');
+      file.hash && formData.append(constants.EDM.CHECKCODE, file.hash);
+    } else {
+      formData.append(constants.EDM.ISCHECKCODE, 'N');
+    }
+    var updateId = state.updateId || props.edm.updateId;
+    if (type === constants.EDM.CHUNKINIT) {
+      formData.append(constants.EDM.FILESIZE, file.size);
+      formData.append(constants.EDM.CHUNKS, file.chunkSize);
+      formData.append(constants.EDM.FILENAME, file.name);
+      updateId && formData.append(constants.EDM.DOCID, updateId);
+    } else {
+      formData.append(constants.EDM.MULTIPART, file, file.filename);
+      formData.append(constants.EDM.CHUNK, file.chunk);
+      formData.append(constants.EDM.LOWERNAME, file.filename);
+      var docId = updateId || file.docId;
+      formData.append(constants.EDM.DOCID, docId);
+    }
+    updateId && formData.append('updateFile', true);
+    return formData;
+  };
+};
+export var largeDocumentUpload = function largeDocumentUpload(_ref46) {
+  var api = _ref46.api,
+    Modal = _ref46.Modal,
+    state = _ref46.state,
+    t = _ref46.t,
+    emit = _ref46.emit,
+    constants = _ref46.constants;
+  return function (file) {
+    var chunkSize = Math.ceil(file.size / state.chunkSize);
+    file.chunkSize = chunkSize;
+    file.cancelToken = [];
+    api.segmentUploadInit(file).then(function (data) {
+      if (data) {
+        file.records = data.chunks;
+        file.docId = data.docId;
+        state.largeFileInfo[data.docId] = file;
+        var batches = api.sliceChunk(file);
+        api.batchSegmentUpload({
+          docId: data.docId,
+          batchIndex: 0,
+          batches: batches,
+          progress: {
+            size: file.size,
+            trunks: [],
+            file: file
+          }
+        });
+      } else {
+        Modal.message({
+          message: t('ui.fileUpload.init'),
+          status: 'warning',
+          duration: '1000'
+        });
+        var fileData = api.getFile(file);
+        state.uploadFiles.splice(state.uploadFiles.indexOf(fileData), 1);
+      }
+    })["catch"](function (err) {
+      file.status = constants.FILE_STATUS.FAIL;
+      emit('error', err, file, state.uploadFiles);
+    });
+  };
+};
+export var segmentUploadInit = function segmentUploadInit(_ref47) {
+  var api = _ref47.api,
+    props = _ref47.props,
+    service = _ref47.service,
+    state = _ref47.state,
+    constants = _ref47.constants;
+  return function (file) {
+    var formData = new FormData();
+    return new Promise(function (resolve, reject) {
+      service.getLargeFileInitUrl().then(function (data) {
+        service.request({
+          method: 'post',
+          url: xss.filterUrl(data),
+          data: api.getFormData({
+            formData: formData,
+            file: file,
+            type: constants.EDM.CHUNKINIT
+          }),
+          withCredentials: props.withCredentials,
+          headers: Object.assign(props.headers, state.headers)
+        }).then(function (data) {
+          if (data.data.status === 200) {
+            resolve(data.data.result);
+          } else {
+            reject(data);
+          }
+        });
+      });
+    });
+  };
+};
+var afterUpload = function afterUpload(_ref48) {
+  var data = _ref48.data,
+    file = _ref48.file,
+    batchIndex = _ref48.batchIndex,
+    state = _ref48.state,
+    api = _ref48.api,
+    progress = _ref48.progress;
+  if (data.status === 200) {
+    var key = file.docId + '-' + batchIndex;
+    var count = state.batchQueue[key];
+    state.batchQueue[key] = count + 1;
+  } else {
+    var countReplay = state.replayAtoms[file.docId + '-' + file.chunk];
+    if (countReplay && countReplay >= 2) {
+      var msgArray = ['The number of retry times exceeds the threshold! [docId:', file.docId, ', chunk:', file.chunk, ']'];
+      log.logger.warn(msgArray.join(''));
+      delete state.replayAtoms[file.docId + '-' + file.chunk];
+    } else {
+      var _msgArray2 = ['replay ', countReplay, '! [docId:', file.docId, ', chunk:', file.chunk, ']'];
+      log.logger.warn(_msgArray2.join(''));
+      state.replayAtoms[file.docId + '-' + file.chunk] = countReplay + 1;
+      api.segmentUpload(batchIndex, file, progress);
+    }
+  }
+};
+var segmentUploadInner = function segmentUploadInner(_ref49) {
+  var api = _ref49.api,
+    props = _ref49.props,
+    service = _ref49.service,
+    state = _ref49.state,
+    emit = _ref49.emit,
+    constants = _ref49.constants,
+    batchIndex = _ref49.batchIndex,
+    file = _ref49.file,
+    progress = _ref49.progress;
+  var formData = new FormData();
+  var postChunk = function postChunk(url) {
+    var source = service.cancelToken();
+    if (progress.file.cancelToken) {
+      progress.file.cancelToken.push(source.cancel);
+      service.request({
+        method: 'post',
+        url: xss.filterUrl(url),
+        data: api.getFormData({
+          formData: formData,
+          file: file,
+          type: ''
+        }),
+        withCredentials: props.withCredentials,
+        headers: Object.assign(props.headers, state.headers),
+        cancelToken: source.token,
+        hideErr: true,
+        onUploadProgress: function onUploadProgress(event) {
+          progress.trunks[file.chunk] = event.loaded;
+          var count = progress.trunks.reduce(function (a, b) {
+            return a + b;
+          });
+          var percentage = Math.floor(count / progress.size * 100) || 0;
+          file.percentage = Math.floor(event.loaded / event.total * 100);
+          event.percentage = progress.file.percentage = percentage > 100 ? 100 : percentage;
+          if (percentage >= 100) progress.file.isFinished = true;
+          emit('progress', progress.file, state.uploadFiles, api.calcUploadingFilesInfo());
+        }
+      }).then(function (data) {
+        afterUpload({
+          data: data,
+          file: file,
+          batchIndex: batchIndex,
+          state: state,
+          api: api,
+          progress: progress
+        });
+        if (progress.file.percentage === 100) progress.file.status = constants.FILE_STATUS.SUCESS;
+      })["catch"](function (data) {
+        if (data.response && data.response.status === 401) {
+          var tokenParams = {
+            token: props.edm.upload.token,
+            file: file,
+            type: 'upload'
+          };
+          api.getToken(tokenParams).then(function (data) {
+            afterUpload({
+              data: data,
+              file: file,
+              batchIndex: batchIndex,
+              state: state,
+              api: api,
+              progress: progress
+            });
+          });
+        } else {
+          file.state = constants.FILE_STATUS.FAIL;
+        }
+      });
+    }
+  };
+  if (!state.chunkUploadUrl) {
+    service.getChunkUploadUrl().then(function (data) {
+      state.chunkUploadUrl = data;
+      postChunk(data);
+    });
+  } else {
+    postChunk(state.chunkUploadUrl);
+  }
+};
+export var segmentUpload = function segmentUpload(_ref50) {
+  var api = _ref50.api,
+    props = _ref50.props,
+    service = _ref50.service,
+    state = _ref50.state,
+    emit = _ref50.emit,
+    constants = _ref50.constants;
+  return function (batchIndex, file, progress) {
+    if (typeof file.then === 'function') {
+      file.then(function (file) {
+        segmentUploadInner({
+          batchIndex: batchIndex,
+          api: api,
+          service: service,
+          state: state,
+          emit: emit,
+          props: props,
+          file: file,
+          constants: constants,
+          progress: progress
+        });
+      });
+    } else {
+      segmentUploadInner({
+        api: api,
+        props: props,
+        service: service,
+        state: state,
+        emit: emit,
+        constants: constants,
+        batchIndex: batchIndex,
+        file: file,
+        progress: progress
+      });
+    }
+  };
+};
+export var batchSegmentUpload = function batchSegmentUpload(_ref51) {
+  var api = _ref51.api,
+    constants = _ref51.constants,
+    props = _ref51.props,
+    refs = _ref51.refs,
+    state = _ref51.state;
+  return function (_ref52) {
+    var docId = _ref52.docId,
+      batchIndex = _ref52.batchIndex,
+      batches = _ref52.batches,
+      progress = _ref52.progress;
+    if (batchIndex < batches.length && progress.file.cancelToken) {
+      var key = docId + '-' + batchIndex;
+      var batch = batches[batchIndex];
+      Object.defineProperty(state.batchQueue, key, {
+        get: function get() {
+          return state.batchQueueListen[key];
+        },
+        set: function set(value) {
+          state.batchQueueListen[key] = value;
+          if (value >= batch.length) {
+            api.batchSegmentUpload({
+              docId: docId,
+              batchIndex: ++batchIndex,
+              batches: batches,
+              progress: progress
+            });
+          }
+        }
+      });
+      var index = 0;
+      while (batch.length - index > 0) {
+        api.segmentUpload(batchIndex, batch[index++], progress);
+      }
+    } else {
+      typeof props.edm.upload.closeloading === 'function' && props.edm.upload.closeloading();
+      refs[constants.UPLOAD_INNER].upload(state.largeFileInfo[docId]);
+    }
+  };
+};
+export var sliceChunk = function sliceChunk(_ref53) {
+  var state = _ref53.state,
+    props = _ref53.props;
+  return function (file) {
+    var chunkSize = file.chunkSize;
+    var chunkBatchArray = [[]];
+    state.batchQueue[file.docId + '-0'] = 0;
+    state.batchQueueListen[file.docId + '-0'] = 0;
+    var _loop = function _loop(i) {
+      if (file.records.indexOf(i.toString()) > -1) {
+        return "continue";
+      }
+      var start = i * state.chunkSize;
+      var end = Math.min(file.size, start + state.chunkSize);
+      var atom = file.raw.slice(start, end);
+      atom.chunk = i + 1;
+      atom.filename = file.name;
+      atom.docId = file.docId;
+      atom.chunkSize = chunkSize;
+      atom.cacheSign = file.cacheSign;
+      atom.records = file.records;
+      atom.percentage = file.percentage;
+      var promise = new Promise(function (resolve) {
+        if (props.edm.isCheckCode !== true) return resolve(atom);
+        var reader = new FileReader();
+        reader.readAsArrayBuffer(atom);
+        reader.onload = function (e) {
+          if (props.edm.isCheckCode === true) {
+            var cryptoJS = props.edm.upload.plugin();
+            var wordArray = cryptoJS.lib.WordArray.create(e.target.result);
+            var hash = cryptoJS[shaMap.shaMap](wordArray).toString();
+            atom.hash = hash;
+          }
+          resolve(atom);
+        };
+      });
+      var lastIndex = chunkBatchArray.length - 1;
+      if (chunkBatchArray[lastIndex].length < state.chunkBatchLimit) {
+        chunkBatchArray[lastIndex].push(promise);
+      } else {
+        state.batchQueue[file.docId + '-' + chunkBatchArray.length] = 0;
+        state.batchQueueListen[file.docId + '-' + chunkBatchArray.length] = 0;
+        chunkBatchArray.push([]);
+        chunkBatchArray[lastIndex + 1].push(promise);
+      }
+    };
+    for (var i = 0; i < chunkSize; i++) {
+      var _ret = _loop(i);
+      if (_ret === "continue") continue;
+    }
+    return chunkBatchArray;
+  };
+};
+export var getToken = function getToken(_ref54) {
+  var constants = _ref54.constants,
+    props = _ref54.props,
+    state = _ref54.state,
+    t = _ref54.t,
+    Modal = _ref54.Modal;
+  return function (_ref55) {
+    var token = _ref55.token,
+      file = _ref55.file,
+      _ref55$isOnlinePrevie = _ref55.isOnlinePreview,
+      isOnlinePreview = _ref55$isOnlinePrevie === void 0 ? false : _ref55$isOnlinePrevie,
+      _ref55$type = _ref55.type,
+      type = _ref55$type === void 0 ? '' : _ref55$type,
+      _ref55$isinit = _ref55.isinit,
+      isinit = _ref55$isinit === void 0 ? false : _ref55$isinit;
+    if (props.edm.isExtranet && !isOnlinePreview) {
+      state.isSuccess = true;
+      state.accept = props.accept;
+      state.singleMaxSize = props.edm.singleFileMaxSize || 200;
+      return Promise.resolve(true);
+    }
+    if (state.isEdm && !token || typeof token !== 'function') {
+      Modal.message({
+        message: t(constants.EDM.I18NKEY),
+        status: 'warning',
+        duration: '2000'
+      });
+      return new Promise(function (resolve) {
+        resolve(false);
+      });
+    }
+    return new Promise(function (resolve, reject) {
+      try {
+        var promise;
+        if (isinit) {
+          !initTokenPromise && (initTokenPromise = token(file));
+          promise = initTokenPromise;
+        } else {
+          promise = token(file);
+        }
+        promise.then(function (data) {
+          var result = data || {};
+          var whitelist = result.config && result.config.fileWhiteList || '';
+          state.isSuccess = true;
+          state.accept = type === 'download' || type === 'preview' ? props.accept : "".concat(whitelist, ",").concat(props.accept);
+          state.headers[constants.EDM.EDMTOKEN] = result.edmToken || '';
+          state.headers[constants.EDM.TRACEID] = result.traceId || '';
+          if (result.config) {
+            state.singleMaxSize = result.config.singleFileMaxSize;
+          }
+          state.edmToken = result;
+          resolve(true);
+        });
+      } catch (error) {
+        reject(new Error(error));
+      }
+    });
+  };
+};
+var getTokenResolver = function getTokenResolver(_ref56) {
+  var reject = _ref56.reject,
+    api = _ref56.api,
+    file = _ref56.file,
+    state = _ref56.state,
+    resolve = _ref56.resolve,
+    props = _ref56.props,
+    constants = _ref56.constants,
+    service = _ref56.service;
+  return function (data) {
+    if (!data) {
+      var message = '[TINY Error][FileUpload] No edm token';
+      reject(new Error(message));
+      return;
+    }
+    var iframeUrl = api.getPreviewUrlSync(file);
+    if (iframeUrl) {
+      state.showPreview = true;
+      state.iframeUrl = iframeUrl;
+      resolve(state.iframeUrl);
+      return;
+    }
+    var watermark = props.edm.preview.watermark || {};
+    var params = state.fileWater ? constants.EDM.FORMAT : '';
+    var downParams = state.fileWater ? constants.EDM.WATER : constants.EDM.SOURCE;
+    var tools = props.edm.preview.plugin;
+    service.all([service.getPreviewUrl(), service.getSingleDownloadUrl()]).then(service.spread(function (previewUrl, downloadurl) {
+      var serviceUrl = props.edm.preview.serviceUrl;
+      var infoUrl = serviceUrl || previewUrl.replace(/{docId}/, file.docId) + "?".concat(params, "docVersion=").concat(file.docVersion);
+      var pageUrl = serviceUrl || previewUrl.replace(/{docId}/, file.docId) + "?type=doc&pageNum=1&".concat(params, "docVersion=").concat(file.docVersion);
+      var downloadUrl = serviceUrl + downloadurl.replace(/{docId}/, file.docId) + "?docId=".concat(file.docId, "&docVersion=").concat(file.docVersion, "&").concat(downParams, "from=Experience&");
+      tools.setIsEDM3(true);
+      tools.setDocumentInfoUrl(infoUrl);
+      tools.setDownloadUrl(downloadUrl, true);
+      tools.setPageUrl(pageUrl);
+      tools.setWatermarkParameters({
+        showWatermark: watermark.showWatermark || 1,
+        rotation: watermark.rotation || 30,
+        text: watermark.text || ''
+      });
+      tools.setPdfjsPaht(props.edm.preview.packageName || constants.EDM.JSLIB);
+      tools.setAuthToken(state.headers[constants.EDM.EDMTOKEN]);
+      state.showPreview = true;
+      state.iframeUrl = props.edm.preview.previewUrl + "".concat(constants.EDM.URLCONTS).concat(file.docVersion, "&docId=").concat(file.docId);
+      resolve(state.iframeUrl);
+    }));
+  };
+};
+export var previewFile = function previewFile(_ref57) {
+  var api = _ref57.api,
+    constants = _ref57.constants,
+    props = _ref57.props,
+    service = _ref57.service,
+    state = _ref57.state;
+  return function (file) {
+    return new Promise(function (resolve, reject) {
+      try {
+        var tokenParams = {
+          isOnlinePreview: true,
+          file: file,
+          type: 'preview',
+          token: props.edm.preview.token
+        };
+        var tokenCatcher = function tokenCatcher(e) {
+          reject(new Error(e));
+        };
+        var tokenResolver = getTokenResolver({
+          reject: reject,
+          api: api,
+          file: file,
+          state: state,
+          resolve: resolve,
+          props: props,
+          constants: constants,
+          service: service
+        });
+        api.getToken(tokenParams).then(tokenResolver)["catch"](tokenCatcher);
+      } catch (e) {
+        reject(new Error(e));
+      }
+    });
+  };
+};
+export var getNewTabPreviewUrl = function getNewTabPreviewUrl(_ref58) {
+  var api = _ref58.api,
+    props = _ref58.props;
+  return function (file) {
+    return new Promise(function (resolve, reject) {
+      api.getToken({
+        token: props.edm.preview.token,
+        file: file,
+        isOnlinePreview: true,
+        type: 'preview'
+      }).then(function (data) {
+        if (!data) {
+          reject(new Error('[TINY Error][FileUpload] No edm token'));
+          return;
+        }
+        var iframeUrl = api.getPreviewUrlSync(file);
+        if (!iframeUrl) {
+          reject(new Error(new Error('[TINY Error][FileUpload] No preview url')));
+        } else {
+          resolve(iframeUrl);
+        }
+      })["catch"](function (e) {
+        reject(new Error(e));
+      });
+    });
+  };
+};
+export var getPreviewUrlSync = function getPreviewUrlSync(_ref59) {
+  var constants = _ref59.constants,
+    props = _ref59.props,
+    state = _ref59.state;
+  return function (file) {
+    var edm = props.edm || {};
+    var preview = edm.preview || {};
+    var online = preview.online;
+    if (!online) {
+      return;
+    }
+    var html = online.jslibhtml.split('?').shift();
+    if (!html) {
+      return;
+    }
+    var watermark = preview.watermark || {};
+    var paramsData = _objectSpread(_objectSpread(_objectSpread({}, online), watermark), {
+      jslibhtml: html,
+      authToken: state.headers[constants.EDM.EDMTOKEN],
+      docId: file.docId,
+      docVersion: file.docVersion || file.version || 'V1',
+      type: 'doc',
+      pageNum: '1'
+    });
+    var params = [];
+    for (var key in paramsData) {
+      if (Object.prototype.hasOwnProperty.call(paramsData, key)) {
+        params.push("".concat(key, "=").concat(paramsData[key]));
+      }
+    }
+    var iframeUrl = html + '?' + params.join('&');
+    return iframeUrl;
+  };
+};
+export var previewImage = function previewImage(_ref60) {
+  var api = _ref60.api,
+    props = _ref60.props,
+    service = _ref60.service,
+    state = _ref60.state;
+  return function (file) {
+    return new Promise(function (resolve, reject) {
+      try {
+        api.getToken({
+          token: props.edm.preview.token,
+          file: file,
+          type: 'preview'
+        }).then(function (data) {
+          if (!data) {
+            reject(new Error('[TINY Error][FileUpload] No edm token'));
+            return;
+          }
+          service.getPreviewUrl().then(function (url) {
+            var imgParam = Object.assign(file, {
+              type: 'image',
+              imageType: 'image'
+            });
+            url = url.replace(/{docId}/, file.docId);
+            service.post(xss.filterUrl(url), imgParam, {
+              withCredentials: props.withCredentials,
+              headers: Object.assign(props.headers, state.headers),
+              responseType: 'blob'
+            }).then(function (data) {
+              var blob = new Blob([data.data]);
+              var URL = window.URL || window.webkitURL;
+              var link = URL.createObjectURL(blob);
+              resolve(link);
+            });
+          });
+        });
+      } catch (e) {
+        reject(new Error(e));
+      }
+    });
+  };
+};
+export var getDialogConfigObj = function getDialogConfigObj(_ref61) {
+  var props = _ref61.props,
+    state = _ref61.state;
+  return function () {
+    var dialogConfigDefault = {
+      "class": 'single-download-modal single-download-modal1',
+      style: '',
+      props: {
+        lockScroll: true,
+        visible: state.showPreview,
+        dragable: true,
+        title: '文档预览',
+        width: '60%'
+      },
+      on: {
+        'update:visible': function updateVisible(value) {
+          return state.showPreview = value;
+        }
+      }
+    };
+    var dialogConfig = {};
+    if (props.edm && props.edm.preview && _typeof(props.edm.preview.dialogConfig) === 'object') {
+      dialogConfig = props.edm.preview.dialogConfig || {};
+    }
+    var dialogConfigCopy = extend(true, {}, dialogConfig);
+    var events = dialogConfigCopy.events || {};
+    var clazz = dialogConfigCopy["class"] || '';
+    var style = dialogConfigCopy.style || '';
+    delete dialogConfigCopy.events;
+    delete dialogConfigCopy["class"];
+    delete dialogConfigCopy.style;
+    return extend(true, {}, dialogConfigDefault, {
+      "class": "".concat(dialogConfigDefault["class"], " ").concat(clazz),
+      style: "".concat(style),
+      props: _objectSpread({}, dialogConfigCopy),
+      on: _objectSpread({}, events)
+    });
+  };
+};
+export var computeDocChunkSize = function computeDocChunkSize(_ref62) {
+  var props = _ref62.props,
+    state = _ref62.state,
+    SIZE_2G = _ref62.SIZE_2G,
+    SIZE_20M = _ref62.SIZE_20M,
+    SIZE_8M = _ref62.SIZE_8M;
+  return function () {
+    var isDefaultChunkSize = !(props.edm && props.edm.chunkSize);
+    var _ref63 = props.edm || {},
+      _ref63$docSize = _ref63.docSize,
+      docSize = _ref63$docSize === void 0 ? SIZE_20M : _ref63$docSize,
+      _ref63$chunkSize = _ref63.chunkSize,
+      chunkSize = _ref63$chunkSize === void 0 ? SIZE_8M : _ref63$chunkSize;
+    docSize = docSize < 0 ? 0 : docSize;
+    docSize = docSize > SIZE_2G ? SIZE_2G : docSize;
+    if (docSize) chunkSize = chunkSize < 0 ? 0 : chunkSize;
+    if (!isDefaultChunkSize) {
+      var chunkSizes = [64 * 1024, 32 * 1024, 16 * 1024, 8 * 1024, 4 * 1024, 2 * 1024, 0 * 1024];
+      chunkSizes.some(function (size) {
+        if (chunkSize >= size) {
+          chunkSize = Math.max(size, 2 * 1024);
+          return true;
+        }
+        return false;
+      });
+    }
+    state.docSize = docSize * 1024;
+    state.chunkSize = chunkSize * 1024;
+  };
+};
+export var updateFile = function updateFile(_ref64) {
+  var constants = _ref64.constants,
+    refs = _ref64.refs;
+  return function (file) {
+    refs[constants.UPLOAD_INNER].handleUpdate(file);
+  };
+};
+export var onBeforeDestroy = function onBeforeDestroy(state) {
+  return function () {
+    state.uploadFiles.forEach(function (file) {
+      if (file.url && file.url.indexOf('blob:') === 0) {
+        URL.revokeObjectURL(file.url);
+      }
+    });
+  };
+};