first commit

node_modules/echarts/lib/coord/polar/AngleAxis.js

@@ -0,0 +1,132 @@
+
+/*
+* 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 textContain = require("zrender/lib/contain/text");
+
+var Axis = require("../Axis");
+
+var _model = require("../../util/model");
+
+var makeInner = _model.makeInner;
+
+/*
+* 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 inner = makeInner();
+
+function AngleAxis(scale, angleExtent) {
+  angleExtent = angleExtent || [0, 360];
+  Axis.call(this, 'angle', scale, angleExtent);
+  /**
+   * Axis type
+   *  - 'category'
+   *  - 'value'
+   *  - 'time'
+   *  - 'log'
+   * @type {string}
+   */
+
+  this.type = 'category';
+}
+
+AngleAxis.prototype = {
+  constructor: AngleAxis,
+
+  /**
+   * @override
+   */
+  pointToData: function (point, clamp) {
+    return this.polar.pointToData(point, clamp)[this.dim === 'radius' ? 0 : 1];
+  },
+  dataToAngle: Axis.prototype.dataToCoord,
+  angleToData: Axis.prototype.coordToData,
+
+  /**
+   * Only be called in category axis.
+   * Angle axis uses text height to decide interval
+   *
+   * @override
+   * @return {number} Auto interval for cateogry axis tick and label
+   */
+  calculateCategoryInterval: function () {
+    var axis = this;
+    var labelModel = axis.getLabelModel();
+    var ordinalScale = axis.scale;
+    var ordinalExtent = ordinalScale.getExtent(); // Providing this method is for optimization:
+    // avoid generating a long array by `getTicks`
+    // in large category data case.
+
+    var tickCount = ordinalScale.count();
+
+    if (ordinalExtent[1] - ordinalExtent[0] < 1) {
+      return 0;
+    }
+
+    var tickValue = ordinalExtent[0];
+    var unitSpan = axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue);
+    var unitH = Math.abs(unitSpan); // Not precise, just use height as text width
+    // and each distance from axis line yet.
+
+    var rect = textContain.getBoundingRect(tickValue, labelModel.getFont(), 'center', 'top');
+    var maxH = Math.max(rect.height, 7);
+    var dh = maxH / unitH; // 0/0 is NaN, 1/0 is Infinity.
+
+    isNaN(dh) && (dh = Infinity);
+    var interval = Math.max(0, Math.floor(dh));
+    var cache = inner(axis.model);
+    var lastAutoInterval = cache.lastAutoInterval;
+    var lastTickCount = cache.lastTickCount; // Use cache to keep interval stable while moving zoom window,
+    // otherwise the calculated interval might jitter when the zoom
+    // window size is close to the interval-changing size.
+
+    if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 // Always choose the bigger one, otherwise the critical
+    // point is not the same when zooming in or zooming out.
+    && lastAutoInterval > interval) {
+      interval = lastAutoInterval;
+    } // Only update cache if cache not used, otherwise the
+    // changing of interval is too insensitive.
+    else {
+        cache.lastTickCount = tickCount;
+        cache.lastAutoInterval = interval;
+      }
+
+    return interval;
+  }
+};
+zrUtil.inherits(AngleAxis, Axis);
+var _default = AngleAxis;
+module.exports = _default;

node_modules/echarts/lib/coord/polar/AxisModel.js

@@ -0,0 +1,91 @@
+
+/*
+* 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 ComponentModel = require("../../model/Component");
+
+var axisModelCreator = require("../axisModelCreator");
+
+var axisModelCommonMixin = require("../axisModelCommonMixin");
+
+/*
+* 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 PolarAxisModel = ComponentModel.extend({
+  type: 'polarAxis',
+
+  /**
+   * @type {module:echarts/coord/polar/AngleAxis|module:echarts/coord/polar/RadiusAxis}
+   */
+  axis: null,
+
+  /**
+   * @override
+   */
+  getCoordSysModel: function () {
+    return this.ecModel.queryComponents({
+      mainType: 'polar',
+      index: this.option.polarIndex,
+      id: this.option.polarId
+    })[0];
+  }
+});
+zrUtil.merge(PolarAxisModel.prototype, axisModelCommonMixin);
+var polarAxisDefaultExtendedOption = {
+  angle: {
+    // polarIndex: 0,
+    // polarId: '',
+    startAngle: 90,
+    clockwise: true,
+    splitNumber: 12,
+    axisLabel: {
+      rotate: false
+    }
+  },
+  radius: {
+    // polarIndex: 0,
+    // polarId: '',
+    splitNumber: 5
+  }
+};
+
+function getAxisType(axisDim, option) {
+  // Default axis with data is category axis
+  return option.type || (option.data ? 'category' : 'value');
+}
+
+axisModelCreator('angle', PolarAxisModel, getAxisType, polarAxisDefaultExtendedOption.angle);
+axisModelCreator('radius', PolarAxisModel, getAxisType, polarAxisDefaultExtendedOption.radius);

node_modules/echarts/lib/coord/polar/Polar.js

@@ -0,0 +1,292 @@
+
+/*
+* 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 RadiusAxis = require("./RadiusAxis");
+
+var AngleAxis = require("./AngleAxis");
+
+/*
+* 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.
+*/
+
+/**
+ * @module echarts/coord/polar/Polar
+ */
+
+/**
+ * @alias {module:echarts/coord/polar/Polar}
+ * @constructor
+ * @param {string} name
+ */
+var Polar = function (name) {
+  /**
+   * @type {string}
+   */
+  this.name = name || '';
+  /**
+   * x of polar center
+   * @type {number}
+   */
+
+  this.cx = 0;
+  /**
+   * y of polar center
+   * @type {number}
+   */
+
+  this.cy = 0;
+  /**
+   * @type {module:echarts/coord/polar/RadiusAxis}
+   * @private
+   */
+
+  this._radiusAxis = new RadiusAxis();
+  /**
+   * @type {module:echarts/coord/polar/AngleAxis}
+   * @private
+   */
+
+  this._angleAxis = new AngleAxis();
+  this._radiusAxis.polar = this._angleAxis.polar = this;
+};
+
+Polar.prototype = {
+  type: 'polar',
+  axisPointerEnabled: true,
+  constructor: Polar,
+
+  /**
+   * @param {Array.<string>}
+   * @readOnly
+   */
+  dimensions: ['radius', 'angle'],
+
+  /**
+   * @type {module:echarts/coord/PolarModel}
+   */
+  model: null,
+
+  /**
+   * If contain coord
+   * @param {Array.<number>} point
+   * @return {boolean}
+   */
+  containPoint: function (point) {
+    var coord = this.pointToCoord(point);
+    return this._radiusAxis.contain(coord[0]) && this._angleAxis.contain(coord[1]);
+  },
+
+  /**
+   * If contain data
+   * @param {Array.<number>} data
+   * @return {boolean}
+   */
+  containData: function (data) {
+    return this._radiusAxis.containData(data[0]) && this._angleAxis.containData(data[1]);
+  },
+
+  /**
+   * @param {string} dim
+   * @return {module:echarts/coord/polar/AngleAxis|module:echarts/coord/polar/RadiusAxis}
+   */
+  getAxis: function (dim) {
+    return this['_' + dim + 'Axis'];
+  },
+
+  /**
+   * @return {Array.<module:echarts/coord/Axis>}
+   */
+  getAxes: function () {
+    return [this._radiusAxis, this._angleAxis];
+  },
+
+  /**
+   * Get axes by type of scale
+   * @param {string} scaleType
+   * @return {module:echarts/coord/polar/AngleAxis|module:echarts/coord/polar/RadiusAxis}
+   */
+  getAxesByScale: function (scaleType) {
+    var axes = [];
+    var angleAxis = this._angleAxis;
+    var radiusAxis = this._radiusAxis;
+    angleAxis.scale.type === scaleType && axes.push(angleAxis);
+    radiusAxis.scale.type === scaleType && axes.push(radiusAxis);
+    return axes;
+  },
+
+  /**
+   * @return {module:echarts/coord/polar/AngleAxis}
+   */
+  getAngleAxis: function () {
+    return this._angleAxis;
+  },
+
+  /**
+   * @return {module:echarts/coord/polar/RadiusAxis}
+   */
+  getRadiusAxis: function () {
+    return this._radiusAxis;
+  },
+
+  /**
+   * @param {module:echarts/coord/polar/Axis}
+   * @return {module:echarts/coord/polar/Axis}
+   */
+  getOtherAxis: function (axis) {
+    var angleAxis = this._angleAxis;
+    return axis === angleAxis ? this._radiusAxis : angleAxis;
+  },
+
+  /**
+   * Base axis will be used on stacking.
+   *
+   * @return {module:echarts/coord/polar/Axis}
+   */
+  getBaseAxis: function () {
+    return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAngleAxis();
+  },
+
+  /**
+   * @param {string} [dim] 'radius' or 'angle' or 'auto' or null/undefined
+   * @return {Object} {baseAxes: [], otherAxes: []}
+   */
+  getTooltipAxes: function (dim) {
+    var baseAxis = dim != null && dim !== 'auto' ? this.getAxis(dim) : this.getBaseAxis();
+    return {
+      baseAxes: [baseAxis],
+      otherAxes: [this.getOtherAxis(baseAxis)]
+    };
+  },
+
+  /**
+   * Convert a single data item to (x, y) point.
+   * Parameter data is an array which the first element is radius and the second is angle
+   * @param {Array.<number>} data
+   * @param {boolean} [clamp=false]
+   * @return {Array.<number>}
+   */
+  dataToPoint: function (data, clamp) {
+    return this.coordToPoint([this._radiusAxis.dataToRadius(data[0], clamp), this._angleAxis.dataToAngle(data[1], clamp)]);
+  },
+
+  /**
+   * Convert a (x, y) point to data
+   * @param {Array.<number>} point
+   * @param {boolean} [clamp=false]
+   * @return {Array.<number>}
+   */
+  pointToData: function (point, clamp) {
+    var coord = this.pointToCoord(point);
+    return [this._radiusAxis.radiusToData(coord[0], clamp), this._angleAxis.angleToData(coord[1], clamp)];
+  },
+
+  /**
+   * Convert a (x, y) point to (radius, angle) coord
+   * @param {Array.<number>} point
+   * @return {Array.<number>}
+   */
+  pointToCoord: function (point) {
+    var dx = point[0] - this.cx;
+    var dy = point[1] - this.cy;
+    var angleAxis = this.getAngleAxis();
+    var extent = angleAxis.getExtent();
+    var minAngle = Math.min(extent[0], extent[1]);
+    var maxAngle = Math.max(extent[0], extent[1]); // Fix fixed extent in polarCreator
+    // FIXME
+
+    angleAxis.inverse ? minAngle = maxAngle - 360 : maxAngle = minAngle + 360;
+    var radius = Math.sqrt(dx * dx + dy * dy);
+    dx /= radius;
+    dy /= radius;
+    var radian = Math.atan2(-dy, dx) / Math.PI * 180; // move to angleExtent
+
+    var dir = radian < minAngle ? 1 : -1;
+
+    while (radian < minAngle || radian > maxAngle) {
+      radian += dir * 360;
+    }
+
+    return [radius, radian];
+  },
+
+  /**
+   * Convert a (radius, angle) coord to (x, y) point
+   * @param {Array.<number>} coord
+   * @return {Array.<number>}
+   */
+  coordToPoint: function (coord) {
+    var radius = coord[0];
+    var radian = coord[1] / 180 * Math.PI;
+    var x = Math.cos(radian) * radius + this.cx; // Inverse the y
+
+    var y = -Math.sin(radian) * radius + this.cy;
+    return [x, y];
+  },
+
+  /**
+   * Get ring area of cartesian.
+   * Area will have a contain function to determine if a point is in the coordinate system.
+   * @return {Ring}
+   */
+  getArea: function () {
+    var angleAxis = this.getAngleAxis();
+    var radiusAxis = this.getRadiusAxis();
+    var radiusExtent = radiusAxis.getExtent().slice();
+    radiusExtent[0] > radiusExtent[1] && radiusExtent.reverse();
+    var angleExtent = angleAxis.getExtent();
+    var RADIAN = Math.PI / 180;
+    return {
+      cx: this.cx,
+      cy: this.cy,
+      r0: radiusExtent[0],
+      r: radiusExtent[1],
+      startAngle: -angleExtent[0] * RADIAN,
+      endAngle: -angleExtent[1] * RADIAN,
+      clockwise: angleAxis.inverse,
+      contain: function (x, y) {
+        // It's a ring shape.
+        // Start angle and end angle don't matter
+        var dx = x - this.cx;
+        var dy = y - this.cy;
+        var d2 = dx * dx + dy * dy;
+        var r = this.r;
+        var r0 = this.r0;
+        return d2 <= r * r && d2 >= r0 * r0;
+      }
+    };
+  }
+};
+var _default = Polar;
+module.exports = _default;

node_modules/echarts/lib/coord/polar/PolarModel.js

@@ -0,0 +1,74 @@
+
+/*
+* 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");
+
+require("./AxisModel");
+
+/*
+* 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 = echarts.extendComponentModel({
+  type: 'polar',
+  dependencies: ['polarAxis', 'angleAxis'],
+
+  /**
+   * @type {module:echarts/coord/polar/Polar}
+   */
+  coordinateSystem: null,
+
+  /**
+   * @param {string} axisType
+   * @return {module:echarts/coord/polar/AxisModel}
+   */
+  findAxisModel: function (axisType) {
+    var foundAxisModel;
+    var ecModel = this.ecModel;
+    ecModel.eachComponent(axisType, function (axisModel) {
+      if (axisModel.getCoordSysModel() === this) {
+        foundAxisModel = axisModel;
+      }
+    }, this);
+    return foundAxisModel;
+  },
+  defaultOption: {
+    zlevel: 0,
+    z: 0,
+    center: ['50%', '50%'],
+    radius: '80%'
+  }
+});
+
+module.exports = _default;

node_modules/echarts/lib/coord/polar/RadiusAxis.js

@@ -0,0 +1,71 @@
+
+/*
+* 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 Axis = require("../Axis");
+
+/*
+* 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 RadiusAxis(scale, radiusExtent) {
+  Axis.call(this, 'radius', scale, radiusExtent);
+  /**
+   * Axis type
+   *  - 'category'
+   *  - 'value'
+   *  - 'time'
+   *  - 'log'
+   * @type {string}
+   */
+
+  this.type = 'category';
+}
+
+RadiusAxis.prototype = {
+  constructor: RadiusAxis,
+
+  /**
+   * @override
+   */
+  pointToData: function (point, clamp) {
+    return this.polar.pointToData(point, clamp)[this.dim === 'radius' ? 0 : 1];
+  },
+  dataToRadius: Axis.prototype.dataToCoord,
+  radiusToData: Axis.prototype.coordToData
+};
+zrUtil.inherits(RadiusAxis, Axis);
+var _default = RadiusAxis;
+module.exports = _default;

node_modules/echarts/lib/coord/polar/polarCreator.js

@@ -0,0 +1,182 @@
+
+/*
+* 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 _config = require("../../config");
+
+var __DEV__ = _config.__DEV__;
+
+var zrUtil = require("zrender/lib/core/util");
+
+var Polar = require("./Polar");
+
+var _number = require("../../util/number");
+
+var parsePercent = _number.parsePercent;
+
+var _axisHelper = require("../../coord/axisHelper");
+
+var createScaleByModel = _axisHelper.createScaleByModel;
+var niceScaleExtent = _axisHelper.niceScaleExtent;
+
+var CoordinateSystem = require("../../CoordinateSystem");
+
+var _dataStackHelper = require("../../data/helper/dataStackHelper");
+
+var getStackedDimension = _dataStackHelper.getStackedDimension;
+
+require("./PolarModel");
+
+/*
+* 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.
+*/
+// TODO Axis scale
+
+/**
+ * Resize method bound to the polar
+ * @param {module:echarts/coord/polar/PolarModel} polarModel
+ * @param {module:echarts/ExtensionAPI} api
+ */
+function resizePolar(polar, polarModel, api) {
+  var center = polarModel.get('center');
+  var width = api.getWidth();
+  var height = api.getHeight();
+  polar.cx = parsePercent(center[0], width);
+  polar.cy = parsePercent(center[1], height);
+  var radiusAxis = polar.getRadiusAxis();
+  var size = Math.min(width, height) / 2;
+  var radius = polarModel.get('radius');
+
+  if (radius == null) {
+    radius = [0, '100%'];
+  } else if (!zrUtil.isArray(radius)) {
+    // r0 = 0
+    radius = [0, radius];
+  }
+
+  radius = [parsePercent(radius[0], size), parsePercent(radius[1], size)];
+  radiusAxis.inverse ? radiusAxis.setExtent(radius[1], radius[0]) : radiusAxis.setExtent(radius[0], radius[1]);
+}
+/**
+ * Update polar
+ */
+
+
+function updatePolarScale(ecModel, api) {
+  var polar = this;
+  var angleAxis = polar.getAngleAxis();
+  var radiusAxis = polar.getRadiusAxis(); // Reset scale
+
+  angleAxis.scale.setExtent(Infinity, -Infinity);
+  radiusAxis.scale.setExtent(Infinity, -Infinity);
+  ecModel.eachSeries(function (seriesModel) {
+    if (seriesModel.coordinateSystem === polar) {
+      var data = seriesModel.getData();
+      zrUtil.each(data.mapDimension('radius', true), function (dim) {
+        radiusAxis.scale.unionExtentFromData(data, getStackedDimension(data, dim));
+      });
+      zrUtil.each(data.mapDimension('angle', true), function (dim) {
+        angleAxis.scale.unionExtentFromData(data, getStackedDimension(data, dim));
+      });
+    }
+  });
+  niceScaleExtent(angleAxis.scale, angleAxis.model);
+  niceScaleExtent(radiusAxis.scale, radiusAxis.model); // Fix extent of category angle axis
+
+  if (angleAxis.type === 'category' && !angleAxis.onBand) {
+    var extent = angleAxis.getExtent();
+    var diff = 360 / angleAxis.scale.count();
+    angleAxis.inverse ? extent[1] += diff : extent[1] -= diff;
+    angleAxis.setExtent(extent[0], extent[1]);
+  }
+}
+/**
+ * Set common axis properties
+ * @param {module:echarts/coord/polar/AngleAxis|module:echarts/coord/polar/RadiusAxis}
+ * @param {module:echarts/coord/polar/AxisModel}
+ * @inner
+ */
+
+
+function setAxis(axis, axisModel) {
+  axis.type = axisModel.get('type');
+  axis.scale = createScaleByModel(axisModel);
+  axis.onBand = axisModel.get('boundaryGap') && axis.type === 'category';
+  axis.inverse = axisModel.get('inverse');
+
+  if (axisModel.mainType === 'angleAxis') {
+    axis.inverse ^= axisModel.get('clockwise');
+    var startAngle = axisModel.get('startAngle');
+    axis.setExtent(startAngle, startAngle + (axis.inverse ? -360 : 360));
+  } // Inject axis instance
+
+
+  axisModel.axis = axis;
+  axis.model = axisModel;
+}
+
+var polarCreator = {
+  dimensions: Polar.prototype.dimensions,
+  create: function (ecModel, api) {
+    var polarList = [];
+    ecModel.eachComponent('polar', function (polarModel, idx) {
+      var polar = new Polar(idx); // Inject resize and update method
+
+      polar.update = updatePolarScale;
+      var radiusAxis = polar.getRadiusAxis();
+      var angleAxis = polar.getAngleAxis();
+      var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+      var angleAxisModel = polarModel.findAxisModel('angleAxis');
+      setAxis(radiusAxis, radiusAxisModel);
+      setAxis(angleAxis, angleAxisModel);
+      resizePolar(polar, polarModel, api);
+      polarList.push(polar);
+      polarModel.coordinateSystem = polar;
+      polar.model = polarModel;
+    }); // Inject coordinateSystem to series
+
+    ecModel.eachSeries(function (seriesModel) {
+      if (seriesModel.get('coordinateSystem') === 'polar') {
+        var polarModel = ecModel.queryComponents({
+          mainType: 'polar',
+          index: seriesModel.get('polarIndex'),
+          id: seriesModel.get('polarId')
+        })[0];
+        seriesModel.coordinateSystem = polarModel.coordinateSystem;
+      }
+    });
+    return polarList;
+  }
+};
+CoordinateSystem.register('polar', polarCreator);

node_modules/echarts/lib/coord/polar/prepareCustom.js

@@ -0,0 +1,84 @@
+
+/*
+* 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");
+
+/*
+* 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 dataToCoordSize(dataSize, dataItem) {
+  // dataItem is necessary in log axis.
+  return zrUtil.map(['Radius', 'Angle'], function (dim, dimIdx) {
+    var axis = this['get' + dim + 'Axis']();
+    var val = dataItem[dimIdx];
+    var halfSize = dataSize[dimIdx] / 2;
+    var method = 'dataTo' + dim;
+    var result = axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis[method](val - halfSize) - axis[method](val + halfSize));
+
+    if (dim === 'Angle') {
+      result = result * Math.PI / 180;
+    }
+
+    return result;
+  }, this);
+}
+
+function _default(coordSys) {
+  var radiusAxis = coordSys.getRadiusAxis();
+  var angleAxis = coordSys.getAngleAxis();
+  var radius = radiusAxis.getExtent();
+  radius[0] > radius[1] && radius.reverse();
+  return {
+    coordSys: {
+      type: 'polar',
+      cx: coordSys.cx,
+      cy: coordSys.cy,
+      r: radius[1],
+      r0: radius[0]
+    },
+    api: {
+      coord: zrUtil.bind(function (data) {
+        var radius = radiusAxis.dataToRadius(data[0]);
+        var angle = angleAxis.dataToAngle(data[1]);
+        var coord = coordSys.coordToPoint([radius, angle]);
+        coord.push(radius, angle * Math.PI / 180);
+        return coord;
+      }),
+      size: zrUtil.bind(dataToCoordSize, coordSys)
+    }
+  };
+}
+
+module.exports = _default;