@vope/utils 1.4.20 → 1.4.21

package/cjs/index.js

@@ -26,6 +26,7 @@ __export(src_exports, {
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
   Neo4j: () => Neo4j,
+  Neo4jAhchors: () => Neo4jAhchors,
   Subscriber: () => Subscriber,
   Union: () => Union,
   clamp: () => clamp,
@@ -591,16 +592,208 @@ 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 {
-  #nid;
+  #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;
+  }
   /**
    * 点视图
    */
@@ -626,13 +819,13 @@ var Neo4j = class {
     eid,
     sourceKey,
     targetKey,
-    dir
+    dir = (edge) => edge[sourceKey] + "|" + edge[targetKey]
   }) {
-    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
-    shield(this, "edges", this.#edges = new MemorySimple(eid));
+    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(dir));
+    shield(this, "dirs", this.#dirs = new MemoryList(this.#dirKey = dir));
     nodeList.forEach((node) => this.node("add", node));
     edgeList.forEach((edge) => this.edge("add", edge));
   }
@@ -645,7 +838,7 @@ var Neo4j = class {
       if (!node)
         return [];
       nodes.delete(node);
-      const id = node[this.#nid];
+      const id = node[this.#nPrimaryKey];
       const sourceKey = this.#sourceKey;
       const targetKey = this.#targetKey;
       const edges = this.#edges;
@@ -775,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,14 +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";
+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 default3 } from "./subscriber";
+import { default as default4 } from "./subscriber";
 import { FlexTable } from "./table/flex";
 import { Union } from "./union";
 import { joinPaths } from "./url/join";
@@ -36,8 +37,9 @@ export {
   MemoryList,
   MemoryPower,
   MemorySimple,
-  default2 as Neo4j,
-  default3 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

@@ -2,14 +2,31 @@ import { hash8strings } from "./convert/strings";
 import { MemoryList } from "./memory/list";
 import { MemorySimple } from "./memory/simple";
 class Neo4j {
-  #nid;
+  #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;
+  }
   /**
    * 点视图
    */
@@ -35,13 +52,13 @@ class Neo4j {
     eid,
     sourceKey,
     targetKey,
-    dir
+    dir = (edge) => edge[sourceKey] + "|" + edge[targetKey]
   }) {
-    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
-    shield(this, "edges", this.#edges = new MemorySimple(eid));
+    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(dir));
+    shield(this, "dirs", this.#dirs = new MemoryList(this.#dirKey = dir));
     nodeList.forEach((node) => this.node("add", node));
     edgeList.forEach((edge) => this.edge("add", edge));
   }
@@ -54,7 +71,7 @@ class Neo4j {
       if (!node)
         return [];
       nodes.delete(node);
-      const id = node[this.#nid];
+      const id = node[this.#nPrimaryKey];
       const sourceKey = this.#sourceKey;
       const targetKey = this.#targetKey;
       const edges = this.#edges;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.20",
+  "version": "1.4.21",
   "description": "",
   "type": "module",
   "publishConfig": {

package/types/index.d.ts

@@ -17,6 +17,7 @@ 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';

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

@@ -3,17 +3,37 @@ 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;
+    /**
+     * 点主键字段
+     */
+    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;
     /**
      * 点视图
      */
@@ -57,6 +77,6 @@ declare const shield_keys: {
     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];
+    [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 {};