@fecp/mobile 1.0.79 → 1.1.1

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

@@ -0,0 +1,70 @@
+import { getPrecision, nice, round, quantityExponent } from "../util/number.mjs";
+function isIntervalOrLogScale(scale2) {
+  return scale2.type === "interval" || scale2.type === "log";
+}
+function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) {
+  var result = {};
+  var span = extent[1] - extent[0];
+  var interval = result.interval = nice(span / splitNumber, true);
+  if (minInterval != null && interval < minInterval) {
+    interval = result.interval = minInterval;
+  }
+  if (maxInterval != null && interval > maxInterval) {
+    interval = result.interval = maxInterval;
+  }
+  var precision = result.intervalPrecision = getIntervalPrecision(interval);
+  var niceTickExtent = result.niceTickExtent = [round(Math.ceil(extent[0] / interval) * interval, precision), round(Math.floor(extent[1] / interval) * interval, precision)];
+  fixExtent(niceTickExtent, extent);
+  return result;
+}
+function increaseInterval(interval) {
+  var exp10 = Math.pow(10, quantityExponent(interval));
+  var f = interval / exp10;
+  if (!f) {
+    f = 1;
+  } else if (f === 2) {
+    f = 3;
+  } else if (f === 3) {
+    f = 5;
+  } else {
+    f *= 2;
+  }
+  return round(f * exp10);
+}
+function getIntervalPrecision(interval) {
+  return getPrecision(interval) + 2;
+}
+function clamp(niceTickExtent, idx, extent) {
+  niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);
+}
+function fixExtent(niceTickExtent, extent) {
+  !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);
+  !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);
+  clamp(niceTickExtent, 0, extent);
+  clamp(niceTickExtent, 1, extent);
+  if (niceTickExtent[0] > niceTickExtent[1]) {
+    niceTickExtent[0] = niceTickExtent[1];
+  }
+}
+function contain(val, extent) {
+  return val >= extent[0] && val <= extent[1];
+}
+function normalize(val, extent) {
+  if (extent[1] === extent[0]) {
+    return 0.5;
+  }
+  return (val - extent[0]) / (extent[1] - extent[0]);
+}
+function scale(val, extent) {
+  return val * (extent[1] - extent[0]) + extent[0];
+}
+export {
+  contain,
+  fixExtent,
+  getIntervalPrecision,
+  increaseInterval,
+  intervalScaleNiceTicks,
+  isIntervalOrLogScale,
+  normalize,
+  scale
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/theme/dark.mjs

@@ -0,0 +1,184 @@
+var contrastColor = "#B9B8CE";
+var backgroundColor = "#100C2A";
+var axisCommon = function() {
+  return {
+    axisLine: {
+      lineStyle: {
+        color: contrastColor
+      }
+    },
+    splitLine: {
+      lineStyle: {
+        color: "#484753"
+      }
+    },
+    splitArea: {
+      areaStyle: {
+        color: ["rgba(255,255,255,0.02)", "rgba(255,255,255,0.05)"]
+      }
+    },
+    minorSplitLine: {
+      lineStyle: {
+        color: "#20203B"
+      }
+    }
+  };
+};
+var colorPalette = ["#4992ff", "#7cffb2", "#fddd60", "#ff6e76", "#58d9f9", "#05c091", "#ff8a45", "#8d48e3", "#dd79ff"];
+var theme = {
+  darkMode: true,
+  color: colorPalette,
+  backgroundColor,
+  axisPointer: {
+    lineStyle: {
+      color: "#817f91"
+    },
+    crossStyle: {
+      color: "#817f91"
+    },
+    label: {
+      // TODO Contrast of label backgorundColor
+      color: "#fff"
+    }
+  },
+  legend: {
+    textStyle: {
+      color: contrastColor
+    },
+    pageTextStyle: {
+      color: contrastColor
+    }
+  },
+  textStyle: {
+    color: contrastColor
+  },
+  title: {
+    textStyle: {
+      color: "#EEF1FA"
+    },
+    subtextStyle: {
+      color: "#B9B8CE"
+    }
+  },
+  toolbox: {
+    iconStyle: {
+      borderColor: contrastColor
+    }
+  },
+  dataZoom: {
+    borderColor: "#71708A",
+    textStyle: {
+      color: contrastColor
+    },
+    brushStyle: {
+      color: "rgba(135,163,206,0.3)"
+    },
+    handleStyle: {
+      color: "#353450",
+      borderColor: "#C5CBE3"
+    },
+    moveHandleStyle: {
+      color: "#B0B6C3",
+      opacity: 0.3
+    },
+    fillerColor: "rgba(135,163,206,0.2)",
+    emphasis: {
+      handleStyle: {
+        borderColor: "#91B7F2",
+        color: "#4D587D"
+      },
+      moveHandleStyle: {
+        color: "#636D9A",
+        opacity: 0.7
+      }
+    },
+    dataBackground: {
+      lineStyle: {
+        color: "#71708A",
+        width: 1
+      },
+      areaStyle: {
+        color: "#71708A"
+      }
+    },
+    selectedDataBackground: {
+      lineStyle: {
+        color: "#87A3CE"
+      },
+      areaStyle: {
+        color: "#87A3CE"
+      }
+    }
+  },
+  visualMap: {
+    textStyle: {
+      color: contrastColor
+    }
+  },
+  timeline: {
+    lineStyle: {
+      color: contrastColor
+    },
+    label: {
+      color: contrastColor
+    },
+    controlStyle: {
+      color: contrastColor,
+      borderColor: contrastColor
+    }
+  },
+  calendar: {
+    itemStyle: {
+      color: backgroundColor
+    },
+    dayLabel: {
+      color: contrastColor
+    },
+    monthLabel: {
+      color: contrastColor
+    },
+    yearLabel: {
+      color: contrastColor
+    }
+  },
+  timeAxis: axisCommon(),
+  logAxis: axisCommon(),
+  valueAxis: axisCommon(),
+  categoryAxis: axisCommon(),
+  line: {
+    symbol: "circle"
+  },
+  graph: {
+    color: colorPalette
+  },
+  gauge: {
+    title: {
+      color: contrastColor
+    },
+    axisLine: {
+      lineStyle: {
+        color: [[1, "rgba(207,212,219,0.2)"]]
+      }
+    },
+    axisLabel: {
+      color: contrastColor
+    },
+    detail: {
+      color: "#EEF1FA"
+    }
+  },
+  candlestick: {
+    itemStyle: {
+      color: "#f64e56",
+      color0: "#54ea92",
+      borderColor: "#f64e56",
+      borderColor0: "#54ea92"
+      // borderColor: '#ca2824',
+      // borderColor0: '#09a443'
+    }
+  }
+};
+theme.categoryAxis.splitLine.show = false;
+export {
+  theme as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/theme/light.mjs

@@ -0,0 +1,8 @@
+var colorAll = ["#37A2DA", "#32C5E9", "#67E0E3", "#9FE6B8", "#FFDB5C", "#ff9f7f", "#fb7293", "#E062AE", "#E690D1", "#e7bcf3", "#9d96f5", "#8378EA", "#96BFFF"];
+const lightTheme = {
+  color: colorAll,
+  colorLayer: [["#37A2DA", "#ffd85c", "#fd7b5f"], ["#37A2DA", "#67E0E3", "#FFDB5C", "#ff9f7f", "#E062AE", "#9d96f5"], ["#37A2DA", "#32C5E9", "#9FE6B8", "#FFDB5C", "#ff9f7f", "#fb7293", "#e7bcf3", "#8378EA", "#96BFFF"], colorAll]
+};
+export {
+  lightTheme as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/ECEventProcessor.mjs

@@ -0,0 +1,79 @@
+import { isString, each } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { parseClassType } from "./clazz.mjs";
+var ECEventProcessor = (
+  /** @class */
+  function() {
+    function ECEventProcessor2() {
+    }
+    ECEventProcessor2.prototype.normalizeQuery = function(query) {
+      var cptQuery = {};
+      var dataQuery = {};
+      var otherQuery = {};
+      if (isString(query)) {
+        var condCptType = parseClassType(query);
+        cptQuery.mainType = condCptType.main || null;
+        cptQuery.subType = condCptType.sub || null;
+      } else {
+        var suffixes_1 = ["Index", "Name", "Id"];
+        var dataKeys_1 = {
+          name: 1,
+          dataIndex: 1,
+          dataType: 1
+        };
+        each(query, function(val, key) {
+          var reserved = false;
+          for (var i = 0; i < suffixes_1.length; i++) {
+            var propSuffix = suffixes_1[i];
+            var suffixPos = key.lastIndexOf(propSuffix);
+            if (suffixPos > 0 && suffixPos === key.length - propSuffix.length) {
+              var mainType = key.slice(0, suffixPos);
+              if (mainType !== "data") {
+                cptQuery.mainType = mainType;
+                cptQuery[propSuffix.toLowerCase()] = val;
+                reserved = true;
+              }
+            }
+          }
+          if (dataKeys_1.hasOwnProperty(key)) {
+            dataQuery[key] = val;
+            reserved = true;
+          }
+          if (!reserved) {
+            otherQuery[key] = val;
+          }
+        });
+      }
+      return {
+        cptQuery,
+        dataQuery,
+        otherQuery
+      };
+    };
+    ECEventProcessor2.prototype.filter = function(eventType, query) {
+      var eventInfo = this.eventInfo;
+      if (!eventInfo) {
+        return true;
+      }
+      var targetEl = eventInfo.targetEl;
+      var packedEvent = eventInfo.packedEvent;
+      var model = eventInfo.model;
+      var view = eventInfo.view;
+      if (!model || !view) {
+        return true;
+      }
+      var cptQuery = query.cptQuery;
+      var dataQuery = query.dataQuery;
+      return check(cptQuery, model, "mainType") && check(cptQuery, model, "subType") && check(cptQuery, model, "index", "componentIndex") && check(cptQuery, model, "name") && check(cptQuery, model, "id") && check(dataQuery, packedEvent, "name") && check(dataQuery, packedEvent, "dataIndex") && check(dataQuery, packedEvent, "dataType") && (!view.filterForExposedEvent || view.filterForExposedEvent(eventType, query.otherQuery, targetEl, packedEvent));
+      function check(query2, host, prop, propOnHost) {
+        return query2[prop] == null || host[propOnHost || prop] === query2[prop];
+      }
+    };
+    ECEventProcessor2.prototype.afterTrigger = function() {
+      this.eventInfo = null;
+    };
+    return ECEventProcessor2;
+  }()
+);
+export {
+  ECEventProcessor
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/clazz.mjs

@@ -0,0 +1,149 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { inherits, extend, isFunction, each, assert } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var TYPE_DELIMITER = ".";
+var IS_CONTAINER = "___EC__COMPONENT__CONTAINER___";
+var IS_EXTENDED_CLASS = "___EC__EXTENDED_CLASS___";
+function parseClassType(componentType) {
+  var ret = {
+    main: "",
+    sub: ""
+  };
+  if (componentType) {
+    var typeArr = componentType.split(TYPE_DELIMITER);
+    ret.main = typeArr[0] || "";
+    ret.sub = typeArr[1] || "";
+  }
+  return ret;
+}
+function checkClassType(componentType) {
+  assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal');
+}
+function isExtendedClass(clz) {
+  return !!(clz && clz[IS_EXTENDED_CLASS]);
+}
+function enableClassExtend(rootClz, mandatoryMethods) {
+  rootClz.$constructor = rootClz;
+  rootClz.extend = function(proto) {
+    var superClass = this;
+    var ExtendedClass;
+    if (isESClass(superClass)) {
+      ExtendedClass = /** @class */
+      function(_super) {
+        __extends(class_1, _super);
+        function class_1() {
+          return _super.apply(this, arguments) || this;
+        }
+        return class_1;
+      }(superClass);
+    } else {
+      ExtendedClass = function() {
+        (proto.$constructor || superClass).apply(this, arguments);
+      };
+      inherits(ExtendedClass, this);
+    }
+    extend(ExtendedClass.prototype, proto);
+    ExtendedClass[IS_EXTENDED_CLASS] = true;
+    ExtendedClass.extend = this.extend;
+    ExtendedClass.superCall = superCall;
+    ExtendedClass.superApply = superApply;
+    ExtendedClass.superClass = superClass;
+    return ExtendedClass;
+  };
+}
+function isESClass(fn) {
+  return isFunction(fn) && /^class\s/.test(Function.prototype.toString.call(fn));
+}
+function mountExtend(SubClz, SupperClz) {
+  SubClz.extend = SupperClz.extend;
+}
+var classBase = Math.round(Math.random() * 10);
+function enableClassCheck(target) {
+  var classAttr = ["__\0is_clz", classBase++].join("_");
+  target.prototype[classAttr] = true;
+  target.isInstance = function(obj) {
+    return !!(obj && obj[classAttr]);
+  };
+}
+function superCall(context, methodName) {
+  var args = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    args[_i - 2] = arguments[_i];
+  }
+  return this.superClass.prototype[methodName].apply(context, args);
+}
+function superApply(context, methodName, args) {
+  return this.superClass.prototype[methodName].apply(context, args);
+}
+function enableClassManagement(target) {
+  var storage = {};
+  target.registerClass = function(clz) {
+    var componentFullType = clz.type || clz.prototype.type;
+    if (componentFullType) {
+      checkClassType(componentFullType);
+      clz.prototype.type = componentFullType;
+      var componentTypeInfo = parseClassType(componentFullType);
+      if (!componentTypeInfo.sub) {
+        storage[componentTypeInfo.main] = clz;
+      } else if (componentTypeInfo.sub !== IS_CONTAINER) {
+        var container = makeContainer(componentTypeInfo);
+        container[componentTypeInfo.sub] = clz;
+      }
+    }
+    return clz;
+  };
+  target.getClass = function(mainType, subType, throwWhenNotFound) {
+    var clz = storage[mainType];
+    if (clz && clz[IS_CONTAINER]) {
+      clz = subType ? clz[subType] : null;
+    }
+    if (throwWhenNotFound && !clz) {
+      throw new Error(!subType ? mainType + ".type should be specified." : "Component " + mainType + "." + (subType || "") + " is used but not imported.");
+    }
+    return clz;
+  };
+  target.getClassesByMainType = function(componentType) {
+    var componentTypeInfo = parseClassType(componentType);
+    var result = [];
+    var obj = storage[componentTypeInfo.main];
+    if (obj && obj[IS_CONTAINER]) {
+      each(obj, function(o, type) {
+        type !== IS_CONTAINER && result.push(o);
+      });
+    } else {
+      result.push(obj);
+    }
+    return result;
+  };
+  target.hasClass = function(componentType) {
+    var componentTypeInfo = parseClassType(componentType);
+    return !!storage[componentTypeInfo.main];
+  };
+  target.getAllClassMainTypes = function() {
+    var types = [];
+    each(storage, function(obj, type) {
+      types.push(type);
+    });
+    return types;
+  };
+  target.hasSubTypes = function(componentType) {
+    var componentTypeInfo = parseClassType(componentType);
+    var obj = storage[componentTypeInfo.main];
+    return obj && obj[IS_CONTAINER];
+  };
+  function makeContainer(componentTypeInfo) {
+    var container = storage[componentTypeInfo.main];
+    if (!container || !container[IS_CONTAINER]) {
+      container = storage[componentTypeInfo.main] = {};
+      container[IS_CONTAINER] = true;
+    }
+    return container;
+  }
+}
+export {
+  enableClassCheck,
+  enableClassExtend,
+  enableClassManagement,
+  isExtendedClass,
+  mountExtend,
+  parseClassType
+};

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

@@ -0,0 +1,112 @@
+import { each, indexOf, merge } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { parseClassType } from "./clazz.mjs";
+var base = Math.round(Math.random() * 10);
+function getUID(type) {
+  return [type || "", base++].join("_");
+}
+function enableSubTypeDefaulter(target) {
+  var subTypeDefaulters = {};
+  target.registerSubTypeDefaulter = function(componentType, defaulter) {
+    var componentTypeInfo = parseClassType(componentType);
+    subTypeDefaulters[componentTypeInfo.main] = defaulter;
+  };
+  target.determineSubType = function(componentType, option) {
+    var type = option.type;
+    if (!type) {
+      var componentTypeMain = parseClassType(componentType).main;
+      if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) {
+        type = subTypeDefaulters[componentTypeMain](option);
+      }
+    }
+    return type;
+  };
+}
+function enableTopologicalTravel(entity, dependencyGetter) {
+  entity.topologicalTravel = function(targetNameList, fullNameList, callback, context) {
+    if (!targetNameList.length) {
+      return;
+    }
+    var result = makeDepndencyGraph(fullNameList);
+    var graph = result.graph;
+    var noEntryList = result.noEntryList;
+    var targetNameSet = {};
+    each(targetNameList, function(name) {
+      targetNameSet[name] = true;
+    });
+    while (noEntryList.length) {
+      var currComponentType = noEntryList.pop();
+      var currVertex = graph[currComponentType];
+      var isInTargetNameSet = !!targetNameSet[currComponentType];
+      if (isInTargetNameSet) {
+        callback.call(context, currComponentType, currVertex.originalDeps.slice());
+        delete targetNameSet[currComponentType];
+      }
+      each(currVertex.successor, isInTargetNameSet ? removeEdgeAndAdd : removeEdge);
+    }
+    each(targetNameSet, function() {
+      var errMsg = "";
+      throw new Error(errMsg);
+    });
+    function removeEdge(succComponentType) {
+      graph[succComponentType].entryCount--;
+      if (graph[succComponentType].entryCount === 0) {
+        noEntryList.push(succComponentType);
+      }
+    }
+    function removeEdgeAndAdd(succComponentType) {
+      targetNameSet[succComponentType] = true;
+      removeEdge(succComponentType);
+    }
+  };
+  function makeDepndencyGraph(fullNameList) {
+    var graph = {};
+    var noEntryList = [];
+    each(fullNameList, function(name) {
+      var thisItem = createDependencyGraphItem(graph, name);
+      var originalDeps = thisItem.originalDeps = dependencyGetter(name);
+      var availableDeps = getAvailableDependencies(originalDeps, fullNameList);
+      thisItem.entryCount = availableDeps.length;
+      if (thisItem.entryCount === 0) {
+        noEntryList.push(name);
+      }
+      each(availableDeps, function(dependentName) {
+        if (indexOf(thisItem.predecessor, dependentName) < 0) {
+          thisItem.predecessor.push(dependentName);
+        }
+        var thatItem = createDependencyGraphItem(graph, dependentName);
+        if (indexOf(thatItem.successor, dependentName) < 0) {
+          thatItem.successor.push(name);
+        }
+      });
+    });
+    return {
+      graph,
+      noEntryList
+    };
+  }
+  function createDependencyGraphItem(graph, name) {
+    if (!graph[name]) {
+      graph[name] = {
+        predecessor: [],
+        successor: []
+      };
+    }
+    return graph[name];
+  }
+  function getAvailableDependencies(originalDeps, fullNameList) {
+    var availableDeps = [];
+    each(originalDeps, function(dep) {
+      indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep);
+    });
+    return availableDeps;
+  }
+}
+function inheritDefaultOption(superOption, subOption) {
+  return merge(merge({}, superOption, true), subOption, true);
+}
+export {
+  enableSubTypeDefaulter,
+  enableTopologicalTravel,
+  getUID,
+  inheritDefaultOption
+};