@antv/layout 1.2.13 → 1.2.14-beta.1

package/lib/comboCombined.js

@@ -1,12 +1,12 @@
-import { __assign, __awaiter, __generator, __read, __spreadArray } from "tslib";
-import { isFunction, isNumber, isObject } from '@antv/util';
+import { __awaiter } from "tslib";
 import { Graph as GraphCore } from '@antv/graphlib';
-import { isArray, getLayoutBBox, graphTreeDfs } from './util';
-import { handleSingleNodeGraph } from './util/common';
-import { MDSLayout } from './mds';
-import { ForceLayout } from './force';
+import { isFunction, isNumber, isObject } from '@antv/util';
 import { ConcentricLayout } from './concentric';
-var FORCE_LAYOUT_TYPE_MAP = {
+import { ForceLayout } from './force';
+import { MDSLayout } from './mds';
+import { getLayoutBBox, graphTreeDfs, isArray } from './util';
+import { handleSingleNodeGraph } from './util/common';
+const FORCE_LAYOUT_TYPE_MAP = {
     gForce: true,
     force2: true,
     d3force: true,
@@ -15,7 +15,7 @@ var FORCE_LAYOUT_TYPE_MAP = {
     force: true,
     'graphin-force': true,
 };
-var DEFAULTS_LAYOUT_OPTIONS = {
+const DEFAULTS_LAYOUT_OPTIONS = {
     center: [0, 0],
     comboPadding: 10,
     treeKey: 'combo',
@@ -35,232 +35,213 @@ var DEFAULTS_LAYOUT_OPTIONS = {
  * // If you want to assign the positions directly to the nodes, use assign method.
  * await layout.assign(graph, { radius: 20 });
  */
-var ComboCombinedLayout = /** @class */ (function () {
-    function ComboCombinedLayout(options) {
-        if (options === void 0) { options = {}; }
+export class ComboCombinedLayout {
+    constructor(options = {}) {
         this.options = options;
         this.id = 'comboCombined';
-        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).
      */
-    ComboCombinedLayout.prototype.execute = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.genericComboCombinedLayout(false, graph, options)];
-            });
+    execute(graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.genericComboCombinedLayout(false, graph, options);
         });
-    };
+    }
     /**
      * To directly assign the positions to the nodes.
      */
-    ComboCombinedLayout.prototype.assign = function (graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.genericComboCombinedLayout(true, graph, options)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+    assign(graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.genericComboCombinedLayout(true, graph, options);
+        });
+    }
+    genericComboCombinedLayout(assign, graph, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mergedOptions = this.initVals(Object.assign(Object.assign({}, this.options), options));
+            const { center, treeKey, outerLayout: propsOuterLayout } = mergedOptions;
+            const nodes = graph
+                .getAllNodes()
+                .filter((node) => !node.data._isCombo);
+            const combos = graph
+                .getAllNodes()
+                .filter((node) => node.data._isCombo);
+            const edges = graph.getAllEdges();
+            const n = nodes === null || nodes === void 0 ? void 0 : nodes.length;
+            if (!n || n === 1) {
+                return handleSingleNodeGraph(graph, assign, center);
+            }
+            // output nodes
+            const layoutNodes = [];
+            const nodeMap = new Map();
+            nodes.forEach((node) => {
+                nodeMap.set(node.id, node);
+            });
+            const comboMap = new Map();
+            combos.forEach((combo) => {
+                comboMap.set(combo.id, combo);
+            });
+            // each one in comboNodes is a combo contains the size and child nodes
+            // comboNodes ncludes the node who has no parent combo
+            const comboNodes = new Map();
+            // the inner layouts, the result positions are stored in comboNodes and their child nodes
+            const innerGraphLayoutPromises = this.getInnerGraphs(graph, treeKey, nodeMap, comboMap, edges, mergedOptions, comboNodes);
+            yield Promise.all(innerGraphLayoutPromises);
+            const outerNodeIds = new Map();
+            const outerLayoutNodes = [];
+            const nodeAncestorIdMap = new Map();
+            let allHaveNoPosition = true;
+            graph.getRoots(treeKey).forEach((root) => {
+                const combo = comboNodes.get(root.id);
+                const cacheCombo = comboMap.get(root.id) || nodeMap.get(root.id);
+                const comboLayoutNode = {
+                    id: root.id,
+                    data: Object.assign(Object.assign({}, root.data), { x: combo.data.x || cacheCombo.data.x, y: combo.data.y || cacheCombo.data.y, fx: combo.data.fx || cacheCombo.data.fx, fy: combo.data.fy || cacheCombo.data.fy, mass: combo.data.mass || cacheCombo.data.mass, size: combo.data.size }),
+                };
+                outerLayoutNodes.push(comboLayoutNode);
+                outerNodeIds.set(root.id, true);
+                if (!isNaN(comboLayoutNode.data.x) &&
+                    comboLayoutNode.data.x !== 0 &&
+                    !isNaN(comboLayoutNode.data.y) &&
+                    comboLayoutNode.data.y !== 0) {
+                    allHaveNoPosition = false;
                 }
+                else {
+                    comboLayoutNode.data.x = Math.random() * 100;
+                    comboLayoutNode.data.y = Math.random() * 100;
+                }
+                graphTreeDfs(graph, [root], (child) => {
+                    if (child.id !== root.id)
+                        nodeAncestorIdMap.set(child.id, root.id);
+                }, 'TB', treeKey);
             });
-        });
-    };
-    ComboCombinedLayout.prototype.genericComboCombinedLayout = function (assign, graph, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mergedOptions, center, treeKey, propsOuterLayout, nodes, combos, edges, n, layoutNodes, nodeMap, comboMap, comboNodes, innerGraphLayoutPromises, outerNodeIds, outerLayoutNodes, nodeAncestorIdMap, allHaveNoPosition, outerLayoutEdges, outerPositions, outerLayoutGraph, outerLayout, outerLayoutPreset, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mergedOptions = this.initVals(__assign(__assign({}, this.options), options));
-                        center = mergedOptions.center, treeKey = mergedOptions.treeKey, propsOuterLayout = mergedOptions.outerLayout;
-                        nodes = graph
-                            .getAllNodes()
-                            .filter(function (node) { return !node.data._isCombo; });
-                        combos = graph
-                            .getAllNodes()
-                            .filter(function (node) { return node.data._isCombo; });
-                        edges = graph.getAllEdges();
-                        n = nodes === null || nodes === void 0 ? void 0 : nodes.length;
-                        if (!n || n === 1) {
-                            return [2 /*return*/, handleSingleNodeGraph(graph, assign, center)];
-                        }
-                        layoutNodes = [];
-                        nodeMap = new Map();
-                        nodes.forEach(function (node) {
-                            nodeMap.set(node.id, node);
-                        });
-                        comboMap = new Map();
-                        combos.forEach(function (combo) {
-                            comboMap.set(combo.id, combo);
-                        });
-                        comboNodes = new Map();
-                        innerGraphLayoutPromises = this.getInnerGraphs(graph, treeKey, nodeMap, comboMap, edges, mergedOptions, comboNodes);
-                        return [4 /*yield*/, Promise.all(innerGraphLayoutPromises)];
-                    case 1:
-                        _a.sent();
-                        outerNodeIds = new Map();
-                        outerLayoutNodes = [];
-                        nodeAncestorIdMap = new Map();
-                        allHaveNoPosition = true;
-                        graph.getRoots(treeKey).forEach(function (root) {
-                            var combo = comboNodes.get(root.id);
-                            var cacheCombo = comboMap.get(root.id) || nodeMap.get(root.id);
-                            var comboLayoutNode = {
-                                id: root.id,
-                                data: __assign(__assign({}, root.data), { x: combo.data.x || cacheCombo.data.x, y: combo.data.y || cacheCombo.data.y, fx: combo.data.fx || cacheCombo.data.fx, fy: combo.data.fy || cacheCombo.data.fy, mass: combo.data.mass || cacheCombo.data.mass, size: combo.data.size }),
-                            };
-                            outerLayoutNodes.push(comboLayoutNode);
-                            outerNodeIds.set(root.id, true);
-                            if (!isNaN(comboLayoutNode.data.x) &&
-                                comboLayoutNode.data.x !== 0 &&
-                                !isNaN(comboLayoutNode.data.y) &&
-                                comboLayoutNode.data.y !== 0) {
-                                allHaveNoPosition = false;
-                            }
-                            else {
-                                comboLayoutNode.data.x = Math.random() * 100;
-                                comboLayoutNode.data.y = Math.random() * 100;
-                            }
-                            graphTreeDfs(graph, [root], function (child) {
-                                if (child.id !== root.id)
-                                    nodeAncestorIdMap.set(child.id, root.id);
-                            }, 'TB', treeKey);
-                        });
-                        outerLayoutEdges = [];
-                        edges.forEach(function (edge) {
-                            var sourceAncestorId = nodeAncestorIdMap.get(edge.source) || edge.source;
-                            var targetAncestorId = nodeAncestorIdMap.get(edge.target) || edge.target;
-                            // create an edge for outer layout if both source and target's ancestor combo is in outer layout nodes
-                            if (sourceAncestorId !== targetAncestorId &&
-                                outerNodeIds.has(sourceAncestorId) &&
-                                outerNodeIds.has(targetAncestorId)) {
-                                outerLayoutEdges.push({
-                                    id: edge.id,
-                                    source: sourceAncestorId,
-                                    target: targetAncestorId,
-                                    data: {},
-                                });
-                            }
-                        });
-                        if (!(outerLayoutNodes === null || outerLayoutNodes === void 0 ? void 0 : outerLayoutNodes.length)) return [3 /*break*/, 7];
-                        if (!(outerLayoutNodes.length === 1)) return [3 /*break*/, 2];
-                        outerLayoutNodes[0].data.x = center[0];
-                        outerLayoutNodes[0].data.y = center[1];
-                        return [3 /*break*/, 6];
-                    case 2:
-                        outerLayoutGraph = new GraphCore({
-                            nodes: outerLayoutNodes,
-                            edges: outerLayoutEdges,
-                        });
-                        outerLayout = propsOuterLayout || new ForceLayout();
-                        if (!(allHaveNoPosition && FORCE_LAYOUT_TYPE_MAP[outerLayout.id])) return [3 /*break*/, 4];
-                        outerLayoutPreset = outerLayoutNodes.length < 100
+            const outerLayoutEdges = [];
+            edges.forEach((edge) => {
+                const sourceAncestorId = nodeAncestorIdMap.get(edge.source) || edge.source;
+                const targetAncestorId = nodeAncestorIdMap.get(edge.target) || edge.target;
+                // create an edge for outer layout if both source and target's ancestor combo is in outer layout nodes
+                if (sourceAncestorId !== targetAncestorId &&
+                    outerNodeIds.has(sourceAncestorId) &&
+                    outerNodeIds.has(targetAncestorId)) {
+                    outerLayoutEdges.push({
+                        id: edge.id,
+                        source: sourceAncestorId,
+                        target: targetAncestorId,
+                        data: {},
+                    });
+                }
+            });
+            // 若有需要最外层的 combo 或节点，则对最外层执行力导向
+            let outerPositions;
+            if (outerLayoutNodes === null || outerLayoutNodes === void 0 ? void 0 : outerLayoutNodes.length) {
+                if (outerLayoutNodes.length === 1) {
+                    outerLayoutNodes[0].data.x = center[0];
+                    outerLayoutNodes[0].data.y = center[1];
+                }
+                else {
+                    const outerLayoutGraph = new GraphCore({
+                        nodes: outerLayoutNodes,
+                        edges: outerLayoutEdges,
+                    });
+                    const outerLayout = propsOuterLayout || new ForceLayout();
+                    // preset the nodes if the outerLayout is a force family layout
+                    if (allHaveNoPosition && FORCE_LAYOUT_TYPE_MAP[outerLayout.id]) {
+                        const outerLayoutPreset = outerLayoutNodes.length < 100
                             ? new MDSLayout()
                             : new ConcentricLayout();
-                        return [4 /*yield*/, outerLayoutPreset.assign(outerLayoutGraph)];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4: return [4 /*yield*/, outerLayout.execute(outerLayoutGraph, __assign({ center: center, kg: 5, preventOverlap: true, animate: false }, (outerLayout.id === 'force'
-                            ? {
-                                gravity: 1,
-                                factor: 4,
-                                linkDistance: function (edge, source, target) {
-                                    var sourceSize = Math.max.apply(Math, __spreadArray([], __read(source.data.size))) || 32;
-                                    var targetSize = Math.max.apply(Math, __spreadArray([], __read(target.data.size))) || 32;
-                                    return sourceSize / 2 + targetSize / 2 + 200;
-                                },
-                            }
-                            : {})))];
-                    case 5:
-                        outerPositions = _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        // move the combos and their child nodes
-                        comboNodes.forEach(function (comboNode) {
-                            var _a;
-                            var outerPosition = outerPositions.nodes.find(function (pos) { return pos.id === comboNode.id; });
-                            if (outerPosition) {
-                                // if it is one of the outer layout nodes, update the positions
-                                var _b = outerPosition.data, x_1 = _b.x, y_1 = _b.y;
-                                comboNode.data.visited = true;
-                                comboNode.data.x = x_1;
-                                comboNode.data.y = y_1;
-                                layoutNodes.push({
-                                    id: comboNode.id,
-                                    data: { x: x_1, y: y_1 },
-                                });
-                            }
-                            // move the child nodes
-                            var _c = comboNode.data, x = _c.x, y = _c.y;
-                            (_a = comboNode.data.nodes) === null || _a === void 0 ? void 0 : _a.forEach(function (node) {
-                                layoutNodes.push({
-                                    id: node.id,
-                                    data: { x: node.data.x + x, y: node.data.y + y },
-                                });
-                            });
+                        yield outerLayoutPreset.assign(outerLayoutGraph);
+                    }
+                    outerPositions = yield outerLayout.execute(outerLayoutGraph, Object.assign({ center, kg: 5, preventOverlap: true, animate: false }, (outerLayout.id === 'force'
+                        ? {
+                            gravity: 1,
+                            factor: 4,
+                            linkDistance: (edge, source, target) => {
+                                const sourceSize = Math.max(...source.data.size) || 32;
+                                const targetSize = Math.max(...target.data.size) || 32;
+                                return sourceSize / 2 + targetSize / 2 + 200;
+                            },
+                        }
+                        : {})));
+                }
+                // move the combos and their child nodes
+                comboNodes.forEach((comboNode) => {
+                    var _a;
+                    const outerPosition = outerPositions.nodes.find((pos) => pos.id === comboNode.id);
+                    if (outerPosition) {
+                        // if it is one of the outer layout nodes, update the positions
+                        const { x, y } = outerPosition.data;
+                        comboNode.data.visited = true;
+                        comboNode.data.x = x;
+                        comboNode.data.y = y;
+                        layoutNodes.push({
+                            id: comboNode.id,
+                            data: { x, y },
                         });
-                        // move the nodes from top to bottom
-                        comboNodes.forEach(function (_a) {
-                            var _b;
-                            var data = _a.data;
-                            var x = data.x, y = data.y, visited = data.visited, nodes = data.nodes;
-                            (_b = nodes) === null || _b === void 0 ? void 0 : _b.forEach(function (node) {
-                                if (!visited) {
-                                    var layoutNode = layoutNodes.find(function (n) { return n.id === node.id; });
-                                    layoutNode.data.x += x || 0;
-                                    layoutNode.data.y += y || 0;
-                                }
-                            });
+                    }
+                    // move the child nodes
+                    const { x, y } = comboNode.data;
+                    (_a = comboNode.data.nodes) === null || _a === void 0 ? void 0 : _a.forEach((node) => {
+                        layoutNodes.push({
+                            id: node.id,
+                            data: { x: node.data.x + x, y: node.data.y + y },
                         });
-                        _a.label = 7;
-                    case 7:
-                        if (assign) {
-                            layoutNodes.forEach(function (node) {
-                                graph.mergeNodeData(node.id, {
-                                    x: node.data.x,
-                                    y: node.data.y,
-                                });
-                            });
+                    });
+                });
+                // move the nodes from top to bottom
+                comboNodes.forEach(({ data }) => {
+                    const { x, y, visited, nodes } = data;
+                    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((node) => {
+                        if (!visited) {
+                            const layoutNode = layoutNodes.find((n) => n.id === node.id);
+                            layoutNode.data.x += x || 0;
+                            layoutNode.data.y += y || 0;
                         }
-                        result = {
-                            nodes: layoutNodes,
-                            edges: edges,
-                        };
-                        return [2 /*return*/, result];
-                }
-            });
+                    });
+                });
+            }
+            if (assign) {
+                layoutNodes.forEach((node) => {
+                    graph.mergeNodeData(node.id, {
+                        x: node.data.x,
+                        y: node.data.y,
+                    });
+                });
+            }
+            const result = {
+                nodes: layoutNodes,
+                edges,
+            };
+            return result;
         });
-    };
-    ComboCombinedLayout.prototype.initVals = function (options) {
-        var formattedOptions = __assign({}, options);
-        var nodeSize = options.nodeSize, spacing = options.spacing, comboPadding = options.comboPadding;
-        var nodeSizeFunc;
-        var spacingFunc;
+    }
+    initVals(options) {
+        const formattedOptions = Object.assign({}, options);
+        const { nodeSize, spacing, comboPadding } = options;
+        let nodeSizeFunc;
+        let spacingFunc;
         // nodeSpacing to function
         if (isNumber(spacing)) {
-            spacingFunc = function () { return spacing; };
+            spacingFunc = () => spacing;
         }
         else if (isFunction(spacing)) {
             spacingFunc = spacing;
         }
         else {
-            spacingFunc = function () { return 0; };
+            spacingFunc = () => 0;
         }
         formattedOptions.spacing = spacingFunc;
         // nodeSize to function
         if (!nodeSize) {
-            nodeSizeFunc = function (d) {
-                var spacing = spacingFunc(d);
+            nodeSizeFunc = (d) => {
+                const spacing = spacingFunc(d);
                 if (d.size) {
                     if (isArray(d.size)) {
-                        var res = d.size[0] > d.size[1] ? d.size[0] : d.size[1];
+                        const res = d.size[0] > d.size[1] ? d.size[0] : d.size[1];
                         return (res + spacing) / 2;
                     }
                     if (isObject(d.size)) {
-                        var res = d.size.width > d.size.height ? d.size.width : d.size.height;
+                        const res = d.size.width > d.size.height ? d.size.width : d.size.height;
                         return (res + spacing) / 2;
                     }
                     return (d.size + spacing) / 2;
@@ -269,66 +250,65 @@ var ComboCombinedLayout = /** @class */ (function () {
             };
         }
         else if (isFunction(nodeSize)) {
-            nodeSizeFunc = function (d) {
-                var size = nodeSize(d);
-                var spacing = spacingFunc(d);
+            nodeSizeFunc = (d) => {
+                const size = nodeSize(d);
+                const spacing = spacingFunc(d);
                 if (isArray(d.size)) {
-                    var res = d.size[0] > d.size[1] ? d.size[0] : d.size[1];
+                    const res = d.size[0] > d.size[1] ? d.size[0] : d.size[1];
                     return (res + spacing) / 2;
                 }
                 return ((size || 32) + spacing) / 2;
             };
         }
         else if (isArray(nodeSize)) {
-            var larger = nodeSize[0] > nodeSize[1] ? nodeSize[0] : nodeSize[1];
-            var radius_1 = larger / 2;
-            nodeSizeFunc = function (d) { return radius_1 + spacingFunc(d) / 2; };
+            const larger = nodeSize[0] > nodeSize[1] ? nodeSize[0] : nodeSize[1];
+            const radius = larger / 2;
+            nodeSizeFunc = (d) => radius + spacingFunc(d) / 2;
         }
         else {
             // number type
-            var radius_2 = nodeSize / 2;
-            nodeSizeFunc = function (d) { return radius_2 + spacingFunc(d) / 2; };
+            const radius = nodeSize / 2;
+            nodeSizeFunc = (d) => radius + spacingFunc(d) / 2;
         }
         formattedOptions.nodeSize = nodeSizeFunc;
         // comboPadding to function
-        var comboPaddingFunc;
+        let comboPaddingFunc;
         if (isNumber(comboPadding)) {
-            comboPaddingFunc = function () { return comboPadding; };
+            comboPaddingFunc = () => comboPadding;
         }
         else if (isArray(comboPadding)) {
-            comboPaddingFunc = function () { return Math.max.apply(null, comboPadding); };
+            comboPaddingFunc = () => Math.max.apply(null, comboPadding);
         }
         else if (isFunction(comboPadding)) {
             comboPaddingFunc = comboPadding;
         }
         else {
             // null type
-            comboPaddingFunc = function () { return 0; };
+            comboPaddingFunc = () => 0;
         }
         formattedOptions.comboPadding = comboPaddingFunc;
         return formattedOptions;
-    };
-    ComboCombinedLayout.prototype.getInnerGraphs = function (graph, treeKey, nodeMap, comboMap, edges, options, comboNodes) {
-        var _this = this;
-        var nodeSize = options.nodeSize, comboPadding = options.comboPadding, spacing = options.spacing, innerLayout = options.innerLayout;
-        var innerGraphLayout = innerLayout || new ConcentricLayout({});
-        var innerLayoutOptions = {
+    }
+    getInnerGraphs(graph, treeKey, nodeMap, comboMap, edges, options, comboNodes) {
+        const { nodeSize, comboPadding, spacing, innerLayout } = options;
+        const innerGraphLayout = innerLayout || new ConcentricLayout({});
+        const innerLayoutOptions = {
             center: [0, 0],
             preventOverlap: true,
             nodeSpacing: spacing,
         };
-        var innerLayoutPromises = [];
-        var getSize = function (node) {
+        const innerLayoutPromises = [];
+        const getSize = (node) => {
             // @ts-ignore
-            var padding = (comboPadding === null || comboPadding === void 0 ? void 0 : comboPadding(node)) || 10;
+            let padding = (comboPadding === null || comboPadding === void 0 ? void 0 : comboPadding(node)) || 10;
             if (isArray(padding))
-                padding = Math.max.apply(Math, __spreadArray([], __read(padding)));
+                padding = Math.max(...padding);
             return {
                 size: padding ? [padding * 2, padding * 2] : [30, 30],
-                padding: padding,
+                padding,
             };
         };
-        graph.getRoots(treeKey).forEach(function (root) {
+        graph.getRoots(treeKey).forEach((root) => {
             // @ts-ignore
             comboNodes.set(root.id, {
                 id: root.id,
@@ -337,105 +317,95 @@ var ComboCombinedLayout = /** @class */ (function () {
                     size: getSize(root).size,
                 },
             });
-            var start = Promise.resolve();
+            let start = Promise.resolve();
             // Regard the child nodes in one combo as a graph, and layout them from bottom to top
-            graphTreeDfs(graph, [root], function (treeNode) {
+            graphTreeDfs(graph, [root], (treeNode) => {
                 var _a;
                 if (!treeNode.data._isCombo)
                     return;
-                var _b = getSize(treeNode), nsize = _b.size, padding = _b.padding;
+                const { size: nsize, padding } = getSize(treeNode);
                 if (!((_a = graph.getChildren(treeNode.id, treeKey)) === null || _a === void 0 ? void 0 : _a.length)) {
                     // empty combo
                     comboNodes.set(treeNode.id, {
                         id: treeNode.id,
-                        data: __assign(__assign({}, treeNode.data), { size: nsize }),
+                        data: Object.assign(Object.assign({}, treeNode.data), { size: nsize }),
                     });
                 }
                 else {
                     // combo not empty
-                    var comboNode = comboNodes.get(treeNode.id);
+                    const comboNode = comboNodes.get(treeNode.id);
                     comboNodes.set(treeNode.id, {
                         id: treeNode.id,
-                        data: __assign({ nodes: [] }, comboNode === null || comboNode === void 0 ? void 0 : comboNode.data),
+                        data: Object.assign({ nodes: [] }, comboNode === null || comboNode === void 0 ? void 0 : comboNode.data),
                     });
-                    var innerLayoutNodeIds_1 = new Map();
-                    var innerLayoutNodes_1 = graph
+                    const innerLayoutNodeIds = new Map();
+                    const innerLayoutNodes = graph
                         .getChildren(treeNode.id, treeKey)
-                        .map(function (child) {
+                        .map((child) => {
                         if (child.data._isCombo) {
-                            if (!comboNodes.has(child.id))
+                            if (!comboNodes.has(child.id)) {
                                 comboNodes.set(child.id, {
                                     id: child.id,
-                                    data: __assign({}, child.data),
+                                    data: Object.assign({}, child.data),
                                 });
-                            innerLayoutNodeIds_1.set(child.id, true);
+                            }
+                            innerLayoutNodeIds.set(child.id, true);
                             return comboNodes.get(child.id);
                         }
-                        var oriNode = nodeMap.get(child.id) || comboMap.get(child.id);
-                        innerLayoutNodeIds_1.set(child.id, true);
+                        const oriNode = nodeMap.get(child.id) || comboMap.get(child.id);
+                        innerLayoutNodeIds.set(child.id, true);
                         return {
                             id: child.id,
-                            data: __assign(__assign({}, oriNode.data), child.data),
+                            data: Object.assign(Object.assign({}, oriNode.data), child.data),
                         };
                     });
-                    var innerGraphData_1 = {
-                        nodes: innerLayoutNodes_1,
-                        edges: edges.filter(function (edge) {
-                            return innerLayoutNodeIds_1.has(edge.source) &&
-                                innerLayoutNodeIds_1.has(edge.target);
-                        }),
+                    const innerGraphData = {
+                        nodes: innerLayoutNodes,
+                        edges: edges.filter((edge) => innerLayoutNodeIds.has(edge.source) &&
+                            innerLayoutNodeIds.has(edge.target)),
                     };
-                    var minNodeSize_1 = Infinity;
-                    innerLayoutNodes_1.forEach(function (node) {
-                        var _a, _b;
-                        var size = node.data.size;
+                    let minNodeSize = Infinity;
+                    innerLayoutNodes.forEach((node) => {
+                        var _a;
+                        let { size } = node.data;
                         if (!size) {
                             size = ((_a = comboNodes.get(node.id)) === null || _a === void 0 ? void 0 : _a.data.size) ||
-                                ((_b = nodeSize) === null || _b === void 0 ? void 0 : _b(node)) || [30, 30];
+                                (nodeSize === null || nodeSize === void 0 ? void 0 : nodeSize(node)) || [30, 30];
                         }
                         if (isNumber(size))
                             size = [size, size];
-                        var _c = __read(size, 2), size0 = _c[0], size1 = _c[1];
-                        if (minNodeSize_1 > size0)
-                            minNodeSize_1 = size0;
-                        if (minNodeSize_1 > size1)
-                            minNodeSize_1 = size1;
+                        const [size0, size1] = size;
+                        if (minNodeSize > size0)
+                            minNodeSize = size0;
+                        if (minNodeSize > size1)
+                            minNodeSize = size1;
                         node.data.size = size;
                     });
                     // innerGraphLayout.assign(innerGraphCore, innerLayoutOptions);
-                    start = start.then(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var innerGraphCore, innerLayout, _a, minX, minY, maxX, maxY, center, size;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    innerGraphCore = new GraphCore(innerGraphData_1);
-                                    return [4 /*yield*/, innerGraphLayout.assign(innerGraphCore, innerLayoutOptions)];
-                                case 1:
-                                    innerLayout = _b.sent();
-                                    _a = getLayoutBBox(innerLayoutNodes_1), minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
-                                    center = { x: (maxX + minX) / 2, y: (maxY + minY) / 2 };
-                                    innerGraphData_1.nodes.forEach(function (node) {
-                                        node.data.x -= center.x;
-                                        node.data.y -= center.y;
-                                    });
-                                    size = [
-                                        Math.max(maxX - minX, minNodeSize_1) + padding * 2,
-                                        Math.max(maxY - minY, minNodeSize_1) + padding * 2,
-                                    ];
-                                    comboNodes.get(treeNode.id).data.size = size;
-                                    comboNodes.get(treeNode.id).data.nodes = innerLayoutNodes_1;
-                                    return [2 /*return*/, innerLayout];
-                            }
+                    start = start.then(() => __awaiter(this, void 0, void 0, function* () {
+                        const innerGraphCore = new GraphCore(innerGraphData);
+                        const innerLayout = yield innerGraphLayout.assign(innerGraphCore, innerLayoutOptions);
+                        const { minX, minY, maxX, maxY } = getLayoutBBox(innerLayoutNodes);
+                        // move the innerGraph to [0, 0], for later controled by parent layout
+                        const center = { x: (maxX + minX) / 2, y: (maxY + minY) / 2 };
+                        innerGraphData.nodes.forEach((node) => {
+                            node.data.x -= center.x;
+                            node.data.y -= center.y;
                         });
-                    }); });
+                        const size = [
+                            Math.max(maxX - minX, minNodeSize) + padding * 2,
+                            Math.max(maxY - minY, minNodeSize) + padding * 2,
+                        ];
+                        comboNodes.get(treeNode.id).data.size = size;
+                        comboNodes.get(treeNode.id).data.nodes = innerLayoutNodes;
+                        return innerLayout;
+                    }));
                 }
                 return true;
             }, 'BT', treeKey);
             innerLayoutPromises.push(start);
         });
         return innerLayoutPromises;
-    };
-    return ComboCombinedLayout;
-}());
-export { ComboCombinedLayout };
+    }
+}
 //# sourceMappingURL=comboCombined.js.map