@vope/utils 1.3.1 → 1.4.1

package/lib/compare/version.js

@@ -1,19 +1,16 @@
-const CHAR = '.';
-/**
- * 版本号大小比较
- * @description from < to = 1，from === to = 0，from > to = -1
- */
+"use strict";
+const CHAR = ".";
 const compareVersion = (from, to) => {
-    const froms = from.split(CHAR);
-    const tos = to.split(CHAR);
-    for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
-        const fromV = +froms[i] || 0;
-        const toV = +tos[i] || 0;
-        if (fromV > toV)
-            return -1;
-        if (fromV < toV)
-            return 1;
-    }
-    return 0;
+  const froms = from.split(CHAR);
+  const tos = to.split(CHAR);
+  for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
+    const fromV = +froms[i] || 0;
+    const toV = +tos[i] || 0;
+    if (fromV > toV)
+      return -1;
+    if (fromV < toV)
+      return 1;
+  }
+  return 0;
 };
 export default compareVersion;

package/lib/compare/weak-equal.js

@@ -1,39 +1,32 @@
-/**
- * 深度相等性比较(弱比较)
- */
+"use strict";
 const deepWeakEqual = (from, to) => {
-    if (typeof from !== 'object'
-        || from === null
-        || typeof to !== 'object'
-        || to === null)
-        return from === to;
-    if (Array.isArray(from) && Array.isArray(to)) {
-        if (from.length !== to.length)
-            return false;
-        return !from.some((t1, index) => {
-            if (!deepWeakEqual(t1, to[index])) {
-                return true;
-            }
-        });
+  if (typeof from !== "object" || from === null || typeof to !== "object" || to === null)
+    return from === to;
+  if (Array.isArray(from) && Array.isArray(to)) {
+    if (from.length !== to.length)
+      return false;
+    return !from.some((t1, index) => {
+      if (!deepWeakEqual(t1, to[index])) {
+        return true;
+      }
+    });
+  } else {
+    const caches = {};
+    for (const key in from) {
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      } else {
+        caches[key] = key;
+      }
     }
-    else {
-        const caches = {};
-        for (const key in from) {
-            if (!deepWeakEqual(from[key], to[key])) {
-                return false;
-            }
-            else {
-                caches[key] = key;
-            }
-        }
-        for (const key in to) {
-            if (key in caches)
-                continue;
-            if (!deepWeakEqual(from[key], to[key])) {
-                return false;
-            }
-        }
+    for (const key in to) {
+      if (key in caches)
+        continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      }
     }
-    return true;
+  }
+  return true;
 };
 export default deepWeakEqual;

package/lib/convert/json.js

@@ -1,16 +1,6 @@
-/**
- * 对象数组转hash(要求主键值为string|number类型)
- * @example
- *  hash8json(
- *    [
- *      { key: 'a', value: 1 },
- *      { key: 'b', value: 2 }
- *    ],
- *    'key'
- *  ).a.value // 1
- */
+"use strict";
 const hash8json = (list, key) => list.reduce((caches, data) => {
-    caches[data[key]] = data;
-    return caches;
+  caches[data[key]] = data;
+  return caches;
 }, {});
 export default hash8json;

package/lib/convert/object.js

@@ -1,16 +1,6 @@
-/**
- * 对象数组转hash
- * @example
- *  hash8object(
- *    [
- *      { key: String, value: 1 },
- *      { key: Object, value: 2 }
- *    ],
- *    'key'
- *  ).get(Object).value // 2
- */
+"use strict";
 const hash8object = (list, key) => list.reduce((caches, data) => {
-    caches.set(data[key], data);
-    return caches;
-}, new Map());
+  caches.set(data[key], data);
+  return caches;
+}, /* @__PURE__ */ new Map());
 export default hash8object;

package/lib/convert/strings.js

@@ -1,10 +1,6 @@
-/**
- * 字符数组转hash
- * @example
- *  hash8strings(['a', 'b']).a // 0
- */
+"use strict";
 const hash8strings = (list) => list.reduce((caches, data, index) => {
-    caches[data] = index;
-    return caches;
+  caches[data] = index;
+  return caches;
 }, {});
 export default hash8strings;

package/lib/encoding.js

@@ -1,62 +1,55 @@
+"use strict";
 const utf8_first_prefix = /^1{2,}/g;
 const utf8_other_prefix = /^10/;
 const Encodes = {
-    UTF_8: 'utf-8',
-    UTF_16LE: 'utf-16le',
-    UTF_16BE: 'utf-16be',
-    GBK: 'gbk'
+  UTF_8: "utf-8",
+  UTF_16LE: "utf-16le",
+  UTF_16BE: "utf-16be",
+  GBK: "gbk"
 };
 const defaults = {
-    utf8: [0xef, 0xbb, 0xbf],
+  utf8: [239, 187, 191]
 };
 const equal = (uint, list) => {
-    if (uint.length !== list.length)
-        return false;
-    return !uint.some((value, index) => value !== list[index]);
+  if (uint.length !== list.length)
+    return false;
+  return !uint.some((value, index) => value !== list[index]);
 };
-/**
- * 根据文件内容判断文件的编码
- * @param uint 文件内容Uint8Array格式
- * @param limit 用于约束GBK和utf_8的判定上限
- */
 const getEncoding = (uint, limit = 1024) => {
-    let encoding;
-    let offset = 0;
-    if (equal(uint.slice(0, 3), defaults.utf8)) {
-        offset = defaults.utf8.length;
-        encoding = Encodes.UTF_8;
-    }
-    else if (equal(uint.slice(0, 2), [0xff, 0xfe])) {
-        encoding = Encodes.UTF_16LE;
-    }
-    else if (equal(uint.slice(0, 2), [0xfe, 0xff])) {
-        encoding = Encodes.UTF_16BE;
-    }
-    else {
-        let isBreak = false;
-        top: for (let i = 0; i < Math.min(uint.length, limit); i++) {
-            const data = uint[i];
-            if (data < 128)
-                continue;
-            const match = data.toString(2).match(utf8_first_prefix);
-            if (match) {
-                for (let m = 0; m < match[0].length - 1; m++) {
-                    const target = uint[++i];
-                    if (target == void 0 || !utf8_other_prefix.test(target.toString(2))) {
-                        encoding = Encodes.GBK;
-                        isBreak = true;
-                        break top;
-                    }
-                }
-            }
-            else {
-                encoding = Encodes.GBK;
-                isBreak = true;
-                break;
+  let encoding;
+  let offset = 0;
+  if (equal(uint.slice(0, 3), defaults.utf8)) {
+    offset = defaults.utf8.length;
+    encoding = Encodes.UTF_8;
+  } else if (equal(uint.slice(0, 2), [255, 254])) {
+    encoding = Encodes.UTF_16LE;
+  } else if (equal(uint.slice(0, 2), [254, 255])) {
+    encoding = Encodes.UTF_16BE;
+  } else {
+    let isBreak = false;
+    top:
+      for (let i = 0; i < Math.min(uint.length, limit); i++) {
+        const data = uint[i];
+        if (data < 128)
+          continue;
+        const match = data.toString(2).match(utf8_first_prefix);
+        if (match) {
+          for (let m = 0; m < match[0].length - 1; m++) {
+            const target = uint[++i];
+            if (target == void 0 || !utf8_other_prefix.test(target.toString(2))) {
+              encoding = Encodes.GBK;
+              isBreak = true;
+              break top;
             }
+          }
+        } else {
+          encoding = Encodes.GBK;
+          isBreak = true;
+          break;
         }
-        isBreak || (encoding = Encodes.UTF_8);
-    }
-    return { encoding, offset };
+      }
+    isBreak || (encoding = Encodes.UTF_8);
+  }
+  return { encoding, offset };
 };
 export default getEncoding;

package/lib/index.js

@@ -1,24 +1,24 @@
-export { apiPost, apiGet } from './api';
-export { default as clamp } from './clamp';
-export { default as classnames } from './classnames';
-export { default as compareVersion } from './compare/version';
-export { default as deepWeakEqual } from './compare/weak-equal';
-export { default as hash8json } from './convert/json';
-export { default as hash8object } from './convert/object';
-export { default as hash8strings } from './convert/strings';
-export { default as getEncoding } from './encoding';
-export { default as inputRegex } from './input-regex';
-export { default as isClass } from './is/class';
-export { default as isEmpty } from './is/empty';
-export { default as isNull } from './is/null';
-export { default as MemoryBasic } from './memory/basic';
-export { default as MemoryList } from './memory/list';
-export { default as MemoryPower } from './memory/power';
-export { default as once } from './once';
-export { default as deconPowersSum } from './power/decon';
-export { default as rotateAngle } from './rotate/angle';
-export { default as rotateRad } from './rotate/rad';
-export { default as Union } from './union';
-export { default as joinPaths } from './url/join';
-export { default as connectURLParams } from './url/params';
-export { default as wait } from './wait';
+"use strict";
+export { default as clamp } from "./clamp";
+export { default as classnames } from "./classnames";
+export { default as compareVersion } from "./compare/version";
+export { default as deepWeakEqual } from "./compare/weak-equal";
+export { default as hash8json } from "./convert/json";
+export { default as hash8object } from "./convert/object";
+export { default as hash8strings } from "./convert/strings";
+export { default as getEncoding } from "./encoding";
+export { default as inputRegex } from "./input-regex";
+export { default as isClass } from "./is/class";
+export { default as isEmpty } from "./is/empty";
+export { default as isNull } from "./is/null";
+export { default as MemoryBasic } from "./memory/basic";
+export { default as MemoryList } from "./memory/list";
+export { default as MemoryPower } from "./memory/power";
+export { default as once } from "./once";
+export { default as deconPowersSum } from "./power/decon";
+export { default as rotateAngle } from "./rotate/angle";
+export { default as rotateRad } from "./rotate/rad";
+export { default as Union } from "./union";
+export { default as joinPaths } from "./url/join";
+export { default as connectURLParams } from "./url/params";
+export { default as wait } from "./wait";

package/lib/input-regex.js

@@ -1,8 +1,7 @@
+"use strict";
 const RE_REGEX = /[$()*+.[?\\^{|]/g;
 const RE_STRING = /[$()*+.[?\\^{|-]/g;
 function inputRegex(text, flags) {
-    return flags === false
-        ? text.replace(RE_STRING, ($0) => '\\' + $0)
-        : new RegExp(text.replace(RE_REGEX, ($0) => '\\' + $0), flags);
+  return flags === false ? text.replace(RE_STRING, ($0) => "\\" + $0) : new RegExp(text.replace(RE_REGEX, ($0) => "\\" + $0), flags);
 }
 export default inputRegex;

package/lib/is/class.js

@@ -1,30 +1,27 @@
+"use strict";
 const re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
 const re_function = /^function\s+[A-Z]/;
 const re_this = /\b\(this\b|\bthis[\.\[]\b/;
 const re_check = /classCallCheck\(this/;
 const re_default = /^function\sdefault_\d+\s*\(/;
-/**
- * 检测是否为class
- */
 const isClass = (value, strict = true) => {
-    if (typeof value !== 'function')
-        return false;
-    const proto = value.prototype;
-    if (!proto || proto.constructor !== value)
-        return false;
-    const str = value.toString();
-    if (str.slice(0, 5) === 'class'
-        || Object.getOwnPropertyNames(proto).length >= 2)
-        return true;
-    if (re_anonymous.test(str))
-        return false;
-    if (strict && re_function.test(str))
-        return true;
-    if (re_this.test(str)) {
-        if (!strict || re_check.test(str))
-            return true;
-        return re_default.test(str);
-    }
+  if (typeof value !== "function")
     return false;
+  const proto = value.prototype;
+  if (!proto || proto.constructor !== value)
+    return false;
+  const str = value.toString();
+  if (str.slice(0, 5) === "class" || Object.getOwnPropertyNames(proto).length >= 2)
+    return true;
+  if (re_anonymous.test(str))
+    return false;
+  if (strict && re_function.test(str))
+    return true;
+  if (re_this.test(str)) {
+    if (!strict || re_check.test(str))
+      return true;
+    return re_default.test(str);
+  }
+  return false;
 };
 export default isClass;

package/lib/is/empty.js

@@ -1,7 +1,4 @@
-import isNull from './null';
-/**
- * 检测是否为空(undefined/null/'')
- */
-const isEmpty = (value) => isNull(value)
-    || value === '';
+"use strict";
+import isNull from "./null";
+const isEmpty = (value) => isNull(value) || value === "";
 export default isEmpty;

package/lib/is/null.js

@@ -1,6 +1,3 @@
-/**
- * 检测是否无值(undefined/null)
- */
-const isNull = (value) => value === void 0
-    || value === null;
+"use strict";
+const isNull = (value) => value === void 0 || value === null;
 export default isNull;

package/lib/memory/basic.js

@@ -1,142 +1,136 @@
-import hash8strings from '../convert/strings';
-/**
- * 分类存储(通过继承，可用于拓展存储方式)
- */
+"use strict";
+import hash8strings from "../convert/strings";
 export default class MemoryBasic {
-    key;
-    #mount;
-    #reflex;
-    list = [];
-    memorys = new Map();
-    /**
-     * 返回存储长度
-     */
-    get size() {
-        return this.list.length;
+  /**
+   * @param key 用于对数据进行分类的key
+   * @param config 
+   */
+  constructor(key, config) {
+    this.key = key;
+    this.#mount = config.mount;
+    this.#reflex = config.reflex;
+  }
+  #mount;
+  #reflex;
+  list = [];
+  memorys = /* @__PURE__ */ new Map();
+  /**
+   * 返回存储长度
+   */
+  get size() {
+    return this.list.length;
+  }
+  getType(data) {
+    const { key } = this;
+    return typeof key === "function" ? key(data) : data[key];
+  }
+  push(...list) {
+    const { memorys } = this;
+    list.forEach((data) => {
+      const type = this.getType(data);
+      const memory = memorys.get(type);
+      const index = this.list.push(data) - 1;
+      const result = this.#mount(index, memory);
+      memory === result || memorys.set(type, result);
+    });
+    return this;
+  }
+  /**
+   * 遍历所有存储数据(按入栈顺序)
+   */
+  forEach(callback) {
+    this.list.forEach(callback);
+    return this;
+  }
+  /**
+   * 遍历所有存储类型
+   */
+  forType(callback) {
+    const { memorys, list } = this;
+    for (const [type, memory] of memorys) {
+      const caches = this.#reflex(memory).map((index) => list[index]);
+      callback(caches, type);
     }
-    /**
-     * @param key 用于对数据进行分类的key
-     * @param config
-     */
-    constructor(key, config) {
-        this.key = key;
-        this.#mount = config.mount;
-        this.#reflex = config.reflex;
-    }
-    getType(data) {
-        const { key } = this;
-        return typeof key === 'function' ? key(data) : data[key];
-    }
-    push(...list) {
-        const { memorys } = this;
-        list.forEach((data) => {
-            const type = this.getType(data);
-            const memory = memorys.get(type);
-            const index = this.list.push(data) - 1;
-            const result = this.#mount(index, memory);
-            memory === result || memorys.set(type, result);
-        });
-        return this;
-    }
-    /**
-     * 遍历所有存储数据(按入栈顺序)
-     */
-    forEach(callback) {
-        this.list.forEach(callback);
-        return this;
-    }
-    /**
-     * 遍历所有存储类型
-     */
-    forType(callback) {
-        const { memorys, list } = this;
-        for (const [type, memory] of memorys) {
-            const caches = this.#reflex(memory).map((index) => list[index]);
-            callback(caches, type);
-        }
-        return this;
-    }
-    /**
-     * 检测存储是否包含某种类型
-     */
-    includes(type) {
-        return this.memorys.has(type);
-    }
-    /**
-     * 获取指定类型存储数据
-     */
-    get(type) {
-        const memory = this.memorys.get(type);
-        return memory === void 0
-            ? null
-            : this.#reflex(memory).map((count) => this.list[count]);
-    }
-    /**
-     * 删除指定存储数据
-     */
-    delete(data) {
-        const { memorys, list } = this;
-        let index = -1;
-        if (!list.some((value, i) => {
-            if (data === value) {
-                index = i;
-                list.splice(index, 1);
-                const type = this.getType(value);
-                const memory = this.#reflex(memorys.get(type));
-                if (memory.length === 1) {
-                    memorys.delete(type);
-                }
-                else {
-                    memory.some((count, j) => {
-                        if (count === i) {
-                            memory.splice(j, 1);
-                            return true;
-                        }
-                    });
-                }
-                return true;
-            }
-        }))
-            return this;
-        for (const [type, target] of memorys) {
-            const memory = this.#reflex(target);
-            memory.forEach((value, index) => {
-                if (value >= index) {
-                    memory[index] = value - 1;
-                }
-            });
-            if (memory !== target) {
-                let reactor;
-                memory.forEach((count) => {
-                    reactor = this.#mount(count, reactor);
-                });
-                memorys.set(type, reactor);
+    return this;
+  }
+  /**
+   * 检测存储是否包含某种类型
+   */
+  includes(type) {
+    return this.memorys.has(type);
+  }
+  /**
+   * 获取指定类型存储数据
+   */
+  get(type) {
+    const memory = this.memorys.get(type);
+    return memory === void 0 ? null : this.#reflex(memory).map((count) => this.list[count]);
+  }
+  /**
+   * 删除指定存储数据
+   */
+  delete(data) {
+    const { memorys, list } = this;
+    let index = -1;
+    if (!list.some((value, i) => {
+      if (data === value) {
+        index = i;
+        list.splice(index, 1);
+        const type = this.getType(value);
+        const memory = this.#reflex(memorys.get(type));
+        if (memory.length === 1) {
+          memorys.delete(type);
+        } else {
+          memory.some((count, j) => {
+            if (count === i) {
+              memory.splice(j, 1);
+              return true;
             }
+          });
         }
-        return this;
-    }
-    /**
-     * 删除指定类型存储数据
-     */
-    deleteType(type) {
-        const { memorys, list } = this;
-        if (!memorys.has(type))
-            return this;
-        const local = hash8strings(this.#reflex(memorys.get(type)));
-        const Memory = this.constructor;
-        const imitator = new Memory(this.key);
-        list.forEach((data, index) => {
-            index in local || imitator.push(data);
+        return true;
+      }
+    }))
+      return this;
+    for (const [type, target] of memorys) {
+      const memory = this.#reflex(target);
+      memory.forEach((value, index2) => {
+        if (value >= index2) {
+          memory[index2] = value - 1;
+        }
+      });
+      if (memory !== target) {
+        let reactor;
+        memory.forEach((count) => {
+          reactor = this.#mount(count, reactor);
         });
-        this.list = imitator.list;
-        this.memorys = imitator.memorys;
-        return this;
-    }
-    /**
-     * 清理存储
-     */
-    clear() {
-        this.list = [];
-        this.memorys.clear();
+        memorys.set(type, reactor);
+      }
     }
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    const { memorys, list } = this;
+    if (!memorys.has(type))
+      return this;
+    const local = hash8strings(this.#reflex(memorys.get(type)));
+    const Memory2 = this.constructor;
+    const imitator = new Memory2(this.key);
+    list.forEach((data, index) => {
+      index in local || imitator.push(data);
+    });
+    this.list = imitator.list;
+    this.memorys = imitator.memorys;
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.list = [];
+    this.memorys.clear();
+  }
 }