leafer-ui 1.0.4 → 1.0.6

package/dist/web.module.js

@@ -552,6 +552,12 @@ const PointHelper = {
         to.y = t.y + sin$4(r) * distance;
         return to;
     },
+    toNumberPoints(originPoints) {
+        let points = originPoints;
+        if (typeof originPoints[0] === 'object')
+            points = [], originPoints.forEach(p => points.push(p.x, p.y));
+        return points;
+    },
     reset(t) {
         P$5.reset(t);
     }
@@ -1542,7 +1548,10 @@ const { assign } = DataHelper;
 
 class LeafData {
     get __useNaturalRatio() { return true; }
-    get __isLinePath() { return this.path && this.path.length === 6; }
+    get __isLinePath() {
+        const { path } = this;
+        return path && path.length === 6 && path[0] === 1;
+    }
     get __blendMode() {
         if (this.eraser && this.eraser !== 'path')
             return 'destination-out';
@@ -2305,11 +2314,12 @@ const RectHelper = {
 
 const { sin: sin$3, cos: cos$3, atan2: atan2$1, ceil: ceil$1, abs: abs$3, PI: PI$2, sqrt: sqrt$1, pow } = Math;
 const { setPoint: setPoint$2, addPoint: addPoint$2 } = TwoPointBoundsHelper;
-const { set } = PointHelper;
+const { set, toNumberPoints } = PointHelper;
 const { M: M$5, L: L$6, C: C$5, Q: Q$4, Z: Z$5 } = PathCommandMap;
 const tempPoint$2 = {};
 const BezierHelper = {
-    points(data, points, curve, close) {
+    points(data, originPoints, curve, close) {
+        let points = toNumberPoints(originPoints);
         data.push(M$5, points[0], points[1]);
         if (curve && points.length > 5) {
             let aX, aY, bX, bY, cX, cY, c1X, c1Y, c2X, c2Y;
@@ -2818,6 +2828,27 @@ const PathConvert = {
         }
         return data;
     },
+    objectToCanvasData(list) {
+        const data = [];
+        list.forEach(item => {
+            switch (item.name) {
+                case 'M':
+                    data.push(M$4, item.x, item.y);
+                    break;
+                case 'L':
+                    data.push(L$5, item.x, item.y);
+                    break;
+                case 'C':
+                    data.push(C$4, item.x1, item.y1, item.x2, item.y2, item.x, item.y);
+                    break;
+                case 'Q':
+                    data.push(Q$3, item.x1, item.y1, item.x, item.y);
+                    break;
+                case 'Z': data.push(Z$4);
+            }
+        });
+        return data;
+    },
     copyData(data, old, index, count) {
         for (let i = index, end = index + count; i < end; i++) {
             data.push(old[i]);
@@ -4755,6 +4786,7 @@ class RenderEvent extends Event {
     }
 }
 RenderEvent.REQUEST = 'render.request';
+RenderEvent.CHILD_START = 'render.child_start';
 RenderEvent.START = 'render.start';
 RenderEvent.BEFORE = 'render.before';
 RenderEvent.RENDER = 'render';
@@ -4930,7 +4962,7 @@ const { isFinite } = Number;
 const debug$8 = Debug.get('setAttr');
 const LeafDataProxy = {
     __setAttr(name, newValue, checkFiniteNumber) {
-        if (this.leafer && this.leafer.created) {
+        if (this.leaferIsCreated) {
             const oldValue = this.__.__getInput(name);
             if (checkFiniteNumber && !isFinite(newValue) && newValue !== undefined) {
                 debug$8.warn(this.innerName, name, newValue);
@@ -5002,7 +5034,7 @@ const LeafMatrix = {
 
 const { updateMatrix: updateMatrix$1, updateAllMatrix: updateAllMatrix$2 } = LeafHelper;
 const { updateBounds: updateBounds$1 } = BranchHelper;
-const { toOuterOf: toOuterOf$1, copyAndSpread: copyAndSpread$2, copy: copy$5 } = BoundsHelper;
+const { toOuterOf: toOuterOf$1, copyAndSpread: copyAndSpread$1, copy: copy$5 } = BoundsHelper;
 const { toBounds: toBounds$2 } = PathBounds;
 const LeafBounds = {
     __updateWorldBounds() {
@@ -5085,7 +5117,7 @@ const LeafBounds = {
         const b = this.__layout.boxBounds;
         const data = this.__;
         if (data.__pathInputed) {
-            toBounds$2(data.__pathForRender, b);
+            toBounds$2(data.path, b);
         }
         else {
             b.x = 0;
@@ -5097,7 +5129,7 @@ const LeafBounds = {
     __updateAutoLayout() {
         this.__layout.matrixChanged = true;
         if (this.isBranch) {
-            if (this.leafer && this.leafer.ready)
+            if (this.leaferIsReady)
                 this.leafer.layouter.addExtra(this);
             if (this.__.flow) {
                 if (this.__layout.boxChanged)
@@ -5123,11 +5155,11 @@ const LeafBounds = {
     },
     __updateStrokeBounds() {
         const layout = this.__layout;
-        copyAndSpread$2(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread);
+        copyAndSpread$1(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread);
     },
     __updateRenderBounds() {
         const layout = this.__layout;
-        layout.renderSpread > 0 ? copyAndSpread$2(layout.renderBounds, layout.boxBounds, layout.renderSpread) : copy$5(layout.renderBounds, layout.strokeBounds);
+        layout.renderSpread > 0 ? copyAndSpread$1(layout.renderBounds, layout.boxBounds, layout.renderSpread) : copy$5(layout.renderBounds, layout.strokeBounds);
     }
 };
 
@@ -5158,7 +5190,7 @@ const LeafRender = {
         if (this.__worldOpacity) {
             canvas.setWorld(this.__nowWorld = this.__getNowWorld(options));
             this.__drawRenderPath(canvas);
-            this.__.windingRule ? canvas.clip(this.__.windingRule) : canvas.clip();
+            this.windingRule ? canvas.clip(this.windingRule) : canvas.clip();
         }
     },
     __updateWorldOpacity() {
@@ -5232,6 +5264,8 @@ let Leaf = class Leaf {
     get innerName() { return this.__.name || this.tag + this.innerId; }
     get __DataProcessor() { return LeafData; }
     get __LayoutProcessor() { return LeafLayout; }
+    get leaferIsCreated() { return this.leafer && this.leafer.created; }
+    get leaferIsReady() { return this.leafer && this.leafer.ready; }
     get isLeafer() { return false; }
     get isBranch() { return false; }
     get isBranchLeaf() { return false; }
@@ -5673,10 +5707,17 @@ let Branch = class Branch extends Leaf {
     add(child, index) {
         if (child === this)
             return;
+        const noIndex = index === undefined;
+        if (!child.__) {
+            if (child instanceof Array)
+                return child.forEach(item => { this.add(item, index); noIndex || index++; });
+            else
+                child = UICreator.get(child.tag, child);
+        }
         if (child.parent)
             child.parent.remove(child);
         child.parent = this;
-        index === undefined ? this.children.push(child) : this.children.splice(index, 0, child);
+        noIndex ? this.children.push(child) : this.children.splice(index, 0, child);
         if (child.isBranch)
             this.__.__childBranchNumber = (this.__.__childBranchNumber || 0) + 1;
         child.__layout.boxChanged || child.__layout.boxChange();
@@ -5690,15 +5731,17 @@ let Branch = class Branch extends Leaf {
         }
         this.__layout.affectChildrenSort && this.__layout.childrenSortChange();
     }
-    addMany(...children) {
-        children.forEach(child => this.add(child));
-    }
+    addMany(...children) { this.add(children); }
     remove(child, destroy) {
         if (child) {
-            if (child.animationOut)
-                child.__runAnimation('out', () => this.__remove(child, destroy));
+            if (child.__) {
+                if (child.animationOut)
+                    child.__runAnimation('out', () => this.__remove(child, destroy));
+                else
+                    this.__remove(child, destroy);
+            }
             else
-                this.__remove(child, destroy);
+                this.find(child).forEach(item => this.remove(item, destroy));
         }
         else if (child === undefined) {
             super.remove(null, destroy);
@@ -5916,7 +5959,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.0.4";
+const version = "1.0.6";
 
 const debug$7 = Debug.get('LeaferCanvas');
 class LeaferCanvas extends LeaferCanvasBase {
@@ -6074,7 +6117,7 @@ class LeaferCanvas extends LeaferCanvasBase {
         const oldSize = {};
         DataHelper.copyAttrs(oldSize, this, canvasSizeAttrs);
         this.resize(size);
-        if (this.width !== undefined)
+        if (this.resizeListener && this.width !== undefined)
             this.resizeListener(new ResizeEvent(size, oldSize));
     }
     unrealCanvas() {
@@ -6558,6 +6601,7 @@ class Renderer {
         this.totalBounds = new Bounds();
         debug$5.log(target.innerName, '--->');
         try {
+            target.app.emit(RenderEvent.CHILD_START, target);
             this.emitRender(RenderEvent.START);
             this.renderOnce(callback);
             this.emitRender(RenderEvent.END, this.totalBounds);
@@ -6855,7 +6899,7 @@ class Picker {
             if (child.isBranch) {
                 if (hit || child.__ignoreHitWorld) {
                     this.eachFind(child.children, child.__onlyHitMask);
-                    if (child.isBranchLeaf && !this.findList.length)
+                    if (child.isBranchLeaf)
                         this.hitChild(child, point);
                 }
             }
@@ -7068,6 +7112,13 @@ function zoomLayerType() {
 
 const TextConvert = {};
 const ColorConvert = {};
+const UnitConvert = {
+    number(value, percentRefer) {
+        if (typeof value === 'object')
+            return value.type === 'percent' ? value.value * percentRefer : value.value;
+        return value;
+    }
+};
 const PathArrow = {};
 const Paint = {};
 const PaintImage = {};
@@ -7088,7 +7139,7 @@ const Transition = {
     }
 };
 
-const { parse } = PathConvert;
+const { parse, objectToCanvasData } = PathConvert;
 const emptyPaint = {};
 const debug$4 = Debug.get('UIData');
 class UIData extends LeafData {
@@ -7102,10 +7153,11 @@ class UIData extends LeafData {
                 scaleX = -scaleX;
             return scaleX > 1 ? strokeWidth / scaleX : strokeWidth;
         }
-        else {
+        else
             return strokeWidth;
-        }
     }
+    get __hasStroke() { return this.stroke && this.strokeWidth; }
+    get __clipAfterFill() { return (this.cornerRadius || this.__pathInputed); }
     get __autoWidth() { return !this._width; }
     get __autoHeight() { return !this._height; }
     get __autoSide() { return !this._width || !this._height; }
@@ -7122,9 +7174,8 @@ class UIData extends LeafData {
             this.__leaf.scaleX *= -1;
             debug$4.warn('width < 0, instead -scaleX ', this);
         }
-        else {
+        else
             this._width = value;
-        }
     }
     setHeight(value) {
         if (value < 0) {
@@ -7132,9 +7183,8 @@ class UIData extends LeafData {
             this.__leaf.scaleY *= -1;
             debug$4.warn('height < 0, instead -scaleY', this);
         }
-        else {
+        else
             this._height = value;
-        }
     }
     setFill(value) {
         if (this.__naturalWidth)
@@ -7175,9 +7225,10 @@ class UIData extends LeafData {
         }
     }
     setPath(value) {
-        if (typeof value === 'string') {
+        const isString = typeof value === 'string';
+        if (isString || (value && typeof value[0] === 'object')) {
             this.__setInput('path', value);
-            this._path = parse(value);
+            this._path = isString ? parse(value) : objectToCanvasData(value);
         }
         else {
             if (this.__input)
@@ -7192,12 +7243,8 @@ class UIData extends LeafData {
                 value = value.filter((item) => item.visible !== false);
             this._shadow = value.length ? value : null;
         }
-        else if (value) {
-            this._shadow = value.visible === false ? null : [value];
-        }
-        else {
-            this._shadow = null;
-        }
+        else
+            this._shadow = value && value.visible !== false ? [value] : null;
     }
     setInnerShadow(value) {
         this.__setInput('innerShadow', value);
@@ -7206,12 +7253,8 @@ class UIData extends LeafData {
                 value = value.filter((item) => item.visible !== false);
             this._innerShadow = value.length ? value : null;
         }
-        else if (value) {
-            this._innerShadow = value.visible === false ? null : [value];
-        }
-        else {
-            this._innerShadow = null;
-        }
+        else
+            this._innerShadow = value && value.visible !== false ? [value] : null;
     }
     __computePaint() {
         const { fill, stroke } = this.__input;
@@ -7222,24 +7265,19 @@ class UIData extends LeafData {
         this.__needComputePaint = false;
     }
 }
-const UnitConvert = {
-    number(value, percentRefer) {
-        if (typeof value === 'object')
-            return value.type === 'percent' ? value.value * percentRefer : value.value;
-        return value;
-    }
-};
 
 class GroupData extends UIData {
 }
 
 class BoxData extends GroupData {
     get __boxStroke() { return !this.__pathInputed; }
+    get __drawAfterFill() { return this.overflow === 'hide' && this.__clipAfterFill && this.__leaf.children.length; }
+    get __clipAfterFill() { return this.__leaf.isOverflow || super.__clipAfterFill; }
 }
 
 class LeaferData extends GroupData {
-    __getInputData() {
-        const data = super.__getInputData();
+    __getInputData(names, options) {
+        const data = super.__getInputData(names, options);
         canvasSizeAttrs.forEach(key => delete data[key]);
         return data;
     }
@@ -7266,6 +7304,7 @@ class StarData extends UIData {
 }
 
 class PathData extends UIData {
+    get __pathInputed() { return 2; }
 }
 
 class PenData extends GroupData {
@@ -7312,16 +7351,18 @@ class ImageData extends RectData {
         delete data.fill;
         return data;
     }
-    __getInputData() {
-        const data = super.__getInputData();
+    __getInputData(names, options) {
+        const data = super.__getInputData(names, options);
         delete data.fill;
         return data;
     }
 }
 
 class CanvasData extends RectData {
-    __getInputData() {
-        const data = super.__getInputData();
+    get __isCanvas() { return true; }
+    get __drawAfterFill() { return true; }
+    __getInputData(names, options) {
+        const data = super.__getInputData(names, options);
         data.url = this.__leaf.canvas.toDataURL('image/png');
         return data;
     }
@@ -7348,16 +7389,12 @@ const UIBounds = {
         let width = 0;
         const { shadow, innerShadow, blur, backgroundBlur } = this.__;
         if (shadow)
-            shadow.forEach(item => {
-                width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5);
-            });
+            shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
         if (blur)
             width = Math.max(width, blur);
         let shapeWidth = width = Math.ceil(width);
         if (innerShadow)
-            innerShadow.forEach(item => {
-                shapeWidth = Math.max(shapeWidth, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread < 0 ? -item.spread : 0) + item.blur * 1.5);
-            });
+            innerShadow.forEach(item => shapeWidth = Math.max(shapeWidth, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread < 0 ? -item.spread : 0) + item.blur * 1.5));
         if (backgroundBlur)
             shapeWidth = Math.max(shapeWidth, backgroundBlur);
         this.__layout.renderShapeSpread = shapeWidth;
@@ -7439,6 +7476,16 @@ const UIRender = {
             if (stroke && !ignoreStroke)
                 this.__.__pixelStroke ? Paint.strokes(stroke, this, canvas) : Paint.stroke('#000000', this, canvas);
         }
+    },
+    __drawAfterFill(canvas, options) {
+        if (this.__.__clipAfterFill) {
+            canvas.save();
+            this.windingRule ? canvas.clip(this.windingRule) : canvas.clip();
+            this.__drawContent(canvas, options);
+            canvas.restore();
+        }
+        else
+            this.__drawContent(canvas, options);
     }
 };
 function drawFast(ui, canvas, options) {
@@ -7505,8 +7552,8 @@ let UI = UI_1 = class UI extends Leaf {
         return pen;
     }
     get editConfig() { return undefined; }
-    get editOuter() { return this.__.__isLinePath ? 'LineEditTool' : 'EditTool'; }
-    get editInner() { return 'PathEditor'; }
+    get editOuter() { return ''; }
+    get editInner() { return ''; }
     constructor(data) {
         super(data);
     }
@@ -7517,9 +7564,8 @@ let UI = UI_1 = class UI extends Leaf {
             Object.assign(this, data);
             this.lockNormalStyle = false;
         }
-        else {
+        else
             Object.assign(this, data);
-        }
     }
     get(name) {
         return typeof name === 'string' ? this.__.__getInput(name) : this.__.__getInputData(name);
@@ -7565,12 +7611,7 @@ let UI = UI_1 = class UI extends Leaf {
         this.__drawPathByData(canvas, this.__.path);
     }
     __drawPathByData(drawer, data) {
-        if (data) {
-            PathDrawer.drawPathByData(drawer, data);
-        }
-        else {
-            this.__drawPathByBox(drawer);
-        }
+        data ? PathDrawer.drawPathByData(drawer, data) : this.__drawPathByBox(drawer);
     }
     __drawPathByBox(drawer) {
         const { x, y, width, height } = this.__layout.boxBounds;
@@ -7578,9 +7619,8 @@ let UI = UI_1 = class UI extends Leaf {
             const { cornerRadius } = this.__;
             drawer.roundRect(x, y, width, height, typeof cornerRadius === 'number' ? [cornerRadius] : cornerRadius);
         }
-        else {
+        else
             drawer.rect(x, y, width, height);
-        }
     }
     animate(_keyframe, _options, _type, _isTemp) {
         return needPlugin('animate');
@@ -7827,23 +7867,13 @@ let Group = class Group extends UI {
         if (data.children) {
             const { children } = data;
             delete data.children;
-            if (!this.children) {
-                this.__setBranch();
-            }
-            else {
-                this.clear();
-            }
+            this.children ? this.clear() : this.__setBranch();
             super.set(data, isTemp);
-            let child;
-            children.forEach(childData => {
-                child = childData.__ ? childData : UICreator.get(childData.tag, childData);
-                this.add(child);
-            });
+            children.forEach(child => this.add(child));
             data.children = children;
         }
-        else {
+        else
             super.set(data, isTemp);
-        }
     }
     toJSON(options) {
         const data = super.toJSON(options);
@@ -8263,10 +8293,9 @@ Rect = __decorate([
     registerUI()
 ], Rect);
 
-const rect$1 = Rect.prototype;
-const group$1 = Group.prototype;
+const { copy: copy$3, add, includes: includes$1 } = BoundsHelper;
+const rect$1 = Rect.prototype, group$1 = Group.prototype;
 const childrenRenderBounds = {};
-const { copy: copy$3, add, includes: includes$1, copyAndSpread: copyAndSpread$1 } = BoundsHelper;
 let Box = class Box extends Group {
     get __tag() { return 'Box'; }
     get isBranchLeaf() { return true; }
@@ -8276,37 +8305,31 @@ let Box = class Box extends Group {
     }
     __updateStrokeSpread() { return 0; }
     __updateRectRenderSpread() { return 0; }
-    __updateRenderSpread() {
-        return this.__updateRectRenderSpread() || -1;
-    }
+    __updateRenderSpread() { return this.__updateRectRenderSpread() || -1; }
     __updateRectBoxBounds() { }
-    __updateBoxBounds(secondLayout) {
+    __updateBoxBounds(_secondLayout) {
         const data = this.__;
         if (this.children.length) {
             if (data.__autoSide) {
-                if (this.leafer && this.leafer.ready)
-                    this.leafer.layouter.addExtra(this);
                 super.__updateBoxBounds();
                 const { boxBounds } = this.__layout;
                 if (!data.__autoSize) {
-                    if (data.__autoWidth)
-                        boxBounds.width += boxBounds.x, boxBounds.height = data.height, boxBounds.y = boxBounds.x = 0;
-                    else
-                        boxBounds.height += boxBounds.y, boxBounds.width = data.width, boxBounds.x = boxBounds.y = 0;
+                    if (data.__autoWidth) {
+                        boxBounds.width += boxBounds.x, boxBounds.x = 0;
+                        boxBounds.height = data.height, boxBounds.y = 0;
+                    }
+                    else {
+                        boxBounds.height += boxBounds.y, boxBounds.y = 0;
+                        boxBounds.width = data.width, boxBounds.x = 0;
+                    }
                 }
-                if (secondLayout && data.flow && data.padding)
-                    copyAndSpread$1(boxBounds, boxBounds, data.padding, false, data.__autoSize ? null : (data.__autoWidth ? 'width' : 'height'));
                 this.__updateNaturalSize();
             }
-            else {
+            else
                 this.__updateRectBoxBounds();
-            }
-            if (data.flow)
-                this.__updateContentBounds();
         }
-        else {
+        else
             this.__updateRectBoxBounds();
-        }
     }
     __updateStrokeBounds() { }
     __updateRenderBounds() {
@@ -8316,14 +8339,13 @@ let Box = class Box extends Group {
             super.__updateRenderBounds();
             copy$3(childrenRenderBounds, renderBounds);
             this.__updateRectRenderBounds();
-            isOverflow = !includes$1(renderBounds, childrenRenderBounds) || !this.pathInputed || !this.__.cornerRadius;
+            isOverflow = !includes$1(renderBounds, childrenRenderBounds);
+            if (isOverflow && this.__.overflow !== 'hide')
+                add(renderBounds, childrenRenderBounds);
         }
-        else {
+        else
             this.__updateRectRenderBounds();
-        }
-        this.isOverflow !== isOverflow && (this.isOverflow = isOverflow);
-        if (!(this.__.__drawAfterFill = this.__.overflow === 'hide') && isOverflow)
-            add(renderBounds, childrenRenderBounds);
+        !this.isOverflow !== !isOverflow && (this.isOverflow = isOverflow);
     }
     __updateRectRenderBounds() { }
     __updateRectChange() { }
@@ -8343,20 +8365,9 @@ let Box = class Box extends Group {
                 this.__renderGroup(canvas, options);
         }
     }
-    __drawAfterFill(canvas, options) {
-        const { length } = this.children;
-        if (this.isOverflow) {
-            canvas.save();
-            canvas.clip();
-            if (length)
-                this.__renderGroup(canvas, options);
-            canvas.restore();
-        }
-        else {
-            if (length)
-                this.__renderGroup(canvas, options);
-        }
-        if (this.__.stroke && length) {
+    __drawContent(canvas, options) {
+        this.__renderGroup(canvas, options);
+        if (this.__.__hasStroke) {
             canvas.setWorld(this.__nowWorld);
             this.__drawRenderPath(canvas);
         }
@@ -8368,6 +8379,9 @@ __decorate([
 __decorate([
     dataType(false)
 ], Box.prototype, "resizeChildren", void 0);
+__decorate([
+    dataType(false)
+], Box.prototype, "textBox", void 0);
 __decorate([
     affectRenderBoundsType('show')
 ], Box.prototype, "overflow", void 0);
@@ -8517,17 +8531,15 @@ let Line = class Line extends UI {
             if (data.__useArrow)
                 PathArrow.addArrows(this, false);
         }
-        else {
+        else
             super.__updateRenderPath();
-        }
     }
     __updateBoxBounds() {
         if (this.points) {
             toBounds$1(this.__.__pathForRender, this.__layout.boxBounds);
         }
-        else {
+        else
             super.__updateBoxBounds();
-        }
     }
 };
 __decorate([
@@ -8665,7 +8677,6 @@ let Canvas = class Canvas extends Rect {
         super(data);
         this.canvas = Creator.canvas(this.__);
         this.context = this.canvas.context;
-        this.__.__isCanvas = this.__.__drawAfterFill = true;
         if (data && data.url)
             this.drawImage(data.url);
     }
@@ -8678,8 +8689,7 @@ let Canvas = class Canvas extends Rect {
         });
     }
     draw(ui, offset, scale, rotation) {
-        ui.__layout.update();
-        const matrix = new Matrix(ui.__world).invert();
+        const matrix = new Matrix(ui.worldTransform).invert();
         const m = new Matrix();
         if (offset)
             m.translate(offset.x, offset.y);
@@ -8694,17 +8704,9 @@ let Canvas = class Canvas extends Rect {
     paint() {
         this.forceRender();
     }
-    __drawAfterFill(canvas, _options) {
-        const { width, height, cornerRadius } = this.__, { view } = this.canvas;
-        if (cornerRadius || this.pathInputed) {
-            canvas.save();
-            canvas.clip();
-            canvas.drawImage(view, 0, 0, view.width, view.height, 0, 0, width, height);
-            canvas.restore();
-        }
-        else {
-            canvas.drawImage(view, 0, 0, view.width, view.height, 0, 0, width, height);
-        }
+    __drawContent(canvas, _options) {
+        const { width, height } = this.__, { view } = this.canvas;
+        canvas.drawImage(view, 0, 0, view.width, view.height, 0, 0, width, height);
     }
     __updateSize() {
         const { canvas } = this;
@@ -8748,7 +8750,6 @@ Canvas = __decorate([
 const { copyAndSpread, includes, isSame: isSame$1, spread, setList } = BoundsHelper;
 let Text = class Text extends UI {
     get __tag() { return 'Text'; }
-    get editInner() { return 'TextEditor'; }
     get textDrawData() {
         this.__layout.update();
         return this.__.__textDrawData;
@@ -8897,6 +8898,9 @@ __decorate([
 __decorate([
     boundsType('top')
 ], Text.prototype, "verticalAlign", void 0);
+__decorate([
+    boundsType(true)
+], Text.prototype, "autoSizeAlign", void 0);
 __decorate([
     boundsType('normal')
 ], Text.prototype, "textWrap", void 0);
@@ -8911,7 +8915,6 @@ let Path = class Path extends UI {
     get __tag() { return 'Path'; }
     constructor(data) {
         super(data);
-        this.__.__pathInputed = 2;
     }
 };
 __decorate([
@@ -8994,21 +8997,17 @@ let App = class App extends Leafer {
                 this.tree = this.addLeafer(tree);
             if (sky || editor)
                 this.sky = this.addLeafer(sky || { type: 'draw', usePartRender: false });
-            if (editor) {
-                this.editor = Creator.editor(editor);
-                this.sky.add(this.editor);
-            }
+            if (editor)
+                this.sky.add(this.editor = Creator.editor(editor));
         }
     }
     __setApp() {
         const { canvas } = this;
         const { realCanvas, view } = this.config;
-        if (realCanvas || view === this.canvas.view || !canvas.parentView) {
+        if (realCanvas || view === this.canvas.view || !canvas.parentView)
             this.realCanvas = true;
-        }
-        else {
+        else
             canvas.unrealCanvas();
-        }
         this.leafer = this;
         this.watcher.disable();
         this.layouter.disable();
@@ -9414,10 +9413,7 @@ leafer.initType = function (type) {
 leafer.getValidMove = function (moveX, moveY) {
     const { scroll, disabled } = this.app.config.move;
     if (scroll) {
-        if (Math.abs(moveX) > Math.abs(moveY))
-            moveY = 0;
-        else
-            moveX = 0;
+        Math.abs(moveX) > Math.abs(moveY) ? moveY = 0 : moveX = 0;
         if (scroll === 'limit') {
             const { x, y, width, height } = new Bounds(this.__world).addPoint(this.zoomLayer);
             const right = x + width - this.width, bottom = y + height - this.height;
@@ -9617,9 +9613,10 @@ class Dragger {
         this.dragData = getDragEventData(data, data, data);
         this.canAnimate = this.canDragOut = true;
     }
-    getList() {
+    getList(realDraggable, hover) {
         const { proxy } = this.interaction.selector;
-        return this.dragging && (!proxy || !proxy.list.length) ? (DragEvent.list || this.dragableList || emptyList) : emptyList;
+        const hasProxyList = proxy && proxy.list.length, dragList = DragEvent.list || this.draggableList || emptyList;
+        return this.dragging && (hasProxyList ? (realDraggable ? emptyList : new LeafList(hover ? [...proxy.list, ...proxy.dragHoverExclude] : proxy.list)) : dragList);
     }
     checkDrag(data, canDrag) {
         const { interaction } = this;
@@ -9644,8 +9641,8 @@ class Dragger {
             this.dragging = canDrag && PointerButton.left(data);
             if (this.dragging) {
                 this.interaction.emit(DragEvent.START, this.dragData);
-                this.getDragableList(this.dragData.path);
-                this.setDragStartPoints(this.realDragableList = this.getList());
+                this.getDraggableList(this.dragData.path);
+                this.setDragStartPoints(this.realDraggableList = this.getList(true));
             }
         }
     }
@@ -9653,12 +9650,12 @@ class Dragger {
         this.dragStartPoints = {};
         list.forEach(leaf => this.dragStartPoints[leaf.innerId] = { x: leaf.x, y: leaf.y });
     }
-    getDragableList(path) {
+    getDraggableList(path) {
         let leaf;
         for (let i = 0, len = path.length; i < len; i++) {
             leaf = path.list[i];
-            if ((leaf.__.draggable || leaf.__.editable) && leaf.__.hitSelf && !leaf.__.locked) {
-                this.dragableList = new LeafList(leaf);
+            if ((leaf.draggable || leaf.editable) && leaf.hitSelf && !leaf.locked) {
+                this.draggableList = new LeafList(leaf);
                 break;
             }
         }
@@ -9683,7 +9680,7 @@ class Dragger {
     }
     dragReal() {
         const { running } = this.interaction;
-        const list = this.realDragableList;
+        const list = this.realDraggableList;
         if (list.length && running) {
             const { totalX, totalY } = this.dragData;
             list.forEach(leaf => leaf.draggable && leaf.move(DragEvent.getValidMove(leaf, this.dragStartPoints[leaf.innerId], { x: totalX, y: totalY })));
@@ -9772,7 +9769,7 @@ class Dragger {
         this.interaction.emit(DragEvent.LEAVE, data, dragEnterPath);
     }
     dragReset() {
-        DragEvent.list = DragEvent.data = this.dragableList = this.dragData = this.downData = this.dragOverPath = this.dragEnterPath = null;
+        DragEvent.list = DragEvent.data = this.draggableList = this.dragData = this.downData = this.dragOverPath = this.dragEnterPath = null;
     }
     checkDragOut(data) {
         const { interaction } = this;
@@ -9913,6 +9910,7 @@ const config = {
     touch: {
         preventDefault: true
     },
+    multiTouch: {},
     cursor: true,
     keyEvent: true
 };
@@ -10039,6 +10037,8 @@ class InteractionBase {
         this.pointerUp(data);
     }
     multiTouch(data, list) {
+        if (this.config.multiTouch.disabled)
+            return;
         const { move, angle, scale, center } = MultiTouchHelper.getData(list);
         this.rotate(getRotateEventData$1(center, angle, data));
         this.zoom(getZoomEventData$1(center, scale, data));
@@ -10228,7 +10228,7 @@ class InteractionBase {
             data = this.hoverData;
         if (!data)
             return;
-        this.findPath(data, { exclude: this.dragger.getList(), name: PointerEvent.MOVE });
+        this.findPath(data, { exclude: this.dragger.getList(false, true), name: PointerEvent.MOVE });
         this.hoverData = data;
     }
     updateCursor(data) {
@@ -10250,7 +10250,7 @@ class InteractionBase {
         const { path } = data;
         for (let i = 0, len = path.length; i < len; i++) {
             leaf = path.list[i];
-            cursor = leaf.syncEventer ? leaf.syncEventer.cursor : leaf.cursor;
+            cursor = (leaf.syncEventer && leaf.syncEventer.cursor) || leaf.cursor;
             if (cursor)
                 break;
         }
@@ -10432,7 +10432,7 @@ ui$2.__updateHitCanvas = function () {
     if (isHitPixel) {
         const { renderBounds } = this.__layout;
         const size = Platform.image.hitCanvasSize;
-        const scale = h.hitScale = tempBounds$1.set(0, 0, size, size).getFitMatrix(renderBounds, 0.5).a;
+        const scale = h.hitScale = tempBounds$1.set(0, 0, size, size).getFitMatrix(renderBounds).a;
         const { x, y, width, height } = tempBounds$1.set(renderBounds).scale(scale);
         h.resize({ width, height, pixelRatio: 1 });
         h.clear();
@@ -10488,15 +10488,14 @@ ui$2.__hit = function (inner) {
     return hitWidth ? this.__hitStroke(inner, hitWidth) : false;
 };
 
-const ui$1 = new UI();
-const rect = Rect.prototype;
-rect.__updateHitCanvas = function () {
+const ui$1 = UI.prototype, rect = Rect.prototype, box$1 = Box.prototype;
+rect.__updateHitCanvas = box$1.__updateHitCanvas = function () {
     if (this.stroke || this.cornerRadius || ((this.fill || this.__.__isCanvas) && this.hitFill === 'pixel') || this.hitStroke === 'all')
         ui$1.__updateHitCanvas.call(this);
     else if (this.__hitCanvas)
         this.__hitCanvas = null;
 };
-rect.__hitFill = function (inner) {
+rect.__hitFill = box$1.__hitFill = function (inner) {
     return this.__hitCanvas ? ui$1.__hitFill.call(this, inner) : BoundsHelper.hitRadiusPoint(this.__layout.boxBounds, inner);
 };
 
@@ -11347,9 +11346,10 @@ function image(ui, attrName, paint, boxBounds, firstUse) {
             onLoadError(ui, event, image.error);
     }
     else {
-        ignoreRender(ui, true);
-        if (firstUse)
+        if (firstUse) {
+            ignoreRender(ui, true);
             onLoad(ui, event);
+        }
         leafPaint.loadId = image.load(() => {
             ignoreRender(ui, false);
             if (!ui.destroyed) {
@@ -11497,7 +11497,7 @@ function checkImage(ui, canvas, paint, allowPaint) {
         }
         if (allowPaint) {
             canvas.save();
-            canvas.clip();
+            ui.windingRule ? canvas.clip(ui.windingRule) : canvas.clip();
             if (paint.blendMode)
                 canvas.blendMode = paint.blendMode;
             if (data.opacity)
@@ -11961,11 +11961,12 @@ const { trimRight } = TextRowHelper;
 const { Letter, Single, Before, After, Symbol, Break } = CharType;
 let word, row, wordWidth, rowWidth, realWidth;
 let char, charWidth, startCharSize, charSize, charType, lastCharType, langBreak, afterBreak, paraStart;
-let textDrawData, rows = [], bounds;
+let textDrawData, rows = [], bounds, findMaxWidth;
 function createRows(drawData, content, style) {
     textDrawData = drawData;
     rows = drawData.rows;
     bounds = drawData.bounds;
+    findMaxWidth = !bounds.width && !style.autoSizeAlign;
     const { __letterSpacing, paraIndent, textCase } = style;
     const { canvas } = Platform;
     const { width, height } = bounds;
@@ -12050,7 +12051,10 @@ function createRows(drawData, content, style) {
     else {
         content.split('\n').forEach(content => {
             textDrawData.paraNumber++;
-            rows.push({ x: paraIndent || 0, text: content, width: canvas.measureText(content).width, paraStart: true });
+            rowWidth = canvas.measureText(content).width;
+            rows.push({ x: paraIndent || 0, text: content, width: rowWidth, paraStart: true });
+            if (findMaxWidth)
+                setMaxWidth();
         });
     }
 }
@@ -12081,10 +12085,16 @@ function addRow() {
     row.width = rowWidth;
     if (bounds.width)
         trimRight(row);
+    else if (findMaxWidth)
+        setMaxWidth();
     rows.push(row);
     row = { words: [] };
     rowWidth = 0;
 }
+function setMaxWidth() {
+    if (rowWidth > (textDrawData.maxWidth || 0))
+        textDrawData.maxWidth = rowWidth;
+}
 
 const CharMode = 0;
 const WordMode = 1;
@@ -12156,34 +12166,32 @@ function toChar(data, charX, rowData, isOverflow) {
 
 function layoutText(drawData, style) {
     const { rows, bounds } = drawData;
-    const { __lineHeight, __baseLine, __letterSpacing, __clipText, textAlign, verticalAlign, paraSpacing } = style;
+    const { __lineHeight, __baseLine, __letterSpacing, __clipText, textAlign, verticalAlign, paraSpacing, autoSizeAlign } = style;
     let { x, y, width, height } = bounds, realHeight = __lineHeight * rows.length + (paraSpacing ? paraSpacing * (drawData.paraNumber - 1) : 0);
     let starY = __baseLine;
     if (__clipText && realHeight > height) {
         realHeight = Math.max(height, __lineHeight);
         drawData.overflow = rows.length;
     }
-    else {
+    else if (height || autoSizeAlign) {
         switch (verticalAlign) {
             case 'middle':
                 y += (height - realHeight) / 2;
                 break;
-            case 'bottom':
-                y += (height - realHeight);
+            case 'bottom': y += (height - realHeight);
         }
     }
     starY += y;
-    let row, rowX, rowWidth;
+    let row, rowX, rowWidth, layoutWidth = (width || autoSizeAlign) ? width : drawData.maxWidth;
     for (let i = 0, len = rows.length; i < len; i++) {
         row = rows[i];
         row.x = x;
         if (row.width < width || (row.width > width && !__clipText)) {
             switch (textAlign) {
                 case 'center':
-                    row.x += (width - row.width) / 2;
+                    row.x += (layoutWidth - row.width) / 2;
                     break;
-                case 'right':
-                    row.x += width - row.width;
+                case 'right': row.x += layoutWidth - row.width;
             }
         }
         if (row.paraStart && paraSpacing && i > 0)
@@ -12288,14 +12296,14 @@ function getDrawData(content, style) {
     let height = style.__getInput('height') || 0;
     const { textDecoration, __font, __padding: padding } = style;
     if (padding) {
-        if (width) {
+        if (width)
+            x = padding[left], width -= (padding[right] + padding[left]);
+        else if (!style.autoSizeAlign)
             x = padding[left];
-            width -= (padding[right] + padding[left]);
-        }
-        if (height) {
+        if (height)
+            y = padding[top], height -= (padding[top] + padding[bottom]);
+        else if (!style.autoSizeAlign)
             y = padding[top];
-            height -= (padding[top] + padding[bottom]);
-        }
     }
     const drawData = {
         bounds: { x, y, width, height },
@@ -12315,22 +12323,20 @@ function getDrawData(content, style) {
     return drawData;
 }
 function padAutoText(padding, drawData, style, width, height) {
-    if (!width) {
+    if (!width && style.autoSizeAlign) {
         switch (style.textAlign) {
             case 'left':
                 offsetText(drawData, 'x', padding[left]);
                 break;
-            case 'right':
-                offsetText(drawData, 'x', -padding[right]);
+            case 'right': offsetText(drawData, 'x', -padding[right]);
         }
     }
-    if (!height) {
+    if (!height && style.autoSizeAlign) {
         switch (style.verticalAlign) {
             case 'top':
                 offsetText(drawData, 'y', padding[top]);
                 break;
-            case 'bottom':
-                offsetText(drawData, 'y', -padding[bottom]);
+            case 'bottom': offsetText(drawData, 'y', -padding[bottom]);
         }
     }
 }