@antv/layout 1.0.0-alpha.17 → 1.0.0-alpha.19

package/lib/dagre/acyclic.d.ts

@@ -0,0 +1,4 @@
+import { Graph } from "../types";
+declare const run: (g: Graph, acyclicer: string) => void;
+declare const undo: (g: Graph) => void;
+export { run, undo };

package/lib/dagre/add-border-segments.d.ts

@@ -0,0 +1,2 @@
+import { Graph } from "../types";
+export declare const addBorderSegments: (g: Graph) => void;

package/lib/dagre/coordinate-system.d.ts

@@ -0,0 +1,4 @@
+import { DagreRankdir, Graph } from "../types";
+declare const adjust: (g: Graph, rankdir: DagreRankdir) => void;
+declare const undo: (g: Graph, rankdir: DagreRankdir) => void;
+export { adjust, undo };

package/lib/dagre/data/list.d.ts

@@ -0,0 +1,12 @@
+type LinkedNode<T> = {
+    prev?: LinkedNode<T>;
+    next?: LinkedNode<T>;
+} & T;
+export default class List<T> {
+    shortcut: LinkedNode<T>;
+    constructor();
+    dequeue(): LinkedNode<T> | undefined;
+    enqueue(entry: LinkedNode<T>): void;
+    toString(): string;
+}
+export {};

package/lib/dagre/greedy-fas.d.ts

@@ -0,0 +1,3 @@
+import { Edge } from "@antv/graphlib";
+import { EdgeData, Graph as IGraph } from "../types";
+export declare const greedyFAS: (g: IGraph, weightFn?: ((e: Edge<EdgeData>) => number) | undefined) => Edge<EdgeData>[];

package/lib/dagre/layout.d.ts

@@ -0,0 +1,18 @@
+import { ID } from "@antv/graphlib";
+import { DagreAlign, DagreRankdir, Graph as IGraph } from "../types";
+export declare const layout: (g: IGraph, options: {
+    keepNodeOrder: boolean;
+    prevGraph: IGraph | null;
+    edgeLabelSpace?: boolean | undefined;
+    align?: DagreAlign | undefined;
+    nodesep?: number | undefined;
+    edgesep?: number | undefined;
+    ranksep?: number | undefined;
+    acyclicer: string;
+    nodeOrder: ID[];
+    ranker: "network-simplex" | "tight-tree" | "longest-path";
+    rankdir: DagreRankdir;
+}) => {
+    width: number;
+    height: number;
+} | undefined;

package/lib/dagre/nesting-graph.d.ts

@@ -0,0 +1,8 @@
+import { ID } from "@antv/graphlib";
+import { Graph as IGraph } from "../types";
+declare const run: (g: IGraph) => {
+    nestingRoot: ID;
+    nodeRankFactor: number;
+};
+declare const cleanup: (g: IGraph, nestingRoot?: ID) => void;
+export { run, cleanup };

package/lib/dagre/normalize.d.ts

@@ -0,0 +1,5 @@
+import { ID } from "@antv/graphlib";
+import { Graph as IGraph } from "../types";
+declare const run: (g: IGraph, dummyChains: ID[]) => void;
+declare const undo: (g: IGraph, dummyChains: ID[]) => void;
+export { run, undo };

package/lib/dagre/order/add-subgraph-constraints.d.ts

@@ -0,0 +1,3 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+export declare const addSubgraphConstraints: (g: Graph, cg: Graph, vs: ID[]) => void;

package/lib/dagre/order/barycenter.d.ts

@@ -0,0 +1,14 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+/**
+ * TODO: The median method consistently performs better than the barycenter method and has a slight theoretical advantage
+ */
+export declare const barycenter: (g: Graph, movable: ID[]) => ({
+    v: ID;
+    barycenter?: undefined;
+    weight?: undefined;
+} | {
+    v: ID;
+    barycenter: number;
+    weight: number;
+})[];

package/lib/dagre/order/build-layer-graph.d.ts

@@ -0,0 +1,3 @@
+import { Graph } from "@antv/graphlib";
+import { EdgeData, Graph as IGraph, NodeData } from "../../types";
+export declare const buildLayerGraph: (g: IGraph, rank: number, direction: "in" | "out") => Graph<NodeData, EdgeData>;

package/lib/dagre/order/cross-count.d.ts

@@ -0,0 +1,3 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+export declare const crossCount: (g: Graph, layering: ID[][]) => number;

package/lib/dagre/order/index.d.ts

@@ -0,0 +1,2 @@
+import { Graph as IGraph } from "../../types";
+export declare const order: (g: IGraph, keepNodeOrder?: boolean) => void;

package/lib/dagre/order/init-data-order.d.ts

@@ -0,0 +1,6 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+/**
+ * 按照数据中的结果设置fixorder
+ */
+export declare const initDataOrder: (g: Graph, nodeOrder?: ID[]) => void;

package/lib/dagre/order/init-order.d.ts

@@ -0,0 +1,3 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+export declare const initOrder: (g: Graph) => ID[][];

package/lib/dagre/order/resolve-conflicts.d.ts

@@ -0,0 +1,20 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+export type ConflictEntry = {
+    i: number;
+    indegree?: number;
+    in?: ConflictEntry[];
+    out?: ConflictEntry[];
+    vs: ID[];
+    barycenter?: number;
+    weight?: number;
+    merged?: boolean;
+    fixorder?: number;
+    order?: number;
+};
+declare const resolveConflicts: (entries: {
+    v: ID;
+    barycenter?: number;
+    weight?: number;
+}[], cg: Graph) => ConflictEntry[];
+export default resolveConflicts;

package/lib/dagre/order/sort-subgraph.d.ts

@@ -0,0 +1,7 @@
+import { ID } from "@antv/graphlib";
+import { Graph } from "../../types";
+export declare const sortSubgraph: (g: Graph, v: ID, cg: Graph, biasRight?: boolean, usePrev?: boolean, keepNodeOrder?: boolean) => {
+    vs: ID[];
+    barycenter?: number | undefined;
+    weight?: number | undefined;
+};

package/lib/dagre/order/sort.d.ts

@@ -0,0 +1,7 @@
+import { ID } from "@antv/graphlib";
+import { ConflictEntry } from "./resolve-conflicts";
+export declare const sort: (entries: ConflictEntry[], biasRight?: boolean, usePrev?: boolean, keepNodeOrder?: boolean) => {
+    vs: ID[];
+    barycenter?: number | undefined;
+    weight?: number | undefined;
+};

package/lib/dagre/parent-dummy-chains.d.ts

@@ -0,0 +1,3 @@
+import { ID } from "@antv/graphlib";
+import { Graph as IGraph } from "../types";
+export declare const parentDummyChains: (g: IGraph, dummyChains: ID[]) => void;

package/lib/dagre/position/bk.d.ts

@@ -0,0 +1,25 @@
+import { ID, Node } from "@antv/graphlib";
+import { DagreAlign, Graph as IGraph, NodeData } from "../../types";
+type Conflicts = Record<ID, Record<ID, boolean>>;
+export declare const findType1Conflicts: (g: IGraph, layering?: ID[][]) => {};
+export declare const findType2Conflicts: (g: IGraph, layering?: ID[][]) => {};
+export declare const findOtherInnerSegmentNode: (g: IGraph, v: ID) => Node<NodeData> | undefined;
+export declare const addConflict: (conflicts: Conflicts, v: ID, w: ID) => void;
+export declare const hasConflict: (conflicts: Conflicts, v: ID, w: ID) => boolean;
+export declare const verticalAlignment: (g: IGraph, layering: ID[][], conflicts: Conflicts, neighborFn: (v: ID) => Node<NodeData>[]) => {
+    root: Record<ID, ID>;
+    align: Record<ID, ID>;
+};
+export declare const horizontalCompaction: (g: IGraph, layering: ID[][], root: Record<ID, ID>, align: Record<ID, ID>, nodesep: number, edgesep: number, reverseSep?: boolean) => Record<ID, number>;
+export declare const buildBlockGraph: (g: IGraph, layering: ID[][], root: Record<ID, ID>, nodesep: number, edgesep: number, reverseSep?: boolean) => IGraph;
+export declare const findSmallestWidthAlignment: (g: IGraph, xss: Record<string, Record<string, number>>) => Record<string, number>;
+export declare function alignCoordinates(xss: Record<string, Record<string, number>>, alignTo: Record<string, number>): void;
+export declare const balance: (xss: Record<string, Record<string, number>>, align?: DagreAlign) => Record<string, number>;
+export declare const positionX: (g: IGraph, options?: Partial<{
+    align: DagreAlign;
+    nodesep: number;
+    edgesep: number;
+}> | undefined) => Record<string, number>;
+export declare const sep: (nodeSep: number, edgeSep: number, reverseSep: boolean) => (g: IGraph, v: ID, w: ID) => number;
+export declare const width: (g: IGraph, v: ID) => number;
+export {};

package/lib/dagre/position/index.d.ts

@@ -0,0 +1,7 @@
+import { DagreAlign, Graph as IGraph } from "../../types";
+export declare const position: (g: IGraph, options?: Partial<{
+    align: DagreAlign;
+    nodesep: number;
+    edgesep: number;
+    ranksep: number;
+}>) => void;

package/lib/dagre/rank/feasible-tree.d.ts

@@ -0,0 +1,5 @@
+import { Graph } from "@antv/graphlib";
+import { Graph as IGraph } from "../../types";
+declare const feasibleTree: (g: IGraph) => Graph<import("@antv/graphlib").PlainObject, import("@antv/graphlib").PlainObject>;
+declare const feasibleTreeWithLayer: (g: IGraph) => Graph<import("@antv/graphlib").PlainObject, import("@antv/graphlib").PlainObject>;
+export { feasibleTree, feasibleTreeWithLayer };

package/lib/dagre/rank/index.d.ts

@@ -0,0 +1,2 @@
+import { Graph as IGraph } from "../../types";
+export declare const rank: (g: IGraph, ranker: "network-simplex" | "tight-tree" | "longest-path") => void;

package/lib/dagre/rank/network-simplex.d.ts

@@ -0,0 +1,16 @@
+import { Edge, ID } from "@antv/graphlib";
+import { EdgeData, Graph as IGraph } from "../../types";
+export declare const networkSimplex: (og: IGraph) => void;
+export declare const initCutValues: (t: IGraph, g: IGraph) => void;
+export declare const calcCutValue: (t: IGraph, g: IGraph, child: ID) => number;
+export declare const initLowLimValues: (tree: IGraph, root?: ID) => void;
+export declare const leaveEdge: (tree: IGraph) => Edge<EdgeData> | undefined;
+export declare const enterEdge: (t: IGraph, g: IGraph, edge: Edge<EdgeData>) => Edge<EdgeData>;
+/**
+ *
+ * @param t
+ * @param g
+ * @param e edge to remove
+ * @param f edge to add
+ */
+export declare const exchangeEdges: (t: IGraph, g: IGraph, e: Edge<EdgeData>, f: Edge<EdgeData>) => void;

package/lib/dagre/rank/util.d.ts

@@ -0,0 +1,6 @@
+import { Edge } from "@antv/graphlib";
+import { EdgeData, Graph } from "../../types";
+declare const longestPath: (g: Graph) => void;
+declare const longestPathWithLayer: (g: Graph) => void;
+declare const slack: (g: Graph, e: Edge<EdgeData>) => number;
+export { longestPath, longestPathWithLayer, slack };

package/lib/dagre/util.d.ts

@@ -0,0 +1,35 @@
+import { ID, Graph, Node } from "@antv/graphlib";
+import { EdgeData, Graph as IGraph, NodeData } from "../types";
+export declare const addDummyNode: (g: IGraph, type: string, data: NodeData, name: string) => ID;
+export declare const simplify: (g: IGraph) => Graph<NodeData, EdgeData>;
+export declare const asNonCompoundGraph: (g: IGraph) => IGraph;
+export declare const zipObject: <T = any>(keys: ID[], values: T[]) => Record<ID, T>;
+export declare const successorWeights: (g: IGraph) => Record<ID, Record<string, number>>;
+export declare const predecessorWeights: (g: IGraph) => Record<ID, Record<ID, number>>;
+export declare const intersectRect: (rect: {
+    x?: number | undefined;
+    y?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+}, point: {
+    x?: number | undefined;
+    y?: number | undefined;
+}) => {
+    x: number;
+    y: number;
+};
+export declare const buildLayerMatrix: (g: IGraph) => ID[][];
+export declare const normalizeRanks: (g: IGraph) => void;
+export declare const removeEmptyRanks: (g: IGraph, nodeRankFactor?: number) => void;
+export declare const addBorderNode: (g: IGraph, prefix: string, rank?: number, order?: number) => ID;
+export declare const maxRank: (g: IGraph) => number;
+export declare const partition: <T = any>(collection: T[], fn: (val: T) => boolean) => {
+    lhs: T[];
+    rhs: T[];
+};
+export declare const minBy: <T = any>(array: T[], func: (param: T) => number) => T;
+/**
+ * @description DFS traversal.
+ * @description.zh-CN DFS 遍历。
+ */
+export declare const dfs: (graph: IGraph, node: Node<NodeData> | Node<NodeData>[], order: "pre" | "post", isDirected: boolean) => ID[];

package/lib/dagre.d.ts

@@ -0,0 +1,31 @@
+import type { Graph as IGraph, Layout, LayoutMapping, Node, DagreLayoutOptions } from "./types";
+/**
+ * Layout arranging the nodes in a circle.
+ *
+ * @example
+ * // Assign layout options when initialization.
+ * const layout = new CircularLayout({ radius: 10 });
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
+ *
+ * // Or use different options later.
+ * const layout = new CircularLayout({ radius: 10 });
+ * const positions = await layout.execute(graph, { radius: 20 }); // { nodes: [], edges: [] }
+ *
+ * // If you want to assign the positions directly to the nodes, use assign method.
+ * await layout.assign(graph, { radius: 20 });
+ */
+export declare class DagreLayout implements Layout<DagreLayoutOptions> {
+    options: DagreLayoutOptions;
+    id: string;
+    constructor(options?: DagreLayoutOptions);
+    /**
+     * Return the positions of nodes and edges(if needed).
+     */
+    execute(graph: IGraph, options?: DagreLayoutOptions): Promise<LayoutMapping>;
+    /**
+     * To directly assign the positions to the nodes.
+     */
+    assign(graph: IGraph, options?: DagreLayoutOptions): Promise<void>;
+    private genericDagreLayout;
+    layoutNode: (node: Node) => boolean;
+}

package/lib/index.d.ts

@@ -10,5 +10,6 @@ export * from "./fruchterman";
 export * from "./d3Force";
 export * from "./force";
 export * from "./forceAtlas2";
+export * from "./dagre";
 export * from "./types";
 export * from "./util";

package/lib/types.d.ts

@@ -1,7 +1,24 @@
-import { Graph as IGraph, Node as INode, Edge as IEdge, PlainObject, GraphView as IGraphView } from "@antv/graphlib";
+import { Graph as IGraph, Node as INode, Edge as IEdge, PlainObject, GraphView as IGraphView, ID } from "@antv/graphlib";
 export interface NodeData extends PlainObject {
     size?: number | number[];
     bboxSize?: number[];
+    borderLeft?: ID | ID[];
+    borderRight?: ID | ID[];
+    x?: number;
+    y?: number;
+    height?: number;
+    width?: number;
+    e?: IEdge<EdgeData>;
+    selfEdges?: IEdge<EdgeData>[];
+    rank?: number;
+    order?: number;
+    fixorder?: number;
+    minRank?: number;
+    maxRank?: number;
+    layout?: boolean;
+    layer?: number;
+    low?: number;
+    lim?: number;
 }
 export interface OutNodeData extends NodeData {
     x: number;
@@ -9,6 +26,16 @@ export interface OutNodeData extends NodeData {
 }
 export interface EdgeData extends PlainObject {
     virtual?: boolean;
+    weight?: number;
+    x?: number;
+    y?: number;
+    height?: number;
+    width?: number;
+    points?: Point[];
+    controlPoints?: Point[];
+    minlen?: number;
+    cutvalue?: number;
+    labeloffset?: number;
 }
 /** input node */
 export type Node = INode<NodeData>;
@@ -149,9 +176,11 @@ export interface RadialLayoutOptions {
     sortBy?: string;
     sortStrength?: number;
 }
+export type DagreRankdir = "TB" | "BT" | "LR" | "RL" | "tb" | "lr" | "rl" | "bt";
+export type DagreAlign = "UL" | "UR" | "DL" | "DR";
 export interface DagreLayoutOptions {
-    rankdir?: "TB" | "BT" | "LR" | "RL";
-    align?: "UL" | "UR" | "DL" | "DR";
+    rankdir?: DagreRankdir;
+    align?: DagreAlign;
     begin?: PointTuple;
     nodeSize?: number | number[];
     nodesep?: number;
@@ -161,7 +190,7 @@ export interface DagreLayoutOptions {
     edgeLabelSpace?: boolean;
     nodeOrder?: string[];
     radial?: boolean;
-    focusNode: string | Node | null;
+    focusNode?: string | Node | null;
     preset?: {
         nodes: OutNode[];
         edges: Edge[];

package/lib/util/common.d.ts

@@ -13,6 +13,21 @@ export declare const handleSingleNodeGraph: (graph: Graph, assign: boolean, cent
             y: number;
             size?: number | number[] | undefined;
             bboxSize?: number[] | undefined;
+            borderLeft?: import("@antv/graphlib").ID | import("@antv/graphlib").ID[] | undefined;
+            borderRight?: import("@antv/graphlib").ID | import("@antv/graphlib").ID[] | undefined;
+            height?: number | undefined;
+            width?: number | undefined;
+            e?: import("@antv/graphlib").Edge<import("../types").EdgeData> | undefined;
+            selfEdges?: import("@antv/graphlib").Edge<import("../types").EdgeData>[] | undefined;
+            rank?: number | undefined;
+            order?: number | undefined;
+            fixorder?: number | undefined;
+            minRank?: number | undefined;
+            maxRank?: number | undefined;
+            layout?: boolean | undefined;
+            layer?: number | undefined;
+            low?: number | undefined;
+            lim?: number | undefined;
         };
         id: import("@antv/graphlib").ID;
     }[];

package/lib/util/function.d.ts

@@ -17,3 +17,10 @@ export declare function formatSizeFn<T extends Node>(defaultValue: number, value
     width: number;
     height: number;
 } | ((d?: T) => number) | undefined, resultIsNumber?: boolean): (d: T) => number | number[];
+/**
+ * format the props nodeSize and nodeSpacing to a function
+ * @param nodeSize
+ * @param nodeSpacing
+ * @returns
+ */
+export declare const formatNodeSize: (nodeSize: number | number[] | undefined, nodeSpacing: number | Function | undefined) => (nodeData: Node) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/layout",
-  "version": "1.0.0-alpha.17",
+  "version": "1.0.0-alpha.19",
   "description": "graph layout algorithm",
   "main": "dist/index.min.js",
   "module": "esm/index.esm.js",