@antv/layout 1.0.0-alpha.12 → 1.0.0-alpha.13

package/lib/forceAtlas2/body.d.ts

@@ -0,0 +1,33 @@
+import Quad from './quad';
+/**
+ * @fileOverview body
+ * @author shiwu.wyy@antfin.com
+ */
+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 {};

package/lib/forceAtlas2/index.d.ts

@@ -0,0 +1,109 @@
+import type { Graph, LayoutMapping, ForceAtlas2LayoutOptions, LayoutWithIterations } 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: [] }
+ *
+ * // Or use different options later.
+ * const layout = new ForceAtlas2Layout({ center: [100, 100] });
+ * const positions = 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] });
+ */
+export declare class ForceAtlas2Layout implements LayoutWithIterations<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;
+    /**
+     * To directly assign the positions to the nodes.
+     */
+    assign(graph: Graph, options?: ForceAtlas2LayoutOptions): 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
+ */
+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/index.d.ts

@@ -9,3 +9,4 @@ export * from "./radial";
 export * from "./fruchterman";
 export * from "./d3Force";
 export * from "./force";
+export * from './forceAtlas2';

package/lib/types.d.ts

@@ -114,11 +114,11 @@ 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 {
     center?: PointTuple;
@@ -133,7 +133,6 @@ export interface ConcentricLayoutOptions extends CommonOptions {
     center?: PointTuple;
     preventOverlap?: boolean;
     nodeSize?: number | PointTuple;
-    minNodeSpacing?: number;
     sweep?: number;
     equidistant?: boolean;
     startAngle?: number;
@@ -142,7 +141,7 @@ 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 {
     center?: PointTuple;
@@ -153,18 +152,18 @@ 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";
     begin?: PointTuple;
-    nodeSize?: number | number[] | undefined;
+    nodeSize?: number | number[];
     nodesep?: number;
     ranksep?: number;
     controlPoints?: boolean;
@@ -177,18 +176,18 @@ export interface DagreLayoutOptions extends CommonOptions {
         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 {
     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;
@@ -219,9 +218,9 @@ export interface ForceLayoutOptions extends CommonOptions {
     center?: PointTuple;
     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);
@@ -241,8 +240,8 @@ export interface ForceLayoutOptions extends CommonOptions {
     collideStrength?: number;
     distanceThresholdMode?: "mean" | "max" | "min";
     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[];
@@ -250,6 +249,24 @@ export interface ForceLayoutOptions extends CommonOptions {
         iterations: number;
     }) => void;
 }
+export interface ForceAtlas2LayoutOptions extends CommonOptions {
+    center?: PointTuple;
+    width?: number;
+    height?: number;
+    kr?: number;
+    kg?: number;
+    ks?: number;
+    ksmax?: number;
+    tao?: number;
+    maxIteration?: 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 CommonOptions {
     center?: PointTuple;
     maxIteration?: number;

package/lib/util/common.d.ts

@@ -0,0 +1,22 @@
+import { PointTuple, LayoutMapping, 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) => {
+    nodes: {
+        data: {
+            x: number;
+            y: number;
+            visible?: boolean | undefined;
+            size?: number | number[] | undefined;
+            bboxSize?: number[] | undefined;
+        };
+        id: import("@antv/graphlib").ID;
+    }[];
+    edges: import("@antv/graphlib").Edge<import("../types").EdgeData>[];
+} | undefined;

package/lib/util/object.d.ts

@@ -1,4 +1,4 @@
-import { Node, Edge } from '../types';
+import { Node, Edge } from "../types";
 export declare const isObject: (val: unknown) => val is Record<any, any>;
 export declare const clone: <T>(target: T) => T;
 /**

package/package.json

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