@antv/layout 1.2.0 → 1.2.2

package/lib/force/index.js

@@ -0,0 +1,797 @@
+import { __assign, __awaiter, __generator, __read } from "tslib";
+import { Graph as IGraph } from "@antv/graphlib";
+import { isNumber, isObject } from "@antv/util";
+import { formatNumberFn, isArray } from "../util";
+import { forceNBody } from "./forceNBody";
+var DEFAULTS_LAYOUT_OPTIONS = {
+    dimensions: 2,
+    maxIteration: 500,
+    gravity: 10,
+    factor: 1,
+    edgeStrength: 200,
+    nodeStrength: 1000,
+    coulombDisScale: 0.005,
+    damping: 0.9,
+    maxSpeed: 500,
+    minMovement: 0.4,
+    interval: 0.02,
+    linkDistance: 200,
+    clusterNodeStrength: 20,
+    preventOverlap: true,
+    distanceThresholdMode: "mean",
+};
+/**
+ * Layout with faster force
+ *
+ * @example
+ * // Assign layout options when initialization.
+ * const layout = new ForceLayout({ center: [100, 100] });
+ * const positions = await layout.execute(graph); // { nodes: [], edges: [] }
+ *
+ * // Or use different options later.
+ * const layout = new ForceLayout({ center: [100, 100] });
+ * const positions = await layout.execute(graph, { center: [100, 100] }); // { nodes: [], edges: [] }
+ *
+ * // If you want to assign the positions directly to the nodes, use assign method.
+ * await layout.assign(graph, { center: [100, 100] });
+ */
+var ForceLayout = /** @class */ (function () {
+    function ForceLayout(options) {
+        if (options === void 0) { options = {}; }
+        this.options = options;
+        this.id = "force";
+        /**
+         * time interval for layout force animations
+         */
+        this.timeInterval = 0;
+        /**
+         * compare with minMovement to end the nodes' movement
+         */
+        this.judgingDistance = 0;
+        this.running = false;
+        this.options = __assign(__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)];
+            });
+        });
+    };
+    /**
+     * 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*/];
+            });
+        });
+    };
+    /**
+     * Stop simulation immediately.
+     */
+    ForceLayout.prototype.stop = function () {
+        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; }
+        if (this.lastResult) {
+            return this.lastResult;
+        }
+        for (var 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 = {
+            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
+                });
+            });
+        }
+        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;
+                    })];
+            });
+        });
+    };
+    /**
+     * Format merged layout options.
+     * @param options merged layout options
+     * @param graph original graph
+     * @returns
+     */
+    ForceLayout.prototype.formatOptions = function (options, graph) {
+        var formattedOptions = options;
+        var propsWidth = options.width, propsHeight = options.height, getMass = options.getMass;
+        // === formating width, height, and center =====
+        formattedOptions.width =
+            !propsWidth && typeof window !== "undefined"
+                ? window.innerWidth
+                : propsWidth;
+        formattedOptions.height =
+            !propsHeight && typeof window !== "undefined"
+                ? window.innerHeight
+                : propsHeight;
+        if (!options.center) {
+            formattedOptions.center = [
+                formattedOptions.width / 2,
+                formattedOptions.height / 2,
+            ];
+        }
+        // === formating node mass =====
+        if (!getMass) {
+            formattedOptions.getMass = function (d) {
+                var 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");
+                return !degree || degree < 5 ? massWeight : degree * 5 * massWeight;
+            };
+        }
+        // === formating node size =====
+        if (options.preventOverlap) {
+            var nodeSpacingFunc_1 = formatNumberFn(0, options.nodeSpacing);
+            if (!options.nodeSize) {
+                formattedOptions.nodeSize = function (d) {
+                    var size = ((d === null || d === void 0 ? void 0 : d.data) || {}).size;
+                    if (size) {
+                        if (isArray(size)) {
+                            return Math.max(size[0], size[1]) + nodeSpacingFunc_1(d);
+                        }
+                        if (isObject(size)) {
+                            return Math.max(size.width, size.height) + nodeSpacingFunc_1(d);
+                        }
+                        return size + nodeSpacingFunc_1(d);
+                    }
+                    return 10 + nodeSpacingFunc_1(d);
+                };
+            }
+            else if (isArray(options.nodeSize)) {
+                formattedOptions.nodeSize = function (d) {
+                    var nodeSize = options.nodeSize;
+                    return Math.max(nodeSize[0], nodeSize[1]) + nodeSpacingFunc_1(d);
+                };
+            }
+            else {
+                formattedOptions.nodeSize = function (d) {
+                    return options.nodeSize + nodeSpacingFunc_1(d);
+                };
+            }
+        }
+        // === formating node / edge strengths =====
+        formattedOptions.linkDistance = options.linkDistance
+            ? formatNumberFn(1, options.linkDistance)
+            : function (edge) {
+                return 1 +
+                    formattedOptions.nodeSize(graph.getNode(edge.source)) +
+                    formattedOptions.nodeSize(graph.getNode(edge.target));
+            };
+        formattedOptions.nodeStrength = formatNumberFn(1, options.nodeStrength);
+        formattedOptions.edgeStrength = formatNumberFn(1, options.edgeStrength);
+        return options;
+    };
+    /**
+     * 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();
+        // === formating centripetalOptions =====
+        var basicCentripetal = centripetalOptions || {
+            leaf: 2,
+            single: 2,
+            others: 1,
+            // eslint-disable-next-line
+            center: function (n) {
+                return {
+                    x: center[0],
+                    y: center[1],
+                    z: dimensions === 3 ? center[2] : undefined
+                };
+            },
+        };
+        if (typeof clusterNodeStrength !== "function") {
+            options.clusterNodeStrength = function (node) {
+                return clusterNodeStrength;
+            };
+        }
+        var sameTypeLeafMap;
+        var 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]; }))) || [];
+            // @ts-ignore
+            options.centripetalOptions = Object.assign(basicCentripetal, {
+                single: 100,
+                leaf: function (node) {
+                    // 找出与它关联的边的起点或终点出发的所有一度节点中同类型的叶子节点
+                    var _a = sameTypeLeafMap[node.id] || {}, siblingLeaves = _a.siblingLeaves, sameTypeLeaves = _a.sameTypeLeaves;
+                    // 如果都是同一类型或者每种类型只有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) {
+                        return 1;
+                    }
+                    return options.clusterNodeStrength(node);
+                },
+                others: 1,
+                center: function (node) {
+                    var degree = calcGraph.getDegree(node.id, "both");
+                    // 孤点默认给1个远离的中心点
+                    if (!degree) {
+                        return {
+                            x: 100,
+                            y: 100,
+                            z: 0,
+                        };
+                    }
+                    var centerPos;
+                    if (degree === 1) {
+                        // 如果为叶子节点
+                        // 找出与它关联的边的起点出发的所有一度节点中同类型的叶子节点
+                        var _a = (sameTypeLeafMap[node.id] || {}).sameTypeLeaves, sameTypeLeaves = _a === void 0 ? [] : _a;
+                        if (sameTypeLeaves.length === 1) {
+                            // 如果同类型的叶子节点只有1个，中心位置为undefined
+                            centerPos = undefined;
+                        }
+                        else if (sameTypeLeaves.length > 1) {
+                            // 找出同类型节点平均位置作为中心
+                            centerPos = getAvgNodePosition(sameTypeLeaves);
+                        }
+                    }
+                    else {
+                        centerPos = undefined;
+                    }
+                    return {
+                        x: centerPos === null || centerPos === void 0 ? void 0 : centerPos.x,
+                        y: centerPos === null || centerPos === void 0 ? void 0 : centerPos.y,
+                        z: centerPos === null || centerPos === void 0 ? void 0 : centerPos.z,
+                    };
+                },
+            });
+        }
+        if (clustering && nodeClusterBy) {
+            if (!sameTypeLeafMap) {
+                sameTypeLeafMap = getSameTypeLeafMap(calcGraph, nodeClusterBy);
+            }
+            if (!clusters) {
+                clusters = Array.from(new Set(calcNodes.map(function (node) { return 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); });
+                // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
+                centerInfo_1[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) {
+                    // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
+                    var centerPos = centerInfo_1[node.data[nodeClusterBy]];
+                    return {
+                        x: centerPos === null || centerPos === void 0 ? void 0 : centerPos.x,
+                        y: centerPos === null || centerPos === void 0 ? void 0 : centerPos.y,
+                        z: centerPos === null || centerPos === void 0 ? void 0 : centerPos.z,
+                    };
+                },
+            });
+        }
+        var _a = options.centripetalOptions || {}, leaf = _a.leaf, single = _a.single, others = _a.others;
+        if (leaf && typeof leaf !== "function") {
+            options.centripetalOptions.leaf = function () { return leaf; };
+        }
+        if (single && typeof single !== "function") {
+            options.centripetalOptions.single = function () { return single; };
+        }
+        if (others && typeof others !== "function") {
+            options.centripetalOptions.others = function () { return others; };
+        }
+    };
+    /**
+     * One iteration.
+     * @param calcGraph calculation graph
+     * @param graph origin graph
+     * @param iter current iteration index
+     * @param velMap nodes' velocity map
+     * @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();
+        if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length))
+            return;
+        var monitor = options.monitor;
+        this.calRepulsive(calcGraph, accMap, options);
+        if (calcEdges)
+            this.calAttractive(calcGraph, accMap, options);
+        this.calGravity(calcGraph, graph, accMap, options);
+        this.updateVelocity(calcGraph, accMap, velMap, options);
+        /** 如果需要监控信息，则提供给用户 */
+        if (monitor) {
+            var energy = this.calTotalEnergy(accMap, calcNodes);
+            monitor({
+                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;
+        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;
+            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;
+        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;
+        calcGraph.getAllEdges().forEach(function (edge, i) {
+            var source = edge.source, target = edge.target;
+            var sourceNode = calcGraph.getNode(source);
+            var 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;
+            if (!vecX && !vecY) {
+                vecX = Math.random() * 0.01;
+                vecY = Math.random() * 0.01;
+                if (dimensions === 3 && !vecZ) {
+                    vecZ = Math.random() * 0.01;
+                }
+            }
+            var vecLength = Math.sqrt(vecX * vecX + vecY * vecY + vecZ * vecZ);
+            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;
+            // 质量占比越大，对另一端影响程度越大
+            var sourceMassRatio = 1 / massSource;
+            var targetMassRatio = 1 / massTarget;
+            var disX = direX * param;
+            var disY = direY * param;
+            var disZ = direZ * param;
+            accMap[source].x -= disX * sourceMassRatio;
+            accMap[source].y -= disY * sourceMassRatio;
+            accMap[source].z -= disZ * sourceMassRatio;
+            accMap[target].x += disX * targetMassRatio;
+            accMap[target].y += disY * targetMassRatio;
+            accMap[target].z += disZ * targetMassRatio;
+        });
+    };
+    /**
+     * Calculate the gravity forces toward center.
+     * @param calcGraph calculation graph
+     * @param graph origin graph
+     * @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;
+        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);
+            if (forceCenter) {
+                var _a = __read(forceCenter, 3), centerX = _a[0], centerY = _a[1], strength = _a[2];
+                vecX = x - centerX;
+                vecY = y - centerY;
+                gravity = strength;
+            }
+            else {
+                vecX = x - center[0];
+                vecY = y - center[1];
+                vecZ = z - center[2];
+            }
+            if (gravity) {
+                accMap[id].x -= (gravity * vecX) / mass;
+                accMap[id].y -= (gravity * vecY) / mass;
+                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)) || {
+                    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;
+                if (centerStrength) {
+                    accMap[id].x -= centerStrength * vx;
+                    accMap[id].y -= centerStrength * vy;
+                    accMap[id].z -= centerStrength * vz;
+                }
+                // 孤点
+                if (degree === 0) {
+                    var singleStrength = single(node);
+                    if (!singleStrength)
+                        return;
+                    accMap[id].x -= singleStrength * vx;
+                    accMap[id].y -= singleStrength * vy;
+                    accMap[id].z -= singleStrength * vz;
+                    return;
+                }
+                // 没有出度或没有入度，都认为是叶子节点
+                if (inDegree === 0 || outDegree === 0) {
+                    var leafStrength = leaf(node, nodes, edges);
+                    if (!leafStrength)
+                        return;
+                    accMap[id].x -= leafStrength * vx;
+                    accMap[id].y -= leafStrength * vy;
+                    accMap[id].z -= leafStrength * vz;
+                    return;
+                }
+                /** others */
+                var othersStrength = others(node);
+                if (!othersStrength)
+                    return;
+                accMap[id].x -= othersStrength * vx;
+                accMap[id].y -= othersStrength * vy;
+                accMap[id].z -= othersStrength * vz;
+            }
+        });
+    };
+    /**
+     * Update the velocities for nodes.
+     * @param calcGraph calculation graph
+     * @param accMap acceleration map
+     * @param velMap velocity map
+     * @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();
+        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 ? ((velMap[id].z + accMap[id].z * interval) * damping || 0.01) : 0.0;
+            var vLength = Math.sqrt(vx * vx + vy * vy + vz * vz);
+            if (vLength > maxSpeed) {
+                var param2 = maxSpeed / vLength;
+                vx = param2 * vx;
+                vy = param2 * vy;
+                vz = param2 * vz;
+            }
+            velMap[id] = {
+                x: vx,
+                y: vy,
+                z: vz
+            };
+        });
+    };
+    /**
+     * Update nodes' positions.
+     * @param graph origin graph
+     * @param calcGraph calculatition graph
+     * @param velMap velocity map
+     * @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();
+        if (!(calcNodes === null || calcNodes === void 0 ? void 0 : calcNodes.length)) {
+            this.judgingDistance = 0;
+            return;
+        }
+        var 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);
+            if (isNumber(node.data.fx) && isNumber(node.data.fy)) {
+                calcGraph.mergeNodeData(id, {
+                    x: node.data.fx,
+                    y: node.data.fy,
+                    z: dimensions === 3 ? node.data.fz : undefined,
+                });
+                return;
+            }
+            var distX = velMap[id].x * interval;
+            var distY = velMap[id].y * interval;
+            var 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);
+            switch (distanceThresholdMode) {
+                case "max":
+                    if (_this.judgingDistance < distanceMagnitude) {
+                        _this.judgingDistance = distanceMagnitude;
+                    }
+                    break;
+                case "min":
+                    if (_this.judgingDistance > distanceMagnitude) {
+                        _this.judgingDistance = distanceMagnitude;
+                    }
+                    break;
+                default:
+                    sum = sum + distanceMagnitude;
+                    break;
+            }
+        });
+        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();
+    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");
+        if (degree === 1) {
+            sameTypeLeafMap[node.id] = getCoreNodeAndSiblingLeaves(calcGraph, "leaf", node, nodeClusterBy);
+        }
+    });
+    return sameTypeLeafMap;
+};
+/**
+ * Find the successor or predecessor of node as coreNode, the sibling leaf nodes
+ * @param calcGraph calculation graph
+ * @param type ('all') filter out the not-same-cluster nodes, ('leaf') or filter out the not-leaf nodes in the same time
+ * @param node the target node
+ * @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");
+    // node is not a leaf, coreNode is itself, siblingLeaves is empty
+    var coreNode = node;
+    var 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];
+        siblingLeaves = calcGraph.getNeighbors(coreNode.id);
+    }
+    else if (outDegree === 0) {
+        // node is a leaf node without in edges, its related(predecessor) node is coreNode, siblingLeaves is the neighbors of its related node
+        coreNode = calcGraph.getPredecessors(node.id)[0];
+        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 };
+};
+/**
+ * Find the same type (according to nodeClusterBy field) of node in relativeNodes.
+ * @param calcGraph calculation graph
+ * @param type ('all') filter out the not-same-cluster nodes, ('leaf') or filter out the not-leaf nodes in the same time
+ * @param nodeClusterBy the field name in node.data to ditinguish different node clusters
+ * @param node the target node
+ * @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; })) ||
+        [];
+    if (type === "leaf") {
+        sameTypeNodes = sameTypeNodes.filter(function (item) {
+            return calcGraph.getDegree(item.id, "in") === 0 ||
+                calcGraph.getDegree(item.id, "out") === 0;
+        });
+    }
+    return sameTypeNodes;
+};
+/**
+ * Get the average position of nodes.
+ * @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;
+        totalNodes.x += x || 0;
+        totalNodes.y += y || 0;
+    });
+    // 获取均值向量
+    var length = nodes.length || 1;
+    return {
+        x: totalNodes.x / length,
+        y: totalNodes.y / length,
+    };
+};
+/**
+ * Format the output nodes from CalcNode[].
+ * @param graph origin graph
+ * @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 }) });
+    });
+};
+//# sourceMappingURL=index.js.map