@vope/utils 1.6.0-bate.2 → 1.6.0-bate.4

package/dist/clamp.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 获取中间数
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;

package/dist/clamp.mjs

@@ -0,0 +1,11 @@
+const clamp = (value, min, max) => {
+  if (min > max) {
+    const swap = max;
+    max = min;
+    min = swap;
+  }
+  return Math.min(max, Math.max(min, value));
+};
+export {
+  clamp
+};

package/dist/classnames.d.ts

@@ -0,0 +1,7 @@
+type Base = string | boolean | undefined | null;
+type Item = Base | Base[] | Record<string, boolean>;
+/**
+ * 拼接多个class
+ */
+export declare const classnames: (...list: Item[]) => string;
+export {};

package/dist/classnames.mjs

@@ -0,0 +1,17 @@
+import { isBoolean, isString } from "lodash-es";
+const add = (a, b) => a ? a + " " + b : b;
+const classnames = (...list) => list.reduce((caches, data) => {
+  if (isString(data)) {
+    data && (caches = add(caches, data));
+  } else if (Array.isArray(data)) {
+    data.forEach((value) => value && isString(value) && (caches = add(caches, value)));
+  } else if (!isBoolean(data)) {
+    for (const key in data) {
+      key && data[key] && (caches = add(caches, key));
+    }
+  }
+  return caches;
+}, "");
+export {
+  classnames
+};

package/dist/compare/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 版本号大小比较
+ * @description from < to = 1，from === to = 0，from > to = -1
+ */
+export declare const compareVersion: (from: string, to: string) => 0 | 1 | -1;

package/dist/compare/version.mjs

@@ -0,0 +1,15 @@
+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;
+};
+export {
+  compareVersion
+};

package/dist/compare/weak-equal.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 深度相等性比较(弱比较)
+ */
+export declare const deepWeakEqual: <A, B>(from: A, to: B, exclude?: Extract<keyof A | keyof B, string | number>[]) => boolean;

package/dist/compare/weak-equal.mjs

@@ -0,0 +1,33 @@
+import { hash8strings } from "../convert/strings";
+const deepWeakEqual = (from, to, exclude) => {
+  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 = {};
+    const excludeCaches = exclude && hash8strings(exclude);
+    for (const key in from) {
+      if (excludeCaches && key in excludeCaches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      } else {
+        caches[key] = key;
+      }
+    }
+    for (const key in to) {
+      if (excludeCaches && key in excludeCaches || key in caches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+export {
+  deepWeakEqual
+};

package/dist/convert/json.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 对象数组转hash(要求主键值为string|number类型)
+ * @example
+ *  hash8json(
+ *    [
+ *      { key: 'a', value: 1 },
+ *      { key: 'b', value: 2 }
+ *    ],
+ *    'key'
+ *  ).a.value // 1
+ */
+export declare const hash8json: <K extends string | symbol, T extends Record<K, string | number>>(list: T[], key: K) => Record<T[K], T>;

package/dist/convert/json.mjs

@@ -0,0 +1,7 @@
+const hash8json = (list, key) => list.reduce((caches, data) => {
+  caches[data[key]] = data;
+  return caches;
+}, {});
+export {
+  hash8json
+};

package/dist/convert/object.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 对象数组转hash
+ * @example
+ *  hash8object(
+ *    [
+ *      { key: String, value: 1 },
+ *      { key: Object, value: 2 }
+ *    ],
+ *    'key'
+ *  ).get(Object).value // 2
+ */
+export declare const hash8object: <K extends string | symbol, T extends Record<K, unknown>>(list: T[], key: K) => Map<T[K], T>;

package/dist/convert/object.mjs

@@ -0,0 +1,7 @@
+const hash8object = (list, key) => list.reduce((caches, data) => {
+  caches.set(data[key], data);
+  return caches;
+}, /* @__PURE__ */ new Map());
+export {
+  hash8object
+};

package/dist/convert/strings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 字符数组转hash
+ * @example
+ *  hash8strings(['a', 'b']).a // 0
+ */
+export declare const hash8strings: <T extends string | number>(list: T[]) => { [P in T]: number; };

package/dist/convert/strings.mjs

@@ -0,0 +1,7 @@
+const hash8strings = (list) => list.reduce((caches, data, index) => {
+  caches[data] = index;
+  return caches;
+}, {});
+export {
+  hash8strings
+};

package/dist/desens.d.ts

@@ -0,0 +1,40 @@
+interface Rule {
+    /** 加密的开始(包含)和结束(包含)位置(位置信息基于明文) */
+    range: [number, number];
+}
+export interface DesensDecrypt extends Rule {
+    /** 密文长度 */
+    modify: number;
+}
+export interface DesensEncrypt extends Rule {
+    /** 密文 */
+    ciphertext: string;
+}
+/**
+ * 脱敏加密(对明文进行多个片段加密)
+ * @param plaintext 明文
+ * @param encrypt 加密方法
+ * @returns 解密要素
+ */
+export declare const desensEncrypt: (plaintext: string, encrypt: (plaintext: string) => DesensEncrypt[]) => {
+    ciphertext: string;
+    rules: DesensDecrypt[];
+};
+/**
+ * 脱敏解密(对密文进行多个片段解密)
+ * @param ciphertext 密文
+ * @param rules 解密要素
+ * @param decrypt 解密方法
+ */
+export declare const desensDecrypt: (ciphertext: string, rules: DesensDecrypt | DesensDecrypt[], decrypt: (ciphertext: string) => string) => string;
+type Replacer = string | {
+    [Symbol.replace](text: string, size: number): string;
+};
+/**
+ * 脱敏平替
+ * @param plaintext 密文
+ * @param rules 解密要素
+ * @param replacer 替换者
+ */
+export declare const desensReplace: (ciphertext: string, rules: DesensDecrypt | DesensDecrypt[], replacer?: Replacer) => string;
+export {};

package/dist/desens.mjs

@@ -0,0 +1,51 @@
+import { isString } from "lodash-es";
+const desensEncrypt = (plaintext, encrypt) => {
+  const rules = [];
+  let point = -1;
+  let ciphertext = encrypt(plaintext).reduce((cache, { range, ciphertext: ciphertext2 }) => {
+    cache += plaintext.slice(point + 1, range[0]) + ciphertext2;
+    point = range[1];
+    rules.push({
+      range,
+      modify: ciphertext2.length
+    });
+    return cache;
+  }, "");
+  if (point !== -1) {
+    ciphertext += plaintext.slice(point + 1);
+  }
+  return {
+    ciphertext,
+    rules
+  };
+};
+const desensDecrypt = (ciphertext, rules, decrypt) => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    cache += ciphertext.slice(from, start + offset) + decrypt(ciphertext.slice(start + offset, start + offset + modify));
+    from = start + offset + modify;
+    offset += modify - (stop + 1 - start);
+    return cache;
+  }, "") + ciphertext.slice(from);
+};
+const desensReplace = (ciphertext, rules, replacer = "*") => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    const part = ciphertext.slice(start + offset, start + offset + modify);
+    const size = stop + 1 - start;
+    const replaceValue = isString(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    cache += ciphertext.slice(from, start + offset) + replaceValue;
+    from = start + offset + modify;
+    offset += modify - size;
+    return cache;
+  }, "") + ciphertext.slice(from);
+};
+export {
+  desensDecrypt,
+  desensEncrypt,
+  desensReplace
+};

package/dist/encoding.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 根据文件内容判断文件的编码
+ * @param uint 文件内容Uint8Array格式
+ * @param limit 用于约束GBK和utf_8的判定上限
+ */
+export declare const getEncoding: (uint: Uint8Array, limit?: number) => {
+    encoding: "utf-8" | "utf-16le" | "utf-16be" | "gbk";
+    offset: number;
+};

package/dist/encoding.mjs

@@ -0,0 +1,56 @@
+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"
+};
+const BOM = {
+  UTF_8: [239, 187, 191],
+  UTF_16LE: [255, 254],
+  UTF_16BE: [254, 255]
+};
+const equal = (uint, list) => {
+  return uint.length === list.length ? !uint.some((value, index) => value !== list[index]) : false;
+};
+const getEncoding = (uint, limit = 1024) => {
+  let encoding;
+  let offset = 0;
+  for (const key in BOM) {
+    const head = BOM[key];
+    if (equal(uint.slice(0, head.length), head)) {
+      offset = head.length;
+      encoding = Encodes[key];
+      break;
+    }
+  }
+  if (!encoding) {
+    let isBreak = false;
+    top:
+      for (let i = 0, max = Math.min(uint.length, limit); i < max; 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 };
+};
+export {
+  getEncoding
+};

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { clamp } from './clamp';
+export { classnames } from './classnames';
+export { compareVersion } from './compare/version';
+export { deepWeakEqual } from './compare/weak-equal';
+export { hash8json } from './convert/json';
+export { hash8object } from './convert/object';
+export { hash8strings } from './convert/strings';
+export { type DesensDecrypt, type DesensEncrypt, desensEncrypt, desensDecrypt, desensReplace } from './desens';
+export { getEncoding } from './encoding';
+export { inputRegex } from './input-regex';
+export { isClass } from './is/class';
+export { isEmpty } from './is/empty';
+export { isKey } from './is/key';
+export { isNull } from './is/null';
+export { loadImage } from './load/image';
+export { MemoryBasic } from './memory/basic';
+export { MemoryList } from './memory/list';
+export { MemoryPower } from './memory/power';
+export { MemorySimple } from './memory/simple';
+export { default as Neo4jAhchors } from './neo4j-anchors';
+export { default as Neo4j } from './neo4j';
+export { once } from './once';
+export { parseNum } from './parse/num';
+export { deconPowersSum } from './power/decon';
+export { rotateAngle } from './rotate/angle';
+export { rotateRad } from './rotate/rad';
+export { type Serializes, cubeURLParams, flatURLParams } from './serialize/url-params';
+export { type CSSProperties, type StyleValue, css } from './style/css';
+export { type SModel, default as Subscriber } from './subscriber';
+export { FlexTable } from './table/flex';
+export { Union } from './union';
+export { joinPaths } from './url/join';
+export { connectURLParams } from './url/params';
+export { wait } from './wait';