office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/component/marker/MarkerView.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Component = require('../../view/Component.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var MarkerModel = require('./MarkerModel.js');
+var model = require('../../util/model.js');
+var states = require('../../util/states.js');
+
+var inner = model.makeInner();
+var MarkerView = /** @class */function (_super) {
+  tslib.__extends(MarkerView, _super);
+  function MarkerView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkerView.type;
+    return _this;
+  }
+  MarkerView.prototype.init = function () {
+    this.markerGroupMap = util.createHashMap();
+  };
+  MarkerView.prototype.render = function (markerModel, ecModel, api) {
+    var _this = this;
+    var markerGroupMap = this.markerGroupMap;
+    markerGroupMap.each(function (item) {
+      inner(item).keep = false;
+    });
+    ecModel.eachSeries(function (seriesModel) {
+      var markerModel = MarkerModel["default"].getMarkerModelFromSeries(seriesModel, _this.type);
+      markerModel && _this.renderSeries(seriesModel, markerModel, ecModel, api);
+    });
+    markerGroupMap.each(function (item) {
+      !inner(item).keep && _this.group.remove(item.group);
+    });
+  };
+  MarkerView.prototype.markKeep = function (drawGroup) {
+    inner(drawGroup).keep = true;
+  };
+  MarkerView.prototype.toggleBlurSeries = function (seriesModelList, isBlur) {
+    var _this = this;
+    util.each(seriesModelList, function (seriesModel) {
+      var markerModel = MarkerModel["default"].getMarkerModelFromSeries(seriesModel, _this.type);
+      if (markerModel) {
+        var data = markerModel.getData();
+        data.eachItemGraphicEl(function (el) {
+          if (el) {
+            isBlur ? states.enterBlur(el) : states.leaveBlur(el);
+          }
+        });
+      }
+    });
+  };
+  MarkerView.type = 'marker';
+  return MarkerView;
+}(Component["default"]);
+
+exports["default"] = MarkerView;

package/lib/node_modules/echarts/lib/component/marker/checkMarkerInSeries.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+
+function checkMarkerInSeries(seriesOpts, markerType) {
+  if (!seriesOpts) {
+    return false;
+  }
+  var seriesOptArr = util.isArray(seriesOpts) ? seriesOpts : [seriesOpts];
+  for (var idx = 0; idx < seriesOptArr.length; idx++) {
+    if (seriesOptArr[idx] && seriesOptArr[idx][markerType]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+exports["default"] = checkMarkerInSeries;

package/lib/node_modules/echarts/lib/component/marker/installMarkArea.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var checkMarkerInSeries = require('./checkMarkerInSeries.js');
+var MarkAreaModel = require('./MarkAreaModel.js');
+var MarkAreaView = require('./MarkAreaView.js');
+
+function install(registers) {
+  registers.registerComponentModel(MarkAreaModel["default"]);
+  registers.registerComponentView(MarkAreaView["default"]);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries["default"](opt.series, 'markArea')) {
+      // Make sure markArea component is enabled
+      opt.markArea = opt.markArea || {};
+    }
+  });
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/marker/installMarkLine.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var checkMarkerInSeries = require('./checkMarkerInSeries.js');
+var MarkLineModel = require('./MarkLineModel.js');
+var MarkLineView = require('./MarkLineView.js');
+
+function install(registers) {
+  registers.registerComponentModel(MarkLineModel["default"]);
+  registers.registerComponentView(MarkLineView["default"]);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries["default"](opt.series, 'markLine')) {
+      // Make sure markLine component is enabled
+      opt.markLine = opt.markLine || {};
+    }
+  });
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/marker/installMarkPoint.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var checkMarkerInSeries = require('./checkMarkerInSeries.js');
+var MarkPointModel = require('./MarkPointModel.js');
+var MarkPointView = require('./MarkPointView.js');
+
+function install(registers) {
+  registers.registerComponentModel(MarkPointModel["default"]);
+  registers.registerComponentView(MarkPointView["default"]);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries["default"](opt.series, 'markPoint')) {
+      // Make sure markPoint component is enabled
+      opt.markPoint = opt.markPoint || {};
+    }
+  });
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/marker/markerHelper.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var number = require('../../util/number.js');
+var dataStackHelper = require('../../data/helper/dataStackHelper.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var dataValueHelper = require('../../data/helper/dataValueHelper.js');
+
+function hasXOrY(item) {
+  return !(isNaN(parseFloat(item.x)) && isNaN(parseFloat(item.y)));
+}
+function hasXAndY(item) {
+  return !isNaN(parseFloat(item.x)) && !isNaN(parseFloat(item.y));
+}
+function markerTypeCalculatorWithExtent(markerType, data, otherDataDim, targetDataDim, otherCoordIndex, targetCoordIndex) {
+  var coordArr = [];
+  var stacked = dataStackHelper.isDimensionStacked(data, targetDataDim /* , otherDataDim */);
+  var calcDataDim = stacked ? data.getCalculationInfo('stackResultDimension') : targetDataDim;
+  var value = numCalculate(data, calcDataDim, markerType);
+  var dataIndex = data.indicesOfNearest(calcDataDim, value)[0];
+  coordArr[otherCoordIndex] = data.get(otherDataDim, dataIndex);
+  coordArr[targetCoordIndex] = data.get(calcDataDim, dataIndex);
+  var coordArrValue = data.get(targetDataDim, dataIndex);
+  // Make it simple, do not visit all stacked value to count precision.
+  var precision = number.getPrecision(data.get(targetDataDim, dataIndex));
+  precision = Math.min(precision, 20);
+  if (precision >= 0) {
+    coordArr[targetCoordIndex] = +coordArr[targetCoordIndex].toFixed(precision);
+  }
+  return [coordArr, coordArrValue];
+}
+// TODO Specified percent
+var markerTypeCalculator = {
+  min: util.curry(markerTypeCalculatorWithExtent, 'min'),
+  max: util.curry(markerTypeCalculatorWithExtent, 'max'),
+  average: util.curry(markerTypeCalculatorWithExtent, 'average'),
+  median: util.curry(markerTypeCalculatorWithExtent, 'median')
+};
+/**
+ * Transform markPoint data item to format used in List by do the following
+ * 1. Calculate statistic like `max`, `min`, `average`
+ * 2. Convert `item.xAxis`, `item.yAxis` to `item.coord` array
+ */
+function dataTransform(seriesModel, item) {
+  if (!item) {
+    return;
+  }
+  var data = seriesModel.getData();
+  var coordSys = seriesModel.coordinateSystem;
+  var dims = coordSys && coordSys.dimensions;
+  // 1. If not specify the position with pixel directly
+  // 2. If `coord` is not a data array. Which uses `xAxis`,
+  // `yAxis` to specify the coord on each dimension
+  // parseFloat first because item.x and item.y can be percent string like '20%'
+  if (!hasXAndY(item) && !util.isArray(item.coord) && util.isArray(dims)) {
+    var axisInfo = getAxisInfo(item, data, coordSys, seriesModel);
+    // Clone the option
+    // Transform the properties xAxis, yAxis, radiusAxis, angleAxis, geoCoord to value
+    item = util.clone(item);
+    if (item.type && markerTypeCalculator[item.type] && axisInfo.baseAxis && axisInfo.valueAxis) {
+      var otherCoordIndex = util.indexOf(dims, axisInfo.baseAxis.dim);
+      var targetCoordIndex = util.indexOf(dims, axisInfo.valueAxis.dim);
+      var coordInfo = markerTypeCalculator[item.type](data, axisInfo.baseDataDim, axisInfo.valueDataDim, otherCoordIndex, targetCoordIndex);
+      item.coord = coordInfo[0];
+      // Force to use the value of calculated value.
+      // let item use the value without stack.
+      item.value = coordInfo[1];
+    } else {
+      // FIXME Only has one of xAxis and yAxis.
+      item.coord = [item.xAxis != null ? item.xAxis : item.radiusAxis, item.yAxis != null ? item.yAxis : item.angleAxis];
+    }
+  }
+  // x y is provided
+  if (item.coord == null || !util.isArray(dims)) {
+    item.coord = [];
+  } else {
+    // Each coord support max, min, average
+    var coord = item.coord;
+    for (var i = 0; i < 2; i++) {
+      if (markerTypeCalculator[coord[i]]) {
+        coord[i] = numCalculate(data, data.mapDimension(dims[i]), coord[i]);
+      }
+    }
+  }
+  return item;
+}
+function getAxisInfo(item, data, coordSys, seriesModel) {
+  var ret = {};
+  if (item.valueIndex != null || item.valueDim != null) {
+    ret.valueDataDim = item.valueIndex != null ? data.getDimension(item.valueIndex) : item.valueDim;
+    ret.valueAxis = coordSys.getAxis(dataDimToCoordDim(seriesModel, ret.valueDataDim));
+    ret.baseAxis = coordSys.getOtherAxis(ret.valueAxis);
+    ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+  } else {
+    ret.baseAxis = seriesModel.getBaseAxis();
+    ret.valueAxis = coordSys.getOtherAxis(ret.baseAxis);
+    ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+    ret.valueDataDim = data.mapDimension(ret.valueAxis.dim);
+  }
+  return ret;
+}
+function dataDimToCoordDim(seriesModel, dataDim) {
+  var dimItem = seriesModel.getData().getDimensionInfo(dataDim);
+  return dimItem && dimItem.coordDim;
+}
+/**
+ * Filter data which is out of coordinateSystem range
+ * [dataFilter description]
+ */
+function dataFilter(
+// Currently only polar and cartesian has containData.
+coordSys, item) {
+  // Always return true if there is no coordSys
+  return coordSys && coordSys.containData && item.coord && !hasXOrY(item) ? coordSys.containData(item.coord) : true;
+}
+function zoneFilter(
+// Currently only polar and cartesian has containData.
+coordSys, item1, item2) {
+  // Always return true if there is no coordSys
+  return coordSys && coordSys.containZone && item1.coord && item2.coord && !hasXOrY(item1) && !hasXOrY(item2) ? coordSys.containZone(item1.coord, item2.coord) : true;
+}
+function createMarkerDimValueGetter(inCoordSys, dims) {
+  return inCoordSys ? function (item, dimName, dataIndex, dimIndex) {
+    var rawVal = dimIndex < 2
+    // x, y, radius, angle
+    ? item.coord && item.coord[dimIndex] : item.value;
+    return dataValueHelper.parseDataValue(rawVal, dims[dimIndex]);
+  } : function (item, dimName, dataIndex, dimIndex) {
+    return dataValueHelper.parseDataValue(item.value, dims[dimIndex]);
+  };
+}
+function numCalculate(data, valueDataDim, type) {
+  if (type === 'average') {
+    var sum_1 = 0;
+    var count_1 = 0;
+    data.each(valueDataDim, function (val, idx) {
+      if (!isNaN(val)) {
+        sum_1 += val;
+        count_1++;
+      }
+    });
+    return sum_1 / count_1;
+  } else if (type === 'median') {
+    return data.getMedian(valueDataDim);
+  } else {
+    // max & min
+    return data.getDataExtent(valueDataDim)[type === 'max' ? 1 : 0];
+  }
+}
+
+exports.createMarkerDimValueGetter = createMarkerDimValueGetter;
+exports.dataFilter = dataFilter;
+exports.dataTransform = dataTransform;
+exports.getAxisInfo = getAxisInfo;
+exports.numCalculate = numCalculate;
+exports.zoneFilter = zoneFilter;

package/lib/node_modules/echarts/lib/component/parallel/ParallelView.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Component = require('../../view/Component.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var throttle = require('../../util/throttle.js');
+
+var CLICK_THRESHOLD = 5; // > 4
+var ParallelView = /** @class */function (_super) {
+  tslib.__extends(ParallelView, _super);
+  function ParallelView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ParallelView.type;
+    return _this;
+  }
+  ParallelView.prototype.render = function (parallelModel, ecModel, api) {
+    this._model = parallelModel;
+    this._api = api;
+    if (!this._handlers) {
+      this._handlers = {};
+      util.each(handlers, function (handler, eventName) {
+        api.getZr().on(eventName, this._handlers[eventName] = util.bind(handler, this));
+      }, this);
+    }
+    throttle.createOrUpdate(this, '_throttledDispatchExpand', parallelModel.get('axisExpandRate'), 'fixRate');
+  };
+  ParallelView.prototype.dispose = function (ecModel, api) {
+    throttle.clear(this, '_throttledDispatchExpand');
+    util.each(this._handlers, function (handler, eventName) {
+      api.getZr().off(eventName, handler);
+    });
+    this._handlers = null;
+  };
+  /**
+   * @internal
+   * @param {Object} [opt] If null, cancel the last action triggering for debounce.
+   */
+  ParallelView.prototype._throttledDispatchExpand = function (opt) {
+    this._dispatchExpand(opt);
+  };
+  /**
+   * @internal
+   */
+  ParallelView.prototype._dispatchExpand = function (opt) {
+    opt && this._api.dispatchAction(util.extend({
+      type: 'parallelAxisExpand'
+    }, opt));
+  };
+  ParallelView.type = 'parallel';
+  return ParallelView;
+}(Component["default"]);
+var handlers = {
+  mousedown: function (e) {
+    if (checkTrigger(this, 'click')) {
+      this._mouseDownPoint = [e.offsetX, e.offsetY];
+    }
+  },
+  mouseup: function (e) {
+    var mouseDownPoint = this._mouseDownPoint;
+    if (checkTrigger(this, 'click') && mouseDownPoint) {
+      var point = [e.offsetX, e.offsetY];
+      var dist = Math.pow(mouseDownPoint[0] - point[0], 2) + Math.pow(mouseDownPoint[1] - point[1], 2);
+      if (dist > CLICK_THRESHOLD) {
+        return;
+      }
+      var result = this._model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+      result.behavior !== 'none' && this._dispatchExpand({
+        axisExpandWindow: result.axisExpandWindow
+      });
+    }
+    this._mouseDownPoint = null;
+  },
+  mousemove: function (e) {
+    // Should do nothing when brushing.
+    if (this._mouseDownPoint || !checkTrigger(this, 'mousemove')) {
+      return;
+    }
+    var model = this._model;
+    var result = model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+    var behavior = result.behavior;
+    behavior === 'jump' && this._throttledDispatchExpand.debounceNextCall(model.get('axisExpandDebounce'));
+    this._throttledDispatchExpand(behavior === 'none' ? null // Cancel the last trigger, in case that mouse slide out of the area quickly.
+    : {
+      axisExpandWindow: result.axisExpandWindow,
+      // Jumping uses animation, and sliding suppresses animation.
+      animation: behavior === 'jump' ? null : {
+        duration: 0 // Disable animation.
+      }
+    });
+  }
+};
+
+function checkTrigger(view, triggerOn) {
+  var model = view._model;
+  return model.get('axisExpandable') && model.get('axisExpandTriggerOn') === triggerOn;
+}
+
+exports["default"] = ParallelView;

package/lib/node_modules/echarts/lib/component/parallel/install.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var parallelPreprocessor = require('../../coord/parallel/parallelPreprocessor.js');
+var ParallelView = require('./ParallelView.js');
+var ParallelModel = require('../../coord/parallel/ParallelModel.js');
+var parallelCreator = require('../../coord/parallel/parallelCreator.js');
+var axisModelCreator = require('../../coord/axisModelCreator.js');
+var AxisModel = require('../../coord/parallel/AxisModel.js');
+var ParallelAxisView = require('../axis/ParallelAxisView.js');
+var parallelAxisAction = require('../axis/parallelAxisAction.js');
+
+var defaultAxisOption = {
+  type: 'value',
+  areaSelectStyle: {
+    width: 20,
+    borderWidth: 1,
+    borderColor: 'rgba(160,197,232)',
+    color: 'rgba(160,197,232)',
+    opacity: 0.3
+  },
+  realtime: true,
+  z: 10
+};
+function install(registers) {
+  registers.registerComponentView(ParallelView["default"]);
+  registers.registerComponentModel(ParallelModel["default"]);
+  registers.registerCoordinateSystem('parallel', parallelCreator["default"]);
+  registers.registerPreprocessor(parallelPreprocessor["default"]);
+  registers.registerComponentModel(AxisModel["default"]);
+  registers.registerComponentView(ParallelAxisView["default"]);
+  axisModelCreator["default"](registers, 'parallel', AxisModel["default"], defaultAxisOption);
+  parallelAxisAction.installParallelActions(registers);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/polar/install.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var extension = require('../../extension.js');
+var AxisView = require('../axis/AxisView.js');
+var PolarAxisPointer = require('../axisPointer/PolarAxisPointer.js');
+var install$1 = require('../axisPointer/install.js');
+var PolarModel = require('../../coord/polar/PolarModel.js');
+var axisModelCreator = require('../../coord/axisModelCreator.js');
+var AxisModel = require('../../coord/polar/AxisModel.js');
+var polarCreator = require('../../coord/polar/polarCreator.js');
+var AngleAxisView = require('../axis/AngleAxisView.js');
+var RadiusAxisView = require('../axis/RadiusAxisView.js');
+var Component = require('../../view/Component.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var barPolar = require('../../layout/barPolar.js');
+
+var angleAxisExtraOption = {
+  startAngle: 90,
+  clockwise: true,
+  splitNumber: 12,
+  axisLabel: {
+    rotate: 0
+  }
+};
+var radiusAxisExtraOption = {
+  splitNumber: 5
+};
+var PolarView = /** @class */function (_super) {
+  tslib.__extends(PolarView, _super);
+  function PolarView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = PolarView.type;
+    return _this;
+  }
+  PolarView.type = 'polar';
+  return PolarView;
+}(Component["default"]);
+function install(registers) {
+  extension.use(install$1.install);
+  AxisView["default"].registerAxisPointerClass('PolarAxisPointer', PolarAxisPointer["default"]);
+  registers.registerCoordinateSystem('polar', polarCreator["default"]);
+  registers.registerComponentModel(PolarModel["default"]);
+  registers.registerComponentView(PolarView);
+  // Model and view for angleAxis and radiusAxis
+  axisModelCreator["default"](registers, 'angle', AxisModel.AngleAxisModel, angleAxisExtraOption);
+  axisModelCreator["default"](registers, 'radius', AxisModel.RadiusAxisModel, radiusAxisExtraOption);
+  registers.registerComponentView(AngleAxisView["default"]);
+  registers.registerComponentView(RadiusAxisView["default"]);
+  registers.registerLayout(util.curry(barPolar["default"], 'bar'));
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/component/radar/RadarView.js

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var AxisBuilder = require('../axis/AxisBuilder.js');
+var graphic = require('../../util/graphic.js');
+var Component = require('../../view/Component.js');
+var Circle = require('../../../../zrender/lib/graphic/shape/Circle.js');
+var Ring = require('../../../../zrender/lib/graphic/shape/Ring.js');
+var Polyline = require('../../../../zrender/lib/graphic/shape/Polyline.js');
+var Polygon = require('../../../../zrender/lib/graphic/shape/Polygon.js');
+
+var axisBuilderAttrs = ['axisLine', 'axisTickLabel', 'axisName'];
+var RadarView = /** @class */function (_super) {
+  tslib.__extends(RadarView, _super);
+  function RadarView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = RadarView.type;
+    return _this;
+  }
+  RadarView.prototype.render = function (radarModel, ecModel, api) {
+    var group = this.group;
+    group.removeAll();
+    this._buildAxes(radarModel);
+    this._buildSplitLineAndArea(radarModel);
+  };
+  RadarView.prototype._buildAxes = function (radarModel) {
+    var radar = radarModel.coordinateSystem;
+    var indicatorAxes = radar.getIndicatorAxes();
+    var axisBuilders = util.map(indicatorAxes, function (indicatorAxis) {
+      var axisName = indicatorAxis.model.get('showName') ? indicatorAxis.name : ''; // hide name
+      var axisBuilder = new AxisBuilder["default"](indicatorAxis.model, {
+        axisName: axisName,
+        position: [radar.cx, radar.cy],
+        rotation: indicatorAxis.angle,
+        labelDirection: -1,
+        tickDirection: -1,
+        nameDirection: 1
+      });
+      return axisBuilder;
+    });
+    util.each(axisBuilders, function (axisBuilder) {
+      util.each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
+      this.group.add(axisBuilder.getGroup());
+    }, this);
+  };
+  RadarView.prototype._buildSplitLineAndArea = function (radarModel) {
+    var radar = radarModel.coordinateSystem;
+    var indicatorAxes = radar.getIndicatorAxes();
+    if (!indicatorAxes.length) {
+      return;
+    }
+    var shape = radarModel.get('shape');
+    var splitLineModel = radarModel.getModel('splitLine');
+    var splitAreaModel = radarModel.getModel('splitArea');
+    var lineStyleModel = splitLineModel.getModel('lineStyle');
+    var areaStyleModel = splitAreaModel.getModel('areaStyle');
+    var showSplitLine = splitLineModel.get('show');
+    var showSplitArea = splitAreaModel.get('show');
+    var splitLineColors = lineStyleModel.get('color');
+    var splitAreaColors = areaStyleModel.get('color');
+    var splitLineColorsArr = util.isArray(splitLineColors) ? splitLineColors : [splitLineColors];
+    var splitAreaColorsArr = util.isArray(splitAreaColors) ? splitAreaColors : [splitAreaColors];
+    var splitLines = [];
+    var splitAreas = [];
+    function getColorIndex(areaOrLine, areaOrLineColorList, idx) {
+      var colorIndex = idx % areaOrLineColorList.length;
+      areaOrLine[colorIndex] = areaOrLine[colorIndex] || [];
+      return colorIndex;
+    }
+    if (shape === 'circle') {
+      var ticksRadius = indicatorAxes[0].getTicksCoords();
+      var cx = radar.cx;
+      var cy = radar.cy;
+      for (var i = 0; i < ticksRadius.length; i++) {
+        if (showSplitLine) {
+          var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+          splitLines[colorIndex].push(new Circle["default"]({
+            shape: {
+              cx: cx,
+              cy: cy,
+              r: ticksRadius[i].coord
+            }
+          }));
+        }
+        if (showSplitArea && i < ticksRadius.length - 1) {
+          var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i);
+          splitAreas[colorIndex].push(new Ring["default"]({
+            shape: {
+              cx: cx,
+              cy: cy,
+              r0: ticksRadius[i].coord,
+              r: ticksRadius[i + 1].coord
+            }
+          }));
+        }
+      }
+    }
+    // Polyyon
+    else {
+      var realSplitNumber_1;
+      var axesTicksPoints = util.map(indicatorAxes, function (indicatorAxis, idx) {
+        var ticksCoords = indicatorAxis.getTicksCoords();
+        realSplitNumber_1 = realSplitNumber_1 == null ? ticksCoords.length - 1 : Math.min(ticksCoords.length - 1, realSplitNumber_1);
+        return util.map(ticksCoords, function (tickCoord) {
+          return radar.coordToPoint(tickCoord.coord, idx);
+        });
+      });
+      var prevPoints = [];
+      for (var i = 0; i <= realSplitNumber_1; i++) {
+        var points = [];
+        for (var j = 0; j < indicatorAxes.length; j++) {
+          points.push(axesTicksPoints[j][i]);
+        }
+        // Close
+        if (points[0]) {
+          points.push(points[0].slice());
+        } else {
+          if (process.env.NODE_ENV !== 'production') {
+            console.error('Can\'t draw value axis ' + i);
+          }
+        }
+        if (showSplitLine) {
+          var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+          splitLines[colorIndex].push(new Polyline["default"]({
+            shape: {
+              points: points
+            }
+          }));
+        }
+        if (showSplitArea && prevPoints) {
+          var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i - 1);
+          splitAreas[colorIndex].push(new Polygon["default"]({
+            shape: {
+              points: points.concat(prevPoints)
+            }
+          }));
+        }
+        prevPoints = points.slice().reverse();
+      }
+    }
+    var lineStyle = lineStyleModel.getLineStyle();
+    var areaStyle = areaStyleModel.getAreaStyle();
+    // Add splitArea before splitLine
+    util.each(splitAreas, function (splitAreas, idx) {
+      this.group.add(graphic.mergePath(splitAreas, {
+        style: util.defaults({
+          stroke: 'none',
+          fill: splitAreaColorsArr[idx % splitAreaColorsArr.length]
+        }, areaStyle),
+        silent: true
+      }));
+    }, this);
+    util.each(splitLines, function (splitLines, idx) {
+      this.group.add(graphic.mergePath(splitLines, {
+        style: util.defaults({
+          fill: 'none',
+          stroke: splitLineColorsArr[idx % splitLineColorsArr.length]
+        }, lineStyle),
+        silent: true
+      }));
+    }, this);
+  };
+  RadarView.type = 'radar';
+  return RadarView;
+}(Component["default"]);
+
+exports["default"] = RadarView;