@visactor/vrender-core 0.16.14-alpha.3 → 0.16.14-alpha.4

package/dist/index.js

@@ -4294,10 +4294,7 @@
         direction: 'horizontal',
         wordBreak: 'break-all',
         ignoreBuf: false,
-        verticalMode: 0,
-        whiteSpace: 'no-wrap',
-        heightLimit: Infinity,
-        lineClamp: Infinity
+        verticalMode: 0
     };
     const DefaultStyle = Object.assign(Object.assign(Object.assign({ opacity: 1, background: null, texture: null, textureColor: 'black', textureSize: 10, texturePadding: 2, backgroundMode: 0, blur: 0, cursor: null, html: null }, DefaultFillStyle), DefaultStrokeStyle), DefaultLayout);
     const DefaultConnectAttribute = {
@@ -5425,247 +5422,6 @@
         return containPath(commands, lineWidth, true, x, y);
     }
 
-    exports.Edge = void 0;
-    (function (Edge) {
-        Edge[Edge["Top"] = 1] = "Top";
-        Edge[Edge["Right"] = 2] = "Right";
-        Edge[Edge["Bottom"] = 4] = "Bottom";
-        Edge[Edge["Left"] = 8] = "Left";
-        Edge[Edge["ALL"] = 15] = "ALL";
-    })(exports.Edge || (exports.Edge = {}));
-    const _strokeVec4 = [
-        false,
-        false,
-        false,
-        false
-    ];
-    const parseStroke = (stroke) => {
-        var _a;
-        let isFullStroke = true;
-        if (vutils.isBoolean(stroke, true)) {
-            for (let i = 0; i < 4; i++) {
-                _strokeVec4[i] = stroke;
-                isFullStroke && (isFullStroke = !!((_a = _strokeVec4[i]) !== null && _a !== void 0 ? _a : true));
-            }
-            isFullStroke = stroke;
-        }
-        else if (Array.isArray(stroke)) {
-            for (let i = 0; i < 4; i++) {
-                _strokeVec4[i] = !!stroke[i];
-                isFullStroke && (isFullStroke = !!_strokeVec4[i]);
-            }
-        }
-        else {
-            _strokeVec4[0] = false;
-            _strokeVec4[1] = false;
-            _strokeVec4[2] = false;
-            _strokeVec4[3] = false;
-        }
-        return {
-            isFullStroke,
-            stroke: _strokeVec4
-        };
-    };
-    const _paddingVec4 = [0, 0, 0, 0];
-    const parsePadding = (padding) => {
-        if (!padding) {
-            return 0;
-        }
-        if (vutils.isArray(padding)) {
-            if (padding.length === 0) {
-                return 0;
-            }
-            else if (padding.length === 1) {
-                return padding[0];
-            }
-            else if (padding.length === 2) {
-                _paddingVec4[0] = padding[0];
-                _paddingVec4[2] = padding[0];
-                _paddingVec4[1] = padding[1];
-                _paddingVec4[3] = padding[1];
-                return _paddingVec4;
-            }
-            return padding;
-        }
-        return padding;
-    };
-    const _coords = [
-        { x: 0, y: 0 },
-        { x: 0, y: 0 },
-        { x: 0, y: 0 },
-        { x: 0, y: 0 }
-    ];
-    const indexList = [1, 2, 3, 0, 1, 2, 3, 0];
-    function circleBounds(startAngle, endAngle, radius, bounds) {
-        while (startAngle >= vutils.pi2) {
-            startAngle -= vutils.pi2;
-        }
-        while (startAngle < 0) {
-            startAngle += vutils.pi2;
-        }
-        while (startAngle > endAngle) {
-            endAngle += vutils.pi2;
-        }
-        _coords[0].x = radius;
-        _coords[1].y = radius;
-        _coords[2].x = -radius;
-        _coords[3].y = -radius;
-        const startIdx = Math.ceil(startAngle / vutils.halfPi) % 4;
-        const endIdx = Math.ceil(endAngle / vutils.halfPi) % 4;
-        bounds.add(vutils.cos(startAngle) * radius, vutils.sin(startAngle) * radius);
-        bounds.add(vutils.cos(endAngle) * radius, vutils.sin(endAngle) * radius);
-        if (startIdx !== endIdx || endAngle - startAngle > vutils.pi) {
-            let match = false;
-            for (let i = 0; i < indexList.length; i++) {
-                if (!match && startIdx === indexList[i]) {
-                    match = true;
-                    const p = _coords[startIdx];
-                    bounds.add(p.x, p.y);
-                    continue;
-                }
-                else if (match && endIdx === indexList[i]) {
-                    break;
-                }
-                if (match) {
-                    const p = _coords[indexList[i]];
-                    bounds.add(p.x, p.y);
-                }
-            }
-        }
-    }
-    function pointsEqual(pointsA, pointsB) {
-        if (!pointsA || !pointsB) {
-            return false;
-        }
-        if (Array.isArray(pointsA) && Array.isArray(pointsB)) {
-            if (pointsA.length !== pointsB.length) {
-                return false;
-            }
-            return pointsA.every((point, index) => pointEqual(point, pointsB[index]));
-        }
-        if (!Number.isNaN(pointsA.x + pointsA.y)) {
-            return pointEqual(pointsA, pointsB);
-        }
-        return false;
-    }
-    function pointEqual(pointA, pointB) {
-        return (pointA.x === pointB.x &&
-            pointA.y === pointB.y &&
-            pointA.x1 === pointB.x1 &&
-            pointA.y1 === pointB.y1 &&
-            pointA.defined === pointB.defined);
-    }
-    function pointInterpolation(pointA, pointB, ratio) {
-        const { x, y } = vutils.pointAt(pointA.x, pointA.y, pointB.x, pointB.y, ratio);
-        const { x: x1, y: y1 } = vutils.pointAt(pointA.x1, pointA.y1, pointB.x1, pointB.y1, ratio);
-        const point = new vutils.Point(x, y, x1, y1);
-        point.defined = pointB.defined;
-        return point;
-    }
-    function pointInterpolationHighPerformance(pointA, pointB, ratio, point) {
-        const { x, y } = vutils.pointAt(pointA.x, pointA.y, pointB.x, pointB.y, ratio);
-        const { x: x1, y: y1 } = vutils.pointAt(pointA.x1, pointA.y1, pointB.x1, pointB.y1, ratio);
-        point.x = x;
-        point.y = y;
-        point.x1 = x1;
-        point.y1 = y1;
-        point.defined = pointB.defined;
-        return point;
-    }
-    function pointsInterpolation(pointsA, pointsB, ratio) {
-        if (!pointsA || !pointsB) {
-            return [];
-        }
-        if (!Array.isArray(pointsA)) {
-            pointsA = [pointsA];
-        }
-        if (!Array.isArray(pointsB)) {
-            pointsB = [pointsB];
-        }
-        let points = [];
-        if (pointsA.length > pointsB.length) {
-            points = pointsB.map(point => {
-                const p = new vutils.Point(point.x, point.y, point.x1, point.y1);
-                p.defined = point.defined;
-                return p;
-            });
-            for (let i = 0; i < pointsB.length; i++) {
-                points[i] = pointInterpolation(pointsA[i], pointsB[i], ratio);
-            }
-        }
-        else {
-            points = pointsB.map(point => {
-                const p = new vutils.Point(point.x, point.y, point.x1, point.y1);
-                p.defined = point.defined;
-                return p;
-            });
-            for (let i = 0; i < pointsA.length; i++) {
-                points[i] = pointInterpolation(pointsA[i], pointsB[i], ratio);
-            }
-        }
-        return points;
-    }
-    const transformKeys = [
-        'x',
-        'y',
-        'dx',
-        'dy',
-        'scaleX',
-        'scaleY',
-        'angle',
-        'anchor',
-        'postMatrix',
-        'scrollX',
-        'scrollY'
-    ];
-    const isTransformKey = (key) => {
-        return transformKeys.includes(key);
-    };
-    function getAttributeFromDefaultAttrList(attr, key) {
-        if (vutils.isArray(attr)) {
-            let val;
-            for (let i = 0; i < attr.length && val === undefined; i++) {
-                val = attr[i][key];
-            }
-            return val;
-        }
-        return attr[key];
-    }
-    class RafBasedSTO {
-        constructor() {
-            this.durations = [];
-            this.timeout = RafBasedSTO.TimeOut;
-            this.lastDate = 0;
-            this.durationsListThreshold = 30;
-        }
-        call(cb) {
-            this.lastDate = Date.now();
-            return setTimeout(() => {
-                this.appendDuration(Date.now() - this.lastDate);
-                cb(0);
-            }, this.timeout, true);
-        }
-        clear(h) {
-            clearTimeout(h);
-        }
-        appendDuration(d) {
-            this.durations.push(d);
-            if (this.durations.length > this.durationsListThreshold) {
-                this.durations.shift();
-            }
-            this.timeout = Math.min(Math.max(this.durations.reduce((a, b) => a + b, 0) / this.durations.length, 1000 / 60), 1000 / 30);
-        }
-    }
-    RafBasedSTO.TimeOut = 1000 / 60;
-    const rafBasedSto = new RafBasedSTO();
-    const calculateLineHeight = (lineHeight, fontSize) => {
-        if (vutils.isString(lineHeight) && lineHeight[lineHeight.length - 1] === '%') {
-            const scale = Number.parseFloat(lineHeight.substring(0, lineHeight.length - 1)) / 100;
-            return fontSize * scale;
-        }
-        return lineHeight;
-    };
-
     exports.DefaultGraphicUtil = class DefaultGraphicUtil {
         constructor(contributions, global) {
             this.contributions = contributions;
@@ -5716,7 +5472,7 @@
             return new vutils.TextMeasure(Object.assign({ defaultFontParams: {
                     fontFamily: DefaultTextStyle.fontFamily,
                     fontSize: DefaultTextStyle.fontSize
-                }, getCanvasForMeasure: getCanvasForMeasure || (() => this.canvas), getTextBounds: undefined, specialCharSet: '-/: .,@%\'"~' + vutils.TextMeasure.ALPHABET_CHAR_SET + vutils.TextMeasure.ALPHABET_CHAR_SET.toUpperCase() }, (option !== null && option !== void 0 ? option : {})), Object.assign(Object.assign({}, textSpec), { lineHeight: calculateLineHeight(textSpec === null || textSpec === void 0 ? void 0 : textSpec.lineHeight, textSpec === null || textSpec === void 0 ? void 0 : textSpec.fontSize) }));
+                }, getCanvasForMeasure: getCanvasForMeasure || (() => this.canvas), getTextBounds: undefined, specialCharSet: '-/: .,@%\'"~' + vutils.TextMeasure.ALPHABET_CHAR_SET + vutils.TextMeasure.ALPHABET_CHAR_SET.toUpperCase() }, (option !== null && option !== void 0 ? option : {})), textSpec);
         }
     };
     exports.DefaultGraphicUtil = __decorate([
@@ -8964,65 +8720,299 @@
                 }
             }
         }
-        getLastPropByName(name, step) {
-            let lastStep = step.prev;
-            while (lastStep) {
-                if (lastStep.props && lastStep.props[name] !== undefined) {
-                    return lastStep.props[name];
-                }
-                else if (lastStep.customAnimate) {
-                    const val = lastStep.customAnimate.getEndProps()[name];
-                    if (val !== undefined) {
-                        return val;
-                    }
-                }
-                lastStep = lastStep.prev;
+        getLastPropByName(name, step) {
+            let lastStep = step.prev;
+            while (lastStep) {
+                if (lastStep.props && lastStep.props[name] !== undefined) {
+                    return lastStep.props[name];
+                }
+                else if (lastStep.customAnimate) {
+                    const val = lastStep.customAnimate.getEndProps()[name];
+                    if (val !== undefined) {
+                        return val;
+                    }
+                }
+                lastStep = lastStep.prev;
+            }
+            console.warn('未知错误，step中找不到属性');
+            return step.props[name];
+        }
+        updateTarget(step, ratio, end) {
+            if (step.props == null && step.customAnimate == null) {
+                return;
+            }
+            this.target.onStep(this, this.animate, step, ratio, end);
+        }
+    }
+    class Step {
+        constructor(position, duration, props, easing) {
+            this.duration = duration;
+            this.position = position;
+            this.props = props;
+            this.easing = easing;
+        }
+        append(step) {
+            step.prev = this;
+            step.next = this.next;
+            this.next = step;
+        }
+        getLastProps() {
+            let step = this.prev;
+            while (step) {
+                if (step.props) {
+                    return step.props;
+                }
+                else if (step.customAnimate) {
+                    return step.customAnimate.getMergedEndProps();
+                }
+                step = step.prev;
+            }
+            return null;
+        }
+    }
+
+    const DefaultStateAnimateConfig = {
+        duration: 200,
+        easing: 'cubicOut'
+    };
+    const DefaultMorphingAnimateConfig = {
+        duration: 1000,
+        easing: 'quadInOut'
+    };
+
+    exports.Edge = void 0;
+    (function (Edge) {
+        Edge[Edge["Top"] = 1] = "Top";
+        Edge[Edge["Right"] = 2] = "Right";
+        Edge[Edge["Bottom"] = 4] = "Bottom";
+        Edge[Edge["Left"] = 8] = "Left";
+        Edge[Edge["ALL"] = 15] = "ALL";
+    })(exports.Edge || (exports.Edge = {}));
+    const _strokeVec4 = [
+        false,
+        false,
+        false,
+        false
+    ];
+    const parseStroke = (stroke) => {
+        var _a;
+        let isFullStroke = true;
+        if (vutils.isBoolean(stroke, true)) {
+            for (let i = 0; i < 4; i++) {
+                _strokeVec4[i] = stroke;
+                isFullStroke && (isFullStroke = !!((_a = _strokeVec4[i]) !== null && _a !== void 0 ? _a : true));
+            }
+            isFullStroke = stroke;
+        }
+        else if (Array.isArray(stroke)) {
+            for (let i = 0; i < 4; i++) {
+                _strokeVec4[i] = !!stroke[i];
+                isFullStroke && (isFullStroke = !!_strokeVec4[i]);
+            }
+        }
+        else {
+            _strokeVec4[0] = false;
+            _strokeVec4[1] = false;
+            _strokeVec4[2] = false;
+            _strokeVec4[3] = false;
+        }
+        return {
+            isFullStroke,
+            stroke: _strokeVec4
+        };
+    };
+    const _paddingVec4 = [0, 0, 0, 0];
+    const parsePadding = (padding) => {
+        if (!padding) {
+            return 0;
+        }
+        if (vutils.isArray(padding)) {
+            if (padding.length === 0) {
+                return 0;
+            }
+            else if (padding.length === 1) {
+                return padding[0];
+            }
+            else if (padding.length === 2) {
+                _paddingVec4[0] = padding[0];
+                _paddingVec4[2] = padding[0];
+                _paddingVec4[1] = padding[1];
+                _paddingVec4[3] = padding[1];
+                return _paddingVec4;
+            }
+            return padding;
+        }
+        return padding;
+    };
+    const _coords = [
+        { x: 0, y: 0 },
+        { x: 0, y: 0 },
+        { x: 0, y: 0 },
+        { x: 0, y: 0 }
+    ];
+    const indexList = [1, 2, 3, 0, 1, 2, 3, 0];
+    function circleBounds(startAngle, endAngle, radius, bounds) {
+        while (startAngle >= vutils.pi2) {
+            startAngle -= vutils.pi2;
+        }
+        while (startAngle < 0) {
+            startAngle += vutils.pi2;
+        }
+        while (startAngle > endAngle) {
+            endAngle += vutils.pi2;
+        }
+        _coords[0].x = radius;
+        _coords[1].y = radius;
+        _coords[2].x = -radius;
+        _coords[3].y = -radius;
+        const startIdx = Math.ceil(startAngle / vutils.halfPi) % 4;
+        const endIdx = Math.ceil(endAngle / vutils.halfPi) % 4;
+        bounds.add(vutils.cos(startAngle) * radius, vutils.sin(startAngle) * radius);
+        bounds.add(vutils.cos(endAngle) * radius, vutils.sin(endAngle) * radius);
+        if (startIdx !== endIdx || endAngle - startAngle > vutils.pi) {
+            let match = false;
+            for (let i = 0; i < indexList.length; i++) {
+                if (!match && startIdx === indexList[i]) {
+                    match = true;
+                    const p = _coords[startIdx];
+                    bounds.add(p.x, p.y);
+                    continue;
+                }
+                else if (match && endIdx === indexList[i]) {
+                    break;
+                }
+                if (match) {
+                    const p = _coords[indexList[i]];
+                    bounds.add(p.x, p.y);
+                }
+            }
+        }
+    }
+    function pointsEqual(pointsA, pointsB) {
+        if (!pointsA || !pointsB) {
+            return false;
+        }
+        if (Array.isArray(pointsA) && Array.isArray(pointsB)) {
+            if (pointsA.length !== pointsB.length) {
+                return false;
+            }
+            return pointsA.every((point, index) => pointEqual(point, pointsB[index]));
+        }
+        if (!Number.isNaN(pointsA.x + pointsA.y)) {
+            return pointEqual(pointsA, pointsB);
+        }
+        return false;
+    }
+    function pointEqual(pointA, pointB) {
+        return (pointA.x === pointB.x &&
+            pointA.y === pointB.y &&
+            pointA.x1 === pointB.x1 &&
+            pointA.y1 === pointB.y1 &&
+            pointA.defined === pointB.defined);
+    }
+    function pointInterpolation(pointA, pointB, ratio) {
+        const { x, y } = vutils.pointAt(pointA.x, pointA.y, pointB.x, pointB.y, ratio);
+        const { x: x1, y: y1 } = vutils.pointAt(pointA.x1, pointA.y1, pointB.x1, pointB.y1, ratio);
+        const point = new vutils.Point(x, y, x1, y1);
+        point.defined = pointB.defined;
+        return point;
+    }
+    function pointInterpolationHighPerformance(pointA, pointB, ratio, point) {
+        const { x, y } = vutils.pointAt(pointA.x, pointA.y, pointB.x, pointB.y, ratio);
+        const { x: x1, y: y1 } = vutils.pointAt(pointA.x1, pointA.y1, pointB.x1, pointB.y1, ratio);
+        point.x = x;
+        point.y = y;
+        point.x1 = x1;
+        point.y1 = y1;
+        point.defined = pointB.defined;
+        return point;
+    }
+    function pointsInterpolation(pointsA, pointsB, ratio) {
+        if (!pointsA || !pointsB) {
+            return [];
+        }
+        if (!Array.isArray(pointsA)) {
+            pointsA = [pointsA];
+        }
+        if (!Array.isArray(pointsB)) {
+            pointsB = [pointsB];
+        }
+        let points = [];
+        if (pointsA.length > pointsB.length) {
+            points = pointsB.map(point => {
+                const p = new vutils.Point(point.x, point.y, point.x1, point.y1);
+                p.defined = point.defined;
+                return p;
+            });
+            for (let i = 0; i < pointsB.length; i++) {
+                points[i] = pointInterpolation(pointsA[i], pointsB[i], ratio);
+            }
+        }
+        else {
+            points = pointsB.map(point => {
+                const p = new vutils.Point(point.x, point.y, point.x1, point.y1);
+                p.defined = point.defined;
+                return p;
+            });
+            for (let i = 0; i < pointsA.length; i++) {
+                points[i] = pointInterpolation(pointsA[i], pointsB[i], ratio);
             }
-            console.warn('未知错误，step中找不到属性');
-            return step.props[name];
         }
-        updateTarget(step, ratio, end) {
-            if (step.props == null && step.customAnimate == null) {
-                return;
+        return points;
+    }
+    const transformKeys = [
+        'x',
+        'y',
+        'dx',
+        'dy',
+        'scaleX',
+        'scaleY',
+        'angle',
+        'anchor',
+        'postMatrix',
+        'scrollX',
+        'scrollY'
+    ];
+    const isTransformKey = (key) => {
+        return transformKeys.includes(key);
+    };
+    function getAttributeFromDefaultAttrList(attr, key) {
+        if (vutils.isArray(attr)) {
+            let val;
+            for (let i = 0; i < attr.length && val === undefined; i++) {
+                val = attr[i][key];
             }
-            this.target.onStep(this, this.animate, step, ratio, end);
+            return val;
         }
+        return attr[key];
     }
-    class Step {
-        constructor(position, duration, props, easing) {
-            this.duration = duration;
-            this.position = position;
-            this.props = props;
-            this.easing = easing;
+    class RafBasedSTO {
+        constructor() {
+            this.durations = [];
+            this.timeout = RafBasedSTO.TimeOut;
+            this.lastDate = 0;
+            this.durationsListThreshold = 30;
         }
-        append(step) {
-            step.prev = this;
-            step.next = this.next;
-            this.next = step;
+        call(cb) {
+            this.lastDate = Date.now();
+            return setTimeout(() => {
+                this.appendDuration(Date.now() - this.lastDate);
+                cb(0);
+            }, this.timeout, true);
         }
-        getLastProps() {
-            let step = this.prev;
-            while (step) {
-                if (step.props) {
-                    return step.props;
-                }
-                else if (step.customAnimate) {
-                    return step.customAnimate.getMergedEndProps();
-                }
-                step = step.prev;
+        clear(h) {
+            clearTimeout(h);
+        }
+        appendDuration(d) {
+            this.durations.push(d);
+            if (this.durations.length > this.durationsListThreshold) {
+                this.durations.shift();
             }
-            return null;
+            this.timeout = Math.min(Math.max(this.durations.reduce((a, b) => a + b, 0) / this.durations.length, 1000 / 60), 1000 / 30);
         }
     }
-
-    const DefaultStateAnimateConfig = {
-        duration: 200,
-        easing: 'cubicOut'
-    };
-    const DefaultMorphingAnimateConfig = {
-        duration: 1000,
-        easing: 'quadInOut'
-    };
+    RafBasedSTO.TimeOut = 1000 / 60;
+    const rafBasedSto = new RafBasedSTO();
 
     class IncreaseCount extends ACustomAnimate {
         constructor(from, to, duration, easing, params) {
@@ -14324,8 +14314,6 @@
     const TEXT_UPDATE_TAG_KEY = [
         'text',
         'maxLineWidth',
-        'heightLimit',
-        'lineClamp',
         'fontSize',
         'fontFamily',
         'fontWeight',
@@ -14410,113 +14398,6 @@
             this.clearUpdateBoundTag();
             return bounds;
         }
-        updateWrapAABBBounds(text) {
-            var _a, _b, _c, _d;
-            const textTheme = getTheme(this).text;
-            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
-            const lineHeight = (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (this.attribute.fontSize || textTheme.fontSize);
-            const buf = ignoreBuf ? 0 : 2;
-            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
-                const bbox = this.cache.layoutData.bbox;
-                this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
-                if (stroke) {
-                    this._AABBBounds.expand(lineWidth / 2);
-                }
-                return this._AABBBounds;
-            }
-            const textMeasure = application.graphicUtil.textMeasure;
-            const layoutObj = new CanvasTextLayout(fontFamily, { fontSize, fontWeight, fontFamily }, textMeasure);
-            const lines = vutils.isArray(text) ? text.map(l => l.toString()) : [text.toString()];
-            const linesLayout = [];
-            const bboxWH = [0, 0];
-            let lineCountLimit = Infinity;
-            if (heightLimit > 0) {
-                lineCountLimit = Math.max(Math.floor(heightLimit / lineHeight), 1);
-            }
-            if (lineClamp) {
-                lineCountLimit = Math.min(lineCountLimit, lineClamp);
-            }
-            if (typeof maxLineWidth === 'number' && maxLineWidth !== Infinity) {
-                if (maxLineWidth > 0) {
-                    for (let i = 0; i < lines.length; i++) {
-                        const str = lines[i];
-                        let needCut = true;
-                        if (i === lineCountLimit - 1) {
-                            const clip = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
-                            linesLayout.push({
-                                str: clip.str,
-                                width: clip.width
-                            });
-                            break;
-                        }
-                        const clip = layoutObj.textMeasure.clipText(str, layoutObj.textOptions, maxLineWidth, wordBreak === 'break-word');
-                        if (str !== '' && clip.str === '') {
-                            if (ellipsis) {
-                                const clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
-                                clip.str = (_c = clipEllipsis.str) !== null && _c !== void 0 ? _c : '';
-                                clip.width = (_d = clipEllipsis.width) !== null && _d !== void 0 ? _d : 0;
-                            }
-                            else {
-                                clip.str = '';
-                                clip.width = 0;
-                            }
-                            needCut = false;
-                        }
-                        linesLayout.push({
-                            str: clip.str,
-                            width: clip.width
-                        });
-                        if (clip.str.length === str.length) ;
-                        else if (needCut) {
-                            const newStr = str.substring(clip.str.length);
-                            lines.splice(i + 1, 0, newStr);
-                        }
-                    }
-                }
-                let maxWidth = 0;
-                linesLayout.forEach(layout => {
-                    maxWidth = Math.max(maxWidth, layout.width);
-                });
-                bboxWH[0] = maxWidth;
-            }
-            else {
-                let lineWidth = 0;
-                let width;
-                let text;
-                for (let i = 0, len = lines.length; i < len; i++) {
-                    if (i === lineCountLimit - 1) {
-                        const clip = layoutObj.textMeasure.clipTextWithSuffix(lines[i], layoutObj.textOptions, maxLineWidth, ellipsis, false);
-                        linesLayout.push({
-                            str: clip.str,
-                            width: clip.width
-                        });
-                        lineWidth = Math.max(lineWidth, clip.width);
-                        break;
-                    }
-                    text = lines[i];
-                    width = layoutObj.textMeasure.measureTextWidth(text, layoutObj.textOptions, wordBreak === 'break-word');
-                    lineWidth = Math.max(lineWidth, width);
-                    linesLayout.push({ str: text, width });
-                }
-                bboxWH[0] = lineWidth;
-            }
-            bboxWH[1] = linesLayout.length * (lineHeight + buf);
-            const bbox = {
-                xOffset: 0,
-                yOffset: 0,
-                width: bboxWH[0],
-                height: bboxWH[1]
-            };
-            layoutObj.LayoutBBox(bbox, textAlign, textBaseline);
-            const layoutData = layoutObj.layoutWithBBox(bbox, linesLayout, textAlign, textBaseline, lineHeight);
-            this.cache.layoutData = layoutData;
-            this.clearUpdateShapeTag();
-            this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
-            if (stroke) {
-                this._AABBBounds.expand(lineWidth / 2);
-            }
-            return this._AABBBounds;
-        }
         updateSingallineAABBBounds(text) {
             const textTheme = getTheme(this).text;
             const { direction = textTheme.direction } = this.attribute;
@@ -14538,13 +14419,9 @@
             let width;
             let str;
             const attribute = this.attribute;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, ignoreBuf = textTheme.ignoreBuf, whiteSpace = textTheme.whiteSpace } = attribute;
-            if (whiteSpace === 'normal') {
-                return this.updateWrapAABBBounds(text);
-            }
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, ignoreBuf = textTheme.ignoreBuf } = attribute;
             const buf = ignoreBuf ? 0 : Math.max(2, fontSize * 0.075);
-            const textFontSize = attribute.fontSize || textTheme.fontSize;
-            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, textFontSize)) !== null && _a !== void 0 ? _a : textFontSize + buf;
+            const { lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf } = attribute;
             if (!this.shouldUpdateShape() && this.cache) {
                 width = (_b = this.cache.clipedWidth) !== null && _b !== void 0 ? _b : 0;
                 const dx = textDrawOffsetX(textAlign, width);
@@ -14602,8 +14479,7 @@
             const attribute = this.attribute;
             const { ignoreBuf = textTheme.ignoreBuf } = attribute;
             const buf = ignoreBuf ? 0 : 2;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, fontFamily = textTheme.fontFamily, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
-            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, fontFamily = textTheme.fontFamily, stroke = textTheme.stroke, lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
             let { textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline } = attribute;
             if (!verticalMode) {
                 const t = textAlign;
@@ -14660,15 +14536,11 @@
             return this._AABBBounds;
         }
         updateHorizontalMultilineAABBBounds(text) {
-            var _a, _b;
+            var _a;
             const textTheme = getTheme(this).text;
             const attribute = this.attribute;
-            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, whiteSpace = textTheme.whiteSpace } = attribute;
-            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize);
-            if (whiteSpace === 'normal') {
-                return this.updateWrapAABBBounds(text);
-            }
-            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
+            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, lineHeight = attribute.lineHeight || attribute.fontSize || textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak } = attribute;
+            if (!this.shouldUpdateShape() && ((_a = this.cache) === null || _a === void 0 ? void 0 : _a.layoutData)) {
                 const bbox = this.cache.layoutData.bbox;
                 this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
                 if (stroke) {
@@ -14696,8 +14568,7 @@
             const attribute = this.attribute;
             const { ignoreBuf = textTheme.ignoreBuf } = attribute;
             const buf = ignoreBuf ? 0 : 2;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
-            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
             let { textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline } = attribute;
             if (!verticalMode) {
                 const t = textAlign;
@@ -14804,12 +14675,11 @@
             return text != null && text !== '';
         }
         updateMultilineAABBBounds(text) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             const textTheme = getTheme(this).text;
-            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
-            const lineHeight = (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (this.attribute.fontSize || textTheme.fontSize);
+            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, lineHeight = this.attribute.lineHeight || this.attribute.fontSize || textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
             const buf = ignoreBuf ? 0 : 2;
-            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
+            if (!this.shouldUpdateShape() && ((_a = this.cache) === null || _a === void 0 ? void 0 : _a.layoutData)) {
                 const bbox = this.cache.layoutData.bbox;
                 this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
                 if (stroke) {
@@ -14846,8 +14716,8 @@
                         if (str !== '' && clip.str === '') {
                             if (ellipsis) {
                                 const clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
-                                clip.str = (_c = clipEllipsis.str) !== null && _c !== void 0 ? _c : '';
-                                clip.width = (_d = clipEllipsis.width) !== null && _d !== void 0 ? _d : 0;
+                                clip.str = (_b = clipEllipsis.str) !== null && _b !== void 0 ? _b : '';
+                                clip.width = (_c = clipEllipsis.width) !== null && _c !== void 0 ? _c : 0;
                             }
                             else {
                                 clip.str = '';
@@ -20991,7 +20861,7 @@
                 textAlign = (_a = text.getBaselineMapAlign()[textBaseline]) !== null && _a !== void 0 ? _a : 'left';
                 textBaseline = (_b = text.getAlignMapBaseline()[t]) !== null && _b !== void 0 ? _b : 'top';
             }
-            const lineHeight = (_c = calculateLineHeight(text.attribute.lineHeight, fontSize)) !== null && _c !== void 0 ? _c : fontSize;
+            const lineHeight = (_c = text.attribute.lineHeight) !== null && _c !== void 0 ? _c : fontSize;
             const data = this.valid(text, textAttribute, fillCb, strokeCb);
             if (!data) {
                 return;
@@ -26254,19 +26124,6 @@
                 this.setAttributes({ background: this._background });
             }
         }
-        preventRender(prevent) {
-            if (prevent) {
-                this._skipRender = -Infinity;
-            }
-            else {
-                if (this.params && this.params.optimize && this.params.optimize.skipRenderWithOutRange !== false) {
-                    this._skipRender = this.window.isVisible() ? 0 : 1;
-                }
-                else {
-                    this._skipRender = 0;
-                }
-            }
-        }
         optmize(params) {
             this.optmizeRender(params === null || params === void 0 ? void 0 : params.skipRenderWithOutRange);
         }
@@ -26274,11 +26131,8 @@
             if (!skipRenderWithOutRange) {
                 return;
             }
-            this._skipRender = this._skipRender < 0 ? this._skipRender : this.window.isVisible() ? 0 : 1;
+            this._skipRender = this.window.isVisible() ? 0 : 1;
             this.window.onVisibleChange(visible => {
-                if (this._skipRender < 0) {
-                    return;
-                }
                 if (visible) {
                     if (this.dirtyBounds) {
                         this.dirtyBounds.setValue(0, 0, this._viewBox.width(), this._viewBox.height());
@@ -27646,7 +27500,6 @@
     exports.builtinSymbols = builtinSymbols;
     exports.builtinSymbolsMap = builtinSymbolsMap;
     exports.calcLineCache = calcLineCache$1;
-    exports.calculateLineHeight = calculateLineHeight;
     exports.centroidOfSubpath = centroidOfSubpath;
     exports.circleBounds = circleBounds;
     exports.clock = clock;