@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/tooltip/helper.mjs

@@ -0,0 +1,39 @@
+import { toCamelCase } from "../../util/format.mjs";
+import env from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.mjs";
+function shouldTooltipConfine(tooltipModel) {
+  var confineOption = tooltipModel.get("confine");
+  return confineOption != null ? !!confineOption : tooltipModel.get("renderMode") === "richText";
+}
+function testStyle(styleProps) {
+  if (!env.domSupported) {
+    return;
+  }
+  var style = document.documentElement.style;
+  for (var i = 0, len = styleProps.length; i < len; i++) {
+    if (styleProps[i] in style) {
+      return styleProps[i];
+    }
+  }
+}
+var TRANSFORM_VENDOR = testStyle(["transform", "webkitTransform", "OTransform", "MozTransform", "msTransform"]);
+var TRANSITION_VENDOR = testStyle(["webkitTransition", "transition", "OTransition", "MozTransition", "msTransition"]);
+function toCSSVendorPrefix(styleVendor, styleProp) {
+  if (!styleVendor) {
+    return styleProp;
+  }
+  styleProp = toCamelCase(styleProp, true);
+  var idx = styleVendor.indexOf(styleProp);
+  styleVendor = idx === -1 ? styleProp : "-" + styleVendor.slice(0, idx) + "-" + styleProp;
+  return styleVendor.toLowerCase();
+}
+function getComputedStyle(el, style) {
+  var stl = el.currentStyle || document.defaultView && document.defaultView.getComputedStyle(el);
+  return stl ? stl[style] : null;
+}
+export {
+  TRANSFORM_VENDOR,
+  TRANSITION_VENDOR,
+  getComputedStyle,
+  shouldTooltipConfine,
+  toCSSVendorPrefix
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/tooltip/install.mjs

@@ -0,0 +1,23 @@
+import { install as install$1 } from "../axisPointer/install.mjs";
+import { use } from "../../extension.mjs";
+import TooltipModel from "./TooltipModel.mjs";
+import TooltipView from "./TooltipView.mjs";
+import { noop } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function install(registers) {
+  use(install$1);
+  registers.registerComponentModel(TooltipModel);
+  registers.registerComponentView(TooltipView);
+  registers.registerAction({
+    type: "showTip",
+    event: "showTip",
+    update: "tooltip:manuallyShowTip"
+  }, noop);
+  registers.registerAction({
+    type: "hideTip",
+    event: "hideTip",
+    update: "tooltip:manuallyHideTip"
+  }, noop);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/tooltip/seriesFormatTooltip.mjs

@@ -0,0 +1,95 @@
+import { isArray, trim, reduce, each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { retrieveVisualColorForTooltipMarker, createTooltipMarkup } from "./tooltipMarkup.mjs";
+import { retrieveRawValue } from "../../data/helper/dataProvider.mjs";
+import { isNameSpecified } from "../../util/model.mjs";
+function defaultSeriesFormatTooltip(opt) {
+  var series = opt.series;
+  var dataIndex = opt.dataIndex;
+  var multipleSeries = opt.multipleSeries;
+  var data = series.getData();
+  var tooltipDims = data.mapDimensionsAll("defaultedTooltip");
+  var tooltipDimLen = tooltipDims.length;
+  var value = series.getRawValue(dataIndex);
+  var isValueArr = isArray(value);
+  var markerColor = retrieveVisualColorForTooltipMarker(series, dataIndex);
+  var inlineValue;
+  var inlineValueType;
+  var subBlocks;
+  var sortParam;
+  if (tooltipDimLen > 1 || isValueArr && !tooltipDimLen) {
+    var formatArrResult = formatTooltipArrayValue(value, series, dataIndex, tooltipDims, markerColor);
+    inlineValue = formatArrResult.inlineValues;
+    inlineValueType = formatArrResult.inlineValueTypes;
+    subBlocks = formatArrResult.blocks;
+    sortParam = formatArrResult.inlineValues[0];
+  } else if (tooltipDimLen) {
+    var dimInfo = data.getDimensionInfo(tooltipDims[0]);
+    sortParam = inlineValue = retrieveRawValue(data, dataIndex, tooltipDims[0]);
+    inlineValueType = dimInfo.type;
+  } else {
+    sortParam = inlineValue = isValueArr ? value[0] : value;
+  }
+  var seriesNameSpecified = isNameSpecified(series);
+  var seriesName = seriesNameSpecified && series.name || "";
+  var itemName = data.getName(dataIndex);
+  var inlineName = multipleSeries ? seriesName : itemName;
+  return createTooltipMarkup("section", {
+    header: seriesName,
+    // When series name is not specified, do not show a header line with only '-'.
+    // This case always happens in tooltip.trigger: 'item'.
+    noHeader: multipleSeries || !seriesNameSpecified,
+    sortParam,
+    blocks: [createTooltipMarkup("nameValue", {
+      markerType: "item",
+      markerColor,
+      // Do not mix display seriesName and itemName in one tooltip,
+      // which might confuses users.
+      name: inlineName,
+      // name dimension might be auto assigned, where the name might
+      // be not readable. So we check trim here.
+      noName: !trim(inlineName),
+      value: inlineValue,
+      valueType: inlineValueType,
+      dataIndex
+    })].concat(subBlocks || [])
+  });
+}
+function formatTooltipArrayValue(value, series, dataIndex, tooltipDims, colorStr) {
+  var data = series.getData();
+  var isValueMultipleLine = reduce(value, function(isValueMultipleLine2, val, idx) {
+    var dimItem = data.getDimensionInfo(idx);
+    return isValueMultipleLine2 = isValueMultipleLine2 || dimItem && dimItem.tooltip !== false && dimItem.displayName != null;
+  }, false);
+  var inlineValues = [];
+  var inlineValueTypes = [];
+  var blocks = [];
+  tooltipDims.length ? each(tooltipDims, function(dim) {
+    setEachItem(retrieveRawValue(data, dataIndex, dim), dim);
+  }) : each(value, setEachItem);
+  function setEachItem(val, dim) {
+    var dimInfo = data.getDimensionInfo(dim);
+    if (!dimInfo || dimInfo.otherDims.tooltip === false) {
+      return;
+    }
+    if (isValueMultipleLine) {
+      blocks.push(createTooltipMarkup("nameValue", {
+        markerType: "subItem",
+        markerColor: colorStr,
+        name: dimInfo.displayName,
+        value: val,
+        valueType: dimInfo.type
+      }));
+    } else {
+      inlineValues.push(val);
+      inlineValueTypes.push(dimInfo.type);
+    }
+  }
+  return {
+    inlineValues,
+    inlineValueTypes,
+    blocks
+  };
+}
+export {
+  defaultSeriesFormatTooltip
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/tooltip/tooltipMarkup.mjs

@@ -0,0 +1,252 @@
+import { convertToColorString, makeValueReadable, getTooltipMarker } from "../../util/format.mjs";
+import { assert, isArray, hasOwn, each, extend, map, isString } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { SortOrderComparator } from "../../data/helper/dataValueHelper.mjs";
+import { getRandomIdBase } from "../../util/number.mjs";
+import { encodeHTML } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/dom.mjs";
+var TOOLTIP_LINE_HEIGHT_CSS = "line-height:1";
+function getTooltipLineHeight(textStyle) {
+  var lineHeight = textStyle.lineHeight;
+  if (lineHeight == null) {
+    return TOOLTIP_LINE_HEIGHT_CSS;
+  } else {
+    return "line-height:" + encodeHTML(lineHeight + "") + "px";
+  }
+}
+function getTooltipTextStyle(textStyle, renderMode) {
+  var nameFontColor = textStyle.color || "#6e7079";
+  var nameFontSize = textStyle.fontSize || 12;
+  var nameFontWeight = textStyle.fontWeight || "400";
+  var valueFontColor = textStyle.color || "#464646";
+  var valueFontSize = textStyle.fontSize || 14;
+  var valueFontWeight = textStyle.fontWeight || "900";
+  if (renderMode === "html") {
+    return {
+      // eslint-disable-next-line max-len
+      nameStyle: "font-size:" + encodeHTML(nameFontSize + "") + "px;color:" + encodeHTML(nameFontColor) + ";font-weight:" + encodeHTML(nameFontWeight + ""),
+      // eslint-disable-next-line max-len
+      valueStyle: "font-size:" + encodeHTML(valueFontSize + "") + "px;color:" + encodeHTML(valueFontColor) + ";font-weight:" + encodeHTML(valueFontWeight + "")
+    };
+  } else {
+    return {
+      nameStyle: {
+        fontSize: nameFontSize,
+        fill: nameFontColor,
+        fontWeight: nameFontWeight
+      },
+      valueStyle: {
+        fontSize: valueFontSize,
+        fill: valueFontColor,
+        fontWeight: valueFontWeight
+      }
+    };
+  }
+}
+var HTML_GAPS = [0, 10, 20, 30];
+var RICH_TEXT_GAPS = ["", "\n", "\n\n", "\n\n\n"];
+function createTooltipMarkup(type, option) {
+  option.type = type;
+  return option;
+}
+function isSectionFragment(frag) {
+  return frag.type === "section";
+}
+function getBuilder(frag) {
+  return isSectionFragment(frag) ? buildSection : buildNameValue;
+}
+function getBlockGapLevel(frag) {
+  if (isSectionFragment(frag)) {
+    var gapLevel_1 = 0;
+    var subBlockLen = frag.blocks.length;
+    var hasInnerGap_1 = subBlockLen > 1 || subBlockLen > 0 && !frag.noHeader;
+    each(frag.blocks, function(subBlock) {
+      var subGapLevel = getBlockGapLevel(subBlock);
+      if (subGapLevel >= gapLevel_1) {
+        gapLevel_1 = subGapLevel + +(hasInnerGap_1 && // 0 always can not be readable gap level.
+        (!subGapLevel || isSectionFragment(subBlock) && !subBlock.noHeader));
+      }
+    });
+    return gapLevel_1;
+  }
+  return 0;
+}
+function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+  var noHeader = fragment.noHeader;
+  var gaps = getGap(getBlockGapLevel(fragment));
+  var subMarkupTextList = [];
+  var subBlocks = fragment.blocks || [];
+  assert(!subBlocks || isArray(subBlocks));
+  subBlocks = subBlocks || [];
+  var orderMode = ctx.orderMode;
+  if (fragment.sortBlocks && orderMode) {
+    subBlocks = subBlocks.slice();
+    var orderMap = {
+      valueAsc: "asc",
+      valueDesc: "desc"
+    };
+    if (hasOwn(orderMap, orderMode)) {
+      var comparator_1 = new SortOrderComparator(orderMap[orderMode], null);
+      subBlocks.sort(function(a, b) {
+        return comparator_1.evaluate(a.sortParam, b.sortParam);
+      });
+    } else if (orderMode === "seriesDesc") {
+      subBlocks.reverse();
+    }
+  }
+  each(subBlocks, function(subBlock, idx) {
+    var valueFormatter = fragment.valueFormatter;
+    var subMarkupText2 = getBuilder(subBlock)(
+      // Inherit valueFormatter
+      valueFormatter ? extend(extend({}, ctx), {
+        valueFormatter
+      }) : ctx,
+      subBlock,
+      idx > 0 ? gaps.html : 0,
+      toolTipTextStyle
+    );
+    subMarkupText2 != null && subMarkupTextList.push(subMarkupText2);
+  });
+  var subMarkupText = ctx.renderMode === "richText" ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(toolTipTextStyle, subMarkupTextList.join(""), noHeader ? topMarginForOuterGap : gaps.html);
+  if (noHeader) {
+    return subMarkupText;
+  }
+  var displayableHeader = makeValueReadable(fragment.header, "ordinal", ctx.useUTC);
+  var nameStyle = getTooltipTextStyle(toolTipTextStyle, ctx.renderMode).nameStyle;
+  var tooltipLineHeight = getTooltipLineHeight(toolTipTextStyle);
+  if (ctx.renderMode === "richText") {
+    return wrapInlineNameRichText(ctx, displayableHeader, nameStyle) + gaps.richText + subMarkupText;
+  } else {
+    return wrapBlockHTML(toolTipTextStyle, '<div style="' + nameStyle + ";" + tooltipLineHeight + ';">' + encodeHTML(displayableHeader) + "</div>" + subMarkupText, topMarginForOuterGap);
+  }
+}
+function buildNameValue(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+  var renderMode = ctx.renderMode;
+  var noName = fragment.noName;
+  var noValue = fragment.noValue;
+  var noMarker = !fragment.markerType;
+  var name = fragment.name;
+  var useUTC = ctx.useUTC;
+  var valueFormatter = fragment.valueFormatter || ctx.valueFormatter || function(value) {
+    value = isArray(value) ? value : [value];
+    return map(value, function(val, idx) {
+      return makeValueReadable(val, isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption, useUTC);
+    });
+  };
+  if (noName && noValue) {
+    return;
+  }
+  var markerStr = noMarker ? "" : ctx.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || "#333", renderMode);
+  var readableName = noName ? "" : makeValueReadable(name, "ordinal", useUTC);
+  var valueTypeOption = fragment.valueType;
+  var readableValueList = noValue ? [] : valueFormatter(fragment.value, fragment.dataIndex);
+  var valueAlignRight = !noMarker || !noName;
+  var valueCloseToMarker = !noMarker && noName;
+  var _a = getTooltipTextStyle(toolTipTextStyle, renderMode), nameStyle = _a.nameStyle, valueStyle = _a.valueStyle;
+  return renderMode === "richText" ? (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameRichText(ctx, readableName, nameStyle)) + (noValue ? "" : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML(toolTipTextStyle, (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? "" : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
+}
+function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) {
+  if (!fragment) {
+    return;
+  }
+  var builder = getBuilder(fragment);
+  var ctx = {
+    useUTC,
+    renderMode,
+    orderMode,
+    markupStyleCreator,
+    valueFormatter: fragment.valueFormatter
+  };
+  return builder(ctx, fragment, 0, toolTipTextStyle);
+}
+function getGap(gapLevel) {
+  return {
+    html: HTML_GAPS[gapLevel],
+    richText: RICH_TEXT_GAPS[gapLevel]
+  };
+}
+function wrapBlockHTML(textStyle, encodedContent, topGap) {
+  var clearfix = '<div style="clear:both"></div>';
+  var marginCSS = "margin: " + topGap + "px 0 0";
+  var tooltipLineHeight = getTooltipLineHeight(textStyle);
+  return '<div style="' + marginCSS + ";" + tooltipLineHeight + ';">' + encodedContent + clearfix + "</div>";
+}
+function wrapInlineNameHTML(name, leftHasMarker, style) {
+  var marginCss = leftHasMarker ? "margin-left:2px" : "";
+  return '<span style="' + style + ";" + marginCss + '">' + encodeHTML(name) + "</span>";
+}
+function wrapInlineValueHTML(valueList, alignRight, valueCloseToMarker, style) {
+  var paddingStr = valueCloseToMarker ? "10px" : "20px";
+  var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : "";
+  valueList = isArray(valueList) ? valueList : [valueList];
+  return '<span style="' + alignCSS + ";" + style + '">' + map(valueList, function(value) {
+    return encodeHTML(value);
+  }).join("&nbsp;&nbsp;") + "</span>";
+}
+function wrapInlineNameRichText(ctx, name, style) {
+  return ctx.markupStyleCreator.wrapRichTextStyle(name, style);
+}
+function wrapInlineValueRichText(ctx, values, alignRight, valueCloseToMarker, style) {
+  var styles = [style];
+  var paddingLeft = valueCloseToMarker ? 10 : 20;
+  alignRight && styles.push({
+    padding: [0, 0, 0, paddingLeft],
+    align: "right"
+  });
+  return ctx.markupStyleCreator.wrapRichTextStyle(isArray(values) ? values.join("  ") : values, styles);
+}
+function retrieveVisualColorForTooltipMarker(series, dataIndex) {
+  var style = series.getData().getItemVisual(dataIndex, "style");
+  var color = style[series.visualDrawType];
+  return convertToColorString(color);
+}
+function getPaddingFromTooltipModel(model, renderMode) {
+  var padding = model.get("padding");
+  return padding != null ? padding : renderMode === "richText" ? [8, 10] : 10;
+}
+var TooltipMarkupStyleCreator = (
+  /** @class */
+  function() {
+    function TooltipMarkupStyleCreator2() {
+      this.richTextStyles = {};
+      this._nextStyleNameId = getRandomIdBase();
+    }
+    TooltipMarkupStyleCreator2.prototype._generateStyleName = function() {
+      return "__EC_aUTo_" + this._nextStyleNameId++;
+    };
+    TooltipMarkupStyleCreator2.prototype.makeTooltipMarker = function(markerType, colorStr, renderMode) {
+      var markerId = renderMode === "richText" ? this._generateStyleName() : null;
+      var marker = getTooltipMarker({
+        color: colorStr,
+        type: markerType,
+        renderMode,
+        markerId
+      });
+      if (isString(marker)) {
+        return marker;
+      } else {
+        this.richTextStyles[markerId] = marker.style;
+        return marker.content;
+      }
+    };
+    TooltipMarkupStyleCreator2.prototype.wrapRichTextStyle = function(text, styles) {
+      var finalStl = {};
+      if (isArray(styles)) {
+        each(styles, function(stl) {
+          return extend(finalStl, stl);
+        });
+      } else {
+        extend(finalStl, styles);
+      }
+      var styleName = this._generateStyleName();
+      this.richTextStyles[styleName] = finalStl;
+      return "{" + styleName + "|" + text + "}";
+    };
+    return TooltipMarkupStyleCreator2;
+  }()
+);
+export {
+  TooltipMarkupStyleCreator,
+  buildTooltipMarkup,
+  createTooltipMarkup,
+  getPaddingFromTooltipModel,
+  retrieveVisualColorForTooltipMarker
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/transform/filterTransform.mjs

@@ -0,0 +1,46 @@
+import { parseConditionalExpression } from "../../util/conditionalExpression.mjs";
+import { createHashMap, hasOwn } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { throwError } from "../../util/log.mjs";
+var filterTransform = {
+  type: "echarts:filter",
+  // PENDING: enhance to filter by index rather than create new data
+  transform: function(params) {
+    var upstream = params.upstream;
+    var rawItem;
+    var condition = parseConditionalExpression(params.config, {
+      valueGetterAttrMap: createHashMap({
+        dimension: true
+      }),
+      prepareGetValue: function(exprOption) {
+        var errMsg = "";
+        var dimLoose = exprOption.dimension;
+        if (!hasOwn(exprOption, "dimension")) {
+          throwError(errMsg);
+        }
+        var dimInfo = upstream.getDimensionInfo(dimLoose);
+        if (!dimInfo) {
+          throwError(errMsg);
+        }
+        return {
+          dimIdx: dimInfo.index
+        };
+      },
+      getValue: function(param) {
+        return upstream.retrieveValueFromItem(rawItem, param.dimIdx);
+      }
+    });
+    var resultData = [];
+    for (var i = 0, len = upstream.count(); i < len; i++) {
+      rawItem = upstream.getRawDataItem(i);
+      if (condition.evaluate()) {
+        resultData.push(rawItem);
+      }
+    }
+    return {
+      data: resultData
+    };
+  }
+};
+export {
+  filterTransform
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/transform/install.mjs

@@ -0,0 +1,9 @@
+import { filterTransform } from "./filterTransform.mjs";
+import { sortTransform } from "./sortTransform.mjs";
+function install(registers) {
+  registers.registerTransform(filterTransform);
+  registers.registerTransform(sortTransform);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/transform/sortTransform.mjs

@@ -0,0 +1,81 @@
+import { SOURCE_FORMAT_ARRAY_ROWS, SOURCE_FORMAT_OBJECT_ROWS } from "../../util/types.mjs";
+import { throwError } from "../../util/log.mjs";
+import { each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { normalizeToArray } from "../../util/model.mjs";
+import { getRawValueParser, SortOrderComparator } from "../../data/helper/dataValueHelper.mjs";
+var sortTransform = {
+  type: "echarts:sort",
+  transform: function(params) {
+    var upstream = params.upstream;
+    var config = params.config;
+    var errMsg = "";
+    var orderExprList = normalizeToArray(config);
+    if (!orderExprList.length) {
+      throwError(errMsg);
+    }
+    var orderDefList = [];
+    each(orderExprList, function(orderExpr) {
+      var dimLoose = orderExpr.dimension;
+      var order = orderExpr.order;
+      var parserName = orderExpr.parser;
+      var incomparable = orderExpr.incomparable;
+      if (dimLoose == null) {
+        throwError(errMsg);
+      }
+      if (order !== "asc" && order !== "desc") {
+        throwError(errMsg);
+      }
+      if (incomparable && incomparable !== "min" && incomparable !== "max") {
+        var errMsg_1 = "";
+        throwError(errMsg_1);
+      }
+      if (order !== "asc" && order !== "desc") {
+        var errMsg_2 = "";
+        throwError(errMsg_2);
+      }
+      var dimInfo = upstream.getDimensionInfo(dimLoose);
+      if (!dimInfo) {
+        throwError(errMsg);
+      }
+      var parser = parserName ? getRawValueParser(parserName) : null;
+      if (parserName && !parser) {
+        throwError(errMsg);
+      }
+      orderDefList.push({
+        dimIdx: dimInfo.index,
+        parser,
+        comparator: new SortOrderComparator(order, incomparable)
+      });
+    });
+    var sourceFormat = upstream.sourceFormat;
+    if (sourceFormat !== SOURCE_FORMAT_ARRAY_ROWS && sourceFormat !== SOURCE_FORMAT_OBJECT_ROWS) {
+      throwError(errMsg);
+    }
+    var resultData = [];
+    for (var i = 0, len = upstream.count(); i < len; i++) {
+      resultData.push(upstream.getRawDataItem(i));
+    }
+    resultData.sort(function(item0, item1) {
+      for (var i2 = 0; i2 < orderDefList.length; i2++) {
+        var orderDef = orderDefList[i2];
+        var val0 = upstream.retrieveValueFromItem(item0, orderDef.dimIdx);
+        var val1 = upstream.retrieveValueFromItem(item1, orderDef.dimIdx);
+        if (orderDef.parser) {
+          val0 = orderDef.parser(val0);
+          val1 = orderDef.parser(val1);
+        }
+        var result = orderDef.comparator.evaluate(val0, val1);
+        if (result !== 0) {
+          return result;
+        }
+      }
+      return 0;
+    });
+    return {
+      data: resultData
+    };
+  }
+};
+export {
+  sortTransform
+};