@deot/helper-utils 1.0.1

package/README.md

@@ -0,0 +1,33 @@
+# @deot/helper-utils
+
+### `Utils`
+```js
+import * as Utils from '@deot/helper-utils';
+
+// or
+import { Utils } from '@deot/helper';
+
+```
+
+| 方法                                                                 | 说明                |
+| ------------------------------------------------------------------ | ----------------- |
+| [asterisk][./src/asterisk.ts]                                      | 文字加`*`            |
+| [autoCatch][./src/auto-catch.ts]                                   | 捕获异常              |
+| [canvasToImage][./src/canvas-to-image.ts]                          | 转图片信息             |
+| [cloneDeepEasier][./src/clone-deep-easier.ts]                      | 深拷贝               |
+| [compressImage][./src/compress-image.ts]                           | 压缩图片              |
+| [dataURLToFile][./src/dataURL-to-file.ts]                          | base64转文件         |
+| [debounce][./src/debounce.ts]                                      | 防抖                |
+| [def][./src/def.ts]                                                | 定义                |
+| [flattenDecodeURIComponent][./src/flatten-decode-uri-component.ts] | 深度解码              |
+| [flattenJSONParse][./src/flatten-json-parse.ts]                    | 深度反序列化            |
+| [getPropByPath][./src/get-prop-by-path.ts]                         | 根据路径找值            |
+| [getUid][./src/get-uid.ts]                                         | 生成唯一id            |
+| [hasOwn][./src/has-own.ts]                                         | 是否在原型上            |
+| [isObj][./src/is-obj.ts]                                           | 是否对象              |
+| [numberToUnit][./src/number-to-unit.ts]                            | 大数据转成中文单位         |
+| [preZero][./src/pre-zero.ts]                                       | 加零                |
+| [raf][./src/raf.ts]                                                | raf               |
+| [random][./src/random.ts]                                          | `range` 和 `probs` |
+| [sleep][./src/sleep.ts]                                            | 等待                |
+| [throttle][./src/throttle.ts]                                      | 节流                |

package/dist/index.cjs.js

@@ -0,0 +1,368 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const asterisk = (value, from, length) => {
+  from = from || 3;
+  length = length || 4;
+  let repeat = length;
+  let content = value.substring(0, from);
+  while (repeat) {
+    content += "*";
+    repeat--;
+  }
+  content += value.substring(from + length);
+  return content;
+};
+
+const autoCatch = async (impl, options = {}) => {
+  const { onError = console.error } = options;
+  let target = impl;
+  typeof target === "function" && (target = target());
+  try {
+    const e = await target;
+    return e;
+  } catch (e) {
+    onError(e);
+  }
+};
+
+const getMime = (filename) => {
+  let ext;
+  if (typeof filename === "string" && filename.includes(".")) {
+    ext = filename.split(".").pop();
+  }
+  return ext ? `image/${ext}` : "image/jpeg";
+};
+const dataURLToFile = (dataURL, filename, filetype) => {
+  const hasPrefix = /data:[^;]+;[^,]+,/g.test(dataURL);
+  if (!hasPrefix) {
+    dataURL = `data:${filetype || getMime(filename)};base64,${dataURL}`;
+  }
+  let [suffix, dataURL$] = dataURL.split(",");
+  let mime = suffix.match(/:(.*?);/)?.[1];
+  let bstr = window.atob(dataURL$);
+  let n = bstr.length;
+  let u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new File([u8arr], filename || "__filename", { type: mime });
+};
+
+const canvasToImage = (canvas, filename) => {
+  const dataURL = canvas.toDataURL("image/png");
+  return new Promise((resolve) => {
+    let result = {
+      dataURL
+    };
+    if (typeof filename === "string") {
+      result.file = dataURLToFile(dataURL, filename);
+    }
+    resolve(result);
+  });
+};
+
+const cloneDeepEasier = (source) => JSON.parse(JSON.stringify(source));
+
+const compressImage = (file, options) => {
+  const { width, height, filetype = "image/jpeg", encoderOptions } = options || {};
+  return new Promise((resolve, reject) => {
+    const el = new Image();
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = (e) => {
+      el.src = e.target.result;
+    };
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    el.onload = () => {
+      const originWidth = el.width;
+      const originHeight = el.height;
+      const maxWidth = width || originWidth;
+      const maxHeight = height || originHeight;
+      let targetWidth = originWidth;
+      let targetHeight = originHeight;
+      if (originWidth > maxWidth || originHeight > maxHeight) {
+        if (originWidth / originHeight > maxWidth / maxHeight) {
+          targetWidth = maxWidth;
+          targetHeight = Math.round(maxWidth * (originHeight / originWidth));
+        } else {
+          targetHeight = maxHeight;
+          targetWidth = Math.round(maxHeight * (originWidth / originHeight));
+        }
+      }
+      canvas.width = targetWidth;
+      canvas.height = targetHeight;
+      context.clearRect(0, 0, targetWidth, targetHeight);
+      context.drawImage(el, 0, 0, targetWidth, targetHeight);
+      const dataURL = canvas.toDataURL(filetype, encoderOptions);
+      const compressFile = dataURLToFile(dataURL, file.name);
+      resolve({
+        dataURL,
+        file: compressFile
+      });
+    };
+    el.onerror = (e) => {
+      reject(e);
+    };
+  });
+};
+
+const debounce = (original, wait, options) => {
+  const { leading, trailing = true, throttle } = options || {};
+  let timer;
+  let invoke;
+  let cancel = () => {
+    timer && clearTimeout(timer);
+    timer = null;
+  };
+  let start = () => {
+    timer = setTimeout(() => {
+      timer = null;
+      trailing && invoke && invoke();
+    }, wait);
+  };
+  const fn = function(...args) {
+    invoke = () => {
+      original.apply(this, args);
+      invoke = null;
+    };
+    if (!wait && throttle)
+      return invoke();
+    if (!timer) {
+      leading && invoke();
+      start();
+    } else if (!throttle) {
+      cancel();
+      start();
+    }
+  };
+  fn.cancel = () => {
+    cancel();
+    invoke = null;
+  };
+  fn.flush = () => {
+    cancel();
+    trailing && invoke && invoke();
+  };
+  return fn;
+};
+
+const def = (target, key, value, options) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: true,
+    configurable: true,
+    ...options
+  });
+};
+
+const getPropByPath = (target, path) => {
+  let o = target;
+  path = path.replace(/\[(\w+)\]/g, ".$1");
+  path = path.replace(/^\./, "");
+  let keyArr = path.split(".");
+  let i = 0;
+  for (let len = keyArr.length; i < len - 1; ++i) {
+    let key = keyArr[i];
+    try {
+      if (key in o) {
+        o = o[key];
+      } else {
+        throw new Error();
+      }
+    } catch {
+      throw new Error("无效路径!");
+    }
+  }
+  return {
+    o,
+    k: keyArr[i],
+    v: o[keyArr[i]]
+  };
+};
+
+const timestamp = +/* @__PURE__ */ new Date();
+let index = 0;
+const getUid = (prefix) => {
+  return `${prefix ? `${prefix}-` : ""}${timestamp}-${++index}`;
+};
+
+const hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+
+const isObj = (target) => typeof target === "object";
+
+const getDigit = (integer) => {
+  let digit = -1;
+  while (integer >= 1) {
+    digit++;
+    integer /= 10;
+  }
+  return digit;
+};
+const addWan = (integer, num, mutiple, decimalDigit) => {
+  let digit = getDigit(integer);
+  if (digit > 3) {
+    let remainder = digit % 8;
+    if (remainder >= 5) {
+      remainder = 4;
+    }
+    return Math.round(num / Math.pow(10, remainder + mutiple - decimalDigit)) / Math.pow(10, decimalDigit) + "万";
+  } else {
+    return Math.round(num / Math.pow(10, mutiple - decimalDigit)) / Math.pow(10, decimalDigit) + "";
+  }
+};
+const numberToUnit = (number, decimalDigit) => {
+  if (number > Number.MAX_SAFE_INTEGER) {
+    number = Number.MAX_SAFE_INTEGER;
+  }
+  decimalDigit = decimalDigit == null ? 2 : decimalDigit;
+  let integer = Math.floor(number);
+  let digit = getDigit(integer);
+  let unit = [];
+  if (digit > 3) {
+    let multiple = Math.floor(digit / 8);
+    if (multiple >= 1) {
+      let tmp = Math.round(integer / Math.pow(10, 8 * multiple));
+      unit.push(addWan(tmp, number, 8 * multiple, decimalDigit));
+      for (let i = 0; i < multiple; i++) {
+        unit.push("亿");
+      }
+      return unit.join("");
+    } else {
+      return addWan(integer, number, 0, decimalDigit);
+    }
+  } else {
+    return number;
+  }
+};
+
+const preZero = (num) => {
+  if (num < 10 && num > 0) {
+    return "0" + num;
+  } else if (num <= 0) {
+    return "00";
+  }
+  return "" + num;
+};
+
+const raf = typeof window !== "undefined" && window.requestAnimationFrame || ((fn) => setTimeout(fn, 16));
+
+const range = (min, max) => {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+};
+const probs = (weights) => {
+  let sum = weights.reduce((pre, cur) => pre + (!cur || cur <= 0 ? 0 : cur), 0);
+  if (!sum) {
+    throw new Error("不可能得到索引值");
+  }
+  let probs$ = weights.map((i) => i / sum);
+  let index = 0;
+  let r = Math.random();
+  while (r > 0) {
+    r -= probs$[index];
+    index++;
+  }
+  index--;
+  return index;
+};
+
+const sleep = (wait, immediate) => {
+  let duration;
+  if (typeof wait === "object") {
+    duration = range(wait.min, wait.max);
+  } else {
+    duration = wait || 0;
+  }
+  return new Promise((r) => {
+    let timer = setTimeout(r, duration);
+    immediate && immediate(timer, duration, r);
+  });
+};
+
+const throttle = (original, wait, options) => {
+  const { leading = true, trailing = true } = options || {};
+  return debounce(
+    original,
+    wait,
+    {
+      leading,
+      trailing,
+      throttle: true
+    }
+  );
+};
+
+const flattenDecodeURIComponent = (value) => {
+  let need = true;
+  let safeCount = 1;
+  let parseValue = value;
+  while (need) {
+    if (safeCount > 1e3) {
+      throw new Error(value);
+    }
+    try {
+      let next = decodeURIComponent(parseValue);
+      if (parseValue === next) {
+        need = false;
+      }
+      parseValue = next;
+    } catch {
+      need = false;
+    }
+    safeCount++;
+  }
+  return parseValue;
+};
+
+const flattenJSONParse = (value) => {
+  if (value === null)
+    return null;
+  let regex = /^\d+$/;
+  if (regex.test(value) && value.length >= 16 && +value > Number.MAX_SAFE_INTEGER) {
+    return value;
+  }
+  let need = true;
+  let safeCount = 1;
+  let parseValue = value;
+  while (need) {
+    if (safeCount > 10) {
+      throw new Error(value);
+    }
+    try {
+      let next = JSON.parse(parseValue);
+      if (parseValue === next) {
+        need = false;
+      }
+      parseValue = next;
+    } catch {
+      need = false;
+    }
+    safeCount++;
+  }
+  return parseValue;
+};
+
+exports.asterisk = asterisk;
+exports.autoCatch = autoCatch;
+exports.canvasToImage = canvasToImage;
+exports.cloneDeepEasier = cloneDeepEasier;
+exports.compressImage = compressImage;
+exports.dataURLToFile = dataURLToFile;
+exports.debounce = debounce;
+exports.def = def;
+exports.flattenDecodeURIComponent = flattenDecodeURIComponent;
+exports.flattenJSONParse = flattenJSONParse;
+exports.getPropByPath = getPropByPath;
+exports.getUid = getUid;
+exports.hasOwn = hasOwn;
+exports.isObj = isObj;
+exports.numberToUnit = numberToUnit;
+exports.preZero = preZero;
+exports.probs = probs;
+exports.raf = raf;
+exports.range = range;
+exports.sleep = sleep;
+exports.throttle = throttle;

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+
+export declare const asterisk: (value: string, from?: number, length?: number) => string;
+
+export declare const autoCatch: (impl: any, options?: Record<string, any>) => Promise<any>;
+
+export declare const canvasToImage: (canvas: HTMLCanvasElement, filename?: string) => Promise<Result>;
+
+export declare const cloneDeepEasier: (source: object) => any;
+
+export declare const compressImage: (file: File, options?: CompressOptions) => Promise<{
+    dataURL: string;
+    file: File;
+}>;
+
+export declare interface CompressOptions {
+    width?: number;
+    height?: number;
+    filetype?: string;
+    encoderOptions?: any;
+}
+
+export declare const dataURLToFile: (dataURL: string, filename?: string, filetype?: string) => File;
+
+export declare const debounce: (original: Function, wait?: number, options?: Options) => {
+    (this: any, ...args: any[]): any;
+    cancel(): void;
+    flush(): void;
+};
+
+export declare const def: (target: object, key: PropertyKey, value?: any, options?: PropertyDescriptor) => void;
+
+export declare const flattenDecodeURIComponent: (value: string) => string;
+
+export declare const flattenJSONParse: (value: string | null) => any;
+
+export declare const getPropByPath: (target: object, path: string) => ObjectKeyValue;
+
+export declare const getUid: (prefix?: string) => string;
+
+export declare const hasOwn: (target: object, key: PropertyKey) => boolean;
+
+export declare const isObj: (target?: any) => boolean;
+
+export declare const numberToUnit: (number: number, decimalDigit?: number) => string | number;
+
+declare interface ObjectKeyValue {
+    o: object;
+    k: PropertyKey;
+    v: any;
+}
+
+declare interface Options {
+    leading?: boolean;
+    trailing?: boolean;
+    throttle?: boolean;
+}
+
+declare interface Options_2 {
+    leading?: boolean;
+    trailing?: boolean;
+}
+
+export declare const preZero: (num: number) => string;
+
+export declare const probs: (weights: number[]) => number;
+
+export declare type Raf = (callback: FrameRequestCallback) => number;
+
+export declare const raf: Raf;
+
+export declare const range: (min: number, max: number) => number;
+
+declare interface Result {
+    dataURL: string;
+    file?: File;
+}
+
+export declare const sleep: (wait?: number | {
+    min: number;
+    max: number;
+}, immediate?: ((timer: ReturnType<typeof global.setTimeout>, duration: number, done: Function) => any) | undefined) => Promise<unknown>;
+
+export declare const throttle: (original: Function, wait?: number, options?: Options_2) => {
+    (this: any, ...args: any[]): any;
+    cancel(): void;
+    flush(): void;
+};
+
+export { }