@leafer-ui/node 1.0.0-rc.6 → 1.0.0-rc.8

package/dist/node.cjs

@@ -42,7 +42,7 @@ class Watcher {
         if (this.hasRemove) {
             const updatedList = new core.LeafList();
             this.__updatedList.list.forEach(item => { if (item.leafer)
-                updatedList.push(item); });
+                updatedList.add(item); });
             return updatedList;
         }
         else {
@@ -77,7 +77,7 @@ class Watcher {
             this.target.emit(core.RenderEvent.REQUEST);
     }
     __onAttrChange(event) {
-        this.__updatedList.push(event.target);
+        this.__updatedList.add(event.target);
         this.update();
     }
     __onChildEvent(event) {
@@ -87,12 +87,12 @@ class Watcher {
         }
         else {
             this.hasRemove = true;
-            this.__updatedList.push(event.parent);
+            this.__updatedList.add(event.parent);
         }
         this.update();
     }
     __pushChild(child) {
-        this.__updatedList.push(child);
+        this.__updatedList.add(child);
         if (child.isBranch)
             this.__loopChildren(child);
     }
@@ -131,7 +131,7 @@ class Watcher {
     }
 }
 
-const { updateAllWorldMatrix: updateAllWorldMatrix$1, updateAllWorldOpacity } = core.LeafHelper;
+const { updateAllMatrix: updateAllMatrix$1, updateBounds: updateOneBounds, updateAllWorldOpacity } = core.LeafHelper;
 const { pushAllChildBranch, pushAllParent } = core.BranchHelper;
 function updateMatrix(updateList, levelList) {
     let layout;
@@ -139,14 +139,14 @@ function updateMatrix(updateList, levelList) {
         layout = leaf.__layout;
         if (levelList.without(leaf) && !layout.proxyZoom) {
             if (layout.matrixChanged) {
-                updateAllWorldMatrix$1(leaf);
-                levelList.push(leaf);
+                updateAllMatrix$1(leaf, true);
+                levelList.add(leaf);
                 if (leaf.isBranch)
                     pushAllChildBranch(leaf, levelList);
                 pushAllParent(leaf, levelList);
             }
             else if (layout.boundsChanged) {
-                levelList.push(leaf);
+                levelList.add(leaf);
                 if (leaf.isBranch)
                     leaf.__tempNumber = 0;
                 pushAllParent(leaf, levelList);
@@ -155,20 +155,21 @@ function updateMatrix(updateList, levelList) {
     });
 }
 function updateBounds(boundsList) {
-    let itemList, branch;
+    let list, branch, children;
     boundsList.sort(true);
     boundsList.levels.forEach(level => {
-        itemList = boundsList.levelMap[level];
-        for (let i = 0, len = itemList.length; i < len; i++) {
-            branch = itemList[i];
+        list = boundsList.levelMap[level];
+        for (let i = 0, len = list.length; i < len; i++) {
+            branch = list[i];
             if (branch.isBranch && branch.__tempNumber) {
-                for (let j = 0, jLen = branch.children.length; j < jLen; j++) {
-                    if (!branch.children[j].isBranch) {
-                        branch.children[j].__updateWorldBounds();
+                children = branch.children;
+                for (let j = 0, jLen = children.length; j < jLen; j++) {
+                    if (!children[j].isBranch) {
+                        updateOneBounds(children[j]);
                     }
                 }
             }
-            branch.__updateWorldBounds();
+            updateOneBounds(branch);
         }
     });
 }
@@ -181,7 +182,7 @@ function updateChange(updateList) {
 }
 
 const { worldBounds } = core.LeafBoundsHelper;
-const { setByListWithHandle } = core.BoundsHelper;
+const bigBounds = { x: 0, y: 0, width: 100000, height: 100000 };
 class LayoutBlockData {
     constructor(list) {
         this.updatedBounds = new core.Bounds();
@@ -192,14 +193,20 @@ class LayoutBlockData {
         this.updatedList = list;
     }
     setBefore() {
-        setByListWithHandle(this.beforeBounds, this.updatedList.list, worldBounds);
+        this.beforeBounds.setListWithFn(this.updatedList.list, worldBounds);
     }
     setAfter() {
-        setByListWithHandle(this.afterBounds, this.updatedList.list, worldBounds);
-        this.updatedBounds.setByList([this.beforeBounds, this.afterBounds]);
+        const { list } = this.updatedList;
+        if (list.some(leaf => leaf.noBounds)) {
+            this.afterBounds.set(bigBounds);
+        }
+        else {
+            this.afterBounds.setListWithFn(list, worldBounds);
+        }
+        this.updatedBounds.setList([this.beforeBounds, this.afterBounds]);
     }
     merge(data) {
-        this.updatedList.pushList(data.updatedList.list);
+        this.updatedList.addList(data.updatedList.list);
         this.beforeBounds.add(data.beforeBounds);
         this.afterBounds.add(data.afterBounds);
         this.updatedBounds.add(data.updatedBounds);
@@ -209,8 +216,7 @@ class LayoutBlockData {
     }
 }
 
-const { updateAllWorldMatrix, updateAllChange } = core.LeafHelper;
-const { pushAllBranchStack, updateWorldBoundsByBranchStack } = core.BranchHelper;
+const { updateAllMatrix, updateAllChange } = core.LeafHelper;
 const debug$1 = core.Debug.get('Layouter');
 class Layouter {
     constructor(target, userConfig) {
@@ -287,12 +293,15 @@ class Layouter {
         const { target, __updatedList: updateList } = this;
         const { BEFORE, LAYOUT, AFTER } = core.LayoutEvent;
         const blocks = this.getBlocks(updateList);
-        blocks.forEach(item => { item.setBefore(); });
+        blocks.forEach(item => item.setBefore());
         target.emitEvent(new core.LayoutEvent(BEFORE, blocks, this.times));
+        this.extraBlock = null;
         updateList.sort();
         updateMatrix(updateList, this.__levelList);
         updateBounds(this.__levelList);
         updateChange(updateList);
+        if (this.extraBlock)
+            blocks.push(this.extraBlock);
         blocks.forEach(item => item.setAfter());
         target.emitEvent(new core.LayoutEvent(LAYOUT, blocks, this.times));
         target.emitEvent(new core.LayoutEvent(AFTER, blocks, this.times));
@@ -315,17 +324,20 @@ class Layouter {
         core.Run.end(t);
     }
     static fullLayout(target) {
-        updateAllWorldMatrix(target);
+        updateAllMatrix(target, true);
         if (target.isBranch) {
-            const branchStack = [target];
-            pushAllBranchStack(target, branchStack);
-            updateWorldBoundsByBranchStack(branchStack);
+            core.BranchHelper.updateBounds(target);
         }
         else {
-            target.__updateWorldBounds();
+            core.LeafHelper.updateBounds(target);
         }
         updateAllChange(target);
     }
+    addExtra(leaf) {
+        const block = this.extraBlock || (this.extraBlock = new LayoutBlockData([]));
+        block.updatedList.add(leaf);
+        block.beforeBounds.add(leaf.__world);
+    }
     createBlock(data) {
         return new LayoutBlockData(data);
     }
@@ -353,8 +365,7 @@ class Layouter {
         if (this.target) {
             this.stop();
             this.__removeListenEvents();
-            this.target = null;
-            this.config = null;
+            this.target = this.config = null;
         }
     }
 }
@@ -465,7 +476,7 @@ class Renderer {
         const { canvas } = this;
         const bounds = block.getIntersect(canvas.bounds);
         const includes = block.includes(this.target.__world);
-        const realBounds = new core.Bounds().copy(bounds);
+        const realBounds = new core.Bounds(bounds);
         canvas.save();
         if (includes && !core.Debug.showRepaint) {
             canvas.clear();
@@ -515,7 +526,7 @@ class Renderer {
         const { updateBlocks: list } = this;
         if (list) {
             const bounds = new core.Bounds();
-            bounds.setByList(list);
+            bounds.setList(list);
             list.length = 0;
             list.push(bounds);
         }
@@ -555,7 +566,7 @@ class Renderer {
                         empty = (!leaf.__world.width || !leaf.__world.height);
                         if (empty) {
                             if (!leaf.isLeafer)
-                                debug.warn(leaf.innerName, ': empty');
+                                debug.tip(leaf.innerName, ': empty');
                             empty = (!leaf.isBranch || leaf.isBranchLeaf);
                         }
                         return empty;
@@ -589,6 +600,14 @@ class Renderer {
     }
 }
 
+var AnswerType;
+(function (AnswerType) {
+    AnswerType[AnswerType["No"] = 0] = "No";
+    AnswerType[AnswerType["Yes"] = 1] = "Yes";
+    AnswerType[AnswerType["NoAndSkip"] = 2] = "NoAndSkip";
+    AnswerType[AnswerType["YesAndSkip"] = 3] = "YesAndSkip";
+})(AnswerType || (AnswerType = {}));
+
 const { hitRadiusPoint } = core.BoundsHelper;
 class Pather {
     constructor(target, selector) {
@@ -633,10 +652,10 @@ class Pather {
     getPath(leaf) {
         const path = new core.LeafList();
         while (leaf) {
-            path.push(leaf);
+            path.add(leaf);
             leaf = leaf.parent;
         }
-        path.push(this.target);
+        path.add(this.target);
         return path;
     }
     getHitablePath(leaf) {
@@ -646,7 +665,7 @@ class Pather {
             item = path.list[i];
             if (!item.__.hittable)
                 break;
-            hittablePath.unshift(item);
+            hittablePath.addAt(item, 0);
             if (!item.__.hitChildren)
                 break;
         }
@@ -665,7 +684,7 @@ class Pather {
                 leaf = path.list[j];
                 if (nextPath && nextPath.has(leaf))
                     break;
-                throughPath.push(leaf);
+                throughPath.add(leaf);
             }
         }
         return throughPath;
@@ -707,14 +726,15 @@ class Pather {
     }
 }
 
+const { Yes, NoAndSkip, YesAndSkip } = AnswerType;
 class Selector {
     constructor(target, userConfig) {
         this.config = {};
         this.innerIdMap = {};
         this.idMap = {};
         this.methods = {
-            id: (leaf, name) => leaf.id === name ? this.idMap[name] = leaf : 0,
-            innerId: (leaf, innerId) => leaf.innerId === innerId ? this.innerIdMap[innerId] = leaf : 0,
+            id: (leaf, name) => leaf.id === name ? (this.idMap[name] = leaf, 1) : 0,
+            innerId: (leaf, innerId) => leaf.innerId === innerId ? (this.innerIdMap[innerId] = leaf, 1) : 0,
             className: (leaf, name) => leaf.className === name ? 1 : 0,
             tag: (leaf, name) => leaf.__tag === name ? 1 : 0
         };
@@ -724,11 +744,6 @@ class Selector {
         this.pather = new Pather(target, this);
         this.__listenEvents();
     }
-    getByPoint(hitPoint, hitRadius, options) {
-        if (core.Platform.name === 'node')
-            this.target.emit(core.LayoutEvent.CHECK_UPDATE);
-        return this.pather.getByPoint(hitPoint, hitRadius, options);
-    }
     getBy(condition, branch, one, options) {
         switch (typeof condition) {
             case 'number':
@@ -748,6 +763,11 @@ class Selector {
                 return this.getByMethod(condition, branch, one, options);
         }
     }
+    getByPoint(hitPoint, hitRadius, options) {
+        if (core.Platform.name === 'node')
+            this.target.emit(core.LayoutEvent.CHECK_UPDATE);
+        return this.pather.getByPoint(hitPoint, hitRadius, options);
+    }
     getByInnerId(innerId, branch) {
         const cache = this.innerIdMap[innerId];
         if (cache)
@@ -774,10 +794,11 @@ class Selector {
         return list || this.findLeaf;
     }
     eachFind(children, method, list, options) {
-        let child;
+        let child, result;
         for (let i = 0, len = children.length; i < len; i++) {
             child = children[i];
-            if (method(child, options)) {
+            result = method(child, options);
+            if (result === Yes || result === YesAndSkip) {
                 if (list) {
                     list.push(child);
                 }
@@ -786,7 +807,7 @@ class Selector {
                     return;
                 }
             }
-            if (child.isBranch)
+            if (child.isBranch && result < NoAndSkip)
                 this.eachFind(child.children, method, list, options);
         }
     }
@@ -903,9 +924,8 @@ core.Platform.name = 'node';
 core.Platform.requestRender = function (render) { setTimeout(render); };
 core.Platform.devicePixelRatio = 1;
 core.Platform.conicGradientSupport = true;
-core.Platform.realtimeLayout = true;
 
-const { get: get$4, rotateOfOuter: rotateOfOuter$2, translate: translate$1, scaleOfOuter: scaleOfOuter$2, scale: scaleHelper$1, rotate } = core.MatrixHelper;
+const { get: get$4, rotateOfOuter: rotateOfOuter$2, translate: translate$1, scaleOfOuter: scaleOfOuter$2, scale: scaleHelper, rotate } = core.MatrixHelper;
 function fillOrFitMode(data, mode, box, width, height, rotation) {
     const transform = get$4();
     const swap = rotation && rotation !== 180;
@@ -915,7 +935,7 @@ function fillOrFitMode(data, mode, box, width, height, rotation) {
     const x = box.x + (box.width - width * scale) / 2;
     const y = box.y + (box.height - height * scale) / 2;
     translate$1(transform, x, y);
-    scaleHelper$1(transform, scale);
+    scaleHelper(transform, scale);
     if (rotation)
         rotateOfOuter$2(transform, { x: box.x + box.width / 2, y: box.y + box.height / 2 }, rotation);
     data.scaleX = data.scaleY = scale;
@@ -927,7 +947,7 @@ function clipMode(data, box, offset, scale, rotation) {
     if (offset)
         translate$1(transform, offset.x, offset.y);
     if (scale) {
-        typeof scale === 'number' ? scaleHelper$1(transform, scale) : scaleHelper$1(transform, scale.x, scale.y);
+        typeof scale === 'number' ? scaleHelper(transform, scale) : scaleHelper(transform, scale.x, scale.y);
         data.scaleX = transform.a;
         data.scaleY = transform.d;
     }
@@ -962,7 +982,7 @@ function repeatMode(data, box, width, height, scale, rotation) {
 const { get: get$3, translate } = core.MatrixHelper;
 function createData(leafPaint, image, paint, box) {
     let { width, height } = image;
-    const { opacity, mode, offset, scale, rotation, blendMode } = paint;
+    const { opacity, mode, offset, scale, rotation, blendMode, repeat } = paint;
     const sameBox = box.width === width && box.height === height;
     if (blendMode)
         leafPaint.blendMode = blendMode;
@@ -983,6 +1003,8 @@ function createData(leafPaint, image, paint, box) {
         case 'repeat':
             if (!sameBox || scale || rotation)
                 repeatMode(data, box, width, height, scale, rotation);
+            if (!repeat)
+                data.repeat = 'repeat';
             break;
         case 'fit':
         case 'cover':
@@ -994,6 +1016,8 @@ function createData(leafPaint, image, paint, box) {
     data.height = height;
     if (opacity)
         data.opacity = opacity;
+    if (repeat)
+        data.repeat = typeof repeat === 'string' ? (repeat === 'x' ? 'repeat-x' : 'repeat-y') : 'repeat';
 }
 
 function image(ui, attrName, attrValue, box, firstUse) {
@@ -1041,6 +1065,10 @@ function hasNaturalSize(ui, attrName, image) {
         d.__naturalHeight = image.height;
         if (!d.__getInput('width') || !d.__getInput('height')) {
             ui.forceUpdate('width');
+            if (ui.__proxyData) {
+                ui.setProxyAttr('width', ui.__.width);
+                ui.setProxyAttr('height', ui.__.height);
+            }
             return false;
         }
     }
@@ -1051,22 +1079,21 @@ function emit(type, data) {
         data.target.emitEvent(new core.ImageEvent(type, data));
 }
 
-const { get: get$2, scale: scaleHelper, copy: copy$1 } = core.MatrixHelper;
+const Export$1 = {};
+
+const { get: get$2, scale, copy: copy$1 } = core.MatrixHelper;
 function createPattern(ui, paint, pixelRatio) {
     let { scaleX, scaleY } = ui.__world;
     const id = scaleX + '-' + scaleY;
     if (paint.patternId !== id && !ui.destroyed) {
-        paint.patternId = id;
         scaleX = Math.abs(scaleX);
         scaleY = Math.abs(scaleY);
         const { image, data } = paint;
-        const maxWidth = image.isSVG ? 4096 : Math.min(image.width, 4096);
-        const maxHeight = image.isSVG ? 4096 : Math.min(image.height, 4096);
-        let scale, matrix, { width, height, scaleX: sx, scaleY: sy, opacity, transform, mode } = data;
+        let imageScale, imageMatrix, { width, height, scaleX: sx, scaleY: sy, opacity, transform, repeat } = data;
         if (sx) {
-            matrix = get$2();
-            copy$1(matrix, transform);
-            scaleHelper(matrix, 1 / sx, 1 / sy);
+            imageMatrix = get$2();
+            copy$1(imageMatrix, transform);
+            scale(imageMatrix, 1 / sx, 1 / sy);
             scaleX *= sx;
             scaleY *= sy;
         }
@@ -1074,38 +1101,49 @@ function createPattern(ui, paint, pixelRatio) {
         scaleY *= pixelRatio;
         width *= scaleX;
         height *= scaleY;
-        if (width > maxWidth || height > maxHeight) {
-            scale = Math.max(width / maxWidth, height / maxHeight);
-        }
-        if (scale) {
-            scaleX /= scale;
-            scaleY /= scale;
-            width /= scale;
-            height /= scale;
+        const size = width * height;
+        if (!repeat) {
+            if (size > core.Platform.image.maxCacheSize)
+                return false;
+        }
+        let maxSize = core.Platform.image.maxPatternSize;
+        if (!image.isSVG) {
+            const imageSize = image.width * image.height;
+            if (maxSize > imageSize)
+                maxSize = imageSize;
+        }
+        if (size > maxSize)
+            imageScale = Math.sqrt(size / maxSize);
+        if (imageScale) {
+            scaleX /= imageScale;
+            scaleY /= imageScale;
+            width /= imageScale;
+            height /= imageScale;
         }
         if (sx) {
             scaleX /= sx;
             scaleY /= sy;
         }
         if (transform || scaleX !== 1 || scaleY !== 1) {
-            if (!matrix) {
-                matrix = get$2();
+            if (!imageMatrix) {
+                imageMatrix = get$2();
                 if (transform)
-                    copy$1(matrix, transform);
+                    copy$1(imageMatrix, transform);
             }
-            scaleHelper(matrix, 1 / scaleX, 1 / scaleY);
+            scale(imageMatrix, 1 / scaleX, 1 / scaleY);
         }
-        const style = core.Platform.canvas.createPattern(image.getCanvas(width < 1 ? 1 : width, height < 1 ? 1 : height, opacity), mode === 'repeat' ? 'repeat' : (core.Platform.origin.noRepeat || 'no-repeat'));
+        const pattern = core.Platform.canvas.createPattern(image.getCanvas(width < 1 ? 1 : width, height < 1 ? 1 : height, opacity), repeat || (core.Platform.origin.noRepeat || 'no-repeat'));
         try {
             if (paint.transform)
                 paint.transform = null;
-            if (matrix)
-                style.setTransform ? style.setTransform(matrix) : paint.transform = matrix;
+            if (imageMatrix)
+                pattern.setTransform ? pattern.setTransform(imageMatrix) : paint.transform = imageMatrix;
         }
         catch (_a) {
-            paint.transform = matrix;
+            paint.transform = imageMatrix;
         }
-        paint.style = style;
+        paint.style = pattern;
+        paint.patternId = id;
         return true;
     }
     else {
@@ -1113,18 +1151,24 @@ function createPattern(ui, paint, pixelRatio) {
     }
 }
 
+const { abs } = Math;
 function checkImage(ui, canvas, paint, allowPaint) {
     const { scaleX, scaleY } = ui.__world;
     if (!paint.data || paint.patternId === scaleX + '-' + scaleY) {
         return false;
     }
     else {
+        const { data } = paint;
         if (allowPaint) {
-            if (paint.image.isSVG && paint.data.mode !== 'repeat') {
-                let { width, height } = paint.data;
-                width *= scaleX * canvas.pixelRatio;
-                height *= scaleY * canvas.pixelRatio;
-                allowPaint = width > 4096 || height > 4096;
+            if (!data.repeat) {
+                let { width, height } = data;
+                width *= abs(scaleX) * canvas.pixelRatio;
+                height *= abs(scaleY) * canvas.pixelRatio;
+                if (data.scaleX) {
+                    width *= data.scaleX;
+                    height *= data.scaleY;
+                }
+                allowPaint = width * height > core.Platform.image.maxCacheSize;
             }
             else {
                 allowPaint = false;
@@ -1133,7 +1177,6 @@ function checkImage(ui, canvas, paint, allowPaint) {
         if (allowPaint) {
             canvas.save();
             canvas.clip();
-            const { data } = paint;
             if (paint.blendMode)
                 canvas.blendMode = paint.blendMode;
             if (data.opacity)
@@ -1145,7 +1188,7 @@ function checkImage(ui, canvas, paint, allowPaint) {
             return true;
         }
         else {
-            if (!paint.style) {
+            if (!paint.style || Export$1.running) {
                 createPattern(ui, paint, canvas.pixelRatio);
             }
             else {
@@ -1164,7 +1207,7 @@ function checkImage(ui, canvas, paint, allowPaint) {
 }
 
 function recycleImage(attrName, data) {
-    const paints = (attrName === 'fill' ? data._fill : data._stroke);
+    const paints = data['_' + attrName];
     if (paints instanceof Array) {
         let image, recycleMap, input, url;
         for (let i = 0, len = paints.length; i < len; i++) {
@@ -1268,7 +1311,7 @@ function drawAlignStroke(align, stroke, isStrokes, ui, canvas, renderOptions) {
     out.blendMode = align === 'outside' ? 'destination-out' : 'destination-in';
     fillText(ui, out);
     out.blendMode = 'normal';
-    if (ui.__hasMirror || renderOptions.matrix) {
+    if (ui.__worldFlipped || renderOptions.matrix) {
         canvas.copyWorldByReset(out);
     }
     else {
@@ -1341,7 +1384,7 @@ function stroke(stroke, ui, canvas, renderOptions) {
                 out.stroke();
                 options.windingRule ? out.clip(options.windingRule) : out.clip();
                 out.clearWorld(ui.__layout.renderBounds);
-                if (ui.__hasMirror || renderOptions.matrix) {
+                if (ui.__worldFlipped || renderOptions.matrix) {
                     canvas.copyWorldByReset(out);
                 }
                 else {
@@ -1381,7 +1424,7 @@ function strokes(strokes, ui, canvas, renderOptions) {
                 drawStrokesStyle(strokes, false, ui, out);
                 options.windingRule ? out.clip(options.windingRule) : out.clip();
                 out.clearWorld(renderBounds);
-                if (ui.__hasMirror || renderOptions.matrix) {
+                if (ui.__worldFlipped || renderOptions.matrix) {
                     canvas.copyWorldByReset(out);
                 }
                 else {
@@ -1605,7 +1648,7 @@ function shadow(ui, current, shape, renderOptions) {
             }
             worldCanvas ? other.copyWorld(worldCanvas, __world, __world, 'destination-out') : other.copyWorld(shape.canvas, shapeBounds, bounds, 'destination-out');
         }
-        if (ui.__hasMirror || renderOptions.matrix) {
+        if (ui.__worldFlipped || renderOptions.matrix) {
             current.copyWorldByReset(other, copyBounds, __world, item.blendMode);
         }
         else {
@@ -1669,7 +1712,7 @@ function innerShadow(ui, current, shape, renderOptions) {
             copyBounds = bounds;
         }
         other.fillWorld(copyBounds, item.color, 'source-in');
-        if (ui.__hasMirror || renderOptions.matrix) {
+        if (ui.__worldFlipped || renderOptions.matrix) {
             current.copyWorldByReset(other, copyBounds, __world, item.blendMode);
         }
         else {
@@ -2117,6 +2160,7 @@ function decorationText(drawData, style) {
     }
 }
 
+const { top, right, bottom, left } = core.Direction4;
 const TextConvert = {
     getDrawData(content, style) {
         if (typeof content !== 'string')
@@ -2124,16 +2168,15 @@ const TextConvert = {
         let x = 0, y = 0;
         let width = style.__getInput('width') || 0;
         let height = style.__getInput('height') || 0;
-        const { textDecoration, __font, padding } = style;
+        const { textDecoration, __font, __padding: padding } = style;
         if (padding) {
-            const [top, right, bottom, left] = core.MathHelper.fourNumber(padding);
             if (width) {
-                x = left;
-                width -= (right + left);
+                x = padding[left];
+                width -= (padding[right] + padding[left]);
             }
             if (height) {
-                y = top;
-                height -= (top + bottom);
+                y = padding[top];
+                height -= (padding[top] + padding[bottom]);
             }
         }
         const drawData = {
@@ -2143,6 +2186,8 @@ const TextConvert = {
             font: core.Platform.canvas.font = __font
         };
         createRows(drawData, content, style);
+        if (padding)
+            padAutoText(padding, drawData, style, width, height);
         layoutText(drawData, style);
         layoutChar(drawData, style, width);
         if (drawData.overflow)
@@ -2152,6 +2197,32 @@ const TextConvert = {
         return drawData;
     }
 };
+function padAutoText(padding, drawData, style, width, height) {
+    if (!width) {
+        switch (style.textAlign) {
+            case 'left':
+                offsetText(drawData, 'x', padding[left]);
+                break;
+            case 'right':
+                offsetText(drawData, 'x', -padding[right]);
+        }
+    }
+    if (!height) {
+        switch (style.verticalAlign) {
+            case 'top':
+                offsetText(drawData, 'y', padding[top]);
+                break;
+            case 'bottom':
+                offsetText(drawData, 'y', -padding[bottom]);
+        }
+    }
+}
+function offsetText(drawData, attrName, value) {
+    const { bounds, rows } = drawData;
+    bounds[attrName] += value;
+    for (let i = 0; i < rows.length; i++)
+        rows[i][attrName] += value;
+}
 
 const ColorConvert = {
     string(color, opacity) {
@@ -2167,6 +2238,7 @@ const ColorConvert = {
 
 const Export = {
     export(leaf, filename, options) {
+        Export.running = true;
         return addTask((success) => new Promise((resolve) => {
             const { leafer } = leaf;
             if (leafer) {
@@ -2204,6 +2276,7 @@ const Export = {
                     }
                     success({ data });
                     resolve();
+                    Export.running = false;
                     if (unreal)
                         canvas.recycle();
                 }));
@@ -2211,6 +2284,7 @@ const Export = {
             else {
                 success({ data: false });
                 resolve();
+                Export.running = false;
             }
         }));
     }