@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/helper/RoamController.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Eventful = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/Eventful.js");
+const event = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/event.js");
+const interactionMutex = require("./interactionMutex.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var RoamController = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(RoamController2, _super);
+    function RoamController2(zr) {
+      var _this = _super.call(this) || this;
+      _this._zr = zr;
+      var mousedownHandler = util.bind(_this._mousedownHandler, _this);
+      var mousemoveHandler = util.bind(_this._mousemoveHandler, _this);
+      var mouseupHandler = util.bind(_this._mouseupHandler, _this);
+      var mousewheelHandler = util.bind(_this._mousewheelHandler, _this);
+      var pinchHandler = util.bind(_this._pinchHandler, _this);
+      _this.enable = function(controlType, opt) {
+        this.disable();
+        this._opt = util.defaults(util.clone(opt) || {}, {
+          zoomOnMouseWheel: true,
+          moveOnMouseMove: true,
+          // By default, wheel do not trigger move.
+          moveOnMouseWheel: false,
+          preventDefaultMouseMove: true
+        });
+        if (controlType == null) {
+          controlType = true;
+        }
+        if (controlType === true || controlType === "move" || controlType === "pan") {
+          zr.on("mousedown", mousedownHandler);
+          zr.on("mousemove", mousemoveHandler);
+          zr.on("mouseup", mouseupHandler);
+        }
+        if (controlType === true || controlType === "scale" || controlType === "zoom") {
+          zr.on("mousewheel", mousewheelHandler);
+          zr.on("pinch", pinchHandler);
+        }
+      };
+      _this.disable = function() {
+        zr.off("mousedown", mousedownHandler);
+        zr.off("mousemove", mousemoveHandler);
+        zr.off("mouseup", mouseupHandler);
+        zr.off("mousewheel", mousewheelHandler);
+        zr.off("pinch", pinchHandler);
+      };
+      return _this;
+    }
+    RoamController2.prototype.isDragging = function() {
+      return this._dragging;
+    };
+    RoamController2.prototype.isPinching = function() {
+      return this._pinching;
+    };
+    RoamController2.prototype.setPointerChecker = function(pointerChecker) {
+      this.pointerChecker = pointerChecker;
+    };
+    RoamController2.prototype.dispose = function() {
+      this.disable();
+    };
+    RoamController2.prototype._mousedownHandler = function(e) {
+      if (event.isMiddleOrRightButtonOnMouseUpDown(e)) {
+        return;
+      }
+      var el = e.target;
+      while (el) {
+        if (el.draggable) {
+          return;
+        }
+        el = el.__hostTarget || el.parent;
+      }
+      var x = e.offsetX;
+      var y = e.offsetY;
+      if (this.pointerChecker && this.pointerChecker(e, x, y)) {
+        this._x = x;
+        this._y = y;
+        this._dragging = true;
+      }
+    };
+    RoamController2.prototype._mousemoveHandler = function(e) {
+      if (!this._dragging || !isAvailableBehavior("moveOnMouseMove", e, this._opt) || e.gestureEvent === "pinch" || interactionMutex.isTaken(this._zr, "globalPan")) {
+        return;
+      }
+      var x = e.offsetX;
+      var y = e.offsetY;
+      var oldX = this._x;
+      var oldY = this._y;
+      var dx = x - oldX;
+      var dy = y - oldY;
+      this._x = x;
+      this._y = y;
+      this._opt.preventDefaultMouseMove && event.stop(e.event);
+      trigger(this, "pan", "moveOnMouseMove", e, {
+        dx,
+        dy,
+        oldX,
+        oldY,
+        newX: x,
+        newY: y,
+        isAvailableBehavior: null
+      });
+    };
+    RoamController2.prototype._mouseupHandler = function(e) {
+      if (!event.isMiddleOrRightButtonOnMouseUpDown(e)) {
+        this._dragging = false;
+      }
+    };
+    RoamController2.prototype._mousewheelHandler = function(e) {
+      var shouldZoom = isAvailableBehavior("zoomOnMouseWheel", e, this._opt);
+      var shouldMove = isAvailableBehavior("moveOnMouseWheel", e, this._opt);
+      var wheelDelta = e.wheelDelta;
+      var absWheelDeltaDelta = Math.abs(wheelDelta);
+      var originX = e.offsetX;
+      var originY = e.offsetY;
+      if (wheelDelta === 0 || !shouldZoom && !shouldMove) {
+        return;
+      }
+      if (shouldZoom) {
+        var factor = absWheelDeltaDelta > 3 ? 1.4 : absWheelDeltaDelta > 1 ? 1.2 : 1.1;
+        var scale = wheelDelta > 0 ? factor : 1 / factor;
+        checkPointerAndTrigger(this, "zoom", "zoomOnMouseWheel", e, {
+          scale,
+          originX,
+          originY,
+          isAvailableBehavior: null
+        });
+      }
+      if (shouldMove) {
+        var absDelta = Math.abs(wheelDelta);
+        var scrollDelta = (wheelDelta > 0 ? 1 : -1) * (absDelta > 3 ? 0.4 : absDelta > 1 ? 0.15 : 0.05);
+        checkPointerAndTrigger(this, "scrollMove", "moveOnMouseWheel", e, {
+          scrollDelta,
+          originX,
+          originY,
+          isAvailableBehavior: null
+        });
+      }
+    };
+    RoamController2.prototype._pinchHandler = function(e) {
+      if (interactionMutex.isTaken(this._zr, "globalPan")) {
+        return;
+      }
+      var scale = e.pinchScale > 1 ? 1.1 : 1 / 1.1;
+      checkPointerAndTrigger(this, "zoom", null, e, {
+        scale,
+        originX: e.pinchX,
+        originY: e.pinchY,
+        isAvailableBehavior: null
+      });
+    };
+    return RoamController2;
+  }(Eventful.default)
+);
+function checkPointerAndTrigger(controller, eventName, behaviorToCheck, e, contollerEvent) {
+  if (controller.pointerChecker && controller.pointerChecker(e, contollerEvent.originX, contollerEvent.originY)) {
+    event.stop(e.event);
+    trigger(controller, eventName, behaviorToCheck, e, contollerEvent);
+  }
+}
+function trigger(controller, eventName, behaviorToCheck, e, contollerEvent) {
+  contollerEvent.isAvailableBehavior = util.bind(isAvailableBehavior, null, behaviorToCheck, e);
+  controller.trigger(eventName, contollerEvent);
+}
+function isAvailableBehavior(behaviorToCheck, e, settings) {
+  var setting = settings[behaviorToCheck];
+  return !behaviorToCheck || setting && (!util.isString(setting) || e.event[setting + "Key"]);
+}
+exports.default = RoamController;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/helper/interactionMutex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const echarts = require("../../core/echarts.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var ATTR = "\0_ec_interaction_mutex";
+function isTaken(zr, resourceKey) {
+  return !!getStore(zr)[resourceKey];
+}
+function getStore(zr) {
+  return zr[ATTR] || (zr[ATTR] = {});
+}
+echarts.registerAction({
+  type: "takeGlobalCursor",
+  event: "globalCursorTaken",
+  update: "update"
+}, util.noop);
+exports.isTaken = isTaken;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/helper/listComponent.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const format = require("../../util/format.js");
+const Rect = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.js");
+function makeBackground(rect, componentModel) {
+  var padding = format.normalizeCssArray(componentModel.get("padding"));
+  var style = componentModel.getItemStyle(["color", "opacity"]);
+  style.fill = componentModel.get("backgroundColor");
+  rect = new Rect.default({
+    shape: {
+      x: rect.x - padding[3],
+      y: rect.y - padding[0],
+      width: rect.width + padding[1] + padding[3],
+      height: rect.height + padding[0] + padding[2],
+      r: componentModel.get("borderRadius")
+    },
+    style,
+    silent: true,
+    z2: -1
+  });
+  return rect;
+}
+exports.makeBackground = makeBackground;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/helper/sliderMove.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function sliderMove(delta, handleEnds, extent, handleIndex, minSpan, maxSpan) {
+  delta = delta || 0;
+  var extentSpan = extent[1] - extent[0];
+  if (minSpan != null) {
+    minSpan = restrict(minSpan, [0, extentSpan]);
+  }
+  if (maxSpan != null) {
+    maxSpan = Math.max(maxSpan, minSpan != null ? minSpan : 0);
+  }
+  if (handleIndex === "all") {
+    var handleSpan = Math.abs(handleEnds[1] - handleEnds[0]);
+    handleSpan = restrict(handleSpan, [0, extentSpan]);
+    minSpan = maxSpan = restrict(handleSpan, [minSpan, maxSpan]);
+    handleIndex = 0;
+  }
+  handleEnds[0] = restrict(handleEnds[0], extent);
+  handleEnds[1] = restrict(handleEnds[1], extent);
+  var originalDistSign = getSpanSign(handleEnds, handleIndex);
+  handleEnds[handleIndex] += delta;
+  var extentMinSpan = minSpan || 0;
+  var realExtent = extent.slice();
+  originalDistSign.sign < 0 ? realExtent[0] += extentMinSpan : realExtent[1] -= extentMinSpan;
+  handleEnds[handleIndex] = restrict(handleEnds[handleIndex], realExtent);
+  var currDistSign;
+  currDistSign = getSpanSign(handleEnds, handleIndex);
+  if (minSpan != null && (currDistSign.sign !== originalDistSign.sign || currDistSign.span < minSpan)) {
+    handleEnds[1 - handleIndex] = handleEnds[handleIndex] + originalDistSign.sign * minSpan;
+  }
+  currDistSign = getSpanSign(handleEnds, handleIndex);
+  if (maxSpan != null && currDistSign.span > maxSpan) {
+    handleEnds[1 - handleIndex] = handleEnds[handleIndex] + currDistSign.sign * maxSpan;
+  }
+  return handleEnds;
+}
+function getSpanSign(handleEnds, handleIndex) {
+  var dist = handleEnds[handleIndex] - handleEnds[1 - handleIndex];
+  return {
+    span: Math.abs(dist),
+    sign: dist > 0 ? -1 : dist < 0 ? 1 : handleIndex ? -1 : 1
+  };
+}
+function restrict(value, extend) {
+  return Math.min(extend[1] != null ? extend[1] : Infinity, Math.max(extend[0] != null ? extend[0] : -Infinity, value));
+}
+exports.default = sliderMove;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/LegendModel.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Model = require("../../model/Model.js");
+const model = require("../../util/model.js");
+const Component = require("../../model/Component.js");
+var getDefaultSelectorOptions = function(ecModel, type) {
+  if (type === "all") {
+    return {
+      type: "all",
+      title: ecModel.getLocaleModel().get(["legend", "selector", "all"])
+    };
+  } else if (type === "inverse") {
+    return {
+      type: "inverse",
+      title: ecModel.getLocaleModel().get(["legend", "selector", "inverse"])
+    };
+  }
+};
+var LegendModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(LegendModel2, _super);
+    function LegendModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = LegendModel2.type;
+      _this.layoutMode = {
+        type: "box",
+        // legend.width/height are maxWidth/maxHeight actually,
+        // whereas real width/height is calculated by its content.
+        // (Setting {left: 10, right: 10} does not make sense).
+        // So consider the case:
+        // `setOption({legend: {left: 10});`
+        // then `setOption({legend: {right: 10});`
+        // The previous `left` should be cleared by setting `ignoreSize`.
+        ignoreSize: true
+      };
+      return _this;
+    }
+    LegendModel2.prototype.init = function(option, parentModel, ecModel) {
+      this.mergeDefaultAndTheme(option, ecModel);
+      option.selected = option.selected || {};
+      this._updateSelector(option);
+    };
+    LegendModel2.prototype.mergeOption = function(option, ecModel) {
+      _super.prototype.mergeOption.call(this, option, ecModel);
+      this._updateSelector(option);
+    };
+    LegendModel2.prototype._updateSelector = function(option) {
+      var selector = option.selector;
+      var ecModel = this.ecModel;
+      if (selector === true) {
+        selector = option.selector = ["all", "inverse"];
+      }
+      if (util.isArray(selector)) {
+        util.each(selector, function(item, index) {
+          util.isString(item) && (item = {
+            type: item
+          });
+          selector[index] = util.merge(item, getDefaultSelectorOptions(ecModel, item.type));
+        });
+      }
+    };
+    LegendModel2.prototype.optionUpdated = function() {
+      this._updateData(this.ecModel);
+      var legendData = this._data;
+      if (legendData[0] && this.get("selectedMode") === "single") {
+        var hasSelected = false;
+        for (var i = 0; i < legendData.length; i++) {
+          var name_1 = legendData[i].get("name");
+          if (this.isSelected(name_1)) {
+            this.select(name_1);
+            hasSelected = true;
+            break;
+          }
+        }
+        !hasSelected && this.select(legendData[0].get("name"));
+      }
+    };
+    LegendModel2.prototype._updateData = function(ecModel) {
+      var potentialData = [];
+      var availableNames = [];
+      ecModel.eachRawSeries(function(seriesModel) {
+        var seriesName = seriesModel.name;
+        availableNames.push(seriesName);
+        var isPotential;
+        if (seriesModel.legendVisualProvider) {
+          var provider = seriesModel.legendVisualProvider;
+          var names = provider.getAllNames();
+          if (!ecModel.isSeriesFiltered(seriesModel)) {
+            availableNames = availableNames.concat(names);
+          }
+          if (names.length) {
+            potentialData = potentialData.concat(names);
+          } else {
+            isPotential = true;
+          }
+        } else {
+          isPotential = true;
+        }
+        if (isPotential && model.isNameSpecified(seriesModel)) {
+          potentialData.push(seriesModel.name);
+        }
+      });
+      this._availableNames = availableNames;
+      var rawData = this.get("data") || potentialData;
+      var legendNameMap = util.createHashMap();
+      var legendData = util.map(rawData, function(dataItem) {
+        if (util.isString(dataItem) || util.isNumber(dataItem)) {
+          dataItem = {
+            name: dataItem
+          };
+        }
+        if (legendNameMap.get(dataItem.name)) {
+          return null;
+        }
+        legendNameMap.set(dataItem.name, true);
+        return new Model.default(dataItem, this, this.ecModel);
+      }, this);
+      this._data = util.filter(legendData, function(item) {
+        return !!item;
+      });
+    };
+    LegendModel2.prototype.getData = function() {
+      return this._data;
+    };
+    LegendModel2.prototype.select = function(name) {
+      var selected = this.option.selected;
+      var selectedMode = this.get("selectedMode");
+      if (selectedMode === "single") {
+        var data = this._data;
+        util.each(data, function(dataItem) {
+          selected[dataItem.get("name")] = false;
+        });
+      }
+      selected[name] = true;
+    };
+    LegendModel2.prototype.unSelect = function(name) {
+      if (this.get("selectedMode") !== "single") {
+        this.option.selected[name] = false;
+      }
+    };
+    LegendModel2.prototype.toggleSelected = function(name) {
+      var selected = this.option.selected;
+      if (!selected.hasOwnProperty(name)) {
+        selected[name] = true;
+      }
+      this[selected[name] ? "unSelect" : "select"](name);
+    };
+    LegendModel2.prototype.allSelect = function() {
+      var data = this._data;
+      var selected = this.option.selected;
+      util.each(data, function(dataItem) {
+        selected[dataItem.get("name", true)] = true;
+      });
+    };
+    LegendModel2.prototype.inverseSelect = function() {
+      var data = this._data;
+      var selected = this.option.selected;
+      util.each(data, function(dataItem) {
+        var name = dataItem.get("name", true);
+        if (!selected.hasOwnProperty(name)) {
+          selected[name] = true;
+        }
+        selected[name] = !selected[name];
+      });
+    };
+    LegendModel2.prototype.isSelected = function(name) {
+      var selected = this.option.selected;
+      return !(selected.hasOwnProperty(name) && !selected[name]) && util.indexOf(this._availableNames, name) >= 0;
+    };
+    LegendModel2.prototype.getOrient = function() {
+      return this.get("orient") === "vertical" ? {
+        index: 1,
+        name: "vertical"
+      } : {
+        index: 0,
+        name: "horizontal"
+      };
+    };
+    LegendModel2.type = "legend.plain";
+    LegendModel2.dependencies = ["series"];
+    LegendModel2.defaultOption = {
+      // zlevel: 0,
+      z: 4,
+      show: true,
+      orient: "horizontal",
+      left: "center",
+      // right: 'center',
+      top: 0,
+      // bottom: null,
+      align: "auto",
+      backgroundColor: "rgba(0,0,0,0)",
+      borderColor: "#ccc",
+      borderRadius: 0,
+      borderWidth: 0,
+      padding: 5,
+      itemGap: 10,
+      itemWidth: 25,
+      itemHeight: 14,
+      symbolRotate: "inherit",
+      symbolKeepAspect: true,
+      inactiveColor: "#ccc",
+      inactiveBorderColor: "#ccc",
+      inactiveBorderWidth: "auto",
+      itemStyle: {
+        color: "inherit",
+        opacity: "inherit",
+        borderColor: "inherit",
+        borderWidth: "auto",
+        borderCap: "inherit",
+        borderJoin: "inherit",
+        borderDashOffset: "inherit",
+        borderMiterLimit: "inherit"
+      },
+      lineStyle: {
+        width: "auto",
+        color: "inherit",
+        inactiveColor: "#ccc",
+        inactiveWidth: 2,
+        opacity: "inherit",
+        type: "inherit",
+        cap: "inherit",
+        join: "inherit",
+        dashOffset: "inherit",
+        miterLimit: "inherit"
+      },
+      textStyle: {
+        color: "#333"
+      },
+      selectedMode: true,
+      selector: false,
+      selectorLabel: {
+        show: true,
+        borderRadius: 10,
+        padding: [3, 5, 3, 5],
+        fontSize: 12,
+        fontFamily: "sans-serif",
+        color: "#666",
+        borderWidth: 1,
+        borderColor: "#666"
+      },
+      emphasis: {
+        selectorLabel: {
+          show: true,
+          color: "#eee",
+          backgroundColor: "#666"
+        }
+      },
+      selectorPosition: "auto",
+      selectorItemGap: 7,
+      selectorButtonGap: 10,
+      tooltip: {
+        show: false
+      }
+    };
+    return LegendModel2;
+  }(Component.default)
+);
+exports.default = LegendModel;