@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/dataFormat.mjs

@@ -0,0 +1,108 @@
+import { isArray, isFunction, isString, isObject } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { retrieveRawValue } from "../../data/helper/dataProvider.mjs";
+import { formatTpl } from "../../util/format.mjs";
+var DIMENSION_LABEL_REG = /\{@(.+?)\}/g;
+var DataFormatMixin = (
+  /** @class */
+  function() {
+    function DataFormatMixin2() {
+    }
+    DataFormatMixin2.prototype.getDataParams = function(dataIndex, dataType) {
+      var data = this.getData(dataType);
+      var rawValue = this.getRawValue(dataIndex, dataType);
+      var rawDataIndex = data.getRawIndex(dataIndex);
+      var name = data.getName(dataIndex);
+      var itemOpt = data.getRawDataItem(dataIndex);
+      var style = data.getItemVisual(dataIndex, "style");
+      var color = style && style[data.getItemVisual(dataIndex, "drawType") || "fill"];
+      var borderColor = style && style.stroke;
+      var mainType = this.mainType;
+      var isSeries = mainType === "series";
+      var userOutput = data.userOutput && data.userOutput.get();
+      return {
+        componentType: mainType,
+        componentSubType: this.subType,
+        componentIndex: this.componentIndex,
+        seriesType: isSeries ? this.subType : null,
+        seriesIndex: this.seriesIndex,
+        seriesId: isSeries ? this.id : null,
+        seriesName: isSeries ? this.name : null,
+        name,
+        dataIndex: rawDataIndex,
+        data: itemOpt,
+        dataType,
+        value: rawValue,
+        color,
+        borderColor,
+        dimensionNames: userOutput ? userOutput.fullDimensions : null,
+        encode: userOutput ? userOutput.encode : null,
+        // Param name list for mapping `a`, `b`, `c`, `d`, `e`
+        $vars: ["seriesName", "name", "value"]
+      };
+    };
+    DataFormatMixin2.prototype.getFormattedLabel = function(dataIndex, status, dataType, labelDimIndex, formatter, extendParams) {
+      status = status || "normal";
+      var data = this.getData(dataType);
+      var params = this.getDataParams(dataIndex, dataType);
+      if (extendParams) {
+        params.value = extendParams.interpolatedValue;
+      }
+      if (labelDimIndex != null && isArray(params.value)) {
+        params.value = params.value[labelDimIndex];
+      }
+      if (!formatter) {
+        var itemModel = data.getItemModel(dataIndex);
+        formatter = itemModel.get(status === "normal" ? ["label", "formatter"] : [status, "label", "formatter"]);
+      }
+      if (isFunction(formatter)) {
+        params.status = status;
+        params.dimensionIndex = labelDimIndex;
+        return formatter(params);
+      } else if (isString(formatter)) {
+        var str = formatTpl(formatter, params);
+        return str.replace(DIMENSION_LABEL_REG, function(origin, dimStr) {
+          var len = dimStr.length;
+          var dimLoose = dimStr;
+          if (dimLoose.charAt(0) === "[" && dimLoose.charAt(len - 1) === "]") {
+            dimLoose = +dimLoose.slice(1, len - 1);
+          }
+          var val = retrieveRawValue(data, dataIndex, dimLoose);
+          if (extendParams && isArray(extendParams.interpolatedValue)) {
+            var dimIndex = data.getDimensionIndex(dimLoose);
+            if (dimIndex >= 0) {
+              val = extendParams.interpolatedValue[dimIndex];
+            }
+          }
+          return val != null ? val + "" : "";
+        });
+      }
+    };
+    DataFormatMixin2.prototype.getRawValue = function(idx, dataType) {
+      return retrieveRawValue(this.getData(dataType), idx);
+    };
+    DataFormatMixin2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) {
+      return;
+    };
+    return DataFormatMixin2;
+  }()
+);
+function normalizeTooltipFormatResult(result) {
+  var markupText;
+  var markupFragment;
+  if (isObject(result)) {
+    if (result.type) {
+      markupFragment = result;
+    }
+  } else {
+    markupText = result;
+  }
+  return {
+    text: markupText,
+    // markers: markers || markersExisting,
+    frag: markupFragment
+  };
+}
+export {
+  DataFormatMixin,
+  normalizeTooltipFormatResult
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/itemStyle.mjs

@@ -0,0 +1,34 @@
+import makeStyleMapper from "./makeStyleMapper.mjs";
+var ITEM_STYLE_KEY_MAP = [
+  ["fill", "color"],
+  ["stroke", "borderColor"],
+  ["lineWidth", "borderWidth"],
+  ["opacity"],
+  ["shadowBlur"],
+  ["shadowOffsetX"],
+  ["shadowOffsetY"],
+  ["shadowColor"],
+  ["lineDash", "borderType"],
+  ["lineDashOffset", "borderDashOffset"],
+  ["lineCap", "borderCap"],
+  ["lineJoin", "borderJoin"],
+  ["miterLimit", "borderMiterLimit"]
+  // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+  // So do not transfer decal directly.
+];
+var getItemStyle = makeStyleMapper(ITEM_STYLE_KEY_MAP);
+var ItemStyleMixin = (
+  /** @class */
+  function() {
+    function ItemStyleMixin2() {
+    }
+    ItemStyleMixin2.prototype.getItemStyle = function(excludes, includes) {
+      return getItemStyle(this, excludes, includes);
+    };
+    return ItemStyleMixin2;
+  }()
+);
+export {
+  ITEM_STYLE_KEY_MAP,
+  ItemStyleMixin
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/lineStyle.mjs

@@ -0,0 +1,33 @@
+import makeStyleMapper from "./makeStyleMapper.mjs";
+var LINE_STYLE_KEY_MAP = [
+  ["lineWidth", "width"],
+  ["stroke", "color"],
+  ["opacity"],
+  ["shadowBlur"],
+  ["shadowOffsetX"],
+  ["shadowOffsetY"],
+  ["shadowColor"],
+  ["lineDash", "type"],
+  ["lineDashOffset", "dashOffset"],
+  ["lineCap", "cap"],
+  ["lineJoin", "join"],
+  ["miterLimit"]
+  // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+  // So do not transfer decal directly.
+];
+var getLineStyle = makeStyleMapper(LINE_STYLE_KEY_MAP);
+var LineStyleMixin = (
+  /** @class */
+  function() {
+    function LineStyleMixin2() {
+    }
+    LineStyleMixin2.prototype.getLineStyle = function(excludes) {
+      return getLineStyle(this, excludes);
+    };
+    return LineStyleMixin2;
+  }()
+);
+export {
+  LINE_STYLE_KEY_MAP,
+  LineStyleMixin
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/makeStyleMapper.mjs

@@ -0,0 +1,26 @@
+import { indexOf } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function makeStyleMapper(properties, ignoreParent) {
+  for (var i = 0; i < properties.length; i++) {
+    if (!properties[i][1]) {
+      properties[i][1] = properties[i][0];
+    }
+  }
+  ignoreParent = ignoreParent || false;
+  return function(model, excludes, includes) {
+    var style = {};
+    for (var i2 = 0; i2 < properties.length; i2++) {
+      var propName = properties[i2][1];
+      if (excludes && indexOf(excludes, propName) >= 0 || includes && indexOf(includes, propName) < 0) {
+        continue;
+      }
+      var val = model.getShallow(propName, ignoreParent);
+      if (val != null) {
+        style[properties[i2][0]] = val;
+      }
+    }
+    return style;
+  };
+}
+export {
+  makeStyleMapper as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/palette.mjs

@@ -0,0 +1,55 @@
+import { makeInner, normalizeToArray } from "../../util/model.mjs";
+var innerColor = makeInner();
+makeInner();
+var PaletteMixin = (
+  /** @class */
+  function() {
+    function PaletteMixin2() {
+    }
+    PaletteMixin2.prototype.getColorFromPalette = function(name, scope, requestNum) {
+      var defaultPalette = normalizeToArray(this.get("color", true));
+      var layeredPalette = this.get("colorLayer", true);
+      return getFromPalette(this, innerColor, defaultPalette, layeredPalette, name, scope, requestNum);
+    };
+    PaletteMixin2.prototype.clearColorPalette = function() {
+      clearPalette(this, innerColor);
+    };
+    return PaletteMixin2;
+  }()
+);
+function getNearestPalette(palettes, requestColorNum) {
+  var paletteNum = palettes.length;
+  for (var i = 0; i < paletteNum; i++) {
+    if (palettes[i].length > requestColorNum) {
+      return palettes[i];
+    }
+  }
+  return palettes[paletteNum - 1];
+}
+function getFromPalette(that, inner, defaultPalette, layeredPalette, name, scope, requestNum) {
+  scope = scope || that;
+  var scopeFields = inner(scope);
+  var paletteIdx = scopeFields.paletteIdx || 0;
+  var paletteNameMap = scopeFields.paletteNameMap = scopeFields.paletteNameMap || {};
+  if (paletteNameMap.hasOwnProperty(name)) {
+    return paletteNameMap[name];
+  }
+  var palette = requestNum == null || !layeredPalette ? defaultPalette : getNearestPalette(layeredPalette, requestNum);
+  palette = palette || defaultPalette;
+  if (!palette || !palette.length) {
+    return;
+  }
+  var pickedPaletteItem = palette[paletteIdx];
+  if (name) {
+    paletteNameMap[name] = pickedPaletteItem;
+  }
+  scopeFields.paletteIdx = (paletteIdx + 1) % palette.length;
+  return pickedPaletteItem;
+}
+function clearPalette(that, inner) {
+  inner(that).paletteIdx = 0;
+  inner(that).paletteNameMap = {};
+}
+export {
+  PaletteMixin
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/textStyle.mjs

@@ -0,0 +1,40 @@
+import { getFont } from "../../label/labelStyle.mjs";
+import ZRText from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.mjs";
+var PATH_COLOR = ["textStyle", "color"];
+var textStyleParams = ["fontStyle", "fontWeight", "fontSize", "fontFamily", "padding", "lineHeight", "rich", "width", "height", "overflow"];
+var tmpText = new ZRText();
+var TextStyleMixin = (
+  /** @class */
+  function() {
+    function TextStyleMixin2() {
+    }
+    TextStyleMixin2.prototype.getTextColor = function(isEmphasis) {
+      var ecModel = this.ecModel;
+      return this.getShallow("color") || (!isEmphasis && ecModel ? ecModel.get(PATH_COLOR) : null);
+    };
+    TextStyleMixin2.prototype.getFont = function() {
+      return getFont({
+        fontStyle: this.getShallow("fontStyle"),
+        fontWeight: this.getShallow("fontWeight"),
+        fontSize: this.getShallow("fontSize"),
+        fontFamily: this.getShallow("fontFamily")
+      }, this.ecModel);
+    };
+    TextStyleMixin2.prototype.getTextRect = function(text) {
+      var style = {
+        text,
+        verticalAlign: this.getShallow("verticalAlign") || this.getShallow("baseline")
+      };
+      for (var i = 0; i < textStyleParams.length; i++) {
+        style[textStyleParams[i]] = this.getShallow(textStyleParams[i]);
+      }
+      tmpText.useStyle(style);
+      tmpText.update();
+      return tmpText.getBoundingRect();
+    };
+    return TextStyleMixin2;
+  }()
+);
+export {
+  TextStyleMixin as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/referHelper.mjs

@@ -0,0 +1,90 @@
+import { each, createHashMap } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { SINGLE_REFERRING } from "../util/model.mjs";
+var CoordSysInfo = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function CoordSysInfo2(coordSysName) {
+      this.coordSysDims = [];
+      this.axisMap = createHashMap();
+      this.categoryAxisMap = createHashMap();
+      this.coordSysName = coordSysName;
+    }
+    return CoordSysInfo2;
+  }()
+);
+function getCoordSysInfoBySeries(seriesModel) {
+  var coordSysName = seriesModel.get("coordinateSystem");
+  var result = new CoordSysInfo(coordSysName);
+  var fetch = fetchers[coordSysName];
+  if (fetch) {
+    fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
+    return result;
+  }
+}
+var fetchers = {
+  cartesian2d: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var xAxisModel = seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0];
+    var yAxisModel = seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0];
+    result.coordSysDims = ["x", "y"];
+    axisMap.set("x", xAxisModel);
+    axisMap.set("y", yAxisModel);
+    if (isCategory(xAxisModel)) {
+      categoryAxisMap.set("x", xAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(yAxisModel)) {
+      categoryAxisMap.set("y", yAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  singleAxis: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var singleAxisModel = seriesModel.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0];
+    result.coordSysDims = ["single"];
+    axisMap.set("single", singleAxisModel);
+    if (isCategory(singleAxisModel)) {
+      categoryAxisMap.set("single", singleAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+  },
+  polar: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var polarModel = seriesModel.getReferringComponents("polar", SINGLE_REFERRING).models[0];
+    var radiusAxisModel = polarModel.findAxisModel("radiusAxis");
+    var angleAxisModel = polarModel.findAxisModel("angleAxis");
+    result.coordSysDims = ["radius", "angle"];
+    axisMap.set("radius", radiusAxisModel);
+    axisMap.set("angle", angleAxisModel);
+    if (isCategory(radiusAxisModel)) {
+      categoryAxisMap.set("radius", radiusAxisModel);
+      result.firstCategoryDimIndex = 0;
+    }
+    if (isCategory(angleAxisModel)) {
+      categoryAxisMap.set("angle", angleAxisModel);
+      result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1);
+    }
+  },
+  geo: function(seriesModel, result, axisMap, categoryAxisMap) {
+    result.coordSysDims = ["lng", "lat"];
+  },
+  parallel: function(seriesModel, result, axisMap, categoryAxisMap) {
+    var ecModel = seriesModel.ecModel;
+    var parallelModel = ecModel.getComponent("parallel", seriesModel.get("parallelIndex"));
+    var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice();
+    each(parallelModel.parallelAxisIndex, function(axisIndex, index) {
+      var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
+      var axisDim = coordSysDims[index];
+      axisMap.set(axisDim, axisModel);
+      if (isCategory(axisModel)) {
+        categoryAxisMap.set(axisDim, axisModel);
+        if (result.firstCategoryDimIndex == null) {
+          result.firstCategoryDimIndex = index;
+        }
+      }
+    });
+  }
+};
+function isCategory(axisModel) {
+  return axisModel.get("type") === "category";
+}
+export {
+  getCoordSysInfoBySeries
+};

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

@@ -0,0 +1,178 @@
+import { each, isObject, isTypedArray, defaults, isArray } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import globalCompatStyle from "./helper/compatStyle.mjs";
+import { normalizeToArray } from "../util/model.mjs";
+function get(opt, path) {
+  var pathArr = path.split(",");
+  var obj = opt;
+  for (var i = 0; i < pathArr.length; i++) {
+    obj = obj && obj[pathArr[i]];
+    if (obj == null) {
+      break;
+    }
+  }
+  return obj;
+}
+function set(opt, path, val, overwrite) {
+  var pathArr = path.split(",");
+  var obj = opt;
+  var key;
+  var i = 0;
+  for (; i < pathArr.length - 1; i++) {
+    key = pathArr[i];
+    if (obj[key] == null) {
+      obj[key] = {};
+    }
+    obj = obj[key];
+  }
+  if (obj[pathArr[i]] == null) {
+    obj[pathArr[i]] = val;
+  }
+}
+function compatLayoutProperties(option) {
+  option && each(LAYOUT_PROPERTIES, function(prop) {
+    if (prop[0] in option && !(prop[1] in option)) {
+      option[prop[1]] = option[prop[0]];
+    }
+  });
+}
+var LAYOUT_PROPERTIES = [["x", "left"], ["y", "top"], ["x2", "right"], ["y2", "bottom"]];
+var COMPATITABLE_COMPONENTS = ["grid", "geo", "parallel", "legend", "toolbox", "title", "visualMap", "dataZoom", "timeline"];
+var BAR_ITEM_STYLE_MAP = [["borderRadius", "barBorderRadius"], ["borderColor", "barBorderColor"], ["borderWidth", "barBorderWidth"]];
+function compatBarItemStyle(option) {
+  var itemStyle = option && option.itemStyle;
+  if (itemStyle) {
+    for (var i = 0; i < BAR_ITEM_STYLE_MAP.length; i++) {
+      var oldName = BAR_ITEM_STYLE_MAP[i][1];
+      var newName = BAR_ITEM_STYLE_MAP[i][0];
+      if (itemStyle[oldName] != null) {
+        itemStyle[newName] = itemStyle[oldName];
+      }
+    }
+  }
+}
+function compatPieLabel(option) {
+  if (!option) {
+    return;
+  }
+  if (option.alignTo === "edge" && option.margin != null && option.edgeDistance == null) {
+    option.edgeDistance = option.margin;
+  }
+}
+function compatSunburstState(option) {
+  if (!option) {
+    return;
+  }
+  if (option.downplay && !option.blur) {
+    option.blur = option.downplay;
+  }
+}
+function compatGraphFocus(option) {
+  if (!option) {
+    return;
+  }
+  if (option.focusNodeAdjacency != null) {
+    option.emphasis = option.emphasis || {};
+    if (option.emphasis.focus == null) {
+      option.emphasis.focus = "adjacency";
+    }
+  }
+}
+function traverseTree(data, cb) {
+  if (data) {
+    for (var i = 0; i < data.length; i++) {
+      cb(data[i]);
+      data[i] && traverseTree(data[i].children, cb);
+    }
+  }
+}
+function globalBackwardCompat(option, isTheme) {
+  globalCompatStyle(option, isTheme);
+  option.series = normalizeToArray(option.series);
+  each(option.series, function(seriesOpt) {
+    if (!isObject(seriesOpt)) {
+      return;
+    }
+    var seriesType = seriesOpt.type;
+    if (seriesType === "line") {
+      if (seriesOpt.clipOverflow != null) {
+        seriesOpt.clip = seriesOpt.clipOverflow;
+      }
+    } else if (seriesType === "pie" || seriesType === "gauge") {
+      if (seriesOpt.clockWise != null) {
+        seriesOpt.clockwise = seriesOpt.clockWise;
+      }
+      compatPieLabel(seriesOpt.label);
+      var data = seriesOpt.data;
+      if (data && !isTypedArray(data)) {
+        for (var i = 0; i < data.length; i++) {
+          compatPieLabel(data[i]);
+        }
+      }
+      if (seriesOpt.hoverOffset != null) {
+        seriesOpt.emphasis = seriesOpt.emphasis || {};
+        if (seriesOpt.emphasis.scaleSize = null) {
+          seriesOpt.emphasis.scaleSize = seriesOpt.hoverOffset;
+        }
+      }
+    } else if (seriesType === "gauge") {
+      var pointerColor = get(seriesOpt, "pointer.color");
+      pointerColor != null && set(seriesOpt, "itemStyle.color", pointerColor);
+    } else if (seriesType === "bar") {
+      compatBarItemStyle(seriesOpt);
+      compatBarItemStyle(seriesOpt.backgroundStyle);
+      compatBarItemStyle(seriesOpt.emphasis);
+      var data = seriesOpt.data;
+      if (data && !isTypedArray(data)) {
+        for (var i = 0; i < data.length; i++) {
+          if (typeof data[i] === "object") {
+            compatBarItemStyle(data[i]);
+            compatBarItemStyle(data[i] && data[i].emphasis);
+          }
+        }
+      }
+    } else if (seriesType === "sunburst") {
+      var highlightPolicy = seriesOpt.highlightPolicy;
+      if (highlightPolicy) {
+        seriesOpt.emphasis = seriesOpt.emphasis || {};
+        if (!seriesOpt.emphasis.focus) {
+          seriesOpt.emphasis.focus = highlightPolicy;
+        }
+      }
+      compatSunburstState(seriesOpt);
+      traverseTree(seriesOpt.data, compatSunburstState);
+    } else if (seriesType === "graph" || seriesType === "sankey") {
+      compatGraphFocus(seriesOpt);
+    } else if (seriesType === "map") {
+      if (seriesOpt.mapType && !seriesOpt.map) {
+        seriesOpt.map = seriesOpt.mapType;
+      }
+      if (seriesOpt.mapLocation) {
+        defaults(seriesOpt, seriesOpt.mapLocation);
+      }
+    }
+    if (seriesOpt.hoverAnimation != null) {
+      seriesOpt.emphasis = seriesOpt.emphasis || {};
+      if (seriesOpt.emphasis && seriesOpt.emphasis.scale == null) {
+        seriesOpt.emphasis.scale = seriesOpt.hoverAnimation;
+      }
+    }
+    compatLayoutProperties(seriesOpt);
+  });
+  if (option.dataRange) {
+    option.visualMap = option.dataRange;
+  }
+  each(COMPATITABLE_COMPONENTS, function(componentName) {
+    var options = option[componentName];
+    if (options) {
+      if (!isArray(options)) {
+        options = [options];
+      }
+      each(options, function(option2) {
+        compatLayoutProperties(option2);
+      });
+    }
+  });
+}
+export {
+  globalBackwardCompat as default
+};