@fecp/mobile 1.0.78 → 1.1.0

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var implsStore = {};
+function registerImpl(name, impl) {
+  implsStore[name] = impl;
+}
+function getImpl(name) {
+  return implsStore[name];
+}
+exports.getImpl = getImpl;
+exports.registerImpl = registerImpl;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Eventful = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/Eventful.js");
+var lifecycle = new Eventful.default();
+exports.default = lifecycle;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Model = require("../model/Model.js");
+const env = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.js");
+const langEN = require("../i18n/langEN.js");
+const langZH = require("../i18n/langZH.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var LOCALE_ZH = "ZH";
+var LOCALE_EN = "EN";
+var DEFAULT_LOCALE = LOCALE_EN;
+var localeStorage = {};
+var localeModels = {};
+var SYSTEM_LANG = !env.default.domSupported ? DEFAULT_LOCALE : function() {
+  var langStr = (
+    /* eslint-disable-next-line */
+    (document.documentElement.lang || navigator.language || navigator.browserLanguage || DEFAULT_LOCALE).toUpperCase()
+  );
+  return langStr.indexOf(LOCALE_ZH) > -1 ? LOCALE_ZH : DEFAULT_LOCALE;
+}();
+function registerLocale(locale, localeObj) {
+  locale = locale.toUpperCase();
+  localeModels[locale] = new Model.default(localeObj);
+  localeStorage[locale] = localeObj;
+}
+function createLocaleObject(locale) {
+  if (util.isString(locale)) {
+    var localeObj = localeStorage[locale.toUpperCase()] || {};
+    if (locale === LOCALE_ZH || locale === LOCALE_EN) {
+      return util.clone(localeObj);
+    } else {
+      return util.merge(util.clone(localeObj), util.clone(localeStorage[DEFAULT_LOCALE]), false);
+    }
+  } else {
+    return util.merge(util.clone(locale), util.clone(localeStorage[DEFAULT_LOCALE]), false);
+  }
+}
+function getLocaleModel(lang) {
+  return localeModels[lang];
+}
+function getDefaultLocaleModel() {
+  return localeModels[DEFAULT_LOCALE];
+}
+registerLocale(LOCALE_EN, langEN.default);
+registerLocale(LOCALE_ZH, langZH.default);
+exports.SYSTEM_LANG = SYSTEM_LANG;
+exports.createLocaleObject = createLocaleObject;
+exports.getDefaultLocaleModel = getDefaultLocaleModel;
+exports.getLocaleModel = getLocaleModel;
+exports.registerLocale = registerLocale;

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function createTask(define) {
+  return new Task(define);
+}
+var Task = (
+  /** @class */
+  function() {
+    function Task2(define) {
+      define = define || {};
+      this._reset = define.reset;
+      this._plan = define.plan;
+      this._count = define.count;
+      this._onDirty = define.onDirty;
+      this._dirty = true;
+    }
+    Task2.prototype.perform = function(performArgs) {
+      var upTask = this._upstream;
+      var skip = performArgs && performArgs.skip;
+      if (this._dirty && upTask) {
+        var context = this.context;
+        context.data = context.outputData = upTask.context.outputData;
+      }
+      if (this.__pipeline) {
+        this.__pipeline.currentTask = this;
+      }
+      var planResult;
+      if (this._plan && !skip) {
+        planResult = this._plan(this.context);
+      }
+      var lastModBy = normalizeModBy(this._modBy);
+      var lastModDataCount = this._modDataCount || 0;
+      var modBy = normalizeModBy(performArgs && performArgs.modBy);
+      var modDataCount = performArgs && performArgs.modDataCount || 0;
+      if (lastModBy !== modBy || lastModDataCount !== modDataCount) {
+        planResult = "reset";
+      }
+      function normalizeModBy(val) {
+        !(val >= 1) && (val = 1);
+        return val;
+      }
+      var forceFirstProgress;
+      if (this._dirty || planResult === "reset") {
+        this._dirty = false;
+        forceFirstProgress = this._doReset(skip);
+      }
+      this._modBy = modBy;
+      this._modDataCount = modDataCount;
+      var step = performArgs && performArgs.step;
+      if (upTask) {
+        this._dueEnd = upTask._outputDueEnd;
+      } else {
+        this._dueEnd = this._count ? this._count(this.context) : Infinity;
+      }
+      if (this._progress) {
+        var start = this._dueIndex;
+        var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);
+        if (!skip && (forceFirstProgress || start < end)) {
+          var progress = this._progress;
+          if (util.isArray(progress)) {
+            for (var i = 0; i < progress.length; i++) {
+              this._doProgress(progress[i], start, end, modBy, modDataCount);
+            }
+          } else {
+            this._doProgress(progress, start, end, modBy, modDataCount);
+          }
+        }
+        this._dueIndex = end;
+        var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end;
+        this._outputDueEnd = outputDueEnd;
+      } else {
+        this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;
+      }
+      return this.unfinished();
+    };
+    Task2.prototype.dirty = function() {
+      this._dirty = true;
+      this._onDirty && this._onDirty(this.context);
+    };
+    Task2.prototype._doProgress = function(progress, start, end, modBy, modDataCount) {
+      iterator.reset(start, end, modBy, modDataCount);
+      this._callingProgress = progress;
+      this._callingProgress({
+        start,
+        end,
+        count: end - start,
+        next: iterator.next
+      }, this.context);
+    };
+    Task2.prototype._doReset = function(skip) {
+      this._dueIndex = this._outputDueEnd = this._dueEnd = 0;
+      this._settedOutputEnd = null;
+      var progress;
+      var forceFirstProgress;
+      if (!skip && this._reset) {
+        progress = this._reset(this.context);
+        if (progress && progress.progress) {
+          forceFirstProgress = progress.forceFirstProgress;
+          progress = progress.progress;
+        }
+        if (util.isArray(progress) && !progress.length) {
+          progress = null;
+        }
+      }
+      this._progress = progress;
+      this._modBy = this._modDataCount = null;
+      var downstream = this._downstream;
+      downstream && downstream.dirty();
+      return forceFirstProgress;
+    };
+    Task2.prototype.unfinished = function() {
+      return this._progress && this._dueIndex < this._dueEnd;
+    };
+    Task2.prototype.pipe = function(downTask) {
+      if (this._downstream !== downTask || this._dirty) {
+        this._downstream = downTask;
+        downTask._upstream = this;
+        downTask.dirty();
+      }
+    };
+    Task2.prototype.dispose = function() {
+      if (this._disposed) {
+        return;
+      }
+      this._upstream && (this._upstream._downstream = null);
+      this._downstream && (this._downstream._upstream = null);
+      this._dirty = false;
+      this._disposed = true;
+    };
+    Task2.prototype.getUpstream = function() {
+      return this._upstream;
+    };
+    Task2.prototype.getDownstream = function() {
+      return this._downstream;
+    };
+    Task2.prototype.setOutputEnd = function(end) {
+      this._outputDueEnd = this._settedOutputEnd = end;
+    };
+    return Task2;
+  }()
+);
+var iterator = /* @__PURE__ */ function() {
+  var end;
+  var current;
+  var modBy;
+  var modDataCount;
+  var winCount;
+  var it = {
+    reset: function(s, e, sStep, sCount) {
+      current = s;
+      end = e;
+      modBy = sStep;
+      modDataCount = sCount;
+      winCount = Math.ceil(modDataCount / modBy);
+      it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;
+    }
+  };
+  return it;
+  function sequentialNext() {
+    return current < end ? current++ : null;
+  }
+  function modNext() {
+    var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);
+    var result = current >= end ? null : dataIndex < modDataCount ? dataIndex : current;
+    current++;
+    return result;
+  }
+}();
+exports.Task = Task;
+exports.createTask = createTask;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/DataDiffer.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function dataIndexMapValueLength(valNumOrArrLengthMoreThan2) {
+  return valNumOrArrLengthMoreThan2 == null ? 0 : valNumOrArrLengthMoreThan2.length || 1;
+}
+function defaultKeyGetter(item) {
+  return item;
+}
+var DataDiffer = (
+  /** @class */
+  function() {
+    function DataDiffer2(oldArr, newArr, oldKeyGetter, newKeyGetter, context, diffMode) {
+      this._old = oldArr;
+      this._new = newArr;
+      this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;
+      this._newKeyGetter = newKeyGetter || defaultKeyGetter;
+      this.context = context;
+      this._diffModeMultiple = diffMode === "multiple";
+    }
+    DataDiffer2.prototype.add = function(func) {
+      this._add = func;
+      return this;
+    };
+    DataDiffer2.prototype.update = function(func) {
+      this._update = func;
+      return this;
+    };
+    DataDiffer2.prototype.updateManyToOne = function(func) {
+      this._updateManyToOne = func;
+      return this;
+    };
+    DataDiffer2.prototype.updateOneToMany = function(func) {
+      this._updateOneToMany = func;
+      return this;
+    };
+    DataDiffer2.prototype.updateManyToMany = function(func) {
+      this._updateManyToMany = func;
+      return this;
+    };
+    DataDiffer2.prototype.remove = function(func) {
+      this._remove = func;
+      return this;
+    };
+    DataDiffer2.prototype.execute = function() {
+      this[this._diffModeMultiple ? "_executeMultiple" : "_executeOneToOne"]();
+    };
+    DataDiffer2.prototype._executeOneToOne = function() {
+      var oldArr = this._old;
+      var newArr = this._new;
+      var newDataIndexMap = {};
+      var oldDataKeyArr = new Array(oldArr.length);
+      var newDataKeyArr = new Array(newArr.length);
+      this._initIndexMap(oldArr, null, oldDataKeyArr, "_oldKeyGetter");
+      this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, "_newKeyGetter");
+      for (var i = 0; i < oldArr.length; i++) {
+        var oldKey = oldDataKeyArr[i];
+        var newIdxMapVal = newDataIndexMap[oldKey];
+        var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+        if (newIdxMapValLen > 1) {
+          var newIdx = newIdxMapVal.shift();
+          if (newIdxMapVal.length === 1) {
+            newDataIndexMap[oldKey] = newIdxMapVal[0];
+          }
+          this._update && this._update(newIdx, i);
+        } else if (newIdxMapValLen === 1) {
+          newDataIndexMap[oldKey] = null;
+          this._update && this._update(newIdxMapVal, i);
+        } else {
+          this._remove && this._remove(i);
+        }
+      }
+      this._performRestAdd(newDataKeyArr, newDataIndexMap);
+    };
+    DataDiffer2.prototype._executeMultiple = function() {
+      var oldArr = this._old;
+      var newArr = this._new;
+      var oldDataIndexMap = {};
+      var newDataIndexMap = {};
+      var oldDataKeyArr = [];
+      var newDataKeyArr = [];
+      this._initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, "_oldKeyGetter");
+      this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, "_newKeyGetter");
+      for (var i = 0; i < oldDataKeyArr.length; i++) {
+        var oldKey = oldDataKeyArr[i];
+        var oldIdxMapVal = oldDataIndexMap[oldKey];
+        var newIdxMapVal = newDataIndexMap[oldKey];
+        var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal);
+        var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+        if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) {
+          this._updateManyToOne && this._updateManyToOne(newIdxMapVal, oldIdxMapVal);
+          newDataIndexMap[oldKey] = null;
+        } else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) {
+          this._updateOneToMany && this._updateOneToMany(newIdxMapVal, oldIdxMapVal);
+          newDataIndexMap[oldKey] = null;
+        } else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) {
+          this._update && this._update(newIdxMapVal, oldIdxMapVal);
+          newDataIndexMap[oldKey] = null;
+        } else if (oldIdxMapValLen > 1 && newIdxMapValLen > 1) {
+          this._updateManyToMany && this._updateManyToMany(newIdxMapVal, oldIdxMapVal);
+          newDataIndexMap[oldKey] = null;
+        } else if (oldIdxMapValLen > 1) {
+          for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) {
+            this._remove && this._remove(oldIdxMapVal[i_1]);
+          }
+        } else {
+          this._remove && this._remove(oldIdxMapVal);
+        }
+      }
+      this._performRestAdd(newDataKeyArr, newDataIndexMap);
+    };
+    DataDiffer2.prototype._performRestAdd = function(newDataKeyArr, newDataIndexMap) {
+      for (var i = 0; i < newDataKeyArr.length; i++) {
+        var newKey = newDataKeyArr[i];
+        var newIdxMapVal = newDataIndexMap[newKey];
+        var idxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+        if (idxMapValLen > 1) {
+          for (var j = 0; j < idxMapValLen; j++) {
+            this._add && this._add(newIdxMapVal[j]);
+          }
+        } else if (idxMapValLen === 1) {
+          this._add && this._add(newIdxMapVal);
+        }
+        newDataIndexMap[newKey] = null;
+      }
+    };
+    DataDiffer2.prototype._initIndexMap = function(arr, map, keyArr, keyGetterName) {
+      var cbModeMultiple = this._diffModeMultiple;
+      for (var i = 0; i < arr.length; i++) {
+        var key = "_ec_" + this[keyGetterName](arr[i], i);
+        if (!cbModeMultiple) {
+          keyArr[i] = key;
+        }
+        if (!map) {
+          continue;
+        }
+        var idxMapVal = map[key];
+        var idxMapValLen = dataIndexMapValueLength(idxMapVal);
+        if (idxMapValLen === 0) {
+          map[key] = i;
+          if (cbModeMultiple) {
+            keyArr.push(key);
+          }
+        } else if (idxMapValLen === 1) {
+          map[key] = [idxMapVal, i];
+        } else {
+          idxMapVal.push(i);
+        }
+      }
+    };
+    return DataDiffer2;
+  }()
+);
+exports.default = DataDiffer;