@antv/layout 1.0.0-alpha.9 → 1.1.0

package/lib/{Circular.d.ts → circular.d.ts}

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

package/lib/concentric.d.ts

@@ -1,30 +1,30 @@
-import type { Graph, LayoutMapping, ConcentricLayoutOptions, SyncLayout } from "./types";
+import type { Graph, LayoutMapping, ConcentricLayoutOptions, Layout } from "./types";
 /**
  * Layout arranging the nodes in concentrics
  *
  * @example
  * // Assign layout options when initialization.
  * const layout = new ConcentricLayout({ nodeSpacing: 10 });
- * const positions = layout.execute(graph); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
  *
  * // Or use different options later.
  * const layout = new ConcentricLayout({ nodeSpacing: 10});
- * const positions = layout.execute(graph, { nodeSpacing: 10 }); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph, { nodeSpacing: 10 }); // { nodes: [], edges: [] }
  *
  * // If you want to assign the positions directly to the nodes, use assign method.
- * layout.assign(graph, { nodeSpacing: 10 });
+ * await layout.assign(graph, { nodeSpacing: 10 });
  */
-export declare class ConcentricLayout implements SyncLayout<ConcentricLayoutOptions> {
+export declare class ConcentricLayout implements Layout<ConcentricLayoutOptions> {
     options: ConcentricLayoutOptions;
     id: string;
     constructor(options?: ConcentricLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: ConcentricLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: ConcentricLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: ConcentricLayoutOptions): void;
+    assign(graph: Graph, options?: ConcentricLayoutOptions): Promise<void>;
     private genericConcentricLayout;
 }

package/lib/d3Force/forceInBox.d.ts

@@ -7,21 +7,21 @@ interface INode {
     cluster: any;
 }
 export default function forceInBox(): {
-    (alpha: number): any | undefined;
+    (alpha: number): any;
     initialize(_: any): void;
     template: (x: any) => string | any;
-    groupBy: (x: any) => ((d: INode) => any) | any;
+    groupBy: (x: any) => any | ((d: INode) => any);
     enableGrouping: (x: any) => boolean | any;
     strength: (x: any) => number | any;
     centerX: (_: any) => number | any;
     centerY: (_: any) => number | any;
-    nodes: (_: any) => INode[] | any;
+    nodes: (_: any) => any | INode[];
     links: (_: any) => any[] | any;
-    forceNodeSize: (_: any) => ((d: any) => number) | any;
-    nodeSize: (_: any) => ((d: any) => number) | any;
-    forceCharge: (_: any) => ((d: any) => number) | any;
-    forceLinkDistance: (_: any) => ((d: any) => number) | any;
-    forceLinkStrength: (_: any) => ((d: any) => number) | any;
+    forceNodeSize: (_: any) => any | (() => number) | ((d: any) => number);
+    nodeSize: (_: any) => any | (() => number) | ((d: any) => number);
+    forceCharge: (_: any) => any | (() => number) | ((d: any) => number);
+    forceLinkDistance: (_: any) => any | (() => number) | ((d: any) => number);
+    forceLinkStrength: (_: any) => any | (() => number) | ((d: any) => number);
     offset: (_: any) => number[] | any;
     getFocis: () => any;
 };

package/lib/d3Force/index.d.ts

@@ -1,45 +1,55 @@
-import { Graph, Node, LayoutMapping, D3ForceLayoutOptions, SyncLayout } from "../types";
+import * as d3Force from "d3-force";
+import { Graph, Node, LayoutMapping, OutNode, D3ForceLayoutOptions, Edge, LayoutWithIterations } from "../types";
 /**
  * Layout the nodes' positions with d3's basic classic force
  *
  * @example
  * // Assign layout options when initialization.
  * const layout = new D3ForceLayout({ center: [100, 100] });
- * const positions = layout.execute(graph); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
  *
  * // Or use different options later.
  * const layout = new D3ForceLayout({ center: [100, 100] });
- * const positions = layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }
  *
  * // If you want to assign the positions directly to the nodes, use assign method.
- * layout.assign(graph, { center: [100, 100] });
+ * await layout.assign(graph, { center: [100, 100] });
  */
-export declare class D3ForceLayout implements SyncLayout<D3ForceLayoutOptions> {
+export declare class D3ForceLayout implements LayoutWithIterations<D3ForceLayoutOptions> {
     options: D3ForceLayoutOptions;
     id: string;
     private forceSimulation;
-    /** The sign of running */
-    private running;
+    private lastLayoutNodes;
+    private lastLayoutEdges;
+    private lastAssign;
+    private lastGraph;
     constructor(options?: D3ForceLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: D3ForceLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: D3ForceLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: D3ForceLayoutOptions): void;
+    assign(graph: Graph, options?: D3ForceLayoutOptions): Promise<void>;
     /**
      * Stop simulation immediately.
      */
     stop(): void;
-    isRunning(): boolean;
+    /**
+     * Manually steps the simulation by the specified number of iterations.
+     * @see https://github.com/d3/d3-force#simulation_tick
+     */
+    tick(iterations?: number): {
+        nodes: OutNode[];
+        edges: Edge[];
+    };
     private genericForceLayout;
     /**
      * Prevent overlappings.
      * @param {object} simulation force simulation of d3
      */
-    overlapProcess(simulation: any, options: {
+    overlapProcess(simulation: d3Force.Simulation<any, any>, options: {
         nodeSize: number | number[] | ((d?: Node) => number) | undefined;
         nodeSpacing: number | number[] | ((d?: Node) => number) | undefined;
         collideStrength: number;

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 @@
+declare type LinkedNode<T> = {
+    prev?: LinkedNode<T>;
+    next?: LinkedNode<T>;
+} & T;
+export default class List<T> {
+    shortcut: LinkedNode<T>;
+    constructor();
+    dequeue(): LinkedNode<T>;
+    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) => 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;
+    align?: DagreAlign;
+    nodesep?: number;
+    edgesep?: number;
+    ranksep?: number;
+    acyclicer: string;
+    nodeOrder: ID[];
+    ranker: "network-simplex" | "tight-tree" | "longest-path";
+    rankdir: DagreRankdir;
+}) => {
+    width: number;
+    height: number;
+};

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 declare 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;
+    weight?: number;
+};

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;
+    weight?: number;
+};

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";
+declare 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>;
+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;
+}>) => 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<Record<string, unknown>, Record<string, unknown>>;
+declare const feasibleTreeWithLayer: (g: IGraph) => Graph<Record<string, unknown>, Record<string, unknown>>;
+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>;
+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;
+    y?: number;
+    width?: number;
+    height?: number;
+}, point: {
+    x?: number;
+    y?: number;
+}) => {
+    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/force/index.d.ts

@@ -1,4 +1,4 @@
-import { Graph, LayoutMapping, ForceLayoutOptions, SyncLayout, Point } from "../types";
+import { Graph, LayoutMapping, ForceLayoutOptions, Point, LayoutWithIterations } from "../types";
 import { CalcGraph, FormatedOptions } from "./types";
 /**
  * Layout with faster force
@@ -6,16 +6,16 @@ import { CalcGraph, FormatedOptions } from "./types";
  * @example
  * // Assign layout options when initialization.
  * const layout = new ForceLayout({ center: [100, 100] });
- * const positions = layout.execute(graph); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
  *
  * // Or use different options later.
  * const layout = new ForceLayout({ center: [100, 100] });
- * const positions = layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }
  *
  * // If you want to assign the positions directly to the nodes, use assign method.
- * layout.assign(graph, { center: [100, 100] });
+ * await layout.assign(graph, { center: [100, 100] });
  */
-export declare class ForceLayout implements SyncLayout<ForceLayoutOptions> {
+export declare class ForceLayout implements LayoutWithIterations<ForceLayoutOptions> {
     options: ForceLayoutOptions;
     id: string;
     /**
@@ -26,15 +26,33 @@ export declare class ForceLayout implements SyncLayout<ForceLayoutOptions> {
      * compare with minMovement to end the nodes' movement
      */
     private judgingDistance;
+    private running;
+    private lastLayoutNodes;
+    private lastLayoutEdges;
+    private lastAssign;
+    private lastCalcGraph;
+    private lastGraph;
+    private lastOptions;
+    private lastVelMap;
+    private lastResult;
     constructor(options?: ForceLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: ForceLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: ForceLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: ForceLayoutOptions): void;
+    assign(graph: Graph, options?: ForceLayoutOptions): Promise<void>;
+    /**
+     * Stop simulation immediately.
+     */
+    stop(): void;
+    /**
+     * Manually steps the simulation by the specified number of iterations.
+     * @see https://github.com/d3/d3-force#simulation_tick
+     */
+    tick(iterations?: number): LayoutMapping;
     private genericForceLayout;
     /**
      * Format merged layout options.
@@ -117,9 +135,4 @@ export declare class ForceLayout implements SyncLayout<ForceLayoutOptions> {
     updatePosition(graph: Graph, calcGraph: CalcGraph, velMap: {
         [id: string]: Point;
     }, options: FormatedOptions): void;
-    /**
-     * Stop the animation for no-silence force.
-     * TODO: confirm the controller and worker's controller
-     */
-    stop(): void;
 }

package/lib/force/types.d.ts

@@ -6,13 +6,13 @@ export interface CalcNodeData extends NodeData {
     mass: number;
     nodeStrength: number;
 }
-export type CalcNode = INode<CalcNodeData>;
+export declare type CalcNode = INode<CalcNodeData>;
 export interface CalcEdgeData extends EdgeData {
     linkDistance?: number;
     edgeStrength?: number;
 }
-export type CalcEdge = IEdge<CalcEdgeData>;
-export type CalcGraph = IGraph<CalcNodeData, CalcEdgeData>;
+export declare type CalcEdge = IEdge<CalcEdgeData>;
+export declare type CalcGraph = IGraph<CalcNodeData, CalcEdgeData>;
 interface FormatCentripetalOptions extends CentripetalOptions {
     leaf: (node: Node, nodes: Node[], edges: Edge[]) => number;
     /** Force strength for single nodes. */

package/lib/forceAtlas2/body.d.ts

@@ -0,0 +1,33 @@
+import Quad from './quad';
+/**
+ * @fileOverview body
+ * @author shiwu.wyy@antfin.com
+ */
+declare type BodyProps = {
+    id?: Number;
+    rx: number;
+    ry: number;
+    fx?: number;
+    fy?: number;
+    mass: number;
+    degree: number;
+    g?: number;
+};
+export default class Body {
+    id: Number;
+    rx: number;
+    ry: number;
+    fx: number;
+    fy: number;
+    mass: number;
+    degree: number;
+    g: number;
+    constructor(params: BodyProps);
+    distanceTo(bo: Body): number;
+    setPos(x: number, y: number): void;
+    resetForce(): void;
+    addForce(b: Body): void;
+    in(quad: Quad): boolean;
+    add(bo: Body): Body;
+}
+export {};