office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+
+/**
+ * @param finder contains {seriesIndex, dataIndex, dataIndexInside}
+ * @param ecModel
+ * @return  {point: [x, y], el: ...} point Will not be null.
+ */
+function findPointFromSeries(finder, ecModel) {
+  var point = [];
+  var seriesIndex = finder.seriesIndex;
+  var seriesModel;
+  if (seriesIndex == null || !(seriesModel = ecModel.getSeriesByIndex(seriesIndex))) {
+    return {
+      point: []
+    };
+  }
+  var data = seriesModel.getData();
+  var dataIndex = model.queryDataIndex(data, finder);
+  if (dataIndex == null || dataIndex < 0 || util.isArray(dataIndex)) {
+    return {
+      point: []
+    };
+  }
+  var el = data.getItemGraphicEl(dataIndex);
+  var coordSys = seriesModel.coordinateSystem;
+  if (seriesModel.getTooltipPosition) {
+    point = seriesModel.getTooltipPosition(dataIndex) || [];
+  } else if (coordSys && coordSys.dataToPoint) {
+    if (finder.isStacked) {
+      var baseAxis = coordSys.getBaseAxis();
+      var valueAxis = coordSys.getOtherAxis(baseAxis);
+      var valueAxisDim = valueAxis.dim;
+      var baseAxisDim = baseAxis.dim;
+      var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0;
+      var baseDim = data.mapDimension(baseAxisDim);
+      var stackedData = [];
+      stackedData[baseDataOffset] = data.get(baseDim, dataIndex);
+      stackedData[1 - baseDataOffset] = data.get(data.getCalculationInfo('stackResultDimension'), dataIndex);
+      point = coordSys.dataToPoint(stackedData) || [];
+    } else {
+      point = coordSys.dataToPoint(data.getValues(util.map(coordSys.dimensions, function (dim) {
+        return data.mapDimension(dim);
+      }), dataIndex)) || [];
+    }
+  } else if (el) {
+    // Use graphic bounding rect
+    var rect = el.getBoundingRect().clone();
+    rect.applyTransform(el.transform);
+    point = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+  }
+  return {
+    point: point,
+    el: el
+  };
+}
+
+exports["default"] = findPointFromSeries;

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

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var env = require('../../../../zrender/lib/core/env.js');
+var model = require('../../util/model.js');
+
+var inner = model.makeInner();
+var each = util.each;
+/**
+ * @param {string} key
+ * @param {module:echarts/ExtensionAPI} api
+ * @param {Function} handler
+ *      param: {string} currTrigger
+ *      param: {Array.<number>} point
+ */
+function register(key, api, handler) {
+  if (env["default"].node) {
+    return;
+  }
+  var zr = api.getZr();
+  inner(zr).records || (inner(zr).records = {});
+  initGlobalListeners(zr, api);
+  var record = inner(zr).records[key] || (inner(zr).records[key] = {});
+  record.handler = handler;
+}
+function initGlobalListeners(zr, api) {
+  if (inner(zr).initialized) {
+    return;
+  }
+  inner(zr).initialized = true;
+  useHandler('click', util.curry(doEnter, 'click'));
+  useHandler('mousemove', util.curry(doEnter, 'mousemove'));
+  // useHandler('mouseout', onLeave);
+  useHandler('globalout', onLeave);
+  function useHandler(eventType, cb) {
+    zr.on(eventType, function (e) {
+      var dis = makeDispatchAction(api);
+      each(inner(zr).records, function (record) {
+        record && cb(record, e, dis.dispatchAction);
+      });
+      dispatchTooltipFinally(dis.pendings, api);
+    });
+  }
+}
+function dispatchTooltipFinally(pendings, api) {
+  var showLen = pendings.showTip.length;
+  var hideLen = pendings.hideTip.length;
+  var actuallyPayload;
+  if (showLen) {
+    actuallyPayload = pendings.showTip[showLen - 1];
+  } else if (hideLen) {
+    actuallyPayload = pendings.hideTip[hideLen - 1];
+  }
+  if (actuallyPayload) {
+    actuallyPayload.dispatchAction = null;
+    api.dispatchAction(actuallyPayload);
+  }
+}
+function onLeave(record, e, dispatchAction) {
+  record.handler('leave', null, dispatchAction);
+}
+function doEnter(currTrigger, record, e, dispatchAction) {
+  record.handler(currTrigger, e, dispatchAction);
+}
+function makeDispatchAction(api) {
+  var pendings = {
+    showTip: [],
+    hideTip: []
+  };
+  // FIXME
+  // better approach?
+  // 'showTip' and 'hideTip' can be triggered by axisPointer and tooltip,
+  // which may be conflict, (axisPointer call showTip but tooltip call hideTip);
+  // So we have to add "final stage" to merge those dispatched actions.
+  var dispatchAction = function (payload) {
+    var pendingList = pendings[payload.type];
+    if (pendingList) {
+      pendingList.push(payload);
+    } else {
+      payload.dispatchAction = dispatchAction;
+      api.dispatchAction(payload);
+    }
+  };
+  return {
+    dispatchAction: dispatchAction,
+    pendings: pendings
+  };
+}
+function unregister(key, api) {
+  if (env["default"].node) {
+    return;
+  }
+  var zr = api.getZr();
+  var record = (inner(zr).records || {})[key];
+  if (record) {
+    inner(zr).records[key] = null;
+  }
+}
+
+exports.register = register;
+exports.unregister = unregister;

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

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AxisView = require('../axis/AxisView.js');
+var CartesianAxisPointer = require('./CartesianAxisPointer.js');
+var AxisPointerModel = require('./AxisPointerModel.js');
+var AxisPointerView = require('./AxisPointerView.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var modelHelper = require('./modelHelper.js');
+var axisTrigger = require('./axisTrigger.js');
+
+function install(registers) {
+  // CartesianAxisPointer is not supposed to be required here. But consider
+  // echarts.simple.js and online build tooltip, which only require gridSimple,
+  // CartesianAxisPointer should be able to required somewhere.
+  AxisView["default"].registerAxisPointerClass('CartesianAxisPointer', CartesianAxisPointer["default"]);
+  registers.registerComponentModel(AxisPointerModel["default"]);
+  registers.registerComponentView(AxisPointerView["default"]);
+  registers.registerPreprocessor(function (option) {
+    // Always has a global axisPointerModel for default setting.
+    if (option) {
+      (!option.axisPointer || option.axisPointer.length === 0) && (option.axisPointer = {});
+      var link = option.axisPointer.link;
+      // Normalize to array to avoid object mergin. But if link
+      // is not set, remain null/undefined, otherwise it will
+      // override existent link setting.
+      if (link && !util.isArray(link)) {
+        option.axisPointer.link = [link];
+      }
+    }
+  });
+  // This process should proformed after coordinate systems created
+  // and series data processed. So put it on statistic processing stage.
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, function (ecModel, api) {
+    // Build axisPointerModel, mergin tooltip.axisPointer model for each axis.
+    // allAxesInfo should be updated when setOption performed.
+    ecModel.getComponent('axisPointer').coordSysAxesInfo = modelHelper.collect(ecModel, api);
+  });
+  // Broadcast to all views.
+  registers.registerAction({
+    type: 'updateAxisPointer',
+    event: 'updateAxisPointer',
+    update: ':updateAxisPointer'
+  }, axisTrigger["default"]);
+}
+
+exports.install = install;

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

@@ -0,0 +1,263 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Model = require('../../model/Model.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+// Build axisPointerModel, mergin tooltip.axisPointer model for each axis.
+// allAxesInfo should be updated when setOption performed.
+function collect(ecModel, api) {
+  var result = {
+    /**
+     * key: makeKey(axis.model)
+     * value: {
+     *      axis,
+     *      coordSys,
+     *      axisPointerModel,
+     *      triggerTooltip,
+     *      triggerEmphasis,
+     *      involveSeries,
+     *      snap,
+     *      seriesModels,
+     *      seriesDataCount
+     * }
+     */
+    axesInfo: {},
+    seriesInvolved: false,
+    /**
+     * key: makeKey(coordSys.model)
+     * value: Object: key makeKey(axis.model), value: axisInfo
+     */
+    coordSysAxesInfo: {},
+    coordSysMap: {}
+  };
+  collectAxesInfo(result, ecModel, api);
+  // Check seriesInvolved for performance, in case too many series in some chart.
+  result.seriesInvolved && collectSeriesInfo(result, ecModel);
+  return result;
+}
+function collectAxesInfo(result, ecModel, api) {
+  var globalTooltipModel = ecModel.getComponent('tooltip');
+  var globalAxisPointerModel = ecModel.getComponent('axisPointer');
+  // links can only be set on global.
+  var linksOption = globalAxisPointerModel.get('link', true) || [];
+  var linkGroups = [];
+  // Collect axes info.
+  util.each(api.getCoordinateSystems(), function (coordSys) {
+    // Some coordinate system do not support axes, like geo.
+    if (!coordSys.axisPointerEnabled) {
+      return;
+    }
+    var coordSysKey = makeKey(coordSys.model);
+    var axesInfoInCoordSys = result.coordSysAxesInfo[coordSysKey] = {};
+    result.coordSysMap[coordSysKey] = coordSys;
+    // Set tooltip (like 'cross') is a convenient way to show axisPointer
+    // for user. So we enable setting tooltip on coordSys model.
+    var coordSysModel = coordSys.model;
+    var baseTooltipModel = coordSysModel.getModel('tooltip', globalTooltipModel);
+    util.each(coordSys.getAxes(), util.curry(saveTooltipAxisInfo, false, null));
+    // If axis tooltip used, choose tooltip axis for each coordSys.
+    // Notice this case: coordSys is `grid` but not `cartesian2D` here.
+    if (coordSys.getTooltipAxes && globalTooltipModel
+    // If tooltip.showContent is set as false, tooltip will not
+    // show but axisPointer will show as normal.
+    && baseTooltipModel.get('show')) {
+      // Compatible with previous logic. But series.tooltip.trigger: 'axis'
+      // or series.data[n].tooltip.trigger: 'axis' are not support any more.
+      var triggerAxis = baseTooltipModel.get('trigger') === 'axis';
+      var cross = baseTooltipModel.get(['axisPointer', 'type']) === 'cross';
+      var tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(['axisPointer', 'axis']));
+      if (triggerAxis || cross) {
+        util.each(tooltipAxes.baseAxes, util.curry(saveTooltipAxisInfo, cross ? 'cross' : true, triggerAxis));
+      }
+      if (cross) {
+        util.each(tooltipAxes.otherAxes, util.curry(saveTooltipAxisInfo, 'cross', false));
+      }
+    }
+    // fromTooltip: true | false | 'cross'
+    // triggerTooltip: true | false | null
+    function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) {
+      var axisPointerModel = axis.model.getModel('axisPointer', globalAxisPointerModel);
+      var axisPointerShow = axisPointerModel.get('show');
+      if (!axisPointerShow || axisPointerShow === 'auto' && !fromTooltip && !isHandleTrigger(axisPointerModel)) {
+        return;
+      }
+      if (triggerTooltip == null) {
+        triggerTooltip = axisPointerModel.get('triggerTooltip');
+      }
+      axisPointerModel = fromTooltip ? makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) : axisPointerModel;
+      var snap = axisPointerModel.get('snap');
+      var triggerEmphasis = axisPointerModel.get('triggerEmphasis');
+      var axisKey = makeKey(axis.model);
+      var involveSeries = triggerTooltip || snap || axis.type === 'category';
+      // If result.axesInfo[key] exist, override it (tooltip has higher priority).
+      var axisInfo = result.axesInfo[axisKey] = {
+        key: axisKey,
+        axis: axis,
+        coordSys: coordSys,
+        axisPointerModel: axisPointerModel,
+        triggerTooltip: triggerTooltip,
+        triggerEmphasis: triggerEmphasis,
+        involveSeries: involveSeries,
+        snap: snap,
+        useHandle: isHandleTrigger(axisPointerModel),
+        seriesModels: [],
+        linkGroup: null
+      };
+      axesInfoInCoordSys[axisKey] = axisInfo;
+      result.seriesInvolved = result.seriesInvolved || involveSeries;
+      var groupIndex = getLinkGroupIndex(linksOption, axis);
+      if (groupIndex != null) {
+        var linkGroup = linkGroups[groupIndex] || (linkGroups[groupIndex] = {
+          axesInfo: {}
+        });
+        linkGroup.axesInfo[axisKey] = axisInfo;
+        linkGroup.mapper = linksOption[groupIndex].mapper;
+        axisInfo.linkGroup = linkGroup;
+      }
+    }
+  });
+}
+function makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) {
+  var tooltipAxisPointerModel = baseTooltipModel.getModel('axisPointer');
+  var fields = ['type', 'snap', 'lineStyle', 'shadowStyle', 'label', 'animation', 'animationDurationUpdate', 'animationEasingUpdate', 'z'];
+  var volatileOption = {};
+  util.each(fields, function (field) {
+    volatileOption[field] = util.clone(tooltipAxisPointerModel.get(field));
+  });
+  // category axis do not auto snap, otherwise some tick that do not
+  // has value can not be hovered. value/time/log axis default snap if
+  // triggered from tooltip and trigger tooltip.
+  volatileOption.snap = axis.type !== 'category' && !!triggerTooltip;
+  // Compatible with previous behavior, tooltip axis does not show label by default.
+  // Only these properties can be overridden from tooltip to axisPointer.
+  if (tooltipAxisPointerModel.get('type') === 'cross') {
+    volatileOption.type = 'line';
+  }
+  var labelOption = volatileOption.label || (volatileOption.label = {});
+  // Follow the convention, do not show label when triggered by tooltip by default.
+  labelOption.show == null && (labelOption.show = false);
+  if (fromTooltip === 'cross') {
+    // When 'cross', both axes show labels.
+    var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(['label', 'show']);
+    labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true;
+    // If triggerTooltip, this is a base axis, which should better not use cross style
+    // (cross style is dashed by default)
+    if (!triggerTooltip) {
+      var crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get('crossStyle');
+      crossStyle && util.defaults(labelOption, crossStyle.textStyle);
+    }
+  }
+  return axis.model.getModel('axisPointer', new Model["default"](volatileOption, globalAxisPointerModel, ecModel));
+}
+function collectSeriesInfo(result, ecModel) {
+  // Prepare data for axis trigger
+  ecModel.eachSeries(function (seriesModel) {
+    // Notice this case: this coordSys is `cartesian2D` but not `grid`.
+    var coordSys = seriesModel.coordinateSystem;
+    var seriesTooltipTrigger = seriesModel.get(['tooltip', 'trigger'], true);
+    var seriesTooltipShow = seriesModel.get(['tooltip', 'show'], true);
+    if (!coordSys || seriesTooltipTrigger === 'none' || seriesTooltipTrigger === false || seriesTooltipTrigger === 'item' || seriesTooltipShow === false || seriesModel.get(['axisPointer', 'show'], true) === false) {
+      return;
+    }
+    util.each(result.coordSysAxesInfo[makeKey(coordSys.model)], function (axisInfo) {
+      var axis = axisInfo.axis;
+      if (coordSys.getAxis(axis.dim) === axis) {
+        axisInfo.seriesModels.push(seriesModel);
+        axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
+        axisInfo.seriesDataCount += seriesModel.getData().count();
+      }
+    });
+  });
+}
+/**
+ * For example:
+ * {
+ *     axisPointer: {
+ *         links: [{
+ *             xAxisIndex: [2, 4],
+ *             yAxisIndex: 'all'
+ *         }, {
+ *             xAxisId: ['a5', 'a7'],
+ *             xAxisName: 'xxx'
+ *         }]
+ *     }
+ * }
+ */
+function getLinkGroupIndex(linksOption, axis) {
+  var axisModel = axis.model;
+  var dim = axis.dim;
+  for (var i = 0; i < linksOption.length; i++) {
+    var linkOption = linksOption[i] || {};
+    if (checkPropInLink(linkOption[dim + 'AxisId'], axisModel.id) || checkPropInLink(linkOption[dim + 'AxisIndex'], axisModel.componentIndex) || checkPropInLink(linkOption[dim + 'AxisName'], axisModel.name)) {
+      return i;
+    }
+  }
+}
+function checkPropInLink(linkPropValue, axisPropValue) {
+  return linkPropValue === 'all' || util.isArray(linkPropValue) && util.indexOf(linkPropValue, axisPropValue) >= 0 || linkPropValue === axisPropValue;
+}
+function fixValue(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  if (!axisInfo) {
+    return;
+  }
+  var axisPointerModel = axisInfo.axisPointerModel;
+  var scale = axisInfo.axis.scale;
+  var option = axisPointerModel.option;
+  var status = axisPointerModel.get('status');
+  var value = axisPointerModel.get('value');
+  // Parse init value for category and time axis.
+  if (value != null) {
+    value = scale.parse(value);
+  }
+  var useHandle = isHandleTrigger(axisPointerModel);
+  // If `handle` used, `axisPointer` will always be displayed, so value
+  // and status should be initialized.
+  if (status == null) {
+    option.status = useHandle ? 'show' : 'hide';
+  }
+  var extent = scale.getExtent().slice();
+  extent[0] > extent[1] && extent.reverse();
+  if (
+  // Pick a value on axis when initializing.
+  value == null
+  // If both `handle` and `dataZoom` are used, value may be out of axis extent,
+  // where we should re-pick a value to keep `handle` displaying normally.
+  || value > extent[1]) {
+    // Make handle displayed on the end of the axis when init, which looks better.
+    value = extent[1];
+  }
+  if (value < extent[0]) {
+    value = extent[0];
+  }
+  option.value = value;
+  if (useHandle) {
+    option.status = axisInfo.axis.scale.isBlank() ? 'hide' : 'show';
+  }
+}
+function getAxisInfo(axisModel) {
+  var coordSysAxesInfo = (axisModel.ecModel.getComponent('axisPointer') || {}).coordSysAxesInfo;
+  return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
+}
+function getAxisPointerModel(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  return axisInfo && axisInfo.axisPointerModel;
+}
+function isHandleTrigger(axisPointerModel) {
+  return !!axisPointerModel.get(['handle', 'show']);
+}
+/**
+ * @param {module:echarts/model/Model} model
+ * @return {string} unique key
+ */
+function makeKey(model) {
+  return model.type + '||' + model.id;
+}
+
+exports.collect = collect;
+exports.fixValue = fixValue;
+exports.getAxisInfo = getAxisInfo;
+exports.getAxisPointerModel = getAxisPointerModel;
+exports.makeKey = makeKey;

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

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var graphic = require('../../util/graphic.js');
+var text = require('../../../../zrender/lib/contain/text.js');
+var format = require('../../util/format.js');
+var matrix = require('../../../../zrender/lib/core/matrix.js');
+var axisHelper = require('../../coord/axisHelper.js');
+var AxisBuilder = require('../axis/AxisBuilder.js');
+var labelStyle = require('../../label/labelStyle.js');
+
+function buildElStyle(axisPointerModel) {
+  var axisPointerType = axisPointerModel.get('type');
+  var styleModel = axisPointerModel.getModel(axisPointerType + 'Style');
+  var style;
+  if (axisPointerType === 'line') {
+    style = styleModel.getLineStyle();
+    style.fill = null;
+  } else if (axisPointerType === 'shadow') {
+    style = styleModel.getAreaStyle();
+    style.stroke = null;
+  }
+  return style;
+}
+/**
+ * @param {Function} labelPos {align, verticalAlign, position}
+ */
+function buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos) {
+  var value = axisPointerModel.get('value');
+  var text$1 = getValueLabel(value, axisModel.axis, axisModel.ecModel, axisPointerModel.get('seriesDataIndices'), {
+    precision: axisPointerModel.get(['label', 'precision']),
+    formatter: axisPointerModel.get(['label', 'formatter'])
+  });
+  var labelModel = axisPointerModel.getModel('label');
+  var paddings = format.normalizeCssArray(labelModel.get('padding') || 0);
+  var font = labelModel.getFont();
+  var textRect = text.getBoundingRect(text$1, font);
+  var position = labelPos.position;
+  var width = textRect.width + paddings[1] + paddings[3];
+  var height = textRect.height + paddings[0] + paddings[2];
+  // Adjust by align.
+  var align = labelPos.align;
+  align === 'right' && (position[0] -= width);
+  align === 'center' && (position[0] -= width / 2);
+  var verticalAlign = labelPos.verticalAlign;
+  verticalAlign === 'bottom' && (position[1] -= height);
+  verticalAlign === 'middle' && (position[1] -= height / 2);
+  // Not overflow ec container
+  confineInContainer(position, width, height, api);
+  var bgColor = labelModel.get('backgroundColor');
+  if (!bgColor || bgColor === 'auto') {
+    bgColor = axisModel.get(['axisLine', 'lineStyle', 'color']);
+  }
+  elOption.label = {
+    // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')},
+    x: position[0],
+    y: position[1],
+    style: labelStyle.createTextStyle(labelModel, {
+      text: text$1,
+      font: font,
+      fill: labelModel.getTextColor(),
+      padding: paddings,
+      backgroundColor: bgColor
+    }),
+    // Label should be over axisPointer.
+    z2: 10
+  };
+}
+// Do not overflow ec container
+function confineInContainer(position, width, height, api) {
+  var viewWidth = api.getWidth();
+  var viewHeight = api.getHeight();
+  position[0] = Math.min(position[0] + width, viewWidth) - width;
+  position[1] = Math.min(position[1] + height, viewHeight) - height;
+  position[0] = Math.max(position[0], 0);
+  position[1] = Math.max(position[1], 0);
+}
+function getValueLabel(value, axis, ecModel, seriesDataIndices, opt) {
+  value = axis.scale.parse(value);
+  var text = axis.scale.getLabel({
+    value: value
+  }, {
+    // If `precision` is set, width can be fixed (like '12.00500'), which
+    // helps to debounce when when moving label.
+    precision: opt.precision
+  });
+  var formatter = opt.formatter;
+  if (formatter) {
+    var params_1 = {
+      value: axisHelper.getAxisRawValue(axis, {
+        value: value
+      }),
+      axisDimension: axis.dim,
+      axisIndex: axis.index,
+      seriesData: []
+    };
+    util.each(seriesDataIndices, function (idxItem) {
+      var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+      var dataIndex = idxItem.dataIndexInside;
+      var dataParams = series && series.getDataParams(dataIndex);
+      dataParams && params_1.seriesData.push(dataParams);
+    });
+    if (util.isString(formatter)) {
+      text = formatter.replace('{value}', text);
+    } else if (util.isFunction(formatter)) {
+      text = formatter(params_1);
+    }
+  }
+  return text;
+}
+function getTransformedPosition(axis, value, layoutInfo) {
+  var transform = matrix.create();
+  matrix.rotate(transform, transform, layoutInfo.rotation);
+  matrix.translate(transform, transform, layoutInfo.position);
+  return graphic.applyTransform([axis.dataToCoord(value), (layoutInfo.labelOffset || 0) + (layoutInfo.labelDirection || 1) * (layoutInfo.labelMargin || 0)], transform);
+}
+function buildCartesianSingleLabelElOption(value, elOption, layoutInfo, axisModel, axisPointerModel, api) {
+  // @ts-ignore
+  var textLayout = AxisBuilder["default"].innerTextLayout(layoutInfo.rotation, 0, layoutInfo.labelDirection);
+  layoutInfo.labelMargin = axisPointerModel.get(['label', 'margin']);
+  buildLabelElOption(elOption, axisModel, axisPointerModel, api, {
+    position: getTransformedPosition(axisModel.axis, value, layoutInfo),
+    align: textLayout.textAlign,
+    verticalAlign: textLayout.textVerticalAlign
+  });
+}
+function makeLineShape(p1, p2, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x1: p1[xDimIndex],
+    y1: p1[1 - xDimIndex],
+    x2: p2[xDimIndex],
+    y2: p2[1 - xDimIndex]
+  };
+}
+function makeRectShape(xy, wh, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x: xy[xDimIndex],
+    y: xy[1 - xDimIndex],
+    width: wh[xDimIndex],
+    height: wh[1 - xDimIndex]
+  };
+}
+function makeSectorShape(cx, cy, r0, r, startAngle, endAngle) {
+  return {
+    cx: cx,
+    cy: cy,
+    r0: r0,
+    r: r,
+    startAngle: startAngle,
+    endAngle: endAngle,
+    clockwise: true
+  };
+}
+
+exports.buildCartesianSingleLabelElOption = buildCartesianSingleLabelElOption;
+exports.buildElStyle = buildElStyle;
+exports.buildLabelElOption = buildLabelElOption;
+exports.getTransformedPosition = getTransformedPosition;
+exports.getValueLabel = getValueLabel;
+exports.makeLineShape = makeLineShape;
+exports.makeRectShape = makeRectShape;
+exports.makeSectorShape = makeSectorShape;