@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/pie/pieLayout.mjs

@@ -0,0 +1,185 @@
+import { linearMap, parsePercent } from "../../util/number.mjs";
+import { getLayoutRect } from "../../util/layout.mjs";
+import { isArray } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { normalizeArcAngles } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/PathProxy.mjs";
+import { makeInner } from "../../util/model.mjs";
+var PI2 = Math.PI * 2;
+var RADIAN = Math.PI / 180;
+function getViewRect(seriesModel, api) {
+  return getLayoutRect(seriesModel.getBoxLayoutParams(), {
+    width: api.getWidth(),
+    height: api.getHeight()
+  });
+}
+function getBasicPieLayout(seriesModel, api) {
+  var viewRect = getViewRect(seriesModel, api);
+  var center = seriesModel.get("center");
+  var radius = seriesModel.get("radius");
+  if (!isArray(radius)) {
+    radius = [0, radius];
+  }
+  var width = parsePercent(viewRect.width, api.getWidth());
+  var height = parsePercent(viewRect.height, api.getHeight());
+  var size = Math.min(width, height);
+  var r0 = parsePercent(radius[0], size / 2);
+  var r = parsePercent(radius[1], size / 2);
+  var cx;
+  var cy;
+  var coordSys = seriesModel.coordinateSystem;
+  if (coordSys) {
+    var point = coordSys.dataToPoint(center);
+    cx = point[0] || 0;
+    cy = point[1] || 0;
+  } else {
+    if (!isArray(center)) {
+      center = [center, center];
+    }
+    cx = parsePercent(center[0], width) + viewRect.x;
+    cy = parsePercent(center[1], height) + viewRect.y;
+  }
+  return {
+    cx,
+    cy,
+    r0,
+    r
+  };
+}
+function pieLayout(seriesType, ecModel, api) {
+  ecModel.eachSeriesByType(seriesType, function(seriesModel) {
+    var data = seriesModel.getData();
+    var valueDim = data.mapDimension("value");
+    var viewRect = getViewRect(seriesModel, api);
+    var _a = getBasicPieLayout(seriesModel, api), cx = _a.cx, cy = _a.cy, r = _a.r, r0 = _a.r0;
+    var startAngle = -seriesModel.get("startAngle") * RADIAN;
+    var endAngle = seriesModel.get("endAngle");
+    var padAngle = seriesModel.get("padAngle") * RADIAN;
+    endAngle = endAngle === "auto" ? startAngle - PI2 : -endAngle * RADIAN;
+    var minAngle = seriesModel.get("minAngle") * RADIAN;
+    var minAndPadAngle = minAngle + padAngle;
+    var validDataCount = 0;
+    data.each(valueDim, function(value) {
+      !isNaN(value) && validDataCount++;
+    });
+    var sum = data.getSum(valueDim);
+    var unitRadian = Math.PI / (sum || validDataCount) * 2;
+    var clockwise = seriesModel.get("clockwise");
+    var roseType = seriesModel.get("roseType");
+    var stillShowZeroSum = seriesModel.get("stillShowZeroSum");
+    var extent = data.getDataExtent(valueDim);
+    extent[0] = 0;
+    var dir = clockwise ? 1 : -1;
+    var angles = [startAngle, endAngle];
+    var halfPadAngle = dir * padAngle / 2;
+    normalizeArcAngles(angles, !clockwise);
+    startAngle = angles[0], endAngle = angles[1];
+    var layoutData = getSeriesLayoutData(seriesModel);
+    layoutData.startAngle = startAngle;
+    layoutData.endAngle = endAngle;
+    layoutData.clockwise = clockwise;
+    var angleRange = Math.abs(endAngle - startAngle);
+    var restAngle = angleRange;
+    var valueSumLargerThanMinAngle = 0;
+    var currentAngle = startAngle;
+    data.setLayout({
+      viewRect,
+      r
+    });
+    data.each(valueDim, function(value, idx) {
+      var angle;
+      if (isNaN(value)) {
+        data.setItemLayout(idx, {
+          angle: NaN,
+          startAngle: NaN,
+          endAngle: NaN,
+          clockwise,
+          cx,
+          cy,
+          r0,
+          r: roseType ? NaN : r
+        });
+        return;
+      }
+      if (roseType !== "area") {
+        angle = sum === 0 && stillShowZeroSum ? unitRadian : value * unitRadian;
+      } else {
+        angle = angleRange / validDataCount;
+      }
+      if (angle < minAndPadAngle) {
+        angle = minAndPadAngle;
+        restAngle -= minAndPadAngle;
+      } else {
+        valueSumLargerThanMinAngle += value;
+      }
+      var endAngle2 = currentAngle + dir * angle;
+      var actualStartAngle = 0;
+      var actualEndAngle = 0;
+      if (padAngle > angle) {
+        actualStartAngle = currentAngle + dir * angle / 2;
+        actualEndAngle = actualStartAngle;
+      } else {
+        actualStartAngle = currentAngle + halfPadAngle;
+        actualEndAngle = endAngle2 - halfPadAngle;
+      }
+      data.setItemLayout(idx, {
+        angle,
+        startAngle: actualStartAngle,
+        endAngle: actualEndAngle,
+        clockwise,
+        cx,
+        cy,
+        r0,
+        r: roseType ? linearMap(value, extent, [r0, r]) : r
+      });
+      currentAngle = endAngle2;
+    });
+    if (restAngle < PI2 && validDataCount) {
+      if (restAngle <= 1e-3) {
+        var angle_1 = angleRange / validDataCount;
+        data.each(valueDim, function(value, idx) {
+          if (!isNaN(value)) {
+            var layout_1 = data.getItemLayout(idx);
+            layout_1.angle = angle_1;
+            var actualStartAngle = 0;
+            var actualEndAngle = 0;
+            if (angle_1 < padAngle) {
+              actualStartAngle = startAngle + dir * (idx + 1 / 2) * angle_1;
+              actualEndAngle = actualStartAngle;
+            } else {
+              actualStartAngle = startAngle + dir * idx * angle_1 + halfPadAngle;
+              actualEndAngle = startAngle + dir * (idx + 1) * angle_1 - halfPadAngle;
+            }
+            layout_1.startAngle = actualStartAngle;
+            layout_1.endAngle = actualEndAngle;
+          }
+        });
+      } else {
+        unitRadian = restAngle / valueSumLargerThanMinAngle;
+        currentAngle = startAngle;
+        data.each(valueDim, function(value, idx) {
+          if (!isNaN(value)) {
+            var layout_2 = data.getItemLayout(idx);
+            var angle = layout_2.angle === minAndPadAngle ? minAndPadAngle : value * unitRadian;
+            var actualStartAngle = 0;
+            var actualEndAngle = 0;
+            if (angle < padAngle) {
+              actualStartAngle = currentAngle + dir * angle / 2;
+              actualEndAngle = actualStartAngle;
+            } else {
+              actualStartAngle = currentAngle + halfPadAngle;
+              actualEndAngle = currentAngle + dir * angle - halfPadAngle;
+            }
+            layout_2.startAngle = actualStartAngle;
+            layout_2.endAngle = actualEndAngle;
+            currentAngle += dir * angle;
+          }
+        });
+      }
+    }
+  });
+}
+var getSeriesLayoutData = makeInner();
+export {
+  pieLayout as default,
+  getBasicPieLayout,
+  getSeriesLayoutData
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/radar/RadarSeries.mjs

@@ -0,0 +1,92 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import SeriesModel from "../../model/Series.mjs";
+import createSeriesDataSimply from "../helper/createSeriesDataSimply.mjs";
+import { bind, map } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import LegendVisualProvider from "../../visual/LegendVisualProvider.mjs";
+import { retrieveVisualColorForTooltipMarker, createTooltipMarkup } from "../../component/tooltip/tooltipMarkup.mjs";
+var RadarSeriesModel = (
+  /** @class */
+  function(_super) {
+    __extends(RadarSeriesModel2, _super);
+    function RadarSeriesModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = RadarSeriesModel2.type;
+      _this.hasSymbolVisual = true;
+      return _this;
+    }
+    RadarSeriesModel2.prototype.init = function(option) {
+      _super.prototype.init.apply(this, arguments);
+      this.legendVisualProvider = new LegendVisualProvider(bind(this.getData, this), bind(this.getRawData, this));
+    };
+    RadarSeriesModel2.prototype.getInitialData = function(option, ecModel) {
+      return createSeriesDataSimply(this, {
+        generateCoord: "indicator_",
+        generateCoordCount: Infinity
+      });
+    };
+    RadarSeriesModel2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) {
+      var data = this.getData();
+      var coordSys = this.coordinateSystem;
+      var indicatorAxes = coordSys.getIndicatorAxes();
+      var name = this.getData().getName(dataIndex);
+      var nameToDisplay = name === "" ? this.name : name;
+      var markerColor = retrieveVisualColorForTooltipMarker(this, dataIndex);
+      return createTooltipMarkup("section", {
+        header: nameToDisplay,
+        sortBlocks: true,
+        blocks: map(indicatorAxes, function(axis) {
+          var val = data.get(data.mapDimension(axis.dim), dataIndex);
+          return createTooltipMarkup("nameValue", {
+            markerType: "subItem",
+            markerColor,
+            name: axis.name,
+            value: val,
+            sortParam: val
+          });
+        })
+      });
+    };
+    RadarSeriesModel2.prototype.getTooltipPosition = function(dataIndex) {
+      if (dataIndex != null) {
+        var data_1 = this.getData();
+        var coordSys = this.coordinateSystem;
+        var values = data_1.getValues(map(coordSys.dimensions, function(dim) {
+          return data_1.mapDimension(dim);
+        }), dataIndex);
+        for (var i = 0, len = values.length; i < len; i++) {
+          if (!isNaN(values[i])) {
+            var indicatorAxes = coordSys.getIndicatorAxes();
+            return coordSys.coordToPoint(indicatorAxes[i].dataToCoord(values[i]), i);
+          }
+        }
+      }
+    };
+    RadarSeriesModel2.type = "series.radar";
+    RadarSeriesModel2.dependencies = ["radar"];
+    RadarSeriesModel2.defaultOption = {
+      // zlevel: 0,
+      z: 2,
+      colorBy: "data",
+      coordinateSystem: "radar",
+      legendHoverLink: true,
+      radarIndex: 0,
+      lineStyle: {
+        width: 2,
+        type: "solid",
+        join: "round"
+      },
+      label: {
+        position: "top"
+      },
+      // areaStyle: {
+      // },
+      // itemStyle: {}
+      symbolSize: 8
+      // symbolRotate: null
+    };
+    return RadarSeriesModel2;
+  }(SeriesModel)
+);
+export {
+  RadarSeriesModel as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/radar/RadarView.mjs

@@ -0,0 +1,187 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import * as graphic from "../../util/graphic.mjs";
+import { setStatesStylesFromModel, toggleHoverEmphasis } from "../../util/states.mjs";
+import { defaults, each, extend, clone, map } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { normalizeSymbolSize, createSymbol } from "../../util/symbol.mjs";
+import ChartView from "../../view/Chart.mjs";
+import { setLabelStyle, getLabelStatesModels } from "../../label/labelStyle.mjs";
+import ZRImage from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Image.mjs";
+import { initProps, saveOldStyle, updateProps } from "../../animation/basicTransition.mjs";
+import Polygon from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polygon.mjs";
+import Polyline from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polyline.mjs";
+import Group from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.mjs";
+var RadarView = (
+  /** @class */
+  function(_super) {
+    __extends(RadarView2, _super);
+    function RadarView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = RadarView2.type;
+      return _this;
+    }
+    RadarView2.prototype.render = function(seriesModel, ecModel, api) {
+      var polar = seriesModel.coordinateSystem;
+      var group = this.group;
+      var data = seriesModel.getData();
+      var oldData = this._data;
+      function createSymbol$1(data2, idx) {
+        var symbolType = data2.getItemVisual(idx, "symbol") || "circle";
+        if (symbolType === "none") {
+          return;
+        }
+        var symbolSize = normalizeSymbolSize(data2.getItemVisual(idx, "symbolSize"));
+        var symbolPath = createSymbol(symbolType, -1, -1, 2, 2);
+        var symbolRotate = data2.getItemVisual(idx, "symbolRotate") || 0;
+        symbolPath.attr({
+          style: {
+            strokeNoScale: true
+          },
+          z2: 100,
+          scaleX: symbolSize[0] / 2,
+          scaleY: symbolSize[1] / 2,
+          rotation: symbolRotate * Math.PI / 180 || 0
+        });
+        return symbolPath;
+      }
+      function updateSymbols(oldPoints, newPoints, symbolGroup, data2, idx, isInit) {
+        symbolGroup.removeAll();
+        for (var i = 0; i < newPoints.length - 1; i++) {
+          var symbolPath = createSymbol$1(data2, idx);
+          if (symbolPath) {
+            symbolPath.__dimIdx = i;
+            if (oldPoints[i]) {
+              symbolPath.setPosition(oldPoints[i]);
+              graphic[isInit ? "initProps" : "updateProps"](symbolPath, {
+                x: newPoints[i][0],
+                y: newPoints[i][1]
+              }, seriesModel, idx);
+            } else {
+              symbolPath.setPosition(newPoints[i]);
+            }
+            symbolGroup.add(symbolPath);
+          }
+        }
+      }
+      function getInitialPoints(points) {
+        return map(points, function(pt) {
+          return [polar.cx, polar.cy];
+        });
+      }
+      data.diff(oldData).add(function(idx) {
+        var points = data.getItemLayout(idx);
+        if (!points) {
+          return;
+        }
+        var polygon = new Polygon();
+        var polyline = new Polyline();
+        var target = {
+          shape: {
+            points
+          }
+        };
+        polygon.shape.points = getInitialPoints(points);
+        polyline.shape.points = getInitialPoints(points);
+        initProps(polygon, target, seriesModel, idx);
+        initProps(polyline, target, seriesModel, idx);
+        var itemGroup = new Group();
+        var symbolGroup = new Group();
+        itemGroup.add(polyline);
+        itemGroup.add(polygon);
+        itemGroup.add(symbolGroup);
+        updateSymbols(polyline.shape.points, points, symbolGroup, data, idx, true);
+        data.setItemGraphicEl(idx, itemGroup);
+      }).update(function(newIdx, oldIdx) {
+        var itemGroup = oldData.getItemGraphicEl(oldIdx);
+        var polyline = itemGroup.childAt(0);
+        var polygon = itemGroup.childAt(1);
+        var symbolGroup = itemGroup.childAt(2);
+        var target = {
+          shape: {
+            points: data.getItemLayout(newIdx)
+          }
+        };
+        if (!target.shape.points) {
+          return;
+        }
+        updateSymbols(polyline.shape.points, target.shape.points, symbolGroup, data, newIdx, false);
+        saveOldStyle(polygon);
+        saveOldStyle(polyline);
+        updateProps(polyline, target, seriesModel);
+        updateProps(polygon, target, seriesModel);
+        data.setItemGraphicEl(newIdx, itemGroup);
+      }).remove(function(idx) {
+        group.remove(oldData.getItemGraphicEl(idx));
+      }).execute();
+      data.eachItemGraphicEl(function(itemGroup, idx) {
+        var itemModel = data.getItemModel(idx);
+        var polyline = itemGroup.childAt(0);
+        var polygon = itemGroup.childAt(1);
+        var symbolGroup = itemGroup.childAt(2);
+        var itemStyle = data.getItemVisual(idx, "style");
+        var color = itemStyle.fill;
+        group.add(itemGroup);
+        polyline.useStyle(defaults(itemModel.getModel("lineStyle").getLineStyle(), {
+          fill: "none",
+          stroke: color
+        }));
+        setStatesStylesFromModel(polyline, itemModel, "lineStyle");
+        setStatesStylesFromModel(polygon, itemModel, "areaStyle");
+        var areaStyleModel = itemModel.getModel("areaStyle");
+        var polygonIgnore = areaStyleModel.isEmpty() && areaStyleModel.parentModel.isEmpty();
+        polygon.ignore = polygonIgnore;
+        each(["emphasis", "select", "blur"], function(stateName) {
+          var stateModel = itemModel.getModel([stateName, "areaStyle"]);
+          var stateIgnore = stateModel.isEmpty() && stateModel.parentModel.isEmpty();
+          polygon.ensureState(stateName).ignore = stateIgnore && polygonIgnore;
+        });
+        polygon.useStyle(defaults(areaStyleModel.getAreaStyle(), {
+          fill: color,
+          opacity: 0.7,
+          decal: itemStyle.decal
+        }));
+        var emphasisModel = itemModel.getModel("emphasis");
+        var itemHoverStyle = emphasisModel.getModel("itemStyle").getItemStyle();
+        symbolGroup.eachChild(function(symbolPath) {
+          if (symbolPath instanceof ZRImage) {
+            var pathStyle = symbolPath.style;
+            symbolPath.useStyle(extend({
+              // TODO other properties like x, y ?
+              image: pathStyle.image,
+              x: pathStyle.x,
+              y: pathStyle.y,
+              width: pathStyle.width,
+              height: pathStyle.height
+            }, itemStyle));
+          } else {
+            symbolPath.useStyle(itemStyle);
+            symbolPath.setColor(color);
+            symbolPath.style.strokeNoScale = true;
+          }
+          var pathEmphasisState = symbolPath.ensureState("emphasis");
+          pathEmphasisState.style = clone(itemHoverStyle);
+          var defaultText = data.getStore().get(data.getDimensionIndex(symbolPath.__dimIdx), idx);
+          (defaultText == null || isNaN(defaultText)) && (defaultText = "");
+          setLabelStyle(symbolPath, getLabelStatesModels(itemModel), {
+            labelFetcher: data.hostModel,
+            labelDataIndex: idx,
+            labelDimIndex: symbolPath.__dimIdx,
+            defaultText,
+            inheritColor: color,
+            defaultOpacity: itemStyle.opacity
+          });
+        });
+        toggleHoverEmphasis(itemGroup, emphasisModel.get("focus"), emphasisModel.get("blurScope"), emphasisModel.get("disabled"));
+      });
+      this._data = data;
+    };
+    RadarView2.prototype.remove = function() {
+      this.group.removeAll();
+      this._data = null;
+    };
+    RadarView2.type = "radar";
+    return RadarView2;
+  }(ChartView)
+);
+export {
+  RadarView as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/radar/backwardCompat.mjs

@@ -0,0 +1,33 @@
+import { isArray, each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function radarBackwardCompat(option) {
+  var polarOptArr = option.polar;
+  if (polarOptArr) {
+    if (!isArray(polarOptArr)) {
+      polarOptArr = [polarOptArr];
+    }
+    var polarNotRadar_1 = [];
+    each(polarOptArr, function(polarOpt, idx) {
+      if (polarOpt.indicator) {
+        if (polarOpt.type && !polarOpt.shape) {
+          polarOpt.shape = polarOpt.type;
+        }
+        option.radar = option.radar || [];
+        if (!isArray(option.radar)) {
+          option.radar = [option.radar];
+        }
+        option.radar.push(polarOpt);
+      } else {
+        polarNotRadar_1.push(polarOpt);
+      }
+    });
+    option.polar = polarNotRadar_1;
+  }
+  each(option.series, function(seriesOpt) {
+    if (seriesOpt && seriesOpt.type === "radar" && seriesOpt.polarIndex) {
+      seriesOpt.radarIndex = seriesOpt.polarIndex;
+    }
+  });
+}
+export {
+  radarBackwardCompat as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/radar/install.mjs

@@ -0,0 +1,18 @@
+import { use } from "../../extension.mjs";
+import radarLayout from "./radarLayout.mjs";
+import dataFilter from "../../processor/dataFilter.mjs";
+import radarBackwardCompat from "./backwardCompat.mjs";
+import RadarView from "./RadarView.mjs";
+import RadarSeriesModel from "./RadarSeries.mjs";
+import { install as install$1 } from "../../component/radar/install.mjs";
+function install(registers) {
+  use(install$1);
+  registers.registerChartView(RadarView);
+  registers.registerSeriesModel(RadarSeriesModel);
+  registers.registerLayout(radarLayout);
+  registers.registerProcessor(dataFilter("radar"));
+  registers.registerPreprocessor(radarBackwardCompat);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/radar/radarLayout.mjs

@@ -0,0 +1,35 @@
+import { each, find } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function radarLayout(ecModel) {
+  ecModel.eachSeriesByType("radar", function(seriesModel) {
+    var data = seriesModel.getData();
+    var points = [];
+    var coordSys = seriesModel.coordinateSystem;
+    if (!coordSys) {
+      return;
+    }
+    var axes = coordSys.getIndicatorAxes();
+    each(axes, function(axis, axisIndex) {
+      data.each(data.mapDimension(axes[axisIndex].dim), function(val, dataIndex) {
+        points[dataIndex] = points[dataIndex] || [];
+        var point = coordSys.dataToPoint(val, axisIndex);
+        points[dataIndex][axisIndex] = isValidPoint(point) ? point : getValueMissingPoint(coordSys);
+      });
+    });
+    data.each(function(idx) {
+      var firstPoint = find(points[idx], function(point) {
+        return isValidPoint(point);
+      }) || getValueMissingPoint(coordSys);
+      points[idx].push(firstPoint.slice());
+      data.setItemLayout(idx, points[idx]);
+    });
+  });
+}
+function isValidPoint(point) {
+  return !isNaN(point[0]) && !isNaN(point[1]);
+}
+function getValueMissingPoint(coordSys) {
+  return [coordSys.cx, coordSys.cy];
+}
+export {
+  radarLayout as default
+};