first commit

node_modules/echarts/lib/chart/tree/TreeSeries.js

@@ -0,0 +1,192 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var SeriesModel = require("../../model/Series");
+
+var Tree = require("../../data/Tree");
+
+var _format = require("../../util/format");
+
+var encodeHTML = _format.encodeHTML;
+
+var Model = require("../../model/Model");
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var _default = SeriesModel.extend({
+  type: 'series.tree',
+  layoutInfo: null,
+  // can support the position parameters 'left', 'top','right','bottom', 'width',
+  // 'height' in the setOption() with 'merge' mode normal.
+  layoutMode: 'box',
+
+  /**
+   * Init a tree data structure from data in option series
+   * @param  {Object} option  the object used to config echarts view
+   * @return {module:echarts/data/List} storage initial data
+   */
+  getInitialData: function (option) {
+    //create an virtual root
+    var root = {
+      name: option.name,
+      children: option.data
+    };
+    var leaves = option.leaves || {};
+    var leavesModel = new Model(leaves, this, this.ecModel);
+    var tree = Tree.createTree(root, this, beforeLink);
+
+    function beforeLink(nodeData) {
+      nodeData.wrapMethod('getItemModel', function (model, idx) {
+        var node = tree.getNodeByDataIndex(idx);
+
+        if (!node.children.length || !node.isExpand) {
+          model.parentModel = leavesModel;
+        }
+
+        return model;
+      });
+    }
+
+    var treeDepth = 0;
+    tree.eachNode('preorder', function (node) {
+      if (node.depth > treeDepth) {
+        treeDepth = node.depth;
+      }
+    });
+    var expandAndCollapse = option.expandAndCollapse;
+    var expandTreeDepth = expandAndCollapse && option.initialTreeDepth >= 0 ? option.initialTreeDepth : treeDepth;
+    tree.root.eachNode('preorder', function (node) {
+      var item = node.hostTree.data.getRawDataItem(node.dataIndex); // Add item.collapsed != null, because users can collapse node original in the series.data.
+
+      node.isExpand = item && item.collapsed != null ? !item.collapsed : node.depth <= expandTreeDepth;
+    });
+    return tree.data;
+  },
+
+  /**
+   * Make the configuration 'orient' backward compatibly, with 'horizontal = LR', 'vertical = TB'.
+   * @returns {string} orient
+   */
+  getOrient: function () {
+    var orient = this.get('orient');
+
+    if (orient === 'horizontal') {
+      orient = 'LR';
+    } else if (orient === 'vertical') {
+      orient = 'TB';
+    }
+
+    return orient;
+  },
+  setZoom: function (zoom) {
+    this.option.zoom = zoom;
+  },
+  setCenter: function (center) {
+    this.option.center = center;
+  },
+
+  /**
+   * @override
+   * @param {number} dataIndex
+   */
+  formatTooltip: function (dataIndex) {
+    var tree = this.getData().tree;
+    var realRoot = tree.root.children[0];
+    var node = tree.getNodeByDataIndex(dataIndex);
+    var value = node.getValue();
+    var name = node.name;
+
+    while (node && node !== realRoot) {
+      name = node.parentNode.name + '.' + name;
+      node = node.parentNode;
+    }
+
+    return encodeHTML(name + (isNaN(value) || value == null ? '' : ' : ' + value));
+  },
+  defaultOption: {
+    zlevel: 0,
+    z: 2,
+    coordinateSystem: 'view',
+    // the position of the whole view
+    left: '12%',
+    top: '12%',
+    right: '12%',
+    bottom: '12%',
+    // the layout of the tree, two value can be selected, 'orthogonal' or 'radial'
+    layout: 'orthogonal',
+    // value can be 'polyline'
+    edgeShape: 'curve',
+    edgeForkPosition: '50%',
+    // true | false | 'move' | 'scale', see module:component/helper/RoamController.
+    roam: false,
+    // Symbol size scale ratio in roam
+    nodeScaleRatio: 0.4,
+    // Default on center of graph
+    center: null,
+    zoom: 1,
+    // The orient of orthoginal layout, can be setted to 'LR', 'TB', 'RL', 'BT'.
+    // and the backward compatibility configuration 'horizontal = LR', 'vertical = TB'.
+    orient: 'LR',
+    symbol: 'emptyCircle',
+    symbolSize: 7,
+    expandAndCollapse: true,
+    initialTreeDepth: 2,
+    lineStyle: {
+      color: '#ccc',
+      width: 1.5,
+      curveness: 0.5
+    },
+    itemStyle: {
+      color: 'lightsteelblue',
+      borderColor: '#c23531',
+      borderWidth: 1.5
+    },
+    label: {
+      show: true,
+      color: '#555'
+    },
+    leaves: {
+      label: {
+        show: true
+      }
+    },
+    animationEasing: 'linear',
+    animationDuration: 700,
+    animationDurationUpdate: 1000
+  }
+});
+
+module.exports = _default;

node_modules/echarts/lib/chart/tree/TreeView.js

@@ -0,0 +1,637 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var zrUtil = require("zrender/lib/core/util");
+
+var graphic = require("../../util/graphic");
+
+var SymbolClz = require("../helper/Symbol");
+
+var _layoutHelper = require("./layoutHelper");
+
+var radialCoordinate = _layoutHelper.radialCoordinate;
+
+var echarts = require("../../echarts");
+
+var bbox = require("zrender/lib/core/bbox");
+
+var View = require("../../coord/View");
+
+var roamHelper = require("../../component/helper/roamHelper");
+
+var RoamController = require("../../component/helper/RoamController");
+
+var _cursorHelper = require("../../component/helper/cursorHelper");
+
+var onIrrelevantElement = _cursorHelper.onIrrelevantElement;
+
+var _config = require("../../config");
+
+var __DEV__ = _config.__DEV__;
+
+var _number = require("../../util/number");
+
+var parsePercent = _number.parsePercent;
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var TreeShape = graphic.extendShape({
+  shape: {
+    parentPoint: [],
+    childPoints: [],
+    orient: '',
+    forkPosition: ''
+  },
+  style: {
+    stroke: '#000',
+    fill: null
+  },
+  buildPath: function (ctx, shape) {
+    var childPoints = shape.childPoints;
+    var childLen = childPoints.length;
+    var parentPoint = shape.parentPoint;
+    var firstChildPos = childPoints[0];
+    var lastChildPos = childPoints[childLen - 1];
+
+    if (childLen === 1) {
+      ctx.moveTo(parentPoint[0], parentPoint[1]);
+      ctx.lineTo(firstChildPos[0], firstChildPos[1]);
+      return;
+    }
+
+    var orient = shape.orient;
+    var forkDim = orient === 'TB' || orient === 'BT' ? 0 : 1;
+    var otherDim = 1 - forkDim;
+    var forkPosition = parsePercent(shape.forkPosition, 1);
+    var tmpPoint = [];
+    tmpPoint[forkDim] = parentPoint[forkDim];
+    tmpPoint[otherDim] = parentPoint[otherDim] + (lastChildPos[otherDim] - parentPoint[otherDim]) * forkPosition;
+    ctx.moveTo(parentPoint[0], parentPoint[1]);
+    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+    ctx.moveTo(firstChildPos[0], firstChildPos[1]);
+    tmpPoint[forkDim] = firstChildPos[forkDim];
+    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+    tmpPoint[forkDim] = lastChildPos[forkDim];
+    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+    ctx.lineTo(lastChildPos[0], lastChildPos[1]);
+
+    for (var i = 1; i < childLen - 1; i++) {
+      var point = childPoints[i];
+      ctx.moveTo(point[0], point[1]);
+      tmpPoint[forkDim] = point[forkDim];
+      ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+    }
+  }
+});
+
+var _default = echarts.extendChartView({
+  type: 'tree',
+
+  /**
+   * Init the chart
+   * @override
+   * @param  {module:echarts/model/Global} ecModel
+   * @param  {module:echarts/ExtensionAPI} api
+   */
+  init: function (ecModel, api) {
+    /**
+     * @private
+     * @type {module:echarts/data/Tree}
+     */
+    this._oldTree;
+    /**
+     * @private
+     * @type {module:zrender/container/Group}
+     */
+
+    this._mainGroup = new graphic.Group();
+    /**
+     * @private
+     * @type {module:echarts/componet/helper/RoamController}
+     */
+
+    this._controller = new RoamController(api.getZr());
+    this._controllerHost = {
+      target: this.group
+    };
+    this.group.add(this._mainGroup);
+  },
+  render: function (seriesModel, ecModel, api, payload) {
+    var data = seriesModel.getData();
+    var layoutInfo = seriesModel.layoutInfo;
+    var group = this._mainGroup;
+    var layout = seriesModel.get('layout');
+
+    if (layout === 'radial') {
+      group.attr('position', [layoutInfo.x + layoutInfo.width / 2, layoutInfo.y + layoutInfo.height / 2]);
+    } else {
+      group.attr('position', [layoutInfo.x, layoutInfo.y]);
+    }
+
+    this._updateViewCoordSys(seriesModel, layoutInfo, layout);
+
+    this._updateController(seriesModel, ecModel, api);
+
+    var oldData = this._data;
+    var seriesScope = {
+      expandAndCollapse: seriesModel.get('expandAndCollapse'),
+      layout: layout,
+      edgeShape: seriesModel.get('edgeShape'),
+      edgeForkPosition: seriesModel.get('edgeForkPosition'),
+      orient: seriesModel.getOrient(),
+      curvature: seriesModel.get('lineStyle.curveness'),
+      symbolRotate: seriesModel.get('symbolRotate'),
+      symbolOffset: seriesModel.get('symbolOffset'),
+      hoverAnimation: seriesModel.get('hoverAnimation'),
+      useNameLabel: true,
+      fadeIn: true
+    };
+    data.diff(oldData).add(function (newIdx) {
+      if (symbolNeedsDraw(data, newIdx)) {
+        // Create node and edge
+        updateNode(data, newIdx, null, group, seriesModel, seriesScope);
+      }
+    }).update(function (newIdx, oldIdx) {
+      var symbolEl = oldData.getItemGraphicEl(oldIdx);
+
+      if (!symbolNeedsDraw(data, newIdx)) {
+        symbolEl && removeNode(oldData, oldIdx, symbolEl, group, seriesModel, seriesScope);
+        return;
+      } // Update node and edge
+
+
+      updateNode(data, newIdx, symbolEl, group, seriesModel, seriesScope);
+    }).remove(function (oldIdx) {
+      var symbolEl = oldData.getItemGraphicEl(oldIdx); // When remove a collapsed node of subtree, since the collapsed
+      // node haven't been initialized with a symbol element,
+      // you can't found it's symbol element through index.
+      // so if we want to remove the symbol element we should insure
+      // that the symbol element is not null.
+
+      if (symbolEl) {
+        removeNode(oldData, oldIdx, symbolEl, group, seriesModel, seriesScope);
+      }
+    }).execute();
+    this._nodeScaleRatio = seriesModel.get('nodeScaleRatio');
+
+    this._updateNodeAndLinkScale(seriesModel);
+
+    if (seriesScope.expandAndCollapse === true) {
+      data.eachItemGraphicEl(function (el, dataIndex) {
+        el.off('click').on('click', function () {
+          api.dispatchAction({
+            type: 'treeExpandAndCollapse',
+            seriesId: seriesModel.id,
+            dataIndex: dataIndex
+          });
+        });
+      });
+    }
+
+    this._data = data;
+  },
+  _updateViewCoordSys: function (seriesModel) {
+    var data = seriesModel.getData();
+    var points = [];
+    data.each(function (idx) {
+      var layout = data.getItemLayout(idx);
+
+      if (layout && !isNaN(layout.x) && !isNaN(layout.y)) {
+        points.push([+layout.x, +layout.y]);
+      }
+    });
+    var min = [];
+    var max = [];
+    bbox.fromPoints(points, min, max); // If don't Store min max when collapse the root node after roam,
+    // the root node will disappear.
+
+    var oldMin = this._min;
+    var oldMax = this._max; // If width or height is 0
+
+    if (max[0] - min[0] === 0) {
+      min[0] = oldMin ? oldMin[0] : min[0] - 1;
+      max[0] = oldMax ? oldMax[0] : max[0] + 1;
+    }
+
+    if (max[1] - min[1] === 0) {
+      min[1] = oldMin ? oldMin[1] : min[1] - 1;
+      max[1] = oldMax ? oldMax[1] : max[1] + 1;
+    }
+
+    var viewCoordSys = seriesModel.coordinateSystem = new View();
+    viewCoordSys.zoomLimit = seriesModel.get('scaleLimit');
+    viewCoordSys.setBoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+    viewCoordSys.setCenter(seriesModel.get('center'));
+    viewCoordSys.setZoom(seriesModel.get('zoom')); // Here we use viewCoordSys just for computing the 'position' and 'scale' of the group
+
+    this.group.attr({
+      position: viewCoordSys.position,
+      scale: viewCoordSys.scale
+    });
+    this._viewCoordSys = viewCoordSys;
+    this._min = min;
+    this._max = max;
+  },
+  _updateController: function (seriesModel, ecModel, api) {
+    var controller = this._controller;
+    var controllerHost = this._controllerHost;
+    var group = this.group;
+    controller.setPointerChecker(function (e, x, y) {
+      var rect = group.getBoundingRect();
+      rect.applyTransform(group.transform);
+      return rect.contain(x, y) && !onIrrelevantElement(e, api, seriesModel);
+    });
+    controller.enable(seriesModel.get('roam'));
+    controllerHost.zoomLimit = seriesModel.get('scaleLimit');
+    controllerHost.zoom = seriesModel.coordinateSystem.getZoom();
+    controller.off('pan').off('zoom').on('pan', function (e) {
+      roamHelper.updateViewOnPan(controllerHost, e.dx, e.dy);
+      api.dispatchAction({
+        seriesId: seriesModel.id,
+        type: 'treeRoam',
+        dx: e.dx,
+        dy: e.dy
+      });
+    }, this).on('zoom', function (e) {
+      roamHelper.updateViewOnZoom(controllerHost, e.scale, e.originX, e.originY);
+      api.dispatchAction({
+        seriesId: seriesModel.id,
+        type: 'treeRoam',
+        zoom: e.scale,
+        originX: e.originX,
+        originY: e.originY
+      });
+
+      this._updateNodeAndLinkScale(seriesModel);
+    }, this);
+  },
+  _updateNodeAndLinkScale: function (seriesModel) {
+    var data = seriesModel.getData();
+
+    var nodeScale = this._getNodeGlobalScale(seriesModel);
+
+    var invScale = [nodeScale, nodeScale];
+    data.eachItemGraphicEl(function (el, idx) {
+      el.attr('scale', invScale);
+    });
+  },
+  _getNodeGlobalScale: function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+
+    if (coordSys.type !== 'view') {
+      return 1;
+    }
+
+    var nodeScaleRatio = this._nodeScaleRatio;
+    var groupScale = coordSys.scale;
+    var groupZoom = groupScale && groupScale[0] || 1; // Scale node when zoom changes
+
+    var roamZoom = coordSys.getZoom();
+    var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+    return nodeScale / groupZoom;
+  },
+  dispose: function () {
+    this._controller && this._controller.dispose();
+    this._controllerHost = {};
+  },
+  remove: function () {
+    this._mainGroup.removeAll();
+
+    this._data = null;
+  }
+});
+
+function symbolNeedsDraw(data, dataIndex) {
+  var layout = data.getItemLayout(dataIndex);
+  return layout && !isNaN(layout.x) && !isNaN(layout.y) && data.getItemVisual(dataIndex, 'symbol') !== 'none';
+}
+
+function getTreeNodeStyle(node, itemModel, seriesScope) {
+  seriesScope.itemModel = itemModel;
+  seriesScope.itemStyle = itemModel.getModel('itemStyle').getItemStyle();
+  seriesScope.hoverItemStyle = itemModel.getModel('emphasis.itemStyle').getItemStyle();
+  seriesScope.lineStyle = itemModel.getModel('lineStyle').getLineStyle();
+  seriesScope.labelModel = itemModel.getModel('label');
+  seriesScope.hoverLabelModel = itemModel.getModel('emphasis.label');
+
+  if (node.isExpand === false && node.children.length !== 0) {
+    seriesScope.symbolInnerColor = seriesScope.itemStyle.fill;
+  } else {
+    seriesScope.symbolInnerColor = '#fff';
+  }
+
+  return seriesScope;
+}
+
+function updateNode(data, dataIndex, symbolEl, group, seriesModel, seriesScope) {
+  var isInit = !symbolEl;
+  var node = data.tree.getNodeByDataIndex(dataIndex);
+  var itemModel = node.getModel();
+  var seriesScope = getTreeNodeStyle(node, itemModel, seriesScope);
+  var virtualRoot = data.tree.root;
+  var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
+  var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
+  var sourceLayout = source.getLayout();
+  var sourceOldLayout = sourceSymbolEl ? {
+    x: sourceSymbolEl.position[0],
+    y: sourceSymbolEl.position[1],
+    rawX: sourceSymbolEl.__radialOldRawX,
+    rawY: sourceSymbolEl.__radialOldRawY
+  } : sourceLayout;
+  var targetLayout = node.getLayout();
+
+  if (isInit) {
+    symbolEl = new SymbolClz(data, dataIndex, seriesScope);
+    symbolEl.attr('position', [sourceOldLayout.x, sourceOldLayout.y]);
+  } else {
+    symbolEl.updateData(data, dataIndex, seriesScope);
+  }
+
+  symbolEl.__radialOldRawX = symbolEl.__radialRawX;
+  symbolEl.__radialOldRawY = symbolEl.__radialRawY;
+  symbolEl.__radialRawX = targetLayout.rawX;
+  symbolEl.__radialRawY = targetLayout.rawY;
+  group.add(symbolEl);
+  data.setItemGraphicEl(dataIndex, symbolEl);
+  graphic.updateProps(symbolEl, {
+    position: [targetLayout.x, targetLayout.y]
+  }, seriesModel);
+  var symbolPath = symbolEl.getSymbolPath();
+
+  if (seriesScope.layout === 'radial') {
+    var realRoot = virtualRoot.children[0];
+    var rootLayout = realRoot.getLayout();
+    var length = realRoot.children.length;
+    var rad;
+    var isLeft;
+
+    if (targetLayout.x === rootLayout.x && node.isExpand === true) {
+      var center = {};
+      center.x = (realRoot.children[0].getLayout().x + realRoot.children[length - 1].getLayout().x) / 2;
+      center.y = (realRoot.children[0].getLayout().y + realRoot.children[length - 1].getLayout().y) / 2;
+      rad = Math.atan2(center.y - rootLayout.y, center.x - rootLayout.x);
+
+      if (rad < 0) {
+        rad = Math.PI * 2 + rad;
+      }
+
+      isLeft = center.x < rootLayout.x;
+
+      if (isLeft) {
+        rad = rad - Math.PI;
+      }
+    } else {
+      rad = Math.atan2(targetLayout.y - rootLayout.y, targetLayout.x - rootLayout.x);
+
+      if (rad < 0) {
+        rad = Math.PI * 2 + rad;
+      }
+
+      if (node.children.length === 0 || node.children.length !== 0 && node.isExpand === false) {
+        isLeft = targetLayout.x < rootLayout.x;
+
+        if (isLeft) {
+          rad = rad - Math.PI;
+        }
+      } else {
+        isLeft = targetLayout.x > rootLayout.x;
+
+        if (!isLeft) {
+          rad = rad - Math.PI;
+        }
+      }
+    }
+
+    var textPosition = isLeft ? 'left' : 'right';
+    var rotate = seriesScope.labelModel.get('rotate');
+    var labelRotateRadian = rotate * (Math.PI / 180);
+    symbolPath.setStyle({
+      textPosition: seriesScope.labelModel.get('position') || textPosition,
+      textRotation: rotate == null ? -rad : labelRotateRadian,
+      textOrigin: 'center',
+      verticalAlign: 'middle'
+    });
+  }
+
+  drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group, seriesScope);
+}
+
+function drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group, seriesScope) {
+  var edgeShape = seriesScope.edgeShape;
+  var edge = symbolEl.__edge;
+
+  if (edgeShape === 'curve') {
+    if (node.parentNode && node.parentNode !== virtualRoot) {
+      if (!edge) {
+        edge = symbolEl.__edge = new graphic.BezierCurve({
+          shape: getEdgeShape(seriesScope, sourceOldLayout, sourceOldLayout),
+          style: zrUtil.defaults({
+            opacity: 0,
+            strokeNoScale: true
+          }, seriesScope.lineStyle)
+        });
+      }
+
+      graphic.updateProps(edge, {
+        shape: getEdgeShape(seriesScope, sourceLayout, targetLayout),
+        style: zrUtil.defaults({
+          opacity: 1
+        }, seriesScope.lineStyle)
+      }, seriesModel);
+    }
+  } else if (edgeShape === 'polyline') {
+    if (seriesScope.layout === 'orthogonal') {
+      if (node !== virtualRoot && node.children && node.children.length !== 0 && node.isExpand === true) {
+        var children = node.children;
+        var childPoints = [];
+
+        for (var i = 0; i < children.length; i++) {
+          var childLayout = children[i].getLayout();
+          childPoints.push([childLayout.x, childLayout.y]);
+        }
+
+        if (!edge) {
+          edge = symbolEl.__edge = new TreeShape({
+            shape: {
+              parentPoint: [targetLayout.x, targetLayout.y],
+              childPoints: [[targetLayout.x, targetLayout.y]],
+              orient: seriesScope.orient,
+              forkPosition: seriesScope.edgeForkPosition
+            },
+            style: zrUtil.defaults({
+              opacity: 0,
+              strokeNoScale: true
+            }, seriesScope.lineStyle)
+          });
+        }
+
+        graphic.updateProps(edge, {
+          shape: {
+            parentPoint: [targetLayout.x, targetLayout.y],
+            childPoints: childPoints
+          },
+          style: zrUtil.defaults({
+            opacity: 1
+          }, seriesScope.lineStyle)
+        }, seriesModel);
+      }
+    } else {}
+  }
+
+  group.add(edge);
+}
+
+function removeNode(data, dataIndex, symbolEl, group, seriesModel, seriesScope) {
+  var node = data.tree.getNodeByDataIndex(dataIndex);
+  var virtualRoot = data.tree.root;
+  var itemModel = node.getModel();
+  var seriesScope = getTreeNodeStyle(node, itemModel, seriesScope);
+  var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
+  var edgeShape = seriesScope.edgeShape;
+  var sourceLayout;
+
+  while (sourceLayout = source.getLayout(), sourceLayout == null) {
+    source = source.parentNode === virtualRoot ? source : source.parentNode || source;
+  }
+
+  graphic.updateProps(symbolEl, {
+    position: [sourceLayout.x + 1, sourceLayout.y + 1]
+  }, seriesModel, function () {
+    group.remove(symbolEl);
+    data.setItemGraphicEl(dataIndex, null);
+  });
+  symbolEl.fadeOut(null, {
+    keepLabel: true
+  });
+  var sourceSymbolEl = data.getItemGraphicEl(source.dataIndex);
+  var sourceEdge = sourceSymbolEl.__edge; // 1. when expand the sub tree, delete the children node should delete the edge of
+  // the source at the same time. because the polyline edge shape is only owned by the source.
+  // 2.when the node is the only children of the source, delete the node should delete the edge of
+  // the source at the same time. the same reason as above.
+
+  var edge = symbolEl.__edge || (source.isExpand === false || source.children.length === 1 ? sourceEdge : undefined);
+  var edgeShape = seriesScope.edgeShape;
+
+  if (edge) {
+    if (edgeShape === 'curve') {
+      graphic.updateProps(edge, {
+        shape: getEdgeShape(seriesScope, sourceLayout, sourceLayout),
+        style: {
+          opacity: 0
+        }
+      }, seriesModel, function () {
+        group.remove(edge);
+      });
+    } else if (edgeShape === 'polyline' && seriesScope.layout === 'orthogonal') {
+      graphic.updateProps(edge, {
+        shape: {
+          parentPoint: [sourceLayout.x, sourceLayout.y],
+          childPoints: [[sourceLayout.x, sourceLayout.y]]
+        },
+        style: {
+          opacity: 0
+        }
+      }, seriesModel, function () {
+        group.remove(edge);
+      });
+    }
+  }
+}
+
+function getEdgeShape(seriesScope, sourceLayout, targetLayout) {
+  var cpx1;
+  var cpy1;
+  var cpx2;
+  var cpy2;
+  var orient = seriesScope.orient;
+  var x1;
+  var x2;
+  var y1;
+  var y2;
+
+  if (seriesScope.layout === 'radial') {
+    x1 = sourceLayout.rawX;
+    y1 = sourceLayout.rawY;
+    x2 = targetLayout.rawX;
+    y2 = targetLayout.rawY;
+    var radialCoor1 = radialCoordinate(x1, y1);
+    var radialCoor2 = radialCoordinate(x1, y1 + (y2 - y1) * seriesScope.curvature);
+    var radialCoor3 = radialCoordinate(x2, y2 + (y1 - y2) * seriesScope.curvature);
+    var radialCoor4 = radialCoordinate(x2, y2);
+    return {
+      x1: radialCoor1.x,
+      y1: radialCoor1.y,
+      x2: radialCoor4.x,
+      y2: radialCoor4.y,
+      cpx1: radialCoor2.x,
+      cpy1: radialCoor2.y,
+      cpx2: radialCoor3.x,
+      cpy2: radialCoor3.y
+    };
+  } else {
+    x1 = sourceLayout.x;
+    y1 = sourceLayout.y;
+    x2 = targetLayout.x;
+    y2 = targetLayout.y;
+
+    if (orient === 'LR' || orient === 'RL') {
+      cpx1 = x1 + (x2 - x1) * seriesScope.curvature;
+      cpy1 = y1;
+      cpx2 = x2 + (x1 - x2) * seriesScope.curvature;
+      cpy2 = y2;
+    }
+
+    if (orient === 'TB' || orient === 'BT') {
+      cpx1 = x1;
+      cpy1 = y1 + (y2 - y1) * seriesScope.curvature;
+      cpx2 = x2;
+      cpy2 = y2 + (y1 - y2) * seriesScope.curvature;
+    }
+  }
+
+  return {
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    cpx1: cpx1,
+    cpy1: cpy1,
+    cpx2: cpx2,
+    cpy2: cpy2
+  };
+}
+
+module.exports = _default;

node_modules/echarts/lib/chart/tree/layoutHelper.js

@@ -0,0 +1,367 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var layout = require("../../util/layout");
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+/*
+* A third-party license is embeded for some of the code in this file:
+* The tree layoutHelper implementation was originally copied from
+* "d3.js"(https://github.com/d3/d3-hierarchy) with
+* some modifications made for this project.
+* (see more details in the comment of the specific method below.)
+* The use of the source code of this file is also subject to the terms
+* and consitions of the licence of "d3.js" (BSD-3Clause, see
+* </licenses/LICENSE-d3>).
+*/
+
+/**
+ * @file The layout algorithm of node-link tree diagrams. Here we using Reingold-Tilford algorithm to drawing
+ *       the tree.
+ */
+
+/**
+ * Initialize all computational message for following algorithm.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} root   The virtual root of the tree.
+ */
+function init(root) {
+  root.hierNode = {
+    defaultAncestor: null,
+    ancestor: root,
+    prelim: 0,
+    modifier: 0,
+    change: 0,
+    shift: 0,
+    i: 0,
+    thread: null
+  };
+  var nodes = [root];
+  var node;
+  var children;
+
+  while (node = nodes.pop()) {
+    // jshint ignore:line
+    children = node.children;
+
+    if (node.isExpand && children.length) {
+      var n = children.length;
+
+      for (var i = n - 1; i >= 0; i--) {
+        var child = children[i];
+        child.hierNode = {
+          defaultAncestor: null,
+          ancestor: child,
+          prelim: 0,
+          modifier: 0,
+          change: 0,
+          shift: 0,
+          i: i,
+          thread: null
+        };
+        nodes.push(child);
+      }
+    }
+  }
+}
+/**
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ *
+ * Computes a preliminary x coordinate for node. Before that, this function is
+ * applied recursively to the children of node, as well as the function
+ * apportion(). After spacing out the children by calling executeShifts(), the
+ * node is placed to the midpoint of its outermost children.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ * @param {Function} separation
+ */
+
+
+function firstWalk(node, separation) {
+  var children = node.isExpand ? node.children : [];
+  var siblings = node.parentNode.children;
+  var subtreeW = node.hierNode.i ? siblings[node.hierNode.i - 1] : null;
+
+  if (children.length) {
+    executeShifts(node);
+    var midPoint = (children[0].hierNode.prelim + children[children.length - 1].hierNode.prelim) / 2;
+
+    if (subtreeW) {
+      node.hierNode.prelim = subtreeW.hierNode.prelim + separation(node, subtreeW);
+      node.hierNode.modifier = node.hierNode.prelim - midPoint;
+    } else {
+      node.hierNode.prelim = midPoint;
+    }
+  } else if (subtreeW) {
+    node.hierNode.prelim = subtreeW.hierNode.prelim + separation(node, subtreeW);
+  }
+
+  node.parentNode.hierNode.defaultAncestor = apportion(node, subtreeW, node.parentNode.hierNode.defaultAncestor || siblings[0], separation);
+}
+/**
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ *
+ * Computes all real x-coordinates by summing up the modifiers recursively.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ */
+
+
+function secondWalk(node) {
+  var nodeX = node.hierNode.prelim + node.parentNode.hierNode.modifier;
+  node.setLayout({
+    x: nodeX
+  }, true);
+  node.hierNode.modifier += node.parentNode.hierNode.modifier;
+}
+
+function separation(cb) {
+  return arguments.length ? cb : defaultSeparation;
+}
+/**
+ * Transform the common coordinate to radial coordinate.
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @return {Object}
+ */
+
+
+function radialCoordinate(x, y) {
+  var radialCoor = {};
+  x -= Math.PI / 2;
+  radialCoor.x = y * Math.cos(x);
+  radialCoor.y = y * Math.sin(x);
+  return radialCoor;
+}
+/**
+ * Get the layout position of the whole view.
+ *
+ * @param {module:echarts/model/Series} seriesModel  the model object of sankey series
+ * @param {module:echarts/ExtensionAPI} api  provide the API list that the developer can call
+ * @return {module:zrender/core/BoundingRect}  size of rect to draw the sankey view
+ */
+
+
+function getViewRect(seriesModel, api) {
+  return layout.getLayoutRect(seriesModel.getBoxLayoutParams(), {
+    width: api.getWidth(),
+    height: api.getHeight()
+  });
+}
+/**
+ * All other shifts, applied to the smaller subtrees between w- and w+, are
+ * performed by this function.
+ *
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ */
+
+
+function executeShifts(node) {
+  var children = node.children;
+  var n = children.length;
+  var shift = 0;
+  var change = 0;
+
+  while (--n >= 0) {
+    var child = children[n];
+    child.hierNode.prelim += shift;
+    child.hierNode.modifier += shift;
+    change += child.hierNode.change;
+    shift += child.hierNode.shift + change;
+  }
+}
+/**
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ *
+ * The core of the algorithm. Here, a new subtree is combined with the
+ * previous subtrees. Threads are used to traverse the inside and outside
+ * contours of the left and right subtree up to the highest common level.
+ * Whenever two nodes of the inside contours conflict, we compute the left
+ * one of the greatest uncommon ancestors using the function nextAncestor()
+ * and call moveSubtree() to shift the subtree and prepare the shifts of
+ * smaller subtrees. Finally, we add a new thread (if necessary).
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} subtreeV
+ * @param  {module:echarts/data/Tree~TreeNode} subtreeW
+ * @param  {module:echarts/data/Tree~TreeNode} ancestor
+ * @param  {Function} separation
+ * @return {module:echarts/data/Tree~TreeNode}
+ */
+
+
+function apportion(subtreeV, subtreeW, ancestor, separation) {
+  if (subtreeW) {
+    var nodeOutRight = subtreeV;
+    var nodeInRight = subtreeV;
+    var nodeOutLeft = nodeInRight.parentNode.children[0];
+    var nodeInLeft = subtreeW;
+    var sumOutRight = nodeOutRight.hierNode.modifier;
+    var sumInRight = nodeInRight.hierNode.modifier;
+    var sumOutLeft = nodeOutLeft.hierNode.modifier;
+    var sumInLeft = nodeInLeft.hierNode.modifier;
+
+    while (nodeInLeft = nextRight(nodeInLeft), nodeInRight = nextLeft(nodeInRight), nodeInLeft && nodeInRight) {
+      nodeOutRight = nextRight(nodeOutRight);
+      nodeOutLeft = nextLeft(nodeOutLeft);
+      nodeOutRight.hierNode.ancestor = subtreeV;
+      var shift = nodeInLeft.hierNode.prelim + sumInLeft - nodeInRight.hierNode.prelim - sumInRight + separation(nodeInLeft, nodeInRight);
+
+      if (shift > 0) {
+        moveSubtree(nextAncestor(nodeInLeft, subtreeV, ancestor), subtreeV, shift);
+        sumInRight += shift;
+        sumOutRight += shift;
+      }
+
+      sumInLeft += nodeInLeft.hierNode.modifier;
+      sumInRight += nodeInRight.hierNode.modifier;
+      sumOutRight += nodeOutRight.hierNode.modifier;
+      sumOutLeft += nodeOutLeft.hierNode.modifier;
+    }
+
+    if (nodeInLeft && !nextRight(nodeOutRight)) {
+      nodeOutRight.hierNode.thread = nodeInLeft;
+      nodeOutRight.hierNode.modifier += sumInLeft - sumOutRight;
+    }
+
+    if (nodeInRight && !nextLeft(nodeOutLeft)) {
+      nodeOutLeft.hierNode.thread = nodeInRight;
+      nodeOutLeft.hierNode.modifier += sumInRight - sumOutLeft;
+      ancestor = subtreeV;
+    }
+  }
+
+  return ancestor;
+}
+/**
+ * This function is used to traverse the right contour of a subtree.
+ * It returns the rightmost child of node or the thread of node. The function
+ * returns null if and only if node is on the highest depth of its subtree.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ * @return {module:echarts/data/Tree~TreeNode}
+ */
+
+
+function nextRight(node) {
+  var children = node.children;
+  return children.length && node.isExpand ? children[children.length - 1] : node.hierNode.thread;
+}
+/**
+ * This function is used to traverse the left contour of a subtree (or a subforest).
+ * It returns the leftmost child of node or the thread of node. The function
+ * returns null if and only if node is on the highest depth of its subtree.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ * @return {module:echarts/data/Tree~TreeNode}
+ */
+
+
+function nextLeft(node) {
+  var children = node.children;
+  return children.length && node.isExpand ? children[0] : node.hierNode.thread;
+}
+/**
+ * If nodeInLeft’s ancestor is a sibling of node, returns nodeInLeft’s ancestor.
+ * Otherwise, returns the specified ancestor.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} nodeInLeft
+ * @param  {module:echarts/data/Tree~TreeNode} node
+ * @param  {module:echarts/data/Tree~TreeNode} ancestor
+ * @return {module:echarts/data/Tree~TreeNode}
+ */
+
+
+function nextAncestor(nodeInLeft, node, ancestor) {
+  return nodeInLeft.hierNode.ancestor.parentNode === node.parentNode ? nodeInLeft.hierNode.ancestor : ancestor;
+}
+/**
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ *
+ * Shifts the current subtree rooted at wr.
+ * This is done by increasing prelim(w+) and modifier(w+) by shift.
+ *
+ * @param  {module:echarts/data/Tree~TreeNode} wl
+ * @param  {module:echarts/data/Tree~TreeNode} wr
+ * @param  {number} shift [description]
+ */
+
+
+function moveSubtree(wl, wr, shift) {
+  var change = shift / (wr.hierNode.i - wl.hierNode.i);
+  wr.hierNode.change -= change;
+  wr.hierNode.shift += shift;
+  wr.hierNode.modifier += shift;
+  wr.hierNode.prelim += shift;
+  wl.hierNode.change += change;
+}
+/**
+ * The implementation of this function was originally copied from "d3.js"
+ * <https://github.com/d3/d3-hierarchy/blob/4c1f038f2725d6eae2e49b61d01456400694bac4/src/tree.js>
+ * with some modifications made for this program.
+ * See the license statement at the head of this file.
+ */
+
+
+function defaultSeparation(node1, node2) {
+  return node1.parentNode === node2.parentNode ? 1 : 2;
+}
+
+exports.init = init;
+exports.firstWalk = firstWalk;
+exports.secondWalk = secondWalk;
+exports.separation = separation;
+exports.radialCoordinate = radialCoordinate;
+exports.getViewRect = getViewRect;

node_modules/echarts/lib/chart/tree/traversalHelper.js

@@ -0,0 +1,98 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+/**
+ * Traverse the tree from bottom to top and do something
+ * @param  {module:echarts/data/Tree~TreeNode} root  The real root of the tree
+ * @param  {Function} callback
+ */
+function eachAfter(root, callback, separation) {
+  var nodes = [root];
+  var next = [];
+  var node;
+
+  while (node = nodes.pop()) {
+    // jshint ignore:line
+    next.push(node);
+
+    if (node.isExpand) {
+      var children = node.children;
+
+      if (children.length) {
+        for (var i = 0; i < children.length; i++) {
+          nodes.push(children[i]);
+        }
+      }
+    }
+  }
+
+  while (node = next.pop()) {
+    // jshint ignore:line
+    callback(node, separation);
+  }
+}
+/**
+ * Traverse the tree from top to bottom and do something
+ * @param  {module:echarts/data/Tree~TreeNode} root  The real root of the tree
+ * @param  {Function} callback
+ */
+
+
+function eachBefore(root, callback) {
+  var nodes = [root];
+  var node;
+
+  while (node = nodes.pop()) {
+    // jshint ignore:line
+    callback(node);
+
+    if (node.isExpand) {
+      var children = node.children;
+
+      if (children.length) {
+        for (var i = children.length - 1; i >= 0; i--) {
+          nodes.push(children[i]);
+        }
+      }
+    }
+  }
+}
+
+exports.eachAfter = eachAfter;
+exports.eachBefore = eachBefore;

node_modules/echarts/lib/chart/tree/treeAction.js

@@ -0,0 +1,80 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var echarts = require("../../echarts");
+
+var _roamHelper = require("../../action/roamHelper");
+
+var updateCenterAndZoom = _roamHelper.updateCenterAndZoom;
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+echarts.registerAction({
+  type: 'treeExpandAndCollapse',
+  event: 'treeExpandAndCollapse',
+  update: 'update'
+}, function (payload, ecModel) {
+  ecModel.eachComponent({
+    mainType: 'series',
+    subType: 'tree',
+    query: payload
+  }, function (seriesModel) {
+    var dataIndex = payload.dataIndex;
+    var tree = seriesModel.getData().tree;
+    var node = tree.getNodeByDataIndex(dataIndex);
+    node.isExpand = !node.isExpand;
+  });
+});
+echarts.registerAction({
+  type: 'treeRoam',
+  event: 'treeRoam',
+  // Here we set 'none' instead of 'update', because roam action
+  // just need to update the transform matrix without having to recalculate
+  // the layout. So don't need to go through the whole update process, such
+  // as 'dataPrcocess', 'coordSystemUpdate', 'layout' and so on.
+  update: 'none'
+}, function (payload, ecModel) {
+  ecModel.eachComponent({
+    mainType: 'series',
+    subType: 'tree',
+    query: payload
+  }, function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    var res = updateCenterAndZoom(coordSys, payload);
+    seriesModel.setCenter && seriesModel.setCenter(res.center);
+    seriesModel.setZoom && seriesModel.setZoom(res.zoom);
+  });
+});

node_modules/echarts/lib/chart/tree/treeLayout.js

@@ -0,0 +1,157 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var _traversalHelper = require("./traversalHelper");
+
+var eachAfter = _traversalHelper.eachAfter;
+var eachBefore = _traversalHelper.eachBefore;
+
+var _layoutHelper = require("./layoutHelper");
+
+var init = _layoutHelper.init;
+var firstWalk = _layoutHelper.firstWalk;
+var secondWalk = _layoutHelper.secondWalk;
+var sep = _layoutHelper.separation;
+var radialCoordinate = _layoutHelper.radialCoordinate;
+var getViewRect = _layoutHelper.getViewRect;
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function _default(ecModel, api) {
+  ecModel.eachSeriesByType('tree', function (seriesModel) {
+    commonLayout(seriesModel, api);
+  });
+}
+
+function commonLayout(seriesModel, api) {
+  var layoutInfo = getViewRect(seriesModel, api);
+  seriesModel.layoutInfo = layoutInfo;
+  var layout = seriesModel.get('layout');
+  var width = 0;
+  var height = 0;
+  var separation = null;
+
+  if (layout === 'radial') {
+    width = 2 * Math.PI;
+    height = Math.min(layoutInfo.height, layoutInfo.width) / 2;
+    separation = sep(function (node1, node2) {
+      return (node1.parentNode === node2.parentNode ? 1 : 2) / node1.depth;
+    });
+  } else {
+    width = layoutInfo.width;
+    height = layoutInfo.height;
+    separation = sep();
+  }
+
+  var virtualRoot = seriesModel.getData().tree.root;
+  var realRoot = virtualRoot.children[0];
+
+  if (realRoot) {
+    init(virtualRoot);
+    eachAfter(realRoot, firstWalk, separation);
+    virtualRoot.hierNode.modifier = -realRoot.hierNode.prelim;
+    eachBefore(realRoot, secondWalk);
+    var left = realRoot;
+    var right = realRoot;
+    var bottom = realRoot;
+    eachBefore(realRoot, function (node) {
+      var x = node.getLayout().x;
+
+      if (x < left.getLayout().x) {
+        left = node;
+      }
+
+      if (x > right.getLayout().x) {
+        right = node;
+      }
+
+      if (node.depth > bottom.depth) {
+        bottom = node;
+      }
+    });
+    var delta = left === right ? 1 : separation(left, right) / 2;
+    var tx = delta - left.getLayout().x;
+    var kx = 0;
+    var ky = 0;
+    var coorX = 0;
+    var coorY = 0;
+
+    if (layout === 'radial') {
+      kx = width / (right.getLayout().x + delta + tx); // here we use (node.depth - 1), bucause the real root's depth is 1
+
+      ky = height / (bottom.depth - 1 || 1);
+      eachBefore(realRoot, function (node) {
+        coorX = (node.getLayout().x + tx) * kx;
+        coorY = (node.depth - 1) * ky;
+        var finalCoor = radialCoordinate(coorX, coorY);
+        node.setLayout({
+          x: finalCoor.x,
+          y: finalCoor.y,
+          rawX: coorX,
+          rawY: coorY
+        }, true);
+      });
+    } else {
+      var orient = seriesModel.getOrient();
+
+      if (orient === 'RL' || orient === 'LR') {
+        ky = height / (right.getLayout().x + delta + tx);
+        kx = width / (bottom.depth - 1 || 1);
+        eachBefore(realRoot, function (node) {
+          coorY = (node.getLayout().x + tx) * ky;
+          coorX = orient === 'LR' ? (node.depth - 1) * kx : width - (node.depth - 1) * kx;
+          node.setLayout({
+            x: coorX,
+            y: coorY
+          }, true);
+        });
+      } else if (orient === 'TB' || orient === 'BT') {
+        kx = width / (right.getLayout().x + delta + tx);
+        ky = height / (bottom.depth - 1 || 1);
+        eachBefore(realRoot, function (node) {
+          coorX = (node.getLayout().x + tx) * kx;
+          coorY = orient === 'TB' ? (node.depth - 1) * ky : height - (node.depth - 1) * ky;
+          node.setLayout({
+            x: coorX,
+            y: coorY
+          }, true);
+        });
+      }
+    }
+  }
+}
+
+module.exports = _default;