@antv/layout 1.0.0-alpha.8 → 1.0.0

package/lib/forceAtlas2/index.d.ts

@@ -0,0 +1,106 @@
+import type { Graph, LayoutMapping, ForceAtlas2LayoutOptions, Layout } from "../types";
+/**
+ * Layout nodes with force atlas 2 model
+ *
+ * @example
+ * // Assign layout options when initialization.
+ * const layout = new ForceAtlas2Layout({ center: [100, 100] });
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
+ *
+ * // Or use different options later.
+ * const layout = new ForceAtlas2Layout({ center: [100, 100] });
+ * 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.
+ * await layout.assign(graph, { center: [100, 100] });
+ */
+export declare class ForceAtlas2Layout implements Layout<ForceAtlas2LayoutOptions> {
+    options: ForceAtlas2LayoutOptions;
+    id: string;
+    constructor(options?: ForceAtlas2LayoutOptions);
+    /**
+     * Return the positions of nodes and edges(if needed).
+     */
+    execute(graph: Graph, options?: ForceAtlas2LayoutOptions): Promise<LayoutMapping>;
+    /**
+     * To directly assign the positions to the nodes.
+     */
+    assign(graph: Graph, options?: ForceAtlas2LayoutOptions): Promise<void>;
+    private genericForceAtlas2Layout;
+    /**
+     * Init the node positions if there is no initial positions.
+     * And pre-calculate the size (max of width and height) for each node.
+     * @param calcGraph graph for calculation
+     * @param graph origin graph
+     * @param nodeSize node size config from layout options
+     * @returns {SizeMap} node'id mapped to max of its width and height
+     */
+    private getSizes;
+    /**
+     * Format the options.
+     * @param options input options
+     * @param nodeNum number of nodes
+     * @returns formatted options
+     */
+    private formatOptions;
+    /**
+     * Loops for fa2.
+     * @param calcGraph graph for calculation
+     * @param graph original graph
+     * @param iteration iteration number
+     * @param sizes nodes' size
+     * @param options formatted layout options
+     * @returns
+     */
+    private run;
+    /**
+     * One step for a loop.
+     * @param graph graph for calculation
+     * @param params parameters for a loop
+     * @param options formatted layout's input options
+     * @returns
+     */
+    private oneStep;
+    /**
+     * Calculate the attract forces for nodes.
+     * @param graph graph for calculation
+     * @param iter current iteration index
+     * @param preventOverlapIters the iteration number for preventing overlappings
+     * @param sizes nodes' sizes
+     * @param forces forces for nodes, which will be modified
+     * @param options formatted layout's input options
+     * @returns
+     */
+    private getAttrForces;
+    /**
+     * Calculate the repulsive forces for nodes under barnesHut mode.
+     * @param graph graph for calculatiion
+     * @param forces forces for nodes, which will be modified
+     * @param bodies force body map
+     * @param options formatted layout's input options
+     * @returns
+     */
+    private getOptRepGraForces;
+    /**
+     * Calculate the repulsive forces for nodes.
+     * @param graph graph for calculatiion
+     * @param iter current iteration index
+     * @param preventOverlapIters the iteration number for preventing overlappings
+     * @param forces forces for nodes, which will be modified
+     * @param krPrime larger the krPrime, larger the repulsive force
+     * @param sizes nodes' sizes
+     * @param options formatted layout's input options
+     * @returns
+     */
+    private getRepGraForces;
+    /**
+     * Update node positions.
+     * @param graph graph for calculatiion
+     * @param forces forces for nodes, which will be modified
+     * @param preForces previous forces for nodes, which will be modified
+     * @param sg constant for move distance of one step
+     * @param options formatted layout's input options
+     * @returns
+     */
+    private updatePos;
+}

package/lib/forceAtlas2/quad.d.ts

@@ -0,0 +1,27 @@
+import { PointTuple } from "../types";
+/**
+ * @fileOverview quad
+ * @author shiwu.wyy@antfin.com
+ */
+declare type QuadProps = {
+    xmid: number;
+    ymid: number;
+    length: number;
+    massCenter?: PointTuple;
+    mass?: number;
+};
+export default class Quad {
+    xmid: number;
+    ymid: number;
+    length: number;
+    massCenter: PointTuple;
+    mass: number;
+    constructor(params: QuadProps);
+    getLength(): number;
+    contains(x: number, y: number): boolean;
+    NW(): Quad;
+    NE(): Quad;
+    SW(): Quad;
+    SE(): Quad;
+}
+export {};

package/lib/forceAtlas2/quadTree.d.ts

@@ -0,0 +1,20 @@
+import Body from './body';
+import Quad from './quad';
+/**
+ * @fileOverview quadTree
+ * @author shiwu.wyy@antfin.com
+ */
+export default class QuadTree {
+    body: Body | null;
+    quad: Quad | null;
+    theta: number;
+    NW: QuadTree | null;
+    NE: QuadTree | null;
+    SW: QuadTree | null;
+    SE: QuadTree | null;
+    constructor(param: Quad | null);
+    insert(bo: Body): void;
+    _putBody(bo: Body): void;
+    _isExternal(): boolean;
+    updateForce(bo: Body): void;
+}

package/lib/fruchterman.d.ts

@@ -0,0 +1,53 @@
+import type { Graph, LayoutMapping, FruchtermanLayoutOptions, LayoutWithIterations } from "./types";
+/**
+ * Layout with fructherman force model
+ *
+ * @example
+ * // Assign layout options when initialization.
+ * const layout = new FruchtermanLayout({ center: [100, 100] });
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
+ *
+ * // Or use different options later.
+ * const layout = new FruchtermanLayout({ center: [100, 100] });
+ * 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.
+ * await layout.assign(graph, { center: [100, 100] });
+ */
+export declare class FruchtermanLayout implements LayoutWithIterations<FruchtermanLayoutOptions> {
+    options: FruchtermanLayoutOptions;
+    id: string;
+    private timeInterval;
+    private running;
+    private lastLayoutNodes;
+    private lastLayoutEdges;
+    private lastAssign;
+    private lastGraph;
+    private lastOptions;
+    private lastClusterMap;
+    private lastResult;
+    constructor(options?: FruchtermanLayoutOptions);
+    /**
+     * Return the positions of nodes and edges(if needed).
+     */
+    execute(graph: Graph, options?: FruchtermanLayoutOptions): Promise<LayoutMapping>;
+    /**
+     * To directly assign the positions to the nodes.
+     */
+    assign(graph: Graph, options?: FruchtermanLayoutOptions): 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 genericFruchtermanLayout;
+    private formatOptions;
+    private runOneStep;
+    private applyCalculate;
+    private calRepulsive;
+    private calAttractive;
+}

package/lib/grid.d.ts

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

package/lib/index.d.ts

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

package/lib/mds.d.ts

@@ -1,30 +1,30 @@
-import type { Graph, LayoutMapping, MDSLayoutOptions, SyncLayout } from "./types";
+import type { Graph, LayoutMapping, MDSLayoutOptions, Layout } from "./types";
 /**
  * Layout arranging the nodes with multiple dimensional scaling algorithm
  *
  * @example
  * // Assign layout options when initialization.
  * const layout = new MDSLayout({ 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 MDSLayout({ center: [100, 100] });
- * const positions = layout.execute(graph, { rows: 20 }); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph, { rows: 20 }); // { 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 MDSLayout implements SyncLayout<MDSLayoutOptions> {
+export declare class MDSLayout implements Layout<MDSLayoutOptions> {
     options: MDSLayoutOptions;
     id: string;
     constructor(options?: MDSLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: MDSLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: MDSLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: MDSLayoutOptions): void;
+    assign(graph: Graph, options?: MDSLayoutOptions): Promise<void>;
     private genericMDSLayout;
 }

package/lib/radial/index.d.ts

@@ -1,31 +1,31 @@
-import type { Graph, LayoutMapping, RadialLayoutOptions, SyncLayout } from "../types";
+import type { Graph, LayoutMapping, RadialLayoutOptions, Layout } from "../types";
 /**
  * Layout arranging the nodes' on a radial shape
  *
  * @example
  * // Assign layout options when initialization.
  * const layout = new RadialLayout({ focusNode: 'node0' });
- * const positions = layout.execute(graph); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
  *
  * // Or use different options later.
  * const layout = new RadialLayout({ focusNode: 'node0' });
- * const positions = layout.execute(graph, { focusNode: 'node0' }); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph, { focusNode: 'node0' }); // { nodes: [], edges: [] }
  *
  * // If you want to assign the positions directly to the nodes, use assign method.
- * layout.assign(graph, { focusNode: 'node0' });
+ * await layout.assign(graph, { focusNode: 'node0' });
  */
-export declare class RadialLayout implements SyncLayout<RadialLayoutOptions> {
+export declare class RadialLayout implements Layout<RadialLayoutOptions> {
     options: RadialLayoutOptions;
     id: string;
     constructor(options?: RadialLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: RadialLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: RadialLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: RadialLayoutOptions): void;
+    assign(graph: Graph, options?: RadialLayoutOptions): Promise<void>;
     private genericRadialLayout;
     private run;
     private oneIteration;

package/lib/radial/{RadialNonoverlapForce.d.ts → radial-nonoverlap-force.d.ts}

@@ -1,5 +1,5 @@
 import type { Graph, Node, Point } from "../types";
-export type RadialNonoverlapForceOptions = {
+export declare type RadialNonoverlapForceOptions = {
     positions: Point[];
     focusIdx: number;
     radii: number[];

package/lib/random.d.ts

@@ -1,30 +1,30 @@
-import type { Graph, LayoutMapping, RandomLayoutOptions, SyncLayout } from "./types";
+import type { Graph, LayoutMapping, RandomLayoutOptions, Layout } from "./types";
 /**
  * Layout randomizing the nodes' position
  *
  * @example
  * // Assign layout options when initialization.
  * const layout = new RandomLayout({ 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 RandomLayout({ 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 RandomLayout implements SyncLayout<RandomLayoutOptions> {
+export declare class RandomLayout implements Layout<RandomLayoutOptions> {
     options: RandomLayoutOptions;
     id: string;
     constructor(options?: RandomLayoutOptions);
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: RandomLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: RandomLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: RandomLayoutOptions): void;
+    assign(graph: Graph, options?: RandomLayoutOptions): Promise<void>;
     private genericRandomLayout;
 }

package/lib/registry.d.ts

@@ -1,3 +1,3 @@
-import type { SyncLayoutConstructor } from "./types";
-export declare const registry: Record<string, SyncLayoutConstructor<any>>;
-export declare function registerLayout(id: string, layout: SyncLayoutConstructor<any>): void;
+import type { LayoutConstructor } from "./types";
+export declare const registry: Record<string, LayoutConstructor<any>>;
+export declare function registerLayout(id: string, layout: LayoutConstructor<any>): void;

package/lib/supervisor.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from "eventemitter3";
+import { Graph, Node, Edge } from "@antv/graphlib";
+import type { Layout, LayoutSupervisor } from "./types";
+/**
+ * The payload transferred from main thread to the worker.
+ */
+export interface Payload {
+    layout: {
+        id: string;
+        options: any;
+        iterations: number;
+    };
+    nodes: Node<any>[];
+    edges: Edge<any>[];
+}
+interface SupervisorOptions {
+    /**
+     * Iterations run in algorithm such as d3force, will be passed in `tick()` later.
+     */
+    iterations: number;
+}
+/**
+ * @example
+ * const graph = new Graph();
+ * const layout = new CircularLayout();
+ *
+ * const supervisor = new Supervisor(graph, layout, { iterations: 1000 });
+ * const positions = await supervisor.execute();
+ * supervisor.stop();
+ * supervisor.kill();
+ */
+export declare class Supervisor extends EventEmitter implements LayoutSupervisor {
+    private graph;
+    private layout;
+    private options?;
+    /**
+     * Internal worker.
+     */
+    private worker;
+    /**
+     * Flag of running state.
+     */
+    private running;
+    constructor(graph: Graph<any, any>, layout: Layout<any>, options?: Partial<SupervisorOptions>);
+    spawnWorker(): void;
+    execute(): Promise<any>;
+    stop(): this;
+    kill(): void;
+    isRunning(): boolean;
+}
+export {};