@antv/layout 1.2.13 → 1.2.14-beta.1

package/lib/force/index.js

@@ -1,9 +1,9 @@
-import { __assign, __awaiter, __generator, __read } from "tslib";
+import { __awaiter } from "tslib";
 import { Graph as IGraph } from '@antv/graphlib';
 import { isFunction, isNumber, isObject } from '@antv/util';
 import { formatNumberFn, isArray } from '../util';
 import { forceNBody } from './forceNBody';
-var DEFAULTS_LAYOUT_OPTIONS = {
+const DEFAULTS_LAYOUT_OPTIONS = {
     dimensions: 2,
     maxIteration: 500,
     gravity: 10,
@@ -35,9 +35,8 @@ 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 ForceLayout = /** @class */ (function () {
-    function ForceLayout(options) {
-        if (options === void 0) { options = {}; }
+export class ForceLayout {
+    constructor(options = {}) {
         this.options = options;
         this.id = 'force';
         /**
@@ -49,162 +48,148 @@ var ForceLayout = /** @class */ (function () {
          */
         this.judgingDistance = 0;
         this.running = false;
-        this.options = __assign(__assign({}, DEFAULTS_LAYOUT_OPTIONS), options);
+        this.options = Object.assign(Object.assign({}, DEFAULTS_LAYOUT_OPTIONS), options);
     }
     /**
      * Return the positions of nodes and edges(if needed).
      */
-    ForceLayout.prototype.execute = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.genericForceLayout(false, graph, options)];
-            });
+    execute(graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.genericForceLayout(false, graph, options);
         });
-    };
+    }
     /**
      * To directly assign the positions to the nodes.
      */
-    ForceLayout.prototype.assign = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                this.genericForceLayout(true, graph, options);
-                return [2 /*return*/];
-            });
+    assign(graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.genericForceLayout(true, graph, options);
         });
-    };
+    }
     /**
      * Stop simulation immediately.
      */
-    ForceLayout.prototype.stop = function () {
+    stop() {
         if (this.timeInterval && typeof window !== 'undefined') {
             window.clearInterval(this.timeInterval);
         }
         this.running = false;
-    };
+    }
     /**
      * Manually steps the simulation by the specified number of iterations.
      * @see https://github.com/d3/d3-force#simulation_tick
      */
-    ForceLayout.prototype.tick = function (iterations) {
-        var _this = this;
-        if (iterations === void 0) { iterations = this.options.maxIteration || 1; }
+    tick(iterations = this.options.maxIteration || 1) {
         if (this.lastResult) {
             return this.lastResult;
         }
-        for (var i = 0; (this.judgingDistance > this.lastOptions.minMovement || i < 1) &&
+        for (let i = 0; (this.judgingDistance > this.lastOptions.minMovement || i < 1) &&
             i < iterations; i++) {
             this.runOneStep(this.lastCalcGraph, this.lastGraph, i, this.lastVelMap, this.lastOptions);
             this.updatePosition(this.lastGraph, this.lastCalcGraph, this.lastVelMap, this.lastOptions);
         }
-        var result = {
+        const result = {
             nodes: this.lastLayoutNodes,
             edges: this.lastLayoutEdges,
         };
         if (this.lastAssign) {
-            result.nodes.forEach(function (node) {
-                return _this.lastGraph.mergeNodeData(node.id, {
-                    x: node.data.x,
-                    y: node.data.y,
-                    z: _this.options.dimensions === 3 ? node.data.z : undefined,
-                });
-            });
+            result.nodes.forEach((node) => this.lastGraph.mergeNodeData(node.id, {
+                x: node.data.x,
+                y: node.data.y,
+                z: this.options.dimensions === 3 ? node.data.z : undefined,
+            }));
         }
         return result;
-    };
-    ForceLayout.prototype.genericForceLayout = function (assign, graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mergedOptions, nodes, edges, formattedOptions, dimensions, width, height, nodeSize, getMass, nodeStrength, edgeStrength, linkDistance, layoutNodes, layoutEdges, velMap, calcGraph, maxIteration, minMovement, onTick, iter;
-            var _this = this;
-            return __generator(this, function (_a) {
-                mergedOptions = __assign(__assign({}, this.options), options);
-                nodes = graph.getAllNodes();
-                edges = graph.getAllEdges();
-                formattedOptions = this.formatOptions(mergedOptions, graph);
-                dimensions = formattedOptions.dimensions, width = formattedOptions.width, height = formattedOptions.height, nodeSize = formattedOptions.nodeSize, getMass = formattedOptions.getMass, nodeStrength = formattedOptions.nodeStrength, edgeStrength = formattedOptions.edgeStrength, linkDistance = formattedOptions.linkDistance;
-                layoutNodes = nodes.map(function (node, i) {
-                    return __assign(__assign({}, node), { data: __assign(__assign({}, node.data), { 
-                            // ...randomDistribution(node, dimensions, 30, i),
-                            x: isNumber(node.data.x) ? node.data.x : Math.random() * width, y: isNumber(node.data.y) ? node.data.y : Math.random() * height, z: isNumber(node.data.z)
-                                ? node.data.z
-                                : Math.random() * Math.sqrt(width * height), size: nodeSize(node) || 30, mass: getMass(node), nodeStrength: nodeStrength(node) }) });
-                });
-                layoutEdges = edges.map(function (edge) { return (__assign(__assign({}, edge), { data: __assign(__assign({}, edge.data), { edgeStrength: edgeStrength(edge), linkDistance: linkDistance(edge, graph.getNode(edge.source), graph.getNode(edge.target)) }) })); });
-                if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length)) {
-                    this.lastResult = { nodes: [], edges: edges };
-                    return [2 /*return*/, { nodes: [], edges: edges }];
-                }
-                velMap = {};
-                nodes.forEach(function (node, i) {
-                    velMap[node.id] = {
-                        x: 0,
-                        y: 0,
-                        z: 0,
-                    };
-                });
-                calcGraph = new IGraph({
-                    nodes: layoutNodes,
-                    edges: layoutEdges,
-                });
-                this.formatCentripetal(formattedOptions, calcGraph);
-                maxIteration = formattedOptions.maxIteration, minMovement = formattedOptions.minMovement, onTick = formattedOptions.onTick;
-                // Use them later in `tick`.
-                this.lastLayoutNodes = layoutNodes;
-                this.lastLayoutEdges = layoutEdges;
-                this.lastAssign = assign;
-                this.lastGraph = graph;
-                this.lastCalcGraph = calcGraph;
-                this.lastOptions = formattedOptions;
-                this.lastVelMap = velMap;
-                if (typeof window === 'undefined')
-                    return [2 /*return*/];
-                iter = 0;
-                return [2 /*return*/, new Promise(function (resolve) {
-                        // interval for render the result after each iteration
-                        _this.timeInterval = window.setInterval(function () {
-                            if (!nodes || !_this.running) {
-                                resolve({
-                                    nodes: formatOutNodes(graph, layoutNodes),
-                                    edges: edges,
-                                });
-                            }
-                            _this.runOneStep(calcGraph, graph, iter, velMap, formattedOptions);
-                            _this.updatePosition(graph, calcGraph, velMap, formattedOptions);
-                            if (assign) {
-                                layoutNodes.forEach(function (node) {
-                                    return graph.mergeNodeData(node.id, {
-                                        x: node.data.x,
-                                        y: node.data.y,
-                                        z: dimensions === 3 ? node.data.z : undefined,
-                                    });
-                                });
-                            }
-                            onTick === null || onTick === void 0 ? void 0 : onTick({
-                                nodes: formatOutNodes(graph, layoutNodes),
-                                edges: edges,
-                            });
-                            iter++;
-                            if (iter >= maxIteration || _this.judgingDistance < minMovement) {
-                                window.clearInterval(_this.timeInterval);
-                                resolve({
-                                    nodes: formatOutNodes(graph, layoutNodes),
-                                    edges: edges,
-                                });
-                            }
-                        }, 0);
-                        _this.running = true;
-                    })];
+    }
+    genericForceLayout(assign, graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mergedOptions = Object.assign(Object.assign({}, this.options), options);
+            const nodes = graph.getAllNodes();
+            const edges = graph.getAllEdges();
+            const formattedOptions = this.formatOptions(mergedOptions, graph);
+            const { dimensions, width, height, nodeSize, getMass, nodeStrength, edgeStrength, linkDistance, } = formattedOptions;
+            // clones the original data and attaches calculation attributes for this layout algorithm
+            const layoutNodes = nodes.map((node, i) => {
+                return Object.assign(Object.assign({}, node), { data: Object.assign(Object.assign({}, node.data), { 
+                        // ...randomDistribution(node, dimensions, 30, i),
+                        x: isNumber(node.data.x) ? node.data.x : Math.random() * width, y: isNumber(node.data.y) ? node.data.y : Math.random() * height, z: isNumber(node.data.z)
+                            ? node.data.z
+                            : Math.random() * Math.sqrt(width * height), size: nodeSize(node) || 30, mass: getMass(node), nodeStrength: nodeStrength(node) }) });
+            });
+            const layoutEdges = edges.map((edge) => (Object.assign(Object.assign({}, edge), { data: Object.assign(Object.assign({}, edge.data), { edgeStrength: edgeStrength(edge), linkDistance: linkDistance(edge, graph.getNode(edge.source), graph.getNode(edge.target)) }) })));
+            if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length)) {
+                this.lastResult = { nodes: [], edges };
+                return { nodes: [], edges };
+            }
+            const velMap = {};
+            nodes.forEach((node, i) => {
+                velMap[node.id] = {
+                    x: 0,
+                    y: 0,
+                    z: 0,
+                };
+            });
+            const calcGraph = new IGraph({
+                nodes: layoutNodes,
+                edges: layoutEdges,
+            });
+            this.formatCentripetal(formattedOptions, calcGraph);
+            const { maxIteration, minMovement, onTick } = formattedOptions;
+            // Use them later in `tick`.
+            this.lastLayoutNodes = layoutNodes;
+            this.lastLayoutEdges = layoutEdges;
+            this.lastAssign = assign;
+            this.lastGraph = graph;
+            this.lastCalcGraph = calcGraph;
+            this.lastOptions = formattedOptions;
+            this.lastVelMap = velMap;
+            if (typeof window === 'undefined')
+                return;
+            let iter = 0;
+            return new Promise((resolve) => {
+                // interval for render the result after each iteration
+                this.timeInterval = window.setInterval(() => {
+                    if (!nodes || !this.running) {
+                        resolve({
+                            nodes: formatOutNodes(graph, layoutNodes),
+                            edges,
+                        });
+                    }
+                    this.runOneStep(calcGraph, graph, iter, velMap, formattedOptions);
+                    this.updatePosition(graph, calcGraph, velMap, formattedOptions);
+                    if (assign) {
+                        layoutNodes.forEach((node) => graph.mergeNodeData(node.id, {
+                            x: node.data.x,
+                            y: node.data.y,
+                            z: dimensions === 3 ? node.data.z : undefined,
+                        }));
+                    }
+                    onTick === null || onTick === void 0 ? void 0 : onTick({
+                        nodes: formatOutNodes(graph, layoutNodes),
+                        edges,
+                    });
+                    iter++;
+                    if (iter >= maxIteration || this.judgingDistance < minMovement) {
+                        window.clearInterval(this.timeInterval);
+                        resolve({
+                            nodes: formatOutNodes(graph, layoutNodes),
+                            edges,
+                        });
+                    }
+                }, 0);
+                this.running = true;
             });
         });
-    };
+    }
     /**
      * Format merged layout options.
      * @param options merged layout options
      * @param graph original graph
      * @returns
      */
-    ForceLayout.prototype.formatOptions = function (options, graph) {
-        var formattedOptions = __assign({}, options);
-        var propsWidth = options.width, propsHeight = options.height, getMass = options.getMass, nodeSize = options.nodeSize;
+    formatOptions(options, graph) {
+        const formattedOptions = Object.assign({}, options);
+        const { width: propsWidth, height: propsHeight, getMass, nodeSize, } = options;
         // === formating width, height, and center =====
         formattedOptions.width =
             !propsWidth && typeof window !== 'undefined'
@@ -222,20 +207,20 @@ var ForceLayout = /** @class */ (function () {
         }
         // === formating node mass =====
         if (!getMass) {
-            formattedOptions.getMass = function (d) {
-                var massWeight = 1;
+            formattedOptions.getMass = (d) => {
+                let massWeight = 1;
                 if (isNumber(d === null || d === void 0 ? void 0 : d.data.mass))
                     massWeight = d === null || d === void 0 ? void 0 : d.data.mass;
-                var degree = graph.getDegree(d.id, 'both');
+                const degree = graph.getDegree(d.id, 'both');
                 return !degree || degree < 5 ? massWeight : degree * 5 * massWeight;
             };
         }
         // === formating node size =====
-        var nodeSpacingFunc = formatNumberFn(0, options.nodeSpacing);
-        var nodeSizeFn;
+        const nodeSpacingFunc = formatNumberFn(0, options.nodeSpacing);
+        let nodeSizeFn;
         if (!nodeSize) {
-            nodeSizeFn = function (d) {
-                var size = ((d === null || d === void 0 ? void 0 : d.data) || {}).size;
+            nodeSizeFn = (d) => {
+                const { size } = (d === null || d === void 0 ? void 0 : d.data) || {};
                 if (size) {
                     if (isArray(size)) {
                         return Math.max(size[0], size[1]) + nodeSpacingFunc(d);
@@ -249,22 +234,22 @@ var ForceLayout = /** @class */ (function () {
             };
         }
         else if (isFunction(nodeSize)) {
-            nodeSizeFn = function (d) { return nodeSize(d) + nodeSpacingFunc(d); };
+            nodeSizeFn = (d) => nodeSize(d) + nodeSpacingFunc(d);
         }
         else if (isArray(nodeSize)) {
-            nodeSizeFn = function (d) {
-                var nodeSizeArr = nodeSize;
+            nodeSizeFn = (d) => {
+                const nodeSizeArr = nodeSize;
                 return Math.max(nodeSizeArr[0], nodeSizeArr[1]) + nodeSpacingFunc(d);
             };
         }
         else {
-            nodeSizeFn = function (d) { return nodeSize + nodeSpacingFunc(d); };
+            nodeSizeFn = (d) => nodeSize + nodeSpacingFunc(d);
         }
         formattedOptions.nodeSize = nodeSizeFn;
         // === formating node / edge strengths =====
-        var linkDistanceFn = options.linkDistance
+        const linkDistanceFn = options.linkDistance
             ? formatNumberFn(1, options.linkDistance)
-            : function (edge) {
+            : (edge) => {
                 return (1 +
                     formattedOptions.nodeSize(graph.getNode(edge.source)) +
                     formattedOptions.nodeSize(graph.getNode(edge.target)));
@@ -273,22 +258,22 @@ var ForceLayout = /** @class */ (function () {
         formattedOptions.nodeStrength = formatNumberFn(1, options.nodeStrength);
         formattedOptions.edgeStrength = formatNumberFn(1, options.edgeStrength);
         return formattedOptions;
-    };
+    }
     /**
      * Format centripetalOption in the option.
      * @param options merged layout options
      * @param calcGraph calculation graph
      */
-    ForceLayout.prototype.formatCentripetal = function (options, calcGraph) {
-        var dimensions = options.dimensions, centripetalOptions = options.centripetalOptions, center = options.center, clusterNodeStrength = options.clusterNodeStrength, leafCluster = options.leafCluster, clustering = options.clustering, nodeClusterBy = options.nodeClusterBy;
-        var calcNodes = calcGraph.getAllNodes();
+    formatCentripetal(options, calcGraph) {
+        const { dimensions, centripetalOptions, center, clusterNodeStrength, leafCluster, clustering, nodeClusterBy, } = options;
+        const calcNodes = calcGraph.getAllNodes();
         // === formating centripetalOptions =====
-        var basicCentripetal = centripetalOptions || {
+        const basicCentripetal = centripetalOptions || {
             leaf: 2,
             single: 2,
             others: 1,
             // eslint-disable-next-line
-            center: function (n) {
+            center: (n) => {
                 return {
                     x: center[0],
                     y: center[1],
@@ -297,22 +282,20 @@ var ForceLayout = /** @class */ (function () {
             },
         };
         if (typeof clusterNodeStrength !== 'function') {
-            options.clusterNodeStrength = function (node) {
-                return clusterNodeStrength;
-            };
+            options.clusterNodeStrength = (node) => clusterNodeStrength;
         }
-        var sameTypeLeafMap;
-        var clusters;
+        let sameTypeLeafMap;
+        let clusters;
         if (leafCluster && nodeClusterBy) {
             sameTypeLeafMap = getSameTypeLeafMap(calcGraph, nodeClusterBy);
             clusters =
-                Array.from(new Set(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.map(function (node) { return node.data[nodeClusterBy]; }))) || [];
+                Array.from(new Set(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.map((node) => node.data[nodeClusterBy]))) || [];
             // @ts-ignore
             options.centripetalOptions = Object.assign(basicCentripetal, {
                 single: 100,
-                leaf: function (node) {
+                leaf: (node) => {
                     // 找出与它关联的边的起点或终点出发的所有一度节点中同类型的叶子节点
-                    var _a = sameTypeLeafMap[node.id] || {}, siblingLeaves = _a.siblingLeaves, sameTypeLeaves = _a.sameTypeLeaves;
+                    const { siblingLeaves, sameTypeLeaves } = sameTypeLeafMap[node.id] || {};
                     // 如果都是同一类型或者每种类型只有1个，则施加默认向心力
                     if ((sameTypeLeaves === null || sameTypeLeaves === void 0 ? void 0 : sameTypeLeaves.length) === (siblingLeaves === null || siblingLeaves === void 0 ? void 0 : siblingLeaves.length) ||
                         (clusters === null || clusters === void 0 ? void 0 : clusters.length) === 1) {
@@ -321,8 +304,8 @@ var ForceLayout = /** @class */ (function () {
                     return options.clusterNodeStrength(node);
                 },
                 others: 1,
-                center: function (node) {
-                    var degree = calcGraph.getDegree(node.id, 'both');
+                center: (node) => {
+                    const degree = calcGraph.getDegree(node.id, 'both');
                     // 孤点默认给1个远离的中心点
                     if (!degree) {
                         return {
@@ -331,11 +314,11 @@ var ForceLayout = /** @class */ (function () {
                             z: 0,
                         };
                     }
-                    var centerPos;
+                    let centerPos;
                     if (degree === 1) {
                         // 如果为叶子节点
                         // 找出与它关联的边的起点出发的所有一度节点中同类型的叶子节点
-                        var _a = (sameTypeLeafMap[node.id] || {}).sameTypeLeaves, sameTypeLeaves = _a === void 0 ? [] : _a;
+                        const { sameTypeLeaves = [] } = sameTypeLeafMap[node.id] || {};
                         if (sameTypeLeaves.length === 1) {
                             // 如果同类型的叶子节点只有1个，中心位置为undefined
                             centerPos = undefined;
@@ -361,24 +344,24 @@ var ForceLayout = /** @class */ (function () {
                 sameTypeLeafMap = getSameTypeLeafMap(calcGraph, nodeClusterBy);
             }
             if (!clusters) {
-                clusters = Array.from(new Set(calcNodes.map(function (node) { return node.data[nodeClusterBy]; })));
+                clusters = Array.from(new Set(calcNodes.map((node) => node.data[nodeClusterBy])));
             }
-            clusters = clusters.filter(function (item) { return item !== undefined; });
-            var centerInfo_1 = {};
-            clusters.forEach(function (cluster) {
-                var sameTypeNodes = calcNodes
-                    .filter(function (node) { return node.data[nodeClusterBy] === cluster; })
-                    .map(function (node) { return calcGraph.getNode(node.id); });
+            clusters = clusters.filter((item) => item !== undefined);
+            const centerInfo = {};
+            clusters.forEach((cluster) => {
+                const sameTypeNodes = calcNodes
+                    .filter((node) => node.data[nodeClusterBy] === cluster)
+                    .map((node) => calcGraph.getNode(node.id));
                 // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
-                centerInfo_1[cluster] = getAvgNodePosition(sameTypeNodes);
+                centerInfo[cluster] = getAvgNodePosition(sameTypeNodes);
             });
             options.centripetalOptions = Object.assign(basicCentripetal, {
-                single: function (node) { return options.clusterNodeStrength(node); },
-                leaf: function (node) { return options.clusterNodeStrength(node); },
-                others: function (node) { return options.clusterNodeStrength(node); },
-                center: function (node) {
+                single: (node) => options.clusterNodeStrength(node),
+                leaf: (node) => options.clusterNodeStrength(node),
+                others: (node) => options.clusterNodeStrength(node),
+                center: (node) => {
                     // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
-                    var centerPos = centerInfo_1[node.data[nodeClusterBy]];
+                    const centerPos = centerInfo[node.data[nodeClusterBy]];
                     return {
                         x: centerPos === null || centerPos === void 0 ? void 0 : centerPos.x,
                         y: centerPos === null || centerPos === void 0 ? void 0 : centerPos.y,
@@ -387,17 +370,17 @@ var ForceLayout = /** @class */ (function () {
                 },
             });
         }
-        var _a = options.centripetalOptions || {}, leaf = _a.leaf, single = _a.single, others = _a.others;
+        const { leaf, single, others } = options.centripetalOptions || {};
         if (leaf && typeof leaf !== 'function') {
-            options.centripetalOptions.leaf = function () { return leaf; };
+            options.centripetalOptions.leaf = () => leaf;
         }
         if (single && typeof single !== 'function') {
-            options.centripetalOptions.single = function () { return single; };
+            options.centripetalOptions.single = () => single;
         }
         if (others && typeof others !== 'function') {
-            options.centripetalOptions.others = function () { return others; };
+            options.centripetalOptions.others = () => others;
         }
-    };
+    }
     /**
      * One iteration.
      * @param calcGraph calculation graph
@@ -407,13 +390,13 @@ var ForceLayout = /** @class */ (function () {
      * @param options formatted layout options
      * @returns
      */
-    ForceLayout.prototype.runOneStep = function (calcGraph, graph, iter, velMap, options) {
-        var accMap = {};
-        var calcNodes = calcGraph.getAllNodes();
-        var calcEdges = calcGraph.getAllEdges();
+    runOneStep(calcGraph, graph, iter, velMap, options) {
+        const accMap = {};
+        const calcNodes = calcGraph.getAllNodes();
+        const calcEdges = calcGraph.getAllEdges();
         if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length))
             return;
-        var monitor = options.monitor;
+        const { monitor } = options;
         this.calRepulsive(calcGraph, accMap, options);
         if (calcEdges)
             this.calAttractive(calcGraph, accMap, options);
@@ -421,62 +404,61 @@ var ForceLayout = /** @class */ (function () {
         this.updateVelocity(calcGraph, accMap, velMap, options);
         /** 如果需要监控信息，则提供给用户 */
         if (monitor) {
-            var energy = this.calTotalEnergy(accMap, calcNodes);
+            const energy = this.calTotalEnergy(accMap, calcNodes);
             monitor({
-                energy: energy,
+                energy,
                 nodes: graph.getAllNodes(),
                 edges: graph.getAllEdges(),
                 iterations: iter,
             });
         }
-    };
+    }
     /**
      * Calculate graph energy for monitoring convergence.
      * @param accMap acceleration map
      * @param nodes calculation nodes
      * @returns energy
      */
-    ForceLayout.prototype.calTotalEnergy = function (accMap, nodes) {
-        var _this = this;
+    calTotalEnergy(accMap, nodes) {
         if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length))
             return 0;
-        var energy = 0.0;
-        nodes.forEach(function (node, i) {
-            var vx = accMap[node.id].x;
-            var vy = accMap[node.id].y;
-            var vz = _this.options.dimensions === 3 ? accMap[node.id].z : 0;
-            var speed2 = vx * vx + vy * vy + vz * vz;
-            var _a = node.data.mass, mass = _a === void 0 ? 1 : _a;
+        let energy = 0.0;
+        nodes.forEach((node, i) => {
+            const vx = accMap[node.id].x;
+            const vy = accMap[node.id].y;
+            const vz = this.options.dimensions === 3 ? accMap[node.id].z : 0;
+            const speed2 = vx * vx + vy * vy + vz * vz;
+            const { mass = 1 } = node.data;
             energy += mass * speed2 * 0.5; // p = 1/2*(mv^2)
         });
         return energy;
-    };
+    }
     /**
      * Calculate the repulsive forces according to coulombs law.
      * @param calcGraph calculation graph
      * @param accMap acceleration map
      * @param options formatted layout options
      */
-    ForceLayout.prototype.calRepulsive = function (calcGraph, accMap, options) {
-        var dimensions = options.dimensions, factor = options.factor, coulombDisScale = options.coulombDisScale;
+    calRepulsive(calcGraph, accMap, options) {
+        const { dimensions, factor, coulombDisScale } = options;
         forceNBody(calcGraph, factor, coulombDisScale * coulombDisScale, accMap, dimensions);
-    };
+    }
     /**
      * Calculate the attractive forces according to hooks law.
      * @param calcGraph calculation graph
      * @param accMap acceleration map
      */
-    ForceLayout.prototype.calAttractive = function (calcGraph, accMap, options) {
-        var dimensions = options.dimensions, nodeSize = options.nodeSize;
-        calcGraph.getAllEdges().forEach(function (edge, i) {
-            var source = edge.source, target = edge.target;
-            var sourceNode = calcGraph.getNode(source);
-            var targetNode = calcGraph.getNode(target);
+    calAttractive(calcGraph, accMap, options) {
+        const { dimensions, nodeSize } = options;
+        calcGraph.getAllEdges().forEach((edge, i) => {
+            const { source, target } = edge;
+            const sourceNode = calcGraph.getNode(source);
+            const targetNode = calcGraph.getNode(target);
             if (!sourceNode || !targetNode)
                 return;
-            var vecX = targetNode.data.x - sourceNode.data.x;
-            var vecY = targetNode.data.y - sourceNode.data.y;
-            var vecZ = dimensions === 3 ? targetNode.data.z - sourceNode.data.z : 0;
+            let vecX = targetNode.data.x - sourceNode.data.x;
+            let vecY = targetNode.data.y - sourceNode.data.y;
+            let vecZ = dimensions === 3 ? targetNode.data.z - sourceNode.data.z : 0;
             if (!vecX && !vecY) {
                 vecX = Math.random() * 0.01;
                 vecY = Math.random() * 0.01;
@@ -484,23 +466,23 @@ var ForceLayout = /** @class */ (function () {
                     vecZ = Math.random() * 0.01;
                 }
             }
-            var vecLength = Math.sqrt(vecX * vecX + vecY * vecY + vecZ * vecZ);
+            const vecLength = Math.sqrt(vecX * vecX + vecY * vecY + vecZ * vecZ);
             if (vecLength < nodeSize(sourceNode) + nodeSize(targetNode))
                 return;
-            var direX = vecX / vecLength;
-            var direY = vecY / vecLength;
-            var direZ = vecZ / vecLength;
-            var _a = edge.data || {}, _b = _a.linkDistance, linkDistance = _b === void 0 ? 200 : _b, _c = _a.edgeStrength, edgeStrength = _c === void 0 ? 200 : _c;
-            var diff = linkDistance - vecLength;
-            var param = diff * edgeStrength;
-            var massSource = sourceNode.data.mass || 1;
-            var massTarget = targetNode.data.mass || 1;
+            const direX = vecX / vecLength;
+            const direY = vecY / vecLength;
+            const direZ = vecZ / vecLength;
+            const { linkDistance = 200, edgeStrength = 200 } = edge.data || {};
+            const diff = linkDistance - vecLength;
+            const param = diff * edgeStrength;
+            const massSource = sourceNode.data.mass || 1;
+            const massTarget = targetNode.data.mass || 1;
             // 质量占比越大，对另一端影响程度越大
-            var sourceMassRatio = 1 / massSource;
-            var targetMassRatio = 1 / massTarget;
-            var disX = direX * param;
-            var disY = direY * param;
-            var disZ = direZ * param;
+            const sourceMassRatio = 1 / massSource;
+            const targetMassRatio = 1 / massTarget;
+            const disX = direX * param;
+            const disY = direY * param;
+            const disZ = direZ * param;
             accMap[source].x -= disX * sourceMassRatio;
             accMap[source].y -= disY * sourceMassRatio;
             accMap[source].z -= disZ * sourceMassRatio;
@@ -508,7 +490,7 @@ var ForceLayout = /** @class */ (function () {
             accMap[target].y += disY * targetMassRatio;
             accMap[target].z += disZ * targetMassRatio;
         });
-    };
+    }
     /**
      * Calculate the gravity forces toward center.
      * @param calcGraph calculation graph
@@ -516,28 +498,28 @@ var ForceLayout = /** @class */ (function () {
      * @param accMap acceleration map
      * @param options formatted layout options
      */
-    ForceLayout.prototype.calGravity = function (calcGraph, graph, accMap, options) {
-        var getCenter = options.getCenter;
-        var calcNodes = calcGraph.getAllNodes();
-        var nodes = graph.getAllNodes();
-        var edges = graph.getAllEdges();
-        var width = options.width, height = options.height, center = options.center, defaultGravity = options.gravity, centripetalOptions = options.centripetalOptions;
+    calGravity(calcGraph, graph, accMap, options) {
+        const { getCenter } = options;
+        const calcNodes = calcGraph.getAllNodes();
+        const nodes = graph.getAllNodes();
+        const edges = graph.getAllEdges();
+        const { width, height, center, gravity: defaultGravity, centripetalOptions, } = options;
         if (!calcNodes)
             return;
-        calcNodes.forEach(function (calcNode) {
-            var id = calcNode.id, data = calcNode.data;
-            var mass = data.mass, x = data.x, y = data.y, z = data.z;
-            var node = graph.getNode(id);
-            var vecX = 0;
-            var vecY = 0;
-            var vecZ = 0;
-            var gravity = defaultGravity;
-            var inDegree = calcGraph.getDegree(id, 'in');
-            var outDegree = calcGraph.getDegree(id, 'out');
-            var degree = calcGraph.getDegree(id, 'both');
-            var forceCenter = getCenter === null || getCenter === void 0 ? void 0 : getCenter(node, degree);
+        calcNodes.forEach((calcNode) => {
+            const { id, data } = calcNode;
+            const { mass, x, y, z } = data;
+            const node = graph.getNode(id);
+            let vecX = 0;
+            let vecY = 0;
+            let vecZ = 0;
+            let gravity = defaultGravity;
+            const inDegree = calcGraph.getDegree(id, 'in');
+            const outDegree = calcGraph.getDegree(id, 'out');
+            const degree = calcGraph.getDegree(id, 'both');
+            const forceCenter = getCenter === null || getCenter === void 0 ? void 0 : getCenter(node, degree);
             if (forceCenter) {
-                var _a = __read(forceCenter, 3), centerX = _a[0], centerY = _a[1], strength = _a[2];
+                const [centerX, centerY, strength] = forceCenter;
                 vecX = x - centerX;
                 vecY = y - centerY;
                 gravity = strength;
@@ -553,18 +535,18 @@ var ForceLayout = /** @class */ (function () {
                 accMap[id].z -= (gravity * vecZ) / mass;
             }
             if (centripetalOptions) {
-                var leaf = centripetalOptions.leaf, single = centripetalOptions.single, others = centripetalOptions.others, centriCenter = centripetalOptions.center;
-                var _b = (centriCenter === null || centriCenter === void 0 ? void 0 : centriCenter(node, nodes, edges, width, height)) || {
+                const { leaf, single, others, center: centriCenter, } = centripetalOptions;
+                const { x: centriX, y: centriY, z: centriZ, centerStrength, } = (centriCenter === null || centriCenter === void 0 ? void 0 : centriCenter(node, nodes, edges, width, height)) || {
                     x: 0,
                     y: 0,
                     z: 0,
                     centerStrength: 0,
-                }, centriX = _b.x, centriY = _b.y, centriZ = _b.z, centerStrength = _b.centerStrength;
+                };
                 if (!isNumber(centriX) || !isNumber(centriY))
                     return;
-                var vx = (x - centriX) / mass;
-                var vy = (y - centriY) / mass;
-                var vz = (z - centriZ) / mass;
+                const vx = (x - centriX) / mass;
+                const vy = (y - centriY) / mass;
+                const vz = (z - centriZ) / mass;
                 if (centerStrength) {
                     accMap[id].x -= centerStrength * vx;
                     accMap[id].y -= centerStrength * vy;
@@ -572,7 +554,7 @@ var ForceLayout = /** @class */ (function () {
                 }
                 // 孤点
                 if (degree === 0) {
-                    var singleStrength = single(node);
+                    const singleStrength = single(node);
                     if (!singleStrength)
                         return;
                     accMap[id].x -= singleStrength * vx;
@@ -582,7 +564,7 @@ var ForceLayout = /** @class */ (function () {
                 }
                 // 没有出度或没有入度，都认为是叶子节点
                 if (inDegree === 0 || outDegree === 0) {
-                    var leafStrength = leaf(node, nodes, edges);
+                    const leafStrength = leaf(node, nodes, edges);
                     if (!leafStrength)
                         return;
                     accMap[id].x -= leafStrength * vx;
@@ -591,7 +573,7 @@ var ForceLayout = /** @class */ (function () {
                     return;
                 }
                 /** others */
-                var othersStrength = others(node);
+                const othersStrength = others(node);
                 if (!othersStrength)
                     return;
                 accMap[id].x -= othersStrength * vx;
@@ -599,7 +581,7 @@ var ForceLayout = /** @class */ (function () {
                 accMap[id].z -= othersStrength * vz;
             }
         });
-    };
+    }
     /**
      * Update the velocities for nodes.
      * @param calcGraph calculation graph
@@ -608,21 +590,21 @@ var ForceLayout = /** @class */ (function () {
      * @param options formatted layout options
      * @returns
      */
-    ForceLayout.prototype.updateVelocity = function (calcGraph, accMap, velMap, options) {
-        var damping = options.damping, maxSpeed = options.maxSpeed, interval = options.interval, dimensions = options.dimensions;
-        var calcNodes = calcGraph.getAllNodes();
+    updateVelocity(calcGraph, accMap, velMap, options) {
+        const { damping, maxSpeed, interval, dimensions } = options;
+        const calcNodes = calcGraph.getAllNodes();
         if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length))
             return;
-        calcNodes.forEach(function (calcNode) {
-            var id = calcNode.id;
-            var vx = (velMap[id].x + accMap[id].x * interval) * damping || 0.01;
-            var vy = (velMap[id].y + accMap[id].y * interval) * damping || 0.01;
-            var vz = dimensions === 3
+        calcNodes.forEach((calcNode) => {
+            const { id } = calcNode;
+            let vx = (velMap[id].x + accMap[id].x * interval) * damping || 0.01;
+            let vy = (velMap[id].y + accMap[id].y * interval) * damping || 0.01;
+            let vz = dimensions === 3
                 ? (velMap[id].z + accMap[id].z * interval) * damping || 0.01
                 : 0.0;
-            var vLength = Math.sqrt(vx * vx + vy * vy + vz * vz);
+            const vLength = Math.sqrt(vx * vx + vy * vy + vz * vz);
             if (vLength > maxSpeed) {
-                var param2 = maxSpeed / vLength;
+                const param2 = maxSpeed / vLength;
                 vx = param2 * vx;
                 vy = param2 * vy;
                 vz = param2 * vz;
@@ -633,7 +615,7 @@ var ForceLayout = /** @class */ (function () {
                 z: vz,
             };
         });
-    };
+    }
     /**
      * Update nodes' positions.
      * @param graph origin graph
@@ -642,22 +624,21 @@ var ForceLayout = /** @class */ (function () {
      * @param options formatted layou options
      * @returns
      */
-    ForceLayout.prototype.updatePosition = function (graph, calcGraph, velMap, options) {
-        var _this = this;
-        var distanceThresholdMode = options.distanceThresholdMode, interval = options.interval, dimensions = options.dimensions;
-        var calcNodes = calcGraph.getAllNodes();
+    updatePosition(graph, calcGraph, velMap, options) {
+        const { distanceThresholdMode, interval, dimensions } = options;
+        const calcNodes = calcGraph.getAllNodes();
         if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length)) {
             this.judgingDistance = 0;
             return;
         }
-        var sum = 0;
+        let sum = 0;
         if (distanceThresholdMode === 'max')
             this.judgingDistance = -Infinity;
         else if (distanceThresholdMode === 'min')
             this.judgingDistance = Infinity;
-        calcNodes.forEach(function (calcNode) {
-            var id = calcNode.id;
-            var node = graph.getNode(id);
+        calcNodes.forEach((calcNode) => {
+            const { id } = calcNode;
+            const node = graph.getNode(id);
             if (isNumber(node.data.fx) && isNumber(node.data.fy)) {
                 calcGraph.mergeNodeData(id, {
                     x: node.data.fx,
@@ -666,24 +647,24 @@ var ForceLayout = /** @class */ (function () {
                 });
                 return;
             }
-            var distX = velMap[id].x * interval;
-            var distY = velMap[id].y * interval;
-            var distZ = dimensions === 3 ? velMap[id].z * interval : 0.0;
+            const distX = velMap[id].x * interval;
+            const distY = velMap[id].y * interval;
+            const distZ = dimensions === 3 ? velMap[id].z * interval : 0.0;
             calcGraph.mergeNodeData(id, {
                 x: calcNode.data.x + distX,
                 y: calcNode.data.y + distY,
                 z: calcNode.data.z + distZ,
             });
-            var distanceMagnitude = Math.sqrt(distX * distX + distY * distY + distZ * distZ);
+            const distanceMagnitude = Math.sqrt(distX * distX + distY * distY + distZ * distZ);
             switch (distanceThresholdMode) {
                 case 'max':
-                    if (_this.judgingDistance < distanceMagnitude) {
-                        _this.judgingDistance = distanceMagnitude;
+                    if (this.judgingDistance < distanceMagnitude) {
+                        this.judgingDistance = distanceMagnitude;
                     }
                     break;
                 case 'min':
-                    if (_this.judgingDistance > distanceMagnitude) {
-                        _this.judgingDistance = distanceMagnitude;
+                    if (this.judgingDistance > distanceMagnitude) {
+                        this.judgingDistance = distanceMagnitude;
                     }
                     break;
                 default:
@@ -694,23 +675,21 @@ var ForceLayout = /** @class */ (function () {
         if (!distanceThresholdMode || distanceThresholdMode === 'mean') {
             this.judgingDistance = sum / calcNodes.length;
         }
-    };
-    return ForceLayout;
-}());
-export { ForceLayout };
+    }
+}
 /**
  * Group the leaf nodes according to nodeClusterBy field.
  * @param calcGraph calculation graph
  * @param nodeClusterBy the field name in node.data to ditinguish different node clusters
  * @returns related same group leaf nodes for each leaf node
  */
-var getSameTypeLeafMap = function (calcGraph, nodeClusterBy) {
-    var calcNodes = calcGraph.getAllNodes();
+const getSameTypeLeafMap = (calcGraph, nodeClusterBy) => {
+    const calcNodes = calcGraph.getAllNodes();
     if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length))
         return {};
-    var sameTypeLeafMap = {};
-    calcNodes.forEach(function (node, i) {
-        var degree = calcGraph.getDegree(node.id, 'both');
+    const sameTypeLeafMap = {};
+    calcNodes.forEach((node, i) => {
+        const degree = calcGraph.getDegree(node.id, 'both');
         if (degree === 1) {
             sameTypeLeafMap[node.id] = getCoreNodeAndSiblingLeaves(calcGraph, 'leaf', node, nodeClusterBy);
         }
@@ -725,12 +704,12 @@ var getSameTypeLeafMap = function (calcGraph, nodeClusterBy) {
  * @param nodeClusterBy the field name in node.data to ditinguish different node clusters
  * @returns coreNode, sibling leaf nodes, and grouped sibling leaf nodes
  */
-var getCoreNodeAndSiblingLeaves = function (calcGraph, type, node, nodeClusterBy) {
-    var inDegree = calcGraph.getDegree(node.id, 'in');
-    var outDegree = calcGraph.getDegree(node.id, 'out');
+const getCoreNodeAndSiblingLeaves = (calcGraph, type, node, nodeClusterBy) => {
+    const inDegree = calcGraph.getDegree(node.id, 'in');
+    const outDegree = calcGraph.getDegree(node.id, 'out');
     // node is not a leaf, coreNode is itself, siblingLeaves is empty
-    var coreNode = node;
-    var siblingLeaves = [];
+    let coreNode = node;
+    let siblingLeaves = [];
     if (inDegree === 0) {
         // node is a leaf node without out edges, its related(successor) node is coreNode, siblingLeaves is the neighbors of its related node
         coreNode = calcGraph.getSuccessors(node.id)[0];
@@ -742,12 +721,10 @@ var getCoreNodeAndSiblingLeaves = function (calcGraph, type, node, nodeClusterBy
         siblingLeaves = calcGraph.getNeighbors(coreNode.id);
     }
     // siblingLeaves are leaf nodes
-    siblingLeaves = siblingLeaves.filter(function (node) {
-        return calcGraph.getDegree(node.id, 'in') === 0 ||
-            calcGraph.getDegree(node.id, 'out') === 0;
-    });
-    var sameTypeLeaves = getSameTypeNodes(calcGraph, type, nodeClusterBy, node, siblingLeaves);
-    return { coreNode: coreNode, siblingLeaves: siblingLeaves, sameTypeLeaves: sameTypeLeaves };
+    siblingLeaves = siblingLeaves.filter((node) => calcGraph.getDegree(node.id, 'in') === 0 ||
+        calcGraph.getDegree(node.id, 'out') === 0);
+    const sameTypeLeaves = getSameTypeNodes(calcGraph, type, nodeClusterBy, node, siblingLeaves);
+    return { coreNode, siblingLeaves, sameTypeLeaves };
 };
 /**
  * Find the same type (according to nodeClusterBy field) of node in relativeNodes.
@@ -758,15 +735,13 @@ var getCoreNodeAndSiblingLeaves = function (calcGraph, type, node, nodeClusterBy
  * @param relativeNodes node's related ndoes to be filtered
  * @returns related nodes that meet the filtering conditions
  */
-var getSameTypeNodes = function (calcGraph, type, nodeClusterBy, node, relativeNodes) {
-    var typeName = node.data[nodeClusterBy] || '';
-    var sameTypeNodes = (relativeNodes === null || relativeNodes === void 0 ? void 0 : relativeNodes.filter(function (item) { return item.data[nodeClusterBy] === typeName; })) ||
+const getSameTypeNodes = (calcGraph, type, nodeClusterBy, node, relativeNodes) => {
+    const typeName = node.data[nodeClusterBy] || '';
+    let sameTypeNodes = (relativeNodes === null || relativeNodes === void 0 ? void 0 : relativeNodes.filter((item) => item.data[nodeClusterBy] === typeName)) ||
         [];
     if (type === 'leaf') {
-        sameTypeNodes = sameTypeNodes.filter(function (item) {
-            return calcGraph.getDegree(item.id, 'in') === 0 ||
-                calcGraph.getDegree(item.id, 'out') === 0;
-        });
+        sameTypeNodes = sameTypeNodes.filter((item) => calcGraph.getDegree(item.id, 'in') === 0 ||
+            calcGraph.getDegree(item.id, 'out') === 0);
     }
     return sameTypeNodes;
 };
@@ -775,15 +750,15 @@ var getSameTypeNodes = function (calcGraph, type, nodeClusterBy, node, relativeN
  * @param nodes nodes set
  * @returns average ppsition
  */
-var getAvgNodePosition = function (nodes) {
-    var totalNodes = { x: 0, y: 0 };
-    nodes.forEach(function (node) {
-        var _a = node.data, x = _a.x, y = _a.y;
+const getAvgNodePosition = (nodes) => {
+    const totalNodes = { x: 0, y: 0 };
+    nodes.forEach((node) => {
+        const { x, y } = node.data;
         totalNodes.x += x || 0;
         totalNodes.y += y || 0;
     });
     // 获取均值向量
-    var length = nodes.length || 1;
+    const length = nodes.length || 1;
     return {
         x: totalNodes.x / length,
         y: totalNodes.y / length,
@@ -795,11 +770,9 @@ var getAvgNodePosition = function (nodes) {
  * @param layoutNodes calculation nodes
  * @returns output nodes
  */
-var formatOutNodes = function (graph, layoutNodes) {
-    return layoutNodes.map(function (calcNode) {
-        var id = calcNode.id, data = calcNode.data;
-        var node = graph.getNode(id);
-        return __assign(__assign({}, node), { data: __assign(__assign({}, node.data), { x: data.x, y: data.y, z: data.z }) });
-    });
-};
+const formatOutNodes = (graph, layoutNodes) => layoutNodes.map((calcNode) => {
+    const { id, data } = calcNode;
+    const node = graph.getNode(id);
+    return Object.assign(Object.assign({}, node), { data: Object.assign(Object.assign({}, node.data), { x: data.x, y: data.y, z: data.z }) });
+});
 //# sourceMappingURL=index.js.map