@vope/utils 1.4.18 → 1.4.20

package/cjs/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
+  Neo4j: () => Neo4j,
   Subscriber: () => Subscriber,
   Union: () => Union,
   clamp: () => clamp,
@@ -49,6 +50,7 @@ __export(src_exports, {
   joinPaths: () => joinPaths,
   loadImage: () => loadImage,
   once: () => once,
+  parseNum: () => parseNum,
   rotateAngle: () => rotateAngle,
   rotateRad: () => rotateRad,
   wait: () => wait
@@ -589,6 +591,149 @@ var MemorySimple = class {
   }
 };
 
+// src/neo4j.ts
+var Neo4j = class {
+  #nid;
+  #sourceKey;
+  #targetKey;
+  #nodes;
+  #edges;
+  #sources;
+  #targets;
+  #dirs;
+  /**
+   * 点视图
+   */
+  nodes;
+  /**
+   * 边视图
+   */
+  edges;
+  /**
+   * (边)出点视图
+   */
+  sources;
+  /**
+   * (边)入点视图
+   */
+  targets;
+  /**
+   * (边)方向视图
+   */
+  dirs;
+  constructor(nodeList, edgeList, {
+    nid,
+    eid,
+    sourceKey,
+    targetKey,
+    dir
+  }) {
+    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
+    shield(this, "edges", this.#edges = new MemorySimple(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(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.#nid];
+      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();
+  }
+};
+var shield_keys = hash8strings([
+  "push",
+  "delete",
+  "deleteType",
+  "clear"
+]);
+var 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;
+    }
+  });
+};
+
 // src/once.ts
 var once = (func, thisArg) => {
   let local;
@@ -596,6 +741,40 @@ var once = (func, thisArg) => {
   return (...list) => inited ? local : (inited = true, local = func.apply(thisArg, list));
 };
 
+// src/parse/num.ts
+var import_lodash_es3 = require("lodash-es");
+var pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
+var re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
+var parseNum = (num) => {
+  if ((0, import_lodash_es3.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;
+  }
+};
+
 // src/rotate/rad.ts
 var rotateRad = (from, rad, visit = [0, 0]) => {
   const x = from[0] - visit[0];
@@ -610,7 +789,7 @@ var rotateRad = (from, rad, visit = [0, 0]) => {
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 
 // src/style/css.ts
-var import_lodash_es3 = require("lodash-es");
+var import_lodash_es4 = require("lodash-es");
 var hump = /[A-Z]/g;
 var css = (...args) => {
   const list = [];
@@ -618,7 +797,7 @@ var css = (...args) => {
     const data = args[i];
     if (!data)
       continue;
-    if ((0, import_lodash_es3.isString)(data)) {
+    if ((0, import_lodash_es4.isString)(data)) {
       list.push(data);
     } else if (Array.isArray(data)) {
       const result = css(...data);

package/lib/index.js

@@ -17,12 +17,14 @@ 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";
 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 { css } from "./style/css";
-import { default as default2 } from "./subscriber";
+import { default as default3 } from "./subscriber";
 import { FlexTable } from "./table/flex";
 import { Union } from "./union";
 import { joinPaths } from "./url/join";
@@ -34,7 +36,8 @@ export {
   MemoryList,
   MemoryPower,
   MemorySimple,
-  default2 as Subscriber,
+  default2 as Neo4j,
+  default3 as Subscriber,
   Union,
   clamp,
   classnames,
@@ -58,6 +61,7 @@ export {
   joinPaths,
   loadImage,
   once,
+  parseNum,
   rotateAngle,
   rotateRad,
   wait

package/lib/neo4j.js

@@ -0,0 +1,147 @@
+import { hash8strings } from "./convert/strings";
+import { MemoryList } from "./memory/list";
+import { MemorySimple } from "./memory/simple";
+class Neo4j {
+  #nid;
+  #sourceKey;
+  #targetKey;
+  #nodes;
+  #edges;
+  #sources;
+  #targets;
+  #dirs;
+  /**
+   * 点视图
+   */
+  nodes;
+  /**
+   * 边视图
+   */
+  edges;
+  /**
+   * (边)出点视图
+   */
+  sources;
+  /**
+   * (边)入点视图
+   */
+  targets;
+  /**
+   * (边)方向视图
+   */
+  dirs;
+  constructor(nodeList, edgeList, {
+    nid,
+    eid,
+    sourceKey,
+    targetKey,
+    dir
+  }) {
+    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
+    shield(this, "edges", this.#edges = new MemorySimple(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(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.#nid];
+      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/lib/parse/num.js

@@ -0,0 +1,35 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.18",
+  "version": "1.4.20",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -49,6 +49,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@type-challenges/utils": "^0.1.1",
     "@types/lodash-es": "^4.17.9",
     "@vope/types": "^1.0.12",
     "csstype": "^3.1.3",

package/types/index.d.ts

@@ -17,7 +17,9 @@ export { MemoryBasic } from './memory/basic';
 export { MemoryList } from './memory/list';
 export { MemoryPower } from './memory/power';
 export { MemorySimple } from './memory/simple';
+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';

package/types/neo4j.d.ts

@@ -0,0 +1,62 @@
+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: GetGivenProps<INode, string> & string;
+    eid: GetGivenProps<IEdge, string> & string;
+    sourceKey: GetGivenProps<IEdge, string> & string;
+    targetKey: GetGivenProps<IEdge, string> & string;
+    dir(edge: IEdge): string;
+}
+/**
+ * 图管理
+ */
+export default class Neo4j<INode extends object, IEdge extends object> {
+    #private;
+    /**
+     * 点视图
+     */
+    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/types/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;