@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/view/Chart.mjs

@@ -0,0 +1,127 @@
+import { each } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import Group from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.mjs";
+import { getUID } from "../util/component.mjs";
+import { enableClassExtend, enableClassManagement } from "../util/clazz.mjs";
+import { makeInner, queryDataIndex, normalizeToArray } from "../util/model.mjs";
+import { getHighlightDigit, isHighDownDispatcher, enterEmphasis, leaveEmphasis } from "../util/states.mjs";
+import { createTask } from "../core/task.mjs";
+import createRenderPlanner from "../chart/helper/createRenderPlanner.mjs";
+import { traverseElements } from "../util/graphic.mjs";
+var inner = makeInner();
+var renderPlanner = createRenderPlanner();
+var ChartView = (
+  /** @class */
+  function() {
+    function ChartView2() {
+      this.group = new Group();
+      this.uid = getUID("viewChart");
+      this.renderTask = createTask({
+        plan: renderTaskPlan,
+        reset: renderTaskReset
+      });
+      this.renderTask.context = {
+        view: this
+      };
+    }
+    ChartView2.prototype.init = function(ecModel, api) {
+    };
+    ChartView2.prototype.render = function(seriesModel, ecModel, api, payload) {
+    };
+    ChartView2.prototype.highlight = function(seriesModel, ecModel, api, payload) {
+      var data = seriesModel.getData(payload && payload.dataType);
+      if (!data) {
+        return;
+      }
+      toggleHighlight(data, payload, "emphasis");
+    };
+    ChartView2.prototype.downplay = function(seriesModel, ecModel, api, payload) {
+      var data = seriesModel.getData(payload && payload.dataType);
+      if (!data) {
+        return;
+      }
+      toggleHighlight(data, payload, "normal");
+    };
+    ChartView2.prototype.remove = function(ecModel, api) {
+      this.group.removeAll();
+    };
+    ChartView2.prototype.dispose = function(ecModel, api) {
+    };
+    ChartView2.prototype.updateView = function(seriesModel, ecModel, api, payload) {
+      this.render(seriesModel, ecModel, api, payload);
+    };
+    ChartView2.prototype.updateLayout = function(seriesModel, ecModel, api, payload) {
+      this.render(seriesModel, ecModel, api, payload);
+    };
+    ChartView2.prototype.updateVisual = function(seriesModel, ecModel, api, payload) {
+      this.render(seriesModel, ecModel, api, payload);
+    };
+    ChartView2.prototype.eachRendered = function(cb) {
+      traverseElements(this.group, cb);
+    };
+    ChartView2.markUpdateMethod = function(payload, methodName) {
+      inner(payload).updateMethod = methodName;
+    };
+    ChartView2.protoInitialize = function() {
+      var proto = ChartView2.prototype;
+      proto.type = "chart";
+    }();
+    return ChartView2;
+  }()
+);
+function elSetState(el, state, highlightDigit) {
+  if (el && isHighDownDispatcher(el)) {
+    (state === "emphasis" ? enterEmphasis : leaveEmphasis)(el, highlightDigit);
+  }
+}
+function toggleHighlight(data, payload, state) {
+  var dataIndex = queryDataIndex(data, payload);
+  var highlightDigit = payload && payload.highlightKey != null ? getHighlightDigit(payload.highlightKey) : null;
+  if (dataIndex != null) {
+    each(normalizeToArray(dataIndex), function(dataIdx) {
+      elSetState(data.getItemGraphicEl(dataIdx), state, highlightDigit);
+    });
+  } else {
+    data.eachItemGraphicEl(function(el) {
+      elSetState(el, state, highlightDigit);
+    });
+  }
+}
+enableClassExtend(ChartView);
+enableClassManagement(ChartView);
+function renderTaskPlan(context) {
+  return renderPlanner(context.model);
+}
+function renderTaskReset(context) {
+  var seriesModel = context.model;
+  var ecModel = context.ecModel;
+  var api = context.api;
+  var payload = context.payload;
+  var progressiveRender = seriesModel.pipelineContext.progressiveRender;
+  var view = context.view;
+  var updateMethod = payload && inner(payload).updateMethod;
+  var methodName = progressiveRender ? "incrementalPrepareRender" : updateMethod && view[updateMethod] ? updateMethod : "render";
+  if (methodName !== "render") {
+    view[methodName](seriesModel, ecModel, api, payload);
+  }
+  return progressMethodMap[methodName];
+}
+var progressMethodMap = {
+  incrementalPrepareRender: {
+    progress: function(params, context) {
+      context.view.incrementalRender(params, context.model, context.ecModel, context.api, context.payload);
+    }
+  },
+  render: {
+    // Put view.render in `progress` to support appendData. But in this case
+    // view.render should not be called in reset, otherwise it will be called
+    // twise. Use `forceFirstProgress` to make sure that view.render is called
+    // in any cases.
+    forceFirstProgress: true,
+    progress: function(params, context) {
+      context.view.render(context.model, context.ecModel, context.api, context.payload);
+    }
+  }
+};
+export {
+  ChartView as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/view/Component.mjs

@@ -0,0 +1,38 @@
+import Group from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.mjs";
+import { getUID } from "../util/component.mjs";
+import { enableClassExtend, enableClassManagement } from "../util/clazz.mjs";
+var ComponentView = (
+  /** @class */
+  function() {
+    function ComponentView2() {
+      this.group = new Group();
+      this.uid = getUID("viewComponent");
+    }
+    ComponentView2.prototype.init = function(ecModel, api) {
+    };
+    ComponentView2.prototype.render = function(model, ecModel, api, payload) {
+    };
+    ComponentView2.prototype.dispose = function(ecModel, api) {
+    };
+    ComponentView2.prototype.updateView = function(model, ecModel, api, payload) {
+    };
+    ComponentView2.prototype.updateLayout = function(model, ecModel, api, payload) {
+    };
+    ComponentView2.prototype.updateVisual = function(model, ecModel, api, payload) {
+    };
+    ComponentView2.prototype.toggleBlurSeries = function(seriesModels, isBlur, ecModel) {
+    };
+    ComponentView2.prototype.eachRendered = function(cb) {
+      var group = this.group;
+      if (group) {
+        group.traverse(cb);
+      }
+    };
+    return ComponentView2;
+  }()
+);
+enableClassExtend(ComponentView);
+enableClassManagement(ComponentView);
+export {
+  ComponentView as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/visual/LegendVisualProvider.mjs

@@ -0,0 +1,29 @@
+var LegendVisualProvider = (
+  /** @class */
+  function() {
+    function LegendVisualProvider2(getDataWithEncodedVisual, getRawData) {
+      this._getDataWithEncodedVisual = getDataWithEncodedVisual;
+      this._getRawData = getRawData;
+    }
+    LegendVisualProvider2.prototype.getAllNames = function() {
+      var rawData = this._getRawData();
+      return rawData.mapArray(rawData.getName);
+    };
+    LegendVisualProvider2.prototype.containName = function(name) {
+      var rawData = this._getRawData();
+      return rawData.indexOfName(name) >= 0;
+    };
+    LegendVisualProvider2.prototype.indexOfName = function(name) {
+      var dataWithEncodedVisual = this._getDataWithEncodedVisual();
+      return dataWithEncodedVisual.indexOfName(name);
+    };
+    LegendVisualProvider2.prototype.getItemVisual = function(dataIndex, key) {
+      var dataWithEncodedVisual = this._getDataWithEncodedVisual();
+      return dataWithEncodedVisual.getItemVisual(dataIndex, key);
+    };
+    return LegendVisualProvider2;
+  }()
+);
+export {
+  LegendVisualProvider as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/visual/decal.mjs

@@ -0,0 +1,26 @@
+import { createOrUpdatePatternFromDecal } from "../util/decal.mjs";
+function decalVisual(ecModel, api) {
+  ecModel.eachRawSeries(function(seriesModel) {
+    if (ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var data = seriesModel.getData();
+    if (data.hasItemVisual()) {
+      data.each(function(idx) {
+        var decal2 = data.getItemVisual(idx, "decal");
+        if (decal2) {
+          var itemStyle = data.ensureUniqueItemVisual(idx, "style");
+          itemStyle.decal = createOrUpdatePatternFromDecal(decal2, api);
+        }
+      });
+    }
+    var decal = data.getVisual("decal");
+    if (decal) {
+      var style = data.getVisual("style");
+      style.decal = createOrUpdatePatternFromDecal(decal, api);
+    }
+  });
+}
+export {
+  decalVisual as default
+};

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

@@ -0,0 +1,30 @@
+function getItemVisualFromData(data, dataIndex, key) {
+  switch (key) {
+    case "color":
+      var style = data.getItemVisual(dataIndex, "style");
+      return style[data.getVisual("drawType")];
+    case "opacity":
+      return data.getItemVisual(dataIndex, "style").opacity;
+    case "symbol":
+    case "symbolSize":
+    case "liftZ":
+      return data.getItemVisual(dataIndex, key);
+  }
+}
+function getVisualFromData(data, key) {
+  switch (key) {
+    case "color":
+      var style = data.getVisual("style");
+      return style[data.getVisual("drawType")];
+    case "opacity":
+      return data.getVisual("style").opacity;
+    case "symbol":
+    case "symbolSize":
+    case "liftZ":
+      return data.getVisual(key);
+  }
+}
+export {
+  getItemVisualFromData,
+  getVisualFromData
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/visual/style.mjs

@@ -0,0 +1,159 @@
+import { isFunction, extend, createHashMap } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import makeStyleMapper from "../model/mixin/makeStyleMapper.mjs";
+import { ITEM_STYLE_KEY_MAP } from "../model/mixin/itemStyle.mjs";
+import { LINE_STYLE_KEY_MAP } from "../model/mixin/lineStyle.mjs";
+import Model from "../model/Model.mjs";
+import { makeInner } from "../util/model.mjs";
+var inner = makeInner();
+var defaultStyleMappers = {
+  itemStyle: makeStyleMapper(ITEM_STYLE_KEY_MAP, true),
+  lineStyle: makeStyleMapper(LINE_STYLE_KEY_MAP, true)
+};
+var defaultColorKey = {
+  lineStyle: "stroke",
+  itemStyle: "fill"
+};
+function getStyleMapper(seriesModel, stylePath) {
+  var styleMapper = seriesModel.visualStyleMapper || defaultStyleMappers[stylePath];
+  if (!styleMapper) {
+    console.warn("Unknown style type '" + stylePath + "'.");
+    return defaultStyleMappers.itemStyle;
+  }
+  return styleMapper;
+}
+function getDefaultColorKey(seriesModel, stylePath) {
+  var colorKey = seriesModel.visualDrawType || defaultColorKey[stylePath];
+  if (!colorKey) {
+    console.warn("Unknown style type '" + stylePath + "'.");
+    return "fill";
+  }
+  return colorKey;
+}
+var seriesStyleTask = {
+  createOnAllSeries: true,
+  performRawSeries: true,
+  reset: function(seriesModel, ecModel) {
+    var data = seriesModel.getData();
+    var stylePath = seriesModel.visualStyleAccessPath || "itemStyle";
+    var styleModel = seriesModel.getModel(stylePath);
+    var getStyle = getStyleMapper(seriesModel, stylePath);
+    var globalStyle = getStyle(styleModel);
+    var decalOption = styleModel.getShallow("decal");
+    if (decalOption) {
+      data.setVisual("decal", decalOption);
+      decalOption.dirty = true;
+    }
+    var colorKey = getDefaultColorKey(seriesModel, stylePath);
+    var color = globalStyle[colorKey];
+    var colorCallback = isFunction(color) ? color : null;
+    var hasAutoColor = globalStyle.fill === "auto" || globalStyle.stroke === "auto";
+    if (!globalStyle[colorKey] || colorCallback || hasAutoColor) {
+      var colorPalette = seriesModel.getColorFromPalette(
+        // TODO series count changed.
+        seriesModel.name,
+        null,
+        ecModel.getSeriesCount()
+      );
+      if (!globalStyle[colorKey]) {
+        globalStyle[colorKey] = colorPalette;
+        data.setVisual("colorFromPalette", true);
+      }
+      globalStyle.fill = globalStyle.fill === "auto" || isFunction(globalStyle.fill) ? colorPalette : globalStyle.fill;
+      globalStyle.stroke = globalStyle.stroke === "auto" || isFunction(globalStyle.stroke) ? colorPalette : globalStyle.stroke;
+    }
+    data.setVisual("style", globalStyle);
+    data.setVisual("drawType", colorKey);
+    if (!ecModel.isSeriesFiltered(seriesModel) && colorCallback) {
+      data.setVisual("colorFromPalette", false);
+      return {
+        dataEach: function(data2, idx) {
+          var dataParams = seriesModel.getDataParams(idx);
+          var itemStyle = extend({}, globalStyle);
+          itemStyle[colorKey] = colorCallback(dataParams);
+          data2.setItemVisual(idx, "style", itemStyle);
+        }
+      };
+    }
+  }
+};
+var sharedModel = new Model();
+var dataStyleTask = {
+  createOnAllSeries: true,
+  performRawSeries: true,
+  reset: function(seriesModel, ecModel) {
+    if (seriesModel.ignoreStyleOnData || ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var data = seriesModel.getData();
+    var stylePath = seriesModel.visualStyleAccessPath || "itemStyle";
+    var getStyle = getStyleMapper(seriesModel, stylePath);
+    var colorKey = data.getVisual("drawType");
+    return {
+      dataEach: data.hasItemOption ? function(data2, idx) {
+        var rawItem = data2.getRawDataItem(idx);
+        if (rawItem && rawItem[stylePath]) {
+          sharedModel.option = rawItem[stylePath];
+          var style = getStyle(sharedModel);
+          var existsStyle = data2.ensureUniqueItemVisual(idx, "style");
+          extend(existsStyle, style);
+          if (sharedModel.option.decal) {
+            data2.setItemVisual(idx, "decal", sharedModel.option.decal);
+            sharedModel.option.decal.dirty = true;
+          }
+          if (colorKey in style) {
+            data2.setItemVisual(idx, "colorFromPalette", false);
+          }
+        }
+      } : null
+    };
+  }
+};
+var dataColorPaletteTask = {
+  performRawSeries: true,
+  overallReset: function(ecModel) {
+    var paletteScopeGroupByType = createHashMap();
+    ecModel.eachSeries(function(seriesModel) {
+      var colorBy = seriesModel.getColorBy();
+      if (seriesModel.isColorBySeries()) {
+        return;
+      }
+      var key = seriesModel.type + "-" + colorBy;
+      var colorScope = paletteScopeGroupByType.get(key);
+      if (!colorScope) {
+        colorScope = {};
+        paletteScopeGroupByType.set(key, colorScope);
+      }
+      inner(seriesModel).scope = colorScope;
+    });
+    ecModel.eachSeries(function(seriesModel) {
+      if (seriesModel.isColorBySeries() || ecModel.isSeriesFiltered(seriesModel)) {
+        return;
+      }
+      var dataAll = seriesModel.getRawData();
+      var idxMap = {};
+      var data = seriesModel.getData();
+      var colorScope = inner(seriesModel).scope;
+      var stylePath = seriesModel.visualStyleAccessPath || "itemStyle";
+      var colorKey = getDefaultColorKey(seriesModel, stylePath);
+      data.each(function(idx) {
+        var rawIdx = data.getRawIndex(idx);
+        idxMap[rawIdx] = idx;
+      });
+      dataAll.each(function(rawIdx) {
+        var idx = idxMap[rawIdx];
+        var fromPalette = data.getItemVisual(idx, "colorFromPalette");
+        if (fromPalette) {
+          var itemStyle = data.ensureUniqueItemVisual(idx, "style");
+          var name_1 = dataAll.getName(rawIdx) || rawIdx + "";
+          var dataCount = dataAll.count();
+          itemStyle[colorKey] = seriesModel.getColorFromPalette(name_1, colorScope, dataCount);
+        }
+      });
+    });
+  }
+};
+export {
+  dataColorPaletteTask,
+  dataStyleTask,
+  seriesStyleTask
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/visual/symbol.mjs

@@ -0,0 +1,81 @@
+import { extend, keys, isFunction } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var SYMBOL_PROPS_WITH_CB = ["symbol", "symbolSize", "symbolRotate", "symbolOffset"];
+var SYMBOL_PROPS = SYMBOL_PROPS_WITH_CB.concat(["symbolKeepAspect"]);
+var seriesSymbolTask = {
+  createOnAllSeries: true,
+  // For legend.
+  performRawSeries: true,
+  reset: function(seriesModel, ecModel) {
+    var data = seriesModel.getData();
+    if (seriesModel.legendIcon) {
+      data.setVisual("legendIcon", seriesModel.legendIcon);
+    }
+    if (!seriesModel.hasSymbolVisual) {
+      return;
+    }
+    var symbolOptions = {};
+    var symbolOptionsCb = {};
+    var hasCallback = false;
+    for (var i = 0; i < SYMBOL_PROPS_WITH_CB.length; i++) {
+      var symbolPropName = SYMBOL_PROPS_WITH_CB[i];
+      var val = seriesModel.get(symbolPropName);
+      if (isFunction(val)) {
+        hasCallback = true;
+        symbolOptionsCb[symbolPropName] = val;
+      } else {
+        symbolOptions[symbolPropName] = val;
+      }
+    }
+    symbolOptions.symbol = symbolOptions.symbol || seriesModel.defaultSymbol;
+    data.setVisual(extend({
+      legendIcon: seriesModel.legendIcon || symbolOptions.symbol,
+      symbolKeepAspect: seriesModel.get("symbolKeepAspect")
+    }, symbolOptions));
+    if (ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var symbolPropsCb = keys(symbolOptionsCb);
+    function dataEach(data2, idx) {
+      var rawValue = seriesModel.getRawValue(idx);
+      var params = seriesModel.getDataParams(idx);
+      for (var i2 = 0; i2 < symbolPropsCb.length; i2++) {
+        var symbolPropName2 = symbolPropsCb[i2];
+        data2.setItemVisual(idx, symbolPropName2, symbolOptionsCb[symbolPropName2](rawValue, params));
+      }
+    }
+    return {
+      dataEach: hasCallback ? dataEach : null
+    };
+  }
+};
+var dataSymbolTask = {
+  createOnAllSeries: true,
+  // For legend.
+  performRawSeries: true,
+  reset: function(seriesModel, ecModel) {
+    if (!seriesModel.hasSymbolVisual) {
+      return;
+    }
+    if (ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var data = seriesModel.getData();
+    function dataEach(data2, idx) {
+      var itemModel = data2.getItemModel(idx);
+      for (var i = 0; i < SYMBOL_PROPS.length; i++) {
+        var symbolPropName = SYMBOL_PROPS[i];
+        var val = itemModel.getShallow(symbolPropName, true);
+        if (val != null) {
+          data2.setItemVisual(idx, symbolPropName, val);
+        }
+      }
+    }
+    return {
+      dataEach: data.hasItemOption ? dataEach : null
+    };
+  }
+};
+export {
+  dataSymbolTask,
+  seriesSymbolTask
+};

package/es/node_modules/.pnpm/tslib@2.3.0/node_modules/tslib/tslib.es6.mjs

@@ -0,0 +1,34 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+export {
+  __extends
+};