@antv/layout 1.2.12 → 1.2.14-beta.0

package/lib/forceAtlas2/index.js

@@ -1,18 +1,21 @@
-import { __assign, __awaiter, __generator, __read, __spreadArray } from "tslib";
-import { isFunction, isNumber, isObject } from "@antv/util";
-import { Graph as GGraph } from "@antv/graphlib";
-import { cloneFormatData, isArray } from "../util";
-import { handleSingleNodeGraph } from "../util/common";
-import Body from "./body";
-import Quad from "./quad";
-import QuadTree from "./quadTree";
-var DEFAULTS_LAYOUT_OPTIONS = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForceAtlas2Layout = void 0;
+const tslib_1 = require("tslib");
+const graphlib_1 = require("@antv/graphlib");
+const util_1 = require("@antv/util");
+const util_2 = require("../util");
+const common_1 = require("../util/common");
+const body_1 = tslib_1.__importDefault(require("./body"));
+const quad_1 = tslib_1.__importDefault(require("./quad"));
+const quadTree_1 = tslib_1.__importDefault(require("./quadTree"));
+const DEFAULTS_LAYOUT_OPTIONS = {
     center: [0, 0],
     width: 300,
     height: 300,
     kr: 5,
     kg: 1,
-    mode: "normal",
+    mode: 'normal',
     preventOverlap: false,
     dissuadeHubs: false,
     maxIteration: 0,
@@ -35,87 +38,78 @@ var DEFAULTS_LAYOUT_OPTIONS = {
  * // If you want to assign the positions directly to the nodes, use assign method.
  * await layout.assign(graph, { center: [100, 100] });
  */
-var ForceAtlas2Layout = /** @class */ (function () {
-    function ForceAtlas2Layout(options) {
-        if (options === void 0) { options = {}; }
+class ForceAtlas2Layout {
+    constructor(options = {}) {
         this.options = options;
-        this.id = "forceAtlas2";
-        this.options = __assign(__assign({}, DEFAULTS_LAYOUT_OPTIONS), options);
+        this.id = 'forceAtlas2';
+        this.options = Object.assign(Object.assign({}, DEFAULTS_LAYOUT_OPTIONS), options);
     }
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    ForceAtlas2Layout.prototype.execute = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.genericForceAtlas2Layout(false, graph, options)];
-            });
+    execute(graph, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.genericForceAtlas2Layout(false, graph, options);
         });
-    };
+    }
     /**
      * To directly assign the positions to the nodes.
      */
-    ForceAtlas2Layout.prototype.assign = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.genericForceAtlas2Layout(true, graph, options);
-                return [2 /*return*/];
-            });
+    assign(graph, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.genericForceAtlas2Layout(true, graph, options);
         });
-    };
-    ForceAtlas2Layout.prototype.genericForceAtlas2Layout = function (assign, graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var edges, nodes, mergedOptions, width, height, prune, maxIteration, nodeSize, center, calcNodes, calcEdges, calcGraph, sizes, j, _a, source, target, sourceDegree, targetDegree, targetNode, sourceNode, postOptions;
-            return __generator(this, function (_b) {
-                edges = graph.getAllEdges();
-                nodes = graph.getAllNodes();
-                mergedOptions = this.formatOptions(options, nodes.length);
-                width = mergedOptions.width, height = mergedOptions.height, prune = mergedOptions.prune, maxIteration = mergedOptions.maxIteration, nodeSize = mergedOptions.nodeSize, center = mergedOptions.center;
-                if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length) || nodes.length === 1) {
-                    return [2 /*return*/, handleSingleNodeGraph(graph, assign, center)];
-                }
-                calcNodes = nodes.map(function (node) { return cloneFormatData(node, [width, height]); });
-                calcEdges = edges.filter(function (edge) {
-                    var source = edge.source, target = edge.target;
-                    return source !== target;
-                });
-                calcGraph = new GGraph({
-                    nodes: calcNodes,
-                    edges: calcEdges,
-                });
-                sizes = this.getSizes(calcGraph, graph, nodeSize);
-                this.run(calcGraph, graph, maxIteration, sizes, assign, mergedOptions);
-                // if prune, place the leaves around their parents, and then re-layout for several iterations.
-                if (prune) {
-                    for (j = 0; j < calcEdges.length; j += 1) {
-                        _a = calcEdges[j], source = _a.source, target = _a.target;
-                        sourceDegree = calcGraph.getDegree(source);
-                        targetDegree = calcGraph.getDegree(source);
-                        if (sourceDegree <= 1) {
-                            targetNode = calcGraph.getNode(target);
-                            calcGraph.mergeNodeData(source, {
-                                x: targetNode.data.x,
-                                y: targetNode.data.y,
-                            });
-                        }
-                        else if (targetDegree <= 1) {
-                            sourceNode = calcGraph.getNode(source);
-                            calcGraph.mergeNodeData(target, {
-                                x: sourceNode.data.x,
-                                y: sourceNode.data.y,
-                            });
-                        }
+    }
+    genericForceAtlas2Layout(assign, graph, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const edges = graph.getAllEdges();
+            const nodes = graph.getAllNodes();
+            const mergedOptions = this.formatOptions(options, nodes.length);
+            const { width, height, prune, maxIteration, nodeSize, center } = mergedOptions;
+            if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length) || nodes.length === 1) {
+                return (0, common_1.handleSingleNodeGraph)(graph, assign, center);
+            }
+            const calcNodes = nodes.map((node) => (0, util_2.cloneFormatData)(node, [width, height]));
+            const calcEdges = edges.filter((edge) => {
+                const { source, target } = edge;
+                return source !== target;
+            });
+            const calcGraph = new graphlib_1.Graph({
+                nodes: calcNodes,
+                edges: calcEdges,
+            });
+            const sizes = this.getSizes(calcGraph, graph, nodeSize);
+            this.run(calcGraph, graph, maxIteration, sizes, assign, mergedOptions);
+            // if prune, place the leaves around their parents, and then re-layout for several iterations.
+            if (prune) {
+                for (let j = 0; j < calcEdges.length; j += 1) {
+                    const { source, target } = calcEdges[j];
+                    const sourceDegree = calcGraph.getDegree(source);
+                    const targetDegree = calcGraph.getDegree(source);
+                    if (sourceDegree <= 1) {
+                        const targetNode = calcGraph.getNode(target);
+                        calcGraph.mergeNodeData(source, {
+                            x: targetNode.data.x,
+                            y: targetNode.data.y,
+                        });
+                    }
+                    else if (targetDegree <= 1) {
+                        const sourceNode = calcGraph.getNode(source);
+                        calcGraph.mergeNodeData(target, {
+                            x: sourceNode.data.x,
+                            y: sourceNode.data.y,
+                        });
                     }
-                    postOptions = __assign(__assign({}, mergedOptions), { prune: false, barnesHut: false });
-                    this.run(calcGraph, graph, 100, sizes, assign, postOptions);
                 }
-                return [2 /*return*/, {
-                        nodes: calcNodes,
-                        edges: edges,
-                    }];
-            });
+                const postOptions = Object.assign(Object.assign({}, mergedOptions), { prune: false, barnesHut: false });
+                this.run(calcGraph, graph, 100, sizes, assign, postOptions);
+            }
+            return {
+                nodes: calcNodes,
+                edges,
+            };
         });
-    };
+    }
     /**
      * Init the node positions if there is no initial positions.
      * And pre-calculate the size (max of width and height) for each node.
@@ -124,58 +118,57 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param nodeSize node size config from layout options
      * @returns {SizeMap} node'id mapped to max of its width and height
      */
-    ForceAtlas2Layout.prototype.getSizes = function (calcGraph, graph, nodeSize) {
-        var nodes = calcGraph.getAllNodes();
-        var sizes = {};
-        for (var i = 0; i < nodes.length; i += 1) {
-            var _a = nodes[i], id = _a.id, data = _a.data;
+    getSizes(calcGraph, graph, nodeSize) {
+        const nodes = calcGraph.getAllNodes();
+        const sizes = {};
+        for (let i = 0; i < nodes.length; i += 1) {
+            const { id, data } = nodes[i];
             sizes[id] = 10;
-            if (isNumber(data.size)) {
+            if ((0, util_1.isNumber)(data.size)) {
                 sizes[id] = data.size;
             }
-            else if (isArray(data.size)) {
+            else if ((0, util_2.isArray)(data.size)) {
                 if (!isNaN(data.size[0]))
                     sizes[id] = Math.max(data.size[0]);
                 if (!isNaN(data.size[1]))
                     sizes[id] = Math.max(data.size[1]);
             }
-            else if (isObject(data.size)) {
+            else if ((0, util_1.isObject)(data.size)) {
                 // @ts-ignore
                 sizes[id] = Math.max(data.size.width, data.size.height);
             }
-            else if (isFunction(nodeSize)) {
-                var originNode = graph.getNode(id);
-                var size = nodeSize(originNode);
-                if (isArray(size)) {
-                    sizes[id] = Math.max.apply(Math, __spreadArray([], __read(size)));
+            else if ((0, util_1.isFunction)(nodeSize)) {
+                const originNode = graph.getNode(id);
+                const size = nodeSize(originNode);
+                if ((0, util_2.isArray)(size)) {
+                    sizes[id] = Math.max(...size);
                 }
                 else {
                     sizes[id] = size;
                 }
             }
-            else if (isArray(nodeSize)) {
-                sizes[id] = Math.max.apply(Math, __spreadArray([], __read(nodeSize)));
+            else if ((0, util_2.isArray)(nodeSize)) {
+                sizes[id] = Math.max(...nodeSize);
             }
-            else if (isNumber(nodeSize)) {
+            else if ((0, util_1.isNumber)(nodeSize)) {
                 sizes[id] = nodeSize;
             }
         }
         return sizes;
-    };
+    }
     /**
      * Format the options.
      * @param options input options
      * @param nodeNum number of nodes
      * @returns formatted options
      */
-    ForceAtlas2Layout.prototype.formatOptions = function (options, nodeNum) {
-        if (options === void 0) { options = {}; }
-        var mergedOptions = __assign(__assign({}, this.options), options);
-        var center = mergedOptions.center, width = mergedOptions.width, height = mergedOptions.height, barnesHut = mergedOptions.barnesHut, prune = mergedOptions.prune, maxIteration = mergedOptions.maxIteration, kr = mergedOptions.kr, kg = mergedOptions.kg;
+    formatOptions(options = {}, nodeNum) {
+        const mergedOptions = Object.assign(Object.assign({}, this.options), options);
+        const { center, width, height, barnesHut, prune, maxIteration, kr, kg } = mergedOptions;
         mergedOptions.width =
-            !width && typeof window !== "undefined" ? window.innerWidth : width;
+            !width && typeof window !== 'undefined' ? window.innerWidth : width;
         mergedOptions.height =
-            !height && typeof window !== "undefined" ? window.innerHeight : height;
+            !height && typeof window !== 'undefined' ? window.innerHeight : height;
         mergedOptions.center = !center
             ? [mergedOptions.width / 2, mergedOptions.height / 2]
             : center;
@@ -213,7 +206,7 @@ var ForceAtlas2Layout = /** @class */ (function () {
                 mergedOptions.kg = 1;
         }
         return mergedOptions;
-    };
+    }
     /**
      * Loops for fa2.
      * @param calcGraph graph for calculation
@@ -223,19 +216,19 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout options
      * @returns
      */
-    ForceAtlas2Layout.prototype.run = function (calcGraph, graph, iteration, sizes, assign, options) {
-        var kr = options.kr, barnesHut = options.barnesHut, onTick = options.onTick;
-        var calcNodes = calcGraph.getAllNodes();
-        var sg = 0;
-        var iter = iteration;
-        var forces = {};
-        var preForces = {};
-        var bodies = {};
-        for (var i = 0; i < calcNodes.length; i += 1) {
-            var _a = calcNodes[i], data = _a.data, id = _a.id;
+    run(calcGraph, graph, iteration, sizes, assign, options) {
+        const { kr, barnesHut, onTick } = options;
+        const calcNodes = calcGraph.getAllNodes();
+        let sg = 0;
+        let iter = iteration;
+        const forces = {};
+        const preForces = {};
+        const bodies = {};
+        for (let i = 0; i < calcNodes.length; i += 1) {
+            const { data, id } = calcNodes[i];
             forces[id] = [0, 0];
             if (barnesHut) {
-                var params = {
+                const params = {
                     id: i,
                     rx: data.x,
                     ry: data.y,
@@ -243,19 +236,19 @@ var ForceAtlas2Layout = /** @class */ (function () {
                     g: kr,
                     degree: calcGraph.getDegree(id),
                 };
-                bodies[id] = new Body(params);
+                bodies[id] = new body_1.default(params);
             }
         }
         while (iter > 0) {
             sg = this.oneStep(calcGraph, {
-                iter: iter,
+                iter,
                 preventOverlapIters: 50,
                 krPrime: 100,
-                sg: sg,
-                forces: forces,
-                preForces: preForces,
-                bodies: bodies,
-                sizes: sizes,
+                sg,
+                forces,
+                preForces,
+                bodies,
+                sizes,
             }, options);
             iter--;
             onTick === null || onTick === void 0 ? void 0 : onTick({
@@ -270,7 +263,7 @@ var ForceAtlas2Layout = /** @class */ (function () {
             // }
         }
         return calcGraph;
-    };
+    }
     /**
      * One step for a loop.
      * @param graph graph for calculation
@@ -278,14 +271,14 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout's input options
      * @returns
      */
-    ForceAtlas2Layout.prototype.oneStep = function (graph, params, options) {
-        var iter = params.iter, preventOverlapIters = params.preventOverlapIters, krPrime = params.krPrime, sg = params.sg, preForces = params.preForces, bodies = params.bodies, sizes = params.sizes;
-        var forces = params.forces;
-        var preventOverlap = options.preventOverlap, barnesHut = options.barnesHut;
-        var nodes = graph.getAllNodes();
-        for (var i = 0; i < nodes.length; i += 1) {
-            var id = nodes[i].id;
-            preForces[id] = __spreadArray([], __read(forces[id]));
+    oneStep(graph, params, options) {
+        const { iter, preventOverlapIters, krPrime, sg, preForces, bodies, sizes } = params;
+        let { forces } = params;
+        const { preventOverlap, barnesHut } = options;
+        const nodes = graph.getAllNodes();
+        for (let i = 0; i < nodes.length; i += 1) {
+            const { id } = nodes[i];
+            preForces[id] = [...forces[id]];
             forces[id] = [0, 0];
         }
         // attractive forces, existing on every actual edge
@@ -301,7 +294,7 @@ var ForceAtlas2Layout = /** @class */ (function () {
         }
         // update the positions
         return this.updatePos(graph, forces, preForces, sg, options);
-    };
+    }
     /**
      * Calculate the attract forces for nodes.
      * @param graph graph for calculation
@@ -312,31 +305,31 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout's input options
      * @returns
      */
-    ForceAtlas2Layout.prototype.getAttrForces = function (graph, iter, preventOverlapIters, sizes, forces, options) {
-        var preventOverlap = options.preventOverlap, dissuadeHubs = options.dissuadeHubs, mode = options.mode, prune = options.prune;
-        var edges = graph.getAllEdges();
-        for (var i = 0; i < edges.length; i += 1) {
-            var _a = edges[i], source = _a.source, target = _a.target;
-            var sourceNode = graph.getNode(source);
-            var targetNode = graph.getNode(target);
-            var sourceDegree = graph.getDegree(source);
-            var targetDegree = graph.getDegree(target);
+    getAttrForces(graph, iter, preventOverlapIters, sizes, forces, options) {
+        const { preventOverlap, dissuadeHubs, mode, prune } = options;
+        const edges = graph.getAllEdges();
+        for (let i = 0; i < edges.length; i += 1) {
+            const { source, target } = edges[i];
+            const sourceNode = graph.getNode(source);
+            const targetNode = graph.getNode(target);
+            const sourceDegree = graph.getDegree(source);
+            const targetDegree = graph.getDegree(target);
             if (prune && (sourceDegree <= 1 || targetDegree <= 1))
                 continue;
-            var dir = [
+            const dir = [
                 targetNode.data.x - sourceNode.data.x,
                 targetNode.data.y - sourceNode.data.y,
             ];
-            var eucliDis = Math.hypot(dir[0], dir[1]);
+            let eucliDis = Math.hypot(dir[0], dir[1]);
             eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;
             dir[0] = dir[0] / eucliDis;
             dir[1] = dir[1] / eucliDis;
             if (preventOverlap && iter < preventOverlapIters) {
                 eucliDis = eucliDis - sizes[source] - sizes[target];
             }
-            var fa1 = eucliDis;
-            var fa2 = fa1;
-            if (mode === "linlog") {
+            let fa1 = eucliDis;
+            let fa2 = fa1;
+            if (mode === 'linlog') {
                 fa1 = Math.log(1 + eucliDis);
                 fa2 = fa1;
             }
@@ -358,7 +351,7 @@ var ForceAtlas2Layout = /** @class */ (function () {
             forces[target][1] -= fa2 * dir[1];
         }
         return forces;
-    };
+    }
     /**
      * Calculate the repulsive forces for nodes under barnesHut mode.
      * @param graph graph for calculatiion
@@ -367,16 +360,16 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout's input options
      * @returns
      */
-    ForceAtlas2Layout.prototype.getOptRepGraForces = function (graph, forces, bodies, options) {
-        var kg = options.kg, center = options.center, prune = options.prune;
-        var nodes = graph.getAllNodes();
-        var nodeNum = nodes.length;
-        var minx = 9e10;
-        var maxx = -9e10;
-        var miny = 9e10;
-        var maxy = -9e10;
-        for (var i = 0; i < nodeNum; i += 1) {
-            var _a = nodes[i], id = _a.id, data = _a.data;
+    getOptRepGraForces(graph, forces, bodies, options) {
+        const { kg, center, prune } = options;
+        const nodes = graph.getAllNodes();
+        const nodeNum = nodes.length;
+        let minx = 9e10;
+        let maxx = -9e10;
+        let miny = 9e10;
+        let maxy = -9e10;
+        for (let i = 0; i < nodeNum; i += 1) {
+            const { id, data } = nodes[i];
             if (prune && graph.getDegree(id) <= 1)
                 continue;
             bodies[id].setPos(data.x, data.y);
@@ -389,28 +382,28 @@ var ForceAtlas2Layout = /** @class */ (function () {
             if (data.y <= miny)
                 miny = data.y;
         }
-        var width = Math.max(maxx - minx, maxy - miny);
-        var quadParams = {
+        const width = Math.max(maxx - minx, maxy - miny);
+        const quadParams = {
             xmid: (maxx + minx) / 2,
             ymid: (maxy + miny) / 2,
             length: width,
             massCenter: center,
             mass: nodeNum,
         };
-        var quad = new Quad(quadParams);
-        var quadTree = new QuadTree(quad);
+        const quad = new quad_1.default(quadParams);
+        const quadTree = new quadTree_1.default(quad);
         // build the tree, insert the nodes(quads) into the tree
-        for (var i = 0; i < nodeNum; i += 1) {
-            var id = nodes[i].id;
+        for (let i = 0; i < nodeNum; i += 1) {
+            const { id } = nodes[i];
             if (prune && graph.getDegree(id) <= 1)
                 continue;
             if (bodies[id].in(quad))
                 quadTree.insert(bodies[id]);
         }
         // update the repulsive forces and the gravity.
-        for (var i = 0; i < nodeNum; i += 1) {
-            var _b = nodes[i], id = _b.id, data = _b.data;
-            var degree = graph.getDegree(id);
+        for (let i = 0; i < nodeNum; i += 1) {
+            const { id, data } = nodes[i];
+            const degree = graph.getDegree(id);
             if (prune && degree <= 1)
                 continue;
             bodies[id].resetForce();
@@ -418,17 +411,17 @@ var ForceAtlas2Layout = /** @class */ (function () {
             forces[id][0] -= bodies[id].fx;
             forces[id][1] -= bodies[id].fy;
             // gravity
-            var dir = [data.x - center[0], data.y - center[1]];
-            var eucliDis = Math.hypot(dir[0], dir[1]);
+            const dir = [data.x - center[0], data.y - center[1]];
+            let eucliDis = Math.hypot(dir[0], dir[1]);
             eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;
             dir[0] = dir[0] / eucliDis;
             dir[1] = dir[1] / eucliDis;
-            var fg = kg * (degree + 1); // tslint:disable-line
+            const fg = kg * (degree + 1); // tslint:disable-line
             forces[id][0] -= fg * dir[0];
             forces[id][1] -= fg * dir[1];
         }
         return forces;
-    };
+    }
     /**
      * Calculate the repulsive forces for nodes.
      * @param graph graph for calculatiion
@@ -440,56 +433,56 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout's input options
      * @returns
      */
-    ForceAtlas2Layout.prototype.getRepGraForces = function (graph, iter, preventOverlapIters, forces, krPrime, sizes, options) {
-        var preventOverlap = options.preventOverlap, kr = options.kr, kg = options.kg, center = options.center, prune = options.prune;
-        var nodes = graph.getAllNodes();
-        var nodeNum = nodes.length;
-        for (var i = 0; i < nodeNum; i += 1) {
-            var nodei = nodes[i];
-            var degreei = graph.getDegree(nodei.id);
-            for (var j = i + 1; j < nodeNum; j += 1) {
-                var nodej = nodes[j];
-                var degreej = graph.getDegree(nodej.id);
+    getRepGraForces(graph, iter, preventOverlapIters, forces, krPrime, sizes, options) {
+        const { preventOverlap, kr, kg, center, prune } = options;
+        const nodes = graph.getAllNodes();
+        const nodeNum = nodes.length;
+        for (let i = 0; i < nodeNum; i += 1) {
+            const nodei = nodes[i];
+            const degreei = graph.getDegree(nodei.id);
+            for (let j = i + 1; j < nodeNum; j += 1) {
+                const nodej = nodes[j];
+                const degreej = graph.getDegree(nodej.id);
                 if (prune && (degreei <= 1 || degreej <= 1))
                     continue;
-                var dir_1 = [nodej.data.x - nodei.data.x, nodej.data.y - nodei.data.y];
-                var eucliDis_1 = Math.hypot(dir_1[0], dir_1[1]);
-                eucliDis_1 = eucliDis_1 < 0.0001 ? 0.0001 : eucliDis_1;
-                dir_1[0] = dir_1[0] / eucliDis_1;
-                dir_1[1] = dir_1[1] / eucliDis_1;
+                const dir = [nodej.data.x - nodei.data.x, nodej.data.y - nodei.data.y];
+                let eucliDis = Math.hypot(dir[0], dir[1]);
+                eucliDis = eucliDis < 0.0001 ? 0.0001 : eucliDis;
+                dir[0] = dir[0] / eucliDis;
+                dir[1] = dir[1] / eucliDis;
                 if (preventOverlap && iter < preventOverlapIters) {
-                    eucliDis_1 = eucliDis_1 - sizes[nodei.id] - sizes[nodej.id];
+                    eucliDis = eucliDis - sizes[nodei.id] - sizes[nodej.id];
                 }
-                var fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis_1;
-                if (preventOverlap && iter < preventOverlapIters && eucliDis_1 < 0) {
+                let fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis;
+                if (preventOverlap && iter < preventOverlapIters && eucliDis < 0) {
                     fr = krPrime * (degreei + 1) * (degreej + 1);
                 }
                 else if (preventOverlap &&
                     iter < preventOverlapIters &&
-                    eucliDis_1 === 0) {
+                    eucliDis === 0) {
                     fr = 0;
                 }
                 else if (preventOverlap &&
                     iter < preventOverlapIters &&
-                    eucliDis_1 > 0) {
-                    fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis_1;
+                    eucliDis > 0) {
+                    fr = (kr * (degreei + 1) * (degreej + 1)) / eucliDis;
                 }
-                forces[nodei.id][0] -= fr * dir_1[0];
-                forces[nodej.id][0] += fr * dir_1[0];
-                forces[nodei.id][1] -= fr * dir_1[1];
-                forces[nodej.id][1] += fr * dir_1[1];
+                forces[nodei.id][0] -= fr * dir[0];
+                forces[nodej.id][0] += fr * dir[0];
+                forces[nodei.id][1] -= fr * dir[1];
+                forces[nodej.id][1] += fr * dir[1];
             }
             // gravity
-            var dir = [nodei.data.x - center[0], nodei.data.y - center[1]];
-            var eucliDis = Math.hypot(dir[0], dir[1]);
+            const dir = [nodei.data.x - center[0], nodei.data.y - center[1]];
+            const eucliDis = Math.hypot(dir[0], dir[1]);
             dir[0] = dir[0] / eucliDis;
             dir[1] = dir[1] / eucliDis;
-            var fg = kg * (degreei + 1); // tslint:disable-line
+            const fg = kg * (degreei + 1); // tslint:disable-line
             forces[nodei.id][0] -= fg * dir[0];
             forces[nodei.id][1] -= fg * dir[1];
         }
         return forces;
-    };
+    }
     /**
      * Update node positions.
      * @param graph graph for calculatiion
@@ -499,64 +492,63 @@ var ForceAtlas2Layout = /** @class */ (function () {
      * @param options formatted layout's input options
      * @returns
      */
-    ForceAtlas2Layout.prototype.updatePos = function (graph, forces, preForces, sg, options) {
-        var ks = options.ks, tao = options.tao, prune = options.prune, ksmax = options.ksmax;
-        var nodes = graph.getAllNodes();
-        var nodeNum = nodes.length;
-        var swgns = [];
-        var trans = [];
+    updatePos(graph, forces, preForces, sg, options) {
+        const { ks, tao, prune, ksmax } = options;
+        const nodes = graph.getAllNodes();
+        const nodeNum = nodes.length;
+        const swgns = [];
+        const trans = [];
         // swg(G) and tra(G)
-        var swgG = 0;
-        var traG = 0;
-        var usingSg = sg;
-        for (var i = 0; i < nodeNum; i += 1) {
-            var id = nodes[i].id;
-            var degree = graph.getDegree(id);
+        let swgG = 0;
+        let traG = 0;
+        let usingSg = sg;
+        for (let i = 0; i < nodeNum; i += 1) {
+            const { id } = nodes[i];
+            const degree = graph.getDegree(id);
             if (prune && degree <= 1)
                 continue;
-            var minus = [
+            const minus = [
                 forces[id][0] - preForces[id][0],
                 forces[id][1] - preForces[id][1],
             ];
-            var minusNorm = Math.hypot(minus[0], minus[1]);
-            var add = [
+            const minusNorm = Math.hypot(minus[0], minus[1]);
+            const add = [
                 forces[id][0] + preForces[id][0],
                 forces[id][1] + preForces[id][1],
             ];
-            var addNorm = Math.hypot(add[0], add[1]);
+            const addNorm = Math.hypot(add[0], add[1]);
             swgns[i] = minusNorm;
             trans[i] = addNorm / 2;
             swgG += (degree + 1) * swgns[i];
             traG += (degree + 1) * trans[i];
         }
-        var preSG = usingSg;
+        const preSG = usingSg;
         usingSg = (tao * traG) / swgG;
         if (preSG !== 0) {
             usingSg = usingSg > 1.5 * preSG ? 1.5 * preSG : usingSg;
         }
         // update the node positions
-        for (var i = 0; i < nodeNum; i += 1) {
-            var _a = nodes[i], id = _a.id, data = _a.data;
-            var degree = graph.getDegree(id);
+        for (let i = 0; i < nodeNum; i += 1) {
+            const { id, data } = nodes[i];
+            const degree = graph.getDegree(id);
             if (prune && degree <= 1)
                 continue;
-            if (isNumber(data.fx) && isNumber(data.fy))
+            if ((0, util_1.isNumber)(data.fx) && (0, util_1.isNumber)(data.fy))
                 continue;
-            var sn = (ks * usingSg) / (1 + usingSg * Math.sqrt(swgns[i]));
-            var absForce = Math.hypot(forces[id][0], forces[id][1]);
+            let sn = (ks * usingSg) / (1 + usingSg * Math.sqrt(swgns[i]));
+            let absForce = Math.hypot(forces[id][0], forces[id][1]);
             absForce = absForce < 0.0001 ? 0.0001 : absForce;
-            var max = ksmax / absForce;
+            const max = ksmax / absForce;
             sn = sn > max ? max : sn;
-            var dnx = sn * forces[id][0];
-            var dny = sn * forces[id][1];
+            const dnx = sn * forces[id][0];
+            const dny = sn * forces[id][1];
             graph.mergeNodeData(id, {
                 x: data.x + dnx,
                 y: data.y + dny,
             });
         }
         return usingSg;
-    };
-    return ForceAtlas2Layout;
-}());
-export { ForceAtlas2Layout };
+    }
+}
+exports.ForceAtlas2Layout = ForceAtlas2Layout;
 //# sourceMappingURL=index.js.map