@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/label/labelStyle.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const states = require("../util/states.js");
+const model = require("../util/model.js");
+require("../util/graphic.js");
+const basicTransition = require("../animation/basicTransition.js");
+var EMPTY_OBJ = {};
+function setLabelText(label, labelTexts) {
+  for (var i = 0; i < states.SPECIAL_STATES.length; i++) {
+    var stateName = states.SPECIAL_STATES[i];
+    var text = labelTexts[stateName];
+    var state = label.ensureState(stateName);
+    state.style = state.style || {};
+    state.style.text = text;
+  }
+  var oldStates = label.currentStates.slice();
+  label.clearStates(true);
+  label.setStyle({
+    text: labelTexts.normal
+  });
+  label.useStates(oldStates, true);
+}
+function getLabelText(opt, stateModels, interpolatedValue) {
+  var labelFetcher = opt.labelFetcher;
+  var labelDataIndex = opt.labelDataIndex;
+  var labelDimIndex = opt.labelDimIndex;
+  var normalModel = stateModels.normal;
+  var baseText;
+  if (labelFetcher) {
+    baseText = labelFetcher.getFormattedLabel(labelDataIndex, "normal", null, labelDimIndex, normalModel && normalModel.get("formatter"), interpolatedValue != null ? {
+      interpolatedValue
+    } : null);
+  }
+  if (baseText == null) {
+    baseText = util.isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt, interpolatedValue) : opt.defaultText;
+  }
+  var statesText = {
+    normal: baseText
+  };
+  for (var i = 0; i < states.SPECIAL_STATES.length; i++) {
+    var stateName = states.SPECIAL_STATES[i];
+    var stateModel = stateModels[stateName];
+    statesText[stateName] = util.retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, stateName, null, labelDimIndex, stateModel && stateModel.get("formatter")) : null, baseText);
+  }
+  return statesText;
+}
+function setLabelStyle(targetEl, labelStatesModels, opt, stateSpecified) {
+  opt = opt || EMPTY_OBJ;
+  var isSetOnText = targetEl instanceof Text.default;
+  var needsCreateText = false;
+  for (var i = 0; i < states.DISPLAY_STATES.length; i++) {
+    var stateModel = labelStatesModels[states.DISPLAY_STATES[i]];
+    if (stateModel && stateModel.getShallow("show")) {
+      needsCreateText = true;
+      break;
+    }
+  }
+  var textContent = isSetOnText ? targetEl : targetEl.getTextContent();
+  if (needsCreateText) {
+    if (!isSetOnText) {
+      if (!textContent) {
+        textContent = new Text.default();
+        targetEl.setTextContent(textContent);
+      }
+      if (targetEl.stateProxy) {
+        textContent.stateProxy = targetEl.stateProxy;
+      }
+    }
+    var labelStatesTexts = getLabelText(opt, labelStatesModels);
+    var normalModel = labelStatesModels.normal;
+    var showNormal = !!normalModel.getShallow("show");
+    var normalStyle = createTextStyle(normalModel, stateSpecified && stateSpecified.normal, opt, false, !isSetOnText);
+    normalStyle.text = labelStatesTexts.normal;
+    if (!isSetOnText) {
+      targetEl.setTextConfig(createTextConfig(normalModel, opt, false));
+    }
+    for (var i = 0; i < states.SPECIAL_STATES.length; i++) {
+      var stateName = states.SPECIAL_STATES[i];
+      var stateModel = labelStatesModels[stateName];
+      if (stateModel) {
+        var stateObj = textContent.ensureState(stateName);
+        var stateShow = !!util.retrieve2(stateModel.getShallow("show"), showNormal);
+        if (stateShow !== showNormal) {
+          stateObj.ignore = !stateShow;
+        }
+        stateObj.style = createTextStyle(stateModel, stateSpecified && stateSpecified[stateName], opt, true, !isSetOnText);
+        stateObj.style.text = labelStatesTexts[stateName];
+        if (!isSetOnText) {
+          var targetElEmphasisState = targetEl.ensureState(stateName);
+          targetElEmphasisState.textConfig = createTextConfig(stateModel, opt, true);
+        }
+      }
+    }
+    textContent.silent = !!normalModel.getShallow("silent");
+    if (textContent.style.x != null) {
+      normalStyle.x = textContent.style.x;
+    }
+    if (textContent.style.y != null) {
+      normalStyle.y = textContent.style.y;
+    }
+    textContent.ignore = !showNormal;
+    textContent.useStyle(normalStyle);
+    textContent.dirty();
+    if (opt.enableTextSetter) {
+      labelInner(textContent).setLabelText = function(interpolatedValue) {
+        var labelStatesTexts2 = getLabelText(opt, labelStatesModels, interpolatedValue);
+        setLabelText(textContent, labelStatesTexts2);
+      };
+    }
+  } else if (textContent) {
+    textContent.ignore = true;
+  }
+  targetEl.dirty();
+}
+function getLabelStatesModels(itemModel, labelName) {
+  labelName = labelName || "label";
+  var statesModels = {
+    normal: itemModel.getModel(labelName)
+  };
+  for (var i = 0; i < states.SPECIAL_STATES.length; i++) {
+    var stateName = states.SPECIAL_STATES[i];
+    statesModels[stateName] = itemModel.getModel([stateName, labelName]);
+  }
+  return statesModels;
+}
+function createTextStyle(textStyleModel, specifiedTextStyle, opt, isNotNormal, isAttached) {
+  var textStyle = {};
+  setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached);
+  specifiedTextStyle && util.extend(textStyle, specifiedTextStyle);
+  return textStyle;
+}
+function createTextConfig(textStyleModel, opt, isNotNormal) {
+  opt = opt || {};
+  var textConfig = {};
+  var labelPosition;
+  var labelRotate = textStyleModel.getShallow("rotate");
+  var labelDistance = util.retrieve2(textStyleModel.getShallow("distance"), isNotNormal ? null : 5);
+  var labelOffset = textStyleModel.getShallow("offset");
+  labelPosition = textStyleModel.getShallow("position") || (isNotNormal ? null : "inside");
+  labelPosition === "outside" && (labelPosition = opt.defaultOutsidePosition || "top");
+  if (labelPosition != null) {
+    textConfig.position = labelPosition;
+  }
+  if (labelOffset != null) {
+    textConfig.offset = labelOffset;
+  }
+  if (labelRotate != null) {
+    labelRotate *= Math.PI / 180;
+    textConfig.rotation = labelRotate;
+  }
+  if (labelDistance != null) {
+    textConfig.distance = labelDistance;
+  }
+  textConfig.outsideFill = textStyleModel.get("color") === "inherit" ? opt.inheritColor || null : "auto";
+  return textConfig;
+}
+function setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached) {
+  opt = opt || EMPTY_OBJ;
+  var ecModel = textStyleModel.ecModel;
+  var globalTextStyle = ecModel && ecModel.option.textStyle;
+  var richItemNames = getRichItemNames(textStyleModel);
+  var richResult;
+  if (richItemNames) {
+    richResult = {};
+    for (var name_1 in richItemNames) {
+      if (richItemNames.hasOwnProperty(name_1)) {
+        var richTextStyle = textStyleModel.getModel(["rich", name_1]);
+        setTokenTextStyle(richResult[name_1] = {}, richTextStyle, globalTextStyle, opt, isNotNormal, isAttached, false, true);
+      }
+    }
+  }
+  if (richResult) {
+    textStyle.rich = richResult;
+  }
+  var overflow = textStyleModel.get("overflow");
+  if (overflow) {
+    textStyle.overflow = overflow;
+  }
+  var margin = textStyleModel.get("minMargin");
+  if (margin != null) {
+    textStyle.margin = margin;
+  }
+  setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, true, false);
+}
+function getRichItemNames(textStyleModel) {
+  var richItemNameMap;
+  while (textStyleModel && textStyleModel !== textStyleModel.ecModel) {
+    var rich = (textStyleModel.option || EMPTY_OBJ).rich;
+    if (rich) {
+      richItemNameMap = richItemNameMap || {};
+      var richKeys = util.keys(rich);
+      for (var i = 0; i < richKeys.length; i++) {
+        var richKey = richKeys[i];
+        richItemNameMap[richKey] = 1;
+      }
+    }
+    textStyleModel = textStyleModel.parentModel;
+  }
+  return richItemNameMap;
+}
+var TEXT_PROPS_WITH_GLOBAL = ["fontStyle", "fontWeight", "fontSize", "fontFamily", "textShadowColor", "textShadowBlur", "textShadowOffsetX", "textShadowOffsetY"];
+var TEXT_PROPS_SELF = ["align", "lineHeight", "width", "height", "tag", "verticalAlign", "ellipsis"];
+var TEXT_PROPS_BOX = ["padding", "borderWidth", "borderRadius", "borderDashOffset", "backgroundColor", "borderColor", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"];
+function setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, isBlock, inRich) {
+  globalTextStyle = !isNotNormal && globalTextStyle || EMPTY_OBJ;
+  var inheritColor = opt && opt.inheritColor;
+  var fillColor = textStyleModel.getShallow("color");
+  var strokeColor = textStyleModel.getShallow("textBorderColor");
+  var opacity = util.retrieve2(textStyleModel.getShallow("opacity"), globalTextStyle.opacity);
+  if (fillColor === "inherit" || fillColor === "auto") {
+    if (inheritColor) {
+      fillColor = inheritColor;
+    } else {
+      fillColor = null;
+    }
+  }
+  if (strokeColor === "inherit" || strokeColor === "auto") {
+    if (inheritColor) {
+      strokeColor = inheritColor;
+    } else {
+      strokeColor = null;
+    }
+  }
+  if (!isAttached) {
+    fillColor = fillColor || globalTextStyle.color;
+    strokeColor = strokeColor || globalTextStyle.textBorderColor;
+  }
+  if (fillColor != null) {
+    textStyle.fill = fillColor;
+  }
+  if (strokeColor != null) {
+    textStyle.stroke = strokeColor;
+  }
+  var textBorderWidth = util.retrieve2(textStyleModel.getShallow("textBorderWidth"), globalTextStyle.textBorderWidth);
+  if (textBorderWidth != null) {
+    textStyle.lineWidth = textBorderWidth;
+  }
+  var textBorderType = util.retrieve2(textStyleModel.getShallow("textBorderType"), globalTextStyle.textBorderType);
+  if (textBorderType != null) {
+    textStyle.lineDash = textBorderType;
+  }
+  var textBorderDashOffset = util.retrieve2(textStyleModel.getShallow("textBorderDashOffset"), globalTextStyle.textBorderDashOffset);
+  if (textBorderDashOffset != null) {
+    textStyle.lineDashOffset = textBorderDashOffset;
+  }
+  if (!isNotNormal && opacity == null && !inRich) {
+    opacity = opt && opt.defaultOpacity;
+  }
+  if (opacity != null) {
+    textStyle.opacity = opacity;
+  }
+  if (!isNotNormal && !isAttached) {
+    if (textStyle.fill == null && opt.inheritColor) {
+      textStyle.fill = opt.inheritColor;
+    }
+  }
+  for (var i = 0; i < TEXT_PROPS_WITH_GLOBAL.length; i++) {
+    var key = TEXT_PROPS_WITH_GLOBAL[i];
+    var val = util.retrieve2(textStyleModel.getShallow(key), globalTextStyle[key]);
+    if (val != null) {
+      textStyle[key] = val;
+    }
+  }
+  for (var i = 0; i < TEXT_PROPS_SELF.length; i++) {
+    var key = TEXT_PROPS_SELF[i];
+    var val = textStyleModel.getShallow(key);
+    if (val != null) {
+      textStyle[key] = val;
+    }
+  }
+  if (textStyle.verticalAlign == null) {
+    var baseline = textStyleModel.getShallow("baseline");
+    if (baseline != null) {
+      textStyle.verticalAlign = baseline;
+    }
+  }
+  if (!isBlock || !opt.disableBox) {
+    for (var i = 0; i < TEXT_PROPS_BOX.length; i++) {
+      var key = TEXT_PROPS_BOX[i];
+      var val = textStyleModel.getShallow(key);
+      if (val != null) {
+        textStyle[key] = val;
+      }
+    }
+    var borderType = textStyleModel.getShallow("borderType");
+    if (borderType != null) {
+      textStyle.borderDash = borderType;
+    }
+    if ((textStyle.backgroundColor === "auto" || textStyle.backgroundColor === "inherit") && inheritColor) {
+      textStyle.backgroundColor = inheritColor;
+    }
+    if ((textStyle.borderColor === "auto" || textStyle.borderColor === "inherit") && inheritColor) {
+      textStyle.borderColor = inheritColor;
+    }
+  }
+}
+function getFont(opt, ecModel) {
+  var gTextStyleModel = ecModel && ecModel.getModel("textStyle");
+  return util.trim([
+    // FIXME in node-canvas fontWeight is before fontStyle
+    opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow("fontStyle") || "",
+    opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow("fontWeight") || "",
+    (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow("fontSize") || 12) + "px",
+    opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow("fontFamily") || "sans-serif"
+  ].join(" "));
+}
+var labelInner = model.makeInner();
+function setLabelValueAnimation(label, labelStatesModels, value, getDefaultText) {
+  if (!label) {
+    return;
+  }
+  var obj = labelInner(label);
+  obj.prevValue = obj.value;
+  obj.value = value;
+  var normalLabelModel = labelStatesModels.normal;
+  obj.valueAnimation = normalLabelModel.get("valueAnimation");
+  if (obj.valueAnimation) {
+    obj.precision = normalLabelModel.get("precision");
+    obj.defaultInterpolatedText = getDefaultText;
+    obj.statesModels = labelStatesModels;
+  }
+}
+function animateLabelValue(textEl, dataIndex, data, animatableModel, labelFetcher) {
+  var labelInnerStore = labelInner(textEl);
+  if (!labelInnerStore.valueAnimation || labelInnerStore.prevValue === labelInnerStore.value) {
+    return;
+  }
+  var defaultInterpolatedText = labelInnerStore.defaultInterpolatedText;
+  var currValue = util.retrieve2(labelInnerStore.interpolatedValue, labelInnerStore.prevValue);
+  var targetValue = labelInnerStore.value;
+  function during(percent) {
+    var interpolated = model.interpolateRawValues(data, labelInnerStore.precision, currValue, targetValue, percent);
+    labelInnerStore.interpolatedValue = percent === 1 ? null : interpolated;
+    var labelText = getLabelText({
+      labelDataIndex: dataIndex,
+      labelFetcher,
+      defaultText: defaultInterpolatedText ? defaultInterpolatedText(interpolated) : interpolated + ""
+    }, labelInnerStore.statesModels, interpolated);
+    setLabelText(textEl, labelText);
+  }
+  textEl.percent = 0;
+  (labelInnerStore.prevValue == null ? basicTransition.initProps : basicTransition.updateProps)(textEl, {
+    // percent is used to prevent animation from being aborted #15916
+    percent: 1
+  }, animatableModel, dataIndex, null, during);
+}
+exports.animateLabelValue = animateLabelValue;
+exports.createTextConfig = createTextConfig;
+exports.createTextStyle = createTextStyle;
+exports.getFont = getFont;
+exports.getLabelStatesModels = getLabelStatesModels;
+exports.labelInner = labelInner;
+exports.setLabelStyle = setLabelStyle;
+exports.setLabelText = setLabelText;
+exports.setLabelValueAnimation = setLabelValueAnimation;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/label/sectorLabel.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/text.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function createSectorCalculateTextPosition(positionMapping, opts) {
+  opts = opts || {};
+  var isRoundCap = opts.isRoundCap;
+  return function(out, opts2, boundingRect) {
+    var textPosition = opts2.position;
+    if (!textPosition || textPosition instanceof Array) {
+      return text.calculateTextPosition(out, opts2, boundingRect);
+    }
+    var mappedSectorPosition = positionMapping(textPosition);
+    var distance = opts2.distance != null ? opts2.distance : 5;
+    var sector = this.shape;
+    var cx = sector.cx;
+    var cy = sector.cy;
+    var r = sector.r;
+    var r0 = sector.r0;
+    var middleR = (r + r0) / 2;
+    var startAngle = sector.startAngle;
+    var endAngle = sector.endAngle;
+    var middleAngle = (startAngle + endAngle) / 2;
+    var extraDist = isRoundCap ? Math.abs(r - r0) / 2 : 0;
+    var mathCos = Math.cos;
+    var mathSin = Math.sin;
+    var x = cx + r * mathCos(startAngle);
+    var y = cy + r * mathSin(startAngle);
+    var textAlign = "left";
+    var textVerticalAlign = "top";
+    switch (mappedSectorPosition) {
+      case "startArc":
+        x = cx + (r0 - distance) * mathCos(middleAngle);
+        y = cy + (r0 - distance) * mathSin(middleAngle);
+        textAlign = "center";
+        textVerticalAlign = "top";
+        break;
+      case "insideStartArc":
+        x = cx + (r0 + distance) * mathCos(middleAngle);
+        y = cy + (r0 + distance) * mathSin(middleAngle);
+        textAlign = "center";
+        textVerticalAlign = "bottom";
+        break;
+      case "startAngle":
+        x = cx + middleR * mathCos(startAngle) + adjustAngleDistanceX(startAngle, distance + extraDist, false);
+        y = cy + middleR * mathSin(startAngle) + adjustAngleDistanceY(startAngle, distance + extraDist, false);
+        textAlign = "right";
+        textVerticalAlign = "middle";
+        break;
+      case "insideStartAngle":
+        x = cx + middleR * mathCos(startAngle) + adjustAngleDistanceX(startAngle, -distance + extraDist, false);
+        y = cy + middleR * mathSin(startAngle) + adjustAngleDistanceY(startAngle, -distance + extraDist, false);
+        textAlign = "left";
+        textVerticalAlign = "middle";
+        break;
+      case "middle":
+        x = cx + middleR * mathCos(middleAngle);
+        y = cy + middleR * mathSin(middleAngle);
+        textAlign = "center";
+        textVerticalAlign = "middle";
+        break;
+      case "endArc":
+        x = cx + (r + distance) * mathCos(middleAngle);
+        y = cy + (r + distance) * mathSin(middleAngle);
+        textAlign = "center";
+        textVerticalAlign = "bottom";
+        break;
+      case "insideEndArc":
+        x = cx + (r - distance) * mathCos(middleAngle);
+        y = cy + (r - distance) * mathSin(middleAngle);
+        textAlign = "center";
+        textVerticalAlign = "top";
+        break;
+      case "endAngle":
+        x = cx + middleR * mathCos(endAngle) + adjustAngleDistanceX(endAngle, distance + extraDist, true);
+        y = cy + middleR * mathSin(endAngle) + adjustAngleDistanceY(endAngle, distance + extraDist, true);
+        textAlign = "left";
+        textVerticalAlign = "middle";
+        break;
+      case "insideEndAngle":
+        x = cx + middleR * mathCos(endAngle) + adjustAngleDistanceX(endAngle, -distance + extraDist, true);
+        y = cy + middleR * mathSin(endAngle) + adjustAngleDistanceY(endAngle, -distance + extraDist, true);
+        textAlign = "right";
+        textVerticalAlign = "middle";
+        break;
+      default:
+        return text.calculateTextPosition(out, opts2, boundingRect);
+    }
+    out = out || {};
+    out.x = x;
+    out.y = y;
+    out.align = textAlign;
+    out.verticalAlign = textVerticalAlign;
+    return out;
+  };
+}
+function setSectorTextRotation(sector, textPosition, positionMapping, rotateType) {
+  if (util.isNumber(rotateType)) {
+    sector.setTextConfig({
+      rotation: rotateType
+    });
+    return;
+  } else if (util.isArray(textPosition)) {
+    sector.setTextConfig({
+      rotation: 0
+    });
+    return;
+  }
+  var shape = sector.shape;
+  var startAngle = shape.clockwise ? shape.startAngle : shape.endAngle;
+  var endAngle = shape.clockwise ? shape.endAngle : shape.startAngle;
+  var middleAngle = (startAngle + endAngle) / 2;
+  var anchorAngle;
+  var mappedSectorPosition = positionMapping(textPosition);
+  switch (mappedSectorPosition) {
+    case "startArc":
+    case "insideStartArc":
+    case "middle":
+    case "insideEndArc":
+    case "endArc":
+      anchorAngle = middleAngle;
+      break;
+    case "startAngle":
+    case "insideStartAngle":
+      anchorAngle = startAngle;
+      break;
+    case "endAngle":
+    case "insideEndAngle":
+      anchorAngle = endAngle;
+      break;
+    default:
+      sector.setTextConfig({
+        rotation: 0
+      });
+      return;
+  }
+  var rotate = Math.PI * 1.5 - anchorAngle;
+  if (mappedSectorPosition === "middle" && rotate > Math.PI / 2 && rotate < Math.PI * 1.5) {
+    rotate -= Math.PI;
+  }
+  sector.setTextConfig({
+    rotation: rotate
+  });
+}
+function adjustAngleDistanceX(angle, distance, isEnd) {
+  return distance * Math.sin(angle) * (isEnd ? -1 : 1);
+}
+function adjustAngleDistanceY(angle, distance, isEnd) {
+  return distance * Math.cos(angle) * (isEnd ? 1 : -1);
+}
+exports.createSectorCalculateTextPosition = createSectorCalculateTextPosition;
+exports.setSectorTextRotation = setSectorTextRotation;