@vope/utils 1.6.0-bate.7 → 1.6.0

package/dist/memory/basic.mjs

@@ -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/dist/memory/list.mjs

@@ -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/dist/memory/power.mjs

@@ -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/dist/memory/simple.mjs

@@ -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
-};

package/dist/neo4j-anchors.mjs

@@ -1,169 +0,0 @@
-import { rotateRad } from "./rotate/rad";
-class Neo4jAhchors {
-  constructor(neo4j, config) {
-    this.neo4j = neo4j;
-    this.config = Object.assign({}, config);
-  }
-  config;
-  #anchors = {};
-  getDir(start, end) {
-    const { neo4j } = this;
-    return neo4j.dirKey({
-      [neo4j.sourceField]: start,
-      [neo4j.targetField]: end
-    });
-  }
-  /**
-   * 设置多边间隔弧长
-   */
-  setRaidx(value) {
-    this.config.radOffsetRaidx = value;
-  }
-  /**
-   * 当图数据准备好后调用
-   */
-  read() {
-    const { neo4j } = this;
-    const { nodeField, edgeField, sourceField, targetField } = neo4j;
-    const anchors = {};
-    neo4j.nodes.forEach((node) => {
-      const nodeId = node[nodeField];
-      let count = 0;
-      [
-        neo4j.sources.get(nodeId),
-        neo4j.targets.get(nodeId)
-      ].forEach((list, i) => {
-        if (!list) return;
-        let diffCount = 0;
-        let sameCount = 0;
-        list.forEach((edge) => {
-          const edgeId = edge[edgeField];
-          if (edge[sourceField] !== edge[targetField]) {
-            const anchor = anchors[edgeId] || (anchors[edgeId] = {});
-            anchor[i ? "target" : "source"] = count + diffCount++;
-          } else if (edgeId in anchors === false) {
-            anchors[edgeId] = {
-              source: sameCount,
-              target: sameCount++
-            };
-          }
-        });
-        count += diffCount;
-      });
-    });
-    this.#anchors = anchors;
-  }
-  calcPoints(edge, index, total, type) {
-    const { neo4j, config: { getBox, radOffsetRaidx = 0.3125 } } = this;
-    const source = getBox(edge[neo4j.sourceField]);
-    const target = getBox(edge[neo4j.targetField]);
-    const rad = Math.atan2(
-      (source.centerY - target.centerY) * type,
-      (source.centerX - target.centerX) * type
-    );
-    let point = rotateRad([0.5, 0], rad);
-    if (total !== 1) {
-      point = rotateRad(point, radOffsetRaidx * (total / 2 - 0.5 - index));
-    }
-    const [x, y] = point;
-    return [x + 0.5, 0.5 - y];
-  }
-  /**
-   * 获取指定节点上出入边连接点的坐标
-   */
-  getPoints(id) {
-    const { neo4j } = this;
-    const { dirs, edgeField, sourceField, targetField } = neo4j;
-    const anchors = this.#anchors;
-    const points = [];
-    const caches = {};
-    neo4j.sources.get(id)?.forEach((edge) => {
-      const source = edge[sourceField];
-      const target = edge[targetField];
-      const direct = this.getDir(source, target);
-      const invert = this.getDir(target, source);
-      if (direct in caches) return;
-      const directs = dirs.get(direct) || [];
-      const inverts = dirs.get(invert) || [];
-      const directsLength = directs.length;
-      const invertsLength = inverts.length;
-      const total = directsLength + invertsLength;
-      directs.forEach((data, index) => {
-        points[anchors[data[edgeField]].source] = this.calcPoints(data, directsLength - 1 - index, total, -1);
-      });
-      caches[direct] = direct;
-    });
-    neo4j.targets.get(id)?.forEach((edge) => {
-      const source = edge[sourceField];
-      const target = edge[targetField];
-      const direct = this.getDir(source, target);
-      const invert = this.getDir(target, source);
-      if (direct in caches) return;
-      const directs = neo4j.dirs.get(direct) || [];
-      const inverts = neo4j.dirs.get(invert) || [];
-      const directsLength = directs.length;
-      const invertsLength = inverts.length;
-      const total = directsLength + invertsLength;
-      directs.forEach((data, index) => {
-        points[anchors[data[edgeField]].target] = this.calcPoints(data, invertsLength + index, total, 1);
-      });
-      caches[direct] = direct;
-    });
-    return points;
-  }
-  /**
-   * 查找边连接点的位置
-   */
-  findAnchor(id) {
-    const anchor = this.#anchors[id];
-    if (!anchor) return null;
-    return {
-      source: anchor.source || 0,
-      target: anchor.target || 0
-    };
-  }
-  /**
-   * 获取指定边控制点距离两端点连线的距离(可理解为控制边的弯曲程度)
-   * @description 返回值是一个相对值，需要乘以一个基数值(基数值应为负值，如-30)
-   */
-  getOffset(id) {
-    const { neo4j } = this;
-    const edge = neo4j.edges.get(id);
-    if (!edge) return -1;
-    const { dirs, edgeField, sourceField, targetField } = neo4j;
-    const source = edge[sourceField];
-    const target = edge[targetField];
-    const directs = dirs.get(this.getDir(source, target)) || [];
-    const inverts = dirs.get(this.getDir(target, source)) || [];
-    let count = 0;
-    let index = 0;
-    [directs, inverts].some((list) => {
-      const result = list.some((data, i) => {
-        if (data[edgeField] === id) {
-          index = i + count;
-          return true;
-        }
-      });
-      count += list.length;
-      return result;
-    });
-    const directsSize = directs.length;
-    const invertsSize = inverts.length;
-    const total = directsSize + invertsSize;
-    if (total === 1) return -1;
-    if (directsSize === 0 || invertsSize === 0) {
-      return total / 2 - index - 0.5;
-    } else {
-      return Math.abs(directsSize - invertsSize) * (directsSize >= invertsSize ? 1 : -1) / 2 - index - 0.5;
-    }
-  }
-  /**
-   * 清理数据
-   */
-  clear() {
-    this.#anchors = {};
-  }
-}
-export {
-  Neo4jAhchors as default
-};

package/dist/neo4j.mjs

@@ -1,161 +0,0 @@
-import { hash8strings } from "./convert/strings";
-import { MemoryList } from "./memory/list";
-import { MemorySimple } from "./memory/simple";
-class Neo4j {
-  #nPrimaryKey;
-  #ePrimaryKey;
-  #sourceKey;
-  #targetKey;
-  #dirKey;
-  #nodes;
-  #edges;
-  #sources;
-  #targets;
-  #dirs;
-  get nodeField() {
-    return this.#nPrimaryKey;
-  }
-  get edgeField() {
-    return this.#ePrimaryKey;
-  }
-  get sourceField() {
-    return this.#sourceKey;
-  }
-  get targetField() {
-    return this.#targetKey;
-  }
-  get dirKey() {
-    return this.#dirKey;
-  }
-  /**
-   * 点视图
-   */
-  nodes;
-  /**
-   * 边视图
-   */
-  edges;
-  /**
-   * (边)出点视图
-   */
-  sources;
-  /**
-   * (边)入点视图
-   */
-  targets;
-  /**
-   * (边)方向视图
-   */
-  dirs;
-  constructor(nodeList, edgeList, {
-    nid,
-    eid,
-    sourceKey,
-    targetKey,
-    dir = (edge) => edge[sourceKey] + "|" + edge[targetKey]
-  }) {
-    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nPrimaryKey = nid));
-    shield(this, "edges", this.#edges = new MemorySimple(this.#ePrimaryKey = eid));
-    shield(this, "sources", this.#sources = new MemoryList(this.#sourceKey = sourceKey));
-    shield(this, "targets", this.#targets = new MemoryList(this.#targetKey = targetKey));
-    shield(this, "dirs", this.#dirs = new MemoryList(this.#dirKey = dir));
-    nodeList.forEach((node) => this.node("add", node));
-    edgeList.forEach((edge) => this.edge("add", edge));
-  }
-  node(type, value) {
-    const nodes = this.#nodes;
-    if (type === "add") {
-      nodes.push(value);
-    } else if (type === "delete") {
-      const node = nodes.get(value);
-      if (!node) return [];
-      nodes.delete(node);
-      const id = node[this.#nPrimaryKey];
-      const sourceKey = this.#sourceKey;
-      const targetKey = this.#targetKey;
-      const edges = this.#edges;
-      const sources = this.#sources;
-      const targets = this.#targets;
-      const dirs = this.#dirs;
-      const list = [];
-      sources.get(id)?.reduce((_, edge) => {
-        edges.delete(edge);
-        targets.delete(edge);
-        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
-        list.push(edge);
-        return true;
-      }, false) && sources.deleteType(id);
-      targets.get(id)?.reduce((_, edge) => {
-        edges.delete(edge);
-        sources.delete(edge);
-        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
-        list.push(edge);
-        return true;
-      }, false) && targets.deleteType(id);
-      return list;
-    }
-  }
-  edge(type, value) {
-    const sourceKey = this.#sourceKey;
-    const targetKey = this.#targetKey;
-    const edges = this.#edges;
-    const sources = this.#sources;
-    const targets = this.#targets;
-    const dirs = this.#dirs;
-    if (type === "add") {
-      const edge = value;
-      edges.push(edge);
-      sources.push(edge);
-      targets.push(edge);
-      edge[sourceKey] === edge[targetKey] || dirs.push(edge);
-    } else if (type === "delete") {
-      const edge = edges.get(value);
-      if (!edge) return false;
-      edges.delete(edge);
-      sources.delete(edge);
-      targets.delete(edge);
-      edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
-      return true;
-    }
-  }
-  /**
-   * 清理图管理数据
-   */
-  clear() {
-    this.#nodes.clear();
-    this.#edges.clear();
-    this.#sources.clear();
-    this.#targets.clear();
-    this.#dirs.clear();
-  }
-}
-const shield_keys = hash8strings([
-  "push",
-  "delete",
-  "deleteType",
-  "clear"
-]);
-const shield = (obj, key, origin) => {
-  const proxy = new Proxy({}, {
-    get(target, p) {
-      if (p in shield_keys) return;
-      const value = origin[p];
-      if (typeof value === "function") {
-        return function(...args) {
-          const result = origin[p](...args);
-          return result === origin ? proxy : result;
-        };
-      } else {
-        return value;
-      }
-    }
-  });
-  Object.defineProperty(obj, key, {
-    get() {
-      return proxy;
-    }
-  });
-};
-export {
-  Neo4j as default
-};

package/dist/once.mjs

@@ -1,8 +0,0 @@
-const once = (func, thisArg) => {
-  let local;
-  let inited = false;
-  return (...list) => inited ? local : (inited = true, local = func.apply(thisArg, list));
-};
-export {
-  once
-};

package/dist/parse/num.mjs

@@ -1,31 +0,0 @@
-import { isNumber } from "lodash-es";
-const pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
-const re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
-const parseNum = (num) => {
-  if (isNumber(num) || typeof num === "bigint") return num;
-  const match = num.match(re_num);
-  if (!match) return Number.NaN;
-  const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
-  if (bigint === "n") return BigInt(valueSymbol + integer);
-  const powSize = integer.length - 1 + (powValue ? powSymbol === "-" ? -powValue : +powValue : 0);
-  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < Number.MAX_SAFE_INTEGER / 10) return +num;
-  try {
-    const bigValue = BigInt(integer.slice(0, powSize + 1).padEnd(powSize + 1, "0"));
-    let smallValue;
-    if (decimal && powValue && powSymbol !== "-") {
-      const powNum = +powValue;
-      const effectDecimal = decimal.slice(0, Math.min(pow, powNum));
-      const tinyValue = decimal.length > pow && powNum > pow ? BigInt(+decimal.slice(pow, powNum)) * BigInt(10 ** Math.max(powNum - decimal.length, 0)) : BigInt(0);
-      smallValue = BigInt(effectDecimal) * BigInt(10 ** (powNum - effectDecimal.length)) + tinyValue;
-    } else {
-      smallValue = BigInt(0);
-    }
-    const value = bigValue + smallValue;
-    return valueSymbol === "-" ? value * BigInt(-1) : value;
-  } catch {
-    return Number.NaN;
-  }
-};
-export {
-  parseNum
-};

package/dist/power/decon.mjs

@@ -1,22 +0,0 @@
-const 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"
-};
-const 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;
-};
-export {
-  deconPowersSum
-};

package/dist/rotate/angle.mjs

@@ -1,5 +0,0 @@
-import { rotateRad } from "./rad";
-const rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
-export {
-  rotateAngle
-};

package/dist/rotate/rad.mjs

@@ -1,11 +0,0 @@
-const 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]
-  ];
-};
-export {
-  rotateRad
-};