@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/tooltip/TooltipView.mjs

@@ -0,0 +1,693 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { bind, each, trim, isString, clone, isArray, isFunction, isObject, extend } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import env from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.mjs";
+import TooltipHTMLContent from "./TooltipHTMLContent.mjs";
+import TooltipRichContent from "./TooltipRichContent.mjs";
+import { convertToColorString, formatTpl } from "../../util/format.mjs";
+import { parsePercent } from "../../util/number.mjs";
+import "../../util/graphic.mjs";
+import findPointFromSeries from "../axisPointer/findPointFromSeries.mjs";
+import { getLayoutRect } from "../../util/layout.mjs";
+import Model from "../../model/Model.mjs";
+import { register, unregister } from "../axisPointer/globalListener.mjs";
+import { getAxisRawValue } from "../../coord/axisHelper.mjs";
+import { getValueLabel } from "../axisPointer/viewHelper.mjs";
+import { getTooltipRenderMode, preParseFinder, queryReferringComponents } from "../../util/model.mjs";
+import ComponentView from "../../view/Component.mjs";
+import { format } from "../../util/time.mjs";
+import { getECData } from "../../util/innerStore.mjs";
+import { shouldTooltipConfine } from "./helper.mjs";
+import { normalizeTooltipFormatResult } from "../../model/mixin/dataFormat.mjs";
+import { createTooltipMarkup, TooltipMarkupStyleCreator, buildTooltipMarkup } from "./tooltipMarkup.mjs";
+import { findEventDispatcher } from "../../util/event.mjs";
+import { createOrUpdate, clear } from "../../util/throttle.mjs";
+import Rect from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.mjs";
+import { encodeHTML } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/dom.mjs";
+var proxyRect = new Rect({
+  shape: {
+    x: -1,
+    y: -1,
+    width: 2,
+    height: 2
+  }
+});
+var TooltipView = (
+  /** @class */
+  function(_super) {
+    __extends(TooltipView2, _super);
+    function TooltipView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = TooltipView2.type;
+      return _this;
+    }
+    TooltipView2.prototype.init = function(ecModel, api) {
+      if (env.node || !api.getDom()) {
+        return;
+      }
+      var tooltipModel = ecModel.getComponent("tooltip");
+      var renderMode = this._renderMode = getTooltipRenderMode(tooltipModel.get("renderMode"));
+      this._tooltipContent = renderMode === "richText" ? new TooltipRichContent(api) : new TooltipHTMLContent(api, {
+        appendTo: tooltipModel.get("appendToBody", true) ? "body" : tooltipModel.get("appendTo", true)
+      });
+    };
+    TooltipView2.prototype.render = function(tooltipModel, ecModel, api) {
+      if (env.node || !api.getDom()) {
+        return;
+      }
+      this.group.removeAll();
+      this._tooltipModel = tooltipModel;
+      this._ecModel = ecModel;
+      this._api = api;
+      var tooltipContent = this._tooltipContent;
+      tooltipContent.update(tooltipModel);
+      tooltipContent.setEnterable(tooltipModel.get("enterable"));
+      this._initGlobalListener();
+      this._keepShow();
+      if (this._renderMode !== "richText" && tooltipModel.get("transitionDuration")) {
+        createOrUpdate(this, "_updatePosition", 50, "fixRate");
+      } else {
+        clear(this, "_updatePosition");
+      }
+    };
+    TooltipView2.prototype._initGlobalListener = function() {
+      var tooltipModel = this._tooltipModel;
+      var triggerOn = tooltipModel.get("triggerOn");
+      register("itemTooltip", this._api, bind(function(currTrigger, e, dispatchAction) {
+        if (triggerOn !== "none") {
+          if (triggerOn.indexOf(currTrigger) >= 0) {
+            this._tryShow(e, dispatchAction);
+          } else if (currTrigger === "leave") {
+            this._hide(dispatchAction);
+          }
+        }
+      }, this));
+    };
+    TooltipView2.prototype._keepShow = function() {
+      var tooltipModel = this._tooltipModel;
+      var ecModel = this._ecModel;
+      var api = this._api;
+      var triggerOn = tooltipModel.get("triggerOn");
+      if (this._lastX != null && this._lastY != null && triggerOn !== "none" && triggerOn !== "click") {
+        var self_1 = this;
+        clearTimeout(this._refreshUpdateTimeout);
+        this._refreshUpdateTimeout = setTimeout(function() {
+          !api.isDisposed() && self_1.manuallyShowTip(tooltipModel, ecModel, api, {
+            x: self_1._lastX,
+            y: self_1._lastY,
+            dataByCoordSys: self_1._lastDataByCoordSys
+          });
+        });
+      }
+    };
+    TooltipView2.prototype.manuallyShowTip = function(tooltipModel, ecModel, api, payload) {
+      if (payload.from === this.uid || env.node || !api.getDom()) {
+        return;
+      }
+      var dispatchAction = makeDispatchAction(payload, api);
+      this._ticket = "";
+      var dataByCoordSys = payload.dataByCoordSys;
+      var cmptRef = findComponentReference(payload, ecModel, api);
+      if (cmptRef) {
+        var rect = cmptRef.el.getBoundingRect().clone();
+        rect.applyTransform(cmptRef.el.transform);
+        this._tryShow({
+          offsetX: rect.x + rect.width / 2,
+          offsetY: rect.y + rect.height / 2,
+          target: cmptRef.el,
+          position: payload.position,
+          // When manully trigger, the mouse is not on the el, so we'd better to
+          // position tooltip on the bottom of the el and display arrow is possible.
+          positionDefault: "bottom"
+        }, dispatchAction);
+      } else if (payload.tooltip && payload.x != null && payload.y != null) {
+        var el = proxyRect;
+        el.x = payload.x;
+        el.y = payload.y;
+        el.update();
+        getECData(el).tooltipConfig = {
+          name: null,
+          option: payload.tooltip
+        };
+        this._tryShow({
+          offsetX: payload.x,
+          offsetY: payload.y,
+          target: el
+        }, dispatchAction);
+      } else if (dataByCoordSys) {
+        this._tryShow({
+          offsetX: payload.x,
+          offsetY: payload.y,
+          position: payload.position,
+          dataByCoordSys,
+          tooltipOption: payload.tooltipOption
+        }, dispatchAction);
+      } else if (payload.seriesIndex != null) {
+        if (this._manuallyAxisShowTip(tooltipModel, ecModel, api, payload)) {
+          return;
+        }
+        var pointInfo = findPointFromSeries(payload, ecModel);
+        var cx = pointInfo.point[0];
+        var cy = pointInfo.point[1];
+        if (cx != null && cy != null) {
+          this._tryShow({
+            offsetX: cx,
+            offsetY: cy,
+            target: pointInfo.el,
+            position: payload.position,
+            // When manully trigger, the mouse is not on the el, so we'd better to
+            // position tooltip on the bottom of the el and display arrow is possible.
+            positionDefault: "bottom"
+          }, dispatchAction);
+        }
+      } else if (payload.x != null && payload.y != null) {
+        api.dispatchAction({
+          type: "updateAxisPointer",
+          x: payload.x,
+          y: payload.y
+        });
+        this._tryShow({
+          offsetX: payload.x,
+          offsetY: payload.y,
+          position: payload.position,
+          target: api.getZr().findHover(payload.x, payload.y).target
+        }, dispatchAction);
+      }
+    };
+    TooltipView2.prototype.manuallyHideTip = function(tooltipModel, ecModel, api, payload) {
+      var tooltipContent = this._tooltipContent;
+      if (this._tooltipModel) {
+        tooltipContent.hideLater(this._tooltipModel.get("hideDelay"));
+      }
+      this._lastX = this._lastY = this._lastDataByCoordSys = null;
+      if (payload.from !== this.uid) {
+        this._hide(makeDispatchAction(payload, api));
+      }
+    };
+    TooltipView2.prototype._manuallyAxisShowTip = function(tooltipModel, ecModel, api, payload) {
+      var seriesIndex = payload.seriesIndex;
+      var dataIndex = payload.dataIndex;
+      var coordSysAxesInfo = ecModel.getComponent("axisPointer").coordSysAxesInfo;
+      if (seriesIndex == null || dataIndex == null || coordSysAxesInfo == null) {
+        return;
+      }
+      var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
+      if (!seriesModel) {
+        return;
+      }
+      var data = seriesModel.getData();
+      var tooltipCascadedModel = buildTooltipModel([data.getItemModel(dataIndex), seriesModel, (seriesModel.coordinateSystem || {}).model], this._tooltipModel);
+      if (tooltipCascadedModel.get("trigger") !== "axis") {
+        return;
+      }
+      api.dispatchAction({
+        type: "updateAxisPointer",
+        seriesIndex,
+        dataIndex,
+        position: payload.position
+      });
+      return true;
+    };
+    TooltipView2.prototype._tryShow = function(e, dispatchAction) {
+      var el = e.target;
+      var tooltipModel = this._tooltipModel;
+      if (!tooltipModel) {
+        return;
+      }
+      this._lastX = e.offsetX;
+      this._lastY = e.offsetY;
+      var dataByCoordSys = e.dataByCoordSys;
+      if (dataByCoordSys && dataByCoordSys.length) {
+        this._showAxisTooltip(dataByCoordSys, e);
+      } else if (el) {
+        var ecData = getECData(el);
+        if (ecData.ssrType === "legend") {
+          return;
+        }
+        this._lastDataByCoordSys = null;
+        var seriesDispatcher_1;
+        var cmptDispatcher_1;
+        findEventDispatcher(el, function(target) {
+          if (getECData(target).dataIndex != null) {
+            seriesDispatcher_1 = target;
+            return true;
+          }
+          if (getECData(target).tooltipConfig != null) {
+            cmptDispatcher_1 = target;
+            return true;
+          }
+        }, true);
+        if (seriesDispatcher_1) {
+          this._showSeriesItemTooltip(e, seriesDispatcher_1, dispatchAction);
+        } else if (cmptDispatcher_1) {
+          this._showComponentItemTooltip(e, cmptDispatcher_1, dispatchAction);
+        } else {
+          this._hide(dispatchAction);
+        }
+      } else {
+        this._lastDataByCoordSys = null;
+        this._hide(dispatchAction);
+      }
+    };
+    TooltipView2.prototype._showOrMove = function(tooltipModel, cb) {
+      var delay = tooltipModel.get("showDelay");
+      cb = bind(cb, this);
+      clearTimeout(this._showTimout);
+      delay > 0 ? this._showTimout = setTimeout(cb, delay) : cb();
+    };
+    TooltipView2.prototype._showAxisTooltip = function(dataByCoordSys, e) {
+      var ecModel = this._ecModel;
+      var globalTooltipModel = this._tooltipModel;
+      var point = [e.offsetX, e.offsetY];
+      var singleTooltipModel = buildTooltipModel([e.tooltipOption], globalTooltipModel);
+      var renderMode = this._renderMode;
+      var cbParamsList = [];
+      var articleMarkup = createTooltipMarkup("section", {
+        blocks: [],
+        noHeader: true
+      });
+      var markupTextArrLegacy = [];
+      var markupStyleCreator = new TooltipMarkupStyleCreator();
+      each(dataByCoordSys, function(itemCoordSys) {
+        each(itemCoordSys.dataByAxis, function(axisItem) {
+          var axisModel = ecModel.getComponent(axisItem.axisDim + "Axis", axisItem.axisIndex);
+          var axisValue = axisItem.value;
+          if (!axisModel || axisValue == null) {
+            return;
+          }
+          var axisValueLabel = getValueLabel(axisValue, axisModel.axis, ecModel, axisItem.seriesDataIndices, axisItem.valueLabelOpt);
+          var axisSectionMarkup = createTooltipMarkup("section", {
+            header: axisValueLabel,
+            noHeader: !trim(axisValueLabel),
+            sortBlocks: true,
+            blocks: []
+          });
+          articleMarkup.blocks.push(axisSectionMarkup);
+          each(axisItem.seriesDataIndices, function(idxItem) {
+            var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+            var dataIndex = idxItem.dataIndexInside;
+            var cbParams = series.getDataParams(dataIndex);
+            if (cbParams.dataIndex < 0) {
+              return;
+            }
+            cbParams.axisDim = axisItem.axisDim;
+            cbParams.axisIndex = axisItem.axisIndex;
+            cbParams.axisType = axisItem.axisType;
+            cbParams.axisId = axisItem.axisId;
+            cbParams.axisValue = getAxisRawValue(axisModel.axis, {
+              value: axisValue
+            });
+            cbParams.axisValueLabel = axisValueLabel;
+            cbParams.marker = markupStyleCreator.makeTooltipMarker("item", convertToColorString(cbParams.color), renderMode);
+            var seriesTooltipResult = normalizeTooltipFormatResult(series.formatTooltip(dataIndex, true, null));
+            var frag = seriesTooltipResult.frag;
+            if (frag) {
+              var valueFormatter = buildTooltipModel([series], globalTooltipModel).get("valueFormatter");
+              axisSectionMarkup.blocks.push(valueFormatter ? extend({
+                valueFormatter
+              }, frag) : frag);
+            }
+            if (seriesTooltipResult.text) {
+              markupTextArrLegacy.push(seriesTooltipResult.text);
+            }
+            cbParamsList.push(cbParams);
+          });
+        });
+      });
+      articleMarkup.blocks.reverse();
+      markupTextArrLegacy.reverse();
+      var positionExpr = e.position;
+      var orderMode = singleTooltipModel.get("order");
+      var builtMarkupText = buildTooltipMarkup(articleMarkup, markupStyleCreator, renderMode, orderMode, ecModel.get("useUTC"), singleTooltipModel.get("textStyle"));
+      builtMarkupText && markupTextArrLegacy.unshift(builtMarkupText);
+      var blockBreak = renderMode === "richText" ? "\n\n" : "<br/>";
+      var allMarkupText = markupTextArrLegacy.join(blockBreak);
+      this._showOrMove(singleTooltipModel, function() {
+        if (this._updateContentNotChangedOnAxis(dataByCoordSys, cbParamsList)) {
+          this._updatePosition(singleTooltipModel, positionExpr, point[0], point[1], this._tooltipContent, cbParamsList);
+        } else {
+          this._showTooltipContent(singleTooltipModel, allMarkupText, cbParamsList, Math.random() + "", point[0], point[1], positionExpr, null, markupStyleCreator);
+        }
+      });
+    };
+    TooltipView2.prototype._showSeriesItemTooltip = function(e, dispatcher, dispatchAction) {
+      var ecModel = this._ecModel;
+      var ecData = getECData(dispatcher);
+      var seriesIndex = ecData.seriesIndex;
+      var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
+      var dataModel = ecData.dataModel || seriesModel;
+      var dataIndex = ecData.dataIndex;
+      var dataType = ecData.dataType;
+      var data = dataModel.getData(dataType);
+      var renderMode = this._renderMode;
+      var positionDefault = e.positionDefault;
+      var tooltipModel = buildTooltipModel([data.getItemModel(dataIndex), dataModel, seriesModel && (seriesModel.coordinateSystem || {}).model], this._tooltipModel, positionDefault ? {
+        position: positionDefault
+      } : null);
+      var tooltipTrigger = tooltipModel.get("trigger");
+      if (tooltipTrigger != null && tooltipTrigger !== "item") {
+        return;
+      }
+      var params = dataModel.getDataParams(dataIndex, dataType);
+      var markupStyleCreator = new TooltipMarkupStyleCreator();
+      params.marker = markupStyleCreator.makeTooltipMarker("item", convertToColorString(params.color), renderMode);
+      var seriesTooltipResult = normalizeTooltipFormatResult(dataModel.formatTooltip(dataIndex, false, dataType));
+      var orderMode = tooltipModel.get("order");
+      var valueFormatter = tooltipModel.get("valueFormatter");
+      var frag = seriesTooltipResult.frag;
+      var markupText = frag ? buildTooltipMarkup(valueFormatter ? extend({
+        valueFormatter
+      }, frag) : frag, markupStyleCreator, renderMode, orderMode, ecModel.get("useUTC"), tooltipModel.get("textStyle")) : seriesTooltipResult.text;
+      var asyncTicket = "item_" + dataModel.name + "_" + dataIndex;
+      this._showOrMove(tooltipModel, function() {
+        this._showTooltipContent(tooltipModel, markupText, params, asyncTicket, e.offsetX, e.offsetY, e.position, e.target, markupStyleCreator);
+      });
+      dispatchAction({
+        type: "showTip",
+        dataIndexInside: dataIndex,
+        dataIndex: data.getRawIndex(dataIndex),
+        seriesIndex,
+        from: this.uid
+      });
+    };
+    TooltipView2.prototype._showComponentItemTooltip = function(e, el, dispatchAction) {
+      var isHTMLRenderMode = this._renderMode === "html";
+      var ecData = getECData(el);
+      var tooltipConfig = ecData.tooltipConfig;
+      var tooltipOpt = tooltipConfig.option || {};
+      var encodeHTMLContent = tooltipOpt.encodeHTMLContent;
+      if (isString(tooltipOpt)) {
+        var content = tooltipOpt;
+        tooltipOpt = {
+          content,
+          // Fixed formatter
+          formatter: content
+        };
+        encodeHTMLContent = true;
+      }
+      if (encodeHTMLContent && isHTMLRenderMode && tooltipOpt.content) {
+        tooltipOpt = clone(tooltipOpt);
+        tooltipOpt.content = encodeHTML(tooltipOpt.content);
+      }
+      var tooltipModelCascade = [tooltipOpt];
+      var cmpt = this._ecModel.getComponent(ecData.componentMainType, ecData.componentIndex);
+      if (cmpt) {
+        tooltipModelCascade.push(cmpt);
+      }
+      tooltipModelCascade.push({
+        formatter: tooltipOpt.content
+      });
+      var positionDefault = e.positionDefault;
+      var subTooltipModel = buildTooltipModel(tooltipModelCascade, this._tooltipModel, positionDefault ? {
+        position: positionDefault
+      } : null);
+      var defaultHtml = subTooltipModel.get("content");
+      var asyncTicket = Math.random() + "";
+      var markupStyleCreator = new TooltipMarkupStyleCreator();
+      this._showOrMove(subTooltipModel, function() {
+        var formatterParams = clone(subTooltipModel.get("formatterParams") || {});
+        this._showTooltipContent(subTooltipModel, defaultHtml, formatterParams, asyncTicket, e.offsetX, e.offsetY, e.position, el, markupStyleCreator);
+      });
+      dispatchAction({
+        type: "showTip",
+        from: this.uid
+      });
+    };
+    TooltipView2.prototype._showTooltipContent = function(tooltipModel, defaultHtml, params, asyncTicket, x, y, positionExpr, el, markupStyleCreator) {
+      this._ticket = "";
+      if (!tooltipModel.get("showContent") || !tooltipModel.get("show")) {
+        return;
+      }
+      var tooltipContent = this._tooltipContent;
+      tooltipContent.setEnterable(tooltipModel.get("enterable"));
+      var formatter = tooltipModel.get("formatter");
+      positionExpr = positionExpr || tooltipModel.get("position");
+      var html = defaultHtml;
+      var nearPoint = this._getNearestPoint([x, y], params, tooltipModel.get("trigger"), tooltipModel.get("borderColor"));
+      var nearPointColor = nearPoint.color;
+      if (formatter) {
+        if (isString(formatter)) {
+          var useUTC = tooltipModel.ecModel.get("useUTC");
+          var params0 = isArray(params) ? params[0] : params;
+          var isTimeAxis = params0 && params0.axisType && params0.axisType.indexOf("time") >= 0;
+          html = formatter;
+          if (isTimeAxis) {
+            html = format(params0.axisValue, html, useUTC);
+          }
+          html = formatTpl(html, params, true);
+        } else if (isFunction(formatter)) {
+          var callback = bind(function(cbTicket, html2) {
+            if (cbTicket === this._ticket) {
+              tooltipContent.setContent(html2, markupStyleCreator, tooltipModel, nearPointColor, positionExpr);
+              this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el);
+            }
+          }, this);
+          this._ticket = asyncTicket;
+          html = formatter(params, asyncTicket, callback);
+        } else {
+          html = formatter;
+        }
+      }
+      tooltipContent.setContent(html, markupStyleCreator, tooltipModel, nearPointColor, positionExpr);
+      tooltipContent.show(tooltipModel, nearPointColor);
+      this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el);
+    };
+    TooltipView2.prototype._getNearestPoint = function(point, tooltipDataParams, trigger, borderColor) {
+      if (trigger === "axis" || isArray(tooltipDataParams)) {
+        return {
+          color: borderColor || (this._renderMode === "html" ? "#fff" : "none")
+        };
+      }
+      if (!isArray(tooltipDataParams)) {
+        return {
+          color: borderColor || tooltipDataParams.color || tooltipDataParams.borderColor
+        };
+      }
+    };
+    TooltipView2.prototype._updatePosition = function(tooltipModel, positionExpr, x, y, content, params, el) {
+      var viewWidth = this._api.getWidth();
+      var viewHeight = this._api.getHeight();
+      positionExpr = positionExpr || tooltipModel.get("position");
+      var contentSize = content.getSize();
+      var align = tooltipModel.get("align");
+      var vAlign = tooltipModel.get("verticalAlign");
+      var rect = el && el.getBoundingRect().clone();
+      el && rect.applyTransform(el.transform);
+      if (isFunction(positionExpr)) {
+        positionExpr = positionExpr([x, y], params, content.el, rect, {
+          viewSize: [viewWidth, viewHeight],
+          contentSize: contentSize.slice()
+        });
+      }
+      if (isArray(positionExpr)) {
+        x = parsePercent(positionExpr[0], viewWidth);
+        y = parsePercent(positionExpr[1], viewHeight);
+      } else if (isObject(positionExpr)) {
+        var boxLayoutPosition = positionExpr;
+        boxLayoutPosition.width = contentSize[0];
+        boxLayoutPosition.height = contentSize[1];
+        var layoutRect = getLayoutRect(boxLayoutPosition, {
+          width: viewWidth,
+          height: viewHeight
+        });
+        x = layoutRect.x;
+        y = layoutRect.y;
+        align = null;
+        vAlign = null;
+      } else if (isString(positionExpr) && el) {
+        var pos = calcTooltipPosition(positionExpr, rect, contentSize, tooltipModel.get("borderWidth"));
+        x = pos[0];
+        y = pos[1];
+      } else {
+        var pos = refixTooltipPosition(x, y, content, viewWidth, viewHeight, align ? null : 20, vAlign ? null : 20);
+        x = pos[0];
+        y = pos[1];
+      }
+      align && (x -= isCenterAlign(align) ? contentSize[0] / 2 : align === "right" ? contentSize[0] : 0);
+      vAlign && (y -= isCenterAlign(vAlign) ? contentSize[1] / 2 : vAlign === "bottom" ? contentSize[1] : 0);
+      if (shouldTooltipConfine(tooltipModel)) {
+        var pos = confineTooltipPosition(x, y, content, viewWidth, viewHeight);
+        x = pos[0];
+        y = pos[1];
+      }
+      content.moveTo(x, y);
+    };
+    TooltipView2.prototype._updateContentNotChangedOnAxis = function(dataByCoordSys, cbParamsList) {
+      var lastCoordSys = this._lastDataByCoordSys;
+      var lastCbParamsList = this._cbParamsList;
+      var contentNotChanged = !!lastCoordSys && lastCoordSys.length === dataByCoordSys.length;
+      contentNotChanged && each(lastCoordSys, function(lastItemCoordSys, indexCoordSys) {
+        var lastDataByAxis = lastItemCoordSys.dataByAxis || [];
+        var thisItemCoordSys = dataByCoordSys[indexCoordSys] || {};
+        var thisDataByAxis = thisItemCoordSys.dataByAxis || [];
+        contentNotChanged = contentNotChanged && lastDataByAxis.length === thisDataByAxis.length;
+        contentNotChanged && each(lastDataByAxis, function(lastItem, indexAxis) {
+          var thisItem = thisDataByAxis[indexAxis] || {};
+          var lastIndices = lastItem.seriesDataIndices || [];
+          var newIndices = thisItem.seriesDataIndices || [];
+          contentNotChanged = contentNotChanged && lastItem.value === thisItem.value && lastItem.axisType === thisItem.axisType && lastItem.axisId === thisItem.axisId && lastIndices.length === newIndices.length;
+          contentNotChanged && each(lastIndices, function(lastIdxItem, j) {
+            var newIdxItem = newIndices[j];
+            contentNotChanged = contentNotChanged && lastIdxItem.seriesIndex === newIdxItem.seriesIndex && lastIdxItem.dataIndex === newIdxItem.dataIndex;
+          });
+          lastCbParamsList && each(lastItem.seriesDataIndices, function(idxItem) {
+            var seriesIdx = idxItem.seriesIndex;
+            var cbParams = cbParamsList[seriesIdx];
+            var lastCbParams = lastCbParamsList[seriesIdx];
+            if (cbParams && lastCbParams && lastCbParams.data !== cbParams.data) {
+              contentNotChanged = false;
+            }
+          });
+        });
+      });
+      this._lastDataByCoordSys = dataByCoordSys;
+      this._cbParamsList = cbParamsList;
+      return !!contentNotChanged;
+    };
+    TooltipView2.prototype._hide = function(dispatchAction) {
+      this._lastDataByCoordSys = null;
+      dispatchAction({
+        type: "hideTip",
+        from: this.uid
+      });
+    };
+    TooltipView2.prototype.dispose = function(ecModel, api) {
+      if (env.node || !api.getDom()) {
+        return;
+      }
+      clear(this, "_updatePosition");
+      this._tooltipContent.dispose();
+      unregister("itemTooltip", api);
+    };
+    TooltipView2.type = "tooltip";
+    return TooltipView2;
+  }(ComponentView)
+);
+function buildTooltipModel(modelCascade, globalTooltipModel, defaultTooltipOption) {
+  var ecModel = globalTooltipModel.ecModel;
+  var resultModel;
+  if (defaultTooltipOption) {
+    resultModel = new Model(defaultTooltipOption, ecModel, ecModel);
+    resultModel = new Model(globalTooltipModel.option, resultModel, ecModel);
+  } else {
+    resultModel = globalTooltipModel;
+  }
+  for (var i = modelCascade.length - 1; i >= 0; i--) {
+    var tooltipOpt = modelCascade[i];
+    if (tooltipOpt) {
+      if (tooltipOpt instanceof Model) {
+        tooltipOpt = tooltipOpt.get("tooltip", true);
+      }
+      if (isString(tooltipOpt)) {
+        tooltipOpt = {
+          formatter: tooltipOpt
+        };
+      }
+      if (tooltipOpt) {
+        resultModel = new Model(tooltipOpt, resultModel, ecModel);
+      }
+    }
+  }
+  return resultModel;
+}
+function makeDispatchAction(payload, api) {
+  return payload.dispatchAction || bind(api.dispatchAction, api);
+}
+function refixTooltipPosition(x, y, content, viewWidth, viewHeight, gapH, gapV) {
+  var size = content.getSize();
+  var width = size[0];
+  var height = size[1];
+  if (gapH != null) {
+    if (x + width + gapH + 2 > viewWidth) {
+      x -= width + gapH;
+    } else {
+      x += gapH;
+    }
+  }
+  if (gapV != null) {
+    if (y + height + gapV > viewHeight) {
+      y -= height + gapV;
+    } else {
+      y += gapV;
+    }
+  }
+  return [x, y];
+}
+function confineTooltipPosition(x, y, content, viewWidth, viewHeight) {
+  var size = content.getSize();
+  var width = size[0];
+  var height = size[1];
+  x = Math.min(x + width, viewWidth) - width;
+  y = Math.min(y + height, viewHeight) - height;
+  x = Math.max(x, 0);
+  y = Math.max(y, 0);
+  return [x, y];
+}
+function calcTooltipPosition(position, rect, contentSize, borderWidth) {
+  var domWidth = contentSize[0];
+  var domHeight = contentSize[1];
+  var offset = Math.ceil(Math.SQRT2 * borderWidth) + 8;
+  var x = 0;
+  var y = 0;
+  var rectWidth = rect.width;
+  var rectHeight = rect.height;
+  switch (position) {
+    case "inside":
+      x = rect.x + rectWidth / 2 - domWidth / 2;
+      y = rect.y + rectHeight / 2 - domHeight / 2;
+      break;
+    case "top":
+      x = rect.x + rectWidth / 2 - domWidth / 2;
+      y = rect.y - domHeight - offset;
+      break;
+    case "bottom":
+      x = rect.x + rectWidth / 2 - domWidth / 2;
+      y = rect.y + rectHeight + offset;
+      break;
+    case "left":
+      x = rect.x - domWidth - offset;
+      y = rect.y + rectHeight / 2 - domHeight / 2;
+      break;
+    case "right":
+      x = rect.x + rectWidth + offset;
+      y = rect.y + rectHeight / 2 - domHeight / 2;
+  }
+  return [x, y];
+}
+function isCenterAlign(align) {
+  return align === "center" || align === "middle";
+}
+function findComponentReference(payload, ecModel, api) {
+  var queryOptionMap = preParseFinder(payload).queryOptionMap;
+  var componentMainType = queryOptionMap.keys()[0];
+  if (!componentMainType || componentMainType === "series") {
+    return;
+  }
+  var queryResult = queryReferringComponents(ecModel, componentMainType, queryOptionMap.get(componentMainType), {
+    useDefault: false,
+    enableAll: false,
+    enableNone: false
+  });
+  var model = queryResult.models[0];
+  if (!model) {
+    return;
+  }
+  var view = api.getViewOfComponentModel(model);
+  var el;
+  view.group.traverse(function(subEl) {
+    var tooltipConfig = getECData(subEl).tooltipConfig;
+    if (tooltipConfig && tooltipConfig.name === payload.name) {
+      el = subEl;
+      return true;
+    }
+  });
+  if (el) {
+    return {
+      componentMainType,
+      componentIndex: model.componentIndex,
+      el
+    };
+  }
+}
+export {
+  TooltipView as default
+};