zrender-nightly 5.6.2-dev.20250624 → 5.6.2-dev.20250625

package/lib/core/BoundingRect.js

@@ -2,14 +2,22 @@ import * as matrix from './matrix.js';
 import Point from './Point.js';
 var mathMin = Math.min;
 var mathMax = Math.max;
+var mathAbs = Math.abs;
+var XY = ['x', 'y'];
+var WH = ['width', 'height'];
 var lt = new Point();
 var rb = new Point();
 var lb = new Point();
 var rt = new Point();
-var minTv = new Point();
-var maxTv = new Point();
+var _intersectCtx = createIntersectContext();
+var _minTv = _intersectCtx.minTv;
+var _maxTv = _intersectCtx.maxTv;
+var _lenMinMax = [0, 0];
 var BoundingRect = (function () {
     function BoundingRect(x, y, width, height) {
+        BoundingRect.set(this, x, y, width, height);
+    }
+    BoundingRect.set = function (target, x, y, width, height) {
         if (width < 0) {
             x = x + width;
             width = -width;
@@ -18,11 +26,12 @@ var BoundingRect = (function () {
             y = y + height;
             height = -height;
         }
-        this.x = x;
-        this.y = y;
-        this.width = width;
-        this.height = height;
-    }
+        target.x = x;
+        target.y = y;
+        target.width = width;
+        target.height = height;
+        return target;
+    };
     BoundingRect.prototype.union = function (other) {
         var x = mathMin(other.x, this.x);
         var y = mathMin(other.y, this.y);
@@ -54,89 +63,64 @@ var BoundingRect = (function () {
         matrix.translate(m, m, [b.x, b.y]);
         return m;
     };
-    BoundingRect.prototype.intersect = function (b, mtv) {
-        if (!b) {
+    BoundingRect.prototype.intersect = function (b, mtv, opt) {
+        return BoundingRect.intersect(this, b, mtv, opt);
+    };
+    BoundingRect.intersect = function (a, b, mtv, opt) {
+        if (mtv) {
+            Point.set(mtv, 0, 0);
+        }
+        var outIntersectRect = opt && opt.outIntersectRect || null;
+        var clamp = opt && opt.clamp;
+        if (outIntersectRect) {
+            outIntersectRect.x = outIntersectRect.y = outIntersectRect.width = outIntersectRect.height = NaN;
+        }
+        if (!a || !b) {
             return false;
         }
+        if (!(a instanceof BoundingRect)) {
+            a = BoundingRect.set(_tmpIntersectA, a.x, a.y, a.width, a.height);
+        }
         if (!(b instanceof BoundingRect)) {
-            b = BoundingRect.create(b);
+            b = BoundingRect.set(_tmpIntersectB, b.x, b.y, b.width, b.height);
+        }
+        var useMTV = !!mtv;
+        _intersectCtx.reset(opt, useMTV);
+        var touchThreshold = _intersectCtx.touchThreshold;
+        var ax0 = a.x + touchThreshold;
+        var ax1 = a.x + a.width - touchThreshold;
+        var ay0 = a.y + touchThreshold;
+        var ay1 = a.y + a.height - touchThreshold;
+        var bx0 = b.x + touchThreshold;
+        var bx1 = b.x + b.width - touchThreshold;
+        var by0 = b.y + touchThreshold;
+        var by1 = b.y + b.height - touchThreshold;
+        if (ax0 > ax1 || ay0 > ay1 || bx0 > bx1 || by0 > by1) {
+            return false;
         }
-        var a = this;
-        var ax0 = a.x;
-        var ax1 = a.x + a.width;
-        var ay0 = a.y;
-        var ay1 = a.y + a.height;
-        var bx0 = b.x;
-        var bx1 = b.x + b.width;
-        var by0 = b.y;
-        var by1 = b.y + b.height;
         var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
-        if (mtv) {
-            var dMin = Infinity;
-            var dMax = 0;
-            var d0 = Math.abs(ax1 - bx0);
-            var d1 = Math.abs(bx1 - ax0);
-            var d2 = Math.abs(ay1 - by0);
-            var d3 = Math.abs(by1 - ay0);
-            var dx = Math.min(d0, d1);
-            var dy = Math.min(d2, d3);
-            if (ax1 < bx0 || bx1 < ax0) {
-                if (dx > dMax) {
-                    dMax = dx;
-                    if (d0 < d1) {
-                        Point.set(maxTv, -d0, 0);
-                    }
-                    else {
-                        Point.set(maxTv, d1, 0);
-                    }
-                }
-            }
-            else {
-                if (dx < dMin) {
-                    dMin = dx;
-                    if (d0 < d1) {
-                        Point.set(minTv, d0, 0);
-                    }
-                    else {
-                        Point.set(minTv, -d1, 0);
-                    }
-                }
+        if (useMTV || outIntersectRect) {
+            _lenMinMax[0] = Infinity;
+            _lenMinMax[1] = 0;
+            intersectOneDim(ax0, ax1, bx0, bx1, 0, useMTV, outIntersectRect, clamp);
+            intersectOneDim(ay0, ay1, by0, by1, 1, useMTV, outIntersectRect, clamp);
+            if (useMTV) {
+                Point.copy(mtv, overlap
+                    ? (_intersectCtx.useDir ? _intersectCtx.dirMinTv : _minTv)
+                    : _maxTv);
             }
-            if (ay1 < by0 || by1 < ay0) {
-                if (dy > dMax) {
-                    dMax = dy;
-                    if (d2 < d3) {
-                        Point.set(maxTv, 0, -d2);
-                    }
-                    else {
-                        Point.set(maxTv, 0, d3);
-                    }
-                }
-            }
-            else {
-                if (dx < dMin) {
-                    dMin = dx;
-                    if (d2 < d3) {
-                        Point.set(minTv, 0, d2);
-                    }
-                    else {
-                        Point.set(minTv, 0, -d3);
-                    }
-                }
-            }
-        }
-        if (mtv) {
-            Point.copy(mtv, overlap ? minTv : maxTv);
         }
         return overlap;
     };
-    BoundingRect.prototype.contain = function (x, y) {
-        var rect = this;
+    BoundingRect.contain = function (rect, x, y) {
         return x >= rect.x
             && x <= (rect.x + rect.width)
             && y >= rect.y
             && y <= (rect.y + rect.height);
     };
+    BoundingRect.prototype.contain = function (x, y) {
+        return BoundingRect.contain(this, x, y);
+    };
     BoundingRect.prototype.clone = function () {
         return new BoundingRect(this.x, this.y, this.width, this.height);
     };
@@ -168,6 +152,7 @@ var BoundingRect = (function () {
         target.y = source.y;
         target.width = source.width;
         target.height = source.height;
+        return target;
     };
     BoundingRect.applyTransform = function (target, source, m) {
         if (!m) {
@@ -212,4 +197,125 @@ var BoundingRect = (function () {
     };
     return BoundingRect;
 }());
+var _tmpIntersectA = new BoundingRect(0, 0, 0, 0);
+var _tmpIntersectB = new BoundingRect(0, 0, 0, 0);
+function intersectOneDim(a0, a1, b0, b1, updateDimIdx, useMTV, outIntersectRect, clamp) {
+    var d0 = mathAbs(a1 - b0);
+    var d1 = mathAbs(b1 - a0);
+    var d01min = mathMin(d0, d1);
+    var updateDim = XY[updateDimIdx];
+    var zeroDim = XY[1 - updateDimIdx];
+    var wh = WH[updateDimIdx];
+    if (a1 < b0 || b1 < a0) {
+        if (d0 < d1) {
+            if (useMTV) {
+                _maxTv[updateDim] = -d0;
+            }
+            if (clamp) {
+                outIntersectRect[updateDim] = a1;
+                outIntersectRect[wh] = 0;
+            }
+        }
+        else {
+            if (useMTV) {
+                _maxTv[updateDim] = d1;
+            }
+            if (clamp) {
+                outIntersectRect[updateDim] = a0;
+                outIntersectRect[wh] = 0;
+            }
+        }
+    }
+    else {
+        if (outIntersectRect) {
+            outIntersectRect[updateDim] = mathMax(a0, b0);
+            outIntersectRect[wh] = mathMin(a1, b1) - outIntersectRect[updateDim];
+        }
+        if (useMTV) {
+            if (d01min < _lenMinMax[0] || _intersectCtx.useDir) {
+                _lenMinMax[0] = mathMin(d01min, _lenMinMax[0]);
+                if (d0 < d1 || !_intersectCtx.bidirectional) {
+                    _minTv[updateDim] = d0;
+                    _minTv[zeroDim] = 0;
+                    if (_intersectCtx.useDir) {
+                        _intersectCtx.calcDirMTV();
+                    }
+                }
+                if (d0 >= d1 || !_intersectCtx.bidirectional) {
+                    _minTv[updateDim] = -d1;
+                    _minTv[zeroDim] = 0;
+                    if (_intersectCtx.useDir) {
+                        _intersectCtx.calcDirMTV();
+                    }
+                }
+            }
+        }
+    }
+}
+export function createIntersectContext() {
+    var _direction = 0;
+    var _dirCheckVec = new Point();
+    var _dirTmp = new Point();
+    var _ctx = {
+        minTv: new Point(),
+        maxTv: new Point(),
+        useDir: false,
+        dirMinTv: new Point(),
+        touchThreshold: 0,
+        bidirectional: true,
+        negativeSize: false,
+        reset: function (opt, useMTV) {
+            _ctx.touchThreshold = 0;
+            if (opt && opt.touchThreshold != null) {
+                _ctx.touchThreshold = mathMax(0, opt.touchThreshold);
+            }
+            _ctx.negativeSize = false;
+            if (!useMTV) {
+                return;
+            }
+            _ctx.minTv.set(Infinity, Infinity);
+            _ctx.maxTv.set(0, 0);
+            _ctx.useDir = false;
+            if (opt && opt.direction != null) {
+                _ctx.useDir = true;
+                _ctx.dirMinTv.copy(_ctx.minTv);
+                _dirTmp.copy(_ctx.minTv);
+                _direction = opt.direction;
+                _ctx.bidirectional = opt.bidirectional == null || !!opt.bidirectional;
+                if (!_ctx.bidirectional) {
+                    _dirCheckVec.set(Math.cos(_direction), Math.sin(_direction));
+                }
+            }
+        },
+        calcDirMTV: function () {
+            var minTv = _ctx.minTv;
+            var dirMinTv = _ctx.dirMinTv;
+            var squareMag = minTv.y * minTv.y + minTv.x * minTv.x;
+            var dirSin = Math.sin(_direction);
+            var dirCos = Math.cos(_direction);
+            var dotProd = dirSin * minTv.y + dirCos * minTv.x;
+            if (nearZero(dotProd)) {
+                if (nearZero(minTv.x) && nearZero(minTv.y)) {
+                    dirMinTv.set(0, 0);
+                }
+                return;
+            }
+            _dirTmp.x = squareMag * dirCos / dotProd;
+            _dirTmp.y = squareMag * dirSin / dotProd;
+            if (nearZero(_dirTmp.x) && nearZero(_dirTmp.y)) {
+                dirMinTv.set(0, 0);
+                return;
+            }
+            if ((_ctx.bidirectional
+                || _dirCheckVec.dot(_dirTmp) > 0)
+                && _dirTmp.len() < dirMinTv.len()) {
+                dirMinTv.copy(_dirTmp);
+            }
+        }
+    };
+    function nearZero(val) {
+        return mathAbs(val) < 1e-10;
+    }
+    return _ctx;
+}
 export default BoundingRect;

package/lib/core/OrientedBoundingRect.d.ts

@@ -1,5 +1,5 @@
 import { PointLike } from './Point';
-import BoundingRect from './BoundingRect';
+import BoundingRect, { BoundingRectIntersectOpt } from './BoundingRect';
 import { MatrixArray } from './matrix';
 declare class OrientedBoundingRect {
     private _corners;
@@ -7,7 +7,7 @@ declare class OrientedBoundingRect {
     private _origin;
     constructor(rect?: BoundingRect, transform?: MatrixArray);
     fromBoundingRect(rect: BoundingRect, transform?: MatrixArray): void;
-    intersect(other: OrientedBoundingRect, mtv?: PointLike): boolean;
+    intersect(other: OrientedBoundingRect, mtv?: PointLike, opt?: BoundingRectIntersectOpt): boolean;
     private _intersectCheckOneSide;
     private _getProjMinMaxOnAxis;
 }

package/lib/core/OrientedBoundingRect.js

@@ -1,8 +1,13 @@
 import Point from './Point.js';
-var extent = [0, 0];
-var extent2 = [0, 0];
-var minTv = new Point();
-var maxTv = new Point();
+import { createIntersectContext } from './BoundingRect.js';
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathAbs = Math.abs;
+var _extent = [0, 0];
+var _extent2 = [0, 0];
+var _intersectCtx = createIntersectContext();
+var _minTv = _intersectCtx.minTv;
+var _maxTv = _intersectCtx.maxTv;
 var OrientedBoundingRect = (function () {
     function OrientedBoundingRect(rect, transform) {
         this._corners = [];
@@ -42,59 +47,69 @@ var OrientedBoundingRect = (function () {
             this._origin[i] = axes[i].dot(corners[0]);
         }
     };
-    OrientedBoundingRect.prototype.intersect = function (other, mtv) {
+    OrientedBoundingRect.prototype.intersect = function (other, mtv, opt) {
         var overlapped = true;
         var noMtv = !mtv;
-        minTv.set(Infinity, Infinity);
-        maxTv.set(0, 0);
-        if (!this._intersectCheckOneSide(this, other, minTv, maxTv, noMtv, 1)) {
+        if (mtv) {
+            Point.set(mtv, 0, 0);
+        }
+        _intersectCtx.reset(opt, !noMtv);
+        if (!this._intersectCheckOneSide(this, other, noMtv, 1)) {
             overlapped = false;
             if (noMtv) {
                 return overlapped;
             }
         }
-        if (!this._intersectCheckOneSide(other, this, minTv, maxTv, noMtv, -1)) {
+        if (!this._intersectCheckOneSide(other, this, noMtv, -1)) {
             overlapped = false;
             if (noMtv) {
                 return overlapped;
             }
         }
-        if (!noMtv) {
-            Point.copy(mtv, overlapped ? minTv : maxTv);
+        if (!noMtv && !_intersectCtx.negativeSize) {
+            Point.copy(mtv, overlapped
+                ? (_intersectCtx.useDir ? _intersectCtx.dirMinTv : _minTv)
+                : _maxTv);
         }
         return overlapped;
     };
-    OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, minTv, maxTv, noMtv, inverse) {
+    OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, noMtv, inverse) {
         var overlapped = true;
         for (var i = 0; i < 2; i++) {
-            var axis = this._axes[i];
-            this._getProjMinMaxOnAxis(i, self._corners, extent);
-            this._getProjMinMaxOnAxis(i, other._corners, extent2);
-            if (extent[1] < extent2[0] || extent[0] > extent2[1]) {
+            var axis = self._axes[i];
+            self._getProjMinMaxOnAxis(i, self._corners, _extent);
+            self._getProjMinMaxOnAxis(i, other._corners, _extent2);
+            if (_intersectCtx.negativeSize || _extent[1] < _extent2[0] || _extent[0] > _extent2[1]) {
                 overlapped = false;
-                if (noMtv) {
+                if (_intersectCtx.negativeSize || noMtv) {
                     return overlapped;
                 }
-                var dist0 = Math.abs(extent2[0] - extent[1]);
-                var dist1 = Math.abs(extent[0] - extent2[1]);
-                if (Math.min(dist0, dist1) > maxTv.len()) {
+                var dist0 = mathAbs(_extent2[0] - _extent[1]);
+                var dist1 = mathAbs(_extent[0] - _extent2[1]);
+                if (mathMin(dist0, dist1) > _maxTv.len()) {
                     if (dist0 < dist1) {
-                        Point.scale(maxTv, axis, -dist0 * inverse);
+                        Point.scale(_maxTv, axis, -dist0 * inverse);
                     }
                     else {
-                        Point.scale(maxTv, axis, dist1 * inverse);
+                        Point.scale(_maxTv, axis, dist1 * inverse);
                     }
                 }
             }
-            else if (minTv) {
-                var dist0 = Math.abs(extent2[0] - extent[1]);
-                var dist1 = Math.abs(extent[0] - extent2[1]);
-                if (Math.min(dist0, dist1) < minTv.len()) {
-                    if (dist0 < dist1) {
-                        Point.scale(minTv, axis, dist0 * inverse);
+            else if (!noMtv) {
+                var dist0 = mathAbs(_extent2[0] - _extent[1]);
+                var dist1 = mathAbs(_extent[0] - _extent2[1]);
+                if (_intersectCtx.useDir || mathMin(dist0, dist1) < _minTv.len()) {
+                    if (dist0 < dist1 || !_intersectCtx.bidirectional) {
+                        Point.scale(_minTv, axis, dist0 * inverse);
+                        if (_intersectCtx.useDir) {
+                            _intersectCtx.calcDirMTV();
+                        }
                     }
-                    else {
-                        Point.scale(minTv, axis, -dist1 * inverse);
+                    if (dist0 >= dist1 || !_intersectCtx.bidirectional) {
+                        Point.scale(_minTv, axis, -dist1 * inverse);
+                        if (_intersectCtx.useDir) {
+                            _intersectCtx.calcDirMTV();
+                        }
                     }
                 }
             }
@@ -109,11 +124,12 @@ var OrientedBoundingRect = (function () {
         var max = proj;
         for (var i = 1; i < corners.length; i++) {
             var proj_1 = corners[i].dot(axis) + origin[dim];
-            min = Math.min(proj_1, min);
-            max = Math.max(proj_1, max);
+            min = mathMin(proj_1, min);
+            max = mathMax(proj_1, max);
         }
-        out[0] = min;
-        out[1] = max;
+        out[0] = min + _intersectCtx.touchThreshold;
+        out[1] = max - _intersectCtx.touchThreshold;
+        _intersectCtx.negativeSize = out[1] < out[0];
     };
     return OrientedBoundingRect;
 }());

package/lib/core/PathProxy.d.ts

@@ -60,6 +60,7 @@ export default class PathProxy {
     private _calculateLength;
     rebuildPath(ctx: PathRebuilder, percent: number): void;
     clone(): PathProxy;
+    canSave(): boolean;
     private static initDefaultProps;
 }
 export interface PathRebuilder {

package/lib/core/PathProxy.js

@@ -211,6 +211,9 @@ var PathProxy = (function () {
         return this._len;
     };
     PathProxy.prototype.setData = function (data) {
+        if (!this._saveData) {
+            return;
+        }
         var len = data.length;
         if (!(this.data && this.data.length === len) && hasTypedArray) {
             this.data = new Float32Array(len);
@@ -221,6 +224,9 @@ var PathProxy = (function () {
         this._len = len;
     };
     PathProxy.prototype.appendPath = function (path) {
+        if (!this._saveData) {
+            return;
+        }
         if (!(path instanceof Array)) {
             path = [path];
         }
@@ -230,8 +236,14 @@ var PathProxy = (function () {
         for (var i = 0; i < len; i++) {
             appendSize += path[i].len();
         }
-        if (hasTypedArray && (this.data instanceof Float32Array)) {
+        var oldData = this.data;
+        if (hasTypedArray && (oldData instanceof Float32Array || !oldData)) {
             this.data = new Float32Array(offset + appendSize);
+            if (offset > 0 && oldData) {
+                for (var k = 0; k < offset; k++) {
+                    this.data[k] = oldData[k];
+                }
+            }
         }
         for (var i = 0; i < len; i++) {
             var appendPathData = path[i].data;
@@ -683,6 +695,9 @@ var PathProxy = (function () {
         newProxy._len = this._len;
         return newProxy;
     };
+    PathProxy.prototype.canSave = function () {
+        return !!this._saveData;
+    };
     PathProxy.CMD = CMD;
     PathProxy.initDefaultProps = (function () {
         var proto = PathProxy.prototype;

package/lib/core/types.d.ts

@@ -5,6 +5,7 @@ export declare type ArrayLike<T> = {
     [key: number]: T;
     length: number;
 };
+export declare type NullUndefined = null | undefined;
 export declare type ImageLike = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
 export declare type TextVerticalAlign = 'top' | 'middle' | 'bottom';
 export declare type TextAlign = 'left' | 'center' | 'right';

package/lib/core/util.d.ts

@@ -97,3 +97,4 @@ export declare function disableUserSelect(dom: HTMLElement): void;
 export declare function hasOwn(own: object, prop: string): boolean;
 export declare function noop(): void;
 export declare const RADIAN_TO_DEGREE: number;
+export declare const EPSILON: number;

package/lib/core/util.js

@@ -540,3 +540,4 @@ export function hasOwn(own, prop) {
 }
 export function noop() { }
 export var RADIAN_TO_DEGREE = 180 / Math.PI;
+export var EPSILON = Number.EPSILON || Math.pow(2, -52);

package/lib/graphic/Displayable.js

@@ -58,7 +58,7 @@ var Displayable = (function (_super) {
             || (m && !m[0] && !m[3])) {
             return false;
         }
-        if (considerClipPath && this.__clipPaths) {
+        if (considerClipPath && this.__clipPaths && this.__clipPaths.length) {
             for (var i = 0; i < this.__clipPaths.length; ++i) {
                 if (this.__clipPaths[i].isZeroArea()) {
                     return false;

package/lib/graphic/Text.d.ts

@@ -1,4 +1,4 @@
-import { TextAlign, TextVerticalAlign, ImageLike, Dictionary, MapToType, FontWeight, FontStyle } from '../core/types';
+import { TextAlign, TextVerticalAlign, ImageLike, Dictionary, MapToType, FontWeight, FontStyle, NullUndefined } from '../core/types';
 import TSpan from './TSpan';
 import ZRImage from './Image';
 import Rect from './shape/Rect';
@@ -43,7 +43,7 @@ export interface TextStylePropsPart {
         image: ImageLike | string;
     };
     padding?: number | number[];
-    margin?: number;
+    margin?: number | number[];
     borderColor?: string;
     borderWidth?: number;
     borderRadius?: number | number[];
@@ -75,6 +75,7 @@ export interface TextProps extends DisplayableProps {
 export declare type TextState = Pick<TextProps, DisplayableStatePropNames> & ElementCommonState;
 export declare type DefaultTextStyle = Pick<TextStyleProps, 'fill' | 'stroke' | 'align' | 'verticalAlign'> & {
     autoStroke?: boolean;
+    overflowRect?: BoundingRect | NullUndefined;
 };
 export declare const DEFAULT_TEXT_ANIMATION_PROPS: MapToType<TextProps, boolean>;
 interface ZRText {

package/lib/graphic/Text.js

@@ -1,5 +1,5 @@
 import { __extends } from "tslib";
-import { parseRichText, parsePlainText } from './helper/parseText.js';
+import { parseRichText, parsePlainText, calcInnerTextOverflowArea } from './helper/parseText.js';
 import TSpan from './TSpan.js';
 import { retrieve2, each, normalizeCssArray, trim, retrieve3, extend, keys, defaults } from '../core/util.js';
 import { adjustTextX, adjustTextY } from '../contain/text.js';
@@ -12,6 +12,7 @@ var DEFAULT_RICH_TEXT_COLOR = {
     fill: '#000'
 };
 var DEFAULT_STROKE_LINE_WIDTH = 2;
+var tmpCITOverflowAreaOut = {};
 export var DEFAULT_TEXT_ANIMATION_PROPS = {
     style: defaults({
         fill: true,
@@ -185,8 +186,16 @@ var ZRText = (function (_super) {
         var style = this.style;
         var textFont = style.font || DEFAULT_FONT;
         var textPadding = style.padding;
+        var defaultStyle = this._defaultStyle;
+        var baseX = style.x || 0;
+        var baseY = style.y || 0;
+        var textAlign = style.align || defaultStyle.align || 'left';
+        var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign || 'top';
+        calcInnerTextOverflowArea(tmpCITOverflowAreaOut, defaultStyle.overflowRect, baseX, baseY, textAlign, verticalAlign);
+        baseX = tmpCITOverflowAreaOut.baseX;
+        baseY = tmpCITOverflowAreaOut.baseY;
         var text = getStyleText(style);
-        var contentBlock = parsePlainText(text, style);
+        var contentBlock = parsePlainText(text, style, tmpCITOverflowAreaOut.outerWidth, tmpCITOverflowAreaOut.outerHeight);
         var needDrawBg = needDrawBackground(style);
         var bgColorDrawn = !!(style.backgroundColor);
         var outerHeight = contentBlock.outerHeight;
@@ -194,12 +203,7 @@ var ZRText = (function (_super) {
         var contentWidth = contentBlock.contentWidth;
         var textLines = contentBlock.lines;
         var lineHeight = contentBlock.lineHeight;
-        var defaultStyle = this._defaultStyle;
         this.isTruncated = !!contentBlock.isTruncated;
-        var baseX = style.x || 0;
-        var baseY = style.y || 0;
-        var textAlign = style.align || defaultStyle.align || 'left';
-        var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign || 'top';
         var textX = baseX;
         var textY = adjustTextY(baseY, contentBlock.contentHeight, verticalAlign);
         if (needDrawBg || textPadding) {
@@ -268,17 +272,20 @@ var ZRText = (function (_super) {
     };
     ZRText.prototype._updateRichTexts = function () {
         var style = this.style;
+        var defaultStyle = this._defaultStyle;
+        var textAlign = style.align || defaultStyle.align;
+        var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign;
+        var baseX = style.x || 0;
+        var baseY = style.y || 0;
+        calcInnerTextOverflowArea(tmpCITOverflowAreaOut, defaultStyle.overflowRect, baseX, baseY, textAlign, verticalAlign);
+        baseX = tmpCITOverflowAreaOut.baseX;
+        baseY = tmpCITOverflowAreaOut.baseY;
         var text = getStyleText(style);
-        var contentBlock = parseRichText(text, style);
+        var contentBlock = parseRichText(text, style, tmpCITOverflowAreaOut.outerWidth, tmpCITOverflowAreaOut.outerHeight, textAlign);
         var contentWidth = contentBlock.width;
         var outerWidth = contentBlock.outerWidth;
         var outerHeight = contentBlock.outerHeight;
         var textPadding = style.padding;
-        var baseX = style.x || 0;
-        var baseY = style.y || 0;
-        var defaultStyle = this._defaultStyle;
-        var textAlign = style.align || defaultStyle.align;
-        var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign;
         this.isTruncated = !!contentBlock.isTruncated;
         var boxX = adjustTextX(baseX, outerWidth, textAlign);
         var boxY = adjustTextY(baseY, outerHeight, verticalAlign);

package/lib/graphic/helper/parseText.d.ts

@@ -1,5 +1,5 @@
-import { TextAlign, TextVerticalAlign } from '../../core/types';
-import { TextStyleProps } from '../Text';
+import { TextAlign, TextVerticalAlign, NullUndefined } from '../../core/types';
+import { DefaultTextStyle, TextStyleProps } from '../Text';
 interface InnerTruncateOption {
     maxIteration?: number;
     minChar?: number;
@@ -19,7 +19,7 @@ export interface PlainTextContentBlock {
     lines: string[];
     isTruncated: boolean;
 }
-export declare function parsePlainText(text: string, style?: TextStyleProps): PlainTextContentBlock;
+export declare function parsePlainText(text: string, style: Omit<TextStyleProps, 'align' | 'verticalAlign'>, defaultOuterWidth: number | NullUndefined, defaultOuterHeight: number | NullUndefined): PlainTextContentBlock;
 declare class RichTextToken {
     styleName: string;
     text: string;
@@ -52,5 +52,12 @@ export declare class RichTextContentBlock {
     lines: RichTextLine[];
     isTruncated: boolean;
 }
-export declare function parseRichText(text: string, style: TextStyleProps): RichTextContentBlock;
+export declare function parseRichText(text: string, style: Omit<TextStyleProps, 'align' | 'verticalAlign'>, defaultOuterWidth: number | NullUndefined, defaultOuterHeight: number | NullUndefined, topTextAlign: TextAlign): RichTextContentBlock;
+export declare function calcInnerTextOverflowArea(out: CalcInnerTextOverflowAreaOut, overflowRect: DefaultTextStyle['overflowRect'], baseX: number, baseY: number, textAlign: TextAlign, textVerticalAlign: TextVerticalAlign): void;
+export declare type CalcInnerTextOverflowAreaOut = {
+    baseX: number;
+    baseY: number;
+    outerWidth: number | NullUndefined;
+    outerHeight: number | NullUndefined;
+};
 export {};