refactor: adjust types

Author: Aarebecca

packages/layout/src/d3Force/index.ts

@@ -1,12 +1,13 @@
 import { isFunction, isNumber, isObject } from '@antv/util';
 import * as d3Force from 'd3-force';
-import {
+import type {
   D3ForceLayoutOptions,
   Edge,
   Graph,
   LayoutMapping,
   LayoutWithIterations,
   Node,
+  OutEdge,
   OutNode,
 } from '../types';
 import { cloneFormatData, isArray } from '../util';
@@ -62,7 +63,7 @@ export class D3ForceLayout
   private forceSimulation: d3Force.Simulation<any, any>;
 
   private lastLayoutNodes: CalcNode[];
-  private lastLayoutEdges: Edge[];
+  private lastLayoutEdges: OutEdge[];
   private lastAssign: boolean;
   private lastGraph: Graph;
 
@@ -146,7 +147,7 @@ export class D3ForceLayout
           y: node.data?.y,
         } as CalcNode),
     );
-    const layoutEdges: Edge[] = edges.map((edge) => cloneFormatData(edge));
+    const layoutEdges: OutEdge[] = edges.map((edge) => cloneFormatData(edge));
 
     // Use them later in `tick`.
     this.lastLayoutNodes = layoutNodes;

packages/layout/src/dagre.ts

@@ -192,7 +192,7 @@ export class DagreLayout implements Layout<DagreLayoutOptions> {
         if (minY > node.data.y!) minY = node.data.y!;
       });
       g.getAllEdges().forEach((edge) => {
-        edge.data.points?.forEach((point) => {
+        edge.data.points?.forEach((point: Point) => {
           if (minX > point.x) minX = point.x;
           if (minY > point.y) minY = point.y;
         });
@@ -460,7 +460,7 @@ export class DagreLayout implements Layout<DagreLayoutOptions> {
         // if (i <= -1) return;
         if (edgeLabelSpace && controlPoints && edge.data.type !== 'loop') {
           edge.data.controlPoints = getControlPoints(
-            edge.data.points?.map(({ x, y }) => ({
+            edge.data.points?.map(({ x, y }: Point) => ({
               x: x + layoutTopLeft[0],
               y: y + layoutTopLeft[1],
             })),

packages/layout/src/dagre/coordinate-system.ts

@@ -1,5 +1,5 @@
 import { Node } from '@antv/graphlib';
-import { DagreRankdir, Graph, NodeData } from '../types';
+import type { DagreRankdir, Graph, NodeData, Point } from '../types';
 
 const adjust = (g: Graph, rankdir: DagreRankdir) => {
   const rd = rankdir.toLowerCase();
@@ -41,14 +41,14 @@ const reverseY = (g: Graph) => {
   });
 
   g.getAllEdges().forEach((edge) => {
-    edge.data.points?.forEach((point) => reverseYOne(point));
+    edge.data.points?.forEach((point: Point) => reverseYOne(point));
     if (edge.data.hasOwnProperty('y')) {
       reverseYOne(edge.data);
     }
   });
 };
 
-const reverseYOne = (node: { x?: number; y?: number }) => {
+const reverseYOne = (node: any) => {
   if (node?.y) {
     node.y = -node.y;
   }
@@ -60,14 +60,14 @@ const swapXY = (g: Graph) => {
   });
 
   g.getAllEdges().forEach((edge) => {
-    edge.data.points?.forEach((point) => swapXYOne(point));
+    edge.data.points?.forEach((point: Point) => swapXYOne(point));
     if (edge.data.hasOwnProperty('x')) {
       swapXYOne(edge.data);
     }
   });
 };
 
-const swapXYOne = (node: { x?: number; y?: number }) => {
+const swapXYOne = (node: any) => {
   const x = node.x;
   node.x = node.y;
   node.y = x;

packages/layout/src/dagre/layout.ts

@@ -1,8 +1,9 @@
-import { Graph, ID } from '@antv/graphlib';
+import { Edge as IEdge, Graph, ID } from '@antv/graphlib';
 import { isNil } from '@antv/util';
 import {
   DagreAlign,
   DagreRankdir,
+  EdgeData,
   Graph as IGraph,
   NodeData,
   Point,
@@ -438,7 +439,7 @@ const translateGraph = (
   });
 
   g.getAllEdges().forEach((edge) => {
-    edge.data.points?.forEach((p) => {
+    edge.data.points?.forEach((p: Point) => {
       p.x -= minX;
       p.y -= minY;
     });
@@ -553,7 +554,7 @@ const insertSelfEdges = (g: IGraph) => {
     layer?.forEach((v: ID, i: number) => {
       const node = g.getNode(v)!;
       node.data.order = i + orderShift;
-      node.data.selfEdges?.forEach((selfEdge) => {
+      node.data.selfEdges?.forEach((selfEdge: IEdge<EdgeData>) => {
         addDummyNode(
           g,
           'selfedge',

packages/layout/src/force/index.ts

@@ -1,12 +1,13 @@
 import { Graph as IGraph } from '@antv/graphlib';
 import { isFunction, isNumber, isObject } from '@antv/util';
-import {
+import type {
   Edge,
   ForceLayoutOptions,
   Graph,
   LayoutMapping,
   LayoutWithIterations,
   Node,
+  OutEdge,
   OutNode,
   Point,
 } from '../types';
@@ -67,7 +68,7 @@ export class ForceLayout implements LayoutWithIterations<ForceLayoutOptions> {
 
   private running: boolean = false;
   private lastLayoutNodes: OutNode[];
-  private lastLayoutEdges: Edge[];
+  private lastLayoutEdges: OutEdge[];
   private lastAssign: boolean;
   private lastCalcGraph: IGraph<CalcNodeData, CalcEdgeData>;
   private lastGraph: Graph;

packages/layout/src/forceAtlas2/index.ts

@@ -8,6 +8,8 @@ import type {
   Layout,
   LayoutMapping,
   Node,
+  OutEdge,
+  OutEdgeData,
   OutNode,
   OutNodeData,
   PointTuple,
@@ -125,8 +127,8 @@ export class ForceAtlas2Layout implements Layout<ForceAtlas2LayoutOptions> {
     const calcEdges = edges.filter((edge: Edge) => {
       const { source, target } = edge;
       return source !== target;
-    });
-    const calcGraph = new GGraph<OutNodeData, EdgeData>({
+    }) as OutEdge[];
+    const calcGraph = new GGraph<OutNodeData, OutEdgeData>({
       nodes: calcNodes,
       edges: calcEdges,
     });

packages/layout/src/fruchterman.ts

@@ -1,16 +1,17 @@
 import { Graph as IGraph } from '@antv/graphlib';
 import { isNumber } from '@antv/util';
 import type {
-  Edge,
   EdgeData,
   FruchtermanLayoutOptions,
   Graph,
   LayoutMapping,
   LayoutWithIterations,
+  OutEdge,
+  OutEdgeData,
   OutNode,
   OutNodeData,
   Point,
-  PointTuple,
+  PointTuple
 } from './types';
 import { cloneFormatData } from './util';
 
@@ -75,7 +76,7 @@ export class FruchtermanLayout
 
   private running: boolean = false;
   private lastLayoutNodes: OutNode[];
-  private lastLayoutEdges: Edge[];
+  private lastLayoutEdges: OutEdge[];
   private lastAssign: boolean;
   private lastGraph: IGraph<OutNodeData, EdgeData>;
   private lastOptions: FormattedOptions;
@@ -212,7 +213,7 @@ export class FruchtermanLayout
     const layoutNodes: OutNode[] = nodes.map(
       (node) => cloneFormatData(node, [width, height]) as OutNode,
     );
-    const calcGraph = new IGraph<OutNodeData, EdgeData>({
+    const calcGraph = new IGraph<OutNodeData, OutEdgeData>({
       nodes: layoutNodes,
       edges,
     });

packages/layout/src/types.ts

@@ -1,82 +1,46 @@
 import {
   Edge as IEdge,
   Graph as IGraph,
-  GraphView as IGraphView,
   ID,
   Node as INode,
-  PlainObject,
 } from '@antv/graphlib';
 
-export interface NodeData extends PlainObject {
-  size?: number | number[];
-  bboxSize?: number[];
-  borderLeft?: ID | ID[];
-  borderRight?: ID | ID[];
+export interface NodeData {
   x?: number;
   y?: number;
   z?: number;
-  height?: number;
-  width?: number;
-  e?: IEdge<EdgeData>;
-  selfEdges?: IEdge<EdgeData>[];
-  rank?: number;
-  _rank?: number;
-  order?: number;
-  fixorder?: number;
-  minRank?: number;
-  maxRank?: number;
-  layout?: boolean;
-  layer?: number;
-  low?: number;
-  lim?: number;
+  size?: number | number[];
+  [key: string]: any;
+}
+
+export interface EdgeData {
+  weight?: number;
+  [keys: string]: any;
 }
 
 export interface OutNodeData extends NodeData {
   x: number;
   y: number;
-  z?: number;
 }
 
-export interface EdgeData extends PlainObject {
-  // temp edges e.g. the edge generated for releated collapsed combo
-  virtual?: boolean;
-  weight?: number;
-  x?: number;
-  y?: number;
-  height?: number;
-  width?: number;
-  points?: Point[];
-  controlPoints?: Point[];
-  minlen?: number;
-  cutvalue?: number;
-  labeloffset?: number;
-}
+export interface OutEdgeData extends EdgeData {}
 
-/** input node */
 export type Node = INode<NodeData>;
-/** output node */
-export type OutNode = INode<OutNodeData>;
-/** input and output edge */
 export type Edge = IEdge<EdgeData>;
-
-export type Degree = {
-  in: number;
-  out: number;
-  all: number;
-};
+export type OutNode = INode<OutNodeData>;
+export type OutEdge = IEdge<OutEdgeData>;
 
 // maps node's id and its index in the nodes array
 export type IndexMap = {
   [nodeId: string]: number;
 };
 
 export type Graph = IGraph<NodeData, EdgeData>;
-export type GraphView = IGraphView<NodeData, EdgeData>;
 
 export type PointTuple = [number, number] | [number, number, number];
 export type Point = { x: number; y: number; z?: number };
 export type Matrix = number[];
-export type LayoutMapping = { nodes: OutNode[]; edges: Edge[] };
+export type LayoutMapping = { nodes: OutNode[]; edges: OutEdge[] };
 
 export interface Layout<LayoutOptions> {
   /**
@@ -119,10 +83,6 @@ export interface LayoutWithIterations<LayoutOptions>
   tick: (iterations?: number) => LayoutMapping;
 }
 
-export interface LayoutConstructor<LayoutOptions> {
-  new (options?: LayoutOptions): Layout<LayoutOptions>;
-}
-
 export interface LayoutSupervisor {
   execute(): Promise<LayoutMapping>;
   stop(): void;

packages/layout/src/util/index.ts

@@ -1,6 +1,4 @@
-export * from './array';
-export * from './function';
-export * from './math';
-export * from './number';
-export * from './object';
-export * from './string';
+export * from "./array";
+export * from "./math";
+export * from "./object";
+export * from "./function";