@vope/utils 1.6.0-bate.5 → 1.6.0-bate.7

package/dist/input-regex.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var input_regex_exports = {};
+__export(input_regex_exports, {
+  inputRegex: () => inputRegex
+});
+module.exports = __toCommonJS(input_regex_exports);
+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);
+}

package/dist/is/class.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var class_exports = {};
+__export(class_exports, {
+  isClass: () => isClass
+});
+module.exports = __toCommonJS(class_exports);
+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;
+};

package/dist/is/empty.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var empty_exports = {};
+__export(empty_exports, {
+  isEmpty: () => isEmpty
+});
+module.exports = __toCommonJS(empty_exports);
+var import_null = require("./null");
+const isEmpty = (value) => (0, import_null.isNull)(value) || value === "";

package/dist/is/key.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var key_exports = {};
+__export(key_exports, {
+  isKey: () => isKey
+});
+module.exports = __toCommonJS(key_exports);
+const isKey = (key, data) => key in data;

package/dist/is/null.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var null_exports = {};
+__export(null_exports, {
+  isNull: () => isNull
+});
+module.exports = __toCommonJS(null_exports);
+const isNull = (value) => value === void 0 || value === null;

package/dist/load/image.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var image_exports = {};
+__export(image_exports, {
+  loadImage: () => loadImage
+});
+module.exports = __toCommonJS(image_exports);
+const loadImage = (src) => {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = src;
+  });
+};

package/dist/memory/basic.js

@@ -0,0 +1,187 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_exports = {};
+__export(basic_exports, {
+  MemoryBasic: () => MemoryBasic
+});
+module.exports = __toCommonJS(basic_exports);
+var import_strings = require("../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 = (0, import_strings.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();
+  }
+}

package/dist/memory/list.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var list_exports = {};
+__export(list_exports, {
+  MemoryList: () => MemoryList
+});
+module.exports = __toCommonJS(list_exports);
+var import_basic = require("./basic");
+class MemoryList extends import_basic.MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
+      reflex: (reactor) => reactor
+    });
+  }
+}

package/dist/memory/power.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var power_exports = {};
+__export(power_exports, {
+  MemoryPower: () => MemoryPower
+});
+module.exports = __toCommonJS(power_exports);
+var import_decon = require("../power/decon");
+var import_basic = require("./basic");
+class MemoryPower extends import_basic.MemoryBasic {
+  constructor(key) {
+    super(key, {
+      mount: (index, reactor) => (reactor || 0) + 2 ** index,
+      reflex: (reactor) => (0, import_decon.deconPowersSum)(reactor, "asc")
+    });
+  }
+}

package/dist/memory/simple.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var simple_exports = {};
+__export(simple_exports, {
+  MemorySimple: () => MemorySimple
+});
+module.exports = __toCommonJS(simple_exports);
+var import_basic = require("./basic");
+class MemorySimple {
+  #memory;
+  #key;
+  get size() {
+    return this.#memory.size;
+  }
+  constructor(key) {
+    this.#key = key;
+    this.#memory = new import_basic.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();
+  }
+}

package/dist/memory/type.d.ts

@@ -0,0 +1,11 @@
+import { GetGivenProps } from '@vope/types'
+
+export namespace Memory { 
+  type Type = string | number | symbol
+
+  type Pitch<Data, Type> = (
+    Data extends object
+      ? GetGivenProps<Data, Type>
+      : never
+  ) | ((data: Data) => Type)
+}