sun-card-design 1.1.16 → 1.1.18

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

@@ -1,268 +1,507 @@
-import { each, indexOf, createHashMap, curry, assert, map } from "./sun-card-design-pc.es922.js";
-import { getTransform } from "./sun-card-design-pc.es1756.js";
-import { makeLinearBrushOtherExtent, makeRectIsTargetByCursor, makeRectPanelClipPath } from "./sun-card-design-pc.es2103.js";
-import { parseFinder as parseFinder$1 } from "./sun-card-design-pc.es1729.js";
-var INCLUDE_FINDER_MAIN_TYPES = ["grid", "xAxis", "yAxis", "geo", "graph", "polar", "radiusAxis", "angleAxis", "bmap"];
-var BrushTargetManager = (
+import { defaults, retrieve, map, extend, isString, each, isObject, retrieve2, isFunction, isNumber } from "./sun-card-design-pc.es922.js";
+import { setTooltipConfig, subPixelOptimizeLine } from "./sun-card-design-pc.es1757.js";
+import { getECData } from "./sun-card-design-pc.es1727.js";
+import { createTextStyle } from "./sun-card-design-pc.es1918.js";
+import Model from "./sun-card-design-pc.es1758.js";
+import { remRadian, isRadianAroundZero } from "./sun-card-design-pc.es1976.js";
+import { normalizeSymbolOffset, createSymbol } from "./sun-card-design-pc.es2020.js";
+import { identity, rotate, mul } from "./sun-card-design-pc.es1966.js";
+import { applyTransform } from "./sun-card-design-pc.es1967.js";
+import { shouldShowAllLabels } from "./sun-card-design-pc.es2094.js";
+import { prepareLayoutList, hideOverlap } from "./sun-card-design-pc.es1987.js";
+import Group from "./sun-card-design-pc.es1753.js";
+import ZRText from "./sun-card-design-pc.es1920.js";
+import Line from "./sun-card-design-pc.es1999.js";
+var PI = Math.PI;
+var AxisBuilder = (
   /** @class */
   (function() {
-    function BrushTargetManager2(finder, ecModel, opt) {
-      var _this = this;
-      this._targetInfoList = [];
-      var foundCpts = parseFinder(ecModel, finder);
-      each(targetInfoBuilders, function(builder, type) {
-        if (!opt || !opt.include || indexOf(opt.include, type) >= 0) {
-          builder(foundCpts, _this._targetInfoList);
+    function AxisBuilder2(axisModel, opt) {
+      this.group = new Group();
+      this.opt = opt;
+      this.axisModel = axisModel;
+      defaults(opt, {
+        labelOffset: 0,
+        nameDirection: 1,
+        tickDirection: 1,
+        labelDirection: 1,
+        silent: true,
+        handleAutoShown: function() {
+          return true;
         }
       });
-    }
-    BrushTargetManager2.prototype.setOutputRanges = function(areas, ecModel) {
-      this.matchOutputRanges(areas, ecModel, function(area, coordRange, coordSys) {
-        (area.coordRanges || (area.coordRanges = [])).push(coordRange);
-        if (!area.coordRange) {
-          area.coordRange = coordRange;
-          var result = coordConvert[area.brushType](0, coordSys, coordRange);
-          area.__rangeOffset = {
-            offset: diffProcessor[area.brushType](result.values, area.range, [1, 1]),
-            xyMinMax: result.xyMinMax
-          };
-        }
+      var transformGroup = new Group({
+        x: opt.position[0],
+        y: opt.position[1],
+        rotation: opt.rotation
       });
-      return areas;
+      transformGroup.updateTransform();
+      this._transformGroup = transformGroup;
+    }
+    AxisBuilder2.prototype.hasBuilder = function(name) {
+      return !!builders[name];
     };
-    BrushTargetManager2.prototype.matchOutputRanges = function(areas, ecModel, cb) {
-      each(areas, function(area) {
-        var targetInfo = this.findTargetInfo(area, ecModel);
-        if (targetInfo && targetInfo !== true) {
-          each(targetInfo.coordSyses, function(coordSys) {
-            var result = coordConvert[area.brushType](1, coordSys, area.range, true);
-            cb(area, result.values, coordSys, ecModel);
-          });
-        }
-      }, this);
+    AxisBuilder2.prototype.add = function(name) {
+      builders[name](this.opt, this.axisModel, this.group, this._transformGroup);
     };
-    BrushTargetManager2.prototype.setInputRanges = function(areas, ecModel) {
-      each(areas, function(area) {
-        var targetInfo = this.findTargetInfo(area, ecModel);
-        if (process.env.NODE_ENV !== "production") {
-          assert(!targetInfo || targetInfo === true || area.coordRange, "coordRange must be specified when coord index specified.");
-          assert(!targetInfo || targetInfo !== true || area.range, "range must be specified in global brush.");
-        }
-        area.range = area.range || [];
-        if (targetInfo && targetInfo !== true) {
-          area.panelId = targetInfo.panelId;
-          var result = coordConvert[area.brushType](0, targetInfo.coordSys, area.coordRange);
-          var rangeOffset = area.__rangeOffset;
-          area.range = rangeOffset ? diffProcessor[area.brushType](result.values, rangeOffset.offset, getScales(result.xyMinMax, rangeOffset.xyMinMax)) : result.values;
-        }
-      }, this);
-    };
-    BrushTargetManager2.prototype.makePanelOpts = function(api, getDefaultBrushType) {
-      return map(this._targetInfoList, function(targetInfo) {
-        var rect = targetInfo.getPanelRect();
-        return {
-          panelId: targetInfo.panelId,
-          defaultBrushType: getDefaultBrushType ? getDefaultBrushType(targetInfo) : null,
-          clipPath: makeRectPanelClipPath(rect),
-          isTargetByCursor: makeRectIsTargetByCursor(rect, api, targetInfo.coordSysModel),
-          getLinearBrushOtherExtent: makeLinearBrushOtherExtent(rect)
-        };
-      });
+    AxisBuilder2.prototype.getGroup = function() {
+      return this.group;
     };
-    BrushTargetManager2.prototype.controlSeries = function(area, seriesModel, ecModel) {
-      var targetInfo = this.findTargetInfo(area, ecModel);
-      return targetInfo === true || targetInfo && indexOf(targetInfo.coordSyses, seriesModel.coordinateSystem) >= 0;
-    };
-    BrushTargetManager2.prototype.findTargetInfo = function(area, ecModel) {
-      var targetInfoList = this._targetInfoList;
-      var foundCpts = parseFinder(ecModel, area);
-      for (var i = 0; i < targetInfoList.length; i++) {
-        var targetInfo = targetInfoList[i];
-        var areaPanelId = area.panelId;
-        if (areaPanelId) {
-          if (targetInfo.panelId === areaPanelId) {
-            return targetInfo;
-          }
+    AxisBuilder2.innerTextLayout = function(axisRotation, textRotation, direction) {
+      var rotationDiff = remRadian(textRotation - axisRotation);
+      var textAlign;
+      var textVerticalAlign;
+      if (isRadianAroundZero(rotationDiff)) {
+        textVerticalAlign = direction > 0 ? "top" : "bottom";
+        textAlign = "center";
+      } else if (isRadianAroundZero(rotationDiff - PI)) {
+        textVerticalAlign = direction > 0 ? "bottom" : "top";
+        textAlign = "center";
+      } else {
+        textVerticalAlign = "middle";
+        if (rotationDiff > 0 && rotationDiff < PI) {
+          textAlign = direction > 0 ? "right" : "left";
         } else {
-          for (var j = 0; j < targetInfoMatchers.length; j++) {
-            if (targetInfoMatchers[j](foundCpts, targetInfo)) {
-              return targetInfo;
-            }
-          }
+          textAlign = direction > 0 ? "left" : "right";
         }
       }
-      return true;
+      return {
+        rotation: rotationDiff,
+        textAlign,
+        textVerticalAlign
+      };
+    };
+    AxisBuilder2.makeAxisEventDataBase = function(axisModel) {
+      var eventData = {
+        componentType: axisModel.mainType,
+        componentIndex: axisModel.componentIndex
+      };
+      eventData[axisModel.mainType + "Index"] = axisModel.componentIndex;
+      return eventData;
+    };
+    AxisBuilder2.isLabelSilent = function(axisModel) {
+      var tooltipOpt = axisModel.get("tooltip");
+      return axisModel.get("silent") || !(axisModel.get("triggerEvent") || tooltipOpt && tooltipOpt.show);
     };
-    return BrushTargetManager2;
+    return AxisBuilder2;
   })()
 );
-function formatMinMax(minMax) {
-  minMax[0] > minMax[1] && minMax.reverse();
-  return minMax;
-}
-function parseFinder(ecModel, finder) {
-  return parseFinder$1(ecModel, finder, {
-    includeMainTypes: INCLUDE_FINDER_MAIN_TYPES
-  });
-}
-var targetInfoBuilders = {
-  grid: function(foundCpts, targetInfoList) {
-    var xAxisModels = foundCpts.xAxisModels;
-    var yAxisModels = foundCpts.yAxisModels;
-    var gridModels = foundCpts.gridModels;
-    var gridModelMap = createHashMap();
-    var xAxesHas = {};
-    var yAxesHas = {};
-    if (!xAxisModels && !yAxisModels && !gridModels) {
+var builders = {
+  axisLine: function(opt, axisModel, group, transformGroup) {
+    var shown = axisModel.get(["axisLine", "show"]);
+    if (shown === "auto" && opt.handleAutoShown) {
+      shown = opt.handleAutoShown("axisLine");
+    }
+    if (!shown) {
       return;
     }
-    each(xAxisModels, function(axisModel) {
-      var gridModel = axisModel.axis.grid.model;
-      gridModelMap.set(gridModel.id, gridModel);
-      xAxesHas[gridModel.id] = true;
-    });
-    each(yAxisModels, function(axisModel) {
-      var gridModel = axisModel.axis.grid.model;
-      gridModelMap.set(gridModel.id, gridModel);
-      yAxesHas[gridModel.id] = true;
-    });
-    each(gridModels, function(gridModel) {
-      gridModelMap.set(gridModel.id, gridModel);
-      xAxesHas[gridModel.id] = true;
-      yAxesHas[gridModel.id] = true;
+    var extent = axisModel.axis.getExtent();
+    var matrix = transformGroup.transform;
+    var pt1 = [extent[0], 0];
+    var pt2 = [extent[1], 0];
+    var inverse = pt1[0] > pt2[0];
+    if (matrix) {
+      applyTransform(pt1, pt1, matrix);
+      applyTransform(pt2, pt2, matrix);
+    }
+    var lineStyle = extend({
+      lineCap: "round"
+    }, axisModel.getModel(["axisLine", "lineStyle"]).getLineStyle());
+    var line = new Line({
+      shape: {
+        x1: pt1[0],
+        y1: pt1[1],
+        x2: pt2[0],
+        y2: pt2[1]
+      },
+      style: lineStyle,
+      strokeContainThreshold: opt.strokeContainThreshold || 5,
+      silent: true,
+      z2: 1
     });
-    gridModelMap.each(function(gridModel) {
-      var grid = gridModel.coordinateSystem;
-      var cartesians = [];
-      each(grid.getCartesians(), function(cartesian, index) {
-        if (indexOf(xAxisModels, cartesian.getAxis("x").model) >= 0 || indexOf(yAxisModels, cartesian.getAxis("y").model) >= 0) {
-          cartesians.push(cartesian);
+    subPixelOptimizeLine(line.shape, line.style.lineWidth);
+    line.anid = "line";
+    group.add(line);
+    var arrows = axisModel.get(["axisLine", "symbol"]);
+    if (arrows != null) {
+      var arrowSize = axisModel.get(["axisLine", "symbolSize"]);
+      if (isString(arrows)) {
+        arrows = [arrows, arrows];
+      }
+      if (isString(arrowSize) || isNumber(arrowSize)) {
+        arrowSize = [arrowSize, arrowSize];
+      }
+      var arrowOffset = normalizeSymbolOffset(axisModel.get(["axisLine", "symbolOffset"]) || 0, arrowSize);
+      var symbolWidth_1 = arrowSize[0];
+      var symbolHeight_1 = arrowSize[1];
+      each([{
+        rotate: opt.rotation + Math.PI / 2,
+        offset: arrowOffset[0],
+        r: 0
+      }, {
+        rotate: opt.rotation - Math.PI / 2,
+        offset: arrowOffset[1],
+        r: Math.sqrt((pt1[0] - pt2[0]) * (pt1[0] - pt2[0]) + (pt1[1] - pt2[1]) * (pt1[1] - pt2[1]))
+      }], function(point, index) {
+        if (arrows[index] !== "none" && arrows[index] != null) {
+          var symbol = createSymbol(arrows[index], -symbolWidth_1 / 2, -symbolHeight_1 / 2, symbolWidth_1, symbolHeight_1, lineStyle.stroke, true);
+          var r = point.r + point.offset;
+          var pt = inverse ? pt2 : pt1;
+          symbol.attr({
+            rotation: point.rotate,
+            x: pt[0] + r * Math.cos(opt.rotation),
+            y: pt[1] - r * Math.sin(opt.rotation),
+            silent: true,
+            z2: 11
+          });
+          group.add(symbol);
         }
       });
-      targetInfoList.push({
-        panelId: "grid--" + gridModel.id,
-        gridModel,
-        coordSysModel: gridModel,
-        // Use the first one as the representitive coordSys.
-        coordSys: cartesians[0],
-        coordSyses: cartesians,
-        getPanelRect: panelRectBuilders.grid,
-        xAxisDeclared: xAxesHas[gridModel.id],
-        yAxisDeclared: yAxesHas[gridModel.id]
-      });
-    });
-  },
-  geo: function(foundCpts, targetInfoList) {
-    each(foundCpts.geoModels, function(geoModel) {
-      var coordSys = geoModel.coordinateSystem;
-      targetInfoList.push({
-        panelId: "geo--" + geoModel.id,
-        geoModel,
-        coordSysModel: geoModel,
-        coordSys,
-        coordSyses: [coordSys],
-        getPanelRect: panelRectBuilders.geo
-      });
-    });
-  }
-};
-var targetInfoMatchers = [
-  // grid
-  function(foundCpts, targetInfo) {
-    var xAxisModel = foundCpts.xAxisModel;
-    var yAxisModel = foundCpts.yAxisModel;
-    var gridModel = foundCpts.gridModel;
-    !gridModel && xAxisModel && (gridModel = xAxisModel.axis.grid.model);
-    !gridModel && yAxisModel && (gridModel = yAxisModel.axis.grid.model);
-    return gridModel && gridModel === targetInfo.gridModel;
-  },
-  // geo
-  function(foundCpts, targetInfo) {
-    var geoModel = foundCpts.geoModel;
-    return geoModel && geoModel === targetInfo.geoModel;
-  }
-];
-var panelRectBuilders = {
-  grid: function() {
-    return this.coordSys.master.getRect().clone();
+    }
   },
-  geo: function() {
-    var coordSys = this.coordSys;
-    var rect = coordSys.getBoundingRect().clone();
-    rect.applyTransform(getTransform(coordSys));
-    return rect;
-  }
-};
-var coordConvert = {
-  lineX: curry(axisConvert, 0),
-  lineY: curry(axisConvert, 1),
-  rect: function(to, coordSys, rangeOrCoordRange, clamp) {
-    var xminymin = to ? coordSys.pointToData([rangeOrCoordRange[0][0], rangeOrCoordRange[1][0]], clamp) : coordSys.dataToPoint([rangeOrCoordRange[0][0], rangeOrCoordRange[1][0]], clamp);
-    var xmaxymax = to ? coordSys.pointToData([rangeOrCoordRange[0][1], rangeOrCoordRange[1][1]], clamp) : coordSys.dataToPoint([rangeOrCoordRange[0][1], rangeOrCoordRange[1][1]], clamp);
-    var values = [formatMinMax([xminymin[0], xmaxymax[0]]), formatMinMax([xminymin[1], xmaxymax[1]])];
-    return {
-      values,
-      xyMinMax: values
-    };
+  axisTickLabel: function(opt, axisModel, group, transformGroup) {
+    var ticksEls = buildAxisMajorTicks(group, transformGroup, axisModel, opt);
+    var labelEls = buildAxisLabel(group, transformGroup, axisModel, opt);
+    fixMinMaxLabelShow(axisModel, labelEls, ticksEls);
+    buildAxisMinorTicks(group, transformGroup, axisModel, opt.tickDirection);
+    if (axisModel.get(["axisLabel", "hideOverlap"])) {
+      var labelList = prepareLayoutList(map(labelEls, function(label) {
+        return {
+          label,
+          priority: label.z2,
+          defaultAttr: {
+            ignore: label.ignore
+          }
+        };
+      }));
+      hideOverlap(labelList);
+    }
   },
-  polygon: function(to, coordSys, rangeOrCoordRange, clamp) {
-    var xyMinMax = [[Infinity, -Infinity], [Infinity, -Infinity]];
-    var values = map(rangeOrCoordRange, function(item) {
-      var p = to ? coordSys.pointToData(item, clamp) : coordSys.dataToPoint(item, clamp);
-      xyMinMax[0][0] = Math.min(xyMinMax[0][0], p[0]);
-      xyMinMax[1][0] = Math.min(xyMinMax[1][0], p[1]);
-      xyMinMax[0][1] = Math.max(xyMinMax[0][1], p[0]);
-      xyMinMax[1][1] = Math.max(xyMinMax[1][1], p[1]);
-      return p;
+  axisName: function(opt, axisModel, group, transformGroup) {
+    var name = retrieve(opt.axisName, axisModel.get("name"));
+    if (!name) {
+      return;
+    }
+    var nameLocation = axisModel.get("nameLocation");
+    var nameDirection = opt.nameDirection;
+    var textStyleModel = axisModel.getModel("nameTextStyle");
+    var gap = axisModel.get("nameGap") || 0;
+    var extent = axisModel.axis.getExtent();
+    var gapSignal = extent[0] > extent[1] ? -1 : 1;
+    var pos = [
+      nameLocation === "start" ? extent[0] - gapSignal * gap : nameLocation === "end" ? extent[1] + gapSignal * gap : (extent[0] + extent[1]) / 2,
+      // Reuse labelOffset.
+      isNameLocationCenter(nameLocation) ? opt.labelOffset + nameDirection * gap : 0
+    ];
+    var labelLayout;
+    var nameRotation = axisModel.get("nameRotate");
+    if (nameRotation != null) {
+      nameRotation = nameRotation * PI / 180;
+    }
+    var axisNameAvailableWidth;
+    if (isNameLocationCenter(nameLocation)) {
+      labelLayout = AxisBuilder.innerTextLayout(
+        opt.rotation,
+        nameRotation != null ? nameRotation : opt.rotation,
+        // Adapt to axis.
+        nameDirection
+      );
+    } else {
+      labelLayout = endTextLayout(opt.rotation, nameLocation, nameRotation || 0, extent);
+      axisNameAvailableWidth = opt.axisNameAvailableWidth;
+      if (axisNameAvailableWidth != null) {
+        axisNameAvailableWidth = Math.abs(axisNameAvailableWidth / Math.sin(labelLayout.rotation));
+        !isFinite(axisNameAvailableWidth) && (axisNameAvailableWidth = null);
+      }
+    }
+    var textFont = textStyleModel.getFont();
+    var truncateOpt = axisModel.get("nameTruncate", true) || {};
+    var ellipsis = truncateOpt.ellipsis;
+    var maxWidth = retrieve(opt.nameTruncateMaxWidth, truncateOpt.maxWidth, axisNameAvailableWidth);
+    var textEl = new ZRText({
+      x: pos[0],
+      y: pos[1],
+      rotation: labelLayout.rotation,
+      silent: AxisBuilder.isLabelSilent(axisModel),
+      style: createTextStyle(textStyleModel, {
+        text: name,
+        font: textFont,
+        overflow: "truncate",
+        width: maxWidth,
+        ellipsis,
+        fill: textStyleModel.getTextColor() || axisModel.get(["axisLine", "lineStyle", "color"]),
+        align: textStyleModel.get("align") || labelLayout.textAlign,
+        verticalAlign: textStyleModel.get("verticalAlign") || labelLayout.textVerticalAlign
+      }),
+      z2: 1
     });
-    return {
-      values,
-      xyMinMax
-    };
+    setTooltipConfig({
+      el: textEl,
+      componentModel: axisModel,
+      itemName: name
+    });
+    textEl.__fullText = name;
+    textEl.anid = "name";
+    if (axisModel.get("triggerEvent")) {
+      var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
+      eventData.targetType = "axisName";
+      eventData.name = name;
+      getECData(textEl).eventData = eventData;
+    }
+    transformGroup.add(textEl);
+    textEl.updateTransform();
+    group.add(textEl);
+    textEl.decomposeTransform();
   }
 };
-function axisConvert(axisNameIndex, to, coordSys, rangeOrCoordRange) {
-  if (process.env.NODE_ENV !== "production") {
-    assert(coordSys.type === "cartesian2d", "lineX/lineY brush is available only in cartesian2d.");
+function endTextLayout(rotation, textPosition, textRotate, extent) {
+  var rotationDiff = remRadian(textRotate - rotation);
+  var textAlign;
+  var textVerticalAlign;
+  var inverse = extent[0] > extent[1];
+  var onLeft = textPosition === "start" && !inverse || textPosition !== "start" && inverse;
+  if (isRadianAroundZero(rotationDiff - PI / 2)) {
+    textVerticalAlign = onLeft ? "bottom" : "top";
+    textAlign = "center";
+  } else if (isRadianAroundZero(rotationDiff - PI * 1.5)) {
+    textVerticalAlign = onLeft ? "top" : "bottom";
+    textAlign = "center";
+  } else {
+    textVerticalAlign = "middle";
+    if (rotationDiff < PI * 1.5 && rotationDiff > PI / 2) {
+      textAlign = onLeft ? "left" : "right";
+    } else {
+      textAlign = onLeft ? "right" : "left";
+    }
   }
-  var axis = coordSys.getAxis(["x", "y"][axisNameIndex]);
-  var values = formatMinMax(map([0, 1], function(i) {
-    return to ? axis.coordToData(axis.toLocalCoord(rangeOrCoordRange[i]), true) : axis.toGlobalCoord(axis.dataToCoord(rangeOrCoordRange[i]));
-  }));
-  var xyMinMax = [];
-  xyMinMax[axisNameIndex] = values;
-  xyMinMax[1 - axisNameIndex] = [NaN, NaN];
   return {
-    values,
-    xyMinMax
+    rotation: rotationDiff,
+    textAlign,
+    textVerticalAlign
   };
 }
-var diffProcessor = {
-  lineX: curry(axisDiffProcessor, 0),
-  lineY: curry(axisDiffProcessor, 1),
-  rect: function(values, refer, scales) {
-    return [[values[0][0] - scales[0] * refer[0][0], values[0][1] - scales[0] * refer[0][1]], [values[1][0] - scales[1] * refer[1][0], values[1][1] - scales[1] * refer[1][1]]];
-  },
-  polygon: function(values, refer, scales) {
-    return map(values, function(item, idx) {
-      return [item[0] - scales[0] * refer[idx][0], item[1] - scales[1] * refer[idx][1]];
+function fixMinMaxLabelShow(axisModel, labelEls, tickEls) {
+  if (shouldShowAllLabels(axisModel.axis)) {
+    return;
+  }
+  var showMinLabel = axisModel.get(["axisLabel", "showMinLabel"]);
+  var showMaxLabel = axisModel.get(["axisLabel", "showMaxLabel"]);
+  labelEls = labelEls || [];
+  tickEls = tickEls || [];
+  var firstLabel = labelEls[0];
+  var nextLabel = labelEls[1];
+  var lastLabel = labelEls[labelEls.length - 1];
+  var prevLabel = labelEls[labelEls.length - 2];
+  var firstTick = tickEls[0];
+  var nextTick = tickEls[1];
+  var lastTick = tickEls[tickEls.length - 1];
+  var prevTick = tickEls[tickEls.length - 2];
+  if (showMinLabel === false) {
+    ignoreEl(firstLabel);
+    ignoreEl(firstTick);
+  } else if (isTwoLabelOverlapped(firstLabel, nextLabel)) {
+    if (showMinLabel) {
+      ignoreEl(nextLabel);
+      ignoreEl(nextTick);
+    } else {
+      ignoreEl(firstLabel);
+      ignoreEl(firstTick);
+    }
+  }
+  if (showMaxLabel === false) {
+    ignoreEl(lastLabel);
+    ignoreEl(lastTick);
+  } else if (isTwoLabelOverlapped(prevLabel, lastLabel)) {
+    if (showMaxLabel) {
+      ignoreEl(prevLabel);
+      ignoreEl(prevTick);
+    } else {
+      ignoreEl(lastLabel);
+      ignoreEl(lastTick);
+    }
+  }
+}
+function ignoreEl(el) {
+  el && (el.ignore = true);
+}
+function isTwoLabelOverlapped(current, next) {
+  var firstRect = current && current.getBoundingRect().clone();
+  var nextRect = next && next.getBoundingRect().clone();
+  if (!firstRect || !nextRect) {
+    return;
+  }
+  var mRotationBack = identity([]);
+  rotate(mRotationBack, mRotationBack, -current.rotation);
+  firstRect.applyTransform(mul([], mRotationBack, current.getLocalTransform()));
+  nextRect.applyTransform(mul([], mRotationBack, next.getLocalTransform()));
+  return firstRect.intersect(nextRect);
+}
+function isNameLocationCenter(nameLocation) {
+  return nameLocation === "middle" || nameLocation === "center";
+}
+function createTicks(ticksCoords, tickTransform, tickEndCoord, tickLineStyle, anidPrefix) {
+  var tickEls = [];
+  var pt1 = [];
+  var pt2 = [];
+  for (var i = 0; i < ticksCoords.length; i++) {
+    var tickCoord = ticksCoords[i].coord;
+    pt1[0] = tickCoord;
+    pt1[1] = 0;
+    pt2[0] = tickCoord;
+    pt2[1] = tickEndCoord;
+    if (tickTransform) {
+      applyTransform(pt1, pt1, tickTransform);
+      applyTransform(pt2, pt2, tickTransform);
+    }
+    var tickEl = new Line({
+      shape: {
+        x1: pt1[0],
+        y1: pt1[1],
+        x2: pt2[0],
+        y2: pt2[1]
+      },
+      style: tickLineStyle,
+      z2: 2,
+      autoBatch: true,
+      silent: true
     });
+    subPixelOptimizeLine(tickEl.shape, tickEl.style.lineWidth);
+    tickEl.anid = anidPrefix + "_" + ticksCoords[i].tickValue;
+    tickEls.push(tickEl);
   }
-};
-function axisDiffProcessor(axisNameIndex, values, refer, scales) {
-  return [values[0] - scales[axisNameIndex] * refer[0], values[1] - scales[axisNameIndex] * refer[1]];
+  return tickEls;
 }
-function getScales(xyMinMaxCurr, xyMinMaxOrigin) {
-  var sizeCurr = getSize(xyMinMaxCurr);
-  var sizeOrigin = getSize(xyMinMaxOrigin);
-  var scales = [sizeCurr[0] / sizeOrigin[0], sizeCurr[1] / sizeOrigin[1]];
-  isNaN(scales[0]) && (scales[0] = 1);
-  isNaN(scales[1]) && (scales[1] = 1);
-  return scales;
+function buildAxisMajorTicks(group, transformGroup, axisModel, opt) {
+  var axis = axisModel.axis;
+  var tickModel = axisModel.getModel("axisTick");
+  var shown = tickModel.get("show");
+  if (shown === "auto" && opt.handleAutoShown) {
+    shown = opt.handleAutoShown("axisTick");
+  }
+  if (!shown || axis.scale.isBlank()) {
+    return;
+  }
+  var lineStyleModel = tickModel.getModel("lineStyle");
+  var tickEndCoord = opt.tickDirection * tickModel.get("length");
+  var ticksCoords = axis.getTicksCoords();
+  var ticksEls = createTicks(ticksCoords, transformGroup.transform, tickEndCoord, defaults(lineStyleModel.getLineStyle(), {
+    stroke: axisModel.get(["axisLine", "lineStyle", "color"])
+  }), "ticks");
+  for (var i = 0; i < ticksEls.length; i++) {
+    group.add(ticksEls[i]);
+  }
+  return ticksEls;
 }
-function getSize(xyMinMax) {
-  return xyMinMax ? [xyMinMax[0][1] - xyMinMax[0][0], xyMinMax[1][1] - xyMinMax[1][0]] : [NaN, NaN];
+function buildAxisMinorTicks(group, transformGroup, axisModel, tickDirection) {
+  var axis = axisModel.axis;
+  var minorTickModel = axisModel.getModel("minorTick");
+  if (!minorTickModel.get("show") || axis.scale.isBlank()) {
+    return;
+  }
+  var minorTicksCoords = axis.getMinorTicksCoords();
+  if (!minorTicksCoords.length) {
+    return;
+  }
+  var lineStyleModel = minorTickModel.getModel("lineStyle");
+  var tickEndCoord = tickDirection * minorTickModel.get("length");
+  var minorTickLineStyle = defaults(lineStyleModel.getLineStyle(), defaults(axisModel.getModel("axisTick").getLineStyle(), {
+    stroke: axisModel.get(["axisLine", "lineStyle", "color"])
+  }));
+  for (var i = 0; i < minorTicksCoords.length; i++) {
+    var minorTicksEls = createTicks(minorTicksCoords[i], transformGroup.transform, tickEndCoord, minorTickLineStyle, "minorticks_" + i);
+    for (var k = 0; k < minorTicksEls.length; k++) {
+      group.add(minorTicksEls[k]);
+    }
+  }
+}
+function buildAxisLabel(group, transformGroup, axisModel, opt) {
+  var axis = axisModel.axis;
+  var show = retrieve(opt.axisLabelShow, axisModel.get(["axisLabel", "show"]));
+  if (!show || axis.scale.isBlank()) {
+    return;
+  }
+  var labelModel = axisModel.getModel("axisLabel");
+  var labelMargin = labelModel.get("margin");
+  var labels = axis.getViewLabels();
+  var labelRotation = (retrieve(opt.labelRotate, labelModel.get("rotate")) || 0) * PI / 180;
+  var labelLayout = AxisBuilder.innerTextLayout(opt.rotation, labelRotation, opt.labelDirection);
+  var rawCategoryData = axisModel.getCategories && axisModel.getCategories(true);
+  var labelEls = [];
+  var silent = AxisBuilder.isLabelSilent(axisModel);
+  var triggerEvent = axisModel.get("triggerEvent");
+  each(labels, function(labelItem, index) {
+    var tickValue = axis.scale.type === "ordinal" ? axis.scale.getRawOrdinalNumber(labelItem.tickValue) : labelItem.tickValue;
+    var formattedLabel = labelItem.formattedLabel;
+    var rawLabel = labelItem.rawLabel;
+    var itemLabelModel = labelModel;
+    if (rawCategoryData && rawCategoryData[tickValue]) {
+      var rawCategoryItem = rawCategoryData[tickValue];
+      if (isObject(rawCategoryItem) && rawCategoryItem.textStyle) {
+        itemLabelModel = new Model(rawCategoryItem.textStyle, labelModel, axisModel.ecModel);
+      }
+    }
+    var textColor = itemLabelModel.getTextColor() || axisModel.get(["axisLine", "lineStyle", "color"]);
+    var tickCoord = axis.dataToCoord(tickValue);
+    var align = itemLabelModel.getShallow("align", true) || labelLayout.textAlign;
+    var alignMin = retrieve2(itemLabelModel.getShallow("alignMinLabel", true), align);
+    var alignMax = retrieve2(itemLabelModel.getShallow("alignMaxLabel", true), align);
+    var verticalAlign = itemLabelModel.getShallow("verticalAlign", true) || itemLabelModel.getShallow("baseline", true) || labelLayout.textVerticalAlign;
+    var verticalAlignMin = retrieve2(itemLabelModel.getShallow("verticalAlignMinLabel", true), verticalAlign);
+    var verticalAlignMax = retrieve2(itemLabelModel.getShallow("verticalAlignMaxLabel", true), verticalAlign);
+    var textEl = new ZRText({
+      x: tickCoord,
+      y: opt.labelOffset + opt.labelDirection * labelMargin,
+      rotation: labelLayout.rotation,
+      silent,
+      z2: 10 + (labelItem.level || 0),
+      style: createTextStyle(itemLabelModel, {
+        text: formattedLabel,
+        align: index === 0 ? alignMin : index === labels.length - 1 ? alignMax : align,
+        verticalAlign: index === 0 ? verticalAlignMin : index === labels.length - 1 ? verticalAlignMax : verticalAlign,
+        fill: isFunction(textColor) ? textColor(
+          // (1) In category axis with data zoom, tick is not the original
+          // index of axis.data. So tick should not be exposed to user
+          // in category axis.
+          // (2) Compatible with previous version, which always use formatted label as
+          // input. But in interval scale the formatted label is like '223,445', which
+          // maked user replace ','. So we modify it to return original val but remain
+          // it as 'string' to avoid error in replacing.
+          axis.type === "category" ? rawLabel : axis.type === "value" ? tickValue + "" : tickValue,
+          index
+        ) : textColor
+      })
+    });
+    textEl.anid = "label_" + tickValue;
+    setTooltipConfig({
+      el: textEl,
+      componentModel: axisModel,
+      itemName: formattedLabel,
+      formatterParamsExtra: {
+        isTruncated: function() {
+          return textEl.isTruncated;
+        },
+        value: rawLabel,
+        tickIndex: index
+      }
+    });
+    if (triggerEvent) {
+      var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
+      eventData.targetType = "axisLabel";
+      eventData.value = rawLabel;
+      eventData.tickIndex = index;
+      if (axis.type === "category") {
+        eventData.dataIndex = tickValue;
+      }
+      getECData(textEl).eventData = eventData;
+    }
+    transformGroup.add(textEl);
+    textEl.updateTransform();
+    labelEls.push(textEl);
+    group.add(textEl);
+    textEl.decomposeTransform();
+  });
+  return labelEls;
 }
 export {
-  BrushTargetManager as default
+  AxisBuilder as default
 };