@antv/layout 0.3.11 → 1.0.0-alpha.0

package/src/layout/dagre/src/order/sort-subgraph.ts

@@ -1,105 +0,0 @@
-import { Graph } from "../../graph";
-import barycenter from "./barycenter";
-import resolveConflicts, { ConflictEntry } from "./resolve-conflicts";
-import sort from "./sort";
-
-const sortSubgraph = (
-  g: Graph,
-  v: string,
-  cg: Graph,
-  biasRight?: boolean,
-  usePrev?: boolean
-) => {
-  let movable = g.children(v);
-  // fixorder的点不参与排序（这个方案不合适，只排了新增节点，和原来的分离）
-  const node = g.node(v)!;
-  const bl = node ? node.borderLeft : undefined;
-  const br = node ? node.borderRight : undefined;
-  const subgraphs: Record<string, Partial<ConflictEntry>> = {};
-
-  if (bl) {
-    movable = movable?.filter((w) => {
-      return w !== bl && w !== br;
-    });
-  }
-
-  const barycenters = barycenter(g, movable || []);
-  barycenters?.forEach((entry) => {
-    if (g.children(entry.v)?.length) {
-      const subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
-      subgraphs[entry.v] = subgraphResult;
-      if (subgraphResult.hasOwnProperty("barycenter")) {
-        mergeBarycenters(entry, subgraphResult);
-      }
-    }
-  });
-
-  const entries = resolveConflicts(barycenters, cg);
-  expandSubgraphs(entries, subgraphs);
-
-  // 添加fixorder信息到entries里边
-  // TODO: 不考虑复合情况，只用第一个点的fixorder信息，后续考虑更完备的实现
-  entries
-    .filter((e) => e.vs.length > 0)
-    ?.forEach((e) => {
-      const node = g.node(e.vs[0])!;
-      if (node) {
-        e.fixorder = node.fixorder;
-        e.order = node.order;
-      }
-    });
-
-  const result = sort(entries, biasRight, usePrev);
-
-  if (bl) {
-    result.vs = [bl, result.vs, br].flat();
-    if (g.predecessors(bl)?.length) {
-      const blPred = g.node(g.predecessors(bl)?.[0] || "")!;
-      const brPred = g.node(g.predecessors(br)?.[0] || "")!;
-      if (!result.hasOwnProperty("barycenter")) {
-        result.barycenter = 0;
-        result.weight = 0;
-      }
-      result.barycenter =
-        (result.barycenter! * result.weight! +
-          (blPred.order as number) +
-          (brPred.order as number)) /
-        (result.weight! + 2);
-      result.weight! += 2;
-    }
-  }
-
-  return result;
-};
-
-const expandSubgraphs = (
-  entries: ConflictEntry[],
-  subgraphs: Record<string, Partial<ConflictEntry>>
-) => {
-  entries?.forEach((entry) => {
-    const vss = entry.vs?.map((v: string) => {
-      if (subgraphs[v]) {
-        return subgraphs[v].vs!;
-      }
-      return v;
-    });
-    entry.vs = vss.flat();
-  });
-};
-
-const mergeBarycenters = (
-  target: { weight?: number; barycenter?: number },
-  other: { weight?: number; barycenter?: number }
-) => {
-  if (target.barycenter !== undefined) {
-    target.barycenter =
-      (target.barycenter * target.weight! + other.barycenter! * other.weight!) /
-      (target.weight! + other.weight!);
-    target.weight! += other.weight!;
-  } else {
-    target.barycenter = other.barycenter;
-    target.weight = other.weight;
-  }
-};
-
-export default sortSubgraph;

package/src/layout/dagre/src/order/sort.ts

@@ -1,76 +0,0 @@
-import { partition } from "../util";
-import { ConflictEntry } from "./resolve-conflicts";
-
-const sort = (entries: ConflictEntry[], biasRight?: boolean, usePrev?: boolean) => {
-  const parts = partition(entries, (entry) => {
-    // NOTE: 有fixorder的也可以排
-    return (entry.hasOwnProperty("fixorder") && !isNaN(entry.fixorder!)) || entry.hasOwnProperty("barycenter");
-  });
-  const sortable = parts.lhs;
-  const unsortable = parts.rhs.sort((a, b) => -a.i - (-b.i));
-  const vs: string[][] = [];
-  let sum = 0;
-  let weight = 0;
-  let vsIndex = 0;
-
-  sortable?.sort(compareWithBias(!!biasRight, !!usePrev));
-
-  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-
-  sortable?.forEach((entry) => {
-    vsIndex += entry.vs?.length;
-    vs.push(entry.vs);
-    sum += entry.barycenter! * entry.weight!;
-    weight += entry.weight!;
-    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-  });
-
-  const result: { vs: string[], barycenter?: number, weight?: number } = { vs: vs.flat() };
-  if (weight) {
-    result.barycenter = sum / weight;
-    result.weight = weight;
-  }
-  return result;
-};
-
-const consumeUnsortable = (vs: string[][], unsortable: ConflictEntry[], index: number) => {
-  let iindex = index;
-  let last;
-  while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= iindex) {
-    unsortable.pop();
-    vs?.push(last.vs);
-    iindex++;
-  }
-  return iindex;
-};
-
-/**
- * 配置是否考虑使用之前的布局结果
- */
-const compareWithBias = (bias: boolean, usePrev: boolean) => {
-  return (entryV: ConflictEntry, entryW: ConflictEntry) => {
-    // 排序的时候先判断fixorder，不行再判断重心
-    if (entryV.fixorder !== undefined && entryW.fixorder !== undefined) {
-      return entryV.fixorder - entryW.fixorder;
-    }
-    if (entryV.barycenter! < entryW.barycenter!) {
-      return -1;
-    }
-    if (entryV.barycenter! > entryW.barycenter!) {
-      return 1;
-    }
-    // 重心相同，考虑之前排好的顺序
-    if (usePrev && entryV.order !== undefined && entryW.order !== undefined) {
-      if (entryV.order < entryW.order) {
-        return -1;
-      }
-      if (entryV.order > entryW.order) {
-        return 1;
-      }
-    }
-
-    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
-  };
-};
-
-export default sort;

package/src/layout/dagre/src/parent-dummy-chains.ts

@@ -1,102 +0,0 @@
-import { Graph } from "../graph";
-
-type OrderItem = { low: number; lim: number };
-
-// deep first search with both order low for pre, lim for post
-const dfsBothOrder = (g: Graph) => {
-  const result: Record<string, OrderItem> = {};
-  let lim = 0;
-
-  const dfs = (v: string) => {
-    const low = lim;
-    g.children(v)?.forEach(dfs);
-    result[v] = { low, lim: lim++ };
-  };
-  g.children()?.forEach(dfs);
-
-  return result;
-};
-
-// Find a path from v to w through the lowest common ancestor (LCA). Return the
-// full path and the LCA.
-const findPath = (
-  g: Graph,
-  postorderNums: Record<string, OrderItem>,
-  v: string,
-  w: string
-) => {
-  const vPath = [];
-  const wPath = [];
-  const low = Math.min(postorderNums[v].low, postorderNums[w].low);
-  const lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
-  let parent: string | undefined;
-  let lca: string | undefined;
-
-  // Traverse up from v to find the LCA
-  parent = v;
-  do {
-    parent = g.parent(parent);
-    vPath.push(parent);
-  } while (
-    parent &&
-    (postorderNums[parent].low > low || lim > postorderNums[parent].lim)
-  );
-  lca = parent;
-
-  // Traverse from w to LCA
-  parent = w;
-  while (parent && parent !== lca) {
-    wPath.push(parent);
-    parent = g.parent(parent);
-  }
-
-  return { lca, path: vPath.concat(wPath.reverse()) };
-};
-
-const parentDummyChains = (g: Graph) => {
-  const postorderNums = dfsBothOrder(g);
-
-  g.graph().dummyChains?.forEach((startV) => {
-    let v = startV; 
-    let node = g.node(v)!;
-    const edgeObj = node.edgeObj;
-    if (!edgeObj) return;
-    const pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-    const path = pathData.path;
-    const lca = pathData.lca;
-    let pathIdx = 0;
-    let pathV = path[pathIdx]!;
-    let ascending = true;
-
-    while (v !== edgeObj.w) {
-      node = g.node(v)!;
-
-      if (ascending) {
-        while (pathV !== lca && g.node(pathV)?.maxRank! < node.rank!) {
-          pathIdx++;
-          pathV = path[pathIdx]!;
-        }
-
-        if (pathV === lca) {
-          ascending = false;
-        }
-      }
-
-      if (!ascending) {
-        while (
-          pathIdx < path.length - 1 &&
-          (g.node(path[pathIdx + 1]!)?.minRank as number) <=
-            (node.rank as number)
-        ) {
-          pathIdx++;
-        }
-        pathV = path[pathIdx]!;
-      }
-
-      g.setParent(v, pathV);
-      v = g.successors(v)![0];
-    }
-  });
-};
-
-export default parentDummyChains;