@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/core.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parseGeoJson = require("./lib/coord/geo/parseGeoJson.js");
+const env = require("../../../zrender@5.6.1/node_modules/zrender/lib/core/env.js");
+const Model = require("./lib/model/Model.js");
+const Axis = require("./lib/coord/Axis.js");
+const SeriesData = require("./lib/data/SeriesData.js");
+const Component = require("./lib/model/Component.js");
+const Component$1 = require("./lib/view/Component.js");
+const Series = require("./lib/model/Series.js");
+const Chart = require("./lib/view/Chart.js");
+const locale = require("./lib/core/locale.js");
+const echarts = require("./lib/core/echarts.js");
+const throttle = require("./lib/util/throttle.js");
+const extension = require("./lib/extension.js");
+const platform = require("../../../zrender@5.6.1/node_modules/zrender/lib/core/platform.js");
+const graphic$1 = require("../../../zrender@5.6.1/node_modules/zrender/lib/canvas/graphic.js");
+const zrender = require("../../../zrender@5.6.1/node_modules/zrender/lib/zrender.js");
+const matrix = require("../../../zrender@5.6.1/node_modules/zrender/lib/core/matrix.js");
+const vector = require("../../../zrender@5.6.1/node_modules/zrender/lib/core/vector.js");
+const util = require("../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const color = require("../../../zrender@5.6.1/node_modules/zrender/lib/tool/color.js");
+const helper = require("./lib/export/api/helper.js");
+const number = require("./lib/export/api/number.js");
+const time = require("./lib/export/api/time.js");
+const graphic = require("./lib/export/api/graphic.js");
+const format = require("./lib/export/api/format.js");
+const util$1 = require("./lib/export/api/util.js");
+const api = require("./lib/export/api.js");
+exports.parseGeoJSON = parseGeoJson.default;
+exports.parseGeoJson = parseGeoJson.default;
+exports.env = env.default;
+exports.Model = Model.default;
+exports.Axis = Axis.default;
+exports.List = SeriesData.default;
+exports.ComponentModel = Component.default;
+exports.ComponentView = Component$1.default;
+exports.SeriesModel = Series.default;
+exports.ChartView = Chart.default;
+exports.registerLocale = locale.registerLocale;
+exports.PRIORITY = echarts.PRIORITY;
+exports.connect = echarts.connect;
+exports.dataTool = echarts.dataTool;
+exports.dependencies = echarts.dependencies;
+exports.disConnect = echarts.disConnect;
+exports.disconnect = echarts.disconnect;
+exports.dispose = echarts.dispose;
+exports.getCoordinateSystemDimensions = echarts.getCoordinateSystemDimensions;
+exports.getInstanceByDom = echarts.getInstanceByDom;
+exports.getInstanceById = echarts.getInstanceById;
+exports.getMap = echarts.getMap;
+exports.init = echarts.init;
+exports.registerAction = echarts.registerAction;
+exports.registerCoordinateSystem = echarts.registerCoordinateSystem;
+exports.registerLayout = echarts.registerLayout;
+exports.registerLoading = echarts.registerLoading;
+exports.registerMap = echarts.registerMap;
+exports.registerPostInit = echarts.registerPostInit;
+exports.registerPostUpdate = echarts.registerPostUpdate;
+exports.registerPreprocessor = echarts.registerPreprocessor;
+exports.registerProcessor = echarts.registerProcessor;
+exports.registerTheme = echarts.registerTheme;
+exports.registerTransform = echarts.registerTransform;
+exports.registerUpdateLifecycle = echarts.registerUpdateLifecycle;
+exports.registerVisual = echarts.registerVisual;
+exports.setCanvasCreator = echarts.setCanvasCreator;
+exports.version = echarts.version;
+exports.throttle = throttle.throttle;
+exports.use = extension.use;
+exports.setPlatformAPI = platform.setPlatformAPI;
+exports.innerDrawElementOnCanvas = graphic$1.brushSingle;
+exports.zrender = zrender;
+exports.matrix = matrix;
+exports.vector = vector;
+exports.zrUtil = util;
+exports.color = color;
+exports.helper = helper;
+exports.number = number;
+exports.time = time;
+exports.graphic = graphic;
+exports.format = format;
+exports.util = util$1;
+exports.extendChartView = api.extendChartView;
+exports.extendComponentModel = api.extendComponentModel;
+exports.extendComponentView = api.extendComponentView;
+exports.extendSeriesModel = api.extendSeriesModel;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/animation/basicTransition.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../util/model.js");
+var transitionStore = model.makeInner();
+function getAnimationConfig(animationType, animatableModel, dataIndex, extraOpts, extraDelayParams) {
+  var animationPayload;
+  if (animatableModel && animatableModel.ecModel) {
+    var updatePayload = animatableModel.ecModel.getUpdatePayload();
+    animationPayload = updatePayload && updatePayload.animation;
+  }
+  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();
+  var isUpdate = animationType === "update";
+  if (animationEnabled) {
+    var duration = void 0;
+    var easing = void 0;
+    var delay = void 0;
+    if (extraOpts) {
+      duration = util.retrieve2(extraOpts.duration, 200);
+      easing = util.retrieve2(extraOpts.easing, "cubicOut");
+      delay = 0;
+    } else {
+      duration = animatableModel.getShallow(isUpdate ? "animationDurationUpdate" : "animationDuration");
+      easing = animatableModel.getShallow(isUpdate ? "animationEasingUpdate" : "animationEasing");
+      delay = animatableModel.getShallow(isUpdate ? "animationDelayUpdate" : "animationDelay");
+    }
+    if (animationPayload) {
+      animationPayload.duration != null && (duration = animationPayload.duration);
+      animationPayload.easing != null && (easing = animationPayload.easing);
+      animationPayload.delay != null && (delay = animationPayload.delay);
+    }
+    if (util.isFunction(delay)) {
+      delay = delay(dataIndex, extraDelayParams);
+    }
+    if (util.isFunction(duration)) {
+      duration = duration(dataIndex);
+    }
+    var config = {
+      duration: duration || 0,
+      delay,
+      easing
+    };
+    return config;
+  } else {
+    return null;
+  }
+}
+function animateOrSetProps(animationType, el, props, animatableModel, dataIndex, cb, during) {
+  var isFrom = false;
+  var removeOpt;
+  if (util.isFunction(dataIndex)) {
+    during = cb;
+    cb = dataIndex;
+    dataIndex = null;
+  } else if (util.isObject(dataIndex)) {
+    cb = dataIndex.cb;
+    during = dataIndex.during;
+    isFrom = dataIndex.isFrom;
+    removeOpt = dataIndex.removeOpt;
+    dataIndex = dataIndex.dataIndex;
+  }
+  var isRemove = animationType === "leave";
+  if (!isRemove) {
+    el.stopAnimation("leave");
+  }
+  var animationConfig = getAnimationConfig(animationType, animatableModel, dataIndex, isRemove ? removeOpt || {} : null, animatableModel && animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);
+  if (animationConfig && animationConfig.duration > 0) {
+    var duration = animationConfig.duration;
+    var animationDelay = animationConfig.delay;
+    var animationEasing = animationConfig.easing;
+    var animateConfig = {
+      duration,
+      delay: animationDelay || 0,
+      easing: animationEasing,
+      done: cb,
+      force: !!cb || !!during,
+      // Set to final state in update/init animation.
+      // So the post processing based on the path shape can be done correctly.
+      setToFinal: !isRemove,
+      scope: animationType,
+      during
+    };
+    isFrom ? el.animateFrom(props, animateConfig) : el.animateTo(props, animateConfig);
+  } else {
+    el.stopAnimation();
+    !isFrom && el.attr(props);
+    during && during(1);
+    cb && cb();
+  }
+}
+function updateProps(el, props, animatableModel, dataIndex, cb, during) {
+  animateOrSetProps("update", el, props, animatableModel, dataIndex, cb, during);
+}
+function initProps(el, props, animatableModel, dataIndex, cb, during) {
+  animateOrSetProps("enter", el, props, animatableModel, dataIndex, cb, during);
+}
+function isElementRemoved(el) {
+  if (!el.__zr) {
+    return true;
+  }
+  for (var i = 0; i < el.animators.length; i++) {
+    var animator = el.animators[i];
+    if (animator.scope === "leave") {
+      return true;
+    }
+  }
+  return false;
+}
+function removeElement(el, props, animatableModel, dataIndex, cb, during) {
+  if (isElementRemoved(el)) {
+    return;
+  }
+  animateOrSetProps("leave", el, props, animatableModel, dataIndex, cb, during);
+}
+function fadeOutDisplayable(el, animatableModel, dataIndex, done) {
+  el.removeTextContent();
+  el.removeTextGuideLine();
+  removeElement(el, {
+    style: {
+      opacity: 0
+    }
+  }, animatableModel, dataIndex, done);
+}
+function removeElementWithFadeOut(el, animatableModel, dataIndex) {
+  function doRemove() {
+    el.parent && el.parent.remove(el);
+  }
+  if (!el.isGroup) {
+    fadeOutDisplayable(el, animatableModel, dataIndex, doRemove);
+  } else {
+    el.traverse(function(disp) {
+      if (!disp.isGroup) {
+        fadeOutDisplayable(disp, animatableModel, dataIndex, doRemove);
+      }
+    });
+  }
+}
+function saveOldStyle(el) {
+  transitionStore(el).oldStyle = el.style;
+}
+function getOldStyle(el) {
+  return transitionStore(el).oldStyle;
+}
+exports.getAnimationConfig = getAnimationConfig;
+exports.getOldStyle = getOldStyle;
+exports.initProps = initProps;
+exports.isElementRemoved = isElementRemoved;
+exports.removeElement = removeElement;
+exports.removeElementWithFadeOut = removeElementWithFadeOut;
+exports.saveOldStyle = saveOldStyle;
+exports.transitionStore = transitionStore;
+exports.updateProps = updateProps;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/animation/morphTransitionHelper.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const morphPath = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/tool/morphPath.js");
+require("../util/graphic.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const basicTransition = require("./basicTransition.js");
+const path = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/tool/path.js");
+const Path = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Path.js");
+function isMultiple(elements) {
+  return util.isArray(elements[0]);
+}
+function prepareMorphBatches(one, many) {
+  var batches = [];
+  var batchCount = one.length;
+  for (var i = 0; i < batchCount; i++) {
+    batches.push({
+      one: one[i],
+      many: []
+    });
+  }
+  for (var i = 0; i < many.length; i++) {
+    var len = many[i].length;
+    var k = void 0;
+    for (k = 0; k < len; k++) {
+      batches[k % batchCount].many.push(many[i][k]);
+    }
+  }
+  var off = 0;
+  for (var i = batchCount - 1; i >= 0; i--) {
+    if (!batches[i].many.length) {
+      var moveFrom = batches[off].many;
+      if (moveFrom.length <= 1) {
+        if (off) {
+          off = 0;
+        } else {
+          return batches;
+        }
+      }
+      var len = moveFrom.length;
+      var mid = Math.ceil(len / 2);
+      batches[i].many = moveFrom.slice(mid, len);
+      batches[off].many = moveFrom.slice(0, mid);
+      off++;
+    }
+  }
+  return batches;
+}
+var pathDividers = {
+  clone: function(params) {
+    var ret = [];
+    var approxOpacity = 1 - Math.pow(1 - params.path.style.opacity, 1 / params.count);
+    for (var i = 0; i < params.count; i++) {
+      var cloned = path.clonePath(params.path);
+      cloned.setStyle("opacity", approxOpacity);
+      ret.push(cloned);
+    }
+    return ret;
+  },
+  // Use the default divider
+  split: null
+};
+function applyMorphAnimation(from, to, divideShape, seriesModel, dataIndex, animateOtherProps) {
+  if (!from.length || !to.length) {
+    return;
+  }
+  var updateAnimationCfg = basicTransition.getAnimationConfig("update", seriesModel, dataIndex);
+  if (!(updateAnimationCfg && updateAnimationCfg.duration > 0)) {
+    return;
+  }
+  var animationDelay = seriesModel.getModel("universalTransition").get("delay");
+  var animationCfg = Object.assign({
+    // Need to setToFinal so the further calculation based on the style can be correct.
+    // Like emphasis color.
+    setToFinal: true
+  }, updateAnimationCfg);
+  var many;
+  var one;
+  if (isMultiple(from)) {
+    many = from;
+    one = to;
+  }
+  if (isMultiple(to)) {
+    many = to;
+    one = from;
+  }
+  function morphOneBatch(batch, fromIsMany2, animateIndex2, animateCount2, forceManyOne) {
+    var batchMany = batch.many;
+    var batchOne = batch.one;
+    if (batchMany.length === 1 && !forceManyOne) {
+      var batchFrom = fromIsMany2 ? batchMany[0] : batchOne;
+      var batchTo = fromIsMany2 ? batchOne : batchMany[0];
+      if (morphPath.isCombineMorphing(batchFrom)) {
+        morphOneBatch({
+          many: [batchFrom],
+          one: batchTo
+        }, true, animateIndex2, animateCount2, true);
+      } else {
+        var individualAnimationCfg = animationDelay ? util.defaults({
+          delay: animationDelay(animateIndex2, animateCount2)
+        }, animationCfg) : animationCfg;
+        morphPath.morphPath(batchFrom, batchTo, individualAnimationCfg);
+        animateOtherProps(batchFrom, batchTo, batchFrom, batchTo, individualAnimationCfg);
+      }
+    } else {
+      var separateAnimationCfg = util.defaults({
+        dividePath: pathDividers[divideShape],
+        individualDelay: animationDelay && function(idx, count2, fromPath, toPath) {
+          return animationDelay(idx + animateIndex2, animateCount2);
+        }
+      }, animationCfg);
+      var _a = fromIsMany2 ? morphPath.combineMorph(batchMany, batchOne, separateAnimationCfg) : morphPath.separateMorph(batchOne, batchMany, separateAnimationCfg), fromIndividuals = _a.fromIndividuals, toIndividuals = _a.toIndividuals;
+      var count = fromIndividuals.length;
+      for (var k = 0; k < count; k++) {
+        var individualAnimationCfg = animationDelay ? util.defaults({
+          delay: animationDelay(k, count)
+        }, animationCfg) : animationCfg;
+        animateOtherProps(fromIndividuals[k], toIndividuals[k], fromIsMany2 ? batchMany[k] : batch.one, fromIsMany2 ? batch.one : batchMany[k], individualAnimationCfg);
+      }
+    }
+  }
+  var fromIsMany = many ? many === from : from.length > to.length;
+  var morphBatches = many ? prepareMorphBatches(one, many) : prepareMorphBatches(fromIsMany ? to : from, [fromIsMany ? from : to]);
+  var animateCount = 0;
+  for (var i = 0; i < morphBatches.length; i++) {
+    animateCount += morphBatches[i].many.length;
+  }
+  var animateIndex = 0;
+  for (var i = 0; i < morphBatches.length; i++) {
+    morphOneBatch(morphBatches[i], fromIsMany, animateIndex, animateCount);
+    animateIndex += morphBatches[i].many.length;
+  }
+}
+function getPathList(elements) {
+  if (!elements) {
+    return [];
+  }
+  if (util.isArray(elements)) {
+    var pathList_1 = [];
+    for (var i = 0; i < elements.length; i++) {
+      pathList_1.push(getPathList(elements[i]));
+    }
+    return pathList_1;
+  }
+  var pathList = [];
+  elements.traverse(function(el) {
+    if (el instanceof Path.default && !el.disableMorphing && !el.invisible && !el.ignore) {
+      pathList.push(el);
+    }
+  });
+  return pathList;
+}
+exports.applyMorphAnimation = applyMorphAnimation;
+exports.getPathList = getPathList;