@antv/layout 1.2.14-beta.9 → 2.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/layout",
-  "version": "1.2.14-beta.9",
+  "version": "2.0.0-alpha.1",
   "description": "graph layout algorithm",
   "license": "MIT",
   "repository": {
@@ -12,7 +12,20 @@
   "module": "lib/index.js",
   "types": "lib/index.d.ts",
   "unpkg": "dist/index.min.js",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./dist/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./worker": {
+      "import": "./lib/worker.js",
+      "default": "./dist/worker.js"
+    },
+    "./lib/*": "./lib/*"
+  },
   "files": [
+    "src",
     "package.json",
     "dist",
     "lib",
@@ -30,7 +43,6 @@
     "@antv/event-emitter": "^0.1.3",
     "@antv/graphlib": "^2.0.0",
     "@antv/util": "^3.3.2",
-    "@naoak/workerize-transferable": "^0.1.0",
     "comlink": "^4.4.1",
     "d3-force": "^3.0.0",
     "d3-force-3d": "^3.0.5",
@@ -38,36 +50,64 @@
     "d3-quadtree": "^3.0.1",
     "dagre": "^0.8.5",
     "ml-matrix": "^6.10.4",
-    "tslib": "^2.5.0"
+    "tslib": "^2.8.1"
   },
   "devDependencies": {
+    "@antv/g": "^5.18.25",
+    "@antv/g-canvas": "^1.11.27",
+    "@antv/g-svg": "^1.10.28",
     "@babel/core": "^7.7.7",
     "@babel/plugin-proposal-class-properties": "^7.1.0",
     "@babel/preset-react": "^7.7.4",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/d3-force": "^3.0.4",
     "@types/d3-quadtree": "^2.0.6",
     "@types/dagre": "^0.7.52",
     "babel-loader": "^8.0.6",
+    "interactjs": "^1.10.27",
+    "jest-canvas-mock": "^2.5.2",
+    "jest-random-mock": "^1.0.0",
+    "limit-size": "^0.1.4",
+    "rollup": "^4.54.0",
+    "rollup-plugin-dts": "^6.3.0",
+    "svgo": "^4.0.0",
     "ts-loader": "^7.0.3",
     "typescript": "^4.0.3",
     "webpack": "^5.38.1",
     "webpack-cli": "^5.0.2",
-    "workerize-loader": "^2.0.2"
+    "workerize-loader": "^2.0.2",
+    "xmlserializer": "^0.6.1"
   },
   "scripts": {
-    "clean": "rimraf dist lib tsconfig.tsbuildinfo",
-    "dev": "webpack --config webpack.dev.config.js --mode development",
-    "build": "npm run clean && run-p build:*",
+    "build:watch": "rollup -c --watch",
+    "build": "npm run clean && rollup -c && npm run size",
     "ci": "npm run build && npm run test",
-    "build:esm": "tsc",
-    "build:umd": "webpack --config webpack.config.js --mode production",
+    "clean": "rimraf dist lib",
+    "dev": "vite",
+    "prepublishOnly": "npm run build",
     "publish:alpha": "npm publish --tag alpha",
-    "test": "jest",
-    "prepublishOnly": "npm run build"
+    "size": "limit-size",
+    "test:coverage:open": "open coverage/lcov-report/index.html",
+    "test:coverage": "jest --coverage",
+    "test": "jest"
   },
   "publishConfig": {
     "access": "public",
-    "tag": "beta",
+    "tag": "alpha",
     "registry": "https://registry.npmjs.org/"
-  }
+  },
+  "limit-size": [
+    {
+      "gzip": true,
+      "limit": "100 Kb",
+      "path": "dist/index.min.js"
+    },
+    {
+      "limit": "500 Kb",
+      "path": "dist/index.min.js"
+    }
+  ]
 }

package/src/antv-dagre/acyclic.ts

@@ -0,0 +1,70 @@
+import type { EdgeData, ID } from '../types';
+import { DagreGraph, GraphEdge } from './graph';
+import { greedyFAS } from './greedy-fas';
+
+const run = (g: DagreGraph, acyclicer: string) => {
+  const weightFn = (g: DagreGraph) => {
+    return (e: GraphEdge<EdgeData>) => e.data.weight || 1;
+  };
+  const fas = acyclicer === 'greedy' ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+  fas?.forEach((e: GraphEdge<EdgeData>) => {
+    const label = e.data;
+    g.removeEdge(e.id);
+    label.forwardName = e.data.name;
+    label.reversed = true;
+    g.addEdge({
+      id: e.id,
+      source: e.target,
+      target: e.source,
+      data: {
+        ...label,
+      },
+    });
+  });
+};
+
+const dfsFAS = (g: DagreGraph) => {
+  const fas: GraphEdge<EdgeData>[] = [];
+  const stack: Record<ID, boolean> = {};
+  const visited: Record<ID, boolean> = {};
+
+  const dfs = (v: ID) => {
+    if (visited[v]) {
+      return;
+    }
+    visited[v] = true;
+    stack[v] = true;
+    g.getRelatedEdges(v, 'out').forEach((e) => {
+      if (stack[e.target]) {
+        fas.push(e);
+      } else {
+        dfs(e.target);
+      }
+    });
+    delete stack[v];
+  };
+
+  g.getAllNodes().forEach((n) => dfs(n.id));
+  return fas;
+};
+
+const undo = (g: DagreGraph) => {
+  g.getAllEdges().forEach((e) => {
+    const label = e.data;
+    if (label.reversed) {
+      g.removeEdge(e.id);
+
+      const forwardName = label.forwardName;
+      delete label.reversed;
+      delete label.forwardName;
+      g.addEdge({
+        id: e.id,
+        source: e.target,
+        target: e.source,
+        data: { ...label, forwardName },
+      });
+    }
+  });
+};
+
+export { run, undo };

package/src/antv-dagre/add-border-segments.ts

@@ -0,0 +1,55 @@
+import type { ID, NodeData } from '../types';
+import { DagreGraph } from './graph';
+import { addDummyNode } from './util';
+
+export const addBorderSegments = (g: DagreGraph) => {
+  const dfs = (v: ID) => {
+    const children = g.getChildren(v);
+    const node = g.getNode(v)!;
+    if (children?.length) {
+      children.forEach((child) => dfs(child.id));
+    }
+
+    if (node.data.hasOwnProperty('minRank')) {
+      node.data.borderLeft = [];
+      node.data.borderRight = [];
+      for (
+        let rank = node.data.minRank!, maxRank = node.data.maxRank! + 1;
+        rank < maxRank;
+        rank += 1
+      ) {
+        addBorderNode(g, 'borderLeft', '_bl', v, node, rank);
+        addBorderNode(g, 'borderRight', '_br', v, node, rank);
+      }
+    }
+  };
+
+  g.getRoots().forEach((child) => dfs(child.id));
+};
+
+const addBorderNode = (
+  g: DagreGraph,
+  prop: string,
+  prefix: string,
+  sg: ID,
+  sgNode: { data: NodeData },
+  rank: number,
+) => {
+  const label: NodeData = { rank, borderType: prop, width: 0, height: 0 };
+  // 使用相对于 minRank 的索引
+  const index = rank - sgNode.data.minRank!;
+  // @ts-ignore
+  const prev = sgNode.data[prop][index - 1];
+  const curr = addDummyNode(g, 'border', label, prefix);
+  // @ts-ignore
+  sgNode.data[prop][index] = curr;
+  g.setParent(curr, sg);
+  if (prev) {
+    g.addEdge({
+      id: `e${Math.random()}`,
+      source: prev,
+      target: curr,
+      data: { weight: 1 },
+    });
+  }
+};

package/src/antv-dagre/coordinate-system.ts

@@ -0,0 +1,77 @@
+import type { NodeData, Point } from '../types';
+import { DagreGraph } from './graph';
+import type { DagreRankdir } from './types';
+
+const adjust = (g: DagreGraph, rankdir: DagreRankdir) => {
+  const rd = rankdir.toLowerCase();
+  if (rd === 'lr' || rd === 'rl') {
+    swapWidthHeight(g);
+  }
+};
+
+const undo = (g: DagreGraph, rankdir: DagreRankdir) => {
+  const rd = rankdir.toLowerCase();
+  if (rd === 'bt' || rd === 'rl') {
+    reverseY(g);
+  }
+
+  if (rd === 'lr' || rd === 'rl') {
+    swapXY(g);
+    swapWidthHeight(g);
+  }
+};
+
+const swapWidthHeight = (g: DagreGraph) => {
+  g.getAllNodes().forEach((v) => {
+    swapWidthHeightOne(v);
+  });
+  g.getAllEdges().forEach((e) => {
+    swapWidthHeightOne(e);
+  });
+};
+
+const swapWidthHeightOne = (node: NodeData) => {
+  const w = node.data.width;
+  node.data.width = node.data.height;
+  node.data.height = w;
+};
+
+const reverseY = (g: DagreGraph) => {
+  g.getAllNodes().forEach((v) => {
+    reverseYOne(v.data);
+  });
+
+  g.getAllEdges().forEach((edge) => {
+    edge.data.points?.forEach((point: Point) => reverseYOne(point));
+    if (edge.data.hasOwnProperty('y')) {
+      reverseYOne(edge.data);
+    }
+  });
+};
+
+const reverseYOne = (node: any) => {
+  if (node?.y) {
+    node.y = -node.y;
+  }
+};
+
+const swapXY = (g: DagreGraph) => {
+  g.getAllNodes().forEach((v) => {
+    swapXYOne(v.data);
+  });
+
+  g.getAllEdges().forEach((edge) => {
+    edge.data.points?.forEach((point: Point) => swapXYOne(point));
+    if (edge.data.hasOwnProperty('x')) {
+      swapXYOne(edge.data);
+    }
+  });
+};
+
+const swapXYOne = (node: any) => {
+  const x = node.x;
+  node.x = node.y;
+  node.y = x;
+};
+
+export { adjust, undo };

package/src/antv-dagre/data/list.ts

@@ -0,0 +1,60 @@
+const filterOutLinks = (k: string, v: string) => {
+  if (k !== 'next' && k !== 'prev') {
+    return v;
+  }
+};
+
+type LinkedNode<T> = {
+  prev?: LinkedNode<T>;
+  next?: LinkedNode<T>;
+} & T;
+
+const unlink = <T>(entry: LinkedNode<T>) => {
+  entry.prev!.next = entry.next;
+  entry.next!.prev = entry.prev;
+  delete entry.next;
+  delete entry.prev;
+};
+
+export default class List<T> {
+  // a shortcut that next is head and prev is tail
+  public shortcut: LinkedNode<T>;
+
+  constructor() {
+    const shortcut: LinkedNode<any> = {};
+    shortcut.prev = shortcut;
+    shortcut.next = shortcut.prev;
+    this.shortcut = shortcut;
+  }
+
+  public dequeue() {
+    const shortcut = this.shortcut;
+    const entry = shortcut.prev;
+    if (entry && entry !== shortcut) {
+      unlink(entry);
+      return entry;
+    }
+  }
+
+  public enqueue(entry: LinkedNode<T>) {
+    const shortcut = this.shortcut;
+    if (entry.prev && entry.next) {
+      unlink(entry);
+    }
+    entry.next = shortcut.next;
+    shortcut.next!.prev = entry;
+    shortcut.next = entry;
+    entry.prev = shortcut;
+  }
+
+  public toString() {
+    const strs = [];
+    const sentinel = this.shortcut;
+    let curr = sentinel.prev;
+    while (curr !== sentinel) {
+      strs.push(JSON.stringify(curr, filterOutLinks));
+      curr = curr?.prev;
+    }
+    return `[${strs.join(', ')}]`;
+  }
+}