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

package/lib/clamp.js

@@ -1,11 +0,0 @@
-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/lib/classnames.js

@@ -1,17 +0,0 @@
-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/lib/compare/version.js

@@ -1,15 +0,0 @@
-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/lib/compare/weak-equal.js

@@ -1,33 +0,0 @@
-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/lib/convert/json.js

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

package/lib/convert/object.js

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

package/lib/convert/strings.js

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

package/lib/desens.js

@@ -1,51 +0,0 @@
-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/lib/encoding.js

@@ -1,56 +0,0 @@
-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/lib/index.js

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

package/lib/input-regex.js

@@ -1,8 +0,0 @@
-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);
-}
-export {
-  inputRegex
-};

package/lib/is/class.js

@@ -1,22 +0,0 @@
-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*\(/;
-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);
-  }
-  return false;
-};
-export {
-  isClass
-};

package/lib/is/empty.js

@@ -1,5 +0,0 @@
-import { isNull } from "./null";
-const isEmpty = (value) => isNull(value) || value === "";
-export {
-  isEmpty
-};

package/lib/is/key.js

@@ -1,4 +0,0 @@
-const isKey = (key, data) => key in data;
-export {
-  isKey
-};

package/lib/is/null.js

@@ -1,4 +0,0 @@
-const isNull = (value) => value === void 0 || value === null;
-export {
-  isNull
-};

package/lib/load/image.js

@@ -1,11 +0,0 @@
-const loadImage = (src) => {
-  return new Promise((resolve) => {
-    const img = new Image();
-    img.onload = () => resolve(img);
-    img.onerror = () => resolve(null);
-    img.src = src;
-  });
-};
-export {
-  loadImage
-};

package/lib/memory/basic.js

@@ -1,167 +0,0 @@
-import { hash8strings } from "../convert/strings";
-class MemoryBasic {
-  /**
-   * @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;
-  }
-  /**
-   * 返回位于指定索引处的项
-   */
-  at(index) {
-    const { list } = this;
-    if (index < 0) {
-      index += list.length;
-    }
-    return this.list.at(index);
-  }
-  /**
-   * 遍历所有存储数据(按入栈顺序)
-   */
-  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;
-  }
-  /**
-   * some(按入栈顺序)
-   */
-  some(callback) {
-    return this.list.some(callback);
-  }
-  /**
-   * map(按入栈顺序)
-   */
-  map(callback) {
-    return this.list.map(callback);
-  }
-  /**
-   * reduce(按入栈顺序)
-   */
-  reduce(callback, initialValue) {
-    return this.list.reduce(callback, initialValue);
-  }
-  /**
-   * 判断存储是否包含指定类型
-   */
-  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, i) => {
-        if (value >= index) {
-          memory[i] = 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 = hash8strings(this.#reflex(memorys.get(type)));
-    const Memory = this.constructor;
-    const imitator = new Memory(this.key, {
-      mount: this.#mount,
-      reflex: this.#reflex
-    });
-    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();
-  }
-}
-export {
-  MemoryBasic
-};

package/lib/memory/list.js

@@ -1,12 +0,0 @@
-import { MemoryBasic } from "./basic";
-class MemoryList extends MemoryBasic {
-  constructor(key) {
-    super(key, {
-      mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
-      reflex: (reactor) => reactor
-    });
-  }
-}
-export {
-  MemoryList
-};

package/lib/memory/power.js

@@ -1,13 +0,0 @@
-import { deconPowersSum } from "../power/decon";
-import { MemoryBasic } from "./basic";
-class MemoryPower extends MemoryBasic {
-  constructor(key) {
-    super(key, {
-      mount: (index, reactor) => (reactor || 0) + 2 ** index,
-      reflex: (reactor) => deconPowersSum(reactor, "asc")
-    });
-  }
-}
-export {
-  MemoryPower
-};

package/lib/memory/simple.js

@@ -1,94 +0,0 @@
-import { MemoryBasic } from "./basic";
-class MemorySimple {
-  #memory;
-  #key;
-  get size() {
-    return this.#memory.size;
-  }
-  constructor(key) {
-    this.#key = key;
-    this.#memory = new MemoryBasic(key, {
-      mount: (index) => index,
-      reflex: (reactor) => [reactor]
-    });
-  }
-  #getType(data) {
-    const key = this.#key;
-    return typeof key === "function" ? key(data) : data[key];
-  }
-  /**
-   * 返回位于指定索引处的项
-   */
-  at(index) {
-    return this.#memory.at(index);
-  }
-  push(...list) {
-    const memory = this.#memory;
-    list.forEach((data) => {
-      memory.includes(this.#getType(data)) || memory.push(data);
-    });
-    return this;
-  }
-  /**
-   * 获取指定类型存储数据
-   */
-  get(type) {
-    const value = this.#memory.get(type);
-    if (value === null) return value;
-    return value.length ? value[0] : null;
-  }
-  /**
-   * 遍历所有存储数据(按入栈顺序)
-   */
-  forEach(callback) {
-    this.#memory.forEach(callback);
-    return this;
-  }
-  /**
-   * some(按入栈顺序)
-   */
-  some(callback) {
-    return this.#memory.some(callback);
-  }
-  /**
-   * map(按入栈顺序)
-   */
-  map(callback) {
-    return this.#memory.map(callback);
-  }
-  /**
-   * reduce(按入栈顺序)
-   */
-  reduce(callback, initialValue) {
-    return this.#memory.reduce(callback, initialValue);
-  }
-  /**
-   * 判断是否包含指定类型
-   */
-  includes(type) {
-    return this.#memory.includes(type);
-  }
-  /**
-   * 删除指定存储数据
-   */
-  delete(data) {
-    this.#memory.delete(data);
-    return this;
-  }
-  /**
-   * 删除指定类型存储数据
-   */
-  deleteType(type) {
-    this.#memory.deleteType(type);
-    return this;
-  }
-  /**
-   * 清理存储
-   */
-  clear() {
-    this.#memory.clear();
-  }
-}
-export {
-  MemorySimple
-};