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

package/dist/neo4j-anchors.mjs

@@ -0,0 +1,169 @@
+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.d.ts

@@ -0,0 +1,82 @@
+import { Equal } from '@type-challenges/utils';
+import { GetGivenProps } from '@vope/types';
+import { MemoryList } from './memory/list';
+import { MemorySimple } from './memory/simple';
+interface Config<INode extends object, IEdge extends object> {
+    /**
+     * 点主键字段
+     */
+    nid: Extract<GetGivenProps<INode, string>, string>;
+    /**
+     * 边主键字段
+     */
+    eid: Extract<GetGivenProps<IEdge, string>, string>;
+    /**
+     * (边)出点字段
+     */
+    sourceKey: Extract<GetGivenProps<IEdge, string>, string>;
+    /**
+     * (边)入点字段
+     */
+    targetKey: Extract<GetGivenProps<IEdge, string>, string>;
+    /**
+     * (边)方向键
+     */
+    dir?(edge: IEdge): string;
+}
+/**
+ * 图管理
+ */
+export default class Neo4j<INode extends object, IEdge extends object> {
+    #private;
+    get nodeField(): keyof INode;
+    get edgeField(): keyof IEdge;
+    get sourceField(): keyof IEdge;
+    get targetField(): keyof IEdge;
+    get dirKey(): (edge: IEdge) => string;
+    /**
+     * 点视图
+     */
+    nodes: Shield<MemorySimple<INode, string>>;
+    /**
+     * 边视图
+     */
+    edges: Shield<MemorySimple<IEdge, string>>;
+    /**
+     * (边)出点视图
+     */
+    sources: Shield<MemoryList<IEdge, string>>;
+    /**
+     * (边)入点视图
+     */
+    targets: Shield<MemoryList<IEdge, string>>;
+    /**
+     * (边)方向视图
+     */
+    dirs: Shield<MemoryList<IEdge, string>>;
+    constructor(nodeList: INode[], edgeList: IEdge[], { nid, eid, sourceKey, targetKey, dir, }: Config<INode, IEdge>);
+    /**
+     * 点操作
+     */
+    node(type: 'add', value: INode): void;
+    node(type: 'delete', value: string): IEdge[];
+    /**
+     * 边操作
+     */
+    edge(type: 'add', value: IEdge): void;
+    edge(type: 'delete', value: string): boolean;
+    /**
+     * 清理图管理数据
+     */
+    clear(): void;
+}
+declare const shield_keys: {
+    push: number;
+    clear: number;
+    delete: number;
+    deleteType: number;
+};
+type Shield<T> = {
+    [P in Exclude<keyof T, keyof typeof shield_keys>]: T[P] extends (...args: infer A) => infer B ? Equal<[B], [T]> extends true ? (...args: A) => Shield<T> : T[P] : T[P];
+};
+export {};

package/dist/neo4j.mjs

@@ -0,0 +1,161 @@
+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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 缓存函数返回值
+ * @param callback 运行返回值的函数
+ * @param thisArg 绑定到运行函数的this对象
+ */
+export declare const once: <T extends (...args: any) => any>(func: T, thisArg?: any) => (...list: Parameters<T>) => ReturnType<T>;

package/dist/once.mjs

@@ -0,0 +1,8 @@
+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.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 解析一个字符串并返回一个数字
+ * @description 1、number最多支持16位小数
+ * @description 2、最终值为bigint则会把小数部分舍去
+ * @description 3、支持科学计数法形式的字符串
+ * @description 4、无法正确解析的值则会返回NaN
+ */
+export declare const parseNum: (num: number | bigint | string) => number | bigint;

package/dist/parse/num.mjs

@@ -0,0 +1,31 @@
+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.d.ts

@@ -0,0 +1,9 @@
+type Sort = 'asc' | 'desc';
+/**
+ * 解构多个2的正整数幂(两两不相等)之和
+ * @param sum 幂和
+ * @param sort 排序方式(默认降序)
+ * @description sum > 2**53则会因为精度问题计算报错
+ */
+export declare const deconPowersSum: (sum: number, sort?: Sort) => number[];
+export {};

package/dist/power/decon.mjs

@@ -0,0 +1,22 @@
+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.d.ts

@@ -0,0 +1,8 @@
+import { Point2Tuple } from '@vope/types';
+/**
+ * 返回点被旋转指定角度后新的位置
+ * @param from 旋转点
+ * @param angle 旋转角度
+ * @param visit 旋转原点
+ */
+export declare const rotateAngle: (from: Point2Tuple, angle: number, visit?: Point2Tuple) => Point2Tuple;

package/dist/rotate/angle.mjs

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

package/dist/rotate/rad.d.ts

@@ -0,0 +1,8 @@
+import { Point2Tuple } from '@vope/types';
+/**
+ * 返回点被旋转指定弧度后新的位置
+ * @param from 旋转点
+ * @param rad 旋转弧度
+ * @param visit 旋转原点
+ */
+export declare const rotateRad: (from: Point2Tuple, rad: number, visit?: Point2Tuple) => Point2Tuple;

package/dist/rotate/rad.mjs

@@ -0,0 +1,11 @@
+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
+};

package/dist/serialize/url-params.d.ts

@@ -0,0 +1,43 @@
+import { Equal } from '@type-challenges/utils';
+import { UnionToTuple } from '@vope/types';
+type NativeMap = {
+    string: string;
+    boolean: boolean;
+    number: number;
+    bigint: bigint;
+    date: Date;
+    regexp: RegExp;
+    null: null;
+};
+type NativeValue = keyof NativeMap;
+interface AccessorValue<T = any> {
+    cube(text: string): T;
+    flat(value: T): string;
+}
+type NativeUnion = UnionToTuple<{
+    [P in NativeValue]: [NativeMap[P], P];
+}[NativeValue]>;
+type Signal<T, U extends any[] = NativeUnion> = U extends [infer A1, ...infer A2] ? A1 extends [infer V, infer K] ? Equal<T, V> extends true ? K : Signal<T, A2> : Signal<T, A2> : never;
+/**
+ * 转换套件类型
+ */
+export type Serializes<T extends object> = {
+    [P in keyof T & string]: Signal<T[P]> | AccessorValue<T[P]>;
+};
+type Cube<T> = [T] extends [NativeValue] ? NativeMap[T] : [T] extends [AccessorValue<infer B>] ? B : never;
+type Cubes<T extends object, S extends Serializes<T>> = {
+    [P in Extract<keyof T, keyof S> & string]: Cube<S[P]>;
+};
+/**
+ * 将URL查询参数转换成(复杂)对象
+ * @param text URL查询参数字符串
+ * @param serializes 转换套件
+ */
+export declare const cubeURLParams: <T extends object, S extends Serializes<T>>(text: string, serializes: S) => Cubes<T, S>;
+/**
+ * 将(复杂)对象转换成URL查询参数
+ * @param data 数据
+ * @param serializes 转换套件
+ */
+export declare const flatURLParams: <T extends object, S extends Serializes<T>>(data: T, serializes: S) => string;
+export {};

package/dist/serialize/url-params.mjs

@@ -0,0 +1,53 @@
+import { isString } from "lodash-es";
+import { isKey } from "../is/key";
+const cubes = {
+  string: (text) => text,
+  boolean: (text) => text === "true",
+  number: (text) => Number(text),
+  bigint: (text) => BigInt(text),
+  date: (text) => new Date(text),
+  regexp: (text) => new RegExp(text),
+  null: () => null
+};
+const flats = {
+  string: (data) => flatEncode(data),
+  boolean: (data) => `${data}`,
+  number: (data) => `${data}`,
+  bigint: (data) => `${data}`,
+  date: (data) => data.toJSON(),
+  regexp: (data) => flatEncode(data.source),
+  null: () => "null"
+};
+const cubeURLParams = (text, serializes) => {
+  const params = new URLSearchParams(text);
+  const result = {};
+  for (const [key, value] of params) {
+    const serialize = serializes[key];
+    if (!serialize) continue;
+    if (isString(serialize) && isKey(serialize, cubes)) {
+      result[key] = cubes[serialize](value);
+    } else {
+      result[key] = serialize.cube(value);
+    }
+  }
+  return result;
+};
+const re_flat = /\+/g;
+const flatEncode = (text) => text.replace(re_flat, () => "%2B");
+const flatURLParams = (data, serializes) => {
+  const params = new URLSearchParams();
+  for (const key in data) {
+    const value = data[key];
+    const serialize = serializes[key];
+    if (!serialize) continue;
+    params.append(
+      key,
+      isString(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+    );
+  }
+  return params.toString();
+};
+export {
+  cubeURLParams,
+  flatURLParams
+};

package/dist/storage/offline.d.ts

@@ -0,0 +1,51 @@
+export interface ICrypto<From, To> {
+    encrypt(plain: From): To | Promise<To>;
+    decrypt(cipher: To): From | Promise<From>;
+}
+interface Options<From, To> {
+    /** 存储名称 */
+    name: string;
+    /** 存储认证 */
+    token?: string;
+    /** 存储期限 */
+    expire?: number;
+    /** 存储加密 */
+    crypto: ICrypto<From, To>;
+}
+/**
+ * 离线存储
+ */
+export declare class OfflineStorage<From, To> {
+    #private;
+    get size(): number;
+    get mounted(): boolean;
+    constructor({ name, expire: newExpire, token: newToken, crypto, }: Options<From, To>);
+    ready(): Promise<this>;
+    /**
+     * 校验存储是否过期
+     */
+    validateExpire(): boolean;
+    /**
+     * 校验
+     */
+    validate(callback: (error?: Error) => void, expireMessage?: string): void;
+    /**
+     * 插入数据
+     */
+    push(data: From): Promise<number>;
+    /**
+     * 修改数据
+     */
+    update(index: number, data: From): Promise<boolean>;
+    /**
+     * 获取数据
+     */
+    get(index: number): Promise<From | null>;
+    /**
+     * 清理存储
+     */
+    clear(): Promise<void>;
+    static default<T>(options: string | Omit<Options<T, T>, 'crypto'>): OfflineStorage<T, T>;
+    static clear(token?: string, callback?: (name: string) => boolean): Promise<void>;
+}
+export {};