@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/geo/Region.mjs

@@ -0,0 +1,231 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import BoundingRect from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.mjs";
+import { min, max, applyTransform } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/vector.mjs";
+import { contain } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/polygon.mjs";
+import { identity, mul, invert } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.mjs";
+import { each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var TMP_TRANSFORM = [];
+function transformPoints(points, transform) {
+  for (var p = 0; p < points.length; p++) {
+    applyTransform(points[p], points[p], transform);
+  }
+}
+function updateBBoxFromPoints(points, min$1, max$1, projection) {
+  for (var i = 0; i < points.length; i++) {
+    var p = points[i];
+    if (projection) {
+      p = projection.project(p);
+    }
+    if (p && isFinite(p[0]) && isFinite(p[1])) {
+      min(min$1, min$1, p);
+      max(max$1, max$1, p);
+    }
+  }
+}
+function centroid(points) {
+  var signedArea = 0;
+  var cx = 0;
+  var cy = 0;
+  var len = points.length;
+  var x0 = points[len - 1][0];
+  var y0 = points[len - 1][1];
+  for (var i = 0; i < len; i++) {
+    var x1 = points[i][0];
+    var y1 = points[i][1];
+    var a = x0 * y1 - x1 * y0;
+    signedArea += a;
+    cx += (x0 + x1) * a;
+    cy += (y0 + y1) * a;
+    x0 = x1;
+    y0 = y1;
+  }
+  return signedArea ? [cx / signedArea / 3, cy / signedArea / 3, signedArea] : [points[0][0] || 0, points[0][1] || 0];
+}
+var Region = (
+  /** @class */
+  function() {
+    function Region2(name) {
+      this.name = name;
+    }
+    Region2.prototype.setCenter = function(center) {
+      this._center = center;
+    };
+    Region2.prototype.getCenter = function() {
+      var center = this._center;
+      if (!center) {
+        center = this._center = this.calcCenter();
+      }
+      return center;
+    };
+    return Region2;
+  }()
+);
+var GeoJSONPolygonGeometry = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function GeoJSONPolygonGeometry2(exterior, interiors) {
+      this.type = "polygon";
+      this.exterior = exterior;
+      this.interiors = interiors;
+    }
+    return GeoJSONPolygonGeometry2;
+  }()
+);
+var GeoJSONLineStringGeometry = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function GeoJSONLineStringGeometry2(points) {
+      this.type = "linestring";
+      this.points = points;
+    }
+    return GeoJSONLineStringGeometry2;
+  }()
+);
+var GeoJSONRegion = (
+  /** @class */
+  function(_super) {
+    __extends(GeoJSONRegion2, _super);
+    function GeoJSONRegion2(name, geometries, cp) {
+      var _this = _super.call(this, name) || this;
+      _this.type = "geoJSON";
+      _this.geometries = geometries;
+      _this._center = cp && [cp[0], cp[1]];
+      return _this;
+    }
+    GeoJSONRegion2.prototype.calcCenter = function() {
+      var geometries = this.geometries;
+      var largestGeo;
+      var largestGeoSize = 0;
+      for (var i = 0; i < geometries.length; i++) {
+        var geo = geometries[i];
+        var exterior = geo.exterior;
+        var size = exterior && exterior.length;
+        if (size > largestGeoSize) {
+          largestGeo = geo;
+          largestGeoSize = size;
+        }
+      }
+      if (largestGeo) {
+        return centroid(largestGeo.exterior);
+      }
+      var rect = this.getBoundingRect();
+      return [rect.x + rect.width / 2, rect.y + rect.height / 2];
+    };
+    GeoJSONRegion2.prototype.getBoundingRect = function(projection) {
+      var rect = this._rect;
+      if (rect && !projection) {
+        return rect;
+      }
+      var min2 = [Infinity, Infinity];
+      var max2 = [-Infinity, -Infinity];
+      var geometries = this.geometries;
+      each(geometries, function(geo) {
+        if (geo.type === "polygon") {
+          updateBBoxFromPoints(geo.exterior, min2, max2, projection);
+        } else {
+          each(geo.points, function(points) {
+            updateBBoxFromPoints(points, min2, max2, projection);
+          });
+        }
+      });
+      if (!(isFinite(min2[0]) && isFinite(min2[1]) && isFinite(max2[0]) && isFinite(max2[1]))) {
+        min2[0] = min2[1] = max2[0] = max2[1] = 0;
+      }
+      rect = new BoundingRect(min2[0], min2[1], max2[0] - min2[0], max2[1] - min2[1]);
+      if (!projection) {
+        this._rect = rect;
+      }
+      return rect;
+    };
+    GeoJSONRegion2.prototype.contain = function(coord) {
+      var rect = this.getBoundingRect();
+      var geometries = this.geometries;
+      if (!rect.contain(coord[0], coord[1])) {
+        return false;
+      }
+      loopGeo: for (var i = 0, len = geometries.length; i < len; i++) {
+        var geo = geometries[i];
+        if (geo.type !== "polygon") {
+          continue;
+        }
+        var exterior = geo.exterior;
+        var interiors = geo.interiors;
+        if (contain(exterior, coord[0], coord[1])) {
+          for (var k = 0; k < (interiors ? interiors.length : 0); k++) {
+            if (contain(interiors[k], coord[0], coord[1])) {
+              continue loopGeo;
+            }
+          }
+          return true;
+        }
+      }
+      return false;
+    };
+    GeoJSONRegion2.prototype.transformTo = function(x, y, width, height) {
+      var rect = this.getBoundingRect();
+      var aspect = rect.width / rect.height;
+      if (!width) {
+        width = aspect * height;
+      } else if (!height) {
+        height = width / aspect;
+      }
+      var target = new BoundingRect(x, y, width, height);
+      var transform = rect.calculateTransform(target);
+      var geometries = this.geometries;
+      for (var i = 0; i < geometries.length; i++) {
+        var geo = geometries[i];
+        if (geo.type === "polygon") {
+          transformPoints(geo.exterior, transform);
+          each(geo.interiors, function(interior) {
+            transformPoints(interior, transform);
+          });
+        } else {
+          each(geo.points, function(points) {
+            transformPoints(points, transform);
+          });
+        }
+      }
+      rect = this._rect;
+      rect.copy(target);
+      this._center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+    };
+    GeoJSONRegion2.prototype.cloneShallow = function(name) {
+      name == null && (name = this.name);
+      var newRegion = new GeoJSONRegion2(name, this.geometries, this._center);
+      newRegion._rect = this._rect;
+      newRegion.transformTo = null;
+      return newRegion;
+    };
+    return GeoJSONRegion2;
+  }(Region)
+);
+(function(_super) {
+  __extends(GeoSVGRegion, _super);
+  function GeoSVGRegion(name, elOnlyForCalculate) {
+    var _this = _super.call(this, name) || this;
+    _this.type = "geoSVG";
+    _this._elOnlyForCalculate = elOnlyForCalculate;
+    return _this;
+  }
+  GeoSVGRegion.prototype.calcCenter = function() {
+    var el = this._elOnlyForCalculate;
+    var rect = el.getBoundingRect();
+    var center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+    var mat = identity(TMP_TRANSFORM);
+    var target = el;
+    while (target && !target.isGeoSVGGraphicRoot) {
+      mul(mat, target.getLocalTransform(), mat);
+      target = target.parent;
+    }
+    invert(mat, mat);
+    applyTransform(center, center, mat);
+    return center;
+  };
+  return GeoSVGRegion;
+})(Region);
+export {
+  GeoJSONLineStringGeometry,
+  GeoJSONPolygonGeometry,
+  GeoJSONRegion,
+  Region
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/geo/parseGeoJson.mjs

@@ -0,0 +1,94 @@
+import { map, each, filter } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { GeoJSONLineStringGeometry, GeoJSONPolygonGeometry, GeoJSONRegion } from "./Region.mjs";
+function decode(json) {
+  if (!json.UTF8Encoding) {
+    return json;
+  }
+  var jsonCompressed = json;
+  var encodeScale = jsonCompressed.UTF8Scale;
+  if (encodeScale == null) {
+    encodeScale = 1024;
+  }
+  var features = jsonCompressed.features;
+  each(features, function(feature) {
+    var geometry = feature.geometry;
+    var encodeOffsets = geometry.encodeOffsets;
+    var coordinates = geometry.coordinates;
+    if (!encodeOffsets) {
+      return;
+    }
+    switch (geometry.type) {
+      case "LineString":
+        geometry.coordinates = decodeRing(coordinates, encodeOffsets, encodeScale);
+        break;
+      case "Polygon":
+        decodeRings(coordinates, encodeOffsets, encodeScale);
+        break;
+      case "MultiLineString":
+        decodeRings(coordinates, encodeOffsets, encodeScale);
+        break;
+      case "MultiPolygon":
+        each(coordinates, function(rings, idx) {
+          return decodeRings(rings, encodeOffsets[idx], encodeScale);
+        });
+    }
+  });
+  jsonCompressed.UTF8Encoding = false;
+  return jsonCompressed;
+}
+function decodeRings(rings, encodeOffsets, encodeScale) {
+  for (var c = 0; c < rings.length; c++) {
+    rings[c] = decodeRing(rings[c], encodeOffsets[c], encodeScale);
+  }
+}
+function decodeRing(coordinate, encodeOffsets, encodeScale) {
+  var result = [];
+  var prevX = encodeOffsets[0];
+  var prevY = encodeOffsets[1];
+  for (var i = 0; i < coordinate.length; i += 2) {
+    var x = coordinate.charCodeAt(i) - 64;
+    var y = coordinate.charCodeAt(i + 1) - 64;
+    x = x >> 1 ^ -(x & 1);
+    y = y >> 1 ^ -(y & 1);
+    x += prevX;
+    y += prevY;
+    prevX = x;
+    prevY = y;
+    result.push([x / encodeScale, y / encodeScale]);
+  }
+  return result;
+}
+function parseGeoJSON(geoJson, nameProperty) {
+  geoJson = decode(geoJson);
+  return map(filter(geoJson.features, function(featureObj) {
+    return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
+  }), function(featureObj) {
+    var properties = featureObj.properties;
+    var geo = featureObj.geometry;
+    var geometries = [];
+    switch (geo.type) {
+      case "Polygon":
+        var coordinates = geo.coordinates;
+        geometries.push(new GeoJSONPolygonGeometry(coordinates[0], coordinates.slice(1)));
+        break;
+      case "MultiPolygon":
+        each(geo.coordinates, function(item) {
+          if (item[0]) {
+            geometries.push(new GeoJSONPolygonGeometry(item[0], item.slice(1)));
+          }
+        });
+        break;
+      case "LineString":
+        geometries.push(new GeoJSONLineStringGeometry([geo.coordinates]));
+        break;
+      case "MultiLineString":
+        geometries.push(new GeoJSONLineStringGeometry(geo.coordinates));
+    }
+    var region = new GeoJSONRegion(properties[nameProperty || "name"], geometries, properties.cp);
+    region.properties = properties;
+    return region;
+  });
+}
+export {
+  parseGeoJSON as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/radar/IndicatorAxis.mjs

@@ -0,0 +1,19 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Axis from "../Axis.mjs";
+var IndicatorAxis = (
+  /** @class */
+  function(_super) {
+    __extends(IndicatorAxis2, _super);
+    function IndicatorAxis2(dim, scale, radiusExtent) {
+      var _this = _super.call(this, dim, scale, radiusExtent) || this;
+      _this.type = "value";
+      _this.angle = 0;
+      _this.name = "";
+      return _this;
+    }
+    return IndicatorAxis2;
+  }(Axis)
+);
+export {
+  IndicatorAxis as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/radar/Radar.mjs

@@ -0,0 +1,138 @@
+import IndicatorAxis from "./IndicatorAxis.mjs";
+import IntervalScale from "../../scale/Interval.mjs";
+import { parsePercent } from "../../util/number.mjs";
+import { each, map, isString, isNumber } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { alignScaleTicks } from "../axisAlignTicks.mjs";
+var Radar = (
+  /** @class */
+  function() {
+    function Radar2(radarModel, ecModel, api) {
+      this.dimensions = [];
+      this._model = radarModel;
+      this._indicatorAxes = map(radarModel.getIndicatorModels(), function(indicatorModel, idx) {
+        var dim = "indicator_" + idx;
+        var indicatorAxis = new IndicatorAxis(
+          dim,
+          new IntervalScale()
+          // (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
+        );
+        indicatorAxis.name = indicatorModel.get("name");
+        indicatorAxis.model = indicatorModel;
+        indicatorModel.axis = indicatorAxis;
+        this.dimensions.push(dim);
+        return indicatorAxis;
+      }, this);
+      this.resize(radarModel, api);
+    }
+    Radar2.prototype.getIndicatorAxes = function() {
+      return this._indicatorAxes;
+    };
+    Radar2.prototype.dataToPoint = function(value, indicatorIndex) {
+      var indicatorAxis = this._indicatorAxes[indicatorIndex];
+      return this.coordToPoint(indicatorAxis.dataToCoord(value), indicatorIndex);
+    };
+    Radar2.prototype.coordToPoint = function(coord, indicatorIndex) {
+      var indicatorAxis = this._indicatorAxes[indicatorIndex];
+      var angle = indicatorAxis.angle;
+      var x = this.cx + coord * Math.cos(angle);
+      var y = this.cy - coord * Math.sin(angle);
+      return [x, y];
+    };
+    Radar2.prototype.pointToData = function(pt) {
+      var dx = pt[0] - this.cx;
+      var dy = pt[1] - this.cy;
+      var radius = Math.sqrt(dx * dx + dy * dy);
+      dx /= radius;
+      dy /= radius;
+      var radian = Math.atan2(-dy, dx);
+      var minRadianDiff = Infinity;
+      var closestAxis;
+      var closestAxisIdx = -1;
+      for (var i = 0; i < this._indicatorAxes.length; i++) {
+        var indicatorAxis = this._indicatorAxes[i];
+        var diff = Math.abs(radian - indicatorAxis.angle);
+        if (diff < minRadianDiff) {
+          closestAxis = indicatorAxis;
+          closestAxisIdx = i;
+          minRadianDiff = diff;
+        }
+      }
+      return [closestAxisIdx, +(closestAxis && closestAxis.coordToData(radius))];
+    };
+    Radar2.prototype.resize = function(radarModel, api) {
+      var center = radarModel.get("center");
+      var viewWidth = api.getWidth();
+      var viewHeight = api.getHeight();
+      var viewSize = Math.min(viewWidth, viewHeight) / 2;
+      this.cx = parsePercent(center[0], viewWidth);
+      this.cy = parsePercent(center[1], viewHeight);
+      this.startAngle = radarModel.get("startAngle") * Math.PI / 180;
+      var radius = radarModel.get("radius");
+      if (isString(radius) || isNumber(radius)) {
+        radius = [0, radius];
+      }
+      this.r0 = parsePercent(radius[0], viewSize);
+      this.r = parsePercent(radius[1], viewSize);
+      each(this._indicatorAxes, function(indicatorAxis, idx) {
+        indicatorAxis.setExtent(this.r0, this.r);
+        var angle = this.startAngle + idx * Math.PI * 2 / this._indicatorAxes.length;
+        angle = Math.atan2(Math.sin(angle), Math.cos(angle));
+        indicatorAxis.angle = angle;
+      }, this);
+    };
+    Radar2.prototype.update = function(ecModel, api) {
+      var indicatorAxes = this._indicatorAxes;
+      var radarModel = this._model;
+      each(indicatorAxes, function(indicatorAxis) {
+        indicatorAxis.scale.setExtent(Infinity, -Infinity);
+      });
+      ecModel.eachSeriesByType("radar", function(radarSeries, idx) {
+        if (radarSeries.get("coordinateSystem") !== "radar" || ecModel.getComponent("radar", radarSeries.get("radarIndex")) !== radarModel) {
+          return;
+        }
+        var data = radarSeries.getData();
+        each(indicatorAxes, function(indicatorAxis) {
+          indicatorAxis.scale.unionExtentFromData(data, data.mapDimension(indicatorAxis.dim));
+        });
+      }, this);
+      var splitNumber = radarModel.get("splitNumber");
+      var dummyScale = new IntervalScale();
+      dummyScale.setExtent(0, splitNumber);
+      dummyScale.setInterval(1);
+      each(indicatorAxes, function(indicatorAxis, idx) {
+        alignScaleTicks(indicatorAxis.scale, indicatorAxis.model, dummyScale);
+      });
+    };
+    Radar2.prototype.convertToPixel = function(ecModel, finder, value) {
+      console.warn("Not implemented.");
+      return null;
+    };
+    Radar2.prototype.convertFromPixel = function(ecModel, finder, pixel) {
+      console.warn("Not implemented.");
+      return null;
+    };
+    Radar2.prototype.containPoint = function(point) {
+      console.warn("Not implemented.");
+      return false;
+    };
+    Radar2.create = function(ecModel, api) {
+      var radarList = [];
+      ecModel.eachComponent("radar", function(radarModel) {
+        var radar = new Radar2(radarModel, ecModel, api);
+        radarList.push(radar);
+        radarModel.coordinateSystem = radar;
+      });
+      ecModel.eachSeriesByType("radar", function(radarSeries) {
+        if (radarSeries.get("coordinateSystem") === "radar") {
+          radarSeries.coordinateSystem = radarList[radarSeries.get("radarIndex") || 0];
+        }
+      });
+      return radarList;
+    };
+    Radar2.dimensions = [];
+    return Radar2;
+  }()
+);
+export {
+  Radar as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/radar/RadarModel.mjs

@@ -0,0 +1,116 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { map, defaults, merge, clone, isString, isFunction, mixin } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import axisDefault from "../axisDefault.mjs";
+import Model from "../../model/Model.mjs";
+import { AxisModelCommonMixin } from "../axisModelCommonMixin.mjs";
+import ComponentModel from "../../model/Component.mjs";
+var valueAxisDefault = axisDefault.value;
+function defaultsShow(opt, show) {
+  return defaults({
+    show
+  }, opt);
+}
+var RadarModel = (
+  /** @class */
+  function(_super) {
+    __extends(RadarModel2, _super);
+    function RadarModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = RadarModel2.type;
+      return _this;
+    }
+    RadarModel2.prototype.optionUpdated = function() {
+      var boundaryGap = this.get("boundaryGap");
+      var splitNumber = this.get("splitNumber");
+      var scale = this.get("scale");
+      var axisLine = this.get("axisLine");
+      var axisTick = this.get("axisTick");
+      var axisLabel = this.get("axisLabel");
+      var nameTextStyle = this.get("axisName");
+      var showName = this.get(["axisName", "show"]);
+      var nameFormatter = this.get(["axisName", "formatter"]);
+      var nameGap = this.get("axisNameGap");
+      var triggerEvent = this.get("triggerEvent");
+      var indicatorModels = map(this.get("indicator") || [], function(indicatorOpt) {
+        if (indicatorOpt.max != null && indicatorOpt.max > 0 && !indicatorOpt.min) {
+          indicatorOpt.min = 0;
+        } else if (indicatorOpt.min != null && indicatorOpt.min < 0 && !indicatorOpt.max) {
+          indicatorOpt.max = 0;
+        }
+        var iNameTextStyle = nameTextStyle;
+        if (indicatorOpt.color != null) {
+          iNameTextStyle = defaults({
+            color: indicatorOpt.color
+          }, nameTextStyle);
+        }
+        var innerIndicatorOpt = merge(clone(indicatorOpt), {
+          boundaryGap,
+          splitNumber,
+          scale,
+          axisLine,
+          axisTick,
+          // axisType: axisType,
+          axisLabel,
+          // Compatible with 2 and use text
+          name: indicatorOpt.text,
+          showName,
+          nameLocation: "end",
+          nameGap,
+          // min: 0,
+          nameTextStyle: iNameTextStyle,
+          triggerEvent
+        }, false);
+        if (isString(nameFormatter)) {
+          var indName = innerIndicatorOpt.name;
+          innerIndicatorOpt.name = nameFormatter.replace("{value}", indName != null ? indName : "");
+        } else if (isFunction(nameFormatter)) {
+          innerIndicatorOpt.name = nameFormatter(innerIndicatorOpt.name, innerIndicatorOpt);
+        }
+        var model = new Model(innerIndicatorOpt, null, this.ecModel);
+        mixin(model, AxisModelCommonMixin.prototype);
+        model.mainType = "radar";
+        model.componentIndex = this.componentIndex;
+        return model;
+      }, this);
+      this._indicatorModels = indicatorModels;
+    };
+    RadarModel2.prototype.getIndicatorModels = function() {
+      return this._indicatorModels;
+    };
+    RadarModel2.type = "radar";
+    RadarModel2.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      center: ["50%", "50%"],
+      radius: "75%",
+      startAngle: 90,
+      axisName: {
+        show: true
+        // formatter: null
+        // textStyle: {}
+      },
+      boundaryGap: [0, 0],
+      splitNumber: 5,
+      axisNameGap: 15,
+      scale: false,
+      // Polygon or circle
+      shape: "polygon",
+      axisLine: merge({
+        lineStyle: {
+          color: "#bbb"
+        }
+      }, valueAxisDefault.axisLine),
+      axisLabel: defaultsShow(valueAxisDefault.axisLabel, false),
+      axisTick: defaultsShow(valueAxisDefault.axisTick, false),
+      // axisType: 'value',
+      splitLine: defaultsShow(valueAxisDefault.splitLine, true),
+      splitArea: defaultsShow(valueAxisDefault.splitArea, true),
+      // {text, min, max}
+      indicator: []
+    };
+    return RadarModel2;
+  }(ComponentModel)
+);
+export {
+  RadarModel as default
+};