office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/component/axisPointer/CartesianAxisPointer.js

@@ -0,0 +1,111 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var BaseAxisPointer = require('./BaseAxisPointer.js');
+var viewHelper = require('./viewHelper.js');
+var cartesianAxisHelper = require('../../coord/cartesian/cartesianAxisHelper.js');
+
+var CartesianAxisPointer = /** @class */function (_super) {
+  tslib.__extends(CartesianAxisPointer, _super);
+  function CartesianAxisPointer() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  /**
+   * @override
+   */
+  CartesianAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+    var axis = axisModel.axis;
+    var grid = axis.grid;
+    var axisPointerType = axisPointerModel.get('type');
+    var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+    var pixelValue = axis.toGlobalCoord(axis.dataToCoord(value, true));
+    if (axisPointerType && axisPointerType !== 'none') {
+      var elStyle = viewHelper.buildElStyle(axisPointerModel);
+      var pointerOption = pointerShapeBuilder[axisPointerType](axis, pixelValue, otherExtent);
+      pointerOption.style = elStyle;
+      elOption.graphicKey = pointerOption.type;
+      elOption.pointer = pointerOption;
+    }
+    var layoutInfo = cartesianAxisHelper.layout(grid.model, axisModel);
+    viewHelper.buildCartesianSingleLabelElOption(
+    // @ts-ignore
+    value, elOption, layoutInfo, axisModel, axisPointerModel, api);
+  };
+  /**
+   * @override
+   */
+  CartesianAxisPointer.prototype.getHandleTransform = function (value, axisModel, axisPointerModel) {
+    var layoutInfo = cartesianAxisHelper.layout(axisModel.axis.grid.model, axisModel, {
+      labelInside: false
+    });
+    // @ts-ignore
+    layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']);
+    var pos = viewHelper.getTransformedPosition(axisModel.axis, value, layoutInfo);
+    return {
+      x: pos[0],
+      y: pos[1],
+      rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
+    };
+  };
+  /**
+   * @override
+   */
+  CartesianAxisPointer.prototype.updateHandleTransform = function (transform, delta, axisModel, axisPointerModel) {
+    var axis = axisModel.axis;
+    var grid = axis.grid;
+    var axisExtent = axis.getGlobalExtent(true);
+    var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+    var dimIndex = axis.dim === 'x' ? 0 : 1;
+    var currPosition = [transform.x, transform.y];
+    currPosition[dimIndex] += delta[dimIndex];
+    currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]);
+    currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]);
+    var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
+    var cursorPoint = [cursorOtherValue, cursorOtherValue];
+    cursorPoint[dimIndex] = currPosition[dimIndex];
+    // Make tooltip do not overlap axisPointer and in the middle of the grid.
+    var tooltipOptions = [{
+      verticalAlign: 'middle'
+    }, {
+      align: 'center'
+    }];
+    return {
+      x: currPosition[0],
+      y: currPosition[1],
+      rotation: transform.rotation,
+      cursorPoint: cursorPoint,
+      tooltipOption: tooltipOptions[dimIndex]
+    };
+  };
+  return CartesianAxisPointer;
+}(BaseAxisPointer["default"]);
+function getCartesian(grid, axis) {
+  var opt = {};
+  opt[axis.dim + 'AxisIndex'] = axis.index;
+  return grid.getCartesian(opt);
+}
+var pointerShapeBuilder = {
+  line: function (axis, pixelValue, otherExtent) {
+    var targetShape = viewHelper.makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getAxisDimIndex(axis));
+    return {
+      type: 'Line',
+      subPixelOptimize: true,
+      shape: targetShape
+    };
+  },
+  shadow: function (axis, pixelValue, otherExtent) {
+    var bandWidth = Math.max(1, axis.getBandWidth());
+    var span = otherExtent[1] - otherExtent[0];
+    return {
+      type: 'Rect',
+      shape: viewHelper.makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getAxisDimIndex(axis))
+    };
+  }
+};
+function getAxisDimIndex(axis) {
+  return axis.dim === 'x' ? 0 : 1;
+}
+
+exports["default"] = CartesianAxisPointer;

package/lib/node_modules/echarts/lib/component/axisPointer/PolarAxisPointer.js

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var BaseAxisPointer = require('./BaseAxisPointer.js');
+var graphic = require('../../util/graphic.js');
+var viewHelper = require('./viewHelper.js');
+var matrix = require('../../../../zrender/lib/core/matrix.js');
+var AxisBuilder = require('../axis/AxisBuilder.js');
+
+var PolarAxisPointer = /** @class */function (_super) {
+  tslib.__extends(PolarAxisPointer, _super);
+  function PolarAxisPointer() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  /**
+   * @override
+   */
+  PolarAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+    var axis = axisModel.axis;
+    if (axis.dim === 'angle') {
+      this.animationThreshold = Math.PI / 18;
+    }
+    var polar = axis.polar;
+    var otherAxis = polar.getOtherAxis(axis);
+    var otherExtent = otherAxis.getExtent();
+    var coordValue = axis.dataToCoord(value);
+    var axisPointerType = axisPointerModel.get('type');
+    if (axisPointerType && axisPointerType !== 'none') {
+      var elStyle = viewHelper.buildElStyle(axisPointerModel);
+      var pointerOption = pointerShapeBuilder[axisPointerType](axis, polar, coordValue, otherExtent);
+      pointerOption.style = elStyle;
+      elOption.graphicKey = pointerOption.type;
+      elOption.pointer = pointerOption;
+    }
+    var labelMargin = axisPointerModel.get(['label', 'margin']);
+    var labelPos = getLabelPosition(value, axisModel, axisPointerModel, polar, labelMargin);
+    viewHelper.buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos);
+  };
+  return PolarAxisPointer;
+}(BaseAxisPointer["default"]);
+function getLabelPosition(value, axisModel, axisPointerModel, polar, labelMargin) {
+  var axis = axisModel.axis;
+  var coord = axis.dataToCoord(value);
+  var axisAngle = polar.getAngleAxis().getExtent()[0];
+  axisAngle = axisAngle / 180 * Math.PI;
+  var radiusExtent = polar.getRadiusAxis().getExtent();
+  var position;
+  var align;
+  var verticalAlign;
+  if (axis.dim === 'radius') {
+    var transform = matrix.create();
+    matrix.rotate(transform, transform, axisAngle);
+    matrix.translate(transform, transform, [polar.cx, polar.cy]);
+    position = graphic.applyTransform([coord, -labelMargin], transform);
+    var labelRotation = axisModel.getModel('axisLabel').get('rotate') || 0;
+    // @ts-ignore
+    var labelLayout = AxisBuilder["default"].innerTextLayout(axisAngle, labelRotation * Math.PI / 180, -1);
+    align = labelLayout.textAlign;
+    verticalAlign = labelLayout.textVerticalAlign;
+  } else {
+    // angle axis
+    var r = radiusExtent[1];
+    position = polar.coordToPoint([r + labelMargin, coord]);
+    var cx = polar.cx;
+    var cy = polar.cy;
+    align = Math.abs(position[0] - cx) / r < 0.3 ? 'center' : position[0] > cx ? 'left' : 'right';
+    verticalAlign = Math.abs(position[1] - cy) / r < 0.3 ? 'middle' : position[1] > cy ? 'top' : 'bottom';
+  }
+  return {
+    position: position,
+    align: align,
+    verticalAlign: verticalAlign
+  };
+}
+var pointerShapeBuilder = {
+  line: function (axis, polar, coordValue, otherExtent) {
+    return axis.dim === 'angle' ? {
+      type: 'Line',
+      shape: viewHelper.makeLineShape(polar.coordToPoint([otherExtent[0], coordValue]), polar.coordToPoint([otherExtent[1], coordValue]))
+    } : {
+      type: 'Circle',
+      shape: {
+        cx: polar.cx,
+        cy: polar.cy,
+        r: coordValue
+      }
+    };
+  },
+  shadow: function (axis, polar, coordValue, otherExtent) {
+    var bandWidth = Math.max(1, axis.getBandWidth());
+    var radian = Math.PI / 180;
+    return axis.dim === 'angle' ? {
+      type: 'Sector',
+      shape: viewHelper.makeSectorShape(polar.cx, polar.cy, otherExtent[0], otherExtent[1],
+      // In ECharts y is negative if angle is positive
+      (-coordValue - bandWidth / 2) * radian, (-coordValue + bandWidth / 2) * radian)
+    } : {
+      type: 'Sector',
+      shape: viewHelper.makeSectorShape(polar.cx, polar.cy, coordValue - bandWidth / 2, coordValue + bandWidth / 2, 0, Math.PI * 2)
+    };
+  }
+};
+
+exports["default"] = PolarAxisPointer;

package/lib/node_modules/echarts/lib/component/axisPointer/SingleAxisPointer.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var BaseAxisPointer = require('./BaseAxisPointer.js');
+var viewHelper = require('./viewHelper.js');
+var singleAxisHelper = require('../../coord/single/singleAxisHelper.js');
+
+var XY = ['x', 'y'];
+var WH = ['width', 'height'];
+var SingleAxisPointer = /** @class */function (_super) {
+  tslib.__extends(SingleAxisPointer, _super);
+  function SingleAxisPointer() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  /**
+   * @override
+   */
+  SingleAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) {
+    var axis = axisModel.axis;
+    var coordSys = axis.coordinateSystem;
+    var otherExtent = getGlobalExtent(coordSys, 1 - getPointDimIndex(axis));
+    var pixelValue = coordSys.dataToPoint(value)[0];
+    var axisPointerType = axisPointerModel.get('type');
+    if (axisPointerType && axisPointerType !== 'none') {
+      var elStyle = viewHelper.buildElStyle(axisPointerModel);
+      var pointerOption = pointerShapeBuilder[axisPointerType](axis, pixelValue, otherExtent);
+      pointerOption.style = elStyle;
+      elOption.graphicKey = pointerOption.type;
+      elOption.pointer = pointerOption;
+    }
+    var layoutInfo = singleAxisHelper.layout(axisModel);
+    viewHelper.buildCartesianSingleLabelElOption(
+    // @ts-ignore
+    value, elOption, layoutInfo, axisModel, axisPointerModel, api);
+  };
+  /**
+   * @override
+   */
+  SingleAxisPointer.prototype.getHandleTransform = function (value, axisModel, axisPointerModel) {
+    var layoutInfo = singleAxisHelper.layout(axisModel, {
+      labelInside: false
+    });
+    // @ts-ignore
+    layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']);
+    var position = viewHelper.getTransformedPosition(axisModel.axis, value, layoutInfo);
+    return {
+      x: position[0],
+      y: position[1],
+      rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
+    };
+  };
+  /**
+   * @override
+   */
+  SingleAxisPointer.prototype.updateHandleTransform = function (transform, delta, axisModel, axisPointerModel) {
+    var axis = axisModel.axis;
+    var coordSys = axis.coordinateSystem;
+    var dimIndex = getPointDimIndex(axis);
+    var axisExtent = getGlobalExtent(coordSys, dimIndex);
+    var currPosition = [transform.x, transform.y];
+    currPosition[dimIndex] += delta[dimIndex];
+    currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]);
+    currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]);
+    var otherExtent = getGlobalExtent(coordSys, 1 - dimIndex);
+    var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
+    var cursorPoint = [cursorOtherValue, cursorOtherValue];
+    cursorPoint[dimIndex] = currPosition[dimIndex];
+    return {
+      x: currPosition[0],
+      y: currPosition[1],
+      rotation: transform.rotation,
+      cursorPoint: cursorPoint,
+      tooltipOption: {
+        verticalAlign: 'middle'
+      }
+    };
+  };
+  return SingleAxisPointer;
+}(BaseAxisPointer["default"]);
+var pointerShapeBuilder = {
+  line: function (axis, pixelValue, otherExtent) {
+    var targetShape = viewHelper.makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getPointDimIndex(axis));
+    return {
+      type: 'Line',
+      subPixelOptimize: true,
+      shape: targetShape
+    };
+  },
+  shadow: function (axis, pixelValue, otherExtent) {
+    var bandWidth = axis.getBandWidth();
+    var span = otherExtent[1] - otherExtent[0];
+    return {
+      type: 'Rect',
+      shape: viewHelper.makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getPointDimIndex(axis))
+    };
+  }
+};
+function getPointDimIndex(axis) {
+  return axis.isHorizontal() ? 0 : 1;
+}
+function getGlobalExtent(coordSys, dimIndex) {
+  var rect = coordSys.getRect();
+  return [rect[XY[dimIndex]], rect[XY[dimIndex]] + rect[WH[dimIndex]]];
+}
+
+exports["default"] = SingleAxisPointer;

package/lib/node_modules/echarts/lib/component/axisPointer/axisTrigger.js

@@ -0,0 +1,342 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var model = require('../../util/model.js');
+var modelHelper = require('./modelHelper.js');
+var findPointFromSeries = require('./findPointFromSeries.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+var inner = model.makeInner();
+/**
+ * Basic logic: check all axis, if they do not demand show/highlight,
+ * then hide/downplay them.
+ *
+ * @return content of event obj for echarts.connect.
+ */
+function axisTrigger(payload, ecModel, api) {
+  var currTrigger = payload.currTrigger;
+  var point = [payload.x, payload.y];
+  var finder = payload;
+  var dispatchAction = payload.dispatchAction || util.bind(api.dispatchAction, api);
+  var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo;
+  // Pending
+  // See #6121. But we are not able to reproduce it yet.
+  if (!coordSysAxesInfo) {
+    return;
+  }
+  if (illegalPoint(point)) {
+    // Used in the default behavior of `connection`: use the sample seriesIndex
+    // and dataIndex. And also used in the tooltipView trigger.
+    point = findPointFromSeries["default"]({
+      seriesIndex: finder.seriesIndex,
+      // Do not use dataIndexInside from other ec instance.
+      // FIXME: auto detect it?
+      dataIndex: finder.dataIndex
+    }, ecModel).point;
+  }
+  var isIllegalPoint = illegalPoint(point);
+  // Axis and value can be specified when calling dispatchAction({type: 'updateAxisPointer'}).
+  // Notice: In this case, it is difficult to get the `point` (which is necessary to show
+  // tooltip, so if point is not given, we just use the point found by sample seriesIndex
+  // and dataIndex.
+  var inputAxesInfo = finder.axesInfo;
+  var axesInfo = coordSysAxesInfo.axesInfo;
+  var shouldHide = currTrigger === 'leave' || illegalPoint(point);
+  var outputPayload = {};
+  var showValueMap = {};
+  var dataByCoordSys = {
+    list: [],
+    map: {}
+  };
+  var updaters = {
+    showPointer: util.curry(showPointer, showValueMap),
+    showTooltip: util.curry(showTooltip, dataByCoordSys)
+  };
+  // Process for triggered axes.
+  util.each(coordSysAxesInfo.coordSysMap, function (coordSys, coordSysKey) {
+    // If a point given, it must be contained by the coordinate system.
+    var coordSysContainsPoint = isIllegalPoint || coordSys.containPoint(point);
+    util.each(coordSysAxesInfo.coordSysAxesInfo[coordSysKey], function (axisInfo, key) {
+      var axis = axisInfo.axis;
+      var inputAxisInfo = findInputAxisInfo(inputAxesInfo, axisInfo);
+      // If no inputAxesInfo, no axis is restricted.
+      if (!shouldHide && coordSysContainsPoint && (!inputAxesInfo || inputAxisInfo)) {
+        var val = inputAxisInfo && inputAxisInfo.value;
+        if (val == null && !isIllegalPoint) {
+          val = axis.pointToData(point);
+        }
+        val != null && processOnAxis(axisInfo, val, updaters, false, outputPayload);
+      }
+    });
+  });
+  // Process for linked axes.
+  var linkTriggers = {};
+  util.each(axesInfo, function (tarAxisInfo, tarKey) {
+    var linkGroup = tarAxisInfo.linkGroup;
+    // If axis has been triggered in the previous stage, it should not be triggered by link.
+    if (linkGroup && !showValueMap[tarKey]) {
+      util.each(linkGroup.axesInfo, function (srcAxisInfo, srcKey) {
+        var srcValItem = showValueMap[srcKey];
+        // If srcValItem exist, source axis is triggered, so link to target axis.
+        if (srcAxisInfo !== tarAxisInfo && srcValItem) {
+          var val = srcValItem.value;
+          linkGroup.mapper && (val = tarAxisInfo.axis.scale.parse(linkGroup.mapper(val, makeMapperParam(srcAxisInfo), makeMapperParam(tarAxisInfo))));
+          linkTriggers[tarAxisInfo.key] = val;
+        }
+      });
+    }
+  });
+  util.each(linkTriggers, function (val, tarKey) {
+    processOnAxis(axesInfo[tarKey], val, updaters, true, outputPayload);
+  });
+  updateModelActually(showValueMap, axesInfo, outputPayload);
+  dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction);
+  dispatchHighDownActually(axesInfo, dispatchAction, api);
+  return outputPayload;
+}
+function processOnAxis(axisInfo, newValue, updaters, noSnap, outputFinder) {
+  var axis = axisInfo.axis;
+  if (axis.scale.isBlank() || !axis.containData(newValue)) {
+    return;
+  }
+  if (!axisInfo.involveSeries) {
+    updaters.showPointer(axisInfo, newValue);
+    return;
+  }
+  // Heavy calculation. So put it after axis.containData checking.
+  var payloadInfo = buildPayloadsBySeries(newValue, axisInfo);
+  var payloadBatch = payloadInfo.payloadBatch;
+  var snapToValue = payloadInfo.snapToValue;
+  // Fill content of event obj for echarts.connect.
+  // By default use the first involved series data as a sample to connect.
+  if (payloadBatch[0] && outputFinder.seriesIndex == null) {
+    util.extend(outputFinder, payloadBatch[0]);
+  }
+  // If no linkSource input, this process is for collecting link
+  // target, where snap should not be accepted.
+  if (!noSnap && axisInfo.snap) {
+    if (axis.containData(snapToValue) && snapToValue != null) {
+      newValue = snapToValue;
+    }
+  }
+  updaters.showPointer(axisInfo, newValue, payloadBatch);
+  // Tooltip should always be snapToValue, otherwise there will be
+  // incorrect "axis value ~ series value" mapping displayed in tooltip.
+  updaters.showTooltip(axisInfo, payloadInfo, snapToValue);
+}
+function buildPayloadsBySeries(value, axisInfo) {
+  var axis = axisInfo.axis;
+  var dim = axis.dim;
+  var snapToValue = value;
+  var payloadBatch = [];
+  var minDist = Number.MAX_VALUE;
+  var minDiff = -1;
+  util.each(axisInfo.seriesModels, function (series, idx) {
+    var dataDim = series.getData().mapDimensionsAll(dim);
+    var seriesNestestValue;
+    var dataIndices;
+    if (series.getAxisTooltipData) {
+      var result = series.getAxisTooltipData(dataDim, value, axis);
+      dataIndices = result.dataIndices;
+      seriesNestestValue = result.nestestValue;
+    } else {
+      dataIndices = series.getData().indicesOfNearest(dataDim[0], value,
+      // Add a threshold to avoid find the wrong dataIndex
+      // when data length is not same.
+      // false,
+      axis.type === 'category' ? 0.5 : null);
+      if (!dataIndices.length) {
+        return;
+      }
+      seriesNestestValue = series.getData().get(dataDim[0], dataIndices[0]);
+    }
+    if (seriesNestestValue == null || !isFinite(seriesNestestValue)) {
+      return;
+    }
+    var diff = value - seriesNestestValue;
+    var dist = Math.abs(diff);
+    // Consider category case
+    if (dist <= minDist) {
+      if (dist < minDist || diff >= 0 && minDiff < 0) {
+        minDist = dist;
+        minDiff = diff;
+        snapToValue = seriesNestestValue;
+        payloadBatch.length = 0;
+      }
+      util.each(dataIndices, function (dataIndex) {
+        payloadBatch.push({
+          seriesIndex: series.seriesIndex,
+          dataIndexInside: dataIndex,
+          dataIndex: series.getData().getRawIndex(dataIndex)
+        });
+      });
+    }
+  });
+  return {
+    payloadBatch: payloadBatch,
+    snapToValue: snapToValue
+  };
+}
+function showPointer(showValueMap, axisInfo, value, payloadBatch) {
+  showValueMap[axisInfo.key] = {
+    value: value,
+    payloadBatch: payloadBatch
+  };
+}
+function showTooltip(dataByCoordSys, axisInfo, payloadInfo, value) {
+  var payloadBatch = payloadInfo.payloadBatch;
+  var axis = axisInfo.axis;
+  var axisModel = axis.model;
+  var axisPointerModel = axisInfo.axisPointerModel;
+  // If no data, do not create anything in dataByCoordSys,
+  // whose length will be used to judge whether dispatch action.
+  if (!axisInfo.triggerTooltip || !payloadBatch.length) {
+    return;
+  }
+  var coordSysModel = axisInfo.coordSys.model;
+  var coordSysKey = modelHelper.makeKey(coordSysModel);
+  var coordSysItem = dataByCoordSys.map[coordSysKey];
+  if (!coordSysItem) {
+    coordSysItem = dataByCoordSys.map[coordSysKey] = {
+      coordSysId: coordSysModel.id,
+      coordSysIndex: coordSysModel.componentIndex,
+      coordSysType: coordSysModel.type,
+      coordSysMainType: coordSysModel.mainType,
+      dataByAxis: []
+    };
+    dataByCoordSys.list.push(coordSysItem);
+  }
+  coordSysItem.dataByAxis.push({
+    axisDim: axis.dim,
+    axisIndex: axisModel.componentIndex,
+    axisType: axisModel.type,
+    axisId: axisModel.id,
+    value: value,
+    // Caustion: viewHelper.getValueLabel is actually on "view stage", which
+    // depends that all models have been updated. So it should not be performed
+    // here. Considering axisPointerModel used here is volatile, which is hard
+    // to be retrieve in TooltipView, we prepare parameters here.
+    valueLabelOpt: {
+      precision: axisPointerModel.get(['label', 'precision']),
+      formatter: axisPointerModel.get(['label', 'formatter'])
+    },
+    seriesDataIndices: payloadBatch.slice()
+  });
+}
+function updateModelActually(showValueMap, axesInfo, outputPayload) {
+  var outputAxesInfo = outputPayload.axesInfo = [];
+  // Basic logic: If no 'show' required, 'hide' this axisPointer.
+  util.each(axesInfo, function (axisInfo, key) {
+    var option = axisInfo.axisPointerModel.option;
+    var valItem = showValueMap[key];
+    if (valItem) {
+      !axisInfo.useHandle && (option.status = 'show');
+      option.value = valItem.value;
+      // For label formatter param and highlight.
+      option.seriesDataIndices = (valItem.payloadBatch || []).slice();
+    }
+    // When always show (e.g., handle used), remain
+    // original value and status.
+    else {
+      // If hide, value still need to be set, consider
+      // click legend to toggle axis blank.
+      !axisInfo.useHandle && (option.status = 'hide');
+    }
+    // If status is 'hide', should be no info in payload.
+    option.status === 'show' && outputAxesInfo.push({
+      axisDim: axisInfo.axis.dim,
+      axisIndex: axisInfo.axis.model.componentIndex,
+      value: option.value
+    });
+  });
+}
+function dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction) {
+  // Basic logic: If no showTip required, hideTip will be dispatched.
+  if (illegalPoint(point) || !dataByCoordSys.list.length) {
+    dispatchAction({
+      type: 'hideTip'
+    });
+    return;
+  }
+  // In most case only one axis (or event one series is used). It is
+  // convenient to fetch payload.seriesIndex and payload.dataIndex
+  // directly. So put the first seriesIndex and dataIndex of the first
+  // axis on the payload.
+  var sampleItem = ((dataByCoordSys.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
+  dispatchAction({
+    type: 'showTip',
+    escapeConnect: true,
+    x: point[0],
+    y: point[1],
+    tooltipOption: payload.tooltipOption,
+    position: payload.position,
+    dataIndexInside: sampleItem.dataIndexInside,
+    dataIndex: sampleItem.dataIndex,
+    seriesIndex: sampleItem.seriesIndex,
+    dataByCoordSys: dataByCoordSys.list
+  });
+}
+function dispatchHighDownActually(axesInfo, dispatchAction, api) {
+  // FIXME
+  // highlight status modification should be a stage of main process?
+  // (Consider confilct (e.g., legend and axisPointer) and setOption)
+  var zr = api.getZr();
+  var highDownKey = 'axisPointerLastHighlights';
+  var lastHighlights = inner(zr)[highDownKey] || {};
+  var newHighlights = inner(zr)[highDownKey] = {};
+  // Update highlight/downplay status according to axisPointer model.
+  // Build hash map and remove duplicate incidentally.
+  util.each(axesInfo, function (axisInfo, key) {
+    var option = axisInfo.axisPointerModel.option;
+    option.status === 'show' && axisInfo.triggerEmphasis && util.each(option.seriesDataIndices, function (batchItem) {
+      var key = batchItem.seriesIndex + ' | ' + batchItem.dataIndex;
+      newHighlights[key] = batchItem;
+    });
+  });
+  // Diff.
+  var toHighlight = [];
+  var toDownplay = [];
+  util.each(lastHighlights, function (batchItem, key) {
+    !newHighlights[key] && toDownplay.push(batchItem);
+  });
+  util.each(newHighlights, function (batchItem, key) {
+    !lastHighlights[key] && toHighlight.push(batchItem);
+  });
+  toDownplay.length && api.dispatchAction({
+    type: 'downplay',
+    escapeConnect: true,
+    // Not blur others when highlight in axisPointer.
+    notBlur: true,
+    batch: toDownplay
+  });
+  toHighlight.length && api.dispatchAction({
+    type: 'highlight',
+    escapeConnect: true,
+    // Not blur others when highlight in axisPointer.
+    notBlur: true,
+    batch: toHighlight
+  });
+}
+function findInputAxisInfo(inputAxesInfo, axisInfo) {
+  for (var i = 0; i < (inputAxesInfo || []).length; i++) {
+    var inputAxisInfo = inputAxesInfo[i];
+    if (axisInfo.axis.dim === inputAxisInfo.axisDim && axisInfo.axis.model.componentIndex === inputAxisInfo.axisIndex) {
+      return inputAxisInfo;
+    }
+  }
+}
+function makeMapperParam(axisInfo) {
+  var axisModel = axisInfo.axis.model;
+  var item = {};
+  var dim = item.axisDim = axisInfo.axis.dim;
+  item.axisIndex = item[dim + 'AxisIndex'] = axisModel.componentIndex;
+  item.axisName = item[dim + 'AxisName'] = axisModel.name;
+  item.axisId = item[dim + 'AxisId'] = axisModel.id;
+  return item;
+}
+function illegalPoint(point) {
+  return !point || point[0] == null || isNaN(point[0]) || point[1] == null || isNaN(point[1]);
+}
+
+exports["default"] = axisTrigger;