@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/modelHelper.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Model = require("../../model/Model.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function collect(ecModel, api) {
+  var result = {
+    /**
+     * key: makeKey(axis.model)
+     * value: {
+     *      axis,
+     *      coordSys,
+     *      axisPointerModel,
+     *      triggerTooltip,
+     *      triggerEmphasis,
+     *      involveSeries,
+     *      snap,
+     *      seriesModels,
+     *      seriesDataCount
+     * }
+     */
+    axesInfo: {},
+    seriesInvolved: false,
+    /**
+     * key: makeKey(coordSys.model)
+     * value: Object: key makeKey(axis.model), value: axisInfo
+     */
+    coordSysAxesInfo: {},
+    coordSysMap: {}
+  };
+  collectAxesInfo(result, ecModel, api);
+  result.seriesInvolved && collectSeriesInfo(result, ecModel);
+  return result;
+}
+function collectAxesInfo(result, ecModel, api) {
+  var globalTooltipModel = ecModel.getComponent("tooltip");
+  var globalAxisPointerModel = ecModel.getComponent("axisPointer");
+  var linksOption = globalAxisPointerModel.get("link", true) || [];
+  var linkGroups = [];
+  util.each(api.getCoordinateSystems(), function(coordSys) {
+    if (!coordSys.axisPointerEnabled) {
+      return;
+    }
+    var coordSysKey = makeKey(coordSys.model);
+    var axesInfoInCoordSys = result.coordSysAxesInfo[coordSysKey] = {};
+    result.coordSysMap[coordSysKey] = coordSys;
+    var coordSysModel = coordSys.model;
+    var baseTooltipModel = coordSysModel.getModel("tooltip", globalTooltipModel);
+    util.each(coordSys.getAxes(), util.curry(saveTooltipAxisInfo, false, null));
+    if (coordSys.getTooltipAxes && globalTooltipModel && baseTooltipModel.get("show")) {
+      var triggerAxis = baseTooltipModel.get("trigger") === "axis";
+      var cross = baseTooltipModel.get(["axisPointer", "type"]) === "cross";
+      var tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(["axisPointer", "axis"]));
+      if (triggerAxis || cross) {
+        util.each(tooltipAxes.baseAxes, util.curry(saveTooltipAxisInfo, cross ? "cross" : true, triggerAxis));
+      }
+      if (cross) {
+        util.each(tooltipAxes.otherAxes, util.curry(saveTooltipAxisInfo, "cross", false));
+      }
+    }
+    function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) {
+      var axisPointerModel = axis.model.getModel("axisPointer", globalAxisPointerModel);
+      var axisPointerShow = axisPointerModel.get("show");
+      if (!axisPointerShow || axisPointerShow === "auto" && !fromTooltip && !isHandleTrigger(axisPointerModel)) {
+        return;
+      }
+      if (triggerTooltip == null) {
+        triggerTooltip = axisPointerModel.get("triggerTooltip");
+      }
+      axisPointerModel = fromTooltip ? makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) : axisPointerModel;
+      var snap = axisPointerModel.get("snap");
+      var triggerEmphasis = axisPointerModel.get("triggerEmphasis");
+      var axisKey = makeKey(axis.model);
+      var involveSeries = triggerTooltip || snap || axis.type === "category";
+      var axisInfo = result.axesInfo[axisKey] = {
+        key: axisKey,
+        axis,
+        coordSys,
+        axisPointerModel,
+        triggerTooltip,
+        triggerEmphasis,
+        involveSeries,
+        snap,
+        useHandle: isHandleTrigger(axisPointerModel),
+        seriesModels: [],
+        linkGroup: null
+      };
+      axesInfoInCoordSys[axisKey] = axisInfo;
+      result.seriesInvolved = result.seriesInvolved || involveSeries;
+      var groupIndex = getLinkGroupIndex(linksOption, axis);
+      if (groupIndex != null) {
+        var linkGroup = linkGroups[groupIndex] || (linkGroups[groupIndex] = {
+          axesInfo: {}
+        });
+        linkGroup.axesInfo[axisKey] = axisInfo;
+        linkGroup.mapper = linksOption[groupIndex].mapper;
+        axisInfo.linkGroup = linkGroup;
+      }
+    }
+  });
+}
+function makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) {
+  var tooltipAxisPointerModel = baseTooltipModel.getModel("axisPointer");
+  var fields = ["type", "snap", "lineStyle", "shadowStyle", "label", "animation", "animationDurationUpdate", "animationEasingUpdate", "z"];
+  var volatileOption = {};
+  util.each(fields, function(field) {
+    volatileOption[field] = util.clone(tooltipAxisPointerModel.get(field));
+  });
+  volatileOption.snap = axis.type !== "category" && !!triggerTooltip;
+  if (tooltipAxisPointerModel.get("type") === "cross") {
+    volatileOption.type = "line";
+  }
+  var labelOption = volatileOption.label || (volatileOption.label = {});
+  labelOption.show == null && (labelOption.show = false);
+  if (fromTooltip === "cross") {
+    var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(["label", "show"]);
+    labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true;
+    if (!triggerTooltip) {
+      var crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get("crossStyle");
+      crossStyle && util.defaults(labelOption, crossStyle.textStyle);
+    }
+  }
+  return axis.model.getModel("axisPointer", new Model.default(volatileOption, globalAxisPointerModel, ecModel));
+}
+function collectSeriesInfo(result, ecModel) {
+  ecModel.eachSeries(function(seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    var seriesTooltipTrigger = seriesModel.get(["tooltip", "trigger"], true);
+    var seriesTooltipShow = seriesModel.get(["tooltip", "show"], true);
+    if (!coordSys || seriesTooltipTrigger === "none" || seriesTooltipTrigger === false || seriesTooltipTrigger === "item" || seriesTooltipShow === false || seriesModel.get(["axisPointer", "show"], true) === false) {
+      return;
+    }
+    util.each(result.coordSysAxesInfo[makeKey(coordSys.model)], function(axisInfo) {
+      var axis = axisInfo.axis;
+      if (coordSys.getAxis(axis.dim) === axis) {
+        axisInfo.seriesModels.push(seriesModel);
+        axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
+        axisInfo.seriesDataCount += seriesModel.getData().count();
+      }
+    });
+  });
+}
+function getLinkGroupIndex(linksOption, axis) {
+  var axisModel = axis.model;
+  var dim = axis.dim;
+  for (var i = 0; i < linksOption.length; i++) {
+    var linkOption = linksOption[i] || {};
+    if (checkPropInLink(linkOption[dim + "AxisId"], axisModel.id) || checkPropInLink(linkOption[dim + "AxisIndex"], axisModel.componentIndex) || checkPropInLink(linkOption[dim + "AxisName"], axisModel.name)) {
+      return i;
+    }
+  }
+}
+function checkPropInLink(linkPropValue, axisPropValue) {
+  return linkPropValue === "all" || util.isArray(linkPropValue) && util.indexOf(linkPropValue, axisPropValue) >= 0 || linkPropValue === axisPropValue;
+}
+function fixValue(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  if (!axisInfo) {
+    return;
+  }
+  var axisPointerModel = axisInfo.axisPointerModel;
+  var scale = axisInfo.axis.scale;
+  var option = axisPointerModel.option;
+  var status = axisPointerModel.get("status");
+  var value = axisPointerModel.get("value");
+  if (value != null) {
+    value = scale.parse(value);
+  }
+  var useHandle = isHandleTrigger(axisPointerModel);
+  if (status == null) {
+    option.status = useHandle ? "show" : "hide";
+  }
+  var extent = scale.getExtent().slice();
+  extent[0] > extent[1] && extent.reverse();
+  if (
+    // Pick a value on axis when initializing.
+    value == null || value > extent[1]
+  ) {
+    value = extent[1];
+  }
+  if (value < extent[0]) {
+    value = extent[0];
+  }
+  option.value = value;
+  if (useHandle) {
+    option.status = axisInfo.axis.scale.isBlank() ? "hide" : "show";
+  }
+}
+function getAxisInfo(axisModel) {
+  var coordSysAxesInfo = (axisModel.ecModel.getComponent("axisPointer") || {}).coordSysAxesInfo;
+  return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
+}
+function getAxisPointerModel(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  return axisInfo && axisInfo.axisPointerModel;
+}
+function isHandleTrigger(axisPointerModel) {
+  return !!axisPointerModel.get(["handle", "show"]);
+}
+function makeKey(model) {
+  return model.type + "||" + model.id;
+}
+exports.collect = collect;
+exports.fixValue = fixValue;
+exports.getAxisInfo = getAxisInfo;
+exports.getAxisPointerModel = getAxisPointerModel;
+exports.makeKey = makeKey;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/viewHelper.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const graphic = require("../../util/graphic.js");
+const text = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/text.js");
+const format = require("../../util/format.js");
+const matrix = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.js");
+const axisHelper = require("../../coord/axisHelper.js");
+const AxisBuilder = require("../axis/AxisBuilder.js");
+const labelStyle = require("../../label/labelStyle.js");
+function buildElStyle(axisPointerModel) {
+  var axisPointerType = axisPointerModel.get("type");
+  var styleModel = axisPointerModel.getModel(axisPointerType + "Style");
+  var style;
+  if (axisPointerType === "line") {
+    style = styleModel.getLineStyle();
+    style.fill = null;
+  } else if (axisPointerType === "shadow") {
+    style = styleModel.getAreaStyle();
+    style.stroke = null;
+  }
+  return style;
+}
+function buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos) {
+  var value = axisPointerModel.get("value");
+  var text$1 = getValueLabel(value, axisModel.axis, axisModel.ecModel, axisPointerModel.get("seriesDataIndices"), {
+    precision: axisPointerModel.get(["label", "precision"]),
+    formatter: axisPointerModel.get(["label", "formatter"])
+  });
+  var labelModel = axisPointerModel.getModel("label");
+  var paddings = format.normalizeCssArray(labelModel.get("padding") || 0);
+  var font = labelModel.getFont();
+  var textRect = text.getBoundingRect(text$1, font);
+  var position = labelPos.position;
+  var width = textRect.width + paddings[1] + paddings[3];
+  var height = textRect.height + paddings[0] + paddings[2];
+  var align = labelPos.align;
+  align === "right" && (position[0] -= width);
+  align === "center" && (position[0] -= width / 2);
+  var verticalAlign = labelPos.verticalAlign;
+  verticalAlign === "bottom" && (position[1] -= height);
+  verticalAlign === "middle" && (position[1] -= height / 2);
+  confineInContainer(position, width, height, api);
+  var bgColor = labelModel.get("backgroundColor");
+  if (!bgColor || bgColor === "auto") {
+    bgColor = axisModel.get(["axisLine", "lineStyle", "color"]);
+  }
+  elOption.label = {
+    // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')},
+    x: position[0],
+    y: position[1],
+    style: labelStyle.createTextStyle(labelModel, {
+      text: text$1,
+      font,
+      fill: labelModel.getTextColor(),
+      padding: paddings,
+      backgroundColor: bgColor
+    }),
+    // Label should be over axisPointer.
+    z2: 10
+  };
+}
+function confineInContainer(position, width, height, api) {
+  var viewWidth = api.getWidth();
+  var viewHeight = api.getHeight();
+  position[0] = Math.min(position[0] + width, viewWidth) - width;
+  position[1] = Math.min(position[1] + height, viewHeight) - height;
+  position[0] = Math.max(position[0], 0);
+  position[1] = Math.max(position[1], 0);
+}
+function getValueLabel(value, axis, ecModel, seriesDataIndices, opt) {
+  value = axis.scale.parse(value);
+  var text2 = axis.scale.getLabel({
+    value
+  }, {
+    // If `precision` is set, width can be fixed (like '12.00500'), which
+    // helps to debounce when when moving label.
+    precision: opt.precision
+  });
+  var formatter = opt.formatter;
+  if (formatter) {
+    var params_1 = {
+      value: axisHelper.getAxisRawValue(axis, {
+        value
+      }),
+      axisDimension: axis.dim,
+      axisIndex: axis.index,
+      seriesData: []
+    };
+    util.each(seriesDataIndices, function(idxItem) {
+      var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+      var dataIndex = idxItem.dataIndexInside;
+      var dataParams = series && series.getDataParams(dataIndex);
+      dataParams && params_1.seriesData.push(dataParams);
+    });
+    if (util.isString(formatter)) {
+      text2 = formatter.replace("{value}", text2);
+    } else if (util.isFunction(formatter)) {
+      text2 = formatter(params_1);
+    }
+  }
+  return text2;
+}
+function getTransformedPosition(axis, value, layoutInfo) {
+  var transform = matrix.create();
+  matrix.rotate(transform, transform, layoutInfo.rotation);
+  matrix.translate(transform, transform, layoutInfo.position);
+  return graphic.applyTransform([axis.dataToCoord(value), (layoutInfo.labelOffset || 0) + (layoutInfo.labelDirection || 1) * (layoutInfo.labelMargin || 0)], transform);
+}
+function buildCartesianSingleLabelElOption(value, elOption, layoutInfo, axisModel, axisPointerModel, api) {
+  var textLayout = AxisBuilder.default.innerTextLayout(layoutInfo.rotation, 0, layoutInfo.labelDirection);
+  layoutInfo.labelMargin = axisPointerModel.get(["label", "margin"]);
+  buildLabelElOption(elOption, axisModel, axisPointerModel, api, {
+    position: getTransformedPosition(axisModel.axis, value, layoutInfo),
+    align: textLayout.textAlign,
+    verticalAlign: textLayout.textVerticalAlign
+  });
+}
+function makeLineShape(p1, p2, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x1: p1[xDimIndex],
+    y1: p1[1 - xDimIndex],
+    x2: p2[xDimIndex],
+    y2: p2[1 - xDimIndex]
+  };
+}
+function makeRectShape(xy, wh, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x: xy[xDimIndex],
+    y: xy[1 - xDimIndex],
+    width: wh[xDimIndex],
+    height: wh[1 - xDimIndex]
+  };
+}
+exports.buildCartesianSingleLabelElOption = buildCartesianSingleLabelElOption;
+exports.buildElStyle = buildElStyle;
+exports.buildLabelElOption = buildLabelElOption;
+exports.getTransformedPosition = getTransformedPosition;
+exports.getValueLabel = getValueLabel;
+exports.makeLineShape = makeLineShape;
+exports.makeRectShape = makeRectShape;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/AxisProxy.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const number = require("../../util/number.js");
+const sliderMove = require("../helper/sliderMove.js");
+const axisHelper = require("../../coord/axisHelper.js");
+const scaleRawExtentInfo = require("../../coord/scaleRawExtentInfo.js");
+const helper = require("./helper.js");
+const model = require("../../util/model.js");
+var each = util.each;
+var asc = number.asc;
+var AxisProxy = (
+  /** @class */
+  function() {
+    function AxisProxy2(dimName, axisIndex, dataZoomModel, ecModel) {
+      this._dimName = dimName;
+      this._axisIndex = axisIndex;
+      this.ecModel = ecModel;
+      this._dataZoomModel = dataZoomModel;
+    }
+    AxisProxy2.prototype.hostedBy = function(dataZoomModel) {
+      return this._dataZoomModel === dataZoomModel;
+    };
+    AxisProxy2.prototype.getDataValueWindow = function() {
+      return this._valueWindow.slice();
+    };
+    AxisProxy2.prototype.getDataPercentWindow = function() {
+      return this._percentWindow.slice();
+    };
+    AxisProxy2.prototype.getTargetSeriesModels = function() {
+      var seriesModels = [];
+      this.ecModel.eachSeries(function(seriesModel) {
+        if (helper.isCoordSupported(seriesModel)) {
+          var axisMainType = helper.getAxisMainType(this._dimName);
+          var axisModel = seriesModel.getReferringComponents(axisMainType, model.SINGLE_REFERRING).models[0];
+          if (axisModel && this._axisIndex === axisModel.componentIndex) {
+            seriesModels.push(seriesModel);
+          }
+        }
+      }, this);
+      return seriesModels;
+    };
+    AxisProxy2.prototype.getAxisModel = function() {
+      return this.ecModel.getComponent(this._dimName + "Axis", this._axisIndex);
+    };
+    AxisProxy2.prototype.getMinMaxSpan = function() {
+      return util.clone(this._minMaxSpan);
+    };
+    AxisProxy2.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"];
+        if (rangePropMode[idx] === "percent") {
+          boundPercent == null && (boundPercent = percentExtent[idx]);
+          boundValue = scale.parse(number.linearMap(boundPercent, percentExtent, dataExtent));
+        } else {
+          hasPropModeValue = true;
+          boundValue = boundValue == null ? dataExtent[idx] : scale.parse(boundValue);
+          boundPercent = number.linearMap(boundValue, dataExtent, percentExtent);
+        }
+        valueWindow[idx] = boundValue == null || isNaN(boundValue) ? dataExtent[idx] : boundValue;
+        percentWindow[idx] = boundPercent == null || isNaN(boundPercent) ? percentExtent[idx] : boundPercent;
+      });
+      asc(valueWindow);
+      asc(percentWindow);
+      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.default(0, fromWindow, fromExtent, "all", spans["min" + suffix], spans["max" + suffix]);
+        for (var i = 0; i < 2; i++) {
+          toWindow[i] = number.linearMap(fromWindow[i], fromExtent, toExtent, true);
+          toValue && (toWindow[i] = scale.parse(toWindow[i]));
+        }
+      }
+      return {
+        valueWindow,
+        percentWindow
+      };
+    };
+    AxisProxy2.prototype.reset = function(dataZoomModel) {
+      if (dataZoomModel !== this._dataZoomModel) {
+        return;
+      }
+      var targetSeries = this.getTargetSeriesModels();
+      this._dataExtent = calculateDataExtent(this, this._dimName, targetSeries);
+      this._updateMinMaxSpan();
+      var dataWindow = this.calculateDataWindow(dataZoomModel.settledOption);
+      this._valueWindow = dataWindow.valueWindow;
+      this._percentWindow = dataWindow.percentWindow;
+      this._setAxisModel();
+    };
+    AxisProxy2.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;
+      }
+      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 = util.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);
+            }
+            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;
+              seriesData.selectRange(range);
+            }
+          });
+        }
+        each(dataDims, function(dim) {
+          seriesData.setApproximateExtent(valueWindow, dim);
+        });
+      });
+      function isInWindow(value) {
+        return value >= valueWindow[0] && value <= valueWindow[1];
+      }
+    };
+    AxisProxy2.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));
+        if (valueSpan != null) {
+          percentSpan = number.linearMap(dataExtent[0] + valueSpan, dataExtent, [0, 100], true);
+        } else if (percentSpan != null) {
+          valueSpan = number.linearMap(percentSpan, [0, 100], dataExtent, true) - dataExtent[0];
+        }
+        minMaxSpan[minMax + "Span"] = percentSpan;
+        minMaxSpan[minMax + "ValueSpan"] = valueSpan;
+      }, this);
+    };
+    AxisProxy2.prototype._setAxisModel = function() {
+      var axisModel = this.getAxisModel();
+      var percentWindow = this._percentWindow;
+      var valueWindow = this._valueWindow;
+      if (!percentWindow) {
+        return;
+      }
+      var precision = number.getPixelPrecision(valueWindow, [0, 500]);
+      precision = Math.min(precision, 20);
+      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 AxisProxy2;
+  }()
+);
+function calculateDataExtent(axisProxy, axisDim, seriesModels) {
+  var dataExtent = [Infinity, -Infinity];
+  each(seriesModels, function(seriesModel) {
+    axisHelper.unionAxisExtentFromData(dataExtent, seriesModel.getData(), axisDim);
+  });
+  var axisModel = axisProxy.getAxisModel();
+  var rawExtentResult = scaleRawExtentInfo.ensureScaleRawExtentInfo(axisModel.axis.scale, axisModel, dataExtent).calculate();
+  return [rawExtentResult.min, rawExtentResult.max];
+}
+exports.default = AxisProxy;