@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/Grid.mjs

@@ -0,0 +1,376 @@
+import { each, isObject, indexOf, keys } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { getLayoutRect } from "../../util/layout.mjs";
+import { estimateLabelUnionRect, createScaleByModel, getDataDimensionsOnAxis, niceScaleExtent, ifAxisCrossZero } from "../axisHelper.mjs";
+import Cartesian2D, { cartesian2DDimensions } from "./Cartesian2D.mjs";
+import Axis2D from "./Axis2D.mjs";
+import { SINGLE_REFERRING } from "../../util/model.mjs";
+import { isCartesian2DSeries, findAxisModels } from "./cartesianAxisHelper.mjs";
+import { isIntervalOrLogScale } from "../../scale/helper.mjs";
+import { alignScaleTicks } from "../axisAlignTicks.mjs";
+var Grid = (
+  /** @class */
+  function() {
+    function Grid2(gridModel, ecModel, api) {
+      this.type = "grid";
+      this._coordsMap = {};
+      this._coordsList = [];
+      this._axesMap = {};
+      this._axesList = [];
+      this.axisPointerEnabled = true;
+      this.dimensions = cartesian2DDimensions;
+      this._initCartesian(gridModel, ecModel, api);
+      this.model = gridModel;
+    }
+    Grid2.prototype.getRect = function() {
+      return this._rect;
+    };
+    Grid2.prototype.update = function(ecModel, api) {
+      var axesMap = this._axesMap;
+      this._updateScale(ecModel, this.model);
+      function updateAxisTicks(axes) {
+        var alignTo;
+        var axesIndices = keys(axes);
+        var len = axesIndices.length;
+        if (!len) {
+          return;
+        }
+        var axisNeedsAlign = [];
+        for (var i = len - 1; i >= 0; i--) {
+          var idx = +axesIndices[i];
+          var axis = axes[idx];
+          var model = axis.model;
+          var scale = axis.scale;
+          if (
+            // Only value and log axis without interval support alignTicks.
+            isIntervalOrLogScale(scale) && model.get("alignTicks") && model.get("interval") == null
+          ) {
+            axisNeedsAlign.push(axis);
+          } else {
+            niceScaleExtent(scale, model);
+            if (isIntervalOrLogScale(scale)) {
+              alignTo = axis;
+            }
+          }
+        }
+        if (axisNeedsAlign.length) {
+          if (!alignTo) {
+            alignTo = axisNeedsAlign.pop();
+            niceScaleExtent(alignTo.scale, alignTo.model);
+          }
+          each(axisNeedsAlign, function(axis2) {
+            alignScaleTicks(axis2.scale, axis2.model, alignTo.scale);
+          });
+        }
+      }
+      updateAxisTicks(axesMap.x);
+      updateAxisTicks(axesMap.y);
+      var onZeroRecords = {};
+      each(axesMap.x, function(xAxis) {
+        fixAxisOnZero(axesMap, "y", xAxis, onZeroRecords);
+      });
+      each(axesMap.y, function(yAxis) {
+        fixAxisOnZero(axesMap, "x", yAxis, onZeroRecords);
+      });
+      this.resize(this.model, api);
+    };
+    Grid2.prototype.resize = function(gridModel, api, ignoreContainLabel) {
+      var boxLayoutParams = gridModel.getBoxLayoutParams();
+      var isContainLabel = !ignoreContainLabel && gridModel.get("containLabel");
+      var gridRect = getLayoutRect(boxLayoutParams, {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+      this._rect = gridRect;
+      var axesList = this._axesList;
+      adjustAxes();
+      if (isContainLabel) {
+        each(axesList, function(axis) {
+          if (!axis.model.get(["axisLabel", "inside"])) {
+            var labelUnionRect = estimateLabelUnionRect(axis);
+            if (labelUnionRect) {
+              var dim = axis.isHorizontal() ? "height" : "width";
+              var margin = axis.model.get(["axisLabel", "margin"]);
+              gridRect[dim] -= labelUnionRect[dim] + margin;
+              if (axis.position === "top") {
+                gridRect.y += labelUnionRect.height + margin;
+              } else if (axis.position === "left") {
+                gridRect.x += labelUnionRect.width + margin;
+              }
+            }
+          }
+        });
+        adjustAxes();
+      }
+      each(this._coordsList, function(coord) {
+        coord.calcAffineTransform();
+      });
+      function adjustAxes() {
+        each(axesList, function(axis) {
+          var isHorizontal = axis.isHorizontal();
+          var extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height];
+          var idx = axis.inverse ? 1 : 0;
+          axis.setExtent(extent[idx], extent[1 - idx]);
+          updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y);
+        });
+      }
+    };
+    Grid2.prototype.getAxis = function(dim, axisIndex) {
+      var axesMapOnDim = this._axesMap[dim];
+      if (axesMapOnDim != null) {
+        return axesMapOnDim[axisIndex || 0];
+      }
+    };
+    Grid2.prototype.getAxes = function() {
+      return this._axesList.slice();
+    };
+    Grid2.prototype.getCartesian = function(xAxisIndex, yAxisIndex) {
+      if (xAxisIndex != null && yAxisIndex != null) {
+        var key = "x" + xAxisIndex + "y" + yAxisIndex;
+        return this._coordsMap[key];
+      }
+      if (isObject(xAxisIndex)) {
+        yAxisIndex = xAxisIndex.yAxisIndex;
+        xAxisIndex = xAxisIndex.xAxisIndex;
+      }
+      for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) {
+        if (coordList[i].getAxis("x").index === xAxisIndex || coordList[i].getAxis("y").index === yAxisIndex) {
+          return coordList[i];
+        }
+      }
+    };
+    Grid2.prototype.getCartesians = function() {
+      return this._coordsList.slice();
+    };
+    Grid2.prototype.convertToPixel = function(ecModel, finder, value) {
+      var target = this._findConvertTarget(finder);
+      return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null;
+    };
+    Grid2.prototype.convertFromPixel = function(ecModel, finder, value) {
+      var target = this._findConvertTarget(finder);
+      return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null;
+    };
+    Grid2.prototype._findConvertTarget = function(finder) {
+      var seriesModel = finder.seriesModel;
+      var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0];
+      var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0];
+      var gridModel = finder.gridModel;
+      var coordsList = this._coordsList;
+      var cartesian;
+      var axis;
+      if (seriesModel) {
+        cartesian = seriesModel.coordinateSystem;
+        indexOf(coordsList, cartesian) < 0 && (cartesian = null);
+      } else if (xAxisModel && yAxisModel) {
+        cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+      } else if (xAxisModel) {
+        axis = this.getAxis("x", xAxisModel.componentIndex);
+      } else if (yAxisModel) {
+        axis = this.getAxis("y", yAxisModel.componentIndex);
+      } else if (gridModel) {
+        var grid = gridModel.coordinateSystem;
+        if (grid === this) {
+          cartesian = this._coordsList[0];
+        }
+      }
+      return {
+        cartesian,
+        axis
+      };
+    };
+    Grid2.prototype.containPoint = function(point) {
+      var coord = this._coordsList[0];
+      if (coord) {
+        return coord.containPoint(point);
+      }
+    };
+    Grid2.prototype._initCartesian = function(gridModel, ecModel, api) {
+      var _this = this;
+      var grid = this;
+      var axisPositionUsed = {
+        left: false,
+        right: false,
+        top: false,
+        bottom: false
+      };
+      var axesMap = {
+        x: {},
+        y: {}
+      };
+      var axesCount = {
+        x: 0,
+        y: 0
+      };
+      ecModel.eachComponent("xAxis", createAxisCreator("x"), this);
+      ecModel.eachComponent("yAxis", createAxisCreator("y"), this);
+      if (!axesCount.x || !axesCount.y) {
+        this._axesMap = {};
+        this._axesList = [];
+        return;
+      }
+      this._axesMap = axesMap;
+      each(axesMap.x, function(xAxis, xAxisIndex) {
+        each(axesMap.y, function(yAxis, yAxisIndex) {
+          var key = "x" + xAxisIndex + "y" + yAxisIndex;
+          var cartesian = new Cartesian2D(key);
+          cartesian.master = _this;
+          cartesian.model = gridModel;
+          _this._coordsMap[key] = cartesian;
+          _this._coordsList.push(cartesian);
+          cartesian.addAxis(xAxis);
+          cartesian.addAxis(yAxis);
+        });
+      });
+      function createAxisCreator(dimName) {
+        return function(axisModel, idx) {
+          if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
+            return;
+          }
+          var axisPosition = axisModel.get("position");
+          if (dimName === "x") {
+            if (axisPosition !== "top" && axisPosition !== "bottom") {
+              axisPosition = axisPositionUsed.bottom ? "top" : "bottom";
+            }
+          } else {
+            if (axisPosition !== "left" && axisPosition !== "right") {
+              axisPosition = axisPositionUsed.left ? "right" : "left";
+            }
+          }
+          axisPositionUsed[axisPosition] = true;
+          var axis = new Axis2D(dimName, createScaleByModel(axisModel), [0, 0], axisModel.get("type"), axisPosition);
+          var isCategory = axis.type === "category";
+          axis.onBand = isCategory && axisModel.get("boundaryGap");
+          axis.inverse = axisModel.get("inverse");
+          axisModel.axis = axis;
+          axis.model = axisModel;
+          axis.grid = grid;
+          axis.index = idx;
+          grid._axesList.push(axis);
+          axesMap[dimName][idx] = axis;
+          axesCount[dimName]++;
+        };
+      }
+    };
+    Grid2.prototype._updateScale = function(ecModel, gridModel) {
+      each(this._axesList, function(axis) {
+        axis.scale.setExtent(Infinity, -Infinity);
+        if (axis.type === "category") {
+          var categorySortInfo = axis.model.get("categorySortInfo");
+          axis.scale.setSortInfo(categorySortInfo);
+        }
+      });
+      ecModel.eachSeries(function(seriesModel) {
+        if (isCartesian2DSeries(seriesModel)) {
+          var axesModelMap = findAxisModels(seriesModel);
+          var xAxisModel = axesModelMap.xAxisModel;
+          var yAxisModel = axesModelMap.yAxisModel;
+          if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) {
+            return;
+          }
+          var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+          var data = seriesModel.getData();
+          var xAxis = cartesian.getAxis("x");
+          var yAxis = cartesian.getAxis("y");
+          unionExtent(data, xAxis);
+          unionExtent(data, yAxis);
+        }
+      }, this);
+      function unionExtent(data, axis) {
+        each(getDataDimensionsOnAxis(data, axis.dim), function(dim) {
+          axis.scale.unionExtentFromData(data, dim);
+        });
+      }
+    };
+    Grid2.prototype.getTooltipAxes = function(dim) {
+      var baseAxes = [];
+      var otherAxes = [];
+      each(this.getCartesians(), function(cartesian) {
+        var baseAxis = dim != null && dim !== "auto" ? cartesian.getAxis(dim) : cartesian.getBaseAxis();
+        var otherAxis = cartesian.getOtherAxis(baseAxis);
+        indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
+        indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
+      });
+      return {
+        baseAxes,
+        otherAxes
+      };
+    };
+    Grid2.create = function(ecModel, api) {
+      var grids = [];
+      ecModel.eachComponent("grid", function(gridModel, idx) {
+        var grid = new Grid2(gridModel, ecModel, api);
+        grid.name = "grid_" + idx;
+        grid.resize(gridModel, api, true);
+        gridModel.coordinateSystem = grid;
+        grids.push(grid);
+      });
+      ecModel.eachSeries(function(seriesModel) {
+        if (!isCartesian2DSeries(seriesModel)) {
+          return;
+        }
+        var axesModelMap = findAxisModels(seriesModel);
+        var xAxisModel = axesModelMap.xAxisModel;
+        var yAxisModel = axesModelMap.yAxisModel;
+        var gridModel = xAxisModel.getCoordSysModel();
+        var grid = gridModel.coordinateSystem;
+        seriesModel.coordinateSystem = grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+      });
+      return grids;
+    };
+    Grid2.dimensions = cartesian2DDimensions;
+    return Grid2;
+  }()
+);
+function isAxisUsedInTheGrid(axisModel, gridModel) {
+  return axisModel.getCoordSysModel() === gridModel;
+}
+function fixAxisOnZero(axesMap, otherAxisDim, axis, onZeroRecords) {
+  axis.getAxesOnZeroOf = function() {
+    return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
+  };
+  var otherAxes = axesMap[otherAxisDim];
+  var otherAxisOnZeroOf;
+  var axisModel = axis.model;
+  var onZero = axisModel.get(["axisLine", "onZero"]);
+  var onZeroAxisIndex = axisModel.get(["axisLine", "onZeroAxisIndex"]);
+  if (!onZero) {
+    return;
+  }
+  if (onZeroAxisIndex != null) {
+    if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
+      otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
+    }
+  } else {
+    for (var idx in otherAxes) {
+      if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx]) && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) {
+        otherAxisOnZeroOf = otherAxes[idx];
+        break;
+      }
+    }
+  }
+  if (otherAxisOnZeroOf) {
+    onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
+  }
+  function getOnZeroRecordKey(axis2) {
+    return axis2.dim + "_" + axis2.index;
+  }
+}
+function canOnZeroToAxis(axis) {
+  return axis && axis.type !== "category" && axis.type !== "time" && ifAxisCrossZero(axis);
+}
+function updateAxisTransform(axis, coordBase) {
+  var axisExtent = axis.getExtent();
+  var axisExtentSum = axisExtent[0] + axisExtent[1];
+  axis.toGlobalCoord = axis.dim === "x" ? function(coord) {
+    return coord + coordBase;
+  } : function(coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+  axis.toLocalCoord = axis.dim === "x" ? function(coord) {
+    return coord - coordBase;
+  } : function(coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+}
+export {
+  Grid as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/GridModel.mjs

@@ -0,0 +1,34 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import ComponentModel from "../../model/Component.mjs";
+var GridModel = (
+  /** @class */
+  function(_super) {
+    __extends(GridModel2, _super);
+    function GridModel2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GridModel2.type = "grid";
+    GridModel2.dependencies = ["xAxis", "yAxis"];
+    GridModel2.layoutMode = "box";
+    GridModel2.defaultOption = {
+      show: false,
+      // zlevel: 0,
+      z: 0,
+      left: "10%",
+      top: 60,
+      right: "10%",
+      bottom: 70,
+      // If grid size contain label
+      containLabel: false,
+      // width: {totalWidth} - left - right,
+      // height: {totalHeight} - top - bottom,
+      backgroundColor: "rgba(0,0,0,0)",
+      borderWidth: 1,
+      borderColor: "#ccc"
+    };
+    return GridModel2;
+  }(ComponentModel)
+);
+export {
+  GridModel as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/cartesian/cartesianAxisHelper.mjs

@@ -0,0 +1,67 @@
+import { retrieve, each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { SINGLE_REFERRING } from "../../util/model.mjs";
+function layout(gridModel, axisModel, opt) {
+  opt = opt || {};
+  var grid = gridModel.coordinateSystem;
+  var axis = axisModel.axis;
+  var layout2 = {};
+  var otherAxisOnZeroOf = axis.getAxesOnZeroOf()[0];
+  var rawAxisPosition = axis.position;
+  var axisPosition = otherAxisOnZeroOf ? "onZero" : rawAxisPosition;
+  var axisDim = axis.dim;
+  var rect = grid.getRect();
+  var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+  var idx = {
+    left: 0,
+    right: 1,
+    top: 0,
+    bottom: 1,
+    onZero: 2
+  };
+  var axisOffset = axisModel.get("offset") || 0;
+  var posBound = axisDim === "x" ? [rectBound[2] - axisOffset, rectBound[3] + axisOffset] : [rectBound[0] - axisOffset, rectBound[1] + axisOffset];
+  if (otherAxisOnZeroOf) {
+    var onZeroCoord = otherAxisOnZeroOf.toGlobalCoord(otherAxisOnZeroOf.dataToCoord(0));
+    posBound[idx.onZero] = Math.max(Math.min(onZeroCoord, posBound[1]), posBound[0]);
+  }
+  layout2.position = [axisDim === "y" ? posBound[idx[axisPosition]] : rectBound[0], axisDim === "x" ? posBound[idx[axisPosition]] : rectBound[3]];
+  layout2.rotation = Math.PI / 2 * (axisDim === "x" ? 0 : 1);
+  var dirMap = {
+    top: -1,
+    bottom: 1,
+    left: -1,
+    right: 1
+  };
+  layout2.labelDirection = layout2.tickDirection = layout2.nameDirection = dirMap[rawAxisPosition];
+  layout2.labelOffset = otherAxisOnZeroOf ? posBound[idx[rawAxisPosition]] - posBound[idx.onZero] : 0;
+  if (axisModel.get(["axisTick", "inside"])) {
+    layout2.tickDirection = -layout2.tickDirection;
+  }
+  if (retrieve(opt.labelInside, axisModel.get(["axisLabel", "inside"]))) {
+    layout2.labelDirection = -layout2.labelDirection;
+  }
+  var labelRotate = axisModel.get(["axisLabel", "rotate"]);
+  layout2.labelRotate = axisPosition === "top" ? -labelRotate : labelRotate;
+  layout2.z2 = 1;
+  return layout2;
+}
+function isCartesian2DSeries(seriesModel) {
+  return seriesModel.get("coordinateSystem") === "cartesian2d";
+}
+function findAxisModels(seriesModel) {
+  var axisModelMap = {
+    xAxisModel: null,
+    yAxisModel: null
+  };
+  each(axisModelMap, function(v, key) {
+    var axisType = key.replace(/Model$/, "");
+    var axisModel = seriesModel.getReferringComponents(axisType, SINGLE_REFERRING).models[0];
+    axisModelMap[key] = axisModel;
+  });
+  return axisModelMap;
+}
+export {
+  findAxisModels,
+  isCartesian2DSeries,
+  layout
+};