office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/chart/sunburst/SunburstPiece.js

@@ -0,0 +1,195 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+require('../../util/graphic.js');
+var states = require('../../util/states.js');
+var labelStyle = require('../../label/labelStyle.js');
+var innerStore = require('../../util/innerStore.js');
+var sectorHelper = require('../helper/sectorHelper.js');
+var decal = require('../../util/decal.js');
+var basicTransition = require('../../animation/basicTransition.js');
+var util$1 = require('../../../../zrender/lib/contain/util.js');
+var number = require('../../util/number.js');
+var Text = require('../../../../zrender/lib/graphic/Text.js');
+var Sector = require('../../../../zrender/lib/graphic/shape/Sector.js');
+
+var DEFAULT_SECTOR_Z = 2;
+var DEFAULT_TEXT_Z = 4;
+/**
+ * Sunburstce of Sunburst including Sector, Label, LabelLine
+ */
+var SunburstPiece = /** @class */function (_super) {
+  tslib.__extends(SunburstPiece, _super);
+  function SunburstPiece(node, seriesModel, ecModel, api) {
+    var _this = _super.call(this) || this;
+    _this.z2 = DEFAULT_SECTOR_Z;
+    _this.textConfig = {
+      inside: true
+    };
+    innerStore.getECData(_this).seriesIndex = seriesModel.seriesIndex;
+    var text = new Text["default"]({
+      z2: DEFAULT_TEXT_Z,
+      silent: node.getModel().get(['label', 'silent'])
+    });
+    _this.setTextContent(text);
+    _this.updateData(true, node, seriesModel, ecModel, api);
+    return _this;
+  }
+  SunburstPiece.prototype.updateData = function (firstCreate, node,
+  // state: 'emphasis' | 'normal' | 'highlight' | 'downplay',
+  seriesModel, ecModel, api) {
+    this.node = node;
+    node.piece = this;
+    seriesModel = seriesModel || this._seriesModel;
+    ecModel = ecModel || this._ecModel;
+    var sector = this;
+    innerStore.getECData(sector).dataIndex = node.dataIndex;
+    var itemModel = node.getModel();
+    var emphasisModel = itemModel.getModel('emphasis');
+    var layout = node.getLayout();
+    var sectorShape = util.extend({}, layout);
+    sectorShape.label = null;
+    var normalStyle = node.getVisual('style');
+    normalStyle.lineJoin = 'bevel';
+    var decal$1 = node.getVisual('decal');
+    if (decal$1) {
+      normalStyle.decal = decal.createOrUpdatePatternFromDecal(decal$1, api);
+    }
+    var cornerRadius = sectorHelper.getSectorCornerRadius(itemModel.getModel('itemStyle'), sectorShape, true);
+    util.extend(sectorShape, cornerRadius);
+    util.each(states.SPECIAL_STATES, function (stateName) {
+      var state = sector.ensureState(stateName);
+      var itemStyleModel = itemModel.getModel([stateName, 'itemStyle']);
+      state.style = itemStyleModel.getItemStyle();
+      // border radius
+      var cornerRadius = sectorHelper.getSectorCornerRadius(itemStyleModel, sectorShape);
+      if (cornerRadius) {
+        state.shape = cornerRadius;
+      }
+    });
+    if (firstCreate) {
+      sector.setShape(sectorShape);
+      sector.shape.r = layout.r0;
+      basicTransition.initProps(sector, {
+        shape: {
+          r: layout.r
+        }
+      }, seriesModel, node.dataIndex);
+    } else {
+      // Disable animation for gradient since no interpolation method
+      // is supported for gradient
+      basicTransition.updateProps(sector, {
+        shape: sectorShape
+      }, seriesModel);
+      basicTransition.saveOldStyle(sector);
+    }
+    sector.useStyle(normalStyle);
+    this._updateLabel(seriesModel);
+    var cursorStyle = itemModel.getShallow('cursor');
+    cursorStyle && sector.attr('cursor', cursorStyle);
+    this._seriesModel = seriesModel || this._seriesModel;
+    this._ecModel = ecModel || this._ecModel;
+    var focus = emphasisModel.get('focus');
+    var focusOrIndices = focus === 'ancestor' ? node.getAncestorsIndices() : focus === 'descendant' ? node.getDescendantIndices() : focus;
+    states.toggleHoverEmphasis(this, focusOrIndices, emphasisModel.get('blurScope'), emphasisModel.get('disabled'));
+  };
+  SunburstPiece.prototype._updateLabel = function (seriesModel) {
+    var _this = this;
+    var itemModel = this.node.getModel();
+    var normalLabelModel = itemModel.getModel('label');
+    var layout = this.node.getLayout();
+    var angle = layout.endAngle - layout.startAngle;
+    var midAngle = (layout.startAngle + layout.endAngle) / 2;
+    var dx = Math.cos(midAngle);
+    var dy = Math.sin(midAngle);
+    var sector = this;
+    var label = sector.getTextContent();
+    var dataIndex = this.node.dataIndex;
+    var labelMinAngle = normalLabelModel.get('minAngle') / 180 * Math.PI;
+    var isNormalShown = normalLabelModel.get('show') && !(labelMinAngle != null && Math.abs(angle) < labelMinAngle);
+    label.ignore = !isNormalShown;
+    // TODO use setLabelStyle
+    util.each(states.DISPLAY_STATES, function (stateName) {
+      var labelStateModel = stateName === 'normal' ? itemModel.getModel('label') : itemModel.getModel([stateName, 'label']);
+      var isNormal = stateName === 'normal';
+      var state = isNormal ? label : label.ensureState(stateName);
+      var text = seriesModel.getFormattedLabel(dataIndex, stateName);
+      if (isNormal) {
+        text = text || _this.node.name;
+      }
+      state.style = labelStyle.createTextStyle(labelStateModel, {}, null, stateName !== 'normal', true);
+      if (text) {
+        state.style.text = text;
+      }
+      // Not displaying text when angle is too small
+      var isShown = labelStateModel.get('show');
+      if (isShown != null && !isNormal) {
+        state.ignore = !isShown;
+      }
+      var labelPosition = getLabelAttr(labelStateModel, 'position');
+      var sectorState = isNormal ? sector : sector.states[stateName];
+      var labelColor = sectorState.style.fill;
+      sectorState.textConfig = {
+        outsideFill: labelStateModel.get('color') === 'inherit' ? labelColor : null,
+        inside: labelPosition !== 'outside'
+      };
+      var r;
+      var labelPadding = getLabelAttr(labelStateModel, 'distance') || 0;
+      var textAlign = getLabelAttr(labelStateModel, 'align');
+      var rotateType = getLabelAttr(labelStateModel, 'rotate');
+      var flipStartAngle = Math.PI * 0.5;
+      var flipEndAngle = Math.PI * 1.5;
+      var midAngleNormal = util$1.normalizeRadian(rotateType === 'tangential' ? Math.PI / 2 - midAngle : midAngle);
+      // For text that is up-side down, rotate 180 degrees to make sure
+      // it's readable
+      var needsFlip = midAngleNormal > flipStartAngle && !number.isRadianAroundZero(midAngleNormal - flipStartAngle) && midAngleNormal < flipEndAngle;
+      if (labelPosition === 'outside') {
+        r = layout.r + labelPadding;
+        textAlign = needsFlip ? 'right' : 'left';
+      } else {
+        if (!textAlign || textAlign === 'center') {
+          // Put label in the center if it's a circle
+          if (angle === 2 * Math.PI && layout.r0 === 0) {
+            r = 0;
+          } else {
+            r = (layout.r + layout.r0) / 2;
+          }
+          textAlign = 'center';
+        } else if (textAlign === 'left') {
+          r = layout.r0 + labelPadding;
+          textAlign = needsFlip ? 'right' : 'left';
+        } else if (textAlign === 'right') {
+          r = layout.r - labelPadding;
+          textAlign = needsFlip ? 'left' : 'right';
+        }
+      }
+      state.style.align = textAlign;
+      state.style.verticalAlign = getLabelAttr(labelStateModel, 'verticalAlign') || 'middle';
+      state.x = r * dx + layout.cx;
+      state.y = r * dy + layout.cy;
+      var rotate = 0;
+      if (rotateType === 'radial') {
+        rotate = util$1.normalizeRadian(-midAngle) + (needsFlip ? Math.PI : 0);
+      } else if (rotateType === 'tangential') {
+        rotate = util$1.normalizeRadian(Math.PI / 2 - midAngle) + (needsFlip ? Math.PI : 0);
+      } else if (util.isNumber(rotateType)) {
+        rotate = rotateType * Math.PI / 180;
+      }
+      state.rotation = util$1.normalizeRadian(rotate);
+    });
+    function getLabelAttr(model, name) {
+      var stateAttr = model.get(name);
+      if (stateAttr == null) {
+        return normalLabelModel.get(name);
+      }
+      return stateAttr;
+    }
+    label.dirtyStyle();
+  };
+  return SunburstPiece;
+}(Sector["default"]);
+
+exports["default"] = SunburstPiece;

package/lib/node_modules/echarts/lib/chart/sunburst/SunburstSeries.js

@@ -0,0 +1,169 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var Series = require('../../model/Series.js');
+var Tree = require('../../data/Tree.js');
+var treeHelper = require('../helper/treeHelper.js');
+var Model = require('../../model/Model.js');
+var enableAriaDecalForTree = require('../helper/enableAriaDecalForTree.js');
+
+var SunburstSeriesModel = /** @class */function (_super) {
+  tslib.__extends(SunburstSeriesModel, _super);
+  function SunburstSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = SunburstSeriesModel.type;
+    _this.ignoreStyleOnData = true;
+    return _this;
+  }
+  SunburstSeriesModel.prototype.getInitialData = function (option, ecModel) {
+    // Create a virtual root.
+    var root = {
+      name: option.name,
+      children: option.data
+    };
+    completeTreeValue(root);
+    var levelModels = this._levelModels = util.map(option.levels || [], function (levelDefine) {
+      return new Model["default"](levelDefine, this, ecModel);
+    }, this);
+    // Make sure always a new tree is created when setOption,
+    // in TreemapView, we check whether oldTree === newTree
+    // to choose mappings approach among old shapes and new shapes.
+    var tree = Tree["default"].createTree(root, this, beforeLink);
+    function beforeLink(nodeData) {
+      nodeData.wrapMethod('getItemModel', function (model, idx) {
+        var node = tree.getNodeByDataIndex(idx);
+        var levelModel = levelModels[node.depth];
+        levelModel && (model.parentModel = levelModel);
+        return model;
+      });
+    }
+    return tree.data;
+  };
+  SunburstSeriesModel.prototype.optionUpdated = function () {
+    this.resetViewRoot();
+  };
+  /*
+   * @override
+   */
+  SunburstSeriesModel.prototype.getDataParams = function (dataIndex) {
+    var params = _super.prototype.getDataParams.apply(this, arguments);
+    var node = this.getData().tree.getNodeByDataIndex(dataIndex);
+    params.treePathInfo = treeHelper.wrapTreePathInfo(node, this);
+    return params;
+  };
+  SunburstSeriesModel.prototype.getLevelModel = function (node) {
+    return this._levelModels && this._levelModels[node.depth];
+  };
+  SunburstSeriesModel.prototype.getViewRoot = function () {
+    return this._viewRoot;
+  };
+  SunburstSeriesModel.prototype.resetViewRoot = function (viewRoot) {
+    viewRoot ? this._viewRoot = viewRoot : viewRoot = this._viewRoot;
+    var root = this.getRawData().tree.root;
+    if (!viewRoot || viewRoot !== root && !root.contains(viewRoot)) {
+      this._viewRoot = root;
+    }
+  };
+  SunburstSeriesModel.prototype.enableAriaDecal = function () {
+    enableAriaDecalForTree["default"](this);
+  };
+  SunburstSeriesModel.type = 'series.sunburst';
+  SunburstSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    // 默认全局居中
+    center: ['50%', '50%'],
+    radius: [0, '75%'],
+    // 默认顺时针
+    clockwise: true,
+    startAngle: 90,
+    // 最小角度改为0
+    minAngle: 0,
+    // If still show when all data zero.
+    stillShowZeroSum: true,
+    // 'rootToNode', 'link', or false
+    nodeClick: 'rootToNode',
+    renderLabelForZeroData: false,
+    label: {
+      // could be: 'radial', 'tangential', or 'none'
+      rotate: 'radial',
+      show: true,
+      opacity: 1,
+      // 'left' is for inner side of inside, and 'right' is for outer
+      // side for inside
+      align: 'center',
+      position: 'inside',
+      distance: 5,
+      silent: true
+    },
+    itemStyle: {
+      borderWidth: 1,
+      borderColor: 'white',
+      borderType: 'solid',
+      shadowBlur: 0,
+      shadowColor: 'rgba(0, 0, 0, 0.2)',
+      shadowOffsetX: 0,
+      shadowOffsetY: 0,
+      opacity: 1
+    },
+    emphasis: {
+      focus: 'descendant'
+    },
+    blur: {
+      itemStyle: {
+        opacity: 0.2
+      },
+      label: {
+        opacity: 0.1
+      }
+    },
+    // Animation type can be expansion, scale.
+    animationType: 'expansion',
+    animationDuration: 1000,
+    animationDurationUpdate: 500,
+    data: [],
+    /**
+     * Sort order.
+     *
+     * Valid values: 'desc', 'asc', null, or callback function.
+     * 'desc' and 'asc' for descend and ascendant order;
+     * null for not sorting;
+     * example of callback function:
+     * function(nodeA, nodeB) {
+     *     return nodeA.getValue() - nodeB.getValue();
+     * }
+     */
+    sort: 'desc'
+  };
+  return SunburstSeriesModel;
+}(Series["default"]);
+function completeTreeValue(dataNode) {
+  // Postorder travel tree.
+  // If value of none-leaf node is not set,
+  // calculate it by suming up the value of all children.
+  var sum = 0;
+  util.each(dataNode.children, function (child) {
+    completeTreeValue(child);
+    var childValue = child.value;
+    // TODO First value of array must be a number
+    util.isArray(childValue) && (childValue = childValue[0]);
+    sum += childValue;
+  });
+  var thisValue = dataNode.value;
+  if (util.isArray(thisValue)) {
+    thisValue = thisValue[0];
+  }
+  if (thisValue == null || isNaN(thisValue)) {
+    thisValue = sum;
+  }
+  // Value should not less than 0.
+  if (thisValue < 0) {
+    thisValue = 0;
+  }
+  util.isArray(dataNode.value) ? dataNode.value[0] = thisValue : dataNode.value = thisValue;
+}
+
+exports["default"] = SunburstSeriesModel;

package/lib/node_modules/echarts/lib/chart/sunburst/SunburstView.js

@@ -0,0 +1,169 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var Chart = require('../../view/Chart.js');
+var SunburstPiece = require('./SunburstPiece.js');
+var DataDiffer = require('../../data/DataDiffer.js');
+var sunburstAction = require('./sunburstAction.js');
+var format = require('../../util/format.js');
+
+var SunburstView = /** @class */function (_super) {
+  tslib.__extends(SunburstView, _super);
+  function SunburstView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = SunburstView.type;
+    return _this;
+  }
+  SunburstView.prototype.render = function (seriesModel, ecModel, api,
+  // @ts-ignore
+  payload) {
+    var self = this;
+    this.seriesModel = seriesModel;
+    this.api = api;
+    this.ecModel = ecModel;
+    var data = seriesModel.getData();
+    var virtualRoot = data.tree.root;
+    var newRoot = seriesModel.getViewRoot();
+    var group = this.group;
+    var renderLabelForZeroData = seriesModel.get('renderLabelForZeroData');
+    var newChildren = [];
+    newRoot.eachNode(function (node) {
+      newChildren.push(node);
+    });
+    var oldChildren = this._oldChildren || [];
+    dualTravel(newChildren, oldChildren);
+    renderRollUp(virtualRoot, newRoot);
+    this._initEvents();
+    this._oldChildren = newChildren;
+    function dualTravel(newChildren, oldChildren) {
+      if (newChildren.length === 0 && oldChildren.length === 0) {
+        return;
+      }
+      new DataDiffer["default"](oldChildren, newChildren, getKey, getKey).add(processNode).update(processNode).remove(util.curry(processNode, null)).execute();
+      function getKey(node) {
+        return node.getId();
+      }
+      function processNode(newIdx, oldIdx) {
+        var newNode = newIdx == null ? null : newChildren[newIdx];
+        var oldNode = oldIdx == null ? null : oldChildren[oldIdx];
+        doRenderNode(newNode, oldNode);
+      }
+    }
+    function doRenderNode(newNode, oldNode) {
+      if (!renderLabelForZeroData && newNode && !newNode.getValue()) {
+        // Not render data with value 0
+        newNode = null;
+      }
+      if (newNode !== virtualRoot && oldNode !== virtualRoot) {
+        if (oldNode && oldNode.piece) {
+          if (newNode) {
+            // Update
+            oldNode.piece.updateData(false, newNode, seriesModel, ecModel, api);
+            // For tooltip
+            data.setItemGraphicEl(newNode.dataIndex, oldNode.piece);
+          } else {
+            // Remove
+            removeNode(oldNode);
+          }
+        } else if (newNode) {
+          // Add
+          var piece = new SunburstPiece["default"](newNode, seriesModel, ecModel, api);
+          group.add(piece);
+          // For tooltip
+          data.setItemGraphicEl(newNode.dataIndex, piece);
+        }
+      }
+    }
+    function removeNode(node) {
+      if (!node) {
+        return;
+      }
+      if (node.piece) {
+        group.remove(node.piece);
+        node.piece = null;
+      }
+    }
+    function renderRollUp(virtualRoot, viewRoot) {
+      if (viewRoot.depth > 0) {
+        // Render
+        if (self.virtualPiece) {
+          // Update
+          self.virtualPiece.updateData(false, virtualRoot, seriesModel, ecModel, api);
+        } else {
+          // Add
+          self.virtualPiece = new SunburstPiece["default"](virtualRoot, seriesModel, ecModel, api);
+          group.add(self.virtualPiece);
+        }
+        // TODO event scope
+        viewRoot.piece.off('click');
+        self.virtualPiece.on('click', function (e) {
+          self._rootToNode(viewRoot.parentNode);
+        });
+      } else if (self.virtualPiece) {
+        // Remove
+        group.remove(self.virtualPiece);
+        self.virtualPiece = null;
+      }
+    }
+  };
+  /**
+   * @private
+   */
+  SunburstView.prototype._initEvents = function () {
+    var _this = this;
+    this.group.off('click');
+    this.group.on('click', function (e) {
+      var targetFound = false;
+      var viewRoot = _this.seriesModel.getViewRoot();
+      viewRoot.eachNode(function (node) {
+        if (!targetFound && node.piece && node.piece === e.target) {
+          var nodeClick = node.getModel().get('nodeClick');
+          if (nodeClick === 'rootToNode') {
+            _this._rootToNode(node);
+          } else if (nodeClick === 'link') {
+            var itemModel = node.getModel();
+            var link = itemModel.get('link');
+            if (link) {
+              var linkTarget = itemModel.get('target', true) || '_blank';
+              format.windowOpen(link, linkTarget);
+            }
+          }
+          targetFound = true;
+        }
+      });
+    });
+  };
+  /**
+   * @private
+   */
+  SunburstView.prototype._rootToNode = function (node) {
+    if (node !== this.seriesModel.getViewRoot()) {
+      this.api.dispatchAction({
+        type: sunburstAction.ROOT_TO_NODE_ACTION,
+        from: this.uid,
+        seriesId: this.seriesModel.id,
+        targetNode: node
+      });
+    }
+  };
+  /**
+   * @implement
+   */
+  SunburstView.prototype.containPoint = function (point, seriesModel) {
+    var treeRoot = seriesModel.getData();
+    var itemLayout = treeRoot.getItemLayout(0);
+    if (itemLayout) {
+      var dx = point[0] - itemLayout.cx;
+      var dy = point[1] - itemLayout.cy;
+      var radius = Math.sqrt(dx * dx + dy * dy);
+      return radius <= itemLayout.r && radius >= itemLayout.r0;
+    }
+  };
+  SunburstView.type = 'sunburst';
+  return SunburstView;
+}(Chart["default"]);
+
+exports["default"] = SunburstView;

package/lib/node_modules/echarts/lib/chart/sunburst/install.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SunburstView = require('./SunburstView.js');
+var SunburstSeries = require('./SunburstSeries.js');
+var sunburstLayout = require('./sunburstLayout.js');
+var sunburstVisual = require('./sunburstVisual.js');
+var dataFilter = require('../../processor/dataFilter.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var sunburstAction = require('./sunburstAction.js');
+
+function install(registers) {
+  registers.registerChartView(SunburstView["default"]);
+  registers.registerSeriesModel(SunburstSeries["default"]);
+  registers.registerLayout(util.curry(sunburstLayout["default"], 'sunburst'));
+  registers.registerProcessor(util.curry(dataFilter["default"], 'sunburst'));
+  registers.registerVisual(sunburstVisual["default"]);
+  sunburstAction.installSunburstAction(registers);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/chart/sunburst/sunburstAction.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var log = require('../../util/log.js');
+var treeHelper = require('../helper/treeHelper.js');
+
+var ROOT_TO_NODE_ACTION = 'sunburstRootToNode';
+var HIGHLIGHT_ACTION = 'sunburstHighlight';
+var UNHIGHLIGHT_ACTION = 'sunburstUnhighlight';
+function installSunburstAction(registers) {
+  registers.registerAction({
+    type: ROOT_TO_NODE_ACTION,
+    update: 'updateView'
+  }, function (payload, ecModel) {
+    ecModel.eachComponent({
+      mainType: 'series',
+      subType: 'sunburst',
+      query: payload
+    }, handleRootToNode);
+    function handleRootToNode(model, index) {
+      var targetInfo = treeHelper.retrieveTargetInfo(payload, [ROOT_TO_NODE_ACTION], model);
+      if (targetInfo) {
+        var originViewRoot = model.getViewRoot();
+        if (originViewRoot) {
+          payload.direction = treeHelper.aboveViewRoot(originViewRoot, targetInfo.node) ? 'rollUp' : 'drillDown';
+        }
+        model.resetViewRoot(targetInfo.node);
+      }
+    }
+  });
+  registers.registerAction({
+    type: HIGHLIGHT_ACTION,
+    update: 'none'
+  }, function (payload, ecModel, api) {
+    // Clone
+    payload = util.extend({}, payload);
+    ecModel.eachComponent({
+      mainType: 'series',
+      subType: 'sunburst',
+      query: payload
+    }, handleHighlight);
+    function handleHighlight(model) {
+      var targetInfo = treeHelper.retrieveTargetInfo(payload, [HIGHLIGHT_ACTION], model);
+      if (targetInfo) {
+        payload.dataIndex = targetInfo.node.dataIndex;
+      }
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      log.deprecateReplaceLog('sunburstHighlight', 'highlight');
+    }
+    // Fast forward action
+    api.dispatchAction(util.extend(payload, {
+      type: 'highlight'
+    }));
+  });
+  registers.registerAction({
+    type: UNHIGHLIGHT_ACTION,
+    update: 'updateView'
+  }, function (payload, ecModel, api) {
+    payload = util.extend({}, payload);
+    if (process.env.NODE_ENV !== 'production') {
+      log.deprecateReplaceLog('sunburstUnhighlight', 'downplay');
+    }
+    api.dispatchAction(util.extend(payload, {
+      type: 'downplay'
+    }));
+  });
+}
+
+exports.ROOT_TO_NODE_ACTION = ROOT_TO_NODE_ACTION;
+exports.installSunburstAction = installSunburstAction;