@vope/utils 1.6.7 → 1.7.0

package/dist/async-lock.d.ts

@@ -0,0 +1,27 @@
+interface Bean {
+    get(): boolean;
+    set(value: boolean): void;
+}
+interface Accessor {
+    get value(): boolean;
+    set value(value: boolean);
+}
+interface Options<V> {
+    /**
+     * 满足验证的值将开启锁
+     */
+    validate?: V | ((data: V) => boolean);
+    /**
+     * 锁状态
+     */
+    sp?: Bean | Accessor;
+}
+/**
+ * 异步锁
+ */
+declare const _default: <const T extends unknown[], V extends unknown>(callback: (...args: T) => Promise<V>, { validate, sp, }?: Options<V>) => {
+    readonly spin: boolean;
+    callback(...args: T): Promise<V>;
+    unlock(): void;
+};
+export default _default;

package/dist/async-lock.js

@@ -0,0 +1,40 @@
+import { isBoolean, isFunction } from "lodash-es";
+const isAccessor = (sp) => {
+  return sp !== void 0 && "value" in sp && isBoolean(sp.value);
+};
+var async_lock_default = (callback, {
+  validate,
+  sp = { value: false }
+} = {}) => {
+  const isA = isAccessor(sp);
+  const getter = () => isA ? sp.value : sp.get();
+  const setter = (value) => isA ? sp.value = value : sp.set(value);
+  let lock = false;
+  let local;
+  return {
+    get spin() {
+      return getter();
+    },
+    async callback(...args) {
+      if (getter() || lock) return local;
+      setter(true);
+      local = callback(...args).then((result) => {
+        if (isFunction(validate)) {
+          lock = validate(result);
+        } else if (validate !== void 0) {
+          lock = validate === result;
+        }
+        return result;
+      });
+      await local;
+      setter(false);
+      return local;
+    },
+    unlock() {
+      lock = false;
+    }
+  };
+};
+export {
+  async_lock_default as default
+};

package/dist/calc.d.ts

@@ -1,16 +1,27 @@
 type Ls = `${string}(${string})` | `${number}${string}` | `-${number}${string}`;
-type Lv = Ls | number;
 export declare namespace Calc {
-    type Value = Lv;
+    type Value = Ls | number;
     interface Clamp {
-        min?: Lv;
-        max?: Lv;
+        min?: Value;
+        max?: Value;
     }
 }
+/**
+ * 判断一个值是否为 calc 表达式
+ */
 export declare const isCalc: (value: Ls) => value is `calc(${string})`;
+/**
+ * CSS 长度值加减混合运算
+ */
 declare const calc: {
-    (...list: Lv[]): 0 | Ls;
-    formatter: (value: Lv) => 0 | Ls;
-    clamp(value: Lv, { min, max }: Calc.Clamp): Ls | 0;
+    (...list: Calc.Value[]): 0 | Ls;
+    getExpMN(value: Ls): string | null;
+    multiply(value: Calc.Value, multiple: number): 0 | Ls;
+    divide(value: Calc.Value, divisor: number): 0 | Ls;
+    /**
+     * CSS 长度值格式化
+     */
+    formatter: (value: Calc.Value) => 0 | Ls;
+    clamp(value: Calc.Value, { min, max }: Calc.Clamp): 0 | Ls;
 };
 export default calc;

package/dist/calc.js

@@ -1,9 +1,20 @@
 import { isNumber } from "lodash-es";
 const { parseFloat } = Number;
-const formatter = (value) => isNumber(value) ? value && `${value}px` : value;
-const isCalc = (value) => value.slice(0, 5) === "calc(" && value.slice(-1) === ")";
-const re_numerical = /^(-?(?:\.\d+|\d+(?:\.\d+)?))([a-zA-Z]+|%)$/;
+const re_numerical = /^(-?(?:\.\d+|\d+(?:\.\d+)?)(?:e\d+)?)([a-zA-Z]+|%)$/;
 const re_zero = /^0[a-zA-Z]+$/;
+const re_method_start = /[a-z]/i;
+const re_method_next = /^\w*\(/;
+const formatter = (value) => {
+  if (isNumber(value)) {
+    return value && `${value}px`;
+  }
+  const matchs = value.match(re_numerical) || (isCalc(value) ? value.slice(5, -1).match(re_numerical) : null);
+  if (matchs) {
+    return matchs[1] === "0" ? 0 : matchs[1] + matchs[2];
+  }
+  return value;
+};
+const isCalc = (value) => value.slice(0, 5) === "calc(" && value.slice(-1) === ")";
 class Memory {
   data = {};
   memory = {};
@@ -44,6 +55,7 @@ const calc = (...list) => {
   if (size === 1) return formatter(list[0]);
   const manager = new Manager();
   list.forEach((value2, index) => manager.push(value2, index));
+  let count = 0;
   const value = list.reduce((caches, _, index) => {
     const data = manager.at(index);
     if (!data || data.value === 0) return caches;
@@ -55,23 +67,81 @@ const calc = (...list) => {
       tmp = value2;
     }
     if (!caches) return tmp;
+    count++;
     return tmp[0] === "-" ? `${caches} - ${tmp.slice(1)}` : `${caches} + ${tmp}`;
   }, "");
-  return !value || re_zero.test(value) ? 0 : `calc(${value})`;
+  return !value ? 0 : count === 0 ? re_zero.test(value) ? 0 : value : `calc(${value})`;
+};
+let exp_max_method_name = null;
+const isMethod = (value) => {
+  if (!re_method_start.test(value)) {
+    exp_max_method_name = null;
+    return false;
+  }
+  const matchs = value.slice(1).match(re_method_next);
+  if (!matchs || value.slice(-1) !== ")") {
+    exp_max_method_name = null;
+    return false;
+  }
+  const size = matchs[0].length;
+  let count = 0;
+  for (let i = size + 1; i < value.length - 1; i++) {
+    const c = value[i];
+    if (c === "(") {
+      count++;
+    } else if (c === ")" && count-- === 0) {
+      exp_max_method_name = null;
+      return false;
+    }
+  }
+  if (count === 0) {
+    exp_max_method_name = value.slice(0, size);
+    return true;
+  } else {
+    exp_max_method_name = null;
+    return false;
+  }
+};
+calc.getExpMN = (value) => {
+  isMethod(value);
+  return exp_max_method_name;
+};
+calc.multiply = (value, multiple) => {
+  if (value === 0 || multiple === 0) return 0;
+  if (isNumber(value)) return `${value * multiple}px`;
+  if (multiple === 1) return value;
+  const tmp = formatter(value);
+  if (!tmp) return 0;
+  const matchs = tmp.match(re_numerical);
+  return matchs ? parseFloat(matchs[1]) * multiple + matchs[2] : isCalc(tmp) ? `calc(${tmp.slice(4)} * ${multiple})` : isMethod(tmp) ? `calc(${tmp} * ${multiple})` : `calc((${value}) * ${multiple})`;
+};
+calc.divide = (value, divisor) => {
+  if (divisor === 0) throw new Error("The divisor cannot be 0");
+  if (value === 0) return 0;
+  if (divisor === 1) return formatter(value);
+  const tmp = formatter(value);
+  if (!tmp) return 0;
+  const matchs = tmp.match(re_numerical);
+  return matchs ? parseFloat(matchs[1]) / divisor + matchs[2] : isCalc(tmp) ? `calc(${tmp.slice(4)} / ${divisor})` : isMethod(tmp) ? `calc(${tmp} / ${divisor})` : `calc((${value}) / ${divisor})`;
 };
 calc.formatter = formatter;
 const zero = "0px";
 const u = void 0;
 calc.clamp = (value, { min, max }) => {
-  const val = calc.formatter(value);
+  const val = formatter(value) || zero;
   if (min !== u && max !== u) {
-    return `clamp(${calc.formatter(min) || zero}, ${val || zero}, ${calc.formatter(max) || zero})`;
-  } else if (max !== u) {
-    return `max(${calc.formatter(max) || zero}, ${val || zero})`;
+    min = formatter(min) || zero;
+    max = formatter(max) || zero;
+    return min === max ? max : `clamp(${min}, ${val}, ${max})`;
+  }
+  if (max !== u) {
+    max = formatter(max) || zero;
+    return max === zero ? val : `max(${max}, ${val})`;
   } else if (min !== u) {
-    return `min(${calc.formatter(min) || zero}, ${val || zero})`;
+    min = formatter(min) || zero;
+    return min === val ? val : `min(${min}, ${val})`;
   } else {
-    return val;
+    return val === zero ? 0 : val;
   }
 };
 var calc_default = calc;

package/dist/disable-enumerable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 设置对象属性为不可枚举
+ * @description 适用场景：属性被当做临时过渡值，最终结果不需要出现在展开运算符的结果中
+ * @param data 需要设置的对象
+ * @param key 需要设为不可枚举的属性键
+ */
+declare const _default: <T extends object, K extends keyof T>(data: T, key: K) => void;
+export default _default;

package/dist/disable-enumerable.js

@@ -0,0 +1,13 @@
+var disable_enumerable_default = (data, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(data, key) || {
+    configurable: true,
+    writable: true
+  };
+  Object.defineProperty(data, key, {
+    ...descriptor,
+    enumerable: false
+  });
+};
+export {
+  disable_enumerable_default as default
+};

package/dist/encoding.d.ts

@@ -2,6 +2,7 @@
  * 根据文件内容判断文件的编码
  * @param uint 文件内容Uint8Array格式
  * @param limit 用于约束GBK和utf_8的判定上限
+ * @description 目前支持utf-8、utf-16le、utf-16be、gbk四种编码
  */
 export declare const getEncoding: (uint: Uint8Array, limit?: number) => {
     encoding: "utf-8" | "utf-16le" | "utf-16be" | "gbk";

package/dist/index-sort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 索引排序
+ * @param list 列表
+ * @param key 索引字段
+ */
+declare const _default: <K extends string, T extends { [P in K]: number; }>(list: T[], key: K) => T[];
+export default _default;

package/dist/index-sort.js

@@ -0,0 +1,34 @@
+var index_sort_default = (list, key) => {
+  const { length } = list;
+  if (length < 2) return list;
+  const first = list[0][key];
+  const caches = { [first]: first };
+  let isA = false;
+  let max = first;
+  let min = first;
+  for (let i = 1; i < length; i++) {
+    const value = list[i][key];
+    if (value === Math.trunc(value) && value in caches === false) {
+      if (value > max) {
+        max = value;
+      } else if (value < min) {
+        min = value;
+      }
+      caches[value] = value;
+    } else {
+      isA = true;
+      break;
+    }
+  }
+  if (!isA && max - min === length - 1) {
+    return list.reduce((cache, data) => {
+      cache[data[key] - min] = data;
+      return cache;
+    }, []);
+  } else {
+    return list.sort((a, b) => a[key] - b[key]);
+  }
+};
+export {
+  index_sort_default as default
+};