@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/scaleRawExtentInfo.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const text = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/contain/text.js");
+var ScaleRawExtentInfo = (
+  /** @class */
+  function() {
+    function ScaleRawExtentInfo2(scale, model, originalExtent) {
+      this._prepareParams(scale, model, originalExtent);
+    }
+    ScaleRawExtentInfo2.prototype._prepareParams = function(scale, model, dataExtent) {
+      if (dataExtent[1] < dataExtent[0]) {
+        dataExtent = [NaN, NaN];
+      }
+      this._dataMin = dataExtent[0];
+      this._dataMax = dataExtent[1];
+      var isOrdinal = this._isOrdinal = scale.type === "ordinal";
+      this._needCrossZero = scale.type === "interval" && model.getNeedCrossZero && model.getNeedCrossZero();
+      var axisMinValue = model.get("min", true);
+      if (axisMinValue == null) {
+        axisMinValue = model.get("startValue", true);
+      }
+      var modelMinRaw = this._modelMinRaw = axisMinValue;
+      if (util.isFunction(modelMinRaw)) {
+        this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw({
+          min: dataExtent[0],
+          max: dataExtent[1]
+        }));
+      } else if (modelMinRaw !== "dataMin") {
+        this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw);
+      }
+      var modelMaxRaw = this._modelMaxRaw = model.get("max", true);
+      if (util.isFunction(modelMaxRaw)) {
+        this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw({
+          min: dataExtent[0],
+          max: dataExtent[1]
+        }));
+      } else if (modelMaxRaw !== "dataMax") {
+        this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw);
+      }
+      if (isOrdinal) {
+        this._axisDataLen = model.getCategories().length;
+      } else {
+        var boundaryGap = model.get("boundaryGap");
+        var boundaryGapArr = util.isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0];
+        if (typeof boundaryGapArr[0] === "boolean" || typeof boundaryGapArr[1] === "boolean") {
+          this._boundaryGapInner = [0, 0];
+        } else {
+          this._boundaryGapInner = [text.parsePercent(boundaryGapArr[0], 1), text.parsePercent(boundaryGapArr[1], 1)];
+        }
+      }
+    };
+    ScaleRawExtentInfo2.prototype.calculate = function() {
+      var isOrdinal = this._isOrdinal;
+      var dataMin = this._dataMin;
+      var dataMax = this._dataMax;
+      var axisDataLen = this._axisDataLen;
+      var boundaryGapInner = this._boundaryGapInner;
+      var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null;
+      var min = this._modelMinRaw === "dataMin" ? dataMin : this._modelMinNum;
+      var max = this._modelMaxRaw === "dataMax" ? dataMax : this._modelMaxNum;
+      var minFixed = min != null;
+      var maxFixed = max != null;
+      if (min == null) {
+        min = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span;
+      }
+      if (max == null) {
+        max = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span;
+      }
+      (min == null || !isFinite(min)) && (min = NaN);
+      (max == null || !isFinite(max)) && (max = NaN);
+      var isBlank = util.eqNaN(min) || util.eqNaN(max) || isOrdinal && !axisDataLen;
+      if (this._needCrossZero) {
+        if (min > 0 && max > 0 && !minFixed) {
+          min = 0;
+        }
+        if (min < 0 && max < 0 && !maxFixed) {
+          max = 0;
+        }
+      }
+      var determinedMin = this._determinedMin;
+      var determinedMax = this._determinedMax;
+      if (determinedMin != null) {
+        min = determinedMin;
+        minFixed = true;
+      }
+      if (determinedMax != null) {
+        max = determinedMax;
+        maxFixed = true;
+      }
+      return {
+        min,
+        max,
+        minFixed,
+        maxFixed,
+        isBlank
+      };
+    };
+    ScaleRawExtentInfo2.prototype.modifyDataMinMax = function(minMaxName, val) {
+      this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
+    };
+    ScaleRawExtentInfo2.prototype.setDeterminedMinMax = function(minMaxName, val) {
+      var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
+      this[attr] = val;
+    };
+    ScaleRawExtentInfo2.prototype.freeze = function() {
+      this.frozen = true;
+    };
+    return ScaleRawExtentInfo2;
+  }()
+);
+var DETERMINED_MIN_MAX_ATTR = {
+  min: "_determinedMin",
+  max: "_determinedMax"
+};
+var DATA_MIN_MAX_ATTR = {
+  min: "_dataMin",
+  max: "_dataMax"
+};
+function ensureScaleRawExtentInfo(scale, model, originalExtent) {
+  var rawExtentInfo = scale.rawExtentInfo;
+  if (rawExtentInfo) {
+    return rawExtentInfo;
+  }
+  rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent);
+  scale.rawExtentInfo = rawExtentInfo;
+  return rawExtentInfo;
+}
+function parseAxisModelMinMax(scale, minMax) {
+  return minMax == null ? null : util.eqNaN(minMax) ? NaN : scale.parse(minMax);
+}
+exports.ScaleRawExtentInfo = ScaleRawExtentInfo;
+exports.ensureScaleRawExtentInfo = ensureScaleRawExtentInfo;
+exports.parseAxisModelMinMax = parseAxisModelMinMax;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var coordinateSystemCreators = {};
+var CoordinateSystemManager = (
+  /** @class */
+  function() {
+    function CoordinateSystemManager2() {
+      this._coordinateSystems = [];
+    }
+    CoordinateSystemManager2.prototype.create = function(ecModel, api) {
+      var coordinateSystems = [];
+      util.each(coordinateSystemCreators, function(creator, type) {
+        var list = creator.create(ecModel, api);
+        coordinateSystems = coordinateSystems.concat(list || []);
+      });
+      this._coordinateSystems = coordinateSystems;
+    };
+    CoordinateSystemManager2.prototype.update = function(ecModel, api) {
+      util.each(this._coordinateSystems, function(coordSys) {
+        coordSys.update && coordSys.update(ecModel, api);
+      });
+    };
+    CoordinateSystemManager2.prototype.getCoordinateSystems = function() {
+      return this._coordinateSystems.slice();
+    };
+    CoordinateSystemManager2.register = function(type, creator) {
+      coordinateSystemCreators[type] = creator;
+    };
+    CoordinateSystemManager2.get = function(type) {
+      return coordinateSystemCreators[type];
+    };
+    return CoordinateSystemManager2;
+  }()
+);
+exports.default = CoordinateSystemManager;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var availableMethods = [
+  "getDom",
+  "getZr",
+  "getWidth",
+  "getHeight",
+  "getDevicePixelRatio",
+  "dispatchAction",
+  "isSSR",
+  "isDisposed",
+  "on",
+  "off",
+  "getDataURL",
+  "getConnectedDataURL",
+  // 'getModel',
+  "getOption",
+  // 'getViewOfComponentModel',
+  // 'getViewOfSeriesModel',
+  "getId",
+  "updateLabelLayout"
+];
+var ExtensionAPI = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function ExtensionAPI2(ecInstance) {
+      util.each(availableMethods, function(methodName) {
+        this[methodName] = util.bind(ecInstance[methodName], ecInstance);
+      }, this);
+    }
+    return ExtensionAPI2;
+  }()
+);
+exports.default = ExtensionAPI;

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

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const task = require("./task.js");
+const component = require("../util/component.js");
+const Global = require("../model/Global.js");
+const ExtensionAPI = require("./ExtensionAPI.js");
+const model = require("../util/model.js");
+var Scheduler = (
+  /** @class */
+  function() {
+    function Scheduler2(ecInstance, api, dataProcessorHandlers, visualHandlers) {
+      this._stageTaskMap = util.createHashMap();
+      this.ecInstance = ecInstance;
+      this.api = api;
+      dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();
+      visualHandlers = this._visualHandlers = visualHandlers.slice();
+      this._allHandlers = dataProcessorHandlers.concat(visualHandlers);
+    }
+    Scheduler2.prototype.restoreData = function(ecModel, payload) {
+      ecModel.restoreData(payload);
+      this._stageTaskMap.each(function(taskRecord) {
+        var overallTask = taskRecord.overallTask;
+        overallTask && overallTask.dirty();
+      });
+    };
+    Scheduler2.prototype.getPerformArgs = function(task2, isBlock) {
+      if (!task2.__pipeline) {
+        return;
+      }
+      var pipeline = this._pipelineMap.get(task2.__pipeline.id);
+      var pCtx = pipeline.context;
+      var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task2.__idxInPipeline > pipeline.blockIndex;
+      var step = incremental ? pipeline.step : null;
+      var modDataCount = pCtx && pCtx.modDataCount;
+      var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;
+      return {
+        step,
+        modBy,
+        modDataCount
+      };
+    };
+    Scheduler2.prototype.getPipeline = function(pipelineId) {
+      return this._pipelineMap.get(pipelineId);
+    };
+    Scheduler2.prototype.updateStreamModes = function(seriesModel, view) {
+      var pipeline = this._pipelineMap.get(seriesModel.uid);
+      var data = seriesModel.getData();
+      var dataLen = data.count();
+      var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;
+      var large = seriesModel.get("large") && dataLen >= seriesModel.get("largeThreshold");
+      var modDataCount = seriesModel.get("progressiveChunkMode") === "mod" ? dataLen : null;
+      seriesModel.pipelineContext = pipeline.context = {
+        progressiveRender,
+        modDataCount,
+        large
+      };
+    };
+    Scheduler2.prototype.restorePipelines = function(ecModel) {
+      var scheduler = this;
+      var pipelineMap = scheduler._pipelineMap = util.createHashMap();
+      ecModel.eachSeries(function(seriesModel) {
+        var progressive = seriesModel.getProgressive();
+        var pipelineId = seriesModel.uid;
+        pipelineMap.set(pipelineId, {
+          id: pipelineId,
+          head: null,
+          tail: null,
+          threshold: seriesModel.getProgressiveThreshold(),
+          progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),
+          blockIndex: -1,
+          step: Math.round(progressive || 700),
+          count: 0
+        });
+        scheduler._pipe(seriesModel, seriesModel.dataTask);
+      });
+    };
+    Scheduler2.prototype.prepareStageTasks = function() {
+      var stageTaskMap = this._stageTaskMap;
+      var ecModel = this.api.getModel();
+      var api = this.api;
+      util.each(this._allHandlers, function(handler) {
+        var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, {});
+        var errMsg = "";
+        util.assert(!(handler.reset && handler.overallReset), errMsg);
+        handler.reset && this._createSeriesStageTask(handler, record, ecModel, api);
+        handler.overallReset && this._createOverallStageTask(handler, record, ecModel, api);
+      }, this);
+    };
+    Scheduler2.prototype.prepareView = function(view, model2, ecModel, api) {
+      var renderTask = view.renderTask;
+      var context = renderTask.context;
+      context.model = model2;
+      context.ecModel = ecModel;
+      context.api = api;
+      renderTask.__block = !view.incrementalPrepareRender;
+      this._pipe(model2, renderTask);
+    };
+    Scheduler2.prototype.performDataProcessorTasks = function(ecModel, payload) {
+      this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, {
+        block: true
+      });
+    };
+    Scheduler2.prototype.performVisualTasks = function(ecModel, payload, opt) {
+      this._performStageTasks(this._visualHandlers, ecModel, payload, opt);
+    };
+    Scheduler2.prototype._performStageTasks = function(stageHandlers, ecModel, payload, opt) {
+      opt = opt || {};
+      var unfinished = false;
+      var scheduler = this;
+      util.each(stageHandlers, function(stageHandler, idx) {
+        if (opt.visualType && opt.visualType !== stageHandler.visualType) {
+          return;
+        }
+        var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid);
+        var seriesTaskMap = stageHandlerRecord.seriesTaskMap;
+        var overallTask = stageHandlerRecord.overallTask;
+        if (overallTask) {
+          var overallNeedDirty_1;
+          var agentStubMap = overallTask.agentStubMap;
+          agentStubMap.each(function(stub) {
+            if (needSetDirty(opt, stub)) {
+              stub.dirty();
+              overallNeedDirty_1 = true;
+            }
+          });
+          overallNeedDirty_1 && overallTask.dirty();
+          scheduler.updatePayload(overallTask, payload);
+          var performArgs_1 = scheduler.getPerformArgs(overallTask, opt.block);
+          agentStubMap.each(function(stub) {
+            stub.perform(performArgs_1);
+          });
+          if (overallTask.perform(performArgs_1)) {
+            unfinished = true;
+          }
+        } else if (seriesTaskMap) {
+          seriesTaskMap.each(function(task2, pipelineId) {
+            if (needSetDirty(opt, task2)) {
+              task2.dirty();
+            }
+            var performArgs = scheduler.getPerformArgs(task2, opt.block);
+            performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task2.context.model);
+            scheduler.updatePayload(task2, payload);
+            if (task2.perform(performArgs)) {
+              unfinished = true;
+            }
+          });
+        }
+      });
+      function needSetDirty(opt2, task2) {
+        return opt2.setDirty && (!opt2.dirtyMap || opt2.dirtyMap.get(task2.__pipeline.id));
+      }
+      this.unfinished = unfinished || this.unfinished;
+    };
+    Scheduler2.prototype.performSeriesTasks = function(ecModel) {
+      var unfinished;
+      ecModel.eachSeries(function(seriesModel) {
+        unfinished = seriesModel.dataTask.perform() || unfinished;
+      });
+      this.unfinished = unfinished || this.unfinished;
+    };
+    Scheduler2.prototype.plan = function() {
+      this._pipelineMap.each(function(pipeline) {
+        var task2 = pipeline.tail;
+        do {
+          if (task2.__block) {
+            pipeline.blockIndex = task2.__idxInPipeline;
+            break;
+          }
+          task2 = task2.getUpstream();
+        } while (task2);
+      });
+    };
+    Scheduler2.prototype.updatePayload = function(task2, payload) {
+      payload !== "remain" && (task2.context.payload = payload);
+    };
+    Scheduler2.prototype._createSeriesStageTask = function(stageHandler, stageHandlerRecord, ecModel, api) {
+      var scheduler = this;
+      var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap;
+      var newSeriesTaskMap = stageHandlerRecord.seriesTaskMap = util.createHashMap();
+      var seriesType2 = stageHandler.seriesType;
+      var getTargetSeries = stageHandler.getTargetSeries;
+      if (stageHandler.createOnAllSeries) {
+        ecModel.eachRawSeries(create);
+      } else if (seriesType2) {
+        ecModel.eachRawSeriesByType(seriesType2, create);
+      } else if (getTargetSeries) {
+        getTargetSeries(ecModel, api).each(create);
+      }
+      function create(seriesModel) {
+        var pipelineId = seriesModel.uid;
+        var task$1 = newSeriesTaskMap.set(pipelineId, oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId) || task.createTask({
+          plan: seriesTaskPlan,
+          reset: seriesTaskReset,
+          count: seriesTaskCount
+        }));
+        task$1.context = {
+          model: seriesModel,
+          ecModel,
+          api,
+          // PENDING: `useClearVisual` not used?
+          useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,
+          plan: stageHandler.plan,
+          reset: stageHandler.reset,
+          scheduler
+        };
+        scheduler._pipe(seriesModel, task$1);
+      }
+    };
+    Scheduler2.prototype._createOverallStageTask = function(stageHandler, stageHandlerRecord, ecModel, api) {
+      var scheduler = this;
+      var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask || task.createTask({
+        reset: overallTaskReset
+      });
+      overallTask.context = {
+        ecModel,
+        api,
+        overallReset: stageHandler.overallReset,
+        scheduler
+      };
+      var oldAgentStubMap = overallTask.agentStubMap;
+      var newAgentStubMap = overallTask.agentStubMap = util.createHashMap();
+      var seriesType2 = stageHandler.seriesType;
+      var getTargetSeries = stageHandler.getTargetSeries;
+      var overallProgress = true;
+      var shouldOverallTaskDirty = false;
+      var errMsg = "";
+      util.assert(!stageHandler.createOnAllSeries, errMsg);
+      if (seriesType2) {
+        ecModel.eachRawSeriesByType(seriesType2, createStub);
+      } else if (getTargetSeries) {
+        getTargetSeries(ecModel, api).each(createStub);
+      } else {
+        overallProgress = false;
+        util.each(ecModel.getSeries(), createStub);
+      }
+      function createStub(seriesModel) {
+        var pipelineId = seriesModel.uid;
+        var stub = newAgentStubMap.set(pipelineId, oldAgentStubMap && oldAgentStubMap.get(pipelineId) || // When the result of `getTargetSeries` changed, the overallTask
+        // should be set as dirty and re-performed.
+        (shouldOverallTaskDirty = true, task.createTask({
+          reset: stubReset,
+          onDirty: stubOnDirty
+        })));
+        stub.context = {
+          model: seriesModel,
+          overallProgress
+          // FIXME:TS never used, so comment it
+          // modifyOutputEnd: modifyOutputEnd
+        };
+        stub.agent = overallTask;
+        stub.__block = overallProgress;
+        scheduler._pipe(seriesModel, stub);
+      }
+      if (shouldOverallTaskDirty) {
+        overallTask.dirty();
+      }
+    };
+    Scheduler2.prototype._pipe = function(seriesModel, task2) {
+      var pipelineId = seriesModel.uid;
+      var pipeline = this._pipelineMap.get(pipelineId);
+      !pipeline.head && (pipeline.head = task2);
+      pipeline.tail && pipeline.tail.pipe(task2);
+      pipeline.tail = task2;
+      task2.__idxInPipeline = pipeline.count++;
+      task2.__pipeline = pipeline;
+    };
+    Scheduler2.wrapStageHandler = function(stageHandler, visualType) {
+      if (util.isFunction(stageHandler)) {
+        stageHandler = {
+          overallReset: stageHandler,
+          seriesType: detectSeriseType(stageHandler)
+        };
+      }
+      stageHandler.uid = component.getUID("stageHandler");
+      visualType && (stageHandler.visualType = visualType);
+      return stageHandler;
+    };
+    return Scheduler2;
+  }()
+);
+function overallTaskReset(context) {
+  context.overallReset(context.ecModel, context.api, context.payload);
+}
+function stubReset(context) {
+  return context.overallProgress && stubProgress;
+}
+function stubProgress() {
+  this.agent.dirty();
+  this.getDownstream().dirty();
+}
+function stubOnDirty() {
+  this.agent && this.agent.dirty();
+}
+function seriesTaskPlan(context) {
+  return context.plan ? context.plan(context.model, context.ecModel, context.api, context.payload) : null;
+}
+function seriesTaskReset(context) {
+  if (context.useClearVisual) {
+    context.data.clearAllVisual();
+  }
+  var resetDefines = context.resetDefines = model.normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));
+  return resetDefines.length > 1 ? util.map(resetDefines, function(v, idx) {
+    return makeSeriesTaskProgress(idx);
+  }) : singleSeriesTaskProgress;
+}
+var singleSeriesTaskProgress = makeSeriesTaskProgress(0);
+function makeSeriesTaskProgress(resetDefineIdx) {
+  return function(params, context) {
+    var data = context.data;
+    var resetDefine = context.resetDefines[resetDefineIdx];
+    if (resetDefine && resetDefine.dataEach) {
+      for (var i = params.start; i < params.end; i++) {
+        resetDefine.dataEach(data, i);
+      }
+    } else if (resetDefine && resetDefine.progress) {
+      resetDefine.progress(params, data);
+    }
+  };
+}
+function seriesTaskCount(context) {
+  return context.data.count();
+}
+function detectSeriseType(legacyFunc) {
+  seriesType = null;
+  try {
+    legacyFunc(ecModelMock, apiMock);
+  } catch (e) {
+  }
+  return seriesType;
+}
+var ecModelMock = {};
+var apiMock = {};
+var seriesType;
+mockMethods(ecModelMock, Global.default);
+mockMethods(apiMock, ExtensionAPI.default);
+ecModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function(type) {
+  seriesType = type;
+};
+ecModelMock.eachComponent = function(cond) {
+  if (cond.mainType === "series" && cond.subType) {
+    seriesType = cond.subType;
+  }
+};
+function mockMethods(target, Clz) {
+  for (var name_1 in Clz.prototype) {
+    target[name_1] = util.noop;
+  }
+}
+exports.default = Scheduler;