@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axis/CartesianAxisView.js

@@ -0,0 +1,199 @@
+"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 graphic = require("../../util/graphic.js");
+const AxisBuilder = require("./AxisBuilder.js");
+const AxisView = require("./AxisView.js");
+const cartesianAxisHelper = require("../../coord/cartesian/cartesianAxisHelper.js");
+const axisSplitHelper = require("./axisSplitHelper.js");
+const helper = require("../../scale/helper.js");
+const Group = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+const Line = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Line.js");
+var axisBuilderAttrs = ["axisLine", "axisTickLabel", "axisName"];
+var selfBuilderAttrs = ["splitArea", "splitLine", "minorSplitLine"];
+var CartesianAxisView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(CartesianAxisView2, _super);
+    function CartesianAxisView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = CartesianAxisView2.type;
+      _this.axisPointerClass = "CartesianAxisPointer";
+      return _this;
+    }
+    CartesianAxisView2.prototype.render = function(axisModel, ecModel, api, payload) {
+      this.group.removeAll();
+      var oldAxisGroup = this._axisGroup;
+      this._axisGroup = new Group.default();
+      this.group.add(this._axisGroup);
+      if (!axisModel.get("show")) {
+        return;
+      }
+      var gridModel = axisModel.getCoordSysModel();
+      var layout = cartesianAxisHelper.layout(gridModel, axisModel);
+      var axisBuilder = new AxisBuilder.default(axisModel, util.extend({
+        handleAutoShown: function(elementType) {
+          var cartesians = gridModel.coordinateSystem.getCartesians();
+          for (var i = 0; i < cartesians.length; i++) {
+            if (helper.isIntervalOrLogScale(cartesians[i].getOtherAxis(axisModel.axis).scale)) {
+              return true;
+            }
+          }
+          return false;
+        }
+      }, layout));
+      util.each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
+      this._axisGroup.add(axisBuilder.getGroup());
+      util.each(selfBuilderAttrs, function(name) {
+        if (axisModel.get([name, "show"])) {
+          axisElementBuilders[name](this, this._axisGroup, axisModel, gridModel);
+        }
+      }, this);
+      var isInitialSortFromBarRacing = payload && payload.type === "changeAxisOrder" && payload.isInitSort;
+      if (!isInitialSortFromBarRacing) {
+        graphic.groupTransition(oldAxisGroup, this._axisGroup, axisModel);
+      }
+      _super.prototype.render.call(this, axisModel, ecModel, api, payload);
+    };
+    CartesianAxisView2.prototype.remove = function() {
+      axisSplitHelper.rectCoordAxisHandleRemove(this);
+    };
+    CartesianAxisView2.type = "cartesianAxis";
+    return CartesianAxisView2;
+  }(AxisView.default)
+);
+var axisElementBuilders = {
+  splitLine: function(axisView, axisGroup, axisModel, gridModel) {
+    var axis = axisModel.axis;
+    if (axis.scale.isBlank()) {
+      return;
+    }
+    var splitLineModel = axisModel.getModel("splitLine");
+    var lineStyleModel = splitLineModel.getModel("lineStyle");
+    var lineColors = lineStyleModel.get("color");
+    var showMinLine = splitLineModel.get("showMinLine") !== false;
+    var showMaxLine = splitLineModel.get("showMaxLine") !== false;
+    lineColors = util.isArray(lineColors) ? lineColors : [lineColors];
+    var gridRect = gridModel.coordinateSystem.getRect();
+    var isHorizontal = axis.isHorizontal();
+    var lineCount = 0;
+    var ticksCoords = axis.getTicksCoords({
+      tickModel: splitLineModel
+    });
+    var p1 = [];
+    var p2 = [];
+    var lineStyle = lineStyleModel.getLineStyle();
+    for (var i = 0; i < ticksCoords.length; i++) {
+      var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
+      if (i === 0 && !showMinLine || i === ticksCoords.length - 1 && !showMaxLine) {
+        continue;
+      }
+      var tickValue = ticksCoords[i].tickValue;
+      if (isHorizontal) {
+        p1[0] = tickCoord;
+        p1[1] = gridRect.y;
+        p2[0] = tickCoord;
+        p2[1] = gridRect.y + gridRect.height;
+      } else {
+        p1[0] = gridRect.x;
+        p1[1] = tickCoord;
+        p2[0] = gridRect.x + gridRect.width;
+        p2[1] = tickCoord;
+      }
+      var colorIndex = lineCount++ % lineColors.length;
+      var line = new Line.default({
+        anid: tickValue != null ? "line_" + tickValue : null,
+        autoBatch: true,
+        shape: {
+          x1: p1[0],
+          y1: p1[1],
+          x2: p2[0],
+          y2: p2[1]
+        },
+        style: util.defaults({
+          stroke: lineColors[colorIndex]
+        }, lineStyle),
+        silent: true
+      });
+      graphic.subPixelOptimizeLine(line.shape, lineStyle.lineWidth);
+      axisGroup.add(line);
+    }
+  },
+  minorSplitLine: function(axisView, axisGroup, axisModel, gridModel) {
+    var axis = axisModel.axis;
+    var minorSplitLineModel = axisModel.getModel("minorSplitLine");
+    var lineStyleModel = minorSplitLineModel.getModel("lineStyle");
+    var gridRect = gridModel.coordinateSystem.getRect();
+    var isHorizontal = axis.isHorizontal();
+    var minorTicksCoords = axis.getMinorTicksCoords();
+    if (!minorTicksCoords.length) {
+      return;
+    }
+    var p1 = [];
+    var p2 = [];
+    var lineStyle = lineStyleModel.getLineStyle();
+    for (var i = 0; i < minorTicksCoords.length; i++) {
+      for (var k = 0; k < minorTicksCoords[i].length; k++) {
+        var tickCoord = axis.toGlobalCoord(minorTicksCoords[i][k].coord);
+        if (isHorizontal) {
+          p1[0] = tickCoord;
+          p1[1] = gridRect.y;
+          p2[0] = tickCoord;
+          p2[1] = gridRect.y + gridRect.height;
+        } else {
+          p1[0] = gridRect.x;
+          p1[1] = tickCoord;
+          p2[0] = gridRect.x + gridRect.width;
+          p2[1] = tickCoord;
+        }
+        var line = new Line.default({
+          anid: "minor_line_" + minorTicksCoords[i][k].tickValue,
+          autoBatch: true,
+          shape: {
+            x1: p1[0],
+            y1: p1[1],
+            x2: p2[0],
+            y2: p2[1]
+          },
+          style: lineStyle,
+          silent: true
+        });
+        graphic.subPixelOptimizeLine(line.shape, lineStyle.lineWidth);
+        axisGroup.add(line);
+      }
+    }
+  },
+  splitArea: function(axisView, axisGroup, axisModel, gridModel) {
+    axisSplitHelper.rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel);
+  }
+};
+var CartesianXAxisView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(CartesianXAxisView2, _super);
+    function CartesianXAxisView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = CartesianXAxisView2.type;
+      return _this;
+    }
+    CartesianXAxisView2.type = "xAxis";
+    return CartesianXAxisView2;
+  }(CartesianAxisView)
+);
+var CartesianYAxisView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(CartesianYAxisView2, _super);
+    function CartesianYAxisView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = CartesianXAxisView.type;
+      return _this;
+    }
+    CartesianYAxisView2.type = "yAxis";
+    return CartesianYAxisView2;
+  }(CartesianAxisView)
+);
+exports.CartesianXAxisView = CartesianXAxisView;
+exports.CartesianYAxisView = CartesianYAxisView;
+exports.default = CartesianAxisView;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axis/axisSplitHelper.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../../util/model.js");
+const Rect = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.js");
+var inner = model.makeInner();
+function rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel) {
+  var axis = axisModel.axis;
+  if (axis.scale.isBlank()) {
+    return;
+  }
+  var splitAreaModel = axisModel.getModel("splitArea");
+  var areaStyleModel = splitAreaModel.getModel("areaStyle");
+  var areaColors = areaStyleModel.get("color");
+  var gridRect = gridModel.coordinateSystem.getRect();
+  var ticksCoords = axis.getTicksCoords({
+    tickModel: splitAreaModel,
+    clamp: true
+  });
+  if (!ticksCoords.length) {
+    return;
+  }
+  var areaColorsLen = areaColors.length;
+  var lastSplitAreaColors = inner(axisView).splitAreaColors;
+  var newSplitAreaColors = util.createHashMap();
+  var colorIndex = 0;
+  if (lastSplitAreaColors) {
+    for (var i = 0; i < ticksCoords.length; i++) {
+      var cIndex = lastSplitAreaColors.get(ticksCoords[i].tickValue);
+      if (cIndex != null) {
+        colorIndex = (cIndex + (areaColorsLen - 1) * i) % areaColorsLen;
+        break;
+      }
+    }
+  }
+  var prev = axis.toGlobalCoord(ticksCoords[0].coord);
+  var areaStyle = areaStyleModel.getAreaStyle();
+  areaColors = util.isArray(areaColors) ? areaColors : [areaColors];
+  for (var i = 1; i < ticksCoords.length; i++) {
+    var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
+    var x = void 0;
+    var y = void 0;
+    var width = void 0;
+    var height = void 0;
+    if (axis.isHorizontal()) {
+      x = prev;
+      y = gridRect.y;
+      width = tickCoord - x;
+      height = gridRect.height;
+      prev = x + width;
+    } else {
+      x = gridRect.x;
+      y = prev;
+      width = gridRect.width;
+      height = tickCoord - y;
+      prev = y + height;
+    }
+    var tickValue = ticksCoords[i - 1].tickValue;
+    tickValue != null && newSplitAreaColors.set(tickValue, colorIndex);
+    axisGroup.add(new Rect.default({
+      anid: tickValue != null ? "area_" + tickValue : null,
+      shape: {
+        x,
+        y,
+        width,
+        height
+      },
+      style: util.defaults({
+        fill: areaColors[colorIndex]
+      }, areaStyle),
+      autoBatch: true,
+      silent: true
+    }));
+    colorIndex = (colorIndex + 1) % areaColorsLen;
+  }
+  inner(axisView).splitAreaColors = newSplitAreaColors;
+}
+function rectCoordAxisHandleRemove(axisView) {
+  inner(axisView).splitAreaColors = null;
+}
+exports.rectCoordAxisBuildSplitArea = rectCoordAxisBuildSplitArea;
+exports.rectCoordAxisHandleRemove = rectCoordAxisHandleRemove;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/AxisPointerModel.js

@@ -0,0 +1,74 @@
+"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 Component = require("../../model/Component.js");
+var AxisPointerModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(AxisPointerModel2, _super);
+    function AxisPointerModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = AxisPointerModel2.type;
+      return _this;
+    }
+    AxisPointerModel2.type = "axisPointer";
+    AxisPointerModel2.defaultOption = {
+      // 'auto' means that show when triggered by tooltip or handle.
+      show: "auto",
+      // zlevel: 0,
+      z: 50,
+      type: "line",
+      // axispointer triggered by tootip determine snap automatically,
+      // see `modelHelper`.
+      snap: false,
+      triggerTooltip: true,
+      triggerEmphasis: true,
+      value: null,
+      status: null,
+      link: [],
+      // Do not set 'auto' here, otherwise global animation: false
+      // will not effect at this axispointer.
+      animation: null,
+      animationDurationUpdate: 200,
+      lineStyle: {
+        color: "#B9BEC9",
+        width: 1,
+        type: "dashed"
+      },
+      shadowStyle: {
+        color: "rgba(210,219,238,0.2)"
+      },
+      label: {
+        show: true,
+        formatter: null,
+        precision: "auto",
+        margin: 3,
+        color: "#fff",
+        padding: [5, 7, 5, 7],
+        backgroundColor: "auto",
+        borderColor: null,
+        borderWidth: 0,
+        borderRadius: 3
+      },
+      handle: {
+        show: false,
+        // eslint-disable-next-line
+        icon: "M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z",
+        size: 45,
+        // handle margin is from symbol center to axis, which is stable when circular move.
+        margin: 50,
+        // color: '#1b8bbd'
+        // color: '#2f4554'
+        color: "#333",
+        shadowBlur: 3,
+        shadowColor: "#aaa",
+        shadowOffsetX: 0,
+        shadowOffsetY: 2,
+        // For mobile performance
+        throttle: 40
+      }
+    };
+    return AxisPointerModel2;
+  }(Component.default)
+);
+exports.default = AxisPointerModel;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/AxisPointerView.js

@@ -0,0 +1,39 @@
+"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 globalListener = require("./globalListener.js");
+const Component = require("../../view/Component.js");
+var AxisPointerView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(AxisPointerView2, _super);
+    function AxisPointerView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = AxisPointerView2.type;
+      return _this;
+    }
+    AxisPointerView2.prototype.render = function(globalAxisPointerModel, ecModel, api) {
+      var globalTooltipModel = ecModel.getComponent("tooltip");
+      var triggerOn = globalAxisPointerModel.get("triggerOn") || globalTooltipModel && globalTooltipModel.get("triggerOn") || "mousemove|click";
+      globalListener.register("axisPointer", api, function(currTrigger, e, dispatchAction) {
+        if (triggerOn !== "none" && (currTrigger === "leave" || triggerOn.indexOf(currTrigger) >= 0)) {
+          dispatchAction({
+            type: "updateAxisPointer",
+            currTrigger,
+            x: e && e.offsetX,
+            y: e && e.offsetY
+          });
+        }
+      });
+    };
+    AxisPointerView2.prototype.remove = function(ecModel, api) {
+      globalListener.unregister("axisPointer", api);
+    };
+    AxisPointerView2.prototype.dispose = function(ecModel, api) {
+      globalListener.unregister("axisPointer", api);
+    };
+    AxisPointerView2.type = "axisPointer";
+    return AxisPointerView2;
+  }(Component.default)
+);
+exports.default = AxisPointerView;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/BaseAxisPointer.js

@@ -0,0 +1,285 @@
+"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 graphic = require("../../util/graphic.js");
+const modelHelper = require("./modelHelper.js");
+const event = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/event.js");
+const throttle = require("../../util/throttle.js");
+const model = require("../../util/model.js");
+const Group = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+const Text = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.js");
+const basicTransition = require("../../animation/basicTransition.js");
+var inner = model.makeInner();
+var clone = util.clone;
+var bind = util.bind;
+var BaseAxisPointer = (
+  /** @class */
+  function() {
+    function BaseAxisPointer2() {
+      this._dragging = false;
+      this.animationThreshold = 15;
+    }
+    BaseAxisPointer2.prototype.render = function(axisModel, axisPointerModel, api, forceRender) {
+      var value = axisPointerModel.get("value");
+      var status = axisPointerModel.get("status");
+      this._axisModel = axisModel;
+      this._axisPointerModel = axisPointerModel;
+      this._api = api;
+      if (!forceRender && this._lastValue === value && this._lastStatus === status) {
+        return;
+      }
+      this._lastValue = value;
+      this._lastStatus = status;
+      var group = this._group;
+      var handle = this._handle;
+      if (!status || status === "hide") {
+        group && group.hide();
+        handle && handle.hide();
+        return;
+      }
+      group && group.show();
+      handle && handle.show();
+      var elOption = {};
+      this.makeElOption(elOption, value, axisModel, axisPointerModel, api);
+      var graphicKey = elOption.graphicKey;
+      if (graphicKey !== this._lastGraphicKey) {
+        this.clear(api);
+      }
+      this._lastGraphicKey = graphicKey;
+      var moveAnimation = this._moveAnimation = this.determineAnimation(axisModel, axisPointerModel);
+      if (!group) {
+        group = this._group = new Group.default();
+        this.createPointerEl(group, elOption, axisModel, axisPointerModel);
+        this.createLabelEl(group, elOption, axisModel, axisPointerModel);
+        api.getZr().add(group);
+      } else {
+        var doUpdateProps = util.curry(updateProps, axisPointerModel, moveAnimation);
+        this.updatePointerEl(group, elOption, doUpdateProps);
+        this.updateLabelEl(group, elOption, doUpdateProps, axisPointerModel);
+      }
+      updateMandatoryProps(group, axisPointerModel, true);
+      this._renderHandle(value);
+    };
+    BaseAxisPointer2.prototype.remove = function(api) {
+      this.clear(api);
+    };
+    BaseAxisPointer2.prototype.dispose = function(api) {
+      this.clear(api);
+    };
+    BaseAxisPointer2.prototype.determineAnimation = function(axisModel, axisPointerModel) {
+      var animation = axisPointerModel.get("animation");
+      var axis = axisModel.axis;
+      var isCategoryAxis = axis.type === "category";
+      var useSnap = axisPointerModel.get("snap");
+      if (!useSnap && !isCategoryAxis) {
+        return false;
+      }
+      if (animation === "auto" || animation == null) {
+        var animationThreshold = this.animationThreshold;
+        if (isCategoryAxis && axis.getBandWidth() > animationThreshold) {
+          return true;
+        }
+        if (useSnap) {
+          var seriesDataCount = modelHelper.getAxisInfo(axisModel).seriesDataCount;
+          var axisExtent = axis.getExtent();
+          return Math.abs(axisExtent[0] - axisExtent[1]) / seriesDataCount > animationThreshold;
+        }
+        return false;
+      }
+      return animation === true;
+    };
+    BaseAxisPointer2.prototype.makeElOption = function(elOption, value, axisModel, axisPointerModel, api) {
+    };
+    BaseAxisPointer2.prototype.createPointerEl = function(group, elOption, axisModel, axisPointerModel) {
+      var pointerOption = elOption.pointer;
+      if (pointerOption) {
+        var pointerEl = inner(group).pointerEl = new graphic[pointerOption.type](clone(elOption.pointer));
+        group.add(pointerEl);
+      }
+    };
+    BaseAxisPointer2.prototype.createLabelEl = function(group, elOption, axisModel, axisPointerModel) {
+      if (elOption.label) {
+        var labelEl = inner(group).labelEl = new Text.default(clone(elOption.label));
+        group.add(labelEl);
+        updateLabelShowHide(labelEl, axisPointerModel);
+      }
+    };
+    BaseAxisPointer2.prototype.updatePointerEl = function(group, elOption, updateProps2) {
+      var pointerEl = inner(group).pointerEl;
+      if (pointerEl && elOption.pointer) {
+        pointerEl.setStyle(elOption.pointer.style);
+        updateProps2(pointerEl, {
+          shape: elOption.pointer.shape
+        });
+      }
+    };
+    BaseAxisPointer2.prototype.updateLabelEl = function(group, elOption, updateProps2, axisPointerModel) {
+      var labelEl = inner(group).labelEl;
+      if (labelEl) {
+        labelEl.setStyle(elOption.label.style);
+        updateProps2(labelEl, {
+          // Consider text length change in vertical axis, animation should
+          // be used on shape, otherwise the effect will be weird.
+          // TODOTODO
+          // shape: elOption.label.shape,
+          x: elOption.label.x,
+          y: elOption.label.y
+        });
+        updateLabelShowHide(labelEl, axisPointerModel);
+      }
+    };
+    BaseAxisPointer2.prototype._renderHandle = function(value) {
+      if (this._dragging || !this.updateHandleTransform) {
+        return;
+      }
+      var axisPointerModel = this._axisPointerModel;
+      var zr = this._api.getZr();
+      var handle = this._handle;
+      var handleModel = axisPointerModel.getModel("handle");
+      var status = axisPointerModel.get("status");
+      if (!handleModel.get("show") || !status || status === "hide") {
+        handle && zr.remove(handle);
+        this._handle = null;
+        return;
+      }
+      var isInit;
+      if (!this._handle) {
+        isInit = true;
+        handle = this._handle = graphic.createIcon(handleModel.get("icon"), {
+          cursor: "move",
+          draggable: true,
+          onmousemove: function(e) {
+            event.stop(e.event);
+          },
+          onmousedown: bind(this._onHandleDragMove, this, 0, 0),
+          drift: bind(this._onHandleDragMove, this),
+          ondragend: bind(this._onHandleDragEnd, this)
+        });
+        zr.add(handle);
+      }
+      updateMandatoryProps(handle, axisPointerModel, false);
+      handle.setStyle(handleModel.getItemStyle(null, ["color", "borderColor", "borderWidth", "opacity", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]));
+      var handleSize = handleModel.get("size");
+      if (!util.isArray(handleSize)) {
+        handleSize = [handleSize, handleSize];
+      }
+      handle.scaleX = handleSize[0] / 2;
+      handle.scaleY = handleSize[1] / 2;
+      throttle.createOrUpdate(this, "_doDispatchAxisPointer", handleModel.get("throttle") || 0, "fixRate");
+      this._moveHandleToValue(value, isInit);
+    };
+    BaseAxisPointer2.prototype._moveHandleToValue = function(value, isInit) {
+      updateProps(this._axisPointerModel, !isInit && this._moveAnimation, this._handle, getHandleTransProps(this.getHandleTransform(value, this._axisModel, this._axisPointerModel)));
+    };
+    BaseAxisPointer2.prototype._onHandleDragMove = function(dx, dy) {
+      var handle = this._handle;
+      if (!handle) {
+        return;
+      }
+      this._dragging = true;
+      var trans = this.updateHandleTransform(getHandleTransProps(handle), [dx, dy], this._axisModel, this._axisPointerModel);
+      this._payloadInfo = trans;
+      handle.stopAnimation();
+      handle.attr(getHandleTransProps(trans));
+      inner(handle).lastProp = null;
+      this._doDispatchAxisPointer();
+    };
+    BaseAxisPointer2.prototype._doDispatchAxisPointer = function() {
+      var handle = this._handle;
+      if (!handle) {
+        return;
+      }
+      var payloadInfo = this._payloadInfo;
+      var axisModel = this._axisModel;
+      this._api.dispatchAction({
+        type: "updateAxisPointer",
+        x: payloadInfo.cursorPoint[0],
+        y: payloadInfo.cursorPoint[1],
+        tooltipOption: payloadInfo.tooltipOption,
+        axesInfo: [{
+          axisDim: axisModel.axis.dim,
+          axisIndex: axisModel.componentIndex
+        }]
+      });
+    };
+    BaseAxisPointer2.prototype._onHandleDragEnd = function() {
+      this._dragging = false;
+      var handle = this._handle;
+      if (!handle) {
+        return;
+      }
+      var value = this._axisPointerModel.get("value");
+      this._moveHandleToValue(value);
+      this._api.dispatchAction({
+        type: "hideTip"
+      });
+    };
+    BaseAxisPointer2.prototype.clear = function(api) {
+      this._lastValue = null;
+      this._lastStatus = null;
+      var zr = api.getZr();
+      var group = this._group;
+      var handle = this._handle;
+      if (zr && group) {
+        this._lastGraphicKey = null;
+        group && zr.remove(group);
+        handle && zr.remove(handle);
+        this._group = null;
+        this._handle = null;
+        this._payloadInfo = null;
+      }
+      throttle.clear(this, "_doDispatchAxisPointer");
+    };
+    BaseAxisPointer2.prototype.doClear = function() {
+    };
+    BaseAxisPointer2.prototype.buildLabel = function(xy, wh, xDimIndex) {
+      xDimIndex = xDimIndex || 0;
+      return {
+        x: xy[xDimIndex],
+        y: xy[1 - xDimIndex],
+        width: wh[xDimIndex],
+        height: wh[1 - xDimIndex]
+      };
+    };
+    return BaseAxisPointer2;
+  }()
+);
+function updateProps(animationModel, moveAnimation, el, props) {
+  if (!propsEqual(inner(el).lastProp, props)) {
+    inner(el).lastProp = props;
+    moveAnimation ? basicTransition.updateProps(el, props, animationModel) : (el.stopAnimation(), el.attr(props));
+  }
+}
+function propsEqual(lastProps, newProps) {
+  if (util.isObject(lastProps) && util.isObject(newProps)) {
+    var equals_1 = true;
+    util.each(newProps, function(item, key) {
+      equals_1 = equals_1 && propsEqual(lastProps[key], item);
+    });
+    return !!equals_1;
+  } else {
+    return lastProps === newProps;
+  }
+}
+function updateLabelShowHide(labelEl, axisPointerModel) {
+  labelEl[axisPointerModel.get(["label", "show"]) ? "show" : "hide"]();
+}
+function getHandleTransProps(trans) {
+  return {
+    x: trans.x || 0,
+    y: trans.y || 0,
+    rotation: trans.rotation || 0
+  };
+}
+function updateMandatoryProps(group, axisPointerModel, silent) {
+  var z = axisPointerModel.get("z");
+  var zlevel = axisPointerModel.get("zlevel");
+  group && group.traverse(function(el) {
+    if (el.type !== "group") {
+      z != null && (el.z = z);
+      zlevel != null && (el.zlevel = zlevel);
+      el.silent = silent;
+    }
+  });
+}
+exports.default = BaseAxisPointer;