sun-card-design 1.1.30 → 1.1.31

package/dist/pc/sun-card-design-pc.es2117.js

@@ -1,80 +1,191 @@
-import { isDimensionStacked } from "./sun-card-design-pc.es2035.js";
-import { map, isNumber } from "./sun-card-design-pc.es933.js";
-function prepareDataCoordInfo(coordSys, data, valueOrigin) {
-  var baseAxis = coordSys.getBaseAxis();
-  var valueAxis = coordSys.getOtherAxis(baseAxis);
-  var valueStart = getValueStart(valueAxis, valueOrigin);
-  var baseAxisDim = baseAxis.dim;
-  var valueAxisDim = valueAxis.dim;
-  var valueDim = data.mapDimension(valueAxisDim);
-  var baseDim = data.mapDimension(baseAxisDim);
-  var baseDataOffset = valueAxisDim === "x" || valueAxisDim === "radius" ? 1 : 0;
-  var dims = map(coordSys.dimensions, function(coordDim) {
-    return data.mapDimension(coordDim);
-  });
-  var stacked = false;
-  var stackResultDim = data.getCalculationInfo("stackResultDimension");
-  if (isDimensionStacked(
-    data,
-    dims[0]
-    /* , dims[1] */
-  )) {
-    stacked = true;
-    dims[0] = stackResultDim;
-  }
-  if (isDimensionStacked(
-    data,
-    dims[1]
-    /* , dims[0] */
-  )) {
-    stacked = true;
-    dims[1] = stackResultDim;
-  }
-  return {
-    dataDimsForPoint: dims,
-    valueStart,
-    valueAxisDim,
-    baseAxisDim,
-    stacked: !!stacked,
-    valueDim,
-    baseDim,
-    baseDataOffset,
-    stackedOverDimension: data.getCalculationInfo("stackedOverDimension")
-  };
-}
-function getValueStart(valueAxis, valueOrigin) {
-  var valueStart = 0;
-  var extent = valueAxis.scale.getExtent();
-  if (valueOrigin === "start") {
-    valueStart = extent[0];
-  } else if (valueOrigin === "end") {
-    valueStart = extent[1];
-  } else if (isNumber(valueOrigin) && !isNaN(valueOrigin)) {
-    valueStart = valueOrigin;
-  } else {
-    if (extent[0] > 0) {
-      valueStart = extent[0];
-    } else if (extent[1] < 0) {
-      valueStart = extent[1];
+import { __extends } from "./sun-card-design-pc.es1814.js";
+import { round, getPrecision } from "./sun-card-design-pc.es1982.js";
+import { addCommas } from "./sun-card-design-pc.es1929.js";
+import Scale from "./sun-card-design-pc.es2192.js";
+import { contain, normalize, scale, getIntervalPrecision, intervalScaleNiceTicks } from "./sun-card-design-pc.es2101.js";
+var roundNumber = round;
+var IntervalScale = (
+  /** @class */
+  (function(_super) {
+    __extends(IntervalScale2, _super);
+    function IntervalScale2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "interval";
+      _this._interval = 0;
+      _this._intervalPrecision = 2;
+      return _this;
     }
-  }
-  return valueStart;
-}
-function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
-  var value = NaN;
-  if (dataCoordInfo.stacked) {
-    value = data.get(data.getCalculationInfo("stackedOverDimension"), idx);
-  }
-  if (isNaN(value)) {
-    value = dataCoordInfo.valueStart;
-  }
-  var baseDataOffset = dataCoordInfo.baseDataOffset;
-  var stackedData = [];
-  stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
-  stackedData[1 - baseDataOffset] = value;
-  return coordSys.dataToPoint(stackedData);
-}
+    IntervalScale2.prototype.parse = function(val) {
+      return val;
+    };
+    IntervalScale2.prototype.contain = function(val) {
+      return contain(val, this._extent);
+    };
+    IntervalScale2.prototype.normalize = function(val) {
+      return normalize(val, this._extent);
+    };
+    IntervalScale2.prototype.scale = function(val) {
+      return scale(val, this._extent);
+    };
+    IntervalScale2.prototype.setExtent = function(start, end) {
+      var thisExtent = this._extent;
+      if (!isNaN(start)) {
+        thisExtent[0] = parseFloat(start);
+      }
+      if (!isNaN(end)) {
+        thisExtent[1] = parseFloat(end);
+      }
+    };
+    IntervalScale2.prototype.unionExtent = function(other) {
+      var extent = this._extent;
+      other[0] < extent[0] && (extent[0] = other[0]);
+      other[1] > extent[1] && (extent[1] = other[1]);
+      this.setExtent(extent[0], extent[1]);
+    };
+    IntervalScale2.prototype.getInterval = function() {
+      return this._interval;
+    };
+    IntervalScale2.prototype.setInterval = function(interval) {
+      this._interval = interval;
+      this._niceExtent = this._extent.slice();
+      this._intervalPrecision = getIntervalPrecision(interval);
+    };
+    IntervalScale2.prototype.getTicks = function(expandToNicedExtent) {
+      var interval = this._interval;
+      var extent = this._extent;
+      var niceTickExtent = this._niceExtent;
+      var intervalPrecision = this._intervalPrecision;
+      var ticks = [];
+      if (!interval) {
+        return ticks;
+      }
+      var safeLimit = 1e4;
+      if (extent[0] < niceTickExtent[0]) {
+        if (expandToNicedExtent) {
+          ticks.push({
+            value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
+          });
+        } else {
+          ticks.push({
+            value: extent[0]
+          });
+        }
+      }
+      var tick = niceTickExtent[0];
+      while (tick <= niceTickExtent[1]) {
+        ticks.push({
+          value: tick
+        });
+        tick = roundNumber(tick + interval, intervalPrecision);
+        if (tick === ticks[ticks.length - 1].value) {
+          break;
+        }
+        if (ticks.length > safeLimit) {
+          return [];
+        }
+      }
+      var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
+      if (extent[1] > lastNiceTick) {
+        if (expandToNicedExtent) {
+          ticks.push({
+            value: roundNumber(lastNiceTick + interval, intervalPrecision)
+          });
+        } else {
+          ticks.push({
+            value: extent[1]
+          });
+        }
+      }
+      return ticks;
+    };
+    IntervalScale2.prototype.getMinorTicks = function(splitNumber) {
+      var ticks = this.getTicks(true);
+      var minorTicks = [];
+      var extent = this.getExtent();
+      for (var i = 1; i < ticks.length; i++) {
+        var nextTick = ticks[i];
+        var prevTick = ticks[i - 1];
+        var count = 0;
+        var minorTicksGroup = [];
+        var interval = nextTick.value - prevTick.value;
+        var minorInterval = interval / splitNumber;
+        while (count < splitNumber - 1) {
+          var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
+          if (minorTick > extent[0] && minorTick < extent[1]) {
+            minorTicksGroup.push(minorTick);
+          }
+          count++;
+        }
+        minorTicks.push(minorTicksGroup);
+      }
+      return minorTicks;
+    };
+    IntervalScale2.prototype.getLabel = function(data, opt) {
+      if (data == null) {
+        return "";
+      }
+      var precision = opt && opt.precision;
+      if (precision == null) {
+        precision = getPrecision(data.value) || 0;
+      } else if (precision === "auto") {
+        precision = this._intervalPrecision;
+      }
+      var dataNum = roundNumber(data.value, precision, true);
+      return addCommas(dataNum);
+    };
+    IntervalScale2.prototype.calcNiceTicks = function(splitNumber, minInterval, maxInterval) {
+      splitNumber = splitNumber || 5;
+      var extent = this._extent;
+      var span = extent[1] - extent[0];
+      if (!isFinite(span)) {
+        return;
+      }
+      if (span < 0) {
+        span = -span;
+        extent.reverse();
+      }
+      var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
+      this._intervalPrecision = result.intervalPrecision;
+      this._interval = result.interval;
+      this._niceExtent = result.niceTickExtent;
+    };
+    IntervalScale2.prototype.calcNiceExtent = function(opt) {
+      var extent = this._extent;
+      if (extent[0] === extent[1]) {
+        if (extent[0] !== 0) {
+          var expandSize = Math.abs(extent[0]);
+          if (!opt.fixMax) {
+            extent[1] += expandSize / 2;
+            extent[0] -= expandSize / 2;
+          } else {
+            extent[0] -= expandSize / 2;
+          }
+        } else {
+          extent[1] = 1;
+        }
+      }
+      var span = extent[1] - extent[0];
+      if (!isFinite(span)) {
+        extent[0] = 0;
+        extent[1] = 1;
+      }
+      this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+      var interval = this._interval;
+      if (!opt.fixMin) {
+        extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
+      }
+      if (!opt.fixMax) {
+        extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
+      }
+    };
+    IntervalScale2.prototype.setNiceExtent = function(min, max) {
+      this._niceExtent = [min, max];
+    };
+    IntervalScale2.type = "interval";
+    return IntervalScale2;
+  })(Scale)
+);
+Scale.registerClass(IntervalScale);
 export {
-  getStackedOnPoint,
-  prepareDataCoordInfo
+  IntervalScale as default
 };

package/dist/pc/sun-card-design-pc.es2118.js

@@ -1,104 +1,299 @@
-import { round } from "./sun-card-design-pc.es1977.js";
-import { isFunction } from "./sun-card-design-pc.es933.js";
-import Rect from "./sun-card-design-pc.es1759.js";
-import Sector from "./sun-card-design-pc.es1984.js";
-import { initProps } from "./sun-card-design-pc.es1762.js";
-function createGridClipPath(cartesian, hasAnimation, seriesModel, done, during) {
-  var rect = cartesian.getArea();
-  var x = rect.x;
-  var y = rect.y;
-  var width = rect.width;
-  var height = rect.height;
-  var lineWidth = seriesModel.get(["lineStyle", "width"]) || 0;
-  x -= lineWidth / 2;
-  y -= lineWidth / 2;
-  width += lineWidth;
-  height += lineWidth;
-  width = Math.ceil(width);
-  if (x !== Math.floor(x)) {
-    x = Math.floor(x);
-    width++;
+import { isString, isDom, isFunction, isArray, each, bind, indexOf, retrieve2 } from "./sun-card-design-pc.es932.js";
+import { normalizeEvent } from "./sun-card-design-pc.es2081.js";
+import { transformLocalCoord } from "./sun-card-design-pc.es2124.js";
+import env from "./sun-card-design-pc.es1815.js";
+import { convertToColorString, toCamelCase, normalizeCssArray } from "./sun-card-design-pc.es1929.js";
+import { toCSSVendorPrefix, getComputedStyle, shouldTooltipConfine, TRANSFORM_VENDOR, TRANSITION_VENDOR } from "./sun-card-design-pc.es2123.js";
+import { getPaddingFromTooltipModel } from "./sun-card-design-pc.es1997.js";
+var CSS_TRANSITION_VENDOR = toCSSVendorPrefix(TRANSITION_VENDOR, "transition");
+var CSS_TRANSFORM_VENDOR = toCSSVendorPrefix(TRANSFORM_VENDOR, "transform");
+var gCssText = "position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;" + (env.transform3dSupported ? "will-change:transform;" : "");
+function mirrorPos(pos) {
+  pos = pos === "left" ? "right" : pos === "right" ? "left" : pos === "top" ? "bottom" : "top";
+  return pos;
+}
+function assembleArrow(tooltipModel, borderColor, arrowPosition) {
+  if (!isString(arrowPosition) || arrowPosition === "inside") {
+    return "";
   }
-  var clipPath = new Rect({
-    shape: {
-      x,
-      y,
-      width,
-      height
-    }
-  });
-  if (hasAnimation) {
-    var baseAxis = cartesian.getBaseAxis();
-    var isHorizontal = baseAxis.isHorizontal();
-    var isAxisInversed = baseAxis.inverse;
-    if (isHorizontal) {
-      if (isAxisInversed) {
-        clipPath.shape.x += width;
-      }
-      clipPath.shape.width = 0;
-    } else {
-      if (!isAxisInversed) {
-        clipPath.shape.y += height;
-      }
-      clipPath.shape.height = 0;
-    }
-    var duringCb = isFunction(during) ? function(percent) {
-      during(percent, clipPath);
-    } : null;
-    initProps(clipPath, {
-      shape: {
-        width,
-        height,
-        x,
-        y
-      }
-    }, seriesModel, null, done, duringCb);
+  var backgroundColor = tooltipModel.get("backgroundColor");
+  var borderWidth = tooltipModel.get("borderWidth");
+  borderColor = convertToColorString(borderColor);
+  var arrowPos = mirrorPos(arrowPosition);
+  var arrowSize = Math.max(Math.round(borderWidth) * 1.5, 6);
+  var positionStyle = "";
+  var transformStyle = CSS_TRANSFORM_VENDOR + ":";
+  var rotateDeg;
+  if (indexOf(["left", "right"], arrowPos) > -1) {
+    positionStyle += "top:50%";
+    transformStyle += "translateY(-50%) rotate(" + (rotateDeg = arrowPos === "left" ? -225 : -45) + "deg)";
+  } else {
+    positionStyle += "left:50%";
+    transformStyle += "translateX(-50%) rotate(" + (rotateDeg = arrowPos === "top" ? 225 : 45) + "deg)";
   }
-  return clipPath;
+  var rotateRadian = rotateDeg * Math.PI / 180;
+  var arrowWH = arrowSize + borderWidth;
+  var rotatedWH = arrowWH * Math.abs(Math.cos(rotateRadian)) + arrowWH * Math.abs(Math.sin(rotateRadian));
+  var arrowOffset = Math.round(((rotatedWH - Math.SQRT2 * borderWidth) / 2 + Math.SQRT2 * borderWidth - (rotatedWH - arrowWH) / 2) * 100) / 100;
+  positionStyle += ";" + arrowPos + ":-" + arrowOffset + "px";
+  var borderStyle = borderColor + " solid " + borderWidth + "px;";
+  var styleCss = ["position:absolute;width:" + arrowSize + "px;height:" + arrowSize + "px;z-index:-1;", positionStyle + ";" + transformStyle + ";", "border-bottom:" + borderStyle, "border-right:" + borderStyle, "background-color:" + backgroundColor + ";"];
+  return '<div style="' + styleCss.join("") + '"></div>';
 }
-function createPolarClipPath(polar, hasAnimation, seriesModel) {
-  var sectorArea = polar.getArea();
-  var r0 = round(sectorArea.r0, 1);
-  var r = round(sectorArea.r, 1);
-  var clipPath = new Sector({
-    shape: {
-      cx: round(polar.cx, 1),
-      cy: round(polar.cy, 1),
-      r0,
-      r,
-      startAngle: sectorArea.startAngle,
-      endAngle: sectorArea.endAngle,
-      clockwise: sectorArea.clockwise
-    }
+function assembleTransition(duration, onlyFade) {
+  var transitionCurve = "cubic-bezier(0.23,1,0.32,1)";
+  var transitionOption = " " + duration / 2 + "s " + transitionCurve;
+  var transitionText = "opacity" + transitionOption + ",visibility" + transitionOption;
+  if (!onlyFade) {
+    transitionOption = " " + duration + "s " + transitionCurve;
+    transitionText += env.transformSupported ? "," + CSS_TRANSFORM_VENDOR + transitionOption : ",left" + transitionOption + ",top" + transitionOption;
+  }
+  return CSS_TRANSITION_VENDOR + ":" + transitionText;
+}
+function assembleTransform(x, y, toString) {
+  var x0 = x.toFixed(0) + "px";
+  var y0 = y.toFixed(0) + "px";
+  if (!env.transformSupported) {
+    return toString ? "top:" + y0 + ";left:" + x0 + ";" : [["top", y0], ["left", x0]];
+  }
+  var is3d = env.transform3dSupported;
+  var translate = "translate" + (is3d ? "3d" : "") + "(" + x0 + "," + y0 + (is3d ? ",0" : "") + ")";
+  return toString ? "top:0;left:0;" + CSS_TRANSFORM_VENDOR + ":" + translate + ";" : [["top", 0], ["left", 0], [TRANSFORM_VENDOR, translate]];
+}
+function assembleFont(textStyleModel) {
+  var cssText = [];
+  var fontSize = textStyleModel.get("fontSize");
+  var color = textStyleModel.getTextColor();
+  color && cssText.push("color:" + color);
+  cssText.push("font:" + textStyleModel.getFont());
+  var lineHeight = retrieve2(textStyleModel.get("lineHeight"), Math.round(fontSize * 3 / 2));
+  fontSize && cssText.push("line-height:" + lineHeight + "px");
+  var shadowColor = textStyleModel.get("textShadowColor");
+  var shadowBlur = textStyleModel.get("textShadowBlur") || 0;
+  var shadowOffsetX = textStyleModel.get("textShadowOffsetX") || 0;
+  var shadowOffsetY = textStyleModel.get("textShadowOffsetY") || 0;
+  shadowColor && shadowBlur && cssText.push("text-shadow:" + shadowOffsetX + "px " + shadowOffsetY + "px " + shadowBlur + "px " + shadowColor);
+  each(["decoration", "align"], function(name) {
+    var val = textStyleModel.get(name);
+    val && cssText.push("text-" + name + ":" + val);
   });
-  if (hasAnimation) {
-    var isRadial = polar.getBaseAxis().dim === "angle";
-    if (isRadial) {
-      clipPath.shape.endAngle = sectorArea.startAngle;
-    } else {
-      clipPath.shape.r = r0;
-    }
-    initProps(clipPath, {
-      shape: {
-        endAngle: sectorArea.endAngle,
-        r
-      }
-    }, seriesModel);
+  return cssText.join(";");
+}
+function assembleCssText(tooltipModel, enableTransition, onlyFade) {
+  var cssText = [];
+  var transitionDuration = tooltipModel.get("transitionDuration");
+  var backgroundColor = tooltipModel.get("backgroundColor");
+  var shadowBlur = tooltipModel.get("shadowBlur");
+  var shadowColor = tooltipModel.get("shadowColor");
+  var shadowOffsetX = tooltipModel.get("shadowOffsetX");
+  var shadowOffsetY = tooltipModel.get("shadowOffsetY");
+  var textStyleModel = tooltipModel.getModel("textStyle");
+  var padding = getPaddingFromTooltipModel(tooltipModel, "html");
+  var boxShadow = shadowOffsetX + "px " + shadowOffsetY + "px " + shadowBlur + "px " + shadowColor;
+  cssText.push("box-shadow:" + boxShadow);
+  enableTransition && transitionDuration && cssText.push(assembleTransition(transitionDuration, onlyFade));
+  if (backgroundColor) {
+    cssText.push("background-color:" + backgroundColor);
   }
-  return clipPath;
+  each(["width", "color", "radius"], function(name) {
+    var borderName = "border-" + name;
+    var camelCase = toCamelCase(borderName);
+    var val = tooltipModel.get(camelCase);
+    val != null && cssText.push(borderName + ":" + val + (name === "color" ? "" : "px"));
+  });
+  cssText.push(assembleFont(textStyleModel));
+  if (padding != null) {
+    cssText.push("padding:" + normalizeCssArray(padding).join("px ") + "px");
+  }
+  return cssText.join(";") + ";";
 }
-function createClipPath(coordSys, hasAnimation, seriesModel, done, during) {
-  if (!coordSys) {
-    return null;
-  } else if (coordSys.type === "polar") {
-    return createPolarClipPath(coordSys, hasAnimation, seriesModel);
-  } else if (coordSys.type === "cartesian2d") {
-    return createGridClipPath(coordSys, hasAnimation, seriesModel, done, during);
+function makeStyleCoord(out, zr, container, zrX, zrY) {
+  var zrPainter = zr && zr.painter;
+  if (container) {
+    var zrViewportRoot = zrPainter && zrPainter.getViewportRoot();
+    if (zrViewportRoot) {
+      transformLocalCoord(out, zrViewportRoot, container, zrX, zrY);
+    }
+  } else {
+    out[0] = zrX;
+    out[1] = zrY;
+    var viewportRootOffset = zrPainter && zrPainter.getViewportRootOffset();
+    if (viewportRootOffset) {
+      out[0] += viewportRootOffset.offsetLeft;
+      out[1] += viewportRootOffset.offsetTop;
+    }
   }
-  return null;
+  out[2] = out[0] / zr.getWidth();
+  out[3] = out[1] / zr.getHeight();
 }
+var TooltipHTMLContent = (
+  /** @class */
+  (function() {
+    function TooltipHTMLContent2(api, opt) {
+      this._show = false;
+      this._styleCoord = [0, 0, 0, 0];
+      this._enterable = true;
+      this._alwaysShowContent = false;
+      this._firstShow = true;
+      this._longHide = true;
+      if (env.wxa) {
+        return null;
+      }
+      var el = document.createElement("div");
+      el.domBelongToZr = true;
+      this.el = el;
+      var zr = this._zr = api.getZr();
+      var appendTo = opt.appendTo;
+      var container = appendTo && (isString(appendTo) ? document.querySelector(appendTo) : isDom(appendTo) ? appendTo : isFunction(appendTo) && appendTo(api.getDom()));
+      makeStyleCoord(this._styleCoord, zr, container, api.getWidth() / 2, api.getHeight() / 2);
+      (container || api.getDom()).appendChild(el);
+      this._api = api;
+      this._container = container;
+      var self = this;
+      el.onmouseenter = function() {
+        if (self._enterable) {
+          clearTimeout(self._hideTimeout);
+          self._show = true;
+        }
+        self._inContent = true;
+      };
+      el.onmousemove = function(e) {
+        e = e || window.event;
+        if (!self._enterable) {
+          var handler = zr.handler;
+          var zrViewportRoot = zr.painter.getViewportRoot();
+          normalizeEvent(zrViewportRoot, e, true);
+          handler.dispatch("mousemove", e);
+        }
+      };
+      el.onmouseleave = function() {
+        self._inContent = false;
+        if (self._enterable) {
+          if (self._show) {
+            self.hideLater(self._hideDelay);
+          }
+        }
+      };
+    }
+    TooltipHTMLContent2.prototype.update = function(tooltipModel) {
+      if (!this._container) {
+        var container = this._api.getDom();
+        var position = getComputedStyle(container, "position");
+        var domStyle = container.style;
+        if (domStyle.position !== "absolute" && position !== "absolute") {
+          domStyle.position = "relative";
+        }
+      }
+      var alwaysShowContent = tooltipModel.get("alwaysShowContent");
+      alwaysShowContent && this._moveIfResized();
+      this._alwaysShowContent = alwaysShowContent;
+      this.el.className = tooltipModel.get("className") || "";
+    };
+    TooltipHTMLContent2.prototype.show = function(tooltipModel, nearPointColor) {
+      clearTimeout(this._hideTimeout);
+      clearTimeout(this._longHideTimeout);
+      var el = this.el;
+      var style = el.style;
+      var styleCoord = this._styleCoord;
+      if (!el.innerHTML) {
+        style.display = "none";
+      } else {
+        style.cssText = gCssText + assembleCssText(tooltipModel, !this._firstShow, this._longHide) + assembleTransform(styleCoord[0], styleCoord[1], true) + ("border-color:" + convertToColorString(nearPointColor) + ";") + (tooltipModel.get("extraCssText") || "") + (";pointer-events:" + (this._enterable ? "auto" : "none"));
+      }
+      this._show = true;
+      this._firstShow = false;
+      this._longHide = false;
+    };
+    TooltipHTMLContent2.prototype.setContent = function(content, markers, tooltipModel, borderColor, arrowPosition) {
+      var el = this.el;
+      if (content == null) {
+        el.innerHTML = "";
+        return;
+      }
+      var arrow = "";
+      if (isString(arrowPosition) && tooltipModel.get("trigger") === "item" && !shouldTooltipConfine(tooltipModel)) {
+        arrow = assembleArrow(tooltipModel, borderColor, arrowPosition);
+      }
+      if (isString(content)) {
+        el.innerHTML = content + arrow;
+      } else if (content) {
+        el.innerHTML = "";
+        if (!isArray(content)) {
+          content = [content];
+        }
+        for (var i = 0; i < content.length; i++) {
+          if (isDom(content[i]) && content[i].parentNode !== el) {
+            el.appendChild(content[i]);
+          }
+        }
+        if (arrow && el.childNodes.length) {
+          var arrowEl = document.createElement("div");
+          arrowEl.innerHTML = arrow;
+          el.appendChild(arrowEl);
+        }
+      }
+    };
+    TooltipHTMLContent2.prototype.setEnterable = function(enterable) {
+      this._enterable = enterable;
+    };
+    TooltipHTMLContent2.prototype.getSize = function() {
+      var el = this.el;
+      return el ? [el.offsetWidth, el.offsetHeight] : [0, 0];
+    };
+    TooltipHTMLContent2.prototype.moveTo = function(zrX, zrY) {
+      if (!this.el) {
+        return;
+      }
+      var styleCoord = this._styleCoord;
+      makeStyleCoord(styleCoord, this._zr, this._container, zrX, zrY);
+      if (styleCoord[0] != null && styleCoord[1] != null) {
+        var style_1 = this.el.style;
+        var transforms = assembleTransform(styleCoord[0], styleCoord[1]);
+        each(transforms, function(transform) {
+          style_1[transform[0]] = transform[1];
+        });
+      }
+    };
+    TooltipHTMLContent2.prototype._moveIfResized = function() {
+      var ratioX = this._styleCoord[2];
+      var ratioY = this._styleCoord[3];
+      this.moveTo(ratioX * this._zr.getWidth(), ratioY * this._zr.getHeight());
+    };
+    TooltipHTMLContent2.prototype.hide = function() {
+      var _this = this;
+      var style = this.el.style;
+      style.visibility = "hidden";
+      style.opacity = "0";
+      env.transform3dSupported && (style.willChange = "");
+      this._show = false;
+      this._longHideTimeout = setTimeout(function() {
+        return _this._longHide = true;
+      }, 500);
+    };
+    TooltipHTMLContent2.prototype.hideLater = function(time) {
+      if (this._show && !(this._inContent && this._enterable) && !this._alwaysShowContent) {
+        if (time) {
+          this._hideDelay = time;
+          this._show = false;
+          this._hideTimeout = setTimeout(bind(this.hide, this), time);
+        } else {
+          this.hide();
+        }
+      }
+    };
+    TooltipHTMLContent2.prototype.isShow = function() {
+      return this._show;
+    };
+    TooltipHTMLContent2.prototype.dispose = function() {
+      clearTimeout(this._hideTimeout);
+      clearTimeout(this._longHideTimeout);
+      var parentNode = this.el.parentNode;
+      parentNode && parentNode.removeChild(this.el);
+      this.el = this._container = null;
+    };
+    return TooltipHTMLContent2;
+  })()
+);
 export {
-  createClipPath,
-  createGridClipPath,
-  createPolarClipPath
+  TooltipHTMLContent as default
 };