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

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

import BMF from 'browser-md5-file';
import OSS from 'ali-oss';
import * as QiniuOSS from 'qiniu-js';

const getMd5 = (file) => {
  const bmf = new BMF();
  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({
    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.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();
  });
};

export { base64ToBlob, base64ToFile, blobToFile, createAliOSS, fileToBase64, fileToBuffer, fileType, getImageAttribute, getMd5, isExistFile, uploadFileToAliOss, uploadFileToQiniuOss, urlToFile };
//# sourceMappingURL=index.es.js.map