file-utils-plus/dist/index.umd.js

文件上传以及常用的公共方法

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('browser-md5-file'), require('ali-oss'), require('qiniu-js')) :
  typeof define === 'function' && define.amd ? define(['exports', 'browser-md5-file', 'ali-oss', 'qiniu-js'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.fileUploadUtils = {}, global.BMF, global.OSS, global.QiniuOSS));
})(this, (function (exports, BMF, OSS, QiniuOSS) { 'use strict';

  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

  function _interopNamespace(e) {
    if (e && e.__esModule) return e;
    var n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
    if (e) {
      Object.keys(e).forEach(function (k) {
        if (k !== 'default') {
          var d = Object.getOwnPropertyDescriptor(e, k);
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: function () { return e[k]; }
          });
        }
      });
    }
    n["default"] = e;
    return Object.freeze(n);
  }

  var BMF__default = /*#__PURE__*/_interopDefaultLegacy(BMF);
  var OSS__default = /*#__PURE__*/_interopDefaultLegacy(OSS);
  var QiniuOSS__namespace = /*#__PURE__*/_interopNamespace(QiniuOSS);

  const getMd5 = (file) => {
    const bmf = new BMF__default["default"]();
    return new Promise((resolve, reject) => {
      bmf.md5(file, (err, md5) => {
        if (err) {
          return reject(err);
        }
        resolve(md5);
      });
    });
  };
  const getImageAttribute = (file) => {
    return new Promise((resolve) => {
      let reader = new FileReader();
      reader.onload = function(e) {
        let result = e.target?.result;
        let img = document.createElement("img");
        img.src = result;
        img.onload = function() {
          resolve({
            width: img.width,
            height: img.height
          });
        };
      };
      reader.onerror = function(e) {
        resolve(e);
      };
      reader.readAsDataURL(file);
    });
  };
  const fileType = (value) => {
    if (value.lastIndexOf("audio") !== -1) {
      return "audio";
    } else if (value.lastIndexOf("image") !== -1) {
      return "image";
    } else {
      return "";
    }
  };
  const isExistFile = (url) => {
    let xmlhttp;
    if (window.XMLHttpRequest) {
      xmlhttp = new XMLHttpRequest();
    } else {
      xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
    }
    xmlhttp.open("GET", `${url}?${new Date().getTime()}`, false);
    xmlhttp.send();
    if (xmlhttp.readyState === 4) {
      if (xmlhttp.status === 200) {
        return true;
      } else {
        return false;
      }
    } else {
      return false;
    }
  };

  const createAliOSS = (ossInfo) => {
    return new OSS__default["default"]({
      region: ossInfo.region,
      bucket: ossInfo.bucket,
      accessKeyId: ossInfo.accessKeyId,
      accessKeySecret: ossInfo.accessKeySecret,
      stsToken: ossInfo.securityToken,
      secure: true
    });
  };
  const uploadFileToAliOss = async ({ file, path, baseUrl, options, argument }) => {
    let ext = file.name.substring(file.name.lastIndexOf(".") + 1);
    const client = await createAliOSS(options);
    let audioAttribute = {};
    let imageAttribute = {};
    try {
      if (fileType(file.type) === "image") {
        imageAttribute = await getImageAttribute(file);
      }
      const md5 = await getMd5(file);
      const fileName = `${md5}.${ext}`;
      await client.multipartUpload(`${path}/${fileName}`, file, {});
      return {
        url: `${baseUrl}/${path}/${fileName}`,
        name: file.name.substring(0, file.name.lastIndexOf(".")),
        md5,
        size: file.size,
        ext,
        ...imageAttribute,
        ...argument,
        ...audioAttribute
      };
    } catch (e) {
      throw new Error(`\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25:${e}`);
    }
  };

  const uploadFileToQiniuOss = async ({ file, path, baseUrl, token, argument }) => {
    let audioAttribute = {};
    let imageAttribute = {};
    let ext = file.name.substring(file.name.lastIndexOf(".") + 1);
    if (fileType(file.type) === "image") {
      imageAttribute = await getImageAttribute(file);
    }
    const md5 = await getMd5(file);
    const fileName = `${md5}.${ext}`;
    return new Promise((resolve) => {
      let observable = QiniuOSS__namespace.upload(file, `${path}/${fileName}`, token);
      const observer = {
        complete() {
          resolve({
            url: `${baseUrl}/${path}/${fileName}`,
            name: file.name.substring(0, file.name.lastIndexOf(".")),
            md5,
            size: file.size,
            ext,
            ...imageAttribute,
            ...argument,
            ...audioAttribute
          });
        }
      };
      observable.subscribe(observer);
    });
  };

  const blobToFile = (blob, fileName, options) => {
    return new File([blob], fileName, options);
  };
  const fileToBase64 = (file) => {
    return new Promise((resolve) => {
      let fileReader = new FileReader();
      fileReader.readAsDataURL(file);
      fileReader.onload = function(e) {
        resolve(e.target?.result);
      };
    });
  };
  const base64ToBlob = (base64) => {
    return new Promise((resolve) => {
      const arr = base64.split(",");
      const mime = arr[0].match(/:(.*?);/);
      const type = mime[0];
      const bstr = atob(arr[1]);
      let n = bstr.length;
      const u8arr = new Uint8Array(n);
      while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
      }
      resolve(new Blob([u8arr], { type }));
    });
  };
  const base64ToFile = (base64, filename) => {
    return new Promise((resolve) => {
      let arr = base64.split(",");
      const mime = arr[0].match(/:(.*?);/);
      const bstr = atob(arr[1]);
      let n = bstr.length;
      const u8arr = new Uint8Array(n);
      while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
      }
      return resolve(new File([u8arr], filename, { type: mime[1] }));
    });
  };
  const fileToBuffer = (files) => {
    return new Promise((resolve) => {
      const fileReader = new FileReader();
      fileReader.onload = function() {
        const result = fileReader.result;
        resolve(result);
      };
      fileReader.readAsArrayBuffer(files);
    });
  };
  const urlToFile = (url) => {
    return new Promise((resolve) => {
      let http = new XMLHttpRequest();
      http.open("GET", url, true);
      http.responseType = "blob";
      http.onload = function(e) {
        if (this.status === 200 || this.status === 0) {
          resolve(blobToFile(e.target.response, url.substring(url.lastIndexOf("/") + 1)));
        }
      };
      http.send();
    });
  };

  exports.base64ToBlob = base64ToBlob;
  exports.base64ToFile = base64ToFile;
  exports.blobToFile = blobToFile;
  exports.createAliOSS = createAliOSS;
  exports.fileToBase64 = fileToBase64;
  exports.fileToBuffer = fileToBuffer;
  exports.fileType = fileType;
  exports.getImageAttribute = getImageAttribute;
  exports.getMd5 = getMd5;
  exports.isExistFile = isExistFile;
  exports.uploadFileToAliOss = uploadFileToAliOss;
  exports.uploadFileToQiniuOss = uploadFileToQiniuOss;
  exports.urlToFile = urlToFile;

  Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });

}));
//# sourceMappingURL=index.umd.js.map