@vope/utils 1.4.19 → 1.4.21

package/cjs/index.js

@@ -25,6 +25,8 @@ __export(src_exports, {
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
+  Neo4j: () => Neo4j,
+  Neo4jAhchors: () => Neo4jAhchors,
   Subscriber: () => Subscriber,
   Union: () => Union,
   clamp: () => clamp,
@@ -590,6 +592,341 @@ var MemorySimple = class {
   }
 };
 
+// src/rotate/rad.ts
+var 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]
+  ];
+};
+
+// src/neo4j-anchors.ts
+var Neo4jAhchors = class {
+  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
+    });
+  }
+  /**
+   * 当图数据准备好后调用
+   */
+  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] || {};
+    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 = {};
+  }
+};
+
+// src/neo4j.ts
+var Neo4j = class {
+  #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();
+  }
+};
+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;
@@ -631,16 +968,6 @@ var parseNum = (num) => {
   }
 };
 
-// src/rotate/rad.ts
-var 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]
-  ];
-};
-
 // src/rotate/angle.ts
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 

package/lib/index.js

@@ -17,13 +17,15 @@ 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 { css } from "./style/css";
-import { default as default2 } from "./subscriber";
+import { default as default4 } from "./subscriber";
 import { FlexTable } from "./table/flex";
 import { Union } from "./union";
 import { joinPaths } from "./url/join";
@@ -35,7 +37,9 @@ export {
   MemoryList,
   MemoryPower,
   MemorySimple,
-  default2 as Subscriber,
+  default3 as Neo4j,
+  default2 as Neo4jAhchors,
+  default4 as Subscriber,
   Union,
   clamp,
   classnames,

package/lib/neo4j-anchors.js

@@ -0,0 +1,167 @@
+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
+    });
+  }
+  /**
+   * 当图数据准备好后调用
+   */
+  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] || {};
+    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/lib/neo4j.js

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

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.19",
+  "version": "1.4.21",
   "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,6 +17,8 @@ export { MemoryBasic } from './memory/basic';
 export { MemoryList } from './memory/list';
 export { MemoryPower } from './memory/power';
 export { MemorySimple } from './memory/simple';
+export { default as Neo4jAhchors } from './neo4j-anchors';
+export { default as Neo4j } from './neo4j';
 export { once } from './once';
 export { parseNum } from './parse/num';
 export { deconPowersSum } from './power/decon';

package/types/neo4j-anchors.d.ts

@@ -0,0 +1,45 @@
+import Neo4j from './neo4j';
+interface IBox {
+    centerX: number;
+    centerY: number;
+}
+interface Config {
+    radOffsetRaidx?: number;
+    getBox(id: string): IBox;
+}
+/**
+ * 图布局之二阶贝塞尔曲线边锚点管理
+ */
+export default class Neo4jAhchors<INode extends object, IEdge extends object> {
+    #private;
+    protected neo4j: Neo4j<INode, IEdge>;
+    protected config: Config;
+    constructor(neo4j: Neo4j<INode, IEdge>, config: Config);
+    protected getDir(start: string, end: string): string;
+    /**
+     * 当图数据准备好后调用
+     */
+    read(): void;
+    protected calcPoints(edge: IEdge, index: number, total: number, type: 1 | -1): number[];
+    /**
+     * 获取指定节点上出入边连接点的坐标
+     */
+    getPoints(id: string): number[][];
+    /**
+     * 查找边连接点的位置
+     */
+    findAnchor(id: string): {
+        source: number;
+        target: number;
+    };
+    /**
+     * 获取指定边控制点距离两端点连线的距离(可理解为控制边的弯曲程度)
+     * @description 返回值是一个相对值，需要乘以一个基数值(基数值应为负值，如-30)
+     */
+    getOffset(id: string): number;
+    /**
+     * 清理数据
+     */
+    clear(): void;
+}
+export {};

package/types/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 {};