@fecp/mobile 1.0.78 → 1.1.0

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

@@ -0,0 +1,206 @@
+import Model from "../../model/Model.mjs";
+import { each, curry, clone, defaults, isArray, indexOf } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+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 = [];
+  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);
+    each(coordSys.getAxes(), 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) {
+        each(tooltipAxes.baseAxes, curry(saveTooltipAxisInfo, cross ? "cross" : true, triggerAxis));
+      }
+      if (cross) {
+        each(tooltipAxes.otherAxes, 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 = {};
+  each(fields, function(field) {
+    volatileOption[field] = 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 && defaults(labelOption, crossStyle.textStyle);
+    }
+  }
+  return axis.model.getModel("axisPointer", new Model(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;
+    }
+    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" || isArray(linkPropValue) && 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;
+}
+export {
+  collect,
+  fixValue,
+  getAxisInfo,
+  getAxisPointerModel,
+  makeKey
+};

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

@@ -0,0 +1,143 @@
+import { each, isString, isFunction } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { applyTransform } from "../../util/graphic.mjs";
+import { getBoundingRect } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/text.mjs";
+import { normalizeCssArray } from "../../util/format.mjs";
+import { rotate, create, translate } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.mjs";
+import { getAxisRawValue } from "../../coord/axisHelper.mjs";
+import AxisBuilder from "../axis/AxisBuilder.mjs";
+import { createTextStyle } from "../../label/labelStyle.mjs";
+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 = 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 = normalizeCssArray(labelModel.get("padding") || 0);
+  var font = labelModel.getFont();
+  var textRect = getBoundingRect(text, 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: createTextStyle(labelModel, {
+      text,
+      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 text = 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: getAxisRawValue(axis, {
+        value
+      }),
+      axisDimension: axis.dim,
+      axisIndex: axis.index,
+      seriesData: []
+    };
+    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 (isString(formatter)) {
+      text = formatter.replace("{value}", text);
+    } else if (isFunction(formatter)) {
+      text = formatter(params_1);
+    }
+  }
+  return text;
+}
+function getTransformedPosition(axis, value, layoutInfo) {
+  var transform = create();
+  rotate(transform, transform, layoutInfo.rotation);
+  translate(transform, transform, layoutInfo.position);
+  return 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.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]
+  };
+}
+export {
+  buildCartesianSingleLabelElOption,
+  buildElStyle,
+  buildLabelElOption,
+  getTransformedPosition,
+  getValueLabel,
+  makeLineShape,
+  makeRectShape
+};

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

@@ -0,0 +1,209 @@
+import { clone, each as each$1, map } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { linearMap, asc as asc$1, getPixelPrecision } from "../../util/number.mjs";
+import sliderMove from "../helper/sliderMove.mjs";
+import { unionAxisExtentFromData } from "../../coord/axisHelper.mjs";
+import { ensureScaleRawExtentInfo } from "../../coord/scaleRawExtentInfo.mjs";
+import { isCoordSupported, getAxisMainType } from "./helper.mjs";
+import { SINGLE_REFERRING } from "../../util/model.mjs";
+var each = each$1;
+var asc = asc$1;
+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 (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;
+    };
+    AxisProxy2.prototype.getAxisModel = function() {
+      return this.ecModel.getComponent(this._dimName + "Axis", this._axisIndex);
+    };
+    AxisProxy2.prototype.getMinMaxSpan = function() {
+      return 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(linearMap(boundPercent, percentExtent, dataExtent));
+        } else {
+          hasPropModeValue = true;
+          boundValue = boundValue == null ? dataExtent[idx] : scale.parse(boundValue);
+          boundPercent = 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(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,
+        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 = 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 = 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);
+    };
+    AxisProxy2.prototype._setAxisModel = function() {
+      var axisModel = this.getAxisModel();
+      var percentWindow = this._percentWindow;
+      var valueWindow = this._valueWindow;
+      if (!percentWindow) {
+        return;
+      }
+      var precision = 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) {
+    unionAxisExtentFromData(dataExtent, seriesModel.getData(), axisDim);
+  });
+  var axisModel = axisProxy.getAxisModel();
+  var rawExtentResult = ensureScaleRawExtentInfo(axisModel.axis.scale, axisModel, dataExtent).calculate();
+  return [rawExtentResult.min, rawExtentResult.max];
+}
+export {
+  AxisProxy as default
+};