jinbi-utils 1.0.0-beta.1

package/src/file/index.ts

@@ -0,0 +1,296 @@
+/**
+ * 文件处理相关
+ * @packageDocumentation
+ * @module File
+ * @preferred
+ */
+
+import { isEmpty } from '../common';
+import { ceil } from '../number';
+
+export type FileSizeUnit =  'B' |'KB' | 'MB' | 'GB' | 'TB';
+
+export interface FileSizeObject {
+  size: number;
+  unit: FileSizeUnit;
+}
+/**
+ * 计算文件大小
+ #### 使用说明
+ ```
+ calcFileSize(100) 返回 { size: 100, unit: 'B' }
+ calcFileSize(1024) 返回 { size: 1, unit: 'KB' }
+ calcFileSize(1024, 'KB') 返回 { size: 1, unit: 'MB' }
+ calcFileSize(1126.4, 'mb') 返回 { size: 1.1, unit: 'GB' }
+ calcFileSize(Math.pow(1024, 2), 'kb') 返回 { size: 1, unit: 'GB' }
+ ```
+ * @param size 单位 k
+ * @returns number
+ */
+export function calcFileSize(size: number, unit: FileSizeUnit = 'B'): FileSizeObject {
+  const unitList: Array<FileSizeUnit> = ['B', 'KB', 'MB', 'GB', 'TB'];
+
+  let currentUnitIndex = unitList.indexOf(unit.toUpperCase() as FileSizeUnit);
+
+  currentUnitIndex = currentUnitIndex === -1 ? 0 : currentUnitIndex;
+
+  // todo 单位换算。
+  while (size >= 1024 && currentUnitIndex < unitList.length) {
+    size = size / 1024;
+    currentUnitIndex += 1;
+  }
+  return {
+    size,
+    unit: unitList[currentUnitIndex],
+  };
+}
+
+/**
+ * 文件大小转换
+ #### 使用说明
+ ```
+ fileSizeFormat('') 返回 -
+ fileSizeFormat('1024') 返回 1KB
+ fileSizeFormat('1024', 'KB') 返回 1MB
+ fileSizeFormat('2645', 'B') 返回 ceil(2645 / 1024, 2)MB
+ ```
+ * @param {string} str 字符串 单位k
+ */
+export function fileSizeFormat(str: string | number, unit: FileSizeUnit = 'B', defaultValue = '-') {
+  if (isEmpty(str)) {
+    return defaultValue;
+  }
+  const o = calcFileSize(parseFloat(str.toString()), unit);
+  return `${ceil(o.size, 2)}${o.unit}`;
+}
+
+/**
+ * base64转换为file
+ * dataurl base64图片
+ * */
+export function dataURLtoBlob(dataurl: string): Blob {
+  const mime = (dataurl.match(/:(.*?);/) as any)[1];
+  const bytes = window.atob(dataurl.split(',')[1]); // 去掉url的头，并转换为byte
+  // 处理异常,将ascii码小于0的转换为大于0
+  const ab = new ArrayBuffer(bytes.length);
+  const ia = new Uint8Array(ab);
+  for (let i = 0; i < bytes.length; i += 1) {
+    ia[i] = bytes.charCodeAt(i);
+  }
+  return new Blob([ab], { type: mime });
+}
+
+export function blobToDataURL(blob: Blob): any {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      if (!e || !e.target) {
+        reject(e);
+      } else {
+        resolve(e.target.result as string);
+      }
+    };
+    reader.onerror = (err) => {
+      reject(err);
+    };
+    reader.readAsDataURL(blob);
+  });
+}
+
+export interface CompressImgScaleCallback {
+  (w: number, h: number): number;
+}
+export interface CompressImgQualityCallback {
+  (fileSize: number, scale: number, w: number, h: number): number;
+}
+
+/**
+ * 压缩图片方法
+ * @param file 图片
+ * @param scaleCallback 宽高 压缩规则
+ * @param qualityCallback 质量 压缩规则
+ */
+export function compressImg(
+  file: File,
+  scaleCallback?: CompressImgScaleCallback,
+  qualityCallback?: CompressImgQualityCallback,
+): Promise<Blob> {
+  return new Promise((resolve, reject) => {
+    const fileSize = parseFloat((file.size / 1024 / 1024).toString());
+    const read = new FileReader();
+    read.onload = (e: ProgressEvent<FileReader>) => {
+      const img = new Image();
+      img.onload = () => {
+        // 读取图片宽高
+        const w = img.width;
+        const h = img.height;
+        // 生成canvas
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+
+        // 处理函数返回的不是 number & NaN 类型的情况
+        let scale = scaleCallback ? scaleCallback(w, h) : 1;
+        if (Number.isNaN(scale) || typeof scale !== 'number') {
+          scale = 1;
+        }
+        let quality = qualityCallback ? qualityCallback(fileSize, scale, w, h) : 1;
+        if (Number.isNaN(quality) || typeof quality !== 'number') {
+          quality = 1;
+        }
+
+        // 图片 缩放规则
+        if (ctx) {
+          const scaleW = parseInt((w * scale).toString(), 10);
+          const scaleH = parseInt((h * scale).toString(), 10);
+          // 创建属性节点
+          canvas.setAttribute('width', scaleW.toString());
+          canvas.setAttribute('height', scaleH.toString());
+          ctx.drawImage(img, 0, 0, scaleW, scaleH);
+        }
+        // 图片质量 压缩
+        const base64 = canvas.toDataURL(file.type, quality);
+
+        resolve(dataURLtoBlob(base64));
+      };
+      img.onerror = (evt: Event | string) => {
+        reject(evt);
+      };
+
+      if (e.target) {
+        img.src = e.target.result as string;
+      }
+    };
+
+    read.onerror = (e: ProgressEvent<FileReader>) => {
+      reject(e);
+    };
+    read.readAsDataURL(file);
+  });
+}
+
+export type Method =
+  | 'get' | 'GET'
+  | 'delete' | 'DELETE'
+  | 'head' | 'HEAD'
+  | 'options' | 'OPTIONS'
+  | 'post' | 'POST'
+  | 'put' | 'PUT'
+  | 'patch' | 'PATCH'
+  | 'link' | 'LINK'
+  | 'unlink' | 'UNLINK'
+
+export interface ExportByBlobParams {
+  /**
+   * 请求方式
+   */
+  method?: Method;
+  /**
+   * 接口地址
+   */
+  url: string;
+  /**
+   * post接口参数
+   */
+  data?: any;
+  /**
+   * get接口参数
+   */
+  params?: any;
+   /**
+   * 导出的文件名称
+   */
+  filename?: string;
+}
+
+
+export interface GenExportByBlobParams {
+/**
+ * axios 请求函数
+ */
+axiosRequest: any;
+/**
+ * 不使用 withCredentials 域名
+ */
+  notWithCredentials?: string[];
+}
+/**
+ * 生成导出函数
+ */
+export function genExportByBlob({
+  axiosRequest,
+  notWithCredentials = [],
+}) {
+  return function exportByBlob(config: ExportByBlobParams) {
+    let {
+      filename,
+    } = config;
+    const {
+      url,
+      data = {},
+      params = {},
+      method = 'post',
+     } = config;
+    return new Promise((resolve, reject) => {
+      axiosRequest({
+        method,
+        url,
+        data,
+        params,
+        responseType: 'blob',
+        config: {
+          withCredentials: notWithCredentials.some((str) => {
+            return !url.includes(str);
+          }),
+        },
+        // eslint-disable-next-line consistent-return
+      }).then(async (res) => {
+        const response = res?.data;
+        if (response.type === 'application/json') {
+          const reader = new FileReader();
+          reader.readAsText(response, 'utf-8');
+          reader.onload = () => {
+            let result: any = {};
+            try {
+              result = JSON.parse(reader.result as string);
+            } catch (e) {
+              result = response;
+            }
+            // Message.error((result && result.message) || '导出失败');
+            reject(result);
+          };
+        } else {
+          try {
+            const { headers } = res; // 下载后文件名
+            const contentDisposition = headers['content-disposition'];
+            const responseFilename = decodeURIComponent(contentDisposition.split(';')[1].split('filename=')[1]);
+            // 有传文件名称&不带后缀 使用服务端的文件拓展名
+            if (filename && !filename.includes('.')) {
+              const splitFileName = responseFilename.split('.');
+              const suffix = splitFileName[splitFileName.length - 1];
+              filename += `.${suffix}`;
+            } else if (!filename) {
+              filename = responseFilename;
+            }
+          } catch (e) {
+            // 默认名称
+            if (!filename) {
+              filename = 'download.xlsx';
+            }
+          }
+          const blob = new Blob([res.data]);
+          const downloadElement = document.createElement('a');
+          const href = await blobToDataURL(blob); // 创建下载的链接
+          downloadElement.href = href;
+          downloadElement.download = filename;
+          document.body.appendChild(downloadElement);
+          downloadElement.click(); // 点击下载
+          document.body.removeChild(downloadElement); // 下载完成移除元素
+          // window.URL.revokeObjectURL(href);
+          resolve(res);
+        }
+      }).catch((e: Error) => {
+        reject(e);
+      });
+    });
+  };
+}

package/src/http/http.ts

@@ -0,0 +1,79 @@
+import axios, {AxiosInstance, AxiosResponse} from "axios";
+import { httpEnum } from './httpEnums';
+import {getDeviceType, getFromType, getToken, removeToken} from "../common/index";
+interface IHttp {
+  cacheType: 'localStorage' | 'sessionStorage' | 'both';
+  currentMode: string; // local | dev | test | prod 等自定义mode
+  errorCb?: (error: any) => void;
+  getTokenCb?: () => void;
+  tokenKey?: 'token';
+}
+const request = axios.create({
+  timeout: 15000,
+  headers: {
+    // 'Authorization': getToken(),
+    "Content-Type": "application/json",
+  },
+});
+// const requestArr = [request];
+
+/**
+ * @param cacheType localStorage | sessionStorage | both
+ * @param currentMode local | dev | test | prod 等自定义mode
+ * @param errorCb 错误回调
+ * @param getTokenCb 获取token的回调
+ * @param tokenKey
+ * */
+export const http = ({cacheType, currentMode, errorCb, getTokenCb, tokenKey}: IHttp):AxiosInstance => {
+  request.interceptors.request.use(
+    async (config: any) => {
+      const token = getToken(cacheType, tokenKey);
+      const deviceType = getDeviceType();
+      config.headers.Authorization = token;
+      config.headers.token = token;
+      config.headers.FrontType = getFromType(deviceType);
+      return config;
+    },
+    (error) => {
+      // do something with request error
+      return Promise.reject(error);
+    }
+  );
+
+  // response interceptor
+  request.interceptors.response.use(
+    async (response: AxiosResponse) => {
+      const res = response.data;
+      const statusCode = res.code || response.status;
+      // blob文件流
+      if (res instanceof Blob) {
+        return res;
+      }
+      // 成功
+      if (statusCode === httpEnum.CODES.Success) {
+        return res;
+      }
+      // token失效
+      if (statusCode === httpEnum.CODES.UnAuthorized) {
+        if (currentMode !== "local" && currentMode !== "dev" && currentMode !== 'development') {
+          removeToken(cacheType, tokenKey);
+          if (getTokenCb && typeof getTokenCb === "function") {
+            getTokenCb();
+          }
+        }
+        return Promise.reject(new Error("token过期！"));
+      }
+      const errMsg = res.message || res.msg;
+      return Promise.reject(new Error(errMsg || "Error"));
+    },
+    async (error) => {
+      if (errorCb && typeof errorCb === "function") {
+        errorCb(error);
+      }
+      return Promise.reject(error);
+    }
+
+  );
+  return request
+}
+

package/src/http/httpEnums.ts

@@ -0,0 +1,61 @@
+export const httpEnum = {
+    // http响应状态码
+    HTTP_STATUS: {
+      // 1xx，临时响应
+      TEMP_RESPOND: {
+        Continue: 100, // 服务器通知浏览器之前一切正常，请客户端继续请求，如果请求结束，可忽略
+        SwitchingProtocal: 101 // 针对请求头的Upgrade返回的信息。表明服务器正在切换到指定的协议
+      },
+      // 2xx，成功
+      SUCCESS: {
+        Ok: 200, // 请求成功
+        Created: 201, // 常用于POST，PUT 请求，表明请求已经成功，并新建了一个资源。并在响应体中返回路径
+        Accepted: 202, // 请求已经接收到，但没有响应，稍后也不会返回一个异步请求结果。 该状态码适用于等待其他进程处理或者批处理的场景
+        NoAuthoritativeInformation: 203, // 表明响应返回的元信息（meta-infomation）和最初的服务器不同，而是从本地或者第三方获取的
+        NoContent: 204, // 请求没有数据返回，但是头信息有用。用户代理(浏览器)会更新缓存的头信息
+        ResetContent: 205, // 告诉用户代理（浏览器）重置发送该请求的文档
+        ParticalContent: 206 // 客户端使用Range请求头时，返回该状态码
+      },
+      // 3xx，重定向
+      REDIRECT: {
+        MultipleChoice: 300, // 返回多个响应，需要浏览器或者用户选择
+        MovedPermanently: 301, // 请求资源的URL被永久的改变，新的URL会在响应的Location中给出。浏览器到新的URL重新请求资源，因为有些客户端会把请求方式method改成GET。所以该状态码建议GET和HEAD方法中使用。搜索引擎会更新地址到资源的链接（SEO中‘link-judge’被发送到新的URL）
+        Found: 302, // 请求资源的URL被暂时修改到Location提供的URL。未来可能还会有新的修改。览器会根据新的URL重新请求资源。有些客户端会把方法method改为GET，建议在GET和HEAD方法中使用。搜索引擎不会更改URL到资源的。
+        SeeOther: 303, // 服务通过返回的响应数据指导客户端通过GET方法去另一个URL获取资源。通常用于POST或者PUT的请求返回结果，重定向到信息提示页面或者进度展示页面。重定向页面的方法是GET方法。
+        NotModified: 304, // 资源未变更。服务器根据请求头判断，需要资源未修改，只返回响应头；否则将资源一起返回。
+        TemporaryRedirect: 307, // 临时重定向。基本和302相同。唯一的区别是这个状态码严格禁止浏览器到新URL请求资源时修改原来的请求方式和请求体。
+        PermanentRedirect: 308 // 永久重定向。基本和301相同。但是严格禁止修改请求方式和请求体。
+      },
+      // 4xx，请求错误
+      REQUEST_ERROR: {
+        BadRequest: 400, // 请求语法有问题，服务器无法识别。
+        UnAuthorized: 401, // 客户端未授权该请求。缺乏有效的身份认证凭证，一般可能是未登陆。登陆后一般都解决问题。
+        Forbidden: 403, // 服务器拒绝响应。权限不足。
+        NotFound: 404, // URL无效或者URL有效但是没有资源。
+        MethodNotAllowed: 405, // 请求方式Method不允许。但是GET和HEAD属于强制方式，不能返回这个状态码。
+        NotAccepted: 406, // 资源类型不符合服务器要求。
+        ProxyAuthorizationRequired: 407, //  需要代理授权。
+        RequestTimeout: 408, // 服务器将不再使用的连接关闭。响应头会有Connection: close。
+        UpgradeRequired: 426, // 告诉客户端需要升级通信协议。
+        TokenUnAuthorized: 499, // 告诉客户端需要升级通信协议。
+      },
+      // 5xx，服务器错误
+      SERVER_ERROR: {
+        InternalServerError: 500, // 服务器内部错误，未捕获。
+        BadGateway: 502, // 服务器作为网关使用时，收到上游服务器返回的无效响应。
+        ServiceUnavailable: 503, // 无法服务。一般发生在因维护而停机或者服务过载。一般还会伴随着返回一个响应头Retry-After: 说明恢复服务的估计时间。
+        GateTimeout: 504, // 网关超时。服务器作为网关或者代理，不能及时从上游服务器获取响应返回给客户端。
+        HttpVersionNotSupported: 505 // 发出的请求http版本服务器不支持。如果请求通过http2发送，服务器不支持http2.0，就会返回该状态码。
+      }
+    },
+    // http状态码
+    CODES: {
+      Success: '00000',
+      UnAuthorized: '00099',
+      UnAuthorizedPhone: '11001', //未授权用户手机号
+      UnAuthorizedWecom: '11000', //调用企微接口异常
+      UnAuthorizedHavePhone: '11002', //查到手机号但是也报错
+    },
+    // http状态码白名单，在具体业务中处理
+    ERR_CODE_WHITE_LIST: []
+  }

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './common';
+export * from './date';
+export * from './file';
+export * from './object';
+export * from './print';
+export * from './validate';
+export * from './number';
+export * from './string';
+export * from './http/httpEnums'
+export * from './http/http'

package/src/number/index.ts

@@ -0,0 +1,190 @@
+/**
+ * number处理相关
+ * @packageDocumentation
+ * @module Number
+ * @preferred
+ */
+
+import { isEmpty } from '../common';
+/**
+ * 千分位格式化
+  #### 使用说明
+  ```
+  toThousands(1) => 1
+  toThousands(12345) => 12,345
+  toThousands('12323.12') 返回 '12,323.12'
+  ```
+ */
+export function toThousands(num: number | string, defaultValue = '-'): string {
+  if (isEmpty(num)) {
+    return defaultValue;
+  }
+  let val = num.toString();
+
+  if (!val.includes('.')) {
+    val += '.';
+  }
+  return val.replace(/\d(?=(\d{3})+\.)/g, $0 => `${$0},`).replace(/\.$/, '');
+}
+
+/**
+ * 阿拉伯数组转中文数字
+ #### 使用说明
+ ```
+ convertCurrency(0) 返回 '壹拾贰元壹角贰分'
+ convertCurrency(1234567809) 返回 '壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰零玖元整'
+ ```
+ * @param {number} money 金额
+ */
+export function convertCurrency(money = '') {
+  const maxNum = 999999999999999.9999; // 最大处理的数字
+
+  if (isEmpty(money)) {
+    return '';
+  }
+  if (Number(money) >= maxNum) {
+    // 超出最大处理数字
+    return money;
+  }
+
+  const cnNums = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
+  const cnIntRadice = ['', '拾', '佰', '仟'];
+  const cnIntUnits = ['', '万', '亿', '兆']; // 对应整数部分扩展单位
+  const cnDecUnits = ['角', '分', '毫', '厘']; // 对应小数部分单位
+  const cnInteger = '整'; // 整数金额时后面跟的字符
+  const cnIntLast = '元'; // 整型完以后的单位
+  let integerNum; // 金额整数部分
+  let decimalNum; // 金额小数部分
+  let chineseStr = ''; // 输出的中文金额字符串
+  let parts; // 分离金额后用的数组，预定义
+  money = parseFloat(money).toString();
+
+  if (money === '0') {
+    chineseStr = cnNums[0] + cnIntLast + cnInteger;
+    return chineseStr;
+  }
+  // 转换为字符串
+  money = money.toString();
+  if (money.indexOf('.') === -1) {
+    integerNum = money;
+    decimalNum = '';
+  } else {
+    parts = money.split('.');
+    integerNum = parts[0];
+    decimalNum = parts[1].substr(0, 4);
+  }
+  // 获取整型部分转换
+  if (parseInt(integerNum, 10) > 0) {
+    let zeroCount = 0;
+    const intLen = integerNum.length;
+    for (let i = 0; i < intLen; i += 1) {
+      const n = integerNum.substr(i, 1);
+      const p = intLen - i - 1;
+      const q = p / 4;
+      const m = p % 4;
+      if (n === '0') {
+        zeroCount += 1;
+      } else {
+        if (zeroCount > 0) {
+          chineseStr += cnNums[0];
+        }
+        // 归零
+        zeroCount = 0;
+        chineseStr += cnNums[parseInt(n, 10)] + cnIntRadice[m];
+      }
+      if (m === 0 && zeroCount < 4) {
+        chineseStr += cnIntUnits[q];
+      }
+    }
+    chineseStr += cnIntLast;
+  }
+  // 小数部分
+  if (decimalNum !== '') {
+    const decLen = decimalNum.length;
+    for (let i = 0; i < decLen; i += 1) {
+      const dn = decimalNum.substr(i, 1);
+      if (dn !== '0') {
+        chineseStr += cnNums[Number(dn)] + cnDecUnits[i];
+      }
+    }
+  }
+  if (chineseStr === '') {
+    chineseStr += cnNums[0] + cnIntLast + cnInteger;
+  } else if (decimalNum === '') {
+    chineseStr += cnInteger;
+  }
+  return chineseStr;
+}
+
+/**
+ * 格式化小数位
+ #### 使用说明
+ ```
+ formatFloat('1.2345') 返回 '1.23'
+ formatFloat('1.2345', 3) 返回 '1.235'
+ formatFloat('1', 3) 返回 '1.000'
+ ```
+ * @param {*} val 小数
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function formatFloat(val: string | number, pos = 2): string {
+  let f = parseFloat(String(val));
+  if (Number.isNaN(f)) {
+    return '';
+  }
+  f = Math.round(Number(val) * Math.pow(10, pos)) / Math.pow(10, pos); // pow 幂
+  let s = f.toString();
+  let rs = s.indexOf('.');
+  if (rs < 0) {
+    rs = s.length;
+    s += '.';
+  }
+  while (s.length <= rs + pos) {
+    s += '0';
+  }
+  return s;
+}
+
+/**
+ * 向上取整
+ #### 使用说明
+ ```
+ ceil('1.23') 返回 2
+ ceil('1.234', 2) 返回 1.24
+ ceil('1.230', 2) 返回 1.23
+ ```
+ * @param {*} val
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function ceil(val: string | number, pos = 0) {
+  if (isEmpty(val)) {
+    return val;
+  }
+
+  const swell = Math.pow(10, pos);
+  const swellVal = Number(val) * swell;
+  const newVal = Math.ceil(swellVal) / swell;
+
+  return newVal;
+}
+
+/**
+ * 向下取整
+ #### 使用说明
+ ```
+ floor('1.23') 返回 1
+ floor('1.234', 2) 返回 1.23
+ floor('1.230', 2) 返回 1.23
+ ```
+ * @param {*} val
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function floor(val: string | number, pos = 0) {
+  if (isEmpty(val)) {
+    return val;
+  }
+
+  const swell = Math.pow(10, pos);
+  const swellVal = Number(val) * swell;
+  return Math.floor(swellVal) / swell;
+}

package/src/object/index.ts

@@ -0,0 +1,54 @@
+/**
+ * object处理相关
+ * @packageDocumentation
+ * @module Object
+ * @preferred
+ */
+
+/**
+ * 比较两者的值是否相等
+ #### 使用说明
+ ```
+ deepEqual({a: 10}, {a: 10}) 返回 true
+ deepEqual({a: 10}, {a: 10, b: 20}) 返回 false
+ ```
+ * @param {*} x 用来比较的值
+ * @param {*} y 另一个用来比较的值
+ */
+export function deepEqual(x, y) {
+  const ok = Object.keys,
+    tx = typeof x,
+    ty = typeof y;
+  return x && y && tx === 'object' && tx === ty
+    ? ok(x).length === ok(y).length && ok(x).every(key => deepEqual(x[key], y[key]))
+    : x === y;
+}
+function getNodePath(node, nodeValue, nodeKey, childrenKey, path: any[] = []) {
+  path.push(node);
+  if (node[nodeKey] === nodeValue) {
+    throw 'GOT IT!';
+  }
+  if (node[childrenKey] && node[childrenKey].length > 0) {
+    for (let i = 0; i < node[childrenKey].length; i++) {
+      getNodePath(node[childrenKey][i], nodeValue, nodeKey, childrenKey, path);
+    }
+  }
+  path.pop();
+}
+/**
+ * 查找树结构节点路径
+ * @param {*} nodeValue 节点值
+ * @param {string} nodeKey 节点键
+ * @param {Array} treeArray 树数据
+ * @param {string} children 子集键
+ */
+export function findNodePath(nodeValue, nodeKey, treeArray, childrenKey) {
+  const path: any[] = [];
+  try {
+    for (let i = 0; i < treeArray.length; i++) {
+      getNodePath(treeArray[i], nodeValue, nodeKey, childrenKey, path);
+    }
+  } catch (e) {
+    return path;
+  }
+}