feat: add hasNode/hasEdge/hasCombo API (#7345)

* feat: Add graph method (#7319)

* feat: expose methods to determine whether there are nodes, edges, and combo to graph

* feat: unit

* docs: add docs

---------

Co-authored-by: ouxiaofeng.utlf <[email protected]>
Co-authored-by: hustcc <[email protected]>
Co-authored-by: Aaron <[email protected]>

* test: fix test case

* fix: fix types

---------

Co-authored-by: xiaofeng ou <[email protected]>
Co-authored-by: ouxiaofeng.utlf <[email protected]>
Co-authored-by: hustcc <[email protected]>

Author: 4 people

packages/g6/__tests__/unit/runtime/graph/graph.spec.ts

@@ -43,6 +43,48 @@ describe('Graph', () => {
     });
   });
 
+  it('hasNode', () => {
+    expect(graph.hasNode('0')).toBe(true);
+    expect(graph.hasNode('1')).toBe(true);
+
+    expect(graph.hasNode('non-existent-node')).toBe(false);
+    expect(graph.hasNode('node-999')).toBe(false);
+
+    expect(graph.hasNode('')).toBe(false);
+    expect(graph.hasNode(null as any)).toBe(false);
+    expect(graph.hasNode(undefined as any)).toBe(false);
+  });
+
+  it('hasEdge', () => {
+    expect(graph.hasEdge('0-1')).toBe(true);
+
+    expect(graph.hasEdge('non-existent-edge')).toBe(false);
+    expect(graph.hasEdge('edge-999')).toBe(false);
+
+    expect(graph.hasEdge('')).toBe(false);
+    expect(graph.hasEdge(null as any)).toBe(false);
+    expect(graph.hasEdge(undefined as any)).toBe(false);
+  });
+
+  it('hasCombo', () => {
+    graph.addComboData([
+      { id: 'combo-test-1', style: {} },
+      { id: 'combo-test-2', style: {} },
+    ]);
+
+    expect(graph.hasCombo('combo-test-1')).toBe(true);
+    expect(graph.hasCombo('combo-test-2')).toBe(true);
+
+    expect(graph.hasCombo('non-existent-combo')).toBe(false);
+    expect(graph.hasCombo('combo-999')).toBe(false);
+
+    expect(graph.hasCombo('')).toBe(false);
+    expect(graph.hasCombo(null as any)).toBe(false);
+    expect(graph.hasCombo(undefined as any)).toBe(false);
+
+    graph.removeComboData(['combo-test-1', 'combo-test-2']);
+  });
+
   it('setSize/getSize', () => {
     expect(graph.getSize()).toEqual([500, 500]);
     expect(createGraph({}).getSize()).toEqual([0, 0]);

packages/g6/src/runtime/graph.ts

@@ -504,6 +504,40 @@ export class Graph extends EventEmitter {
   public getData(): Required<GraphData> {
     return this.context.model.getData();
   }
+  /**
+   * <zh/> 判断图中是否存在指定节点
+   * <en/> Determine whether a specified node exists in the graph
+   * @param {ID} id
+   * @returns {boolean}
+   * @remarks <zh/> 判断图中是否存在指定节点,避免在不存在的节点上进行操作
+   * <en/> Determine whether a specified node exists in the graph and avoid operating on non-existent nodes
+   */
+  public hasNode(id: ID): boolean {
+    return this.context.model.hasNode(id);
+  }
+  /**
+   * <zh/> 判断图中是否存在指定边
+   * <en/> Determine whether a specified edge exists in the graph
+   * @param {ID} id
+   * @returns  {boolean}
+   * @remarks <zh/> 判断图中是否存在指定边,避免在不存在的边上进行操作
+   * <en/> Determine whether a specified edge exists in the graph and avoid operating on non-existent edges
+   */
+  public hasEdge(id: ID): boolean {
+    return this.context.model.hasEdge(id);
+  }
+
+  /**
+   * <zh/> 判断图中是否存在指定组合
+   * <en/> Determine whether a specified combo exists in the graph
+   * @param {ID} id
+   * @returns  {boolean}
+   * @remarks <zh/> 判断图中是否存在指定组合,避免在不存在的组合上进行操作
+   * <en/> Determine whether a specified combo exists in the graph and avoid operating on non-existent combos
+   */
+  public hasCombo(id: ID): boolean {
+    return this.context.model.hasCombo(id);
+  }
 
   /**
    * <zh/> 获取单个元素数据

packages/g6/src/runtime/viewport.ts

@@ -1,7 +1,15 @@
 import { AABB, ICamera } from '@antv/g';
 import { clamp, isNumber, pick } from '@antv/util';
 import { AnimationType, GraphEvent } from '../constants';
-import type { FitViewOptions, ID, Point, TransformOptions, Vector2, ViewportAnimationEffectTiming } from '../types';
+import type {
+  FitViewOptions,
+  ID,
+  Point,
+  TransformOptions,
+  Vector2,
+  Vector3,
+  ViewportAnimationEffectTiming,
+} from '../types';
 import type { Element } from '../types/element';
 import { getAnimationOptions } from '../utils/animation';
 import { getBBoxSize, getCombinedBBox, getExpandedBBox, isBBoxInside, isPointInBBox } from '../utils/bbox';
@@ -131,8 +139,8 @@ export class ViewportController {
 
     return mode === 'relative'
       ? {
-          position: add(position, delta),
-          focalPoint: add(focalPoint, delta),
+          position: add(position as Vector3, delta),
+          focalPoint: add(focalPoint as Vector3, delta),
         }
       : {
           position: add([cx, cy, position[2]], delta),

packages/g6/src/utils/element.ts

@@ -148,7 +148,7 @@ export function isSimplePort(portStyle: NodePortStyleProps): boolean {
  * @returns <zh/> 连接桩的位置 | <en/> Port Position
  */
 export function getPortPosition(port: Port): Point {
-  return isPoint(port) ? port : port.getPosition();
+  return isPoint(port) ? port : (port.getPosition() as Point);
 }
 
 /**
@@ -246,7 +246,7 @@ export function getPortConnectionPoint(port: Port, opposite: Node | Port): Point
   if (isPoint(port)) return port;
 
   // 1. linkToCenter 为 true，则返回连接桩的中心 | If linkToCenter is true, return the center of the port
-  if (port.attributes.linkToCenter) return port.getPosition();
+  if (port.attributes.linkToCenter) return port.getPosition() as Point;
 
   // 2. 推导对端的具体点：如果是连接桩或节点，则返回它的中心；如果是具体点，则直接返回
   // 2. Get a specific opposite point: if it is a port or a node, return its center; if it is a specific point, return directly
@@ -257,7 +257,7 @@ export function getPortConnectionPoint(port: Port, opposite: Node | Port): Point
       : opposite.getPosition();
 
   // 3. 返回连接桩边界上的交点 | Return the intersection point on the port boundary
-  return getEllipseIntersectPoint(oppositePosition, port.getBounds());
+  return getEllipseIntersectPoint(oppositePosition as Point, port.getBounds());
 }
 
 /**
@@ -275,7 +275,7 @@ export function getNodeConnectionPoint(nodeLike: Node | Combo, opposite: Node |
     ? opposite
     : isNode(opposite)
       ? opposite.getCenter()
-      : opposite.getPosition();
+      : (opposite.getPosition() as Point);
   return nodeLike.getIntersectPoint(oppositePosition) || nodeLike.getCenter();
 }
 

packages/site/docs/api/data.en.md

@@ -806,6 +806,74 @@ updateComboData(data: (ComboData[] | ((prev: ComboData[]) => ComboData[]))): voi
 graph.updateComboData([{ id: 'combo-1', style: { x: 100, y: 100 } }]);
 ```
 
+### Graph.hasNode()
+
+Determine if an node exists
+
+```typescript
+hasNode(id:ID): boolean;
+```
+
+**参数**:
+| Parameter | Description | Type | Default | Required |
+| ---- | -------------------- | --------- | ------ | ---- |
+| id | Node ID to be judged | [ID](#id) | - | ✓ |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasNode('node-1');
+```
+
+### Graph.hasEdge()
+
+Determine if an edge exists
+
+```typescript
+hasEdge(id:ID): boolean;
+```
+
+**参数**:
+
+| Parameter | Description          | Type      | Default | Required |
+| --------- | -------------------- | --------- | ------- | -------- |
+| id        | Edge ID to be judged | [ID](#id) | -       | ✓        |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasEdge('edge-1');
+```
+
+### Graph.hasCombo()
+
+Determine if combo exists
+
+```typescript
+hasCombo(id:ID): boolean;
+```
+
+**参数**:
+
+| Parameter | Description           | Type      | Default | Required |
+| --------- | --------------------- | --------- | ------- | -------- |
+| id        | Combo ID to be judged | [ID](#id) | -       | ✓        |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasCombo('combo-1');
+```
+
 ## Type Definitions
 
 ### ID

packages/site/docs/api/data.zh.md

@@ -806,6 +806,75 @@ updateComboData(data: (ComboData[] | ((prev: ComboData[]) => ComboData[]))): voi
 graph.updateComboData([{ id: 'combo-1', style: { x: 100, y: 100 } }]);
 ```
 
+### Graph.hasNode()
+
+判断节点是否存在
+
+```typescript
+hasNode(id:ID): boolean;
+```
+
+**参数**:
+
+| 参数 | 描述                 | 类型      | 默认值 | 必选 |
+| ---- | -------------------- | --------- | ------ | ---- |
+| id   | 需要进行判断的节点id | [ID](#id) | -      | ✓    |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasNode('node-1');
+```
+
+### Graph.hasEdge()
+
+判断边是否存在
+
+```typescript
+hasEdge(id:ID): boolean;
+```
+
+**参数**:
+
+| 参数 | 描述               | 类型      | 默认值 | 必选 |
+| ---- | ------------------ | --------- | ------ | ---- |
+| id   | 需要进行判断的边id | [ID](#id) | -      | ✓    |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasEdge('edge-1');
+```
+
+### Graph.hasCombo()
+
+判断combo是否存在
+
+```typescript
+hasCombo(id:ID): boolean;
+```
+
+**参数**:
+
+| 参数 | 描述                      | 类型      | 默认值 | 必选 |
+| ---- | ------------------------- | --------- | ------ | ---- |
+| id   | 需要进行判断的combo组合id | [ID](#id) | -      | ✓    |
+
+**返回值**:
+
+- **类型**: boolean
+  **示例**:
+
+```typescript
+graph.hasCombo('combo-1');
+```
+
 ## 类型定义
 
 ### ID