office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,584 @@
+import { __extends } from 'tslib';
+import { concatArray, defaults } from '../../../../zrender/lib/core/util.js';
+import '../../util/graphic.js';
+import { getECData } from '../../util/innerStore.js';
+import Symbol from '../helper/Symbol.js';
+import { radialCoordinate } from './layoutHelper.js';
+import { fromPoints } from '../../../../zrender/lib/core/bbox.js';
+import View from '../../coord/View.js';
+import { updateViewOnPan, updateViewOnZoom } from '../../component/helper/roamHelper.js';
+import RoamController from '../../component/helper/RoamController.js';
+import { onIrrelevantElement } from '../../component/helper/cursorHelper.js';
+import { parsePercent } from '../../util/number.js';
+import ChartView from '../../view/Chart.js';
+import Path from '../../../../zrender/lib/graphic/Path.js';
+import { HOVER_STATE_BLUR, setStatesFlag, setStatesStylesFromModel, setDefaultStateProxy } from '../../util/states.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+import { updateProps, removeElement } from '../../animation/basicTransition.js';
+import BezierCurve from '../../../../zrender/lib/graphic/shape/BezierCurve.js';
+
+var TreeEdgeShape = /** @class */function () {
+  function TreeEdgeShape() {
+    this.parentPoint = [];
+    this.childPoints = [];
+  }
+  return TreeEdgeShape;
+}();
+var TreePath = /** @class */function (_super) {
+  __extends(TreePath, _super);
+  function TreePath(opts) {
+    return _super.call(this, opts) || this;
+  }
+  TreePath.prototype.getDefaultStyle = function () {
+    return {
+      stroke: '#000',
+      fill: null
+    };
+  };
+  TreePath.prototype.getDefaultShape = function () {
+    return new TreeEdgeShape();
+  };
+  TreePath.prototype.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]);
+    }
+  };
+  return TreePath;
+}(Path);
+var TreeView = /** @class */function (_super) {
+  __extends(TreeView, _super);
+  function TreeView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = TreeView.type;
+    _this._mainGroup = new Group();
+    return _this;
+  }
+  TreeView.prototype.init = function (ecModel, api) {
+    this._controller = new RoamController(api.getZr());
+    this._controllerHost = {
+      target: this.group
+    };
+    this.group.add(this._mainGroup);
+  };
+  TreeView.prototype.render = function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    var layoutInfo = seriesModel.layoutInfo;
+    var group = this._mainGroup;
+    var layout = seriesModel.get('layout');
+    if (layout === 'radial') {
+      group.x = layoutInfo.x + layoutInfo.width / 2;
+      group.y = layoutInfo.y + layoutInfo.height / 2;
+    } else {
+      group.x = layoutInfo.x;
+      group.y = layoutInfo.y;
+    }
+    this._updateViewCoordSys(seriesModel, api);
+    this._updateController(seriesModel, ecModel, api);
+    var oldData = this._data;
+    data.diff(oldData).add(function (newIdx) {
+      if (symbolNeedsDraw(data, newIdx)) {
+        // Create node and edge
+        updateNode(data, newIdx, null, group, seriesModel);
+      }
+    }).update(function (newIdx, oldIdx) {
+      var symbolEl = oldData.getItemGraphicEl(oldIdx);
+      if (!symbolNeedsDraw(data, newIdx)) {
+        symbolEl && removeNode(oldData, oldIdx, symbolEl, group, seriesModel);
+        return;
+      }
+      // Update node and edge
+      updateNode(data, newIdx, symbolEl, group, seriesModel);
+    }).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);
+      }
+    }).execute();
+    this._nodeScaleRatio = seriesModel.get('nodeScaleRatio');
+    this._updateNodeAndLinkScale(seriesModel);
+    if (seriesModel.get('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;
+  };
+  TreeView.prototype._updateViewCoordSys = function (seriesModel, api) {
+    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 = [];
+    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'), api);
+    viewCoordSys.setZoom(seriesModel.get('zoom'));
+    // Here we use viewCoordSys just for computing the 'position' and 'scale' of the group
+    this.group.attr({
+      x: viewCoordSys.x,
+      y: viewCoordSys.y,
+      scaleX: viewCoordSys.scaleX,
+      scaleY: viewCoordSys.scaleY
+    });
+    this._min = min;
+    this._max = max;
+  };
+  TreeView.prototype._updateController = function (seriesModel, ecModel, api) {
+    var _this = this;
+    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) {
+      updateViewOnPan(controllerHost, e.dx, e.dy);
+      api.dispatchAction({
+        seriesId: seriesModel.id,
+        type: 'treeRoam',
+        dx: e.dx,
+        dy: e.dy
+      });
+    }).on('zoom', function (e) {
+      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);
+      // Only update label layout on zoom
+      api.updateLabelLayout();
+    });
+  };
+  TreeView.prototype._updateNodeAndLinkScale = function (seriesModel) {
+    var data = seriesModel.getData();
+    var nodeScale = this._getNodeGlobalScale(seriesModel);
+    data.eachItemGraphicEl(function (el, idx) {
+      el.setSymbolScale(nodeScale);
+    });
+  };
+  TreeView.prototype._getNodeGlobalScale = function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    if (coordSys.type !== 'view') {
+      return 1;
+    }
+    var nodeScaleRatio = this._nodeScaleRatio;
+    var groupZoom = coordSys.scaleX || 1;
+    // Scale node when zoom changes
+    var roamZoom = coordSys.getZoom();
+    var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+    return nodeScale / groupZoom;
+  };
+  TreeView.prototype.dispose = function () {
+    this._controller && this._controller.dispose();
+    this._controllerHost = null;
+  };
+  TreeView.prototype.remove = function () {
+    this._mainGroup.removeAll();
+    this._data = null;
+  };
+  TreeView.type = 'tree';
+  return TreeView;
+}(ChartView);
+function symbolNeedsDraw(data, dataIndex) {
+  var layout = data.getItemLayout(dataIndex);
+  return layout && !isNaN(layout.x) && !isNaN(layout.y);
+}
+function updateNode(data, dataIndex, symbolEl, group, seriesModel) {
+  var isInit = !symbolEl;
+  var node = data.tree.getNodeByDataIndex(dataIndex);
+  var itemModel = node.getModel();
+  var visualColor = node.getVisual('style').fill;
+  var symbolInnerColor = node.isExpand === false && node.children.length !== 0 ? visualColor : '#fff';
+  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.__oldX,
+    y: sourceSymbolEl.__oldY,
+    rawX: sourceSymbolEl.__radialOldRawX,
+    rawY: sourceSymbolEl.__radialOldRawY
+  } : sourceLayout;
+  var targetLayout = node.getLayout();
+  if (isInit) {
+    symbolEl = new Symbol(data, dataIndex, null, {
+      symbolInnerColor: symbolInnerColor,
+      useNameLabel: true
+    });
+    symbolEl.x = sourceOldLayout.x;
+    symbolEl.y = sourceOldLayout.y;
+  } else {
+    symbolEl.updateData(data, dataIndex, null, {
+      symbolInnerColor: symbolInnerColor,
+      useNameLabel: true
+    });
+  }
+  symbolEl.__radialOldRawX = symbolEl.__radialRawX;
+  symbolEl.__radialOldRawY = symbolEl.__radialRawY;
+  symbolEl.__radialRawX = targetLayout.rawX;
+  symbolEl.__radialRawY = targetLayout.rawY;
+  group.add(symbolEl);
+  data.setItemGraphicEl(dataIndex, symbolEl);
+  symbolEl.__oldX = symbolEl.x;
+  symbolEl.__oldY = symbolEl.y;
+  updateProps(symbolEl, {
+    x: targetLayout.x,
+    y: targetLayout.y
+  }, seriesModel);
+  var symbolPath = symbolEl.getSymbolPath();
+  if (seriesModel.get('layout') === 'radial') {
+    var realRoot = virtualRoot.children[0];
+    var rootLayout = realRoot.getLayout();
+    var length_1 = realRoot.children.length;
+    var rad = void 0;
+    var isLeft = void 0;
+    if (targetLayout.x === rootLayout.x && node.isExpand === true && realRoot.children.length) {
+      var center = {
+        x: (realRoot.children[0].getLayout().x + realRoot.children[length_1 - 1].getLayout().x) / 2,
+        y: (realRoot.children[0].getLayout().y + realRoot.children[length_1 - 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 normalLabelModel = itemModel.getModel('label');
+    var rotate = normalLabelModel.get('rotate');
+    var labelRotateRadian = rotate * (Math.PI / 180);
+    var textContent = symbolPath.getTextContent();
+    if (textContent) {
+      symbolPath.setTextConfig({
+        position: normalLabelModel.get('position') || textPosition,
+        rotation: rotate == null ? -rad : labelRotateRadian,
+        origin: 'center'
+      });
+      textContent.setStyle('verticalAlign', 'middle');
+    }
+  }
+  // Handle status
+  var focus = itemModel.get(['emphasis', 'focus']);
+  var focusDataIndices = focus === 'relative' ? concatArray(node.getAncestorsIndices(), node.getDescendantIndices()) : focus === 'ancestor' ? node.getAncestorsIndices() : focus === 'descendant' ? node.getDescendantIndices() : null;
+  if (focusDataIndices) {
+    // Modify the focus to data indices.
+    getECData(symbolEl).focus = focusDataIndices;
+  }
+  drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group);
+  if (symbolEl.__edge) {
+    symbolEl.onHoverStateChange = function (toState) {
+      if (toState !== 'blur') {
+        // NOTE: Ensure the parent elements will been blurred firstly.
+        // According to the return of getAncestorsIndices and getDescendantIndices
+        // TODO: A bit tricky.
+        var parentEl = node.parentNode && data.getItemGraphicEl(node.parentNode.dataIndex);
+        if (!(parentEl && parentEl.hoverState === HOVER_STATE_BLUR)) {
+          setStatesFlag(symbolEl.__edge, toState);
+        }
+      }
+    };
+  }
+}
+function drawEdge(seriesModel, node, virtualRoot, symbolEl, sourceOldLayout, sourceLayout, targetLayout, group) {
+  var itemModel = node.getModel();
+  var edgeShape = seriesModel.get('edgeShape');
+  var layout = seriesModel.get('layout');
+  var orient = seriesModel.getOrient();
+  var curvature = seriesModel.get(['lineStyle', 'curveness']);
+  var edgeForkPosition = seriesModel.get('edgeForkPosition');
+  var lineStyle = itemModel.getModel('lineStyle').getLineStyle();
+  var edge = symbolEl.__edge;
+  // curve edge from node -> parent
+  // polyline edge from node -> children
+  if (edgeShape === 'curve') {
+    if (node.parentNode && node.parentNode !== virtualRoot) {
+      if (!edge) {
+        edge = symbolEl.__edge = new BezierCurve({
+          shape: getEdgeShape(layout, orient, curvature, sourceOldLayout, sourceOldLayout)
+        });
+      }
+      updateProps(edge, {
+        shape: getEdgeShape(layout, orient, curvature, sourceLayout, targetLayout)
+      }, seriesModel);
+    }
+  } else if (edgeShape === 'polyline') {
+    if (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 TreePath({
+            shape: {
+              parentPoint: [targetLayout.x, targetLayout.y],
+              childPoints: [[targetLayout.x, targetLayout.y]],
+              orient: orient,
+              forkPosition: edgeForkPosition
+            }
+          });
+        }
+        updateProps(edge, {
+          shape: {
+            parentPoint: [targetLayout.x, targetLayout.y],
+            childPoints: childPoints
+          }
+        }, seriesModel);
+      }
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        throw new Error('The polyline edgeShape can only be used in orthogonal layout');
+      }
+    }
+  }
+  // show all edge when edgeShape is 'curve', filter node `isExpand` is false when edgeShape is 'polyline'
+  if (edge && !(edgeShape === 'polyline' && !node.isExpand)) {
+    edge.useStyle(defaults({
+      strokeNoScale: true,
+      fill: null
+    }, lineStyle));
+    setStatesStylesFromModel(edge, itemModel, 'lineStyle');
+    setDefaultStateProxy(edge);
+    group.add(edge);
+  }
+}
+function removeNodeEdge(node, data, group, seriesModel, removeAnimationOpt) {
+  var virtualRoot = data.tree.root;
+  var _a = getSourceNode(virtualRoot, node),
+    source = _a.source,
+    sourceLayout = _a.sourceLayout;
+  var symbolEl = data.getItemGraphicEl(node.dataIndex);
+  if (!symbolEl) {
+    return;
+  }
+  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 = seriesModel.get('edgeShape');
+  var layoutOpt = seriesModel.get('layout');
+  var orient = seriesModel.get('orient');
+  var curvature = seriesModel.get(['lineStyle', 'curveness']);
+  if (edge) {
+    if (edgeShape === 'curve') {
+      removeElement(edge, {
+        shape: getEdgeShape(layoutOpt, orient, curvature, sourceLayout, sourceLayout),
+        style: {
+          opacity: 0
+        }
+      }, seriesModel, {
+        cb: function () {
+          group.remove(edge);
+        },
+        removeOpt: removeAnimationOpt
+      });
+    } else if (edgeShape === 'polyline' && seriesModel.get('layout') === 'orthogonal') {
+      removeElement(edge, {
+        shape: {
+          parentPoint: [sourceLayout.x, sourceLayout.y],
+          childPoints: [[sourceLayout.x, sourceLayout.y]]
+        },
+        style: {
+          opacity: 0
+        }
+      }, seriesModel, {
+        cb: function () {
+          group.remove(edge);
+        },
+        removeOpt: removeAnimationOpt
+      });
+    }
+  }
+}
+function getSourceNode(virtualRoot, node) {
+  var source = node.parentNode === virtualRoot ? node : node.parentNode || node;
+  var sourceLayout;
+  while (sourceLayout = source.getLayout(), sourceLayout == null) {
+    source = source.parentNode === virtualRoot ? source : source.parentNode || source;
+  }
+  return {
+    source: source,
+    sourceLayout: sourceLayout
+  };
+}
+function removeNode(data, dataIndex, symbolEl, group, seriesModel) {
+  var node = data.tree.getNodeByDataIndex(dataIndex);
+  var virtualRoot = data.tree.root;
+  var sourceLayout = getSourceNode(virtualRoot, node).sourceLayout;
+  // Use same duration and easing with update to have more consistent animation.
+  var removeAnimationOpt = {
+    duration: seriesModel.get('animationDurationUpdate'),
+    easing: seriesModel.get('animationEasingUpdate')
+  };
+  removeElement(symbolEl, {
+    x: sourceLayout.x + 1,
+    y: sourceLayout.y + 1
+  }, seriesModel, {
+    cb: function () {
+      group.remove(symbolEl);
+      data.setItemGraphicEl(dataIndex, null);
+    },
+    removeOpt: removeAnimationOpt
+  });
+  symbolEl.fadeOut(null, data.hostModel, {
+    fadeLabel: true,
+    animation: removeAnimationOpt
+  });
+  // remove edge as parent node
+  node.children.forEach(function (childNode) {
+    removeNodeEdge(childNode, data, group, seriesModel, removeAnimationOpt);
+  });
+  // remove edge as child node
+  removeNodeEdge(node, data, group, seriesModel, removeAnimationOpt);
+}
+function getEdgeShape(layoutOpt, orient, curvature, sourceLayout, targetLayout) {
+  var cpx1;
+  var cpy1;
+  var cpx2;
+  var cpy2;
+  var x1;
+  var x2;
+  var y1;
+  var y2;
+  if (layoutOpt === '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) * curvature);
+    var radialCoor3 = radialCoordinate(x2, y2 + (y1 - y2) * curvature);
+    var radialCoor4 = radialCoordinate(x2, y2);
+    return {
+      x1: radialCoor1.x || 0,
+      y1: radialCoor1.y || 0,
+      x2: radialCoor4.x || 0,
+      y2: radialCoor4.y || 0,
+      cpx1: radialCoor2.x || 0,
+      cpy1: radialCoor2.y || 0,
+      cpx2: radialCoor3.x || 0,
+      cpy2: radialCoor3.y || 0
+    };
+  } else {
+    x1 = sourceLayout.x;
+    y1 = sourceLayout.y;
+    x2 = targetLayout.x;
+    y2 = targetLayout.y;
+    if (orient === 'LR' || orient === 'RL') {
+      cpx1 = x1 + (x2 - x1) * curvature;
+      cpy1 = y1;
+      cpx2 = x2 + (x1 - x2) * curvature;
+      cpy2 = y2;
+    }
+    if (orient === 'TB' || orient === 'BT') {
+      cpx1 = x1;
+      cpy1 = y1 + (y2 - y1) * curvature;
+      cpx2 = x2;
+      cpy2 = y2 + (y1 - y2) * curvature;
+    }
+  }
+  return {
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    cpx1: cpx1,
+    cpy1: cpy1,
+    cpx2: cpx2,
+    cpy2: cpy2
+  };
+}
+
+export { TreeView as default };

package/esm/node_modules/echarts/lib/chart/tree/install.js

@@ -0,0 +1,15 @@
+import TreeView from './TreeView.js';
+import TreeSeriesModel from './TreeSeries.js';
+import treeLayout from './treeLayout.js';
+import treeVisual from './treeVisual.js';
+import { installTreeAction } from './treeAction.js';
+
+function install(registers) {
+  registers.registerChartView(TreeView);
+  registers.registerSeriesModel(TreeSeriesModel);
+  registers.registerLayout(treeLayout);
+  registers.registerVisual(treeVisual);
+  installTreeAction(registers);
+}
+
+export { install };