@antv/layout 1.0.0-alpha.9 → 1.1.0

package/lib/types.d.ts

@@ -1,62 +1,111 @@
-import { Graph as IGraph, Node as INode, Edge as IEdge, PlainObject } 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 {
-    visible?: boolean;
     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;
+    _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;
     y: number;
 }
 export interface EdgeData extends PlainObject {
-    visible?: boolean;
     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>;
+export declare type Node = INode<NodeData>;
 /** output node */
-export type OutNode = INode<OutNodeData>;
+export declare type OutNode = INode<OutNodeData>;
 /** input and output edge */
-export type Edge = IEdge<EdgeData>;
-export type Degree = {
+export declare type Edge = IEdge<EdgeData>;
+export declare type Degree = {
     in: number;
     out: number;
     all: number;
 };
-export type IndexMap = {
+export declare type IndexMap = {
     [nodeId: string]: number;
 };
-export type Graph = IGraph<NodeData, EdgeData>;
-export type PointTuple = [number, number];
-export type Point = {
+export declare type Graph = IGraph<NodeData, EdgeData>;
+export declare type GraphView = IGraphView<NodeData, EdgeData>;
+export declare type PointTuple = [number, number];
+export declare type Point = {
     x: number;
     y: number;
 };
-export type Matrix = number[];
-export type LayoutMapping = {
+export declare type Matrix = number[];
+export declare type LayoutMapping = {
     nodes: OutNode[];
     edges: Edge[];
 };
-export interface SyncLayout<LayoutOptions> {
-    assign(graph: Graph, options?: LayoutOptions): void;
-    execute(graph: Graph, options?: LayoutOptions): LayoutMapping;
+export interface Layout<LayoutOptions> {
+    /**
+     * To directly assign the positions to the nodes.
+     */
+    assign(graph: Graph, options?: LayoutOptions): Promise<void>;
+    /**
+     * Return the positions of nodes and edges(if needed).
+     */
+    execute(graph: Graph, options?: LayoutOptions): Promise<LayoutMapping>;
+    /**
+     * Layout options, can be changed in runtime.
+     */
     options: LayoutOptions;
+    /**
+     * Unique ID, it will get registered and used on the webworker-side.
+     */
     id: string;
 }
-export interface SyncLayoutConstructor<LayoutOptions> {
-    new (options?: LayoutOptions): SyncLayout<LayoutOptions>;
+export declare function isLayoutWithIterations(layout: any): layout is LayoutWithIterations<any>;
+export interface LayoutWithIterations<LayoutOptions> extends Layout<LayoutOptions> {
+    /**
+     * Some layout algorithm has n iterations so that the simulation needs to be stopped at any time.
+     * This method is useful for running the simulation manually.
+     * @see https://github.com/d3/d3-force#simulation_stop
+     */
+    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;
+}
+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 {
-    layoutInvisibles?: boolean;
-    onLayoutEnd?: (data: LayoutMapping) => void;
-}
-export interface CircularLayoutOptions extends CommonOptions {
+export interface CircularLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -72,7 +121,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;
@@ -83,26 +132,25 @@ export interface GridLayoutOptions extends CommonOptions {
     rows?: number;
     cols?: number;
     sortBy?: string;
-    position?: ((node?: Node) => {
+    position?: (node?: Node) => {
         row?: number;
         col?: number;
-    }) | undefined;
-    nodeSpacing?: ((node?: Node) => number) | number | undefined;
+    };
+    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;
-    minNodeSpacing?: number;
     sweep?: number;
     equidistant?: boolean;
     startAngle?: number;
@@ -111,9 +159,9 @@ export interface ConcentricLayoutOptions extends CommonOptions {
     sortBy?: string;
     width?: number;
     height?: number;
-    nodeSpacing?: number | number[] | ((node?: Node) => number) | undefined;
+    nodeSpacing?: number | number[] | ((node?: Node) => number);
 }
-export interface RadialLayoutOptions extends CommonOptions {
+export interface RadialLayoutOptions {
     center?: PointTuple;
     width?: number;
     height?: number;
@@ -122,18 +170,20 @@ export interface RadialLayoutOptions extends CommonOptions {
     focusNode?: string | Node | null;
     unitRadius?: number | null;
     preventOverlap?: boolean;
-    nodeSize?: number | number[] | undefined;
-    nodeSpacing?: number | Function | undefined;
+    nodeSize?: number | number[];
+    nodeSpacing?: number | Function;
     maxPreventOverlapIteration?: number;
     strictRadial?: boolean;
-    sortBy?: string | undefined;
+    sortBy?: string;
     sortStrength?: number;
 }
-export interface DagreLayoutOptions extends CommonOptions {
-    rankdir?: "TB" | "BT" | "LR" | "RL";
-    align?: "UL" | "UR" | "DL" | "DR";
+export declare type DagreRankdir = "TB" | "BT" | "LR" | "RL" | "tb" | "lr" | "rl" | "bt";
+export declare type DagreAlign = "UL" | "UR" | "DL" | "DR";
+export interface DagreLayoutOptions {
+    rankdir?: DagreRankdir;
+    align?: DagreAlign;
     begin?: PointTuple;
-    nodeSize?: number | number[] | undefined;
+    nodeSize?: number | number[];
     nodesep?: number;
     ranksep?: number;
     controlPoints?: boolean;
@@ -141,23 +191,23 @@ export interface DagreLayoutOptions extends CommonOptions {
     edgeLabelSpace?: boolean;
     nodeOrder?: string[];
     radial?: boolean;
-    focusNode: string | Node | null;
+    focusNode?: ID | Node | null;
     preset?: {
         nodes: OutNode[];
         edges: Edge[];
     };
-    nodesepFunc?: ((d?: Node) => number) | undefined;
-    ranksepFunc?: ((d?: Node) => number) | undefined;
+    nodesepFunc?: (d?: Node) => number;
+    ranksepFunc?: (d?: Node) => number;
 }
-export interface D3ForceLayoutOptions extends CommonOptions {
+export interface D3ForceLayoutOptions {
     center?: PointTuple;
-    linkDistance?: number | ((edge?: Edge) => number) | undefined;
-    edgeStrength?: number | ((edge?: Edge) => number) | undefined;
-    nodeStrength?: number | ((node: Node, i: number, nodes: Node[]) => number) | undefined;
+    linkDistance?: number | ((edge?: Edge) => number);
+    edgeStrength?: number | ((edge?: Edge) => number);
+    nodeStrength?: number | ((node?: Node) => number);
     preventOverlap?: boolean;
     collideStrength?: number;
-    nodeSize?: number | number[] | ((node?: Node) => number) | undefined;
-    nodeSpacing?: number | number[] | ((node?: Node) => number) | undefined;
+    nodeSize?: number | number[] | ((node?: Node) => number);
+    nodeSpacing?: number | number[] | ((node?: Node) => number);
     alpha?: number;
     alphaDecay?: number;
     alphaMin?: number;
@@ -184,18 +234,27 @@ export interface CentripetalOptions {
         centerStrength?: number;
     };
 }
-export interface ForceLayoutOptions extends CommonOptions {
+interface CommonForceLayoutOptions {
     center?: PointTuple;
+    minMovement?: number;
+    maxIteration?: number;
+    distanceThresholdMode?: "mean" | "max" | "min";
+    /**
+     * If distance is specified, sets the maximum distance between nodes over which this force is considered.
+     * If distance is not specified, returns the current maximum distance, which defaults to infinity.
+     * Specifying a finite maximum distance improves performance and produces a more localized layout.
+     */
+    maxDistance?: number;
+}
+export interface ForceLayoutOptions extends CommonForceLayoutOptions {
     width?: number;
     height?: number;
-    linkDistance?: number | ((edge?: Edge, source?: any, target?: any) => number) | undefined;
-    nodeStrength?: number | ((d?: Node) => number) | undefined;
-    edgeStrength?: number | ((d?: Edge) => number) | undefined;
+    linkDistance?: number | ((edge?: Edge, source?: any, target?: any) => number);
+    nodeStrength?: number | ((d?: Node) => number);
+    edgeStrength?: number | ((d?: Edge) => number);
     preventOverlap?: boolean;
     nodeSize?: number | number[] | ((d?: Node) => number);
     nodeSpacing?: number | ((d?: Node) => number);
-    minMovement?: number;
-    maxIteration?: number;
     damping?: number;
     maxSpeed?: number;
     coulombDisScale?: number;
@@ -208,11 +267,9 @@ export interface ForceLayoutOptions extends CommonOptions {
     nodeClusterBy?: string;
     clusterNodeStrength?: number | ((node: Node) => number);
     collideStrength?: number;
-    distanceThresholdMode?: "mean" | "max" | "min";
-    animate?: boolean;
     onTick?: (data: LayoutMapping) => void;
-    getMass?: ((d: Node) => number) | undefined;
-    getCenter?: ((d?: Node, degree?: number) => number[]) | undefined;
+    getMass?: (node?: Node) => number;
+    getCenter?: (node?: Node, degree?: number) => number[];
     monitor?: (params: {
         energy: number;
         nodes: Node[];
@@ -220,4 +277,30 @@ export interface ForceLayoutOptions extends CommonOptions {
         iterations: number;
     }) => void;
 }
+export interface ForceAtlas2LayoutOptions extends CommonForceLayoutOptions {
+    width?: number;
+    height?: number;
+    kr?: number;
+    kg?: number;
+    ks?: number;
+    ksmax?: number;
+    tao?: number;
+    mode?: "normal" | "linlog";
+    preventOverlap?: boolean;
+    dissuadeHubs?: boolean;
+    barnesHut?: boolean;
+    prune?: boolean;
+    nodeSize?: number | number[] | ((node?: Node) => number);
+    onTick?: (data: LayoutMapping) => void;
+}
+export interface FruchtermanLayoutOptions extends CommonForceLayoutOptions {
+    width?: number;
+    height?: number;
+    gravity?: number;
+    speed?: number;
+    clustering?: boolean;
+    clusterGravity?: number;
+    nodeClusterBy?: string;
+    onTick?: (data: LayoutMapping) => void;
+}
 export {};

package/lib/util/function.d.ts

@@ -1,5 +1,4 @@
 import { Node } from "../types";
-export declare const isFunction: (val: unknown) => val is Function;
 /**
  * Format value with multiple types into a function returns number.
  * @param defaultValue default value when value is invalid
@@ -18,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/lib/util/math.d.ts

@@ -15,7 +15,7 @@ export declare const scaleMatrix: (matrix: Matrix[], ratio: number) => Matrix[];
  * if the fn returns false, terminate the traverse
  */
 export declare const traverseTreeUp: <T extends {
-    children?: T[] | undefined;
+    children?: T[];
 }>(data: T, fn: (param: T) => boolean) => void;
 /**
  * calculate the bounding box for the nodes according to their x, y, and size

package/lib/util/number.d.ts

@@ -1,3 +1 @@
-export declare const isNumber: (val: unknown) => val is Number;
-export declare const isNaN: (num: unknown) => boolean;
 export declare const toNumber: (val: any) => any;

package/lib/util/object.d.ts

@@ -1,9 +1,9 @@
-import { Node, Edge } from '../types';
-export declare const isObject: (val: unknown) => val is Record<any, any>;
+import { Node, Edge } from "../types";
 export declare const clone: <T>(target: T) => T;
 /**
  * Clone node or edge data and format it
- * @param target
- * @returns
+ * @param target node/edge to be cloned
+ * @param initRange whether init the x and y in data with the range, which means [xRange, yRange]
+ * @returns cloned node/edge
  */
-export declare const cloneFormatData: <T extends Node | Edge>(target: T) => T;
+export declare const cloneFormatData: <T extends Node | Edge>(target: T, initRange?: [number, number]) => T;

package/lib/util/string.d.ts

@@ -1,2 +1 @@
-export declare const isString: (val: unknown) => val is string;
 export declare const camelize: (str: string) => string;

package/lib/worker.d.ts

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

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "@antv/layout",
-  "version": "1.0.0-alpha.9",
+  "version": "1.1.0",
   "description": "graph layout algorithm",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/antvis/layout",
+    "directory": "packages/layout"
+  },
   "main": "dist/index.min.js",
   "module": "esm/index.esm.js",
   "types": "lib/index.d.ts",
@@ -21,29 +27,34 @@
     "antv"
   ],
   "dependencies": {
-    "@antv/graphlib": "^2.0.0-alpha.2",
+    "@antv/graphlib": "^2.0.0",
+    "@antv/util": "^3.3.2",
     "@naoak/workerize-transferable": "^0.1.0",
     "d3-force": "^3.0.0",
     "d3-quadtree": "^3.0.1",
     "eventemitter3": "^4.0.0",
-    "ml-matrix": "^6.10.4"
+    "ml-matrix": "^6.10.4",
+    "tslib": "^2.5.0"
   },
   "devDependencies": {
     "@babel/core": "^7.7.7",
     "@babel/plugin-proposal-class-properties": "^7.1.0",
     "@babel/preset-react": "^7.7.4",
+    "@types/d3-force": "^3.0.4",
     "babel-loader": "^8.0.6",
     "ts-loader": "^7.0.3",
     "typescript": "^4.0.3",
     "webpack": "^5.38.1",
-    "webpack-cli": "^4.7.2",
+    "webpack-cli": "^5.0.2",
     "workerize-loader": "^2.0.2"
   },
   "scripts": {
+    "clean": "rimraf dist esm lib",
     "dev": "webpack --config webpack.dev.config.js --mode development",
-    "build": "npm run build:esm && npm run build:umd",
+    "build": "npm run clean && npm run build:esm && npm run build:umd",
+    "build:ci": "npm run build",
     "build:esm": "webpack --config webpack.esm.config.js --mode production",
     "build:umd": "webpack --config webpack.config.js --mode production",
     "publish:alpha": "npm publish --tag alpha"
   }
-}
+}