@visactor/vrender-components 0.19.5-alpha.1 → 0.19.5

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";
@@ -15708,11 +15708,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) {
@@ -15910,14 +15907,14 @@ class Tag extends AbstractComponent {
                 const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
                 const tsWidth = textWidth + symbolPlaceWidth;
                 const textX = flag === 1
-                    ? (containerWidth - tsWidth) / 2 + symbolPlaceWidth
-                    : parsedPadding[0] + symbolPlaceWidth - (tagWidth / 2 + tsWidth / 2 - symbolPlaceWidth);
+                    ? (containerWidth - tsWidth) / 2 + symbolPlaceWidth + textWidth / 2
+                    : parsedPadding[0] + symbolPlaceWidth - (tagWidth / 2 + tsWidth / 2 - symbolPlaceWidth) + textWidth / 2;
                 textShape.setAttributes({
                     x: textX,
-                    textAlign: 'left'
+                    textAlign: 'center'
                 });
                 if (symbol) {
-                    const symbolX = textX - symbolPlaceWidth + maxSize / 2;
+                    const symbolX = textX - textWidth / 2 - symbolPlaceWidth + maxSize / 2;
                     symbol.setAttributes({
                         x: symbolX
                     });
@@ -19278,6 +19275,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 +19787,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 +19802,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 +19811,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 +19838,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 +19851,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 +20898,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) {
@@ -28848,6 +29351,6 @@ Radio.defaultAttributes = {
     }
 };
 
-const version = "0.19.5-alpha.1";
+const version = "0.19.5";
 
-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, getCircleLabelPosition, getCircleVerticalVector, getElMap, getHorizontalPath, getMarksByName, getNoneGroupMarksByName, getPolarAngleLabelPosition, 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, ticks, traverseGroup, version };

package/es/axis/index.d.ts

@@ -4,3 +4,4 @@ export * from './type';
 export * from './animate';
 export * from './constant';
 export * from './util';
+export * from './tick-data';