@vope/utils 1.4.2 → 1.4.4

package/README.md

@@ -3,26 +3,6 @@
 发布构建
 ```
 
-### cjs
-```
-构建cjs版本
-```
-
-### esm
-```
-构建esm版本
-```
-
-### trove
-```
-构建统一导出入口(即生成src/index.ts文件)
-```
-
-### devs
-```
-构建开发环境工具代码
-```
-
 ### test
 ```
 运行测试用例

package/cjs/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,62 +15,591 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  MemoryBasic: () => import_basic.default,
-  MemoryList: () => import_list.default,
-  MemoryPower: () => import_power.default,
-  Union: () => import_union.default,
-  clamp: () => import_clamp.default,
-  classnames: () => import_classnames.default,
-  compareVersion: () => import_version.default,
-  connectURLParams: () => import_params.default,
-  deconPowersSum: () => import_decon.default,
-  deepWeakEqual: () => import_weak_equal.default,
-  getEncoding: () => import_encoding.default,
-  hash8json: () => import_json.default,
-  hash8object: () => import_object.default,
-  hash8strings: () => import_strings.default,
-  inputRegex: () => import_input_regex.default,
-  isClass: () => import_class.default,
-  isEmpty: () => import_empty.default,
-  isNull: () => import_null.default,
-  joinPaths: () => import_join.default,
-  once: () => import_once.default,
-  rotateAngle: () => import_angle.default,
-  rotateRad: () => import_rad.default,
-  wait: () => import_wait.default
+  FlexTable: () => FlexTable,
+  MemoryBasic: () => MemoryBasic,
+  MemoryList: () => MemoryList,
+  MemoryPower: () => MemoryPower,
+  Union: () => Union,
+  clamp: () => clamp_default,
+  classnames: () => classnames_default,
+  compareVersion: () => version_default,
+  connectURLParams: () => params_default,
+  deconPowersSum: () => decon_default,
+  deepWeakEqual: () => weak_equal_default,
+  getEncoding: () => encoding_default,
+  hash8json: () => json_default,
+  hash8object: () => object_default,
+  hash8strings: () => strings_default,
+  inputRegex: () => input_regex_default,
+  isClass: () => class_default,
+  isEmpty: () => empty_default,
+  isNull: () => null_default,
+  joinPaths: () => join_default,
+  once: () => once_default,
+  rotateAngle: () => angle_default,
+  rotateRad: () => rad_default,
+  wait: () => wait_default
 });
 module.exports = __toCommonJS(src_exports);
-var import_clamp = __toESM(require("./clamp"), 1);
-var import_classnames = __toESM(require("./classnames"), 1);
-var import_version = __toESM(require("./compare/version"), 1);
-var import_weak_equal = __toESM(require("./compare/weak-equal"), 1);
-var import_json = __toESM(require("./convert/json"), 1);
-var import_object = __toESM(require("./convert/object"), 1);
-var import_strings = __toESM(require("./convert/strings"), 1);
-var import_encoding = __toESM(require("./encoding"), 1);
-var import_input_regex = __toESM(require("./input-regex"), 1);
-var import_class = __toESM(require("./is/class"), 1);
-var import_empty = __toESM(require("./is/empty"), 1);
-var import_null = __toESM(require("./is/null"), 1);
-var import_basic = __toESM(require("./memory/basic"), 1);
-var import_list = __toESM(require("./memory/list"), 1);
-var import_power = __toESM(require("./memory/power"), 1);
-var import_once = __toESM(require("./once"), 1);
-var import_decon = __toESM(require("./power/decon"), 1);
-var import_angle = __toESM(require("./rotate/angle"), 1);
-var import_rad = __toESM(require("./rotate/rad"), 1);
-var import_union = __toESM(require("./union"), 1);
-var import_join = __toESM(require("./url/join"), 1);
-var import_params = __toESM(require("./url/params"), 1);
-var import_wait = __toESM(require("./wait"), 1);
+
+// src/clamp.ts
+var clamp_default = (value, min, max) => {
+  if (min > max) {
+    const swap = max;
+    max = min;
+    min = swap;
+  }
+  return Math.min(max, Math.max(min, value));
+};
+
+// src/classnames.ts
+var import_lodash_es = require("lodash-es");
+var add = (a, b) => a ? a + " " + b : b;
+var classnames_default = (...list) => list.reduce((caches, data) => {
+  if ((0, import_lodash_es.isString)(data)) {
+    data && (caches = add(caches, data));
+  } else if (Array.isArray(data)) {
+    data.forEach((value) => value && (0, import_lodash_es.isString)(value) && (caches = add(caches, value)));
+  } else if (!(0, import_lodash_es.isBoolean)(data)) {
+    for (const key in data) {
+      key && data[key] && (caches = add(caches, key));
+    }
+  }
+  return caches;
+}, "");
+
+// src/compare/version.ts
+var CHAR = ".";
+var 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;
+};
+var version_default = compareVersion;
+
+// src/compare/weak-equal.ts
+var 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;
+      }
+    });
+  } 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;
+      }
+    }
+  }
+  return true;
+};
+var weak_equal_default = deepWeakEqual;
+
+// src/convert/json.ts
+var hash8json = (list, key) => list.reduce((caches, data) => {
+  caches[data[key]] = data;
+  return caches;
+}, {});
+var json_default = hash8json;
+
+// src/convert/object.ts
+var hash8object = (list, key) => list.reduce((caches, data) => {
+  caches.set(data[key], data);
+  return caches;
+}, /* @__PURE__ */ new Map());
+var object_default = hash8object;
+
+// src/convert/strings.ts
+var hash8strings = (list) => list.reduce((caches, data, index) => {
+  caches[data] = index;
+  return caches;
+}, {});
+var strings_default = hash8strings;
+
+// src/encoding.ts
+var utf8_first_prefix = /^1{2,}/g;
+var utf8_other_prefix = /^10/;
+var Encodes = {
+  UTF_8: "utf-8",
+  UTF_16LE: "utf-16le",
+  UTF_16BE: "utf-16be",
+  GBK: "gbk"
+};
+var defaults = {
+  utf8: [239, 187, 191]
+};
+var equal = (uint, list) => {
+  if (uint.length !== list.length)
+    return false;
+  return !uint.some((value, index) => value !== list[index]);
+};
+var 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), [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 };
+};
+var encoding_default = getEncoding;
+
+// src/input-regex.ts
+var RE_REGEX = /[$()*+.[?\\^{|]/g;
+var 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);
+}
+var input_regex_default = inputRegex;
+
+// src/is/class.ts
+var re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
+var re_function = /^function\s+[A-Z]/;
+var re_this = /\b\(this\b|\bthis[\.\[]\b/;
+var re_check = /classCallCheck\(this/;
+var re_default = /^function\sdefault_\d+\s*\(/;
+var 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);
+  }
+  return false;
+};
+var class_default = isClass;
+
+// src/is/null.ts
+var isNull = (value) => value === void 0 || value === null;
+var null_default = isNull;
+
+// src/is/empty.ts
+var isEmpty = (value) => null_default(value) || value === "";
+var empty_default = isEmpty;
+
+// src/memory/basic.ts
+var MemoryBasic = class {
+  /**
+   * @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);
+    }
+    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, index2) => {
+        if (value >= index2) {
+          memory[index2] = value - 1;
+        }
+      });
+      if (memory !== target) {
+        let reactor;
+        memory.forEach((count) => {
+          reactor = this.#mount(count, reactor);
+        });
+        memorys.set(type, reactor);
+      }
+    }
+    return this;
+  }
+  /**
+   * 删除指定类型存储数据
+   */
+  deleteType(type) {
+    const { memorys, list } = this;
+    if (!memorys.has(type))
+      return this;
+    const local = strings_default(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);
+    });
+    this.list = imitator.list;
+    this.memorys = imitator.memorys;
+    return this;
+  }
+  /**
+   * 清理存储
+   */
+  clear() {
+    this.list = [];
+    this.memorys.clear();
+  }
+};
+
+// src/memory/list.ts
+var MemoryList = class extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
+      reflex: (reactor) => reactor
+    });
+  }
+};
+
+// src/power/decon.ts
+var ERROR_MESSAGE = {
+  INT: "\u53C2\u6570\u5FC5\u987B\u662F\u6574\u6570",
+  MIN: "\u591A\u4E2A2\u7684\u6B63\u6574\u6570\u5E42(\u4E24\u4E24\u4E0D\u76F8\u7B49)\u4E4B\u548C\u5FC5\u5B9A\u5927\u4E8E\u7B49\u4E8E1"
+};
+var deconPowersSum = (sum, sort) => {
+  if (sum < 1) {
+    throw new Error(ERROR_MESSAGE.MIN);
+  } else if (sum !== Math.floor(sum)) {
+    throw new Error(ERROR_MESSAGE.INT);
+  }
+  const list = [];
+  let cache = sum;
+  while (cache) {
+    const power = Math.log2(cache) ^ 0;
+    list.push(power);
+    cache -= Math.pow(2, power);
+  }
+  return sort === "asc" ? list.reverse() : list;
+};
+var decon_default = deconPowersSum;
+
+// src/memory/power.ts
+var MemoryPower = class extends MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => (reactor || 0) + 2 ** index,
+      reflex: (reactor) => decon_default(reactor, "asc")
+    });
+  }
+};
+
+// src/once.ts
+var once_default = (func, thisArg) => {
+  let local;
+  let inited = false;
+  return (...list) => inited ? local : (inited = true, local = func.apply(thisArg, list));
+};
+
+// src/rotate/rad.ts
+var rotateRad = (from, rad, visit = [0, 0]) => {
+  const x = from[0] - visit[0];
+  const y = from[1] - visit[1];
+  return [
+    x * Math.cos(rad) + y * Math.sin(rad) + visit[0],
+    y * Math.cos(rad) - x * Math.sin(rad) + visit[1]
+  ];
+};
+var rad_default = rotateRad;
+
+// src/rotate/angle.ts
+var rotateAngle = (from, angle, visit) => rad_default(from, angle / 180 * Math.PI, visit);
+var angle_default = rotateAngle;
+
+// src/table/flex.ts
+var FlexTable = class {
+  #data = [];
+  /**
+   * 行数
+   */
+  get rowspan() {
+    return this.#data.length;
+  }
+  /**
+   * 总数据长度
+   */
+  get length() {
+    return this.#data.reduce((length, list) => length + list.length, 0);
+  }
+  constructor() {
+    this.newline();
+  }
+  /**
+   * 创建新行
+   */
+  newline() {
+    this.#data.push([]);
+    return this;
+  }
+  push(value) {
+    const rowspan = this.#data.length;
+    rowspan || this.newline();
+    this.#data[rowspan - 1].push(value);
+    return this;
+  }
+  /**
+   * 替换指定位置的数据
+   * @description 指定位置必需为有效位置
+   */
+  replace(rowspan, colspan, value) {
+    const list = this.#data[rowspan];
+    list && colspan in list && (list[colspan] = value);
+    return this;
+  }
+  /**
+   * 从指定位置开始移除或者替换/添加元素
+   * @description 指定位置必需为有效位置
+   */
+  splice(rowspan, colspan, deleteCount, ...values) {
+    const list = this.#data[rowspan];
+    list && colspan in list && list.splice(colspan, deleteCount, ...values);
+    return this;
+  }
+  pop() {
+    const data = this.#data;
+    const rowspan = data.length;
+    if (!rowspan)
+      return null;
+    const list = data[rowspan - 1];
+    if (list.length) {
+      return list.pop();
+    } else {
+      data.pop();
+      return this.pop();
+    }
+  }
+  /**
+   * 遍历数据
+   */
+  each(callback) {
+    const data = this.#data;
+    outloop:
+      for (let i = 0; i < data.length; i++) {
+        const list = data[i];
+        for (let j = 0; j < list.length; j++) {
+          if (callback(list[j], i, j) === false)
+            break outloop;
+        }
+      }
+  }
+  /**
+   * 反序遍历数据
+   */
+  reverseEach(callback) {
+    const data = this.#data;
+    outloop:
+      for (let i = data.length; i; ) {
+        const list = data[--i];
+        for (let j = list.length; j; ) {
+          if (callback(list[--j], i, j) === false)
+            break outloop;
+        }
+      }
+  }
+  /**
+   * 清空数据
+   */
+  clear() {
+    if (this.#data.length) {
+      this.#data = [];
+    }
+  }
+};
+
+// src/union.ts
+var Union = class {
+  constructor(key, formatter) {
+    this.key = key;
+    this.formatter = formatter;
+  }
+  #data = {};
+  #options = {};
+  get data() {
+    return this.#data;
+  }
+  get options() {
+    return this.#options;
+  }
+  add(data) {
+    const key = data[this.key];
+    const result = this.formatter(data);
+    this.#data[key] = result.data;
+    this.#options[key] = result.option;
+    return this;
+  }
+};
+
+// src/url/join.ts
+var re = /([^:])\/{2,}/g;
+var joinPaths = (...list) => {
+  const { length } = list;
+  if (length === 0)
+    return "";
+  return length === 1 ? list[0] : list.join("/").replace(re, ($0, $1) => `${$1}/`);
+};
+var join_default = joinPaths;
+
+// src/url/params.ts
+var connectURLParams = (url, params, isOpenType) => {
+  if (!params)
+    return url;
+  const list = [];
+  for (const key in params) {
+    const value = params[key];
+    if (value === void 0) {
+      list.push(key);
+    } else if (Array.isArray(value)) {
+      list.push(
+        key + "=" + (isOpenType ? JSON.stringify(value).slice(1, -1) : value.join(","))
+      );
+    } else {
+      list.push(key + "=" + (isOpenType ? JSON.stringify(value) : value.toString()));
+    }
+  }
+  if (!list.length)
+    return url;
+  const caches = list.join("&");
+  return url.includes("?") ? url + "&" + caches : url + "?" + caches;
+};
+var params_default = connectURLParams;
+
+// src/wait.ts
+var wait_default = (delay = 0) => new Promise((resolve) => setTimeout(resolve, delay));

package/lib/clamp.js

@@ -1,5 +1,4 @@
-"use strict";
-export default (value, min, max) => {
+var clamp_default = (value, min, max) => {
   if (min > max) {
     const swap = max;
     max = min;
@@ -7,3 +6,6 @@ export default (value, min, max) => {
   }
   return Math.min(max, Math.max(min, value));
 };
+export {
+  clamp_default as default
+};