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

package/lib/Circular.d.ts

@@ -5,14 +5,14 @@ import type { Graph, CircularLayoutOptions, Layout, LayoutMapping } from "./type
  * @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 Layout<CircularLayoutOptions> {
     options: CircularLayoutOptions;
@@ -21,10 +21,10 @@ export declare class CircularLayout implements Layout<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/Supervisor.d.ts

@@ -13,16 +13,6 @@ export interface Payload {
     nodes: Node<any>[];
     edges: Edge<any>[];
 }
-export declare const SupervisorEvent: {
-    /**
-     * Get triggerred when each iteration finished.
-     */
-    LAYOUT_ITERATION: string;
-    /**
-     * Get triggerred when layout calculation is done.
-     */
-    LAYOUT_END: string;
-};
 interface SupervisorOptions {
     /**
      * Iterations run in algorithm such as d3force, will be passed in `tick()` later.
@@ -34,21 +24,10 @@ interface SupervisorOptions {
  * const graph = new Graph();
  * const layout = new CircularLayout();
  *
- * const supervisor = new Supervisor(graph, layout, { auto: true });
- * supervisor.start();
+ * const supervisor = new Supervisor(graph, layout, { iterations: 1000 });
+ * const positions = await supervisor.execute();
  * supervisor.stop();
  * supervisor.kill();
- *
- * // lifecycle
- * supervisor.on('tick', () => {
- * });
- * supervisor.on('layoutend', () => {
- * });
- *
- * // Re-layout when graph changed.
- * graph.addNodes([{ id: 'node1' }, { id: 'node2' }]);
- *
- * // TODO: Custom layout.
  */
 export declare class Supervisor extends EventEmitter implements LayoutSupervisor {
     private graph;
@@ -64,7 +43,7 @@ export declare class Supervisor extends EventEmitter implements LayoutSupervisor
     private running;
     constructor(graph: Graph<any, any>, layout: Layout<any>, options?: Partial<SupervisorOptions> | undefined);
     spawnWorker(): void;
-    start(): this;
+    execute(): Promise<any>;
     stop(): this;
     kill(): void;
     isRunning(): boolean;

package/lib/concentric.d.ts

@@ -5,14 +5,14 @@ import type { Graph, LayoutMapping, ConcentricLayoutOptions, Layout } from "./ty
  * @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 Layout<ConcentricLayoutOptions> {
     options: ConcentricLayoutOptions;
@@ -21,10 +21,10 @@ export declare class ConcentricLayout implements Layout<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/index.d.ts

@@ -6,14 +6,14 @@ import { Graph, Node, LayoutMapping, OutNode, D3ForceLayoutOptions, Edge, Layout
  * @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 LayoutWithIterations<D3ForceLayoutOptions> {
     options: D3ForceLayoutOptions;
@@ -23,25 +23,21 @@ export declare class D3ForceLayout implements LayoutWithIterations<D3ForceLayout
     private lastLayoutEdges;
     private lastAssign;
     private lastGraph;
-    private lastOptions;
-    private running;
     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;
-    restart(): void;
     /**
      * Manually steps the simulation by the specified number of iterations.
-     * When finished it will trigger `onLayoutEnd` callback.
      * @see https://github.com/d3/d3-force#simulation_tick
      */
     tick(iterations?: number): {

package/lib/force/index.d.ts

@@ -6,14 +6,14 @@ 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 LayoutWithIterations<ForceLayoutOptions> {
     options: ForceLayoutOptions;
@@ -39,19 +39,17 @@ export declare class ForceLayout implements LayoutWithIterations<ForceLayoutOpti
     /**
      * 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;
-    restart(): void;
     /**
      * Manually steps the simulation by the specified number of iterations.
-     * When finished it will trigger `onLayoutEnd` callback.
      * @see https://github.com/d3/d3-force#simulation_tick
      */
     tick(iterations?: number): LayoutMapping;

package/lib/forceAtlas2/index.d.ts

@@ -1,34 +1,31 @@
-import type { Graph, LayoutMapping, ForceAtlas2LayoutOptions, LayoutWithIterations } from "../types";
+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 = layout.execute(graph); // { nodes: [], edges: [] }
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
  *
  * // Or use different options later.
  * const layout = new ForceAtlas2Layout({ 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 ForceAtlas2Layout implements LayoutWithIterations<ForceAtlas2LayoutOptions> {
+export declare class ForceAtlas2Layout implements Layout<ForceAtlas2LayoutOptions> {
     options: ForceAtlas2LayoutOptions;
     id: string;
     constructor(options?: ForceAtlas2LayoutOptions);
-    stop: () => void;
-    restart: () => void;
-    tick: (iterations?: number | undefined) => LayoutMapping;
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: ForceAtlas2LayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: ForceAtlas2LayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: ForceAtlas2LayoutOptions): void;
+    assign(graph: Graph, options?: ForceAtlas2LayoutOptions): Promise<void>;
     private genericForceAtlas2Layout;
     /**
      * Init the node positions if there is no initial positions.

package/lib/fruchterman.d.ts

@@ -5,14 +5,14 @@ import type { Graph, LayoutMapping, FruchtermanLayoutOptions, LayoutWithIteratio
  * @example
  * // Assign layout options when initialization.
  * const layout = new FruchtermanLayout({ 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 FruchtermanLayout({ 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 FruchtermanLayout implements LayoutWithIterations<FruchtermanLayoutOptions> {
     options: FruchtermanLayoutOptions;
@@ -30,19 +30,17 @@ export declare class FruchtermanLayout implements LayoutWithIterations<Fruchterm
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: FruchtermanLayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: FruchtermanLayoutOptions): Promise<LayoutMapping>;
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: FruchtermanLayoutOptions): void;
+    assign(graph: Graph, options?: FruchtermanLayoutOptions): Promise<void>;
     /**
      * Stop simulation immediately.
      */
     stop(): void;
-    restart(): void;
     /**
      * Manually steps the simulation by the specified number of iterations.
-     * When finished it will trigger `onLayoutEnd` callback.
      * @see https://github.com/d3/d3-force#simulation_tick
      */
     tick(iterations?: number): LayoutMapping;

package/lib/grid.d.ts

@@ -5,14 +5,14 @@ import type { Graph, GridLayoutOptions, LayoutMapping, Layout } from "./types";
  * @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 Layout<GridLayoutOptions> {
     options: GridLayoutOptions;
@@ -21,10 +21,10 @@ export declare class GridLayout implements Layout<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/mds.d.ts

@@ -5,14 +5,14 @@ import type { Graph, LayoutMapping, MDSLayoutOptions, Layout } from "./types";
  * @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 Layout<MDSLayoutOptions> {
     options: MDSLayoutOptions;
@@ -21,10 +21,10 @@ export declare class MDSLayout implements Layout<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

@@ -5,14 +5,14 @@ import type { Graph, LayoutMapping, RadialLayoutOptions, Layout } from "../types
  * @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 Layout<RadialLayoutOptions> {
     options: RadialLayoutOptions;
@@ -21,11 +21,11 @@ export declare class RadialLayout implements Layout<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/random.d.ts

@@ -5,14 +5,14 @@ import type { Graph, LayoutMapping, RandomLayoutOptions, Layout } from "./types"
  * @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 Layout<RandomLayoutOptions> {
     options: RandomLayoutOptions;
@@ -21,10 +21,10 @@ export declare class RandomLayout implements Layout<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/types.d.ts

@@ -1,6 +1,5 @@
 import { Graph as IGraph, Node as INode, Edge as IEdge, PlainObject, GraphView as IGraphView } from "@antv/graphlib";
 export interface NodeData extends PlainObject {
-    visible?: boolean;
     size?: number | number[];
     bboxSize?: number[];
 }
@@ -9,7 +8,6 @@ export interface OutNodeData extends NodeData {
     y: number;
 }
 export interface EdgeData extends PlainObject {
-    visible?: boolean;
     virtual?: boolean;
 }
 /** input node */
@@ -42,11 +40,11 @@ export interface Layout<LayoutOptions> {
     /**
      * To directly assign the positions to the nodes.
      */
-    assign(graph: Graph, options?: LayoutOptions): void;
+    assign(graph: Graph, options?: LayoutOptions): Promise<void>;
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    execute(graph: Graph, options?: LayoutOptions): LayoutMapping;
+    execute(graph: Graph, options?: LayoutOptions): Promise<LayoutMapping>;
     /**
      * Layout options, can be changed in runtime.
      */
@@ -64,11 +62,6 @@ export interface LayoutWithIterations<LayoutOptions> extends Layout<LayoutOption
      * @see https://github.com/d3/d3-force#simulation_stop
      */
     stop: () => void;
-    /**
-     * Restarts the simulation’s internal timer and returns the simulation.
-     * @see https://github.com/d3/d3-force#simulation_restart
-     */
-    restart: () => void;
     /**
      * Manually steps the simulation by the specified number of iterations.
      * @see https://github.com/d3/d3-force#simulation_tick
@@ -79,15 +72,12 @@ export interface LayoutConstructor<LayoutOptions> {
     new (options?: LayoutOptions): Layout<LayoutOptions>;
 }
 export interface LayoutSupervisor {
-    start(): void;
+    execute(): Promise<LayoutMapping>;
     stop(): void;
     kill(): void;
     isRunning(): boolean;
 }
-interface CommonOptions {
-    onLayoutEnd?: (data: LayoutMapping) => void;
-}
-export interface CircularLayoutOptions extends CommonOptions {
+export interface CircularLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -103,7 +93,7 @@ export interface CircularLayoutOptions extends CommonOptions {
     nodeSpacing?: ((node?: Node) => number) | number;
     nodeSize?: number | number[];
 }
-export interface GridLayoutOptions extends CommonOptions {
+export interface GridLayoutOptions {
     width?: number;
     height?: number;
     begin?: PointTuple;
@@ -120,16 +110,16 @@ export interface GridLayoutOptions extends CommonOptions {
     };
     nodeSpacing?: ((node?: Node) => number) | number;
 }
-export interface RandomLayoutOptions extends CommonOptions {
+export interface RandomLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
 }
-export interface MDSLayoutOptions extends CommonOptions {
+export interface MDSLayoutOptions {
     center?: PointTuple;
     linkDistance?: number;
 }
-export interface ConcentricLayoutOptions extends CommonOptions {
+export interface ConcentricLayoutOptions {
     center?: PointTuple;
     preventOverlap?: boolean;
     nodeSize?: number | PointTuple;
@@ -143,7 +133,7 @@ export interface ConcentricLayoutOptions extends CommonOptions {
     height?: number;
     nodeSpacing?: number | number[] | ((node?: Node) => number);
 }
-export interface RadialLayoutOptions extends CommonOptions {
+export interface RadialLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -159,7 +149,7 @@ export interface RadialLayoutOptions extends CommonOptions {
     sortBy?: string;
     sortStrength?: number;
 }
-export interface DagreLayoutOptions extends CommonOptions {
+export interface DagreLayoutOptions {
     rankdir?: "TB" | "BT" | "LR" | "RL";
     align?: "UL" | "UR" | "DL" | "DR";
     begin?: PointTuple;
@@ -179,7 +169,7 @@ export interface DagreLayoutOptions extends CommonOptions {
     nodesepFunc?: (d?: Node) => number;
     ranksepFunc?: (d?: Node) => number;
 }
-export interface D3ForceLayoutOptions extends CommonOptions {
+export interface D3ForceLayoutOptions {
     center?: PointTuple;
     linkDistance?: number | ((edge?: Edge) => number);
     edgeStrength?: number | ((edge?: Edge) => number);
@@ -214,7 +204,7 @@ export interface CentripetalOptions {
         centerStrength?: number;
     };
 }
-export interface ForceLayoutOptions extends CommonOptions {
+export interface ForceLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -249,7 +239,7 @@ export interface ForceLayoutOptions extends CommonOptions {
         iterations: number;
     }) => void;
 }
-export interface ForceAtlas2LayoutOptions extends CommonOptions {
+export interface ForceAtlas2LayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -267,7 +257,7 @@ export interface ForceAtlas2LayoutOptions extends CommonOptions {
     nodeSize?: number | number[] | ((node?: Node) => number);
     onTick?: (data: LayoutMapping) => void;
 }
-export interface FruchtermanLayoutOptions extends CommonOptions {
+export interface FruchtermanLayoutOptions {
     center?: PointTuple;
     maxIteration?: number;
     width?: number;
@@ -279,4 +269,3 @@ export interface FruchtermanLayoutOptions extends CommonOptions {
     nodeClusterBy?: string;
     onTick?: (data: LayoutMapping) => void;
 }
-export {};

package/lib/util/common.d.ts

@@ -1,18 +1,16 @@
-import { PointTuple, LayoutMapping, Graph } from "../types";
+import { PointTuple, Graph } from "../types";
 /**
  * Assign or only return the result for the graph who has no nodes or only one node.
  * @param graph original graph
  * @param assign whether assign result to original graph
  * @param center the layout center
- * @param onLayoutEnd callback for layout end
  * @returns
  */
-export declare const handleSingleNodeGraph: (graph: Graph, assign: boolean, center: PointTuple, onLayoutEnd?: ((data: LayoutMapping) => void) | undefined) => {
+export declare const handleSingleNodeGraph: (graph: Graph, assign: boolean, center: PointTuple) => {
     nodes: {
         data: {
             x: number;
             y: number;
-            visible?: boolean | undefined;
             size?: number | number[] | undefined;
             bboxSize?: number[] | undefined;
         };

package/lib/worker.d.ts

@@ -1,3 +1,3 @@
 import type { Payload } from "./supervisor";
 export declare function stopLayout(): void;
-export declare function calculateLayout(payload: Payload, transferables: Float32Array[]): Promise<unknown>;
+export declare function calculateLayout(payload: Payload, transferables: Float32Array[]): Promise<(import("./types").LayoutMapping | Float32Array[])[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/layout",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.17",
   "description": "graph layout algorithm",
   "main": "dist/index.min.js",
   "module": "esm/index.esm.js",
@@ -21,7 +21,7 @@
     "antv"
   ],
   "dependencies": {
-    "@antv/graphlib": "^2.0.0-alpha.3",
+    "@antv/graphlib": "^2.0.0",
     "@antv/util": "^3.0.0",
     "@naoak/workerize-transferable": "^0.1.0",
     "d3-force": "^3.0.0",