office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/coord/parallel/Parallel.js

@@ -0,0 +1,369 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var matrix = require('../../../../zrender/lib/core/matrix.js');
+var layout = require('../../util/layout.js');
+var axisHelper = require('../axisHelper.js');
+var ParallelAxis = require('./ParallelAxis.js');
+var graphic = require('../../util/graphic.js');
+var number = require('../../util/number.js');
+var sliderMove = require('../../component/helper/sliderMove.js');
+
+var each = util.each;
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var round = number.round;
+var PI = Math.PI;
+var Parallel = /** @class */function () {
+  function Parallel(parallelModel, ecModel, api) {
+    this.type = 'parallel';
+    /**
+     * key: dimension
+     */
+    this._axesMap = util.createHashMap();
+    /**
+     * key: dimension
+     * value: {position: [], rotation, }
+     */
+    this._axesLayout = {};
+    this.dimensions = parallelModel.dimensions;
+    this._model = parallelModel;
+    this._init(parallelModel, ecModel, api);
+  }
+  Parallel.prototype._init = function (parallelModel, ecModel, api) {
+    var dimensions = parallelModel.dimensions;
+    var parallelAxisIndex = parallelModel.parallelAxisIndex;
+    each(dimensions, function (dim, idx) {
+      var axisIndex = parallelAxisIndex[idx];
+      var axisModel = ecModel.getComponent('parallelAxis', axisIndex);
+      var axis = this._axesMap.set(dim, new ParallelAxis["default"](dim, axisHelper.createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisIndex));
+      var isCategory = axis.type === 'category';
+      axis.onBand = isCategory && axisModel.get('boundaryGap');
+      axis.inverse = axisModel.get('inverse');
+      // Injection
+      axisModel.axis = axis;
+      axis.model = axisModel;
+      axis.coordinateSystem = axisModel.coordinateSystem = this;
+    }, this);
+  };
+  /**
+   * Update axis scale after data processed
+   */
+  Parallel.prototype.update = function (ecModel, api) {
+    this._updateAxesFromSeries(this._model, ecModel);
+  };
+  Parallel.prototype.containPoint = function (point) {
+    var layoutInfo = this._makeLayoutInfo();
+    var axisBase = layoutInfo.axisBase;
+    var layoutBase = layoutInfo.layoutBase;
+    var pixelDimIndex = layoutInfo.pixelDimIndex;
+    var pAxis = point[1 - pixelDimIndex];
+    var pLayout = point[pixelDimIndex];
+    return pAxis >= axisBase && pAxis <= axisBase + layoutInfo.axisLength && pLayout >= layoutBase && pLayout <= layoutBase + layoutInfo.layoutLength;
+  };
+  Parallel.prototype.getModel = function () {
+    return this._model;
+  };
+  /**
+   * Update properties from series
+   */
+  Parallel.prototype._updateAxesFromSeries = function (parallelModel, ecModel) {
+    ecModel.eachSeries(function (seriesModel) {
+      if (!parallelModel.contains(seriesModel, ecModel)) {
+        return;
+      }
+      var data = seriesModel.getData();
+      each(this.dimensions, function (dim) {
+        var axis = this._axesMap.get(dim);
+        axis.scale.unionExtentFromData(data, data.mapDimension(dim));
+        axisHelper.niceScaleExtent(axis.scale, axis.model);
+      }, this);
+    }, this);
+  };
+  /**
+   * Resize the parallel coordinate system.
+   */
+  Parallel.prototype.resize = function (parallelModel, api) {
+    this._rect = layout.getLayoutRect(parallelModel.getBoxLayoutParams(), {
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+    this._layoutAxes();
+  };
+  Parallel.prototype.getRect = function () {
+    return this._rect;
+  };
+  Parallel.prototype._makeLayoutInfo = function () {
+    var parallelModel = this._model;
+    var rect = this._rect;
+    var xy = ['x', 'y'];
+    var wh = ['width', 'height'];
+    var layout = parallelModel.get('layout');
+    var pixelDimIndex = layout === 'horizontal' ? 0 : 1;
+    var layoutLength = rect[wh[pixelDimIndex]];
+    var layoutExtent = [0, layoutLength];
+    var axisCount = this.dimensions.length;
+    var axisExpandWidth = restrict(parallelModel.get('axisExpandWidth'), layoutExtent);
+    var axisExpandCount = restrict(parallelModel.get('axisExpandCount') || 0, [0, axisCount]);
+    var axisExpandable = parallelModel.get('axisExpandable') && axisCount > 3 && axisCount > axisExpandCount && axisExpandCount > 1 && axisExpandWidth > 0 && layoutLength > 0;
+    // `axisExpandWindow` is According to the coordinates of [0, axisExpandLength],
+    // for sake of consider the case that axisCollapseWidth is 0 (when screen is narrow),
+    // where collapsed axes should be overlapped.
+    var axisExpandWindow = parallelModel.get('axisExpandWindow');
+    var winSize;
+    if (!axisExpandWindow) {
+      winSize = restrict(axisExpandWidth * (axisExpandCount - 1), layoutExtent);
+      var axisExpandCenter = parallelModel.get('axisExpandCenter') || mathFloor(axisCount / 2);
+      axisExpandWindow = [axisExpandWidth * axisExpandCenter - winSize / 2];
+      axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+    } else {
+      winSize = restrict(axisExpandWindow[1] - axisExpandWindow[0], layoutExtent);
+      axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+    }
+    var axisCollapseWidth = (layoutLength - winSize) / (axisCount - axisExpandCount);
+    // Avoid axisCollapseWidth is too small.
+    axisCollapseWidth < 3 && (axisCollapseWidth = 0);
+    // Find the first and last indices > ewin[0] and < ewin[1].
+    var winInnerIndices = [mathFloor(round(axisExpandWindow[0] / axisExpandWidth, 1)) + 1, mathCeil(round(axisExpandWindow[1] / axisExpandWidth, 1)) - 1];
+    // Pos in ec coordinates.
+    var axisExpandWindow0Pos = axisCollapseWidth / axisExpandWidth * axisExpandWindow[0];
+    return {
+      layout: layout,
+      pixelDimIndex: pixelDimIndex,
+      layoutBase: rect[xy[pixelDimIndex]],
+      layoutLength: layoutLength,
+      axisBase: rect[xy[1 - pixelDimIndex]],
+      axisLength: rect[wh[1 - pixelDimIndex]],
+      axisExpandable: axisExpandable,
+      axisExpandWidth: axisExpandWidth,
+      axisCollapseWidth: axisCollapseWidth,
+      axisExpandWindow: axisExpandWindow,
+      axisCount: axisCount,
+      winInnerIndices: winInnerIndices,
+      axisExpandWindow0Pos: axisExpandWindow0Pos
+    };
+  };
+  Parallel.prototype._layoutAxes = function () {
+    var rect = this._rect;
+    var axes = this._axesMap;
+    var dimensions = this.dimensions;
+    var layoutInfo = this._makeLayoutInfo();
+    var layout = layoutInfo.layout;
+    axes.each(function (axis) {
+      var axisExtent = [0, layoutInfo.axisLength];
+      var idx = axis.inverse ? 1 : 0;
+      axis.setExtent(axisExtent[idx], axisExtent[1 - idx]);
+    });
+    each(dimensions, function (dim, idx) {
+      var posInfo = (layoutInfo.axisExpandable ? layoutAxisWithExpand : layoutAxisWithoutExpand)(idx, layoutInfo);
+      var positionTable = {
+        horizontal: {
+          x: posInfo.position,
+          y: layoutInfo.axisLength
+        },
+        vertical: {
+          x: 0,
+          y: posInfo.position
+        }
+      };
+      var rotationTable = {
+        horizontal: PI / 2,
+        vertical: 0
+      };
+      var position = [positionTable[layout].x + rect.x, positionTable[layout].y + rect.y];
+      var rotation = rotationTable[layout];
+      var transform = matrix.create();
+      matrix.rotate(transform, transform, rotation);
+      matrix.translate(transform, transform, position);
+      // TODO
+      // tick layout info
+      // TODO
+      // update dimensions info based on axis order.
+      this._axesLayout[dim] = {
+        position: position,
+        rotation: rotation,
+        transform: transform,
+        axisNameAvailableWidth: posInfo.axisNameAvailableWidth,
+        axisLabelShow: posInfo.axisLabelShow,
+        nameTruncateMaxWidth: posInfo.nameTruncateMaxWidth,
+        tickDirection: 1,
+        labelDirection: 1
+      };
+    }, this);
+  };
+  /**
+   * Get axis by dim.
+   */
+  Parallel.prototype.getAxis = function (dim) {
+    return this._axesMap.get(dim);
+  };
+  /**
+   * Convert a dim value of a single item of series data to Point.
+   */
+  Parallel.prototype.dataToPoint = function (value, dim) {
+    return this.axisCoordToPoint(this._axesMap.get(dim).dataToCoord(value), dim);
+  };
+  /**
+   * Travel data for one time, get activeState of each data item.
+   * @param start the start dataIndex that travel from.
+   * @param end the next dataIndex of the last dataIndex will be travel.
+   */
+  Parallel.prototype.eachActiveState = function (data, callback, start, end) {
+    start == null && (start = 0);
+    end == null && (end = data.count());
+    var axesMap = this._axesMap;
+    var dimensions = this.dimensions;
+    var dataDimensions = [];
+    var axisModels = [];
+    util.each(dimensions, function (axisDim) {
+      dataDimensions.push(data.mapDimension(axisDim));
+      axisModels.push(axesMap.get(axisDim).model);
+    });
+    var hasActiveSet = this.hasAxisBrushed();
+    for (var dataIndex = start; dataIndex < end; dataIndex++) {
+      var activeState = void 0;
+      if (!hasActiveSet) {
+        activeState = 'normal';
+      } else {
+        activeState = 'active';
+        var values = data.getValues(dataDimensions, dataIndex);
+        for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+          var state = axisModels[j].getActiveState(values[j]);
+          if (state === 'inactive') {
+            activeState = 'inactive';
+            break;
+          }
+        }
+      }
+      callback(activeState, dataIndex);
+    }
+  };
+  /**
+   * Whether has any activeSet.
+   */
+  Parallel.prototype.hasAxisBrushed = function () {
+    var dimensions = this.dimensions;
+    var axesMap = this._axesMap;
+    var hasActiveSet = false;
+    for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+      if (axesMap.get(dimensions[j]).model.getActiveState() !== 'normal') {
+        hasActiveSet = true;
+      }
+    }
+    return hasActiveSet;
+  };
+  /**
+   * Convert coords of each axis to Point.
+   *  Return point. For example: [10, 20]
+   */
+  Parallel.prototype.axisCoordToPoint = function (coord, dim) {
+    var axisLayout = this._axesLayout[dim];
+    return graphic.applyTransform([coord, 0], axisLayout.transform);
+  };
+  /**
+   * Get axis layout.
+   */
+  Parallel.prototype.getAxisLayout = function (dim) {
+    return util.clone(this._axesLayout[dim]);
+  };
+  /**
+   * @return {Object} {axisExpandWindow, delta, behavior: 'jump' | 'slide' | 'none'}.
+   */
+  Parallel.prototype.getSlidedAxisExpandWindow = function (point) {
+    var layoutInfo = this._makeLayoutInfo();
+    var pixelDimIndex = layoutInfo.pixelDimIndex;
+    var axisExpandWindow = layoutInfo.axisExpandWindow.slice();
+    var winSize = axisExpandWindow[1] - axisExpandWindow[0];
+    var extent = [0, layoutInfo.axisExpandWidth * (layoutInfo.axisCount - 1)];
+    // Out of the area of coordinate system.
+    if (!this.containPoint(point)) {
+      return {
+        behavior: 'none',
+        axisExpandWindow: axisExpandWindow
+      };
+    }
+    // Convert the point from global to expand coordinates.
+    var pointCoord = point[pixelDimIndex] - layoutInfo.layoutBase - layoutInfo.axisExpandWindow0Pos;
+    // For dragging operation convenience, the window should not be
+    // slided when mouse is the center area of the window.
+    var delta;
+    var behavior = 'slide';
+    var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+    var triggerArea = this._model.get('axisExpandSlideTriggerArea');
+    // But consider touch device, jump is necessary.
+    var useJump = triggerArea[0] != null;
+    if (axisCollapseWidth) {
+      if (useJump && axisCollapseWidth && pointCoord < winSize * triggerArea[0]) {
+        behavior = 'jump';
+        delta = pointCoord - winSize * triggerArea[2];
+      } else if (useJump && axisCollapseWidth && pointCoord > winSize * (1 - triggerArea[0])) {
+        behavior = 'jump';
+        delta = pointCoord - winSize * (1 - triggerArea[2]);
+      } else {
+        (delta = pointCoord - winSize * triggerArea[1]) >= 0 && (delta = pointCoord - winSize * (1 - triggerArea[1])) <= 0 && (delta = 0);
+      }
+      delta *= layoutInfo.axisExpandWidth / axisCollapseWidth;
+      delta ? sliderMove["default"](delta, axisExpandWindow, extent, 'all')
+      // Avoid nonsense triger on mousemove.
+      : behavior = 'none';
+    }
+    // When screen is too narrow, make it visible and slidable, although it is hard to interact.
+    else {
+      var winSize2 = axisExpandWindow[1] - axisExpandWindow[0];
+      var pos = extent[1] * pointCoord / winSize2;
+      axisExpandWindow = [mathMax(0, pos - winSize2 / 2)];
+      axisExpandWindow[1] = mathMin(extent[1], axisExpandWindow[0] + winSize2);
+      axisExpandWindow[0] = axisExpandWindow[1] - winSize2;
+    }
+    return {
+      axisExpandWindow: axisExpandWindow,
+      behavior: behavior
+    };
+  };
+  return Parallel;
+}();
+function restrict(len, extent) {
+  return mathMin(mathMax(len, extent[0]), extent[1]);
+}
+function layoutAxisWithoutExpand(axisIndex, layoutInfo) {
+  var step = layoutInfo.layoutLength / (layoutInfo.axisCount - 1);
+  return {
+    position: step * axisIndex,
+    axisNameAvailableWidth: step,
+    axisLabelShow: true
+  };
+}
+function layoutAxisWithExpand(axisIndex, layoutInfo) {
+  var layoutLength = layoutInfo.layoutLength;
+  var axisExpandWidth = layoutInfo.axisExpandWidth;
+  var axisCount = layoutInfo.axisCount;
+  var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+  var winInnerIndices = layoutInfo.winInnerIndices;
+  var position;
+  var axisNameAvailableWidth = axisCollapseWidth;
+  var axisLabelShow = false;
+  var nameTruncateMaxWidth;
+  if (axisIndex < winInnerIndices[0]) {
+    position = axisIndex * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  } else if (axisIndex <= winInnerIndices[1]) {
+    position = layoutInfo.axisExpandWindow0Pos + axisIndex * axisExpandWidth - layoutInfo.axisExpandWindow[0];
+    axisNameAvailableWidth = axisExpandWidth;
+    axisLabelShow = true;
+  } else {
+    position = layoutLength - (axisCount - 1 - axisIndex) * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  }
+  return {
+    position: position,
+    axisNameAvailableWidth: axisNameAvailableWidth,
+    axisLabelShow: axisLabelShow,
+    nameTruncateMaxWidth: nameTruncateMaxWidth
+  };
+}
+
+exports["default"] = Parallel;

package/lib/node_modules/echarts/lib/coord/parallel/ParallelAxis.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Axis = require('../Axis.js');
+
+var ParallelAxis = /** @class */function (_super) {
+  tslib.__extends(ParallelAxis, _super);
+  function ParallelAxis(dim, scale, coordExtent, axisType, axisIndex) {
+    var _this = _super.call(this, dim, scale, coordExtent) || this;
+    _this.type = axisType || 'value';
+    _this.axisIndex = axisIndex;
+    return _this;
+  }
+  ParallelAxis.prototype.isHorizontal = function () {
+    return this.coordinateSystem.getModel().get('layout') !== 'horizontal';
+  };
+  return ParallelAxis;
+}(Axis["default"]);
+
+exports["default"] = ParallelAxis;

package/lib/node_modules/echarts/lib/coord/parallel/ParallelModel.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var Component = require('../../model/Component.js');
+
+var ParallelModel = /** @class */function (_super) {
+  tslib.__extends(ParallelModel, _super);
+  function ParallelModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ParallelModel.type;
+    return _this;
+  }
+  ParallelModel.prototype.init = function () {
+    _super.prototype.init.apply(this, arguments);
+    this.mergeOption({});
+  };
+  ParallelModel.prototype.mergeOption = function (newOption) {
+    var thisOption = this.option;
+    newOption && util.merge(thisOption, newOption, true);
+    this._initDimensions();
+  };
+  /**
+   * Whether series or axis is in this coordinate system.
+   */
+  ParallelModel.prototype.contains = function (model, ecModel) {
+    var parallelIndex = model.get('parallelIndex');
+    return parallelIndex != null && ecModel.getComponent('parallel', parallelIndex) === this;
+  };
+  ParallelModel.prototype.setAxisExpand = function (opt) {
+    util.each(['axisExpandable', 'axisExpandCenter', 'axisExpandCount', 'axisExpandWidth', 'axisExpandWindow'], function (name) {
+      if (opt.hasOwnProperty(name)) {
+        // @ts-ignore FIXME: why "never" inferred in this.option[name]?
+        this.option[name] = opt[name];
+      }
+    }, this);
+  };
+  ParallelModel.prototype._initDimensions = function () {
+    var dimensions = this.dimensions = [];
+    var parallelAxisIndex = this.parallelAxisIndex = [];
+    var axisModels = util.filter(this.ecModel.queryComponents({
+      mainType: 'parallelAxis'
+    }), function (axisModel) {
+      // Can not use this.contains here, because
+      // initialization has not been completed yet.
+      return (axisModel.get('parallelIndex') || 0) === this.componentIndex;
+    }, this);
+    util.each(axisModels, function (axisModel) {
+      dimensions.push('dim' + axisModel.get('dim'));
+      parallelAxisIndex.push(axisModel.componentIndex);
+    });
+  };
+  ParallelModel.type = 'parallel';
+  ParallelModel.dependencies = ['parallelAxis'];
+  ParallelModel.layoutMode = 'box';
+  ParallelModel.defaultOption = {
+    // zlevel: 0,
+    z: 0,
+    left: 80,
+    top: 60,
+    right: 80,
+    bottom: 60,
+    // width: {totalWidth} - left - right,
+    // height: {totalHeight} - top - bottom,
+    layout: 'horizontal',
+    // FIXME
+    // naming?
+    axisExpandable: false,
+    axisExpandCenter: null,
+    axisExpandCount: 0,
+    axisExpandWidth: 50,
+    axisExpandRate: 17,
+    axisExpandDebounce: 50,
+    // [out, in, jumpTarget]. In percentage. If use [null, 0.05], null means full.
+    // Do not doc to user until necessary.
+    axisExpandSlideTriggerArea: [-0.15, 0.05, 0.4],
+    axisExpandTriggerOn: 'click',
+    parallelAxisDefault: null
+  };
+  return ParallelModel;
+}(Component["default"]);
+
+exports["default"] = ParallelModel;

package/lib/node_modules/echarts/lib/coord/parallel/parallelCreator.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Parallel = require('./Parallel.js');
+var model = require('../../util/model.js');
+
+function createParallelCoordSys(ecModel, api) {
+  var coordSysList = [];
+  ecModel.eachComponent('parallel', function (parallelModel, idx) {
+    var coordSys = new Parallel["default"](parallelModel, ecModel, api);
+    coordSys.name = 'parallel_' + idx;
+    coordSys.resize(parallelModel, api);
+    parallelModel.coordinateSystem = coordSys;
+    coordSys.model = parallelModel;
+    coordSysList.push(coordSys);
+  });
+  // Inject the coordinateSystems into seriesModel
+  ecModel.eachSeries(function (seriesModel) {
+    if (seriesModel.get('coordinateSystem') === 'parallel') {
+      var parallelModel = seriesModel.getReferringComponents('parallel', model.SINGLE_REFERRING).models[0];
+      seriesModel.coordinateSystem = parallelModel.coordinateSystem;
+    }
+  });
+  return coordSysList;
+}
+var parallelCoordSysCreator = {
+  create: createParallelCoordSys
+};
+
+exports["default"] = parallelCoordSysCreator;

package/lib/node_modules/echarts/lib/coord/parallel/parallelPreprocessor.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+
+function parallelPreprocessor(option) {
+  createParallelIfNeeded(option);
+  mergeAxisOptionFromParallel(option);
+}
+/**
+ * Create a parallel coordinate if not exists.
+ * @inner
+ */
+function createParallelIfNeeded(option) {
+  if (option.parallel) {
+    return;
+  }
+  var hasParallelSeries = false;
+  util.each(option.series, function (seriesOpt) {
+    if (seriesOpt && seriesOpt.type === 'parallel') {
+      hasParallelSeries = true;
+    }
+  });
+  if (hasParallelSeries) {
+    option.parallel = [{}];
+  }
+}
+/**
+ * Merge aixs definition from parallel option (if exists) to axis option.
+ * @inner
+ */
+function mergeAxisOptionFromParallel(option) {
+  var axes = model.normalizeToArray(option.parallelAxis);
+  util.each(axes, function (axisOption) {
+    if (!util.isObject(axisOption)) {
+      return;
+    }
+    var parallelIndex = axisOption.parallelIndex || 0;
+    var parallelOption = model.normalizeToArray(option.parallel)[parallelIndex];
+    if (parallelOption && parallelOption.parallelAxisDefault) {
+      util.merge(axisOption, parallelOption.parallelAxisDefault, false);
+    }
+  });
+}
+
+exports["default"] = parallelPreprocessor;

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

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var text = require('../../../../zrender/lib/contain/text.js');
+var Axis = require('../Axis.js');
+var model = require('../../util/model.js');
+
+var inner = model.makeInner();
+var AngleAxis = /** @class */function (_super) {
+  tslib.__extends(AngleAxis, _super);
+  function AngleAxis(scale, angleExtent) {
+    return _super.call(this, 'angle', scale, angleExtent || [0, 360]) || this;
+  }
+  AngleAxis.prototype.pointToData = function (point, clamp) {
+    return this.polar.pointToData(point, clamp)[this.dim === 'radius' ? 0 : 1];
+  };
+  /**
+   * 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
+   */
+  AngleAxis.prototype.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 = text.getBoundingRect(tickValue == null ? '' : 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;
+  };
+  return AngleAxis;
+}(Axis["default"]);
+AngleAxis.prototype.dataToAngle = Axis["default"].prototype.dataToCoord;
+AngleAxis.prototype.angleToData = Axis["default"].prototype.coordToData;
+
+exports["default"] = AngleAxis;

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

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var Component = require('../../model/Component.js');
+var axisModelCommonMixin = require('../axisModelCommonMixin.js');
+var model = require('../../util/model.js');
+
+var PolarAxisModel = /** @class */function (_super) {
+  tslib.__extends(PolarAxisModel, _super);
+  function PolarAxisModel() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  PolarAxisModel.prototype.getCoordSysModel = function () {
+    return this.getReferringComponents('polar', model.SINGLE_REFERRING).models[0];
+  };
+  PolarAxisModel.type = 'polarAxis';
+  return PolarAxisModel;
+}(Component["default"]);
+util.mixin(PolarAxisModel, axisModelCommonMixin.AxisModelCommonMixin);
+var AngleAxisModel = /** @class */function (_super) {
+  tslib.__extends(AngleAxisModel, _super);
+  function AngleAxisModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = AngleAxisModel.type;
+    return _this;
+  }
+  AngleAxisModel.type = 'angleAxis';
+  return AngleAxisModel;
+}(PolarAxisModel);
+var RadiusAxisModel = /** @class */function (_super) {
+  tslib.__extends(RadiusAxisModel, _super);
+  function RadiusAxisModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = RadiusAxisModel.type;
+    return _this;
+  }
+  RadiusAxisModel.type = 'radiusAxis';
+  return RadiusAxisModel;
+}(PolarAxisModel);
+
+exports.AngleAxisModel = AngleAxisModel;
+exports.PolarAxisModel = PolarAxisModel;
+exports.RadiusAxisModel = RadiusAxisModel;