@visactor/vrender-components 0.14.3 → 0.14.5-alpha.1

package/dist/index.js

@@ -1587,7 +1587,7 @@
         setBitmapTool(bmpTool) {
             this._bmpTool = bmpTool;
         }
-        layoutArcLabels(position, attribute, currentMarks, data, textBoundsArray) {
+        layoutArcLabels(position, attribute, currentMarks, data, textBoundsArray, ellipsisWidth) {
             const arcs = [];
             return arcs;
         }
@@ -1680,7 +1680,6 @@
             }
         }
         layout(data = []) {
-            var _a;
             const { textStyle = {}, position, offset } = this.attribute;
             const labels = [];
             const textBoundsArray = [];
@@ -1702,15 +1701,23 @@
                 labels.push(text);
             }
             if (this.attribute.type === 'arc') {
-                const arcs = this.layoutArcLabels(position, this.attribute, Array.from(this._idToGraphic.values()), data, textBoundsArray);
+                const ellipsisLabelAttribute = Object.assign(Object.assign({}, this.attribute.textStyle), { text: '...' });
+                const ellipsisText = this._createLabelText(ellipsisLabelAttribute);
+                const ellipsisTextBounds = this.getGraphicBounds(ellipsisText);
+                const ellipsisWidth = ellipsisTextBounds.x2 - ellipsisTextBounds.x1;
+                const arcs = this.layoutArcLabels(position, this.attribute, Array.from(this._idToGraphic.values()), data, textBoundsArray, ellipsisWidth);
                 for (let i = 0; i < data.length; i++) {
                     const textData = data[i];
-                    const basedArc = arcs.find(arc => arc.labelText === textData.text);
+                    const basedArc = arcs.find(arc => arc.refDatum.id === textData.id);
                     const labelAttribute = {
+                        visible: basedArc.labelVisible,
                         x: basedArc.labelPosition.x,
                         y: basedArc.labelPosition.y,
-                        angle: (_a = this.attribute.angle) !== null && _a !== void 0 ? _a : basedArc.angle,
-                        labelLinePath: basedArc.labelLinePath
+                        angle: basedArc.angle,
+                        maxLineWidth: basedArc.labelLimit,
+                        points: (basedArc === null || basedArc === void 0 ? void 0 : basedArc.pointA) && (basedArc === null || basedArc === void 0 ? void 0 : basedArc.pointB) && (basedArc === null || basedArc === void 0 ? void 0 : basedArc.pointC)
+                            ? [basedArc.pointA, basedArc.pointB, basedArc.pointC]
+                            : undefined
                     };
                     labels[i].setAttributes(labelAttribute);
                 }
@@ -1772,20 +1779,6 @@
                         continue;
                     }
                 }
-                if (clampForce) {
-                    const { dx = 0, dy = 0 } = clampText(text, bmpTool.width, bmpTool.height);
-                    if (!(dx === 0 && dy === 0) &&
-                        canPlace(bmpTool, bitmap, {
-                            x1: text.AABBBounds.x1 + dx,
-                            x2: text.AABBBounds.x2 + dx,
-                            y1: text.AABBBounds.y1 + dy,
-                            y2: text.AABBBounds.y2 + dy
-                        })) {
-                        text.setAttributes({ x: text.attribute.x + dx, y: text.attribute.y + dy });
-                        result.push(text);
-                        continue;
-                    }
-                }
                 let hasPlace = false;
                 for (let j = 0; j < strategy.length; j++) {
                     hasPlace = place(bmpTool, bitmap, strategy[j], this.attribute, text, this.getGraphicBounds(baseMark, labels[i]), this.labeling);
@@ -1845,13 +1838,13 @@
             const prevTextMap = this._graphicToText || new Map();
             const texts = [];
             labels.forEach((text, index) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-                const labelLine = ((_a = text.attribute) === null || _a === void 0 ? void 0 : _a.labelLinePath)
-                    ? vrender.createPath({
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                const labelLine = ((_a = text.attribute) === null || _a === void 0 ? void 0 : _a.points)
+                    ? vrender.createLine({
                         visible: (_c = (_b = text.attribute) === null || _b === void 0 ? void 0 : _b.visible) !== null && _c !== void 0 ? _c : true,
                         stroke: (_f = (_e = (_d = text.attribute) === null || _d === void 0 ? void 0 : _d.line) === null || _e === void 0 ? void 0 : _e.stroke) !== null && _f !== void 0 ? _f : (_g = text.attribute) === null || _g === void 0 ? void 0 : _g.fill,
-                        lineWidth: 1,
-                        path: (_h = text.attribute) === null || _h === void 0 ? void 0 : _h.labelLinePath
+                        lineWidth: (_k = (_j = (_h = text.attribute) === null || _h === void 0 ? void 0 : _h.line) === null || _j === void 0 ? void 0 : _j.lineWidth) !== null && _k !== void 0 ? _k : 1,
+                        points: (_l = text.attribute) === null || _l === void 0 ? void 0 : _l.points
                     })
                     : undefined;
                 const relatedGraphic = this._idToGraphic.get(text.attribute.id);
@@ -1892,9 +1885,9 @@
                         const prevText = prevLabel.text;
                         prevText.animate().to(text.attribute, duration, easing);
                         if (prevLabel.labelLine) {
-                            prevLabel.labelLine
-                                .animate()
-                                .to(vutils.merge({}, prevLabel.labelLine.attribute, { path: (_j = text.attribute) === null || _j === void 0 ? void 0 : _j.labelLinePath }), duration, easing);
+                            prevLabel.labelLine.animate().to(vutils.merge({}, prevLabel.labelLine.attribute, {
+                                points: (_m = text.attribute) === null || _m === void 0 ? void 0 : _m.points
+                            }), duration, easing);
                         }
                         if (animationConfig.increaseEffect !== false &&
                             prevText.attribute.text !== text.attribute.text &&
@@ -1907,7 +1900,7 @@
                     else {
                         prevLabel.text.setAttributes(text.attribute);
                         if (prevLabel === null || prevLabel === void 0 ? void 0 : prevLabel.labelLine) {
-                            prevLabel.labelLine.setAttributes({ path: (_k = text.attribute) === null || _k === void 0 ? void 0 : _k.labelLinePath });
+                            prevLabel.labelLine.setAttributes({ points: (_o = text.attribute) === null || _o === void 0 ? void 0 : _o.points });
                         }
                     }
                 }
@@ -1981,8 +1974,16 @@
             return listener;
         }
         _smartInvert(labels) {
+            var _a, _b, _c, _d;
             const option = (this.attribute.smartInvert || {});
             const { textType, contrastRatiosThreshold, alternativeColors } = option;
+            const fillStrategy = (_a = option.fillStrategy) !== null && _a !== void 0 ? _a : 'invertBase';
+            const strokeStrategy = (_b = option.strokeStrategy) !== null && _b !== void 0 ? _b : 'base';
+            const brightColor = (_c = option.brightColor) !== null && _c !== void 0 ? _c : '#ffffff';
+            const darkColor = (_d = option.darkColor) !== null && _d !== void 0 ? _d : '#000000';
+            if (fillStrategy === 'null' && strokeStrategy === 'null') {
+                return;
+            }
             for (let i = 0; i < labels.length; i++) {
                 const label = labels[i];
                 if (!label) {
@@ -1991,33 +1992,70 @@
                 const baseMark = this._idToGraphic.get(label.attribute.id);
                 let isInside = canPlaceInside(label.AABBBounds, baseMark === null || baseMark === void 0 ? void 0 : baseMark.AABBBounds);
                 if (this.attribute.type === 'arc') {
-                    if (this.attribute.position === 'inside') {
-                        isInside = true;
+                    isInside = this.attribute.position === 'inside';
+                }
+                const backgroundColor = baseMark.attribute.fill;
+                const foregroundColor = label.attribute.fill;
+                const baseColor = backgroundColor;
+                const invertColor = labelSmartInvert(foregroundColor, backgroundColor, textType, contrastRatiosThreshold, alternativeColors);
+                const simialrColor = contrastAccessibilityChecker(invertColor, brightColor) ? brightColor : darkColor;
+                if (isInside) {
+                    this.setFillStrategy(fillStrategy, label, baseColor, invertColor, simialrColor);
+                    if (label.attribute.lineWidth === 0) {
+                        continue;
                     }
-                    else {
-                        isInside = false;
+                    this.setStrokeStrategy(strokeStrategy, label, baseColor, invertColor, simialrColor);
+                }
+                else {
+                    if (label.attribute.lineWidth === 0) {
+                        continue;
+                    }
+                    if (label.attribute.stroke) {
+                        label.setAttributes({
+                            fill: labelSmartInvert(label.attribute.fill, label.attribute.stroke, textType, contrastRatiosThreshold, alternativeColors)
+                        });
+                        continue;
                     }
+                    this.setFillStrategy(fillStrategy, label, baseColor, invertColor, simialrColor);
+                    this.setStrokeStrategy(strokeStrategy, label, baseColor, invertColor, simialrColor);
                 }
-                if (label.attribute.stroke && label.attribute.lineWidth > 0) {
+            }
+        }
+        setFillStrategy(fillStrategy, label, baseColor, invertColor, simialrColor) {
+            switch (fillStrategy) {
+                case 'base':
                     label.setAttributes({
-                        fill: labelSmartInvert(label.attribute.fill, label.attribute.stroke, textType, contrastRatiosThreshold, alternativeColors)
+                        fill: baseColor
                     });
-                }
-                else if (isInside) {
-                    const backgroundColor = baseMark.attribute.fill;
-                    const foregroundColor = label.attribute.fill;
+                    break;
+                case 'invertBase':
                     label.setAttributes({
-                        fill: labelSmartInvert(foregroundColor, backgroundColor, textType, contrastRatiosThreshold, alternativeColors)
+                        fill: invertColor
                     });
-                }
-                else if (label.attribute.lineWidth > 0) {
-                    const backgroundColor = label.attribute.stroke;
-                    const foregroundColor = label.attribute.fill;
+                    break;
+                case 'similarBase':
                     label.setAttributes({
-                        stroke: baseMark.attribute.fill,
-                        fill: labelSmartInvert(foregroundColor, backgroundColor, textType, contrastRatiosThreshold, alternativeColors)
+                        fill: simialrColor
                     });
-                }
+            }
+        }
+        setStrokeStrategy(strokeStrategy, label, baseColor, invertColor, simialrColor) {
+            switch (strokeStrategy) {
+                case 'base':
+                    label.setAttributes({
+                        stroke: baseColor
+                    });
+                    break;
+                case 'invertBase':
+                    label.setAttributes({
+                        stroke: invertColor
+                    });
+                    break;
+                case 'similarBase':
+                    label.setAttributes({
+                        stroke: simialrColor
+                    });
+                    break;
             }
         }
         setLocation(point) {
@@ -2384,15 +2422,18 @@
             }
             return { x: 0, y: 0 };
         }
-        layoutArcLabels(position, attribute, currentMarks, data, textBoundsArray) {
+        layoutArcLabels(position, attribute, currentMarks, data, textBoundsArray, ellipsisWidth) {
+            var _a;
             this._arcLeft.clear();
             this._arcRight.clear();
+            this._ellipsisWidth = ellipsisWidth;
             const { width, height } = attribute;
+            const centerOffset = (_a = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _a !== void 0 ? _a : 0;
             currentMarks.forEach((currentMark, index) => {
                 var _a, _b;
                 const graphicAttribute = currentMark.attribute;
                 const radiusRatio = this.computeLayoutOuterRadius(graphicAttribute.outerRadius, width, height);
-                const radius = this.computeRadius(radiusRatio, width, height);
+                const radius = this.computeRadius(radiusRatio, width, height, centerOffset);
                 const center = { x: (_a = graphicAttribute === null || graphicAttribute === void 0 ? void 0 : graphicAttribute.x) !== null && _a !== void 0 ? _a : 0, y: (_b = graphicAttribute === null || graphicAttribute === void 0 ? void 0 : graphicAttribute.y) !== null && _b !== void 0 ? _b : 0 };
                 const item = data[index];
                 const textBounds = textBoundsArray[index];
@@ -2402,7 +2443,7 @@
                 const arcMiddle = circlePoint(center.x, center.y, graphicAttribute.outerRadius, arcMiddleAngle);
                 const outerArcMiddle = circlePoint(center.x, center.y, radius + attribute.line.line1MinLength, arcMiddleAngle);
                 const arc = new ArcInfo(item, arcMiddle, outerArcMiddle, arcQuadrant, intervalAngle, arcMiddleAngle);
-                arc.pointA = circlePoint(center.x, center.y, this.computeDatumRadius(center.x * 2, center.y * 2, graphicAttribute.outerRadius), arc.middleAngle);
+                arc.pointA = circlePoint(center.x, center.y, this.computeDatumRadius(center.x * 2, center.y * 2, graphicAttribute.outerRadius, centerOffset), arc.middleAngle);
                 arc.labelSize = {
                     width: textBounds.x2 - textBounds.x1,
                     height: textBounds.y2 - textBounds.y1
@@ -2428,16 +2469,18 @@
             return arcs;
         }
         _layoutInsideLabels(arcs, attribute, currentMarks) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const center = { x: (_b = (_a = currentMarks[0].attribute) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0, y: (_d = (_c = currentMarks[0].attribute) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0 };
+            const centerOffset = (_e = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _e !== void 0 ? _e : 0;
             const innerRadiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.innerRadius, attribute.width, attribute.height);
             const outerRadiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.outerRadius, attribute.width, attribute.height);
             const labelConfig = attribute;
             const spaceWidth = labelConfig.spaceWidth;
             arcs.forEach((arc) => {
+                var _a, _b;
                 const { labelSize, radian } = arc;
-                const innerRadius = this.computeRadius(innerRadiusRatio, attribute.width, attribute.height, 1);
-                const outerRadius = this.computeRadius(outerRadiusRatio, attribute.width, attribute.height, 1);
+                const innerRadius = this.computeRadius(innerRadiusRatio, attribute.width, attribute.height, centerOffset, 1);
+                const outerRadius = this.computeRadius(outerRadiusRatio, attribute.width, attribute.height, centerOffset, 1);
                 const minRadian = connectLineRadian(outerRadius, labelSize.height);
                 let limit;
                 if (radian < minRadian) {
@@ -2467,7 +2510,7 @@
                 if (!vutils.isGreater(labelWidth, 0)) {
                     arc.labelVisible = false;
                 }
-                arc.angle = arc.middleAngle;
+                arc.angle = (_b = (_a = attribute === null || attribute === void 0 ? void 0 : attribute.textStyle) === null || _a === void 0 ? void 0 : _a.angle) !== null && _b !== void 0 ? _b : arc.middleAngle;
             });
             return arcs;
         }
@@ -2525,36 +2568,33 @@
             }
             const width = center.x * 2;
             arcs.forEach(arc => {
+                var _a, _b;
                 if (arc.labelVisible &&
                     (vutils.isLess(arc.pointB.x, line2MinLength + spaceWidth) ||
                         vutils.isGreater(arc.pointB.x, width - line2MinLength - spaceWidth))) {
                     arc.labelVisible = false;
                 }
-                arc.angle = 0;
-                arc.labelLinePath =
-                    `M${Math.round(arc.pointA.x)},${Math.round(arc.pointA.y)}` +
-                        ` L${Math.round(arc.pointB.x)},${Math.round(arc.pointB.y)}` +
-                        ` L${Math.round(arc.pointC.x)},${Math.round(arc.pointC.y)}`;
+                arc.angle = (_b = (_a = attribute === null || attribute === void 0 ? void 0 : attribute.textStyle) === null || _a === void 0 ? void 0 : _a.angle) !== null && _b !== void 0 ? _b : 0;
             });
             return arcs;
         }
         _computeX(arc, attribute, currentMarks) {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f;
             const center = { x: (_b = (_a = currentMarks[0].attribute) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0, y: (_d = (_c = currentMarks[0].attribute) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0 };
+            const centerOffset = (_e = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _e !== void 0 ? _e : 0;
             const plotLayout = { width: center.x * 2, height: center.y * 2 };
             const radiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.outerRadius, attribute.width, attribute.height);
             const line1MinLength = attribute.line.line1MinLength;
             const line2MinLength = attribute.line.line2MinLength;
-            const labelLayoutAlign = (_e = attribute.layout) === null || _e === void 0 ? void 0 : _e.align;
+            const labelLayoutAlign = (_f = attribute.layout) === null || _f === void 0 ? void 0 : _f.align;
             const spaceWidth = attribute.spaceWidth;
-            this._computeAlign(arc, attribute);
             const { labelPosition, quadrant, pointB } = arc;
             if (!vutils.isValidNumber(pointB.x * pointB.y)) {
                 arc.pointC = { x: NaN, y: NaN };
                 labelPosition.x = NaN;
                 arc.labelLimit = 0;
             }
-            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height);
+            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height, centerOffset);
             const flag = isQuadrantLeft(quadrant) ? -1 : 1;
             let cx = 0;
             const restWidth = flag > 0 ? plotLayout.width - pointB.x : pointB.x;
@@ -2578,16 +2618,17 @@
                     break;
             }
             labelWidth = Math.max(this._ellipsisWidth, labelWidth);
+            arc.labelLimit = labelWidth;
             arc.pointC = { x: cx, y: labelPosition.y };
+            const targetCenterOffset = 0.5 * (arc.labelLimit < arc.labelSize.width ? arc.labelLimit : arc.labelSize.width);
             if (labelLayoutAlign === 'edge') {
                 const alignOffset = 0;
-                labelPosition.x = flag > 0 ? plotLayout.width + alignOffset : alignOffset;
+                labelPosition.x = (flag > 0 ? plotLayout.width + alignOffset : alignOffset) - flag * targetCenterOffset;
             }
             else {
                 const alignOffset = 0;
-                labelPosition.x = cx + alignOffset + flag * (spaceWidth + 0.5 * arc.labelSize.width);
+                labelPosition.x = cx + alignOffset + flag * (spaceWidth + targetCenterOffset);
             }
-            arc.labelLimit = labelWidth;
         }
         _computeAlignOffset(align, labelWidth, alignFlag) {
             switch (align) {
@@ -2771,7 +2812,7 @@
             return -1;
         }
         _computePointB(arc, r, attribute, currentMarks) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const labelConfig = attribute;
             const radiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.outerRadius, attribute.width, attribute.height);
             const line1MinLength = labelConfig.line.line1MinLength;
@@ -2784,7 +2825,8 @@
             }
             else {
                 const center = { x: (_b = (_a = currentMarks[0].attribute) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0, y: (_d = (_c = currentMarks[0].attribute) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0 };
-                const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height);
+                const centerOffset = (_e = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _e !== void 0 ? _e : 0;
+                const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height, centerOffset);
                 const { labelPosition, quadrant } = arc;
                 const outerR = Math.max(radius + line1MinLength, currentMarks[0].attribute.outerRadius);
                 const rd = r - outerR;
@@ -2808,13 +2850,14 @@
             }
         }
         _computeYRange(arc, attribute, currentMarks) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const center = { x: (_b = (_a = currentMarks[0].attribute) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0, y: (_d = (_c = currentMarks[0].attribute) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0 };
             const plotRect = { width: center.x * 2, height: center.y * 2 };
             const radiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.outerRadius, attribute.width, attribute.height);
             const line1MinLength = attribute.line.line1MinLength;
             const { width, height } = plotRect;
-            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height);
+            const centerOffset = (_e = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _e !== void 0 ? _e : 0;
+            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height, centerOffset);
             const r = this._computeLayoutRadius(height / 2, attribute, currentMarks);
             const cx = Math.abs(arc.center.x - width / 2);
             const cy = arc.center.y - height / 2;
@@ -2873,11 +2916,13 @@
             arc.labelYRange = [min, max];
         }
         _computeLayoutRadius(halfYLength, attribute, currentMarks) {
+            var _a;
             const labelConfig = attribute;
             const layoutArcGap = labelConfig.layoutArcGap;
             const line1MinLength = labelConfig.line.line1MinLength;
             const radiusRatio = this.computeLayoutOuterRadius(currentMarks[0].attribute.outerRadius, attribute.width, attribute.height);
-            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height);
+            const centerOffset = (_a = attribute === null || attribute === void 0 ? void 0 : attribute.centerOffset) !== null && _a !== void 0 ? _a : 0;
+            const radius = this.computeRadius(radiusRatio, attribute.width, attribute.height, centerOffset);
             const outerR = radius + line1MinLength;
             const a = outerR - layoutArcGap;
             return Math.max((a ** 2 + halfYLength ** 2) / (2 * a), outerR);
@@ -2943,8 +2988,9 @@
                 }
             }
         }
-        computeRadius(r, width, height, k) {
-            return this.computeLayoutRadius(width ? width : 0, height ? height : 0) * r * (vutils.isNil(k) ? 1 : k);
+        computeRadius(r, width, height, centerOffset, k) {
+            var _a;
+            return ((_a = this.computeLayoutRadius(width ? width : 0, height ? height : 0) * r * (vutils.isNil(k) ? 1 : k) + centerOffset) !== null && _a !== void 0 ? _a : 0);
         }
         computeLayoutRadius(width, height) {
             return Math.min(width / 2, height / 2);
@@ -2952,9 +2998,10 @@
         computeLayoutOuterRadius(r, width, height) {
             return r / (Math.min(width, height) / 2);
         }
-        computeDatumRadius(width, height, outerRadius) {
+        computeDatumRadius(width, height, outerRadius, centerOffset) {
+            var _a;
             const outerRadiusRatio = this.computeLayoutOuterRadius(outerRadius, width, height);
-            return this.computeLayoutRadius(width ? width : 0, height ? height : 0) * outerRadiusRatio;
+            return (_a = this.computeLayoutRadius(width ? width : 0, height ? height : 0) * outerRadiusRatio + centerOffset) !== null && _a !== void 0 ? _a : 0;
         }
     }
     ArcLabel.defaultAttributes = {
@@ -3839,10 +3886,8 @@
             textStyle = vutils.isFunction(textStyle)
                 ? vutils.merge({}, DEFAULT_AXIS_THEME.label.style, textStyle(tickDatum, index, tickData, layer))
                 : textStyle;
-            textStyle = vutils.merge({
-                textAlign: this.getTextAlign(vector),
-                textBaseline: this.getTextBaseline(vector, inside)
-            }, textStyle);
+            const labelAlign = this.getLabelAlign(vector, inside, textStyle.angle);
+            textStyle = vutils.merge(labelAlign, textStyle);
             if (vutils.isFunction(textStyle.text)) {
                 textStyle.text = textStyle.text({
                     label: tickDatum.label,
@@ -4008,73 +4053,70 @@
             item.rotatedBounds = bounds;
         });
     }
-    function rotateYAxis(orient, items) {
-        let align = ['right', 'right', 'center', 'left', 'center', 'left', 'center', 'right', 'right'];
-        let baseline = ['middle', 'middle', 'top', 'top', 'middle', 'middle', 'bottom', 'bottom', 'middle'];
-        if (orient === 'right') {
-            align = ['left', 'right', 'right', 'right', 'left', 'left', 'left', 'left', 'right'];
-            baseline = ['middle', 'bottom', 'middle', 'top', 'top', 'top', 'middle', 'bottom', 'bottom'];
-        }
-        items.forEach((item, i) => {
-            let angle = item.attribute.angle || 0;
-            if (angle < 0) {
-                while (angle < 0) {
-                    angle += Math.PI * 2;
-                }
+    function clampAngle(angle = 0) {
+        if (angle < 0) {
+            while (angle < 0) {
+                angle += Math.PI * 2;
             }
-            if (angle > 0) {
-                while (angle >= Math.PI * 2) {
-                    angle -= Math.PI * 2;
-                }
-            }
-            const step = angle / (Math.PI * 0.5);
-            let index;
-            if (step === Math.floor(step)) {
-                index = Math.floor(step) * 2;
-            }
-            else {
-                index = Math.floor(step) * 2 + 1;
+        }
+        if (angle > 0) {
+            while (angle >= Math.PI * 2) {
+                angle -= Math.PI * 2;
             }
-            item.setAttributes({
-                textAlign: align[index],
-                textBaseline: baseline[index],
-                angle: angle
-            });
+        }
+        return angle;
+    }
+    function rotateYAxis(orient, items) {
+        items.forEach((item, i) => {
+            item.setAttributes(Object.assign(Object.assign({}, getYAxisLabelAlign(orient, item.attribute.angle)), { angle: clampAngle(item.attribute.angle) }));
         });
     }
     function rotateXAxis(orient, items) {
+        items.forEach(item => {
+            item.setAttributes(Object.assign(Object.assign({}, getXAxisLabelAlign(orient, item.attribute.angle)), { angle: clampAngle(item.attribute.angle) }));
+        });
+    }
+    function getXAxisLabelAlign(orient, angle = 0) {
         let align = ['center', 'left', 'left', 'left', 'center', 'right', 'right', 'right', 'left'];
         let baseline = ['top', 'top', 'middle', 'bottom', 'bottom', 'bottom', 'middle', 'top', 'top'];
         if (orient === 'top') {
             align = ['center', 'right', 'right', 'right', 'center', 'left', 'left', 'left', 'right'];
             baseline = ['bottom', 'bottom', 'middle', 'top', 'top', 'top', 'middle', 'bottom', 'bottom'];
         }
-        items.forEach(item => {
-            let angle = item.attribute.angle || 0;
-            if (angle < 0) {
-                while (angle < 0) {
-                    angle += Math.PI * 2;
-                }
-            }
-            if (angle > 0) {
-                while (angle >= Math.PI * 2) {
-                    angle -= Math.PI * 2;
-                }
-            }
-            const step = angle / (Math.PI * 0.5);
-            let index;
-            if (step === Math.floor(step)) {
-                index = Math.floor(step) * 2;
-            }
-            else {
-                index = Math.floor(step) * 2 + 1;
-            }
-            item.setAttributes({
-                textAlign: align[index],
-                textBaseline: baseline[index],
-                angle
-            });
-        });
+        angle = clampAngle(angle);
+        const step = angle / (Math.PI * 0.5);
+        let index;
+        if (step === Math.floor(step)) {
+            index = Math.floor(step) * 2;
+        }
+        else {
+            index = Math.floor(step) * 2 + 1;
+        }
+        return {
+            textAlign: align[index],
+            textBaseline: baseline[index]
+        };
+    }
+    function getYAxisLabelAlign(orient, angle = 0) {
+        let align = ['right', 'right', 'center', 'left', 'center', 'left', 'center', 'right', 'right'];
+        let baseline = ['middle', 'middle', 'top', 'top', 'middle', 'middle', 'bottom', 'bottom', 'middle'];
+        if (orient === 'right') {
+            align = ['left', 'right', 'right', 'right', 'left', 'left', 'left', 'left', 'right'];
+            baseline = ['middle', 'bottom', 'middle', 'top', 'top', 'top', 'middle', 'bottom', 'bottom'];
+        }
+        angle = clampAngle(angle);
+        const step = angle / (Math.PI * 0.5);
+        let index;
+        if (step === Math.floor(step)) {
+            index = Math.floor(step) * 2;
+        }
+        else {
+            index = Math.floor(step) * 2 + 1;
+        }
+        return {
+            textAlign: align[index],
+            textBaseline: baseline[index]
+        };
     }
 
     function autoLimit(labels, config) {
@@ -4481,14 +4523,23 @@
             }
             return base;
         }
-        beforeLabelsOverlap(labelShapes, labelData, labelContainer, layer, layerCount) {
+        getLabelAlign(vector, inside, angle) {
             const orient = this.attribute.orient;
-            if (orient === 'left' || orient === 'right') {
-                rotateYAxis(orient, labelShapes);
-            }
-            else if (orient === 'bottom' || orient === 'top') {
-                rotateXAxis(orient, labelShapes);
+            if (vutils.isValidNumber(angle)) {
+                if (orient === 'top' || orient === 'bottom') {
+                    return getXAxisLabelAlign(orient, angle);
+                }
+                if (orient === 'left' || orient === 'right') {
+                    return getYAxisLabelAlign(orient, angle);
+                }
             }
+            return {
+                textAlign: this.getTextAlign(vector),
+                textBaseline: this.getTextBaseline(vector, inside)
+            };
+        }
+        beforeLabelsOverlap(labelShapes, labelData, labelContainer, layer, layerCount) {
+            return;
         }
         handleLabelsOverlap(labelShapes, labelData, labelContainer, layer, layerCount) {
             if (vutils.isEmpty(labelShapes)) {
@@ -4836,6 +4887,12 @@
         afterLabelsOverlap(labelShapes, labelData, labelContainer, layer, layerCount) {
             return;
         }
+        getLabelAlign(vector, inside, angle) {
+            return {
+                textAlign: this.getTextAlign(vector),
+                textBaseline: this.getTextBaseline(vector)
+            };
+        }
     }
     CircleAxis.defaultAttributes = DEFAULT_AXIS_THEME;
 
@@ -6941,15 +6998,30 @@
                 this._appendDataToShape(valueShape, exports.LEGEND_ELEMENT_NAME.itemValue, item, itemGroup, valueAttr === null || valueAttr === void 0 ? void 0 : valueAttr.state);
                 valueShape.addState(isSelected ? exports.LegendStateValue.selected : exports.LegendStateValue.unSelected);
                 if (this._itemWidthByUser) {
-                    valueShape.setAttribute('maxLineWidth', this._itemWidthByUser -
+                    const layoutWidth = this._itemWidthByUser -
                         parsedPadding[1] -
                         parsedPadding[3] -
                         shapeSize -
                         shapeSpace -
-                        labelShape.AABBBounds.width() -
                         labelSpace -
                         focusSpace -
-                        valueSpace);
+                        valueSpace;
+                    const valueBounds = valueShape.AABBBounds;
+                    const labelBounds = labelShape.AABBBounds;
+                    const valueWidth = valueBounds.width();
+                    const labelWidth = labelBounds.width();
+                    if (labelWidth > layoutWidth) {
+                        if ((layoutWidth - valueWidth) / labelWidth > 0.4) {
+                            labelShape.setAttribute('maxLineWidth', layoutWidth - valueWidth);
+                        }
+                        else {
+                            valueShape.setAttribute('maxLineWidth', layoutWidth * 0.5);
+                            labelShape.setAttribute('maxLineWidth', layoutWidth * 0.5);
+                        }
+                    }
+                    else {
+                        valueShape.setAttribute('maxLineWidth', layoutWidth - labelWidth);
+                    }
                     if (valueAttr.alignRight) {
                         valueShape.setAttributes({
                             textAlign: 'right',
@@ -10016,7 +10088,7 @@
     }
     Tooltip.defaultAttributes = defaultAttributes;
 
-    const version = "0.14.3";
+    const version = "0.14.5-alpha.1";
 
     exports.AbstractComponent = AbstractComponent;
     exports.ArcInfo = ArcInfo;