office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/component/calendar/CalendarView.js

@@ -0,0 +1,352 @@
+import { __extends } from 'tslib';
+import { isString, isFunction, extend, map } from '../../../../zrender/lib/core/util.js';
+import '../../util/graphic.js';
+import { createTextStyle } from '../../label/labelStyle.js';
+import { formatTplSimple } from '../../util/format.js';
+import { parsePercent } from '../../util/number.js';
+import ComponentView from '../../view/Component.js';
+import { getLocaleModel } from '../../core/locale.js';
+import Rect from '../../../../zrender/lib/graphic/shape/Rect.js';
+import Polyline from '../../../../zrender/lib/graphic/shape/Polyline.js';
+import ZRText from '../../../../zrender/lib/graphic/Text.js';
+
+var CalendarView = /** @class */function (_super) {
+  __extends(CalendarView, _super);
+  function CalendarView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CalendarView.type;
+    return _this;
+  }
+  CalendarView.prototype.render = function (calendarModel, ecModel, api) {
+    var group = this.group;
+    group.removeAll();
+    var coordSys = calendarModel.coordinateSystem;
+    // range info
+    var rangeData = coordSys.getRangeInfo();
+    var orient = coordSys.getOrient();
+    // locale
+    var localeModel = ecModel.getLocaleModel();
+    this._renderDayRect(calendarModel, rangeData, group);
+    // _renderLines must be called prior to following function
+    this._renderLines(calendarModel, rangeData, orient, group);
+    this._renderYearText(calendarModel, rangeData, orient, group);
+    this._renderMonthText(calendarModel, localeModel, orient, group);
+    this._renderWeekText(calendarModel, localeModel, rangeData, orient, group);
+  };
+  // render day rect
+  CalendarView.prototype._renderDayRect = function (calendarModel, rangeData, group) {
+    var coordSys = calendarModel.coordinateSystem;
+    var itemRectStyleModel = calendarModel.getModel('itemStyle').getItemStyle();
+    var sw = coordSys.getCellWidth();
+    var sh = coordSys.getCellHeight();
+    for (var i = rangeData.start.time; i <= rangeData.end.time; i = coordSys.getNextNDay(i, 1).time) {
+      var point = coordSys.dataToRect([i], false).tl;
+      // every rect
+      var rect = new Rect({
+        shape: {
+          x: point[0],
+          y: point[1],
+          width: sw,
+          height: sh
+        },
+        cursor: 'default',
+        style: itemRectStyleModel
+      });
+      group.add(rect);
+    }
+  };
+  // render separate line
+  CalendarView.prototype._renderLines = function (calendarModel, rangeData, orient, group) {
+    var self = this;
+    var coordSys = calendarModel.coordinateSystem;
+    var lineStyleModel = calendarModel.getModel(['splitLine', 'lineStyle']).getLineStyle();
+    var show = calendarModel.get(['splitLine', 'show']);
+    var lineWidth = lineStyleModel.lineWidth;
+    this._tlpoints = [];
+    this._blpoints = [];
+    this._firstDayOfMonth = [];
+    this._firstDayPoints = [];
+    var firstDay = rangeData.start;
+    for (var i = 0; firstDay.time <= rangeData.end.time; i++) {
+      addPoints(firstDay.formatedDate);
+      if (i === 0) {
+        firstDay = coordSys.getDateInfo(rangeData.start.y + '-' + rangeData.start.m);
+      }
+      var date = firstDay.date;
+      date.setMonth(date.getMonth() + 1);
+      firstDay = coordSys.getDateInfo(date);
+    }
+    addPoints(coordSys.getNextNDay(rangeData.end.time, 1).formatedDate);
+    function addPoints(date) {
+      self._firstDayOfMonth.push(coordSys.getDateInfo(date));
+      self._firstDayPoints.push(coordSys.dataToRect([date], false).tl);
+      var points = self._getLinePointsOfOneWeek(calendarModel, date, orient);
+      self._tlpoints.push(points[0]);
+      self._blpoints.push(points[points.length - 1]);
+      show && self._drawSplitline(points, lineStyleModel, group);
+    }
+    // render top/left line
+    show && this._drawSplitline(self._getEdgesPoints(self._tlpoints, lineWidth, orient), lineStyleModel, group);
+    // render bottom/right line
+    show && this._drawSplitline(self._getEdgesPoints(self._blpoints, lineWidth, orient), lineStyleModel, group);
+  };
+  // get points at both ends
+  CalendarView.prototype._getEdgesPoints = function (points, lineWidth, orient) {
+    var rs = [points[0].slice(), points[points.length - 1].slice()];
+    var idx = orient === 'horizontal' ? 0 : 1;
+    // both ends of the line are extend half lineWidth
+    rs[0][idx] = rs[0][idx] - lineWidth / 2;
+    rs[1][idx] = rs[1][idx] + lineWidth / 2;
+    return rs;
+  };
+  // render split line
+  CalendarView.prototype._drawSplitline = function (points, lineStyle, group) {
+    var poyline = new Polyline({
+      z2: 20,
+      shape: {
+        points: points
+      },
+      style: lineStyle
+    });
+    group.add(poyline);
+  };
+  // render month line of one week points
+  CalendarView.prototype._getLinePointsOfOneWeek = function (calendarModel, date, orient) {
+    var coordSys = calendarModel.coordinateSystem;
+    var parsedDate = coordSys.getDateInfo(date);
+    var points = [];
+    for (var i = 0; i < 7; i++) {
+      var tmpD = coordSys.getNextNDay(parsedDate.time, i);
+      var point = coordSys.dataToRect([tmpD.time], false);
+      points[2 * tmpD.day] = point.tl;
+      points[2 * tmpD.day + 1] = point[orient === 'horizontal' ? 'bl' : 'tr'];
+    }
+    return points;
+  };
+  CalendarView.prototype._formatterLabel = function (formatter, params) {
+    if (isString(formatter) && formatter) {
+      return formatTplSimple(formatter, params);
+    }
+    if (isFunction(formatter)) {
+      return formatter(params);
+    }
+    return params.nameMap;
+  };
+  CalendarView.prototype._yearTextPositionControl = function (textEl, point, orient, position, margin) {
+    var x = point[0];
+    var y = point[1];
+    var aligns = ['center', 'bottom'];
+    if (position === 'bottom') {
+      y += margin;
+      aligns = ['center', 'top'];
+    } else if (position === 'left') {
+      x -= margin;
+    } else if (position === 'right') {
+      x += margin;
+      aligns = ['center', 'top'];
+    } else {
+      // top
+      y -= margin;
+    }
+    var rotate = 0;
+    if (position === 'left' || position === 'right') {
+      rotate = Math.PI / 2;
+    }
+    return {
+      rotation: rotate,
+      x: x,
+      y: y,
+      style: {
+        align: aligns[0],
+        verticalAlign: aligns[1]
+      }
+    };
+  };
+  // render year
+  CalendarView.prototype._renderYearText = function (calendarModel, rangeData, orient, group) {
+    var yearLabel = calendarModel.getModel('yearLabel');
+    if (!yearLabel.get('show')) {
+      return;
+    }
+    var margin = yearLabel.get('margin');
+    var pos = yearLabel.get('position');
+    if (!pos) {
+      pos = orient !== 'horizontal' ? 'top' : 'left';
+    }
+    var points = [this._tlpoints[this._tlpoints.length - 1], this._blpoints[0]];
+    var xc = (points[0][0] + points[1][0]) / 2;
+    var yc = (points[0][1] + points[1][1]) / 2;
+    var idx = orient === 'horizontal' ? 0 : 1;
+    var posPoints = {
+      top: [xc, points[idx][1]],
+      bottom: [xc, points[1 - idx][1]],
+      left: [points[1 - idx][0], yc],
+      right: [points[idx][0], yc]
+    };
+    var name = rangeData.start.y;
+    if (+rangeData.end.y > +rangeData.start.y) {
+      name = name + '-' + rangeData.end.y;
+    }
+    var formatter = yearLabel.get('formatter');
+    var params = {
+      start: rangeData.start.y,
+      end: rangeData.end.y,
+      nameMap: name
+    };
+    var content = this._formatterLabel(formatter, params);
+    var yearText = new ZRText({
+      z2: 30,
+      style: createTextStyle(yearLabel, {
+        text: content
+      })
+    });
+    yearText.attr(this._yearTextPositionControl(yearText, posPoints[pos], orient, pos, margin));
+    group.add(yearText);
+  };
+  CalendarView.prototype._monthTextPositionControl = function (point, isCenter, orient, position, margin) {
+    var align = 'left';
+    var vAlign = 'top';
+    var x = point[0];
+    var y = point[1];
+    if (orient === 'horizontal') {
+      y = y + margin;
+      if (isCenter) {
+        align = 'center';
+      }
+      if (position === 'start') {
+        vAlign = 'bottom';
+      }
+    } else {
+      x = x + margin;
+      if (isCenter) {
+        vAlign = 'middle';
+      }
+      if (position === 'start') {
+        align = 'right';
+      }
+    }
+    return {
+      x: x,
+      y: y,
+      align: align,
+      verticalAlign: vAlign
+    };
+  };
+  // render month and year text
+  CalendarView.prototype._renderMonthText = function (calendarModel, localeModel, orient, group) {
+    var monthLabel = calendarModel.getModel('monthLabel');
+    if (!monthLabel.get('show')) {
+      return;
+    }
+    var nameMap = monthLabel.get('nameMap');
+    var margin = monthLabel.get('margin');
+    var pos = monthLabel.get('position');
+    var align = monthLabel.get('align');
+    var termPoints = [this._tlpoints, this._blpoints];
+    if (!nameMap || isString(nameMap)) {
+      if (nameMap) {
+        // case-sensitive
+        localeModel = getLocaleModel(nameMap) || localeModel;
+      }
+      // PENDING
+      // for ZH locale, original form is `一月` but current form is `1月`
+      nameMap = localeModel.get(['time', 'monthAbbr']) || [];
+    }
+    var idx = pos === 'start' ? 0 : 1;
+    var axis = orient === 'horizontal' ? 0 : 1;
+    margin = pos === 'start' ? -margin : margin;
+    var isCenter = align === 'center';
+    for (var i = 0; i < termPoints[idx].length - 1; i++) {
+      var tmp = termPoints[idx][i].slice();
+      var firstDay = this._firstDayOfMonth[i];
+      if (isCenter) {
+        var firstDayPoints = this._firstDayPoints[i];
+        tmp[axis] = (firstDayPoints[axis] + termPoints[0][i + 1][axis]) / 2;
+      }
+      var formatter = monthLabel.get('formatter');
+      var name_1 = nameMap[+firstDay.m - 1];
+      var params = {
+        yyyy: firstDay.y,
+        yy: (firstDay.y + '').slice(2),
+        MM: firstDay.m,
+        M: +firstDay.m,
+        nameMap: name_1
+      };
+      var content = this._formatterLabel(formatter, params);
+      var monthText = new ZRText({
+        z2: 30,
+        style: extend(createTextStyle(monthLabel, {
+          text: content
+        }), this._monthTextPositionControl(tmp, isCenter, orient, pos, margin))
+      });
+      group.add(monthText);
+    }
+  };
+  CalendarView.prototype._weekTextPositionControl = function (point, orient, position, margin, cellSize) {
+    var align = 'center';
+    var vAlign = 'middle';
+    var x = point[0];
+    var y = point[1];
+    var isStart = position === 'start';
+    if (orient === 'horizontal') {
+      x = x + margin + (isStart ? 1 : -1) * cellSize[0] / 2;
+      align = isStart ? 'right' : 'left';
+    } else {
+      y = y + margin + (isStart ? 1 : -1) * cellSize[1] / 2;
+      vAlign = isStart ? 'bottom' : 'top';
+    }
+    return {
+      x: x,
+      y: y,
+      align: align,
+      verticalAlign: vAlign
+    };
+  };
+  // render weeks
+  CalendarView.prototype._renderWeekText = function (calendarModel, localeModel, rangeData, orient, group) {
+    var dayLabel = calendarModel.getModel('dayLabel');
+    if (!dayLabel.get('show')) {
+      return;
+    }
+    var coordSys = calendarModel.coordinateSystem;
+    var pos = dayLabel.get('position');
+    var nameMap = dayLabel.get('nameMap');
+    var margin = dayLabel.get('margin');
+    var firstDayOfWeek = coordSys.getFirstDayOfWeek();
+    if (!nameMap || isString(nameMap)) {
+      if (nameMap) {
+        // case-sensitive
+        localeModel = getLocaleModel(nameMap) || localeModel;
+      }
+      // Use the first letter of `dayOfWeekAbbr` if `dayOfWeekShort` doesn't exist in the locale file
+      var dayOfWeekShort = localeModel.get(['time', 'dayOfWeekShort']);
+      nameMap = dayOfWeekShort || map(localeModel.get(['time', 'dayOfWeekAbbr']), function (val) {
+        return val[0];
+      });
+    }
+    var start = coordSys.getNextNDay(rangeData.end.time, 7 - rangeData.lweek).time;
+    var cellSize = [coordSys.getCellWidth(), coordSys.getCellHeight()];
+    margin = parsePercent(margin, Math.min(cellSize[1], cellSize[0]));
+    if (pos === 'start') {
+      start = coordSys.getNextNDay(rangeData.start.time, -(7 + rangeData.fweek)).time;
+      margin = -margin;
+    }
+    for (var i = 0; i < 7; i++) {
+      var tmpD = coordSys.getNextNDay(start, i);
+      var point = coordSys.dataToRect([tmpD.time], false).center;
+      var day = i;
+      day = Math.abs((i + firstDayOfWeek) % 7);
+      var weekText = new ZRText({
+        z2: 30,
+        style: extend(createTextStyle(dayLabel, {
+          text: nameMap[day]
+        }), this._weekTextPositionControl(point, orient, pos, margin, cellSize))
+      });
+      group.add(weekText);
+    }
+  };
+  CalendarView.type = 'calendar';
+  return CalendarView;
+}(ComponentView);
+
+export { CalendarView as default };

package/esm/node_modules/echarts/lib/component/calendar/install.js

@@ -0,0 +1,11 @@
+import CalendarModel from '../../coord/calendar/CalendarModel.js';
+import CalendarView from './CalendarView.js';
+import Calendar from '../../coord/calendar/Calendar.js';
+
+function install(registers) {
+  registers.registerComponentModel(CalendarModel);
+  registers.registerComponentView(CalendarView);
+  registers.registerCoordinateSystem('calendar', Calendar);
+}
+
+export { install };

package/esm/node_modules/echarts/lib/component/dataZoom/AxisProxy.js

@@ -0,0 +1,301 @@
+import { clone, map, each as each$1 } from '../../../../zrender/lib/core/util.js';
+import { linearMap, getPixelPrecision, asc as asc$1 } from '../../util/number.js';
+import sliderMove from '../helper/sliderMove.js';
+import { unionAxisExtentFromData } from '../../coord/axisHelper.js';
+import { ensureScaleRawExtentInfo } from '../../coord/scaleRawExtentInfo.js';
+import { isCoordSupported, getAxisMainType } from './helper.js';
+import { SINGLE_REFERRING } from '../../util/model.js';
+
+var each = each$1;
+var asc = asc$1;
+/**
+ * Operate single axis.
+ * One axis can only operated by one axis operator.
+ * Different dataZoomModels may be defined to operate the same axis.
+ * (i.e. 'inside' data zoom and 'slider' data zoom components)
+ * So dataZoomModels share one axisProxy in that case.
+ */
+var AxisProxy = /** @class */function () {
+  function AxisProxy(dimName, axisIndex, dataZoomModel, ecModel) {
+    this._dimName = dimName;
+    this._axisIndex = axisIndex;
+    this.ecModel = ecModel;
+    this._dataZoomModel = dataZoomModel;
+    // /**
+    //  * @readOnly
+    //  * @private
+    //  */
+    // this.hasSeriesStacked;
+  }
+  /**
+   * Whether the axisProxy is hosted by dataZoomModel.
+   */
+  AxisProxy.prototype.hostedBy = function (dataZoomModel) {
+    return this._dataZoomModel === dataZoomModel;
+  };
+  /**
+   * @return Value can only be NaN or finite value.
+   */
+  AxisProxy.prototype.getDataValueWindow = function () {
+    return this._valueWindow.slice();
+  };
+  /**
+   * @return {Array.<number>}
+   */
+  AxisProxy.prototype.getDataPercentWindow = function () {
+    return this._percentWindow.slice();
+  };
+  AxisProxy.prototype.getTargetSeriesModels = function () {
+    var seriesModels = [];
+    this.ecModel.eachSeries(function (seriesModel) {
+      if (isCoordSupported(seriesModel)) {
+        var axisMainType = getAxisMainType(this._dimName);
+        var axisModel = seriesModel.getReferringComponents(axisMainType, SINGLE_REFERRING).models[0];
+        if (axisModel && this._axisIndex === axisModel.componentIndex) {
+          seriesModels.push(seriesModel);
+        }
+      }
+    }, this);
+    return seriesModels;
+  };
+  AxisProxy.prototype.getAxisModel = function () {
+    return this.ecModel.getComponent(this._dimName + 'Axis', this._axisIndex);
+  };
+  AxisProxy.prototype.getMinMaxSpan = function () {
+    return clone(this._minMaxSpan);
+  };
+  /**
+   * Only calculate by given range and this._dataExtent, do not change anything.
+   */
+  AxisProxy.prototype.calculateDataWindow = function (opt) {
+    var dataExtent = this._dataExtent;
+    var axisModel = this.getAxisModel();
+    var scale = axisModel.axis.scale;
+    var rangePropMode = this._dataZoomModel.getRangePropMode();
+    var percentExtent = [0, 100];
+    var percentWindow = [];
+    var valueWindow = [];
+    var hasPropModeValue;
+    each(['start', 'end'], function (prop, idx) {
+      var boundPercent = opt[prop];
+      var boundValue = opt[prop + 'Value'];
+      // Notice: dataZoom is based either on `percentProp` ('start', 'end') or
+      // on `valueProp` ('startValue', 'endValue'). (They are based on the data extent
+      // but not min/max of axis, which will be calculated by data window then).
+      // The former one is suitable for cases that a dataZoom component controls multiple
+      // axes with different unit or extent, and the latter one is suitable for accurate
+      // zoom by pixel (e.g., in dataZoomSelect).
+      // we use `getRangePropMode()` to mark which prop is used. `rangePropMode` is updated
+      // only when setOption or dispatchAction, otherwise it remains its original value.
+      // (Why not only record `percentProp` and always map to `valueProp`? Because
+      // the map `valueProp` -> `percentProp` -> `valueProp` probably not the original
+      // `valueProp`. consider two axes constrolled by one dataZoom. They have different
+      // data extent. All of values that are overflow the `dataExtent` will be calculated
+      // to percent '100%').
+      if (rangePropMode[idx] === 'percent') {
+        boundPercent == null && (boundPercent = percentExtent[idx]);
+        // Use scale.parse to math round for category or time axis.
+        boundValue = scale.parse(linearMap(boundPercent, percentExtent, dataExtent));
+      } else {
+        hasPropModeValue = true;
+        boundValue = boundValue == null ? dataExtent[idx] : scale.parse(boundValue);
+        // Calculating `percent` from `value` may be not accurate, because
+        // This calculation can not be inversed, because all of values that
+        // are overflow the `dataExtent` will be calculated to percent '100%'
+        boundPercent = linearMap(boundValue, dataExtent, percentExtent);
+      }
+      // valueWindow[idx] = round(boundValue);
+      // percentWindow[idx] = round(boundPercent);
+      // fallback to extent start/end when parsed value or percent is invalid
+      valueWindow[idx] = boundValue == null || isNaN(boundValue) ? dataExtent[idx] : boundValue;
+      percentWindow[idx] = boundPercent == null || isNaN(boundPercent) ? percentExtent[idx] : boundPercent;
+    });
+    asc(valueWindow);
+    asc(percentWindow);
+    // The windows from user calling of `dispatchAction` might be out of the extent,
+    // or do not obey the `min/maxSpan`, `min/maxValueSpan`. But we don't restrict window
+    // by `zoomLock` here, because we see `zoomLock` just as a interaction constraint,
+    // where API is able to initialize/modify the window size even though `zoomLock`
+    // specified.
+    var spans = this._minMaxSpan;
+    hasPropModeValue ? restrictSet(valueWindow, percentWindow, dataExtent, percentExtent, false) : restrictSet(percentWindow, valueWindow, percentExtent, dataExtent, true);
+    function restrictSet(fromWindow, toWindow, fromExtent, toExtent, toValue) {
+      var suffix = toValue ? 'Span' : 'ValueSpan';
+      sliderMove(0, fromWindow, fromExtent, 'all', spans['min' + suffix], spans['max' + suffix]);
+      for (var i = 0; i < 2; i++) {
+        toWindow[i] = linearMap(fromWindow[i], fromExtent, toExtent, true);
+        toValue && (toWindow[i] = scale.parse(toWindow[i]));
+      }
+    }
+    return {
+      valueWindow: valueWindow,
+      percentWindow: percentWindow
+    };
+  };
+  /**
+   * Notice: reset should not be called before series.restoreData() is called,
+   * so it is recommended to be called in "process stage" but not "model init
+   * stage".
+   */
+  AxisProxy.prototype.reset = function (dataZoomModel) {
+    if (dataZoomModel !== this._dataZoomModel) {
+      return;
+    }
+    var targetSeries = this.getTargetSeriesModels();
+    // Culculate data window and data extent, and record them.
+    this._dataExtent = calculateDataExtent(this, this._dimName, targetSeries);
+    // `calculateDataWindow` uses min/maxSpan.
+    this._updateMinMaxSpan();
+    var dataWindow = this.calculateDataWindow(dataZoomModel.settledOption);
+    this._valueWindow = dataWindow.valueWindow;
+    this._percentWindow = dataWindow.percentWindow;
+    // Update axis setting then.
+    this._setAxisModel();
+  };
+  AxisProxy.prototype.filterData = function (dataZoomModel, api) {
+    if (dataZoomModel !== this._dataZoomModel) {
+      return;
+    }
+    var axisDim = this._dimName;
+    var seriesModels = this.getTargetSeriesModels();
+    var filterMode = dataZoomModel.get('filterMode');
+    var valueWindow = this._valueWindow;
+    if (filterMode === 'none') {
+      return;
+    }
+    // FIXME
+    // Toolbox may has dataZoom injected. And if there are stacked bar chart
+    // with NaN data, NaN will be filtered and stack will be wrong.
+    // So we need to force the mode to be set empty.
+    // In fect, it is not a big deal that do not support filterMode-'filter'
+    // when using toolbox#dataZoom, utill tooltip#dataZoom support "single axis
+    // selection" some day, which might need "adapt to data extent on the
+    // otherAxis", which is disabled by filterMode-'empty'.
+    // But currently, stack has been fixed to based on value but not index,
+    // so this is not an issue any more.
+    // let otherAxisModel = this.getOtherAxisModel();
+    // if (dataZoomModel.get('$fromToolbox')
+    //     && otherAxisModel
+    //     && otherAxisModel.hasSeriesStacked
+    // ) {
+    //     filterMode = 'empty';
+    // }
+    // TODO
+    // filterMode 'weakFilter' and 'empty' is not optimized for huge data yet.
+    each(seriesModels, function (seriesModel) {
+      var seriesData = seriesModel.getData();
+      var dataDims = seriesData.mapDimensionsAll(axisDim);
+      if (!dataDims.length) {
+        return;
+      }
+      if (filterMode === 'weakFilter') {
+        var store_1 = seriesData.getStore();
+        var dataDimIndices_1 = map(dataDims, function (dim) {
+          return seriesData.getDimensionIndex(dim);
+        }, seriesData);
+        seriesData.filterSelf(function (dataIndex) {
+          var leftOut;
+          var rightOut;
+          var hasValue;
+          for (var i = 0; i < dataDims.length; i++) {
+            var value = store_1.get(dataDimIndices_1[i], dataIndex);
+            var thisHasValue = !isNaN(value);
+            var thisLeftOut = value < valueWindow[0];
+            var thisRightOut = value > valueWindow[1];
+            if (thisHasValue && !thisLeftOut && !thisRightOut) {
+              return true;
+            }
+            thisHasValue && (hasValue = true);
+            thisLeftOut && (leftOut = true);
+            thisRightOut && (rightOut = true);
+          }
+          // If both left out and right out, do not filter.
+          return hasValue && leftOut && rightOut;
+        });
+      } else {
+        each(dataDims, function (dim) {
+          if (filterMode === 'empty') {
+            seriesModel.setData(seriesData = seriesData.map(dim, function (value) {
+              return !isInWindow(value) ? NaN : value;
+            }));
+          } else {
+            var range = {};
+            range[dim] = valueWindow;
+            // console.time('select');
+            seriesData.selectRange(range);
+            // console.timeEnd('select');
+          }
+        });
+      }
+
+      each(dataDims, function (dim) {
+        seriesData.setApproximateExtent(valueWindow, dim);
+      });
+    });
+    function isInWindow(value) {
+      return value >= valueWindow[0] && value <= valueWindow[1];
+    }
+  };
+  AxisProxy.prototype._updateMinMaxSpan = function () {
+    var minMaxSpan = this._minMaxSpan = {};
+    var dataZoomModel = this._dataZoomModel;
+    var dataExtent = this._dataExtent;
+    each(['min', 'max'], function (minMax) {
+      var percentSpan = dataZoomModel.get(minMax + 'Span');
+      var valueSpan = dataZoomModel.get(minMax + 'ValueSpan');
+      valueSpan != null && (valueSpan = this.getAxisModel().axis.scale.parse(valueSpan));
+      // minValueSpan and maxValueSpan has higher priority than minSpan and maxSpan
+      if (valueSpan != null) {
+        percentSpan = linearMap(dataExtent[0] + valueSpan, dataExtent, [0, 100], true);
+      } else if (percentSpan != null) {
+        valueSpan = linearMap(percentSpan, [0, 100], dataExtent, true) - dataExtent[0];
+      }
+      minMaxSpan[minMax + 'Span'] = percentSpan;
+      minMaxSpan[minMax + 'ValueSpan'] = valueSpan;
+    }, this);
+  };
+  AxisProxy.prototype._setAxisModel = function () {
+    var axisModel = this.getAxisModel();
+    var percentWindow = this._percentWindow;
+    var valueWindow = this._valueWindow;
+    if (!percentWindow) {
+      return;
+    }
+    // [0, 500]: arbitrary value, guess axis extent.
+    var precision = getPixelPrecision(valueWindow, [0, 500]);
+    precision = Math.min(precision, 20);
+    // For value axis, if min/max/scale are not set, we just use the extent obtained
+    // by series data, which may be a little different from the extent calculated by
+    // `axisHelper.getScaleExtent`. But the different just affects the experience a
+    // little when zooming. So it will not be fixed until some users require it strongly.
+    var rawExtentInfo = axisModel.axis.scale.rawExtentInfo;
+    if (percentWindow[0] !== 0) {
+      rawExtentInfo.setDeterminedMinMax('min', +valueWindow[0].toFixed(precision));
+    }
+    if (percentWindow[1] !== 100) {
+      rawExtentInfo.setDeterminedMinMax('max', +valueWindow[1].toFixed(precision));
+    }
+    rawExtentInfo.freeze();
+  };
+  return AxisProxy;
+}();
+function calculateDataExtent(axisProxy, axisDim, seriesModels) {
+  var dataExtent = [Infinity, -Infinity];
+  each(seriesModels, function (seriesModel) {
+    unionAxisExtentFromData(dataExtent, seriesModel.getData(), axisDim);
+  });
+  // It is important to get "consistent" extent when more then one axes is
+  // controlled by a `dataZoom`, otherwise those axes will not be synchronized
+  // when zooming. But it is difficult to know what is "consistent", considering
+  // axes have different type or even different meanings (For example, two
+  // time axes are used to compare data of the same date in different years).
+  // So basically dataZoom just obtains extent by series.data (in category axis
+  // extent can be obtained from axis.data).
+  // Nevertheless, user can set min/max/scale on axes to make extent of axes
+  // consistent.
+  var axisModel = axisProxy.getAxisModel();
+  var rawExtentResult = ensureScaleRawExtentInfo(axisModel.axis.scale, axisModel, dataExtent).calculate();
+  return [rawExtentResult.min, rawExtentResult.max];
+}
+
+export { AxisProxy as default };