@visactor/vrender-components 0.19.5-alpha.2 → 0.19.6-alpha.0

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, Matrix, Logger, pi2, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, isString, isArray, cos, sin, pi, pointAt, isNumber, getDecimalPlaces, isNil, Color, has, normalTransform, isValidUrl, isBase64, epsilon, acos, sqrt, LRU, clampAngleByRadian, asin, transformBoundsWithMatrix, arrayEqual, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, isEmpty, isValid, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian as polarToCartesian$1, array, isValidNumber, calculateAnchorOfBounds, isGreater, isLess, isNumberClose, flattenArray, cloneDeep, get, isRotateAABBIntersect, last, mixin, isEqual, interpolateString, minInArray, polygonContainPoint } from '@visactor/vutils';
-import { LinearScale } from '@visactor/vscale';
+import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, Matrix, Logger, pi2, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, isString, isArray, cos, sin, pi, pointAt, isNumber, getDecimalPlaces, isNil, Color, has, normalTransform, isValidUrl, isBase64, epsilon, acos, sqrt, LRU, clampAngleByRadian, asin, transformBoundsWithMatrix, arrayEqual, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, isEmpty, isValid, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian as polarToCartesian$1, array, isValidNumber, calculateAnchorOfBounds, isGreater, isLess, isNumberClose, flattenArray, normalizeAngle as normalizeAngle$1, cloneDeep, get, isRotateAABBIntersect, last, mixin, isEqual, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, polygonContainPoint } from '@visactor/vutils';
+import { isContinuous, isDiscrete, LinearScale } from '@visactor/vscale';
 
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
@@ -6004,7 +6004,7 @@ function drawPathProxy(graphic, context, x, y, drawContext, params, fillCb, stro
   const path = "function" == typeof graphic.pathProxy ? graphic.pathProxy(graphic.attribute) : graphic.pathProxy;
   return renderCommandList(path.commandList, context, x, y), context.setShadowBlendStyle && context.setShadowBlendStyle(graphic, graphic.attribute, themeAttributes), doStroke && (strokeCb ? strokeCb(context, graphic.attribute, themeAttributes) : sVisible && (context.setStrokeStyle(graphic, graphic.attribute, x - originX, y - originY, themeAttributes), context.stroke())), doFill && (fillCb ? fillCb(context, graphic.attribute, themeAttributes) : fVisible && (context.setCommonStyle(graphic, graphic.attribute, x - originX, y - originY, themeAttributes), context.fill())), !0;
 }
-function intersect$1(x0, y0, x1, y1, x2, y2, x3, y3) {
+function intersect$2(x0, y0, x1, y1, x2, y2, x3, y3) {
   const x10 = x1 - x0,
     y10 = y1 - y0,
     x32 = x3 - x2,
@@ -6083,7 +6083,7 @@ function drawArcPath(arc, context, cx, cy, outerRadius, innerRadius, partStroke)
       yire = innerRadius * sin(innerEndAngle);
     let xore, yore, xirs, yirs;
     if ((maxInnerCornerRadius > epsilon || maxOuterCornerRadius > epsilon) && (xore = outerRadius * cos(outerEndAngle), yore = outerRadius * sin(outerEndAngle), xirs = innerRadius * cos(innerStartAngle), yirs = innerRadius * sin(innerStartAngle), deltaAngle < pi)) {
-      const oc = intersect$1(xors, yors, xirs, yirs, xore, yore, xire, yire);
+      const oc = intersect$2(xors, yors, xirs, yirs, xore, yore, xire, yire);
       if (oc) {
         const ax = xors - oc[0],
           ay = yors - oc[1],
@@ -10863,7 +10863,7 @@ let DefaultCanvasArcRender = class DefaultCanvasArcRender extends BaseRender {
       yire = innerRadius * sin(innerEndAngle);
     let xore, yore, xirs, yirs;
     if ((maxInnerCornerRadius > epsilon || maxOuterCornerRadius > epsilon) && (xore = outerRadius * cos(outerEndAngle), yore = outerRadius * sin(outerEndAngle), xirs = innerRadius * cos(innerStartAngle), yirs = innerRadius * sin(innerStartAngle), deltaAngle < pi)) {
-      const oc = intersect$1(xors, yors, xirs, yirs, xore, yore, xire, yire);
+      const oc = intersect$2(xors, yors, xirs, yirs, xore, yore, xire, yire);
       if (oc) {
         const ax = xors - oc[0],
           ay = yors - oc[1],
@@ -15155,8 +15155,8 @@ function loadScrollbarComponent() {
 
 const POLAR_START_ANGLE = -0.5 * Math.PI;
 const POLAR_END_ANGLE = 1.5 * Math.PI;
-const DEFAULT_TEXT_FONT_FAMILY = 'PingFang SC,Microsoft Yahei,system-ui,-apple-system,segoe ui,Roboto,Helvetica,Arial,sans-serif, apple color emoji,segoe ui emoji,segoe ui symbol';
-const DEFAULT_TEXT_FONT_SIZE = 11;
+const DEFAULT_TEXT_FONT_FAMILY = 'PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,-apple-system,segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol';
+const DEFAULT_TEXT_FONT_SIZE = 14;
 var StateValue;
 (function (StateValue) {
     StateValue["selected"] = "selected";
@@ -15541,14 +15541,33 @@ function removeRepeatPoint(points) {
     }
     return result;
 }
-function isPostiveXAxisCartes(angle) {
-    return angle > -Math.PI / 2 && angle < Math.PI / 2;
+function isPostiveXAxis(angle) {
+    return (angle >= 0 && angle < Math.PI / 2) || (angle > (Math.PI * 3) / 2 && angle <= Math.PI * 2);
 }
-function isPostiveXAxisPolar(angle, isReverse) {
-    if (isReverse) {
-        return (angle > 0 && angle < Math.PI / 2) || (angle < 0 && angle > -Math.PI * 2);
+function fuzzyEqualNumber(a, b, delta) {
+    return Math.abs(a - b) < delta;
+}
+function getTextAlignAttrOfVerticalDir(autoRotate, lineEndAngle, itemPosition) {
+    if (autoRotate) {
+        return {
+            textAlign: 'right',
+            textBaseline: 'middle'
+        };
     }
-    return (angle > 0 && angle < Math.PI / 2) || (angle > (Math.PI * 3) / 2 && angle < Math.PI * 2);
+    return {
+        textAlign: (lineEndAngle < Math.PI && itemPosition.toLocaleLowerCase().includes('top')) ||
+            (lineEndAngle > Math.PI && itemPosition.toLocaleLowerCase().includes('bottom'))
+            ? 'left'
+            :
+                (lineEndAngle < Math.PI && itemPosition.toLocaleLowerCase().includes('bottom')) ||
+                    (lineEndAngle > Math.PI && itemPosition.toLocaleLowerCase().includes('top'))
+                    ? 'right'
+                    : 'center',
+        textBaseline: (lineEndAngle < Math.PI && itemPosition.includes('inside')) ||
+            (lineEndAngle > Math.PI && !itemPosition.includes('inside'))
+            ? 'bottom'
+            : 'top'
+    };
 }
 
 const defaultAlternativeColors = ['#ffffff', '#000000'];
@@ -15708,11 +15727,8 @@ function angleTo(v1, v2, direct) {
     return Math.PI * 2 - ang;
 }
 
-const initTextMeasure = (textSpec, option, useNaiveCanvas) => {
-    return new TextMeasure(Object.assign({ defaultFontParams: {
-            fontFamily: DEFAULT_TEXT_FONT_FAMILY,
-            fontSize: DEFAULT_TEXT_FONT_SIZE
-        }, getTextBounds: useNaiveCanvas ? undefined : getTextBounds, specialCharSet: '-/: .,@%\'"~' + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase() }, (option !== null && option !== void 0 ? option : {})), textSpec);
+const initTextMeasure = (textSpec, option, useNaiveCanvas, defaultFontParams) => {
+    return new TextMeasure(Object.assign({ defaultFontParams: Object.assign({ fontFamily: DEFAULT_TEXT_FONT_FAMILY, fontSize: DEFAULT_TEXT_FONT_SIZE }, defaultFontParams), getTextBounds: useNaiveCanvas ? undefined : getTextBounds, specialCharSet: '-/: .,@%\'"~' + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase() }, (option !== null && option !== void 0 ? option : {})), textSpec);
 };
 function measureTextSize(text, textSpec, defaultTextTheme = {}) {
     if (!text) {
@@ -18836,10 +18852,18 @@ function loadArcSegmentComponent() {
 loadSegmentComponent();
 class Segment extends AbstractComponent {
     getStartAngle() {
-        return this._startAngle;
+        return this._startAngle < 0
+            ? this._startAngle + Math.PI * 2
+            : this._startAngle > Math.PI * 2
+                ? this._startAngle - Math.PI * 2
+                : this._startAngle;
     }
     getEndAngle() {
-        return this._endAngle;
+        return this._endAngle < 0
+            ? this._endAngle + Math.PI * 2
+            : this._endAngle > Math.PI * 2
+                ? this._endAngle - Math.PI * 2
+                : this._endAngle;
     }
     getMainSegmentPoints() {
         return this._mainSegmentPoints;
@@ -18914,8 +18938,8 @@ class Segment extends AbstractComponent {
         const { autoRotate = true } = attribute;
         let symbol;
         if (attribute && attribute.visible) {
-            const startAngle = this._startAngle;
-            const endAngle = this._endAngle;
+            const startAngle = this.getStartAngle();
+            const endAngle = this.getEndAngle();
             const { state } = this.attribute;
             const start = points[0];
             const end = points[points.length - 1];
@@ -18929,14 +18953,14 @@ class Segment extends AbstractComponent {
                     y: start.y +
                         (isValidNumber(startAngle) ? refX * Math.sin(startAngle) + refY * Math.sin(startAngle - Math.PI / 2) : 0)
                 };
-                rotate = this._computeStartRotate(startAngle);
+                rotate = this._computeStartRotate(this._startAngle);
             }
             else {
                 position = {
                     x: end.x + (isValidNumber(endAngle) ? refX * Math.cos(endAngle) + refY * Math.cos(endAngle - Math.PI / 2) : 0),
                     y: end.y + (isValidNumber(endAngle) ? refX * Math.sin(endAngle) + refY * Math.sin(endAngle - Math.PI / 2) : 0)
                 };
-                rotate = this._computeEndRotate(endAngle);
+                rotate = this._computeEndRotate(this._endAngle);
             }
             symbol = graphicCreator.symbol(Object.assign(Object.assign(Object.assign({}, position), { symbolType: symbolType, size, angle: autoRotate ? rotate + refAngle : 0, strokeBoundsBuffer: 0 }), style));
             symbol.name = `${this.name}-${dim}-symbol`;
@@ -19066,12 +19090,12 @@ class ArcSegment extends Segment {
         this.isReverseArc = false;
     }
     getStartAngle() {
-        const startAngle = this.isReverseArc ? this._startAngle + Math.PI / 2 : this._startAngle - Math.PI / 2;
-        return startAngle > Math.PI * 2 ? startAngle - Math.PI * 2 : startAngle;
+        const tangAng = this.isReverseArc ? this._startAngle + Math.PI / 2 : this._startAngle - Math.PI / 2;
+        return tangAng < 0 ? tangAng + Math.PI * 2 : tangAng > Math.PI * 2 ? tangAng - Math.PI * 2 : tangAng;
     }
     getEndAngle() {
-        const endAngle = this.isReverseArc ? this._endAngle - Math.PI / 2 : this._endAngle + Math.PI / 2;
-        return endAngle > Math.PI * 2 ? endAngle - Math.PI * 2 : endAngle;
+        const tangAng = this.isReverseArc ? this._endAngle - Math.PI / 2 : this._endAngle + Math.PI / 2;
+        return tangAng < 0 ? tangAng + Math.PI * 2 : tangAng > Math.PI * 2 ? tangAng - Math.PI * 2 : tangAng;
     }
     getMainSegmentPoints() {
         return this._mainSegmentPoints;
@@ -19278,6 +19302,36 @@ function getCircleVerticalVector(offset, point, center, inside = false, axisInsi
     const vector = [point.x - center.x, point.y - center.y];
     return scale(vector, ((inside ? -1 : 1) * (axisInside ? -1 : 1) * offset) / length(vector));
 }
+function angleLabelOrientAttribute(angle) {
+    let align = 'center';
+    let baseline = 'middle';
+    angle = normalizeAngle$1(angle);
+    if (angle >= Math.PI * (5 / 3) || angle <= Math.PI * (1 / 3)) {
+        align = 'left';
+    }
+    else if (angle >= Math.PI * (2 / 3) && angle <= Math.PI * (4 / 3)) {
+        align = 'right';
+    }
+    else {
+        align = 'center';
+    }
+    if (angle >= Math.PI * (7 / 6) && angle <= Math.PI * (11 / 6)) {
+        baseline = 'bottom';
+    }
+    else if (angle >= Math.PI * (1 / 6) && angle <= Math.PI * (5 / 6)) {
+        baseline = 'top';
+    }
+    else {
+        baseline = 'middle';
+    }
+    return { align, baseline };
+}
+function getPolarAngleLabelPosition(angle, center, radius, labelOffset, inside, text, style) {
+    const point = polarToCartesian$1({ x: 0, y: 0 }, radius, angle);
+    const labelPoint = getVerticalCoord(point, getCircleVerticalVector(labelOffset, point, center, inside));
+    const vector = getCircleVerticalVector(labelOffset || 1, labelPoint, center, inside);
+    return getCircleLabelPosition(labelPoint, vector, text, style);
+}
 
 const dispatchHoverState = (e, container, lastHover) => {
     const target = e.target;
@@ -19760,14 +19814,14 @@ function itemIntersect(item1, item2) {
             : true));
 }
 
-const methods = {
+const methods$1 = {
     parity: function (items) {
         return items.filter((item, i) => (i % 2 ? item.setAttribute('opacity', 0) : 1));
     },
     greedy: function (items, sep) {
         let a;
         return items.filter((b, i) => {
-            if (!i || !intersect(a, b, sep)) {
+            if (!i || !intersect$1(a, b, sep)) {
                 a = b;
                 return 1;
             }
@@ -19775,7 +19829,7 @@ const methods = {
         });
     }
 };
-function intersect(textA, textB, sep) {
+function intersect$1(textA, textB, sep) {
     const a = textA.AABBBounds;
     const b = textB.AABBBounds;
     return (sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2) &&
@@ -19784,9 +19838,9 @@ function intersect(textA, textB, sep) {
                 Math.max(textB.rotatedBounds.x1 - textA.rotatedBounds.x2, textA.rotatedBounds.x1 - textB.rotatedBounds.x2, textB.rotatedBounds.y1 - textA.rotatedBounds.y2, textA.rotatedBounds.y1 - textB.rotatedBounds.y2)
             : true));
 }
-function hasOverlap(items, pad) {
+function hasOverlap$1(items, pad) {
     for (let i = 1, n = items.length, a = items[0], b; i < n; a = b, ++i) {
-        if (intersect(a, (b = items[i]), pad)) {
+        if (intersect$1(a, (b = items[i]), pad)) {
             return true;
         }
     }
@@ -19811,11 +19865,11 @@ function autoHide(labels, config) {
     items = reset(source);
     genRotateBounds(items);
     const { method = 'parity', separation: sep = 0 } = config;
-    const reduce = isFunction(method) ? method : methods[method] || methods.parity;
-    if (items.length >= 3 && hasOverlap(items, sep)) {
+    const reduce = isFunction(method) ? method : methods$1[method] || methods$1.parity;
+    if (items.length >= 3 && hasOverlap$1(items, sep)) {
         do {
             items = reduce(items, sep);
-        } while (items.length >= 3 && hasOverlap(items, sep));
+        } while (items.length >= 3 && hasOverlap$1(items, sep));
         const checkLast = items.length < 3 || config.lastVisible;
         if (checkLast) {
             const lastSourceItem = last(source);
@@ -19824,7 +19878,7 @@ function autoHide(labels, config) {
                 if (remainLength > 1) {
                     lastSourceItem.setAttribute('opacity', 1);
                     for (let i = remainLength - 1; i >= 0; i--) {
-                        if (intersect(items[i], lastSourceItem, sep)) {
+                        if (intersect$1(items[i], lastSourceItem, sep)) {
                             items[i].setAttribute('opacity', 0);
                         }
                         else {
@@ -20871,6 +20925,482 @@ class GroupFadeOut extends ACustomAnimate {
     }
 }
 
+const convertDomainToTickData = (domain) => {
+    const ticks = domain.map((t, index) => {
+        return {
+            index,
+            value: t
+        };
+    });
+    return ticks;
+};
+const labelOverlap = (prevLabel, nextLabel, gap = 0) => {
+    const prevBounds = new AABBBounds(prevLabel).expand(gap / 2);
+    const nextBounds = new AABBBounds(nextLabel).expand(gap / 2);
+    return prevBounds.intersects(nextBounds);
+};
+function intersect(a, b, sep) {
+    return sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2);
+}
+function hasOverlap(items, pad) {
+    for (let i = 1, n = items.length, a = items[0], b; i < n; a = b, ++i) {
+        b = items[i];
+        if (intersect(a.AABBBounds, b.AABBBounds, pad)) {
+            return true;
+        }
+    }
+    return false;
+}
+const MIN_TICK_GAP = 12;
+const calculateFlushPos = (basePosition, size, rangePosition, otherEnd) => {
+    return rangePosition < basePosition
+        ? Math.max(basePosition - size / 2, rangePosition)
+        : rangePosition > basePosition
+            ? Math.min(basePosition - size / 2, rangePosition - size)
+            : rangePosition < otherEnd
+                ? rangePosition
+                : rangePosition - size;
+};
+const getCartesianLabelBounds = (scale, domain, op) => {
+    var _a;
+    const { labelStyle, axisOrientType, labelFlush, labelFormatter, startAngle = 0 } = op;
+    let labelAngle = (_a = labelStyle.angle) !== null && _a !== void 0 ? _a : 0;
+    if (labelStyle.direction === 'vertical') {
+        labelAngle += degreeToRadian(90);
+    }
+    const isHorizontal = ['bottom', 'top'].includes(axisOrientType);
+    const isVertical = ['left', 'right'].includes(axisOrientType);
+    let scaleX = 1;
+    let scaleY = 0;
+    if (isHorizontal) ;
+    else if (isVertical) {
+        scaleX = 0;
+        scaleY = 1;
+    }
+    else if (startAngle) {
+        scaleX = Math.cos(startAngle);
+        scaleY = -Math.sin(startAngle);
+    }
+    const textMeasure = initTextMeasure(labelStyle);
+    const range = scale.range();
+    const labelBoundsList = domain.map((v, i) => {
+        var _a, _b;
+        const str = labelFormatter ? labelFormatter(v) : `${v}`;
+        const { width, height } = textMeasure.quickMeasure(str);
+        const textWidth = Math.max(width, MIN_TICK_GAP);
+        const textHeight = Math.max(height, MIN_TICK_GAP);
+        const pos = scale.scale(v);
+        const baseTextX = scaleX * pos;
+        const baseTextY = scaleY * pos;
+        let textX = baseTextX;
+        let textY = baseTextY;
+        let align;
+        if (labelFlush && isHorizontal && i === 0) {
+            textX = calculateFlushPos(baseTextX, textWidth, range[0], range[range.length - 1]);
+        }
+        else if (labelFlush && isHorizontal && i === domain.length - 1) {
+            textX = calculateFlushPos(baseTextX, textWidth, range[range.length - 1], range[0]);
+        }
+        else {
+            align = (_a = labelStyle.textAlign) !== null && _a !== void 0 ? _a : 'center';
+        }
+        if (align === 'right') {
+            textX -= textWidth;
+        }
+        else if (align === 'center') {
+            textX -= textWidth / 2;
+        }
+        let baseline;
+        if (labelFlush && isVertical && i === 0) {
+            textY = calculateFlushPos(baseTextY, textHeight, range[0], range[range.length - 1]);
+        }
+        else if (labelFlush && isVertical && i === domain.length - 1) {
+            textY = calculateFlushPos(baseTextY, textHeight, range[range.length - 1], range[0]);
+        }
+        else {
+            baseline = (_b = labelStyle.textBaseline) !== null && _b !== void 0 ? _b : 'middle';
+        }
+        if (baseline === 'bottom') {
+            textY -= textHeight;
+        }
+        else if (baseline === 'middle') {
+            textY -= textHeight / 2;
+        }
+        const bounds = new AABBBounds().set(textX, textY, textX + textWidth, textY + textHeight);
+        if (labelAngle) {
+            bounds.rotate(labelAngle, baseTextX, baseTextY);
+        }
+        return bounds;
+    });
+    return labelBoundsList;
+};
+const getPolarAngleLabelBounds = (scale, domain, op) => {
+    var _a;
+    const { labelStyle, getRadius, labelOffset, labelFormatter, inside } = op;
+    const radius = getRadius === null || getRadius === void 0 ? void 0 : getRadius();
+    const labelAngle = (_a = labelStyle.angle) !== null && _a !== void 0 ? _a : 0;
+    const textMeasure = initTextMeasure(labelStyle);
+    const labelBoundsList = domain.map((v) => {
+        var _a, _b;
+        const str = labelFormatter ? labelFormatter(v) : `${v}`;
+        const { width, height } = textMeasure.quickMeasure(str);
+        const textWidth = Math.max(width, MIN_TICK_GAP);
+        const textHeight = Math.max(height, MIN_TICK_GAP);
+        const angle = scale.scale(v);
+        let textX = 0;
+        let textY = 0;
+        const orient = {
+            align: (_a = labelStyle.textAlign) !== null && _a !== void 0 ? _a : 'center',
+            baseline: (_b = labelStyle.textBaseline) !== null && _b !== void 0 ? _b : 'middle'
+        };
+        const { x, y } = getPolarAngleLabelPosition(angle, { x: 0, y: 0 }, radius, labelOffset, inside, str, labelStyle);
+        textX = x + (orient.align === 'right' ? -textWidth : orient.align === 'center' ? -textWidth / 2 : 0);
+        textY = y + (orient.baseline === 'bottom' ? -textHeight : orient.baseline === 'middle' ? -textHeight / 2 : 0);
+        const bounds = new AABBBounds()
+            .set(textX, textY, textX + textWidth, textY + textHeight)
+            .rotate(labelAngle, textX + textWidth / 2, textY + textHeight / 2);
+        return bounds;
+    });
+    return labelBoundsList;
+};
+const isAxisHorizontal = (axisOrientType) => {
+    return ['bottom', 'top', 'z'].includes(axisOrientType);
+};
+
+const DEFAULT_CONTINUOUS_TICK_COUNT = 5;
+const continuousTicks = (scale, op) => {
+    if (!isContinuous(scale.type)) {
+        return convertDomainToTickData(scale.domain());
+    }
+    const range = scale.range();
+    const rangeSize = Math.abs(range[range.length - 1] - range[0]);
+    if (rangeSize < 2) {
+        return convertDomainToTickData([scale.domain()[0]]);
+    }
+    const { tickCount, forceTickCount, tickStep, noDecimals = false, labelStyle } = op;
+    let scaleTicks;
+    if (isValid(tickStep)) {
+        scaleTicks = scale.stepTicks(tickStep);
+    }
+    else if (isValid(forceTickCount)) {
+        scaleTicks = scale.forceTicks(forceTickCount);
+    }
+    else if (op.tickMode === 'd3') {
+        const count = isFunction(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+        scaleTicks = scale.d3Ticks(count !== null && count !== void 0 ? count : DEFAULT_CONTINUOUS_TICK_COUNT, { noDecimals });
+    }
+    else {
+        const count = isFunction(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+        scaleTicks = scale.ticks(count !== null && count !== void 0 ? count : DEFAULT_CONTINUOUS_TICK_COUNT, { noDecimals });
+    }
+    if (op.sampling) {
+        if (op.coordinateType === 'cartesian' || (op.coordinateType === 'polar' && op.axisOrientType === 'radius')) {
+            const { labelGap = 4, labelFlush } = op;
+            let items = getCartesianLabelBounds(scale, scaleTicks, op).map((bounds, i) => ({
+                AABBBounds: bounds,
+                value: scaleTicks[i]
+            }));
+            while (items.length >= 3 && hasOverlap(items, labelGap)) {
+                items = methods.parity(items);
+            }
+            const ticks = items.map(item => item.value);
+            if (ticks.length < 3 && labelFlush) {
+                if (ticks.length > 1) {
+                    ticks.pop();
+                }
+                if (last(ticks) !== last(scaleTicks)) {
+                    ticks.push(last(scaleTicks));
+                }
+            }
+            scaleTicks = ticks;
+        }
+    }
+    return convertDomainToTickData(scaleTicks);
+};
+const methods = {
+    parity: function (items) {
+        return items.filter((item, i) => i % 2 === 0);
+    },
+    greedy: function (items, sep) {
+        let a;
+        return items.filter((b, i) => {
+            if (!i || !intersect(a.AABBBounds, b.AABBBounds, sep)) {
+                a = b;
+                return true;
+            }
+            return false;
+        });
+    }
+};
+
+const getOneDimensionalLabelBounds = (scale, domain, op, isHorizontal) => {
+    const labelBoundsList = getCartesianLabelBounds(scale, domain, op);
+    return labelBoundsList.map(bounds => {
+        if (isHorizontal) {
+            return [bounds.x1, bounds.x2, bounds.width()];
+        }
+        return [bounds.y1, bounds.y2, bounds.height()];
+    });
+};
+const boundsOverlap = (prevBounds, nextBounds, gap = 0) => {
+    return Math.max(prevBounds[0], nextBounds[0]) - gap / 2 <= Math.min(prevBounds[1], nextBounds[1]) + gap / 2;
+};
+const boundsDistance = (prevBounds, nextBounds) => {
+    if (prevBounds[1] < nextBounds[0]) {
+        return nextBounds[0] - prevBounds[1];
+    }
+    else if (nextBounds[1] < prevBounds[0]) {
+        return prevBounds[0] - nextBounds[1];
+    }
+    return 0;
+};
+const linearDiscreteTicks = (scale, op) => {
+    var _a;
+    const domain = scale.domain();
+    if (!domain.length) {
+        return [];
+    }
+    const { tickCount, forceTickCount, tickStep, labelGap = 4, axisOrientType, labelStyle } = op;
+    const isHorizontal = isAxisHorizontal(axisOrientType);
+    const range = scale.range();
+    const rangeSize = scale.calculateWholeRangeSize();
+    if (rangeSize < 2) {
+        if (op.labelLastVisible) {
+            return convertDomainToTickData([domain[domain.length - 1]]);
+        }
+        return convertDomainToTickData([domain[0]]);
+    }
+    let scaleTicks;
+    if (isValid(tickStep)) {
+        scaleTicks = scale.stepTicks(tickStep);
+    }
+    else if (isValid(forceTickCount)) {
+        scaleTicks = scale.forceTicks(forceTickCount);
+    }
+    else if (isValid(tickCount)) {
+        const count = isFunction(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+        scaleTicks = scale.ticks(count);
+    }
+    else if (op.sampling) {
+        const fontSize = ((_a = op.labelStyle.fontSize) !== null && _a !== void 0 ? _a : 12) + 2;
+        const rangeStart = minInArray(range);
+        const rangeEnd = maxInArray(range);
+        if (domain.length <= rangeSize / fontSize) {
+            const incrementUnit = (rangeEnd - rangeStart) / domain.length;
+            const labelBoundsList = getOneDimensionalLabelBounds(scale, domain, op, isHorizontal);
+            const minBoundsLength = Math.min(...labelBoundsList.map(bounds => bounds[2]));
+            const stepResult = getStep$1(domain, labelBoundsList, labelGap, op.labelLastVisible, Math.floor(minBoundsLength / incrementUnit), false);
+            scaleTicks = scale.stepTicks(stepResult.step);
+            if (op.labelLastVisible) {
+                if (stepResult.delCount) {
+                    scaleTicks = scaleTicks.slice(0, scaleTicks.length - stepResult.delCount);
+                }
+                scaleTicks.push(domain[domain.length - 1]);
+            }
+        }
+        else {
+            const tempDomain = [domain[0], domain[Math.floor(domain.length / 2)], domain[domain.length - 1]];
+            const tempList = getOneDimensionalLabelBounds(scale, tempDomain, op, isHorizontal);
+            let maxBounds = null;
+            tempList.forEach(current => {
+                if (!maxBounds) {
+                    maxBounds = current;
+                    return;
+                }
+                if (maxBounds[2] < current[2]) {
+                    maxBounds = current;
+                }
+            });
+            const step = rangeEnd - rangeStart - labelGap > 0
+                ? Math.ceil((domain.length * (labelGap + maxBounds[2])) / (rangeEnd - rangeStart - labelGap))
+                : domain.length - 1;
+            scaleTicks = scale.stepTicks(step);
+            if (op.labelLastVisible &&
+                (!scaleTicks.length || scaleTicks[scaleTicks.length - 1] !== domain[domain.length - 1])) {
+                if (scaleTicks.length &&
+                    Math.abs(scale.scale(scaleTicks[scaleTicks.length - 1]) - scale.scale(domain[domain.length - 1])) <
+                        maxBounds[2]) {
+                    scaleTicks = scaleTicks.slice(0, -1);
+                }
+                scaleTicks.push(domain[domain.length - 1]);
+            }
+        }
+    }
+    else {
+        scaleTicks = scale.domain();
+    }
+    return convertDomainToTickData(scaleTicks);
+};
+const getStep$1 = (domain, labelBoundsList, labelGap, labelLastVisible, defaultStep, areAllBoundsSame) => {
+    let resultDelCount = 0;
+    let resultStep = 0;
+    let resultTickCount = -1;
+    let minDiff = Number.MAX_VALUE;
+    const validateStep = (step) => {
+        let success = true;
+        let ptr = 0;
+        do {
+            if (ptr + step < domain.length && boundsOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap)) {
+                success = false;
+            }
+            ptr += step;
+        } while (success && ptr < domain.length);
+        return success;
+    };
+    const minValidStep = binaryFuzzySearchInNumberRange(defaultStep, domain.length, step => validateStep(step) ? 1 : -1);
+    let step = minValidStep;
+    do {
+        if (step > minValidStep && !areAllBoundsSame) {
+            if (!validateStep(step)) {
+                step++;
+                continue;
+            }
+        }
+        if (labelLastVisible) {
+            const lastIndex = domain.length - 1;
+            let delCount = 0;
+            let ptr;
+            if (domain.length % step > 0) {
+                ptr = domain.length - (domain.length % step) + step;
+            }
+            else {
+                ptr = domain.length;
+            }
+            do {
+                ptr -= step;
+                if (ptr === lastIndex || boundsOverlap(labelBoundsList[ptr], labelBoundsList[lastIndex], labelGap)) {
+                    delCount++;
+                }
+                else {
+                    break;
+                }
+            } while (ptr > 0);
+            if (ptr === lastIndex) {
+                resultStep = step;
+                resultDelCount = delCount;
+                break;
+            }
+            else {
+                const tickCount = Math.floor(domain.length / step) - delCount + 1;
+                if (tickCount < resultTickCount) {
+                    break;
+                }
+                else {
+                    resultTickCount = tickCount;
+                    const distance1 = boundsDistance(labelBoundsList[ptr], labelBoundsList[lastIndex]);
+                    const distance2 = ptr - step >= 0 ? boundsDistance(labelBoundsList[ptr - step], labelBoundsList[ptr]) : distance1;
+                    const diff = Math.abs(distance1 - distance2);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        resultStep = step;
+                        resultDelCount = delCount;
+                    }
+                    if (distance1 <= distance2) {
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            resultStep = step;
+            break;
+        }
+        step++;
+    } while (step <= domain.length);
+    return {
+        step: resultStep,
+        delCount: resultDelCount
+    };
+};
+
+const polarAngleAxisDiscreteTicks = (scale, op) => {
+    const { tickCount, forceTickCount, tickStep, getRadius, labelOffset, labelGap = 0, labelStyle } = op;
+    const radius = getRadius === null || getRadius === void 0 ? void 0 : getRadius();
+    if (!radius) {
+        return convertDomainToTickData(scale.domain());
+    }
+    let scaleTicks;
+    if (isValid(tickStep)) {
+        scaleTicks = scale.stepTicks(tickStep);
+    }
+    else if (isValid(forceTickCount)) {
+        scaleTicks = scale.forceTicks(forceTickCount);
+    }
+    else if (isValid(tickCount)) {
+        const range = scale.range();
+        const rangeSize = Math.abs(range[range.length - 1] - range[0]);
+        const count = isFunction(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+        scaleTicks = scale.ticks(count);
+    }
+    else if (op.sampling) {
+        const domain = scale.domain();
+        const range = scale.range();
+        const labelBoundsList = getPolarAngleLabelBounds(scale, domain, op);
+        const rangeStart = minInArray(range);
+        const rangeEnd = maxInArray(range);
+        const axisLength = Math.abs(rangeEnd - rangeStart) * (radius + labelOffset);
+        const incrementUnit = axisLength / domain.length;
+        const { step, delCount } = getStep(domain, labelBoundsList, labelGap, Math.floor(labelBoundsList.reduce((min, curBounds) => {
+            return Math.min(min, curBounds.width(), curBounds.height());
+        }, Number.MAX_VALUE) / incrementUnit));
+        scaleTicks = scale.stepTicks(step);
+        scaleTicks = scaleTicks.slice(0, scaleTicks.length - delCount);
+    }
+    else {
+        scaleTicks = scale.domain();
+    }
+    return convertDomainToTickData(scaleTicks);
+};
+const getStep = (domain, labelBoundsList, labelGap, defaultStep) => {
+    let step = defaultStep;
+    do {
+        let success = true;
+        step++;
+        let ptr = 0;
+        do {
+            if (ptr + step < domain.length && labelOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap)) {
+                success = false;
+            }
+            ptr += step;
+        } while (success && ptr < domain.length);
+        if (success) {
+            break;
+        }
+    } while (step <= domain.length);
+    let delCount = 0;
+    if (domain.length > 2) {
+        let ptr = domain.length - (domain.length % step);
+        if (ptr >= domain.length) {
+            ptr -= step;
+        }
+        while (ptr > 0 && labelOverlap(labelBoundsList[0], labelBoundsList[ptr])) {
+            delCount++;
+            ptr -= step;
+        }
+    }
+    return {
+        step,
+        delCount
+    };
+};
+
+const ticks = (scale, op) => {
+    if (isContinuous(scale.type)) {
+        return continuousTicks(scale, op);
+    }
+    else if (isDiscrete(scale.type)) {
+        if (op.coordinateType === 'cartesian') {
+            return linearDiscreteTicks(scale, op);
+        }
+        else if (op.coordinateType === 'polar') {
+            if (op.axisOrientType === 'angle') {
+                return polarAngleAxisDiscreteTicks(scale, op);
+            }
+        }
+    }
+    return convertDomainToTickData(scale.domain());
+};
+
 function getLinePath(points, closed) {
     let path = '';
     if (points.length === 0) {
@@ -22673,7 +23203,9 @@ class MarkCommonLine extends Marker {
         const { label = {}, limitRect } = this.attribute;
         const { position, confine, autoRotate } = label;
         const labelPoint = this.getPointAttrByPosition(position);
-        const labelAngle = this._line.getEndAngle() || 0;
+        const labelAngle = position.toString().toLocaleLowerCase().includes('start')
+            ? this._line.getStartAngle() || 0
+            : this._line.getEndAngle() || 0;
         this._label.setAttributes(Object.assign(Object.assign({}, labelPoint.position), { angle: autoRotate ? this.getRotateByAngle(labelPoint.angle) : 0, textStyle: Object.assign(Object.assign({}, this.getTextStyle(position, labelAngle, autoRotate)), label.textStyle) }));
         if (limitRect && confine) {
             const { x, y, width, height } = limitRect;
@@ -23137,7 +23669,7 @@ class MarkLine extends MarkCommonLine {
         const { refX = 0, refY = 0 } = label;
         const points = this._line.getMainSegmentPoints();
         const lineEndAngle = (_a = this._line.getEndAngle()) !== null && _a !== void 0 ? _a : 0;
-        const labelAngle = isPostiveXAxisCartes(lineEndAngle) ? lineEndAngle : lineEndAngle;
+        const labelAngle = isPostiveXAxis(lineEndAngle) ? lineEndAngle : lineEndAngle;
         const labelOffsetX = refX * Math.cos(labelAngle) + refY * Math.cos(labelAngle - Math.PI / 2);
         const labelOffsetY = refX * Math.sin(labelAngle) + refY * Math.sin(labelAngle - Math.PI / 2);
         if (position.includes('start') || position.includes('Start')) {
@@ -23168,25 +23700,15 @@ class MarkLine extends MarkCommonLine {
     }
     getRotateByAngle(angle) {
         var _a;
-        const itemAngle = isPostiveXAxisCartes(angle) ? angle : angle - Math.PI;
+        const itemAngle = isPostiveXAxis(angle) ? angle : angle - Math.PI;
         return itemAngle + ((_a = this.attribute.label.refAngle) !== null && _a !== void 0 ? _a : 0);
     }
     getTextStyle(position, labelAngle, autoRotate) {
-        if (Math.abs(Math.abs(labelAngle) - Math.PI / 2) < 0.0001) {
-            if (autoRotate) {
-                return {
-                    textAlign: 'right',
-                    textBaseline: 'middle'
-                };
-            }
-            return {
-                textAlign: 'center',
-                textBaseline: (labelAngle > 0 && position.includes('inside')) || (labelAngle < 0 && !position.includes('inside'))
-                    ? 'bottom'
-                    : 'top'
-            };
+        if (fuzzyEqualNumber(Math.abs(labelAngle), Math.PI / 2, 0.0001) ||
+            fuzzyEqualNumber(Math.abs(labelAngle), (Math.PI * 3) / 2, 0.0001)) {
+            return getTextAlignAttrOfVerticalDir(autoRotate, labelAngle, position);
         }
-        if (isPostiveXAxisCartes(labelAngle)) {
+        if (isPostiveXAxis(labelAngle)) {
             return DEFAULT_CARTESIAN_MARK_LINE_TEXT_STYLE_MAP.postiveXAxis[position];
         }
         return DEFAULT_CARTESIAN_MARK_LINE_TEXT_STYLE_MAP.negativeXAxis[position];
@@ -23617,18 +24139,16 @@ class MarkPoint extends Marker {
         this.defaultUpdateAnimation = DefaultUpdateMarkPointAnimation;
         this.defaultExitAnimation = DefaultExitMarkerAnimation;
         this._isArcLine = false;
+        this._isStraightLine = false;
     }
     setLabelPos() {
     }
     getTextAlignAttr(autoRotate, offsetX, offsetY, lineEndAngle, itemPosition) {
-        let isPostiveXAxis = true;
-        if (this._isArcLine) {
-            isPostiveXAxis = isPostiveXAxisPolar(lineEndAngle, this._line.isReverseArc);
-        }
-        else {
-            isPostiveXAxis = isPostiveXAxisCartes(lineEndAngle);
+        if (fuzzyEqualNumber(Math.abs(lineEndAngle), Math.PI / 2, 0.0001) ||
+            fuzzyEqualNumber(Math.abs(lineEndAngle), (Math.PI * 3) / 2, 0.0001)) {
+            return getTextAlignAttrOfVerticalDir(autoRotate, lineEndAngle, itemPosition);
         }
-        if (isPostiveXAxis) {
+        if (isPostiveXAxis(lineEndAngle)) {
             return DEFAULT_MARK_POINT_TEXT_STYLE_MAP.postiveXAxis[itemPosition];
         }
         return DEFAULT_MARK_POINT_TEXT_STYLE_MAP.negativeXAxis[itemPosition];
@@ -23641,8 +24161,8 @@ class MarkPoint extends Marker {
         const { autoRotate = true, refX = 0, refY = 0, refAngle = 0, textStyle = {}, richTextStyle = {}, imageStyle = {}, position: positionType = IMarkPointItemPosition.middle } = itemContent;
         const { state } = this.attribute;
         const lineEndAngle = ((_a = this._line) === null || _a === void 0 ? void 0 : _a.getEndAngle()) || 0;
-        const itemRefOffsetX = refX * Math.cos(lineEndAngle) + refY * Math.cos(lineEndAngle);
-        const itemRefOffsetY = refX * Math.sin(lineEndAngle) + refY * Math.sin(lineEndAngle);
+        const itemRefOffsetX = refX * Math.cos(lineEndAngle) + refY * Math.cos(lineEndAngle - Math.PI / 2);
+        const itemRefOffsetY = refX * Math.sin(lineEndAngle) + refY * Math.sin(lineEndAngle - Math.PI / 2);
         if (itemType === 'text') {
             const offsetX = newItemPosition.x - newPosition.x;
             const offsetY = newItemPosition.y - newPosition.y;
@@ -23665,16 +24185,7 @@ class MarkPoint extends Marker {
             });
             item.states = merge({}, DEFAULT_STATES$2, state === null || state === void 0 ? void 0 : state.image);
         }
-        let isPostiveXAxis = true;
-        let itemAngle;
-        if (this._isArcLine) {
-            isPostiveXAxis = isPostiveXAxisPolar(lineEndAngle, this._line.isReverseArc);
-            itemAngle = isPostiveXAxis ? lineEndAngle : lineEndAngle - Math.PI;
-        }
-        else {
-            isPostiveXAxis = isPostiveXAxisCartes(lineEndAngle);
-            itemAngle = isPostiveXAxis ? lineEndAngle : lineEndAngle - Math.PI;
-        }
+        const itemAngle = isPostiveXAxis(lineEndAngle) ? lineEndAngle : lineEndAngle - Math.PI;
         item.setAttributes({
             x: newItemPosition.x + (itemRefOffsetX || 0),
             y: newItemPosition.y + (itemRefOffsetY || 0),
@@ -23751,12 +24262,22 @@ class MarkPoint extends Marker {
             const deltaX = arcRatio * direction * x0;
             const centerX = x0 + deltaX;
             const centerY = line(centerX);
-            center = { x: centerX, y: centerY };
             startAngle = deltaXYToAngle(y1 - centerY, x1 - centerX);
             endAngle = deltaXYToAngle(y2 - centerY, x2 - centerX);
+            center = { x: centerX, y: centerY };
+            if (arcRatio > 0) {
+                if (endAngle < startAngle) {
+                    endAngle += Math.PI * 2;
+                }
+            }
+            else {
+                if (startAngle < endAngle) {
+                    startAngle += Math.PI * 2;
+                }
+            }
             radius = Math.sqrt((centerX - x1) * (centerX - x1) + (centerY - y1) * (centerY - y1));
         }
-        else if (type === 'type-do') {
+        else if (type === 'type-do' && !this._isStraightLine) {
             points = [
                 newPosition,
                 {
@@ -23766,7 +24287,7 @@ class MarkPoint extends Marker {
                 newItemPosition
             ];
         }
-        else if (type === 'type-po') {
+        else if (type === 'type-po' && !this._isStraightLine) {
             points = [
                 newPosition,
                 {
@@ -23776,7 +24297,7 @@ class MarkPoint extends Marker {
                 newItemPosition
             ];
         }
-        else if (type === 'type-op') {
+        else if (type === 'type-op' && !this._isStraightLine) {
             points = [
                 newPosition,
                 {
@@ -23818,8 +24339,7 @@ class MarkPoint extends Marker {
             const { startSymbol, endSymbol, lineStyle, type = 'type-s' } = itemLine;
             const { state } = this.attribute;
             const pointsAttr = this.getItemLineAttr(itemLine, newPosition, newItemPosition);
-            if ((type === 'type-arc' && this._line.key === 'arc-segment') ||
-                (type !== 'type-arc' && this._line.key === 'segment')) {
+            if ((this._isArcLine && this._line.key === 'arc-segment') || (!this._isArcLine && this._line.key === 'segment')) {
                 this._line.setAttributes(Object.assign(Object.assign({}, pointsAttr), { startSymbol,
                     endSymbol,
                     lineStyle, visible: itemLine.visible, state: {
@@ -23901,24 +24421,22 @@ class MarkPoint extends Marker {
         const targetSize = targetItemvisible ? targetSymbolSize || ((_a = targetSymbolStyle.size) !== null && _a !== void 0 ? _a : 10) : 0;
         const targetOffsetAngle = deltaXYToAngle(itemContentOffsetY, itemContentOffsetX);
         const newPosition = {
-            x: position.x + (targetSize + targetSymbolOffset) * Math.cos(targetOffsetAngle),
-            y: position.y + (targetSize + targetSymbolOffset) * Math.sin(targetOffsetAngle)
+            x: position.x + (targetSize / 2 + targetSymbolOffset) * Math.cos(targetOffsetAngle),
+            y: position.y + (targetSize / 2 + targetSymbolOffset) * Math.sin(targetOffsetAngle)
         };
         const newItemPosition = {
-            x: position.x + (targetSize + targetSymbolOffset) * Math.cos(targetOffsetAngle) + itemContentOffsetX,
-            y: position.y + (targetSize + targetSymbolOffset) * Math.sin(targetOffsetAngle) + itemContentOffsetY
+            x: position.x + (targetSize / 2 + targetSymbolOffset) * Math.cos(targetOffsetAngle) + itemContentOffsetX,
+            y: position.y + (targetSize / 2 + targetSymbolOffset) * Math.sin(targetOffsetAngle) + itemContentOffsetY
         };
         return { newPosition, newItemPosition };
     }
     initMarker(container) {
         const { position, itemContent = {}, itemLine } = this.attribute;
         const { type: itemLineType = 'type-s', arcRatio = 0.8 } = itemLine;
+        const { offsetX = 0, offsetY = 0 } = itemContent;
+        this._isStraightLine = fuzzyEqualNumber(offsetX, 0, 0.0001) || fuzzyEqualNumber(offsetY, 0, 0.0001);
+        this._isArcLine = itemLineType === 'type-arc' && arcRatio !== 0 && !this._isStraightLine;
         const { newPosition, newItemPosition } = this.computeNewPositionAfterTargetItem(position);
-        this._isArcLine =
-            itemLineType === 'type-arc' &&
-                arcRatio !== 0 &&
-                newPosition.x !== newItemPosition.x &&
-                newPosition.y !== newItemPosition.y;
         const lineConstructor = this._isArcLine ? ArcSegment : Segment;
         const line = new lineConstructor({
             points: [],
@@ -23950,11 +24468,10 @@ class MarkPoint extends Marker {
         const { position, itemContent = {}, itemLine } = this.attribute;
         const { type = 'text' } = itemContent;
         const { type: itemLineType = 'type-s', arcRatio = 0.8 } = itemLine;
+        const { offsetX = 0, offsetY = 0 } = itemContent;
+        this._isStraightLine = fuzzyEqualNumber(offsetX, 0, 0.001) || fuzzyEqualNumber(offsetY, 0, 0.001);
+        const isArcLine = itemLineType === 'type-arc' && arcRatio !== 0 && !this._isStraightLine;
         const { newPosition, newItemPosition } = this.computeNewPositionAfterTargetItem(position);
-        const isArcLine = itemLineType === 'type-arc' &&
-            arcRatio !== 0 &&
-            newPosition.x !== newItemPosition.x &&
-            newPosition.y !== newItemPosition.y;
         if (isArcLine !== this._isArcLine) {
             this._isArcLine = isArcLine;
             this.reDrawLine(itemLine, {
@@ -28848,6 +29365,6 @@ Radio.defaultAttributes = {
     }
 };
 
-const version = "0.19.5-alpha.2";
+const version = "0.19.6-alpha.0";
 
-export { AXIS_ELEMENT_NAME, AbstractComponent, ArcInfo, ArcLabel, ArcSegment, AreaLabel, AxisStateValue, BasePlayer, Brush, CheckBox, CircleAxis, CircleAxisGrid, CircleCrosshair, ColorContinuousLegend, ContinuousPlayer, DEFAULT_ITEM_SPACE_COL, DEFAULT_ITEM_SPACE_ROW, DEFAULT_LABEL_SPACE, DEFAULT_PAGER_SPACE, DEFAULT_SHAPE_SIZE, DEFAULT_SHAPE_SPACE, DEFAULT_STATES$1 as DEFAULT_STATES, DEFAULT_TITLE_SPACE, DEFAULT_VALUE_SPACE, DataLabel, DataZoom, DataZoomActiveTag, DirectionEnum, DiscreteLegend, DiscretePlayer, GroupFadeIn, GroupFadeOut, GroupTransition, IMarkAreaLabelPosition, IMarkCommonArcLabelPosition, IMarkLineLabelPosition, IMarkPointItemPosition, IOperateType, Indicator, LEGEND_ELEMENT_NAME, LabelBase, LegendEvent, LegendStateValue, LineAxis, LineAxisGrid, LineCrosshair, LineDataLabel, LineLabel, LinkPath, MarkArcArea, MarkArcLine, MarkArea, MarkLine, MarkPoint, Pager, PlayerEventEnum, PolygonCrosshair, PopTip, Radio, RectCrosshair, RectLabel, SLIDER_ELEMENT_NAME, ScrollBar, SectorCrosshair, Segment, SizeContinuousLegend, Slider, SymbolLabel, Tag, Title, Tooltip, VTag, angle, angleTo, clampRadian, contrastAccessibilityChecker, createTextGraphicByType, deltaXYToAngle, direction, getCircleLabelPosition, getCircleVerticalVector, getElMap, getHorizontalPath, getMarksByName, getNoneGroupMarksByName, getSizeHandlerPath, getTextType, getVerticalCoord, getVerticalPath, htmlAttributeTransform, initTextMeasure, isInRange, isPostiveXAxisCartes, isPostiveXAxisPolar, isRichText, isVisible, labelSmartInvert, length, loadPoptip, measureTextSize, normalize, reactAttributeTransform, registerMarkArcAreaAnimate, registerMarkArcLineAnimate, registerMarkAreaAnimate, registerMarkLineAnimate, registerMarkPointAnimate, removeRepeatPoint, richTextAttributeTransform, scale, setPoptipTheme, smartInvertStrategy, tan2AngleToAngle, traverseGroup, version };
+export { AXIS_ELEMENT_NAME, AbstractComponent, ArcInfo, ArcLabel, ArcSegment, AreaLabel, AxisStateValue, BasePlayer, Brush, CheckBox, CircleAxis, CircleAxisGrid, CircleCrosshair, ColorContinuousLegend, ContinuousPlayer, DEFAULT_ITEM_SPACE_COL, DEFAULT_ITEM_SPACE_ROW, DEFAULT_LABEL_SPACE, DEFAULT_PAGER_SPACE, DEFAULT_SHAPE_SIZE, DEFAULT_SHAPE_SPACE, DEFAULT_STATES$1 as DEFAULT_STATES, DEFAULT_TITLE_SPACE, DEFAULT_VALUE_SPACE, DataLabel, DataZoom, DataZoomActiveTag, DirectionEnum, DiscreteLegend, DiscretePlayer, GroupFadeIn, GroupFadeOut, GroupTransition, IMarkAreaLabelPosition, IMarkCommonArcLabelPosition, IMarkLineLabelPosition, IMarkPointItemPosition, IOperateType, Indicator, LEGEND_ELEMENT_NAME, LabelBase, LegendEvent, LegendStateValue, LineAxis, LineAxisGrid, LineCrosshair, LineDataLabel, LineLabel, LinkPath, MarkArcArea, MarkArcLine, MarkArea, MarkLine, MarkPoint, Pager, PlayerEventEnum, PolygonCrosshair, PopTip, Radio, RectCrosshair, RectLabel, SLIDER_ELEMENT_NAME, ScrollBar, SectorCrosshair, Segment, SizeContinuousLegend, Slider, SymbolLabel, Tag, Title, Tooltip, VTag, angle, angleLabelOrientAttribute, angleTo, clampRadian, contrastAccessibilityChecker, convertDomainToTickData, createTextGraphicByType, deltaXYToAngle, direction, fuzzyEqualNumber, getCircleLabelPosition, getCircleVerticalVector, getElMap, getHorizontalPath, getMarksByName, getNoneGroupMarksByName, getPolarAngleLabelPosition, getSizeHandlerPath, getTextAlignAttrOfVerticalDir, getTextType, getVerticalCoord, getVerticalPath, htmlAttributeTransform, initTextMeasure, isInRange, isPostiveXAxis, isRichText, isVisible, labelSmartInvert, length, loadPoptip, measureTextSize, normalize, reactAttributeTransform, registerMarkArcAreaAnimate, registerMarkArcLineAnimate, registerMarkAreaAnimate, registerMarkLineAnimate, registerMarkPointAnimate, removeRepeatPoint, richTextAttributeTransform, scale, setPoptipTheme, smartInvertStrategy, tan2AngleToAngle, ticks, traverseGroup, version };