zrender-nightly 5.7.0-dev.20250620 → 5.7.0-dev.20250622

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/dom.d.ts

@@ -1,4 +1,5 @@
 export declare function transformLocalCoord(out: number[], elFrom: HTMLElement, elTarget: HTMLElement, inX: number, inY: number): boolean;
+export declare function transformLocalCoordClear(elFrom: HTMLElement, elTarget: HTMLElement): void;
 export declare function transformCoordWithViewport(out: number[], el: HTMLElement, inX: number, inY: number, inverse?: boolean): boolean;
 export declare function isCanvasEl(el: HTMLElement): el is HTMLCanvasElement;
 export declare function encodeHTML(source: string): string;

package/lib/core/dom.js

@@ -1,11 +1,23 @@
 import env from './env.js';
 import { buildTransformer } from './fourPointsTransform.js';
+import { each } from './util.js';
 var EVENT_SAVED_PROP = '___zrEVENTSAVED';
 var _calcOut = [];
 export function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
     return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
         && transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
 }
+export function transformLocalCoordClear(elFrom, elTarget) {
+    elFrom && dealClear(elFrom);
+    elTarget && dealClear(elTarget);
+    function dealClear(el) {
+        var saved = el[EVENT_SAVED_PROP];
+        if (saved) {
+            saved.clearMarkers && saved.clearMarkers();
+            delete el[EVENT_SAVED_PROP];
+        }
+    }
+}
 export function transformCoordWithViewport(out, el, inX, inY, inverse) {
     if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
         var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
@@ -49,6 +61,11 @@ function prepareCoordMarkers(el, saved) {
         el.appendChild(marker);
         markers.push(marker);
     }
+    saved.clearMarkers = function () {
+        each(markers, function (marker) {
+            marker.parentNode && marker.parentNode.removeChild(marker);
+        });
+    };
     return markers;
 }
 function preparePointerTransformer(markers, saved, inverse) {

package/lib/core/env.js

@@ -32,7 +32,10 @@ if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
 else if (typeof document === 'undefined' && typeof self !== 'undefined') {
     env.worker = true;
 }
-else if (!env.hasGlobalWindow || 'Deno' in window) {
+else if (!env.hasGlobalWindow
+    || 'Deno' in window
+    || (typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string'
+        && navigator.userAgent.indexOf('Node.js') > -1)) {
     env.node = true;
     env.svgSupported = true;
 }
@@ -66,14 +69,16 @@ function detect(ua, env) {
     env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
     env.pointerEventsSupported = 'onpointerdown' in window
         && (browser.edge || (browser.ie && +browser.version >= 11));
-    env.domSupported = typeof document !== 'undefined';
-    var style = document.documentElement.style;
-    env.transform3dSupported = ((browser.ie && 'transition' in style)
-        || browser.edge
-        || (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
-        || 'MozPerspective' in style)
-        && !('OTransition' in style);
-    env.transformSupported = env.transform3dSupported
-        || (browser.ie && +browser.version >= 9);
+    var domSupported = env.domSupported = typeof document !== 'undefined';
+    if (domSupported) {
+        var style = document.documentElement.style;
+        env.transform3dSupported = ((browser.ie && 'transition' in style)
+            || browser.edge
+            || (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
+            || 'MozPerspective' in style)
+            && !('OTransition' in style);
+        env.transformSupported = env.transform3dSupported
+            || (browser.ie && +browser.version >= 9);
+    }
 }
 export default env;

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

@@ -135,7 +135,7 @@ export function extend(target, source) {
 }
 export function defaults(target, source, overlay) {
     var keysArr = keys(source);
-    for (var i = 0; i < keysArr.length; i++) {
+    for (var i = 0, len = keysArr.length; i < len; i++) {
         var key = keysArr[i];
         if ((overlay ? source[key] != null : target[key] == null)) {
             target[key] = source[key];
@@ -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 {
@@ -90,6 +91,7 @@ declare class ZRText extends Displayable<TextProps> implements GroupLike {
     style: TextStyleProps;
     overlap: 'hidden' | 'show' | 'blur';
     innerTransformable: Transformable;
+    isTruncated: boolean;
     private _children;
     private _childCursor;
     private _defaultStyle;