@fecp/mobile 1.0.78 → 1.1.0

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

@@ -0,0 +1,18 @@
+import { findEffectedDataZooms } from "./helper.mjs";
+import { each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function installDataZoomAction(registers) {
+  registers.registerAction("dataZoom", function(payload, ecModel) {
+    var effectedModels = findEffectedDataZooms(ecModel, payload);
+    each(effectedModels, function(dataZoomModel) {
+      dataZoomModel.setRawRange({
+        start: payload.start,
+        end: payload.end,
+        startValue: payload.startValue,
+        endValue: payload.endValue
+      });
+    });
+  });
+}
+export {
+  installDataZoomAction as default
+};

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

@@ -0,0 +1,64 @@
+import { createHashMap, each } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { getAxisMainType } from "./helper.mjs";
+import AxisProxy from "./AxisProxy.mjs";
+var dataZoomProcessor = {
+  // `dataZoomProcessor` will only be performed in needed series. Consider if
+  // there is a line series and a pie series, it is better not to update the
+  // line series if only pie series is needed to be updated.
+  getTargetSeries: function(ecModel) {
+    function eachAxisModel(cb) {
+      ecModel.eachComponent("dataZoom", function(dataZoomModel) {
+        dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+          var axisModel = ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+          cb(axisDim, axisIndex, axisModel, dataZoomModel);
+        });
+      });
+    }
+    eachAxisModel(function(axisDim, axisIndex, axisModel, dataZoomModel) {
+      axisModel.__dzAxisProxy = null;
+    });
+    var proxyList = [];
+    eachAxisModel(function(axisDim, axisIndex, axisModel, dataZoomModel) {
+      if (!axisModel.__dzAxisProxy) {
+        axisModel.__dzAxisProxy = new AxisProxy(axisDim, axisIndex, dataZoomModel, ecModel);
+        proxyList.push(axisModel.__dzAxisProxy);
+      }
+    });
+    var seriesModelMap = createHashMap();
+    each(proxyList, function(axisProxy) {
+      each(axisProxy.getTargetSeriesModels(), function(seriesModel) {
+        seriesModelMap.set(seriesModel.uid, seriesModel);
+      });
+    });
+    return seriesModelMap;
+  },
+  // Consider appendData, where filter should be performed. Because data process is
+  // in block mode currently, it is not need to worry about that the overallProgress
+  // execute every frame.
+  overallReset: function(ecModel, api) {
+    ecModel.eachComponent("dataZoom", function(dataZoomModel) {
+      dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+        dataZoomModel.getAxisProxy(axisDim, axisIndex).reset(dataZoomModel);
+      });
+      dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+        dataZoomModel.getAxisProxy(axisDim, axisIndex).filterData(dataZoomModel, api);
+      });
+    });
+    ecModel.eachComponent("dataZoom", function(dataZoomModel) {
+      var axisProxy = dataZoomModel.findRepresentativeAxisProxy();
+      if (axisProxy) {
+        var percentRange = axisProxy.getDataPercentWindow();
+        var valueRange = axisProxy.getDataValueWindow();
+        dataZoomModel.setCalculatedRange({
+          start: percentRange[0],
+          end: percentRange[1],
+          startValue: valueRange[0],
+          endValue: valueRange[1]
+        });
+      }
+    });
+  }
+};
+export {
+  dataZoomProcessor as default
+};

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

@@ -0,0 +1,91 @@
+import { createHashMap, indexOf } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var DATA_ZOOM_AXIS_DIMENSIONS = ["x", "y", "radius", "angle", "single"];
+var SERIES_COORDS = ["cartesian2d", "polar", "singleAxis"];
+function isCoordSupported(seriesModel) {
+  var coordType = seriesModel.get("coordinateSystem");
+  return indexOf(SERIES_COORDS, coordType) >= 0;
+}
+function getAxisMainType(axisDim) {
+  return axisDim + "Axis";
+}
+function findEffectedDataZooms(ecModel, payload) {
+  var axisRecords = createHashMap();
+  var effectedModels = [];
+  var effectedModelMap = createHashMap();
+  ecModel.eachComponent({
+    mainType: "dataZoom",
+    query: payload
+  }, function(dataZoomModel) {
+    if (!effectedModelMap.get(dataZoomModel.uid)) {
+      addToEffected(dataZoomModel);
+    }
+  });
+  var foundNewLink;
+  do {
+    foundNewLink = false;
+    ecModel.eachComponent("dataZoom", processSingle);
+  } while (foundNewLink);
+  function processSingle(dataZoomModel) {
+    if (!effectedModelMap.get(dataZoomModel.uid) && isLinked(dataZoomModel)) {
+      addToEffected(dataZoomModel);
+      foundNewLink = true;
+    }
+  }
+  function addToEffected(dataZoom) {
+    effectedModelMap.set(dataZoom.uid, true);
+    effectedModels.push(dataZoom);
+    markAxisControlled(dataZoom);
+  }
+  function isLinked(dataZoomModel) {
+    var isLink = false;
+    dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+      var axisIdxArr = axisRecords.get(axisDim);
+      if (axisIdxArr && axisIdxArr[axisIndex]) {
+        isLink = true;
+      }
+    });
+    return isLink;
+  }
+  function markAxisControlled(dataZoomModel) {
+    dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+      (axisRecords.get(axisDim) || axisRecords.set(axisDim, []))[axisIndex] = true;
+    });
+  }
+  return effectedModels;
+}
+function collectReferCoordSysModelInfo(dataZoomModel) {
+  var ecModel = dataZoomModel.ecModel;
+  var coordSysInfoWrap = {
+    infoList: [],
+    infoMap: createHashMap()
+  };
+  dataZoomModel.eachTargetAxis(function(axisDim, axisIndex) {
+    var axisModel = ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+    if (!axisModel) {
+      return;
+    }
+    var coordSysModel = axisModel.getCoordSysModel();
+    if (!coordSysModel) {
+      return;
+    }
+    var coordSysUid = coordSysModel.uid;
+    var coordSysInfo = coordSysInfoWrap.infoMap.get(coordSysUid);
+    if (!coordSysInfo) {
+      coordSysInfo = {
+        model: coordSysModel,
+        axisModels: []
+      };
+      coordSysInfoWrap.infoList.push(coordSysInfo);
+      coordSysInfoWrap.infoMap.set(coordSysUid, coordSysInfo);
+    }
+    coordSysInfo.axisModels.push(axisModel);
+  });
+  return coordSysInfoWrap;
+}
+export {
+  DATA_ZOOM_AXIS_DIMENSIONS,
+  collectReferCoordSysModelInfo,
+  findEffectedDataZooms,
+  getAxisMainType,
+  isCoordSupported
+};

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

@@ -0,0 +1,10 @@
+import { use } from "../../extension.mjs";
+import { install as install$1 } from "./installDataZoomInside.mjs";
+import { install as install$2 } from "./installDataZoomSlider.mjs";
+function install(registers) {
+  use(install$1);
+  use(install$2);
+}
+export {
+  install
+};

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

@@ -0,0 +1,17 @@
+import dataZoomProcessor from "./dataZoomProcessor.mjs";
+import installDataZoomAction from "./dataZoomAction.mjs";
+var installed = false;
+function installCommon(registers) {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, dataZoomProcessor);
+  installDataZoomAction(registers);
+  registers.registerSubTypeDefaulter("dataZoom", function() {
+    return "slider";
+  });
+}
+export {
+  installCommon as default
+};

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

@@ -0,0 +1,13 @@
+import InsideZoomModel from "./InsideZoomModel.mjs";
+import InsideZoomView from "./InsideZoomView.mjs";
+import { installDataZoomRoamProcessor } from "./roams.mjs";
+import installCommon from "./installCommon.mjs";
+function install(registers) {
+  installCommon(registers);
+  registers.registerComponentModel(InsideZoomModel);
+  registers.registerComponentView(InsideZoomView);
+  installDataZoomRoamProcessor(registers);
+}
+export {
+  install
+};

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

@@ -0,0 +1,11 @@
+import SliderZoomModel from "./SliderZoomModel.mjs";
+import SliderZoomView from "./SliderZoomView.mjs";
+import installCommon from "./installCommon.mjs";
+function install(registers) {
+  registers.registerComponentModel(SliderZoomModel);
+  registers.registerComponentView(SliderZoomView);
+  installCommon(registers);
+}
+export {
+  install
+};

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

@@ -0,0 +1,164 @@
+import RoamController from "../helper/RoamController.mjs";
+import { createOrUpdate } from "../../util/throttle.mjs";
+import { makeInner } from "../../util/model.mjs";
+import { createHashMap, each, curry } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { collectReferCoordSysModelInfo } from "./helper.mjs";
+var inner = makeInner();
+function setViewInfoToCoordSysRecord(api, dataZoomModel, getRange) {
+  inner(api).coordSysRecordMap.each(function(coordSysRecord) {
+    var dzInfo = coordSysRecord.dataZoomInfoMap.get(dataZoomModel.uid);
+    if (dzInfo) {
+      dzInfo.getRange = getRange;
+    }
+  });
+}
+function disposeCoordSysRecordIfNeeded(api, dataZoomModel) {
+  var coordSysRecordMap = inner(api).coordSysRecordMap;
+  var coordSysKeyArr = coordSysRecordMap.keys();
+  for (var i = 0; i < coordSysKeyArr.length; i++) {
+    var coordSysKey = coordSysKeyArr[i];
+    var coordSysRecord = coordSysRecordMap.get(coordSysKey);
+    var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+    if (dataZoomInfoMap) {
+      var dzUid = dataZoomModel.uid;
+      var dzInfo = dataZoomInfoMap.get(dzUid);
+      if (dzInfo) {
+        dataZoomInfoMap.removeKey(dzUid);
+        if (!dataZoomInfoMap.keys().length) {
+          disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+        }
+      }
+    }
+  }
+}
+function disposeCoordSysRecord(coordSysRecordMap, coordSysRecord) {
+  if (coordSysRecord) {
+    coordSysRecordMap.removeKey(coordSysRecord.model.uid);
+    var controller = coordSysRecord.controller;
+    controller && controller.dispose();
+  }
+}
+function createCoordSysRecord(api, coordSysModel) {
+  var coordSysRecord = {
+    model: coordSysModel,
+    containsPoint: curry(containsPoint, coordSysModel),
+    dispatchAction: curry(dispatchAction, api),
+    dataZoomInfoMap: null,
+    controller: null
+  };
+  var controller = coordSysRecord.controller = new RoamController(api.getZr());
+  each(["pan", "zoom", "scrollMove"], function(eventName) {
+    controller.on(eventName, function(event) {
+      var batch = [];
+      coordSysRecord.dataZoomInfoMap.each(function(dzInfo) {
+        if (!event.isAvailableBehavior(dzInfo.model.option)) {
+          return;
+        }
+        var method = (dzInfo.getRange || {})[eventName];
+        var range = method && method(dzInfo.dzReferCoordSysInfo, coordSysRecord.model.mainType, coordSysRecord.controller, event);
+        !dzInfo.model.get("disabled", true) && range && batch.push({
+          dataZoomId: dzInfo.model.id,
+          start: range[0],
+          end: range[1]
+        });
+      });
+      batch.length && coordSysRecord.dispatchAction(batch);
+    });
+  });
+  return coordSysRecord;
+}
+function dispatchAction(api, batch) {
+  if (!api.isDisposed()) {
+    api.dispatchAction({
+      type: "dataZoom",
+      animation: {
+        easing: "cubicOut",
+        duration: 100
+      },
+      batch
+    });
+  }
+}
+function containsPoint(coordSysModel, e, x, y) {
+  return coordSysModel.coordinateSystem.containPoint([x, y]);
+}
+function mergeControllerParams(dataZoomInfoMap) {
+  var controlType;
+  var prefix = "type_";
+  var typePriority = {
+    "type_true": 2,
+    "type_move": 1,
+    "type_false": 0,
+    "type_undefined": -1
+  };
+  var preventDefaultMouseMove = true;
+  dataZoomInfoMap.each(function(dataZoomInfo) {
+    var dataZoomModel = dataZoomInfo.model;
+    var oneType = dataZoomModel.get("disabled", true) ? false : dataZoomModel.get("zoomLock", true) ? "move" : true;
+    if (typePriority[prefix + oneType] > typePriority[prefix + controlType]) {
+      controlType = oneType;
+    }
+    preventDefaultMouseMove = preventDefaultMouseMove && dataZoomModel.get("preventDefaultMouseMove", true);
+  });
+  return {
+    controlType,
+    opt: {
+      // RoamController will enable all of these functionalities,
+      // and the final behavior is determined by its event listener
+      // provided by each inside zoom.
+      zoomOnMouseWheel: true,
+      moveOnMouseMove: true,
+      moveOnMouseWheel: true,
+      preventDefaultMouseMove: !!preventDefaultMouseMove
+    }
+  };
+}
+function installDataZoomRoamProcessor(registers) {
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, function(ecModel, api) {
+    var apiInner = inner(api);
+    var coordSysRecordMap = apiInner.coordSysRecordMap || (apiInner.coordSysRecordMap = createHashMap());
+    coordSysRecordMap.each(function(coordSysRecord) {
+      coordSysRecord.dataZoomInfoMap = null;
+    });
+    ecModel.eachComponent({
+      mainType: "dataZoom",
+      subType: "inside"
+    }, function(dataZoomModel) {
+      var dzReferCoordSysWrap = collectReferCoordSysModelInfo(dataZoomModel);
+      each(dzReferCoordSysWrap.infoList, function(dzCoordSysInfo) {
+        var coordSysUid = dzCoordSysInfo.model.uid;
+        var coordSysRecord = coordSysRecordMap.get(coordSysUid) || coordSysRecordMap.set(coordSysUid, createCoordSysRecord(api, dzCoordSysInfo.model));
+        var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap || (coordSysRecord.dataZoomInfoMap = createHashMap());
+        dataZoomInfoMap.set(dataZoomModel.uid, {
+          dzReferCoordSysInfo: dzCoordSysInfo,
+          model: dataZoomModel,
+          getRange: null
+        });
+      });
+    });
+    coordSysRecordMap.each(function(coordSysRecord) {
+      var controller = coordSysRecord.controller;
+      var firstDzInfo;
+      var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+      if (dataZoomInfoMap) {
+        var firstDzKey = dataZoomInfoMap.keys()[0];
+        if (firstDzKey != null) {
+          firstDzInfo = dataZoomInfoMap.get(firstDzKey);
+        }
+      }
+      if (!firstDzInfo) {
+        disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+        return;
+      }
+      var controllerParams = mergeControllerParams(dataZoomInfoMap);
+      controller.enable(controllerParams.controlType, controllerParams.opt);
+      controller.setPointerChecker(coordSysRecord.containsPoint);
+      createOrUpdate(coordSysRecord, "dispatchAction", firstDzInfo.model.get("throttle", true), "fixRate");
+    });
+  });
+}
+export {
+  disposeCoordSysRecordIfNeeded,
+  installDataZoomRoamProcessor,
+  setViewInfoToCoordSysRecord
+};

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

@@ -0,0 +1,57 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import ComponentModel from "../../model/Component.mjs";
+import ComponentView from "../../view/Component.mjs";
+import { SERIES_LAYOUT_BY_COLUMN } from "../../util/types.mjs";
+import { SourceManager, disableTransformOptionMerge } from "../../data/helper/sourceManager.mjs";
+var DatasetModel = (
+  /** @class */
+  function(_super) {
+    __extends(DatasetModel2, _super);
+    function DatasetModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "dataset";
+      return _this;
+    }
+    DatasetModel2.prototype.init = function(option, parentModel, ecModel) {
+      _super.prototype.init.call(this, option, parentModel, ecModel);
+      this._sourceManager = new SourceManager(this);
+      disableTransformOptionMerge(this);
+    };
+    DatasetModel2.prototype.mergeOption = function(newOption, ecModel) {
+      _super.prototype.mergeOption.call(this, newOption, ecModel);
+      disableTransformOptionMerge(this);
+    };
+    DatasetModel2.prototype.optionUpdated = function() {
+      this._sourceManager.dirty();
+    };
+    DatasetModel2.prototype.getSourceManager = function() {
+      return this._sourceManager;
+    };
+    DatasetModel2.type = "dataset";
+    DatasetModel2.defaultOption = {
+      seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN
+    };
+    return DatasetModel2;
+  }(ComponentModel)
+);
+var DatasetView = (
+  /** @class */
+  function(_super) {
+    __extends(DatasetView2, _super);
+    function DatasetView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "dataset";
+      return _this;
+    }
+    DatasetView2.type = "dataset";
+    return DatasetView2;
+  }(ComponentView)
+);
+function install(registers) {
+  registers.registerComponentModel(DatasetModel);
+  registers.registerComponentView(DatasetView);
+}
+export {
+  DatasetModel,
+  install
+};

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

@@ -0,0 +1,10 @@
+import { install as install$1 } from "./installSimple.mjs";
+import { install as install$2 } from "../axisPointer/install.mjs";
+import { use } from "../../extension.mjs";
+function install(registers) {
+  use(install$1);
+  use(install$2);
+}
+export {
+  install
+};

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

@@ -0,0 +1,58 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import ComponentView from "../../view/Component.mjs";
+import GridModel from "../../coord/cartesian/GridModel.mjs";
+import "../../util/graphic.mjs";
+import { defaults } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { CartesianAxisModel } from "../../coord/cartesian/AxisModel.mjs";
+import axisModelCreator from "../../coord/axisModelCreator.mjs";
+import Grid from "../../coord/cartesian/Grid.mjs";
+import { CartesianXAxisView, CartesianYAxisView } from "../axis/CartesianAxisView.mjs";
+import Rect from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.mjs";
+var GridView = (
+  /** @class */
+  function(_super) {
+    __extends(GridView2, _super);
+    function GridView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "grid";
+      return _this;
+    }
+    GridView2.prototype.render = function(gridModel, ecModel) {
+      this.group.removeAll();
+      if (gridModel.get("show")) {
+        this.group.add(new Rect({
+          shape: gridModel.coordinateSystem.getRect(),
+          style: defaults({
+            fill: gridModel.get("backgroundColor")
+          }, gridModel.getItemStyle()),
+          silent: true,
+          z2: -1
+        }));
+      }
+    };
+    GridView2.type = "grid";
+    return GridView2;
+  }(ComponentView)
+);
+var extraOption = {
+  // gridIndex: 0,
+  // gridId: '',
+  offset: 0
+};
+function install(registers) {
+  registers.registerComponentView(GridView);
+  registers.registerComponentModel(GridModel);
+  registers.registerCoordinateSystem("cartesian2d", Grid);
+  axisModelCreator(registers, "x", CartesianAxisModel, extraOption);
+  axisModelCreator(registers, "y", CartesianAxisModel, extraOption);
+  registers.registerComponentView(CartesianXAxisView);
+  registers.registerComponentView(CartesianYAxisView);
+  registers.registerPreprocessor(function(option) {
+    if (option.xAxis && option.yAxis && !option.grid) {
+      option.grid = {};
+    }
+  });
+}
+export {
+  install
+};