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

package/dist/core.esm.js

@@ -1,4 +1,4 @@
-import { MoveEvent, LeafHelper, ZoomEvent, Debug, LeafData, PathConvert, defineLeafAttr, OneRadian, Platform, dataProcessor, dataType, surfaceType, opacityType, maskType, eraserType, sortType, positionType, boundsType, scaleType, rotationType, hitType, strokeType, cursorType, pathType, rewrite, Leaf, PathDrawer, useModule, rewriteAble, PathCorner, UICreator, Branch, registerUI, affectRenderBoundsType, BoundsHelper, PathCommandDataHelper, PathBounds, affectStrokeBoundsType, PointHelper, ImageEvent, Creator, Matrix, PathCreator, DataHelper, CanvasManager, HitCanvasManager, PluginManager, LeaferEvent, canvasSizeAttrs, ResizeEvent, AutoBounds, WaitHelper, ImageManager, Run, LayoutEvent, RenderEvent, WatchEvent, PropertyEvent } from '@leafer/core';
+import { MoveEvent, LeafHelper, ZoomEvent, Debug, LeafData, PathConvert, defineLeafAttr, OneRadian, Platform, dataProcessor, dataType, surfaceType, opacityType, maskType, eraserType, sortType, positionType, boundsType, scaleType, rotationType, autoLayoutType, hitType, strokeType, cursorType, pathType, rewrite, Leaf, PathDrawer, useModule, rewriteAble, PathCorner, UICreator, MatrixHelper, Branch, registerUI, affectRenderBoundsType, BoundsHelper, PathCommandDataHelper, affectStrokeBoundsType, PathScaler, PointHelper, PathBounds, ImageEvent, Creator, Matrix, MathHelper, PathCreator, ImageManager, DataHelper, CanvasManager, HitCanvasManager, PluginManager, LeaferEvent, canvasSizeAttrs, ResizeEvent, AutoBounds, WaitHelper, Run, LayoutEvent, RenderEvent, WatchEvent, AnimateEvent, PropertyEvent } from '@leafer/core';
 export * from '@leafer/core';
 
 /******************************************************************************
@@ -39,7 +39,7 @@ function design(leafer) {
     if (leafer.isApp)
         return;
     leafer.__eventIds.push(leafer.on_(MoveEvent.BEFORE_MOVE, (e) => { LeafHelper.moveWorld(leafer.zoomLayer, e.moveX, e.moveY); }), leafer.on_(ZoomEvent.BEFORE_ZOOM, (e) => {
-        const { scaleX } = leafer.zoomLayer.__, { min, max } = leafer.config.zoom;
+        const { scaleX } = leafer.zoomLayer.__, { min, max } = leafer.app.config.zoom;
         let { scale } = e;
         if (scale * Math.abs(scaleX) < min)
             scale = min / scaleX;
@@ -86,6 +86,9 @@ const Export = {};
 const emptyPaint = {};
 const debug$1 = Debug.get('UIData');
 class UIData extends LeafData {
+    get __autoWidth() { return !this._width; }
+    get __autoHeight() { return !this._height; }
+    get __autoBounds() { return !this._width && !this._height; }
     setVisible(value) {
         if (this.__leaf.leafer)
             this.__leaf.leafer.watcher.hasVisible = true;
@@ -262,6 +265,9 @@ class TextData extends UIData {
 class ImageData extends RectData {
 }
 
+class CanvasData extends RectData {
+}
+
 function effectType(defaultValue) {
     return (target, key) => {
         defineLeafAttr(target, key, defaultValue, {
@@ -472,6 +478,7 @@ const RectRender = {
 
 var UI_1;
 let UI = UI_1 = class UI extends Leaf {
+    get app() { return this.leafer && this.leafer.app; }
     set scale(value) {
         if (typeof value === 'number') {
             this.scaleX = this.scaleY = value;
@@ -485,22 +492,25 @@ let UI = UI_1 = class UI extends Leaf {
         const { scaleX, scaleY } = this;
         return scaleX !== scaleY ? { x: scaleX, y: scaleY } : scaleX;
     }
+    constructor(data) {
+        super(data);
+    }
     reset(_data) { }
     set(data) {
         Object.assign(this, data);
     }
-    get(options) {
-        return this.__.__getInputData(options);
+    get() {
+        return this.__.__getInputData();
     }
-    getProxyData() { return undefined; }
-    find(condition) {
-        return this.leafer ? this.leafer.selector.getBy(condition, this) : [];
+    createProxyData() { return undefined; }
+    find(condition, options) {
+        return this.leafer ? this.leafer.selector.getBy(condition, this, false, options) : [];
     }
-    findOne(condition) {
-        return this.leafer ? this.leafer.selector.getBy(condition, this, true) : null;
+    findOne(condition, options) {
+        return this.leafer ? this.leafer.selector.getBy(condition, this, true, options) : null;
     }
     getPath(curve) {
-        const path = this.__.path;
+        const { path } = this.__;
         if (!path)
             return [];
         return curve ? PathConvert.toCanvasData(path, true) : path;
@@ -532,6 +542,15 @@ let UI = UI_1 = class UI extends Leaf {
         this.__drawPathByData(canvas, this.__.path);
     }
     __drawPathByData(_drawer, _data) { }
+    __drawPathByBox(drawer) {
+        const { x, y, width, height } = this.__layout.boxBounds;
+        if (this.__.cornerRadius) {
+            drawer.roundRect(x, y, width, height, this.__.cornerRadius);
+        }
+        else {
+            drawer.rect(x, y, width, height);
+        }
+    }
     export(filename, options) {
         return Export.export(this, filename, options);
     }
@@ -573,12 +592,12 @@ __decorate([
 __decorate([
     eraserType(false)
 ], UI.prototype, "isEraser", void 0);
+__decorate([
+    dataType(false)
+], UI.prototype, "locked", void 0);
 __decorate([
     sortType(0)
 ], UI.prototype, "zIndex", void 0);
-__decorate([
-    dataType()
-], UI.prototype, "locked", void 0);
 __decorate([
     positionType(0)
 ], UI.prototype, "x", void 0);
@@ -607,11 +626,17 @@ __decorate([
     rotationType(0)
 ], UI.prototype, "skewY", void 0);
 __decorate([
-    positionType()
+    autoLayoutType()
 ], UI.prototype, "around", void 0);
 __decorate([
     dataType(false)
 ], UI.prototype, "draggable", void 0);
+__decorate([
+    dataType(false)
+], UI.prototype, "editable", void 0);
+__decorate([
+    dataType('size')
+], UI.prototype, "editSize", void 0);
 __decorate([
     hitType(true)
 ], UI.prototype, "hittable", void 0);
@@ -664,7 +689,7 @@ __decorate([
     strokeType(10)
 ], UI.prototype, "miterLimit", void 0);
 __decorate([
-    pathType()
+    pathType(0)
 ], UI.prototype, "cornerRadius", void 0);
 __decorate([
     pathType()
@@ -697,9 +722,9 @@ UI = UI_1 = __decorate([
     rewriteAble()
 ], UI);
 
+const matrix = MatrixHelper.get();
 let Group = class Group extends UI {
     get __tag() { return 'Group'; }
-    get resizeable() { return false; }
     set mask(child) {
         if (this.__hasMask)
             this.__removeMask();
@@ -747,6 +772,14 @@ let Group = class Group extends UI {
         data.children = this.children.map(child => child.toJSON());
         return data;
     }
+    __scaleResize(scaleX, scaleY) {
+        const { children } = this;
+        for (let i = 0; i < children.length; i++) {
+            matrix.a = scaleX;
+            matrix.d = scaleY;
+            children[i].transform(matrix, true);
+        }
+    }
     addAt(child, index) {
         this.add(child, index);
     }
@@ -774,21 +807,17 @@ let Rect = class Rect extends UI {
     constructor(data) {
         super(data);
     }
-    __drawPathByData(drawer, _data) {
-        const { width, height, cornerRadius } = this.__;
-        if (cornerRadius) {
-            drawer.roundRect(0, 0, width, height, cornerRadius);
-        }
-        else {
-            drawer.rect(0, 0, width, height);
-        }
-    }
+    __drawPathByData(_drawer, _data) { }
 };
 __decorate([
     dataProcessor(RectData)
 ], Rect.prototype, "__", void 0);
+__decorate([
+    rewrite(UI.prototype.__drawPathByBox)
+], Rect.prototype, "__drawPathByData", null);
 Rect = __decorate([
     useModule(RectRender),
+    rewriteAble(),
     registerUI()
 ], Rect);
 
@@ -798,12 +827,20 @@ const bounds = {};
 const { copy, add } = BoundsHelper;
 let Box = class Box extends Group {
     get __tag() { return 'Box'; }
-    get resizeable() { return true; }
     constructor(data) {
         super(data);
         this.isBranchLeaf = true;
         this.__layout.renderChanged || this.__layout.renderChange();
     }
+    __scaleResize(scaleX, scaleY) {
+        if (this.__.__autoBounds && this.children.length) {
+            super.__scaleResize(scaleX, scaleY);
+        }
+        else {
+            this.width *= scaleX;
+            this.height *= scaleY;
+        }
+    }
     __updateStrokeSpread() { return 0; }
     __updateRectRenderSpread() { return 0; }
     __updateRenderSpread() {
@@ -813,7 +850,15 @@ let Box = class Box extends Group {
             width = this.__.__drawAfterFill ? 0 : 1;
         return width;
     }
-    __updateBoxBounds() { }
+    __updateRectBoxBounds() { }
+    __updateBoxBounds() {
+        if (this.__.__autoBounds && this.children.length) {
+            super.__updateBoxBounds();
+        }
+        else {
+            this.__updateRectBoxBounds();
+        }
+    }
     __updateStrokeBounds() { }
     __updateRenderBounds() {
         this.__updateRectRenderBounds();
@@ -865,7 +910,7 @@ __decorate([
 ], Box.prototype, "__updateRectRenderSpread", null);
 __decorate([
     rewrite(rect.__updateBoxBounds)
-], Box.prototype, "__updateBoxBounds", null);
+], Box.prototype, "__updateRectBoxBounds", null);
 __decorate([
     rewrite(rect.__updateStrokeBounds)
 ], Box.prototype, "__updateStrokeBounds", null);
@@ -893,6 +938,7 @@ let Frame = class Frame extends Box {
     get __tag() { return 'Frame'; }
     constructor(data) {
         super(data);
+        this.isFrame = true;
         if (!this.__.fill)
             this.__.fill = '#FFFFFF';
     }
@@ -933,7 +979,7 @@ let Ellipse = class Ellipse extends UI {
                 ellipse(path, rx, ry, rx, ry, 0, 360, 0, true);
             }
             if (Platform.ellipseToCurve)
-                this.__.path = PathConvert.toCanvasData(path, true);
+                this.__.path = this.getPath(true);
         }
         else {
             if (startAngle || endAngle) {
@@ -963,47 +1009,118 @@ Ellipse = __decorate([
     registerUI()
 ], Ellipse);
 
-const { sin: sin$1, cos: cos$1, PI: PI$1 } = Math;
-const { moveTo: moveTo$2, lineTo: lineTo$2, closePath: closePath$1, drawPoints: drawPoints$1 } = PathCommandDataHelper;
-const { toBounds: toBounds$2 } = PathBounds;
-let Polygon = class Polygon extends UI {
-    get __tag() { return 'Polygon'; }
-    get resizeable() { return !this.points; }
+const { moveTo: moveTo$2, lineTo: lineTo$2, drawPoints: drawPoints$1 } = PathCommandDataHelper;
+const { rotate, getAngle, getDistance, defaultPoint } = PointHelper;
+const { toBounds: toBounds$1 } = PathBounds;
+let Line = class Line extends UI {
+    get __tag() { return 'Line'; }
+    get toPoint() {
+        const { width, rotation } = this.__;
+        const to = { x: 0, y: 0 };
+        if (width)
+            to.x = width;
+        if (rotation)
+            rotate(to, rotation);
+        return to;
+    }
+    set toPoint(value) {
+        this.width = getDistance(defaultPoint, value);
+        this.rotation = getAngle(defaultPoint, value);
+        if (this.height)
+            this.height = 0;
+    }
     constructor(data) {
         super(data);
     }
     __updatePath() {
         const path = this.__.path = [];
         if (this.__.points) {
-            drawPoints$1(path, this.__.points, false, true);
+            drawPoints$1(path, this.__.points, false);
         }
         else {
-            const { width, height, sides } = this.__;
-            const rx = width / 2, ry = height / 2;
-            moveTo$2(path, rx, 0);
-            for (let i = 1; i < sides; i++) {
-                lineTo$2(path, rx + rx * sin$1((i * 2 * PI$1) / sides), ry - ry * cos$1((i * 2 * PI$1) / sides));
-            }
+            moveTo$2(path, 0, 0);
+            lineTo$2(path, this.width, 0);
         }
-        closePath$1(path);
     }
     __updateRenderPath() {
         if (this.__.points && this.__.curve) {
-            drawPoints$1(this.__.__pathForRender = [], this.__.points, this.__.curve, true);
+            drawPoints$1(this.__.__pathForRender = [], this.__.points, this.__.curve, this.__tag !== 'Line');
         }
         else {
             super.__updateRenderPath();
         }
     }
     __updateBoxBounds() {
-        if (this.__.points) {
-            toBounds$2(this.__.__pathForRender, this.__layout.boxBounds);
-            this.__updateNaturalSize();
+        if (this.points) {
+            toBounds$1(this.__.__pathForRender, this.__layout.boxBounds);
         }
         else {
             super.__updateBoxBounds();
         }
     }
+    __scaleResize(scaleX, scaleY) {
+        if (this.points) {
+            PathScaler.scalePoints(this.__.points, scaleX, scaleY);
+            this.points = this.__.points;
+        }
+        else {
+            if (this.__tag === 'Line') {
+                const point = this.toPoint;
+                point.x *= scaleX;
+                point.y *= scaleY;
+                this.toPoint = point;
+            }
+            else {
+                super.__scaleResize(scaleX, scaleY);
+            }
+        }
+    }
+};
+__decorate([
+    dataProcessor(LineData)
+], Line.prototype, "__", void 0);
+__decorate([
+    affectStrokeBoundsType('center')
+], Line.prototype, "strokeAlign", void 0);
+__decorate([
+    boundsType(0)
+], Line.prototype, "height", void 0);
+__decorate([
+    pathType()
+], Line.prototype, "points", void 0);
+__decorate([
+    pathType(0)
+], Line.prototype, "curve", void 0);
+Line = __decorate([
+    registerUI()
+], Line);
+
+const { sin: sin$1, cos: cos$1, PI: PI$1 } = Math;
+const { moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath$1, drawPoints } = PathCommandDataHelper;
+const line = Line.prototype;
+let Polygon = class Polygon extends UI {
+    get __tag() { return 'Polygon'; }
+    constructor(data) {
+        super(data);
+    }
+    __updatePath() {
+        const path = this.__.path = [];
+        if (this.__.points) {
+            drawPoints(path, this.__.points, false, true);
+        }
+        else {
+            const { width, height, sides } = this.__;
+            const rx = width / 2, ry = height / 2;
+            moveTo$1(path, rx, 0);
+            for (let i = 1; i < sides; i++) {
+                lineTo$1(path, rx + rx * sin$1((i * 2 * PI$1) / sides), ry - ry * cos$1((i * 2 * PI$1) / sides));
+            }
+        }
+        closePath$1(path);
+    }
+    __updateRenderPath() { }
+    __updateBoxBounds() { }
+    __scaleResize(_scaleX, _scaleY) { }
 };
 __decorate([
     dataProcessor(PolygonData)
@@ -1017,12 +1134,22 @@ __decorate([
 __decorate([
     pathType(0)
 ], Polygon.prototype, "curve", void 0);
+__decorate([
+    rewrite(line.__updateRenderPath)
+], Polygon.prototype, "__updateRenderPath", null);
+__decorate([
+    rewrite(line.__updateBoxBounds)
+], Polygon.prototype, "__updateBoxBounds", null);
+__decorate([
+    rewrite(line.__scaleResize)
+], Polygon.prototype, "__scaleResize", null);
 Polygon = __decorate([
+    rewriteAble(),
     registerUI()
 ], Polygon);
 
 const { sin, cos, PI } = Math;
-const { moveTo: moveTo$1, lineTo: lineTo$1, closePath } = PathCommandDataHelper;
+const { moveTo, lineTo, closePath } = PathCommandDataHelper;
 let Star = class Star extends UI {
     get __tag() { return 'Star'; }
     constructor(data) {
@@ -1032,9 +1159,9 @@ let Star = class Star extends UI {
         const { width, height, corners, innerRadius } = this.__;
         const rx = width / 2, ry = height / 2;
         const path = this.__.path = [];
-        moveTo$1(path, rx, 0);
+        moveTo(path, rx, 0);
         for (let i = 1; i < corners * 2; i++) {
-            lineTo$1(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin((i * PI) / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos((i * PI) / corners));
+            lineTo(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin((i * PI) / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos((i * PI) / corners));
         }
         closePath(path);
     }
@@ -1052,77 +1179,6 @@ Star = __decorate([
     registerUI()
 ], Star);
 
-const { moveTo, lineTo, drawPoints } = PathCommandDataHelper;
-const { rotate, getAngle, getDistance, defaultPoint } = PointHelper;
-const { toBounds: toBounds$1 } = PathBounds;
-let Line = class Line extends UI {
-    get __tag() { return 'Line'; }
-    get resizeable() { return !this.points; }
-    get toPoint() {
-        const { width, rotation } = this.__;
-        const to = { x: 0, y: 0 };
-        if (width)
-            to.x = width;
-        if (rotation)
-            rotate(to, rotation);
-        return to;
-    }
-    set toPoint(value) {
-        this.width = getDistance(defaultPoint, value);
-        this.rotation = getAngle(defaultPoint, value);
-        if (this.height)
-            this.height = 0;
-    }
-    constructor(data) {
-        super(data);
-    }
-    __updatePath() {
-        const path = this.__.path = [];
-        if (this.__.points) {
-            drawPoints(path, this.__.points, false);
-        }
-        else {
-            moveTo(path, 0, 0);
-            lineTo(path, this.width, 0);
-        }
-    }
-    __updateRenderPath() {
-        if (this.__.points && this.__.curve) {
-            drawPoints(this.__.__pathForRender = [], this.__.points, this.__.curve, false);
-        }
-        else {
-            super.__updateRenderPath();
-        }
-    }
-    __updateBoxBounds() {
-        if (this.points) {
-            toBounds$1(this.__.__pathForRender, this.__layout.boxBounds);
-            this.__updateNaturalSize();
-        }
-        else {
-            super.__updateBoxBounds();
-        }
-    }
-};
-__decorate([
-    dataProcessor(LineData)
-], Line.prototype, "__", void 0);
-__decorate([
-    affectStrokeBoundsType('center')
-], Line.prototype, "strokeAlign", void 0);
-__decorate([
-    boundsType(0)
-], Line.prototype, "height", void 0);
-__decorate([
-    pathType()
-], Line.prototype, "points", void 0);
-__decorate([
-    pathType(0)
-], Line.prototype, "curve", void 0);
-Line = __decorate([
-    registerUI()
-], Line);
-
 let Image = class Image extends Rect {
     get __tag() { return 'Image'; }
     get ready() { return this.image ? this.image.ready : false; }
@@ -1173,7 +1229,7 @@ let Canvas = class Canvas extends Rect {
         this.__.__drawAfterFill = true;
     }
     draw(ui, offset, scale, rotation) {
-        ui.__layout.checkUpdate();
+        ui.__layout.update();
         const matrix = new Matrix(ui.__world);
         matrix.invert();
         const m = new Matrix();
@@ -1183,7 +1239,7 @@ let Canvas = class Canvas extends Rect {
             typeof scale === 'number' ? m.scale(scale) : m.scale(scale.x, scale.y);
         if (rotation)
             m.rotate(rotation);
-        matrix.preMultiply(m);
+        matrix.multiplyParent(m);
         ui.__render(this.canvas, { matrix });
         this.paint();
     }
@@ -1243,11 +1299,11 @@ Canvas = __decorate([
     registerUI()
 ], Canvas);
 
-const { copyAndSpread, includes, spread, setByList } = BoundsHelper;
+const { copyAndSpread, includes, spread, setList } = BoundsHelper;
 let Text = class Text extends UI {
     get __tag() { return 'Text'; }
     get textDrawData() {
-        this.__layout.checkUpdate();
+        this.__layout.update();
         return this.__.__textDrawData;
     }
     constructor(data) {
@@ -1277,34 +1333,46 @@ let Text = class Text extends UI {
     __updateBoxBounds() {
         const data = this.__;
         const layout = this.__layout;
-        const { lineHeight, letterSpacing, fontFamily, fontSize, fontWeight, italic, textCase, textOverflow } = data;
-        const width = data.__getInput('width');
-        const height = data.__getInput('height');
+        const { lineHeight, letterSpacing, fontFamily, fontSize, fontWeight, italic, textCase, textOverflow, padding } = data;
+        const autoWidth = data.__autoWidth;
+        const autoHeight = data.__autoHeight;
         data.__lineHeight = UnitConvert.number(lineHeight, fontSize);
         data.__letterSpacing = UnitConvert.number(letterSpacing, fontSize);
+        data.__padding = padding ? MathHelper.fourNumber(padding) : undefined;
         data.__baseLine = data.__lineHeight - (data.__lineHeight - fontSize * 0.7) / 2;
         data.__font = `${italic ? 'italic ' : ''}${textCase === 'small-caps' ? 'small-caps ' : ''}${fontWeight !== 'normal' ? fontWeight + ' ' : ''}${fontSize}px ${fontFamily}`;
-        data.__clipText = textOverflow !== 'show' && (width || height);
+        data.__clipText = textOverflow !== 'show' && !data.__autoBounds;
         this.__updateTextDrawData();
         const { bounds } = data.__textDrawData;
         const b = layout.boxBounds;
         if (data.__lineHeight < fontSize)
             spread(bounds, fontSize / 2);
-        if (width && height) {
-            super.__updateBoxBounds();
+        if (autoWidth || autoHeight) {
+            b.x = autoWidth ? bounds.x : 0;
+            b.y = autoHeight ? bounds.y : 0;
+            b.width = autoWidth ? bounds.width : data.width;
+            b.height = autoHeight ? bounds.height : data.height;
+            if (padding) {
+                const [top, right, bottom, left] = data.__padding;
+                if (autoWidth) {
+                    b.x -= left;
+                    b.width += (right + left);
+                }
+                if (autoHeight) {
+                    b.y -= top;
+                    b.height += (bottom + top);
+                }
+            }
+            this.__updateNaturalSize();
         }
         else {
-            b.x = width ? 0 : bounds.x;
-            b.y = height ? 0 : bounds.y;
-            b.width = width ? width : bounds.width;
-            b.height = height ? height : bounds.height;
-            this.__updateNaturalSize();
+            super.__updateBoxBounds();
         }
         const contentBounds = includes(b, bounds) ? b : bounds;
         if (contentBounds !== layout.contentBounds) {
             layout.contentBounds = contentBounds;
             layout.renderChanged = true;
-            setByList(data.__textBoxBounds = {}, [b, bounds]);
+            setList(data.__textBoxBounds = {}, [b, bounds]);
         }
         else {
             data.__textBoxBounds = contentBounds;
@@ -1332,6 +1400,9 @@ __decorate([
 __decorate([
     boundsType(0)
 ], Text.prototype, "padding", void 0);
+__decorate([
+    surfaceType('#000000')
+], Text.prototype, "fill", void 0);
 __decorate([
     affectStrokeBoundsType('outside')
 ], Text.prototype, "strokeAlign", void 0);
@@ -1390,13 +1461,15 @@ Text = __decorate([
 const { toBounds } = PathBounds;
 let Path = class Path extends UI {
     get __tag() { return 'Path'; }
-    get resizeable() { return false; }
     constructor(data) {
         super(data);
     }
+    __scaleResize(scaleX, scaleY) {
+        PathScaler.scale(this.__.path, scaleX, scaleY);
+        this.path = this.__.path;
+    }
     __updateBoxBounds() {
         toBounds(this.__.path, this.__layout.boxBounds);
-        this.__updateNaturalSize();
     }
 };
 __decorate([
@@ -1465,6 +1538,8 @@ let Leafer = class Leafer extends Group {
     get __tag() { return 'Leafer'; }
     get isApp() { return false; }
     get app() { return this.parent || this; }
+    get imageReady() { return this.viewReady && ImageManager.isComplete; }
+    get layoutLocked() { return !this.layouter.running; }
     get cursorPoint() { return (this.interaction && this.interaction.hoverData) || { x: this.width / 2, y: this.height / 2 }; }
     constructor(userConfig, data) {
         super(data);
@@ -1557,13 +1632,18 @@ let Leafer = class Leafer extends Group {
             this.emitLeafer(LeaferEvent.STOP);
         }
     }
+    unlockLayout() {
+        this.layouter.start();
+        this.updateLayout();
+    }
+    lockLayout() {
+        this.updateLayout();
+        this.layouter.stop();
+    }
     resize(size) {
         const data = DataHelper.copyAttrs({}, size, canvasSizeAttrs);
         Object.keys(data).forEach(key => this[key] = data[key]);
     }
-    forceLayout() {
-        this.__layout.checkUpdate(true);
-    }
     forceFullRender() {
         this.renderer.addBlock(this.canvas.bounds);
         if (this.viewReady)
@@ -1661,23 +1741,26 @@ let Leafer = class Leafer extends Group {
         this.emitLeafer(LeaferEvent.VIEW_READY);
         WaitHelper.run(this.__viewReadyWait);
     }
-    __onRenderEnd(_e) {
-        if (!this.viewReady)
-            this.__onViewReady();
-        const completed = this.__checkViewCompleted();
-        if (completed)
-            this.__onViewCompleted();
-        this.viewCompleted = completed;
-        WaitHelper.run(this.__nextRenderWait);
-    }
-    __checkViewCompleted() {
-        return this.viewReady && !this.watcher.changed && ImageManager.isComplete;
-    }
-    __onViewCompleted() {
-        if (!this.viewCompleted) {
-            this.emitLeafer(LeaferEvent.VIEW_COMPLETED);
-            WaitHelper.run(this.__viewCompletedWait);
-        }
+    __onAnimateFrame() {
+        if (this.viewReady) {
+            if (this.__nextRenderWait.length)
+                WaitHelper.run(this.__nextRenderWait);
+            const { imageReady } = this;
+            if (imageReady && !this.viewCompleted)
+                this.__checkViewCompleted();
+            if (!imageReady)
+                this.viewCompleted = false;
+        }
+    }
+    __checkViewCompleted(emit = true) {
+        this.nextRender(() => {
+            if (this.imageReady) {
+                if (emit)
+                    this.emitLeafer(LeaferEvent.VIEW_COMPLETED);
+                WaitHelper.run(this.__viewCompletedWait);
+                this.viewCompleted = true;
+            }
+        });
     }
     __onWatchData() {
         if (this.watcher.childrenChanged && this.interaction) {
@@ -1691,25 +1774,20 @@ let Leafer = class Leafer extends Group {
         this.viewReady ? item() : this.__viewReadyWait.push(item);
     }
     waitViewCompleted(item) {
+        this.__viewCompletedWait.push(item);
         if (this.viewCompleted) {
-            item();
+            this.__checkViewCompleted(false);
         }
         else {
-            this.__viewCompletedWait.push(item);
             if (!this.running)
                 this.start();
         }
     }
     nextRender(item) {
-        if (this.watcher && !this.watcher.changed) {
-            item();
-        }
-        else {
-            this.__nextRenderWait.push(item);
-        }
+        this.__nextRenderWait.push(item);
     }
     __checkUpdateLayout() {
-        this.__layout.checkUpdate();
+        this.__layout.update();
     }
     emitLeafer(type) {
         this.emitEvent(new LeaferEvent(type, this));
@@ -1719,7 +1797,8 @@ let Leafer = class Leafer extends Group {
         this.once(LeaferEvent.START, () => Run.end(runId));
         this.once(LayoutEvent.END, () => this.__onReady());
         this.once(RenderEvent.START, () => this.__onCreated());
-        this.__eventIds.push(this.on_(WatchEvent.DATA, this.__onWatchData, this), this.on_(RenderEvent.END, this.__onRenderEnd, this), this.on_(LayoutEvent.CHECK_UPDATE, this.__checkUpdateLayout, this));
+        this.once(RenderEvent.END, () => this.__onViewReady());
+        this.__eventIds.push(this.on_(WatchEvent.DATA, this.__onWatchData, this), this.on_(AnimateEvent.FRAME, this.__onAnimateFrame, this), this.on_(LayoutEvent.CHECK_UPDATE, this.__checkUpdateLayout, this));
     }
     __removeListenEvents() {
         this.off_(this.__eventIds);
@@ -1769,6 +1848,22 @@ Leafer = __decorate([
 let App = class App extends Leafer {
     get __tag() { return 'App'; }
     get isApp() { return true; }
+    constructor(userConfig, data) {
+        super(userConfig, data);
+        if (userConfig) {
+            const { ground, tree, sky, editor } = userConfig;
+            if (ground)
+                this.ground = this.addLeafer(ground);
+            if (tree || editor)
+                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);
+            }
+        }
+    }
     __setApp() {
         const { canvas } = this;
         const { realCanvas, view } = this.config;
@@ -1785,12 +1880,20 @@ let App = class App extends Leafer {
     }
     start() {
         super.start();
-        this.children.forEach(leafer => { leafer.start(); });
+        this.children.forEach(leafer => leafer.start());
     }
     stop() {
-        this.children.forEach(leafer => { leafer.stop(); });
+        this.children.forEach(leafer => leafer.stop());
         super.stop();
     }
+    unlockLayout() {
+        super.unlockLayout();
+        this.children.forEach(leafer => leafer.unlockLayout());
+    }
+    lockLayout() {
+        super.lockLayout();
+        this.children.forEach(leafer => leafer.lockLayout());
+    }
     addLeafer(merge) {
         const leafer = new Leafer(merge);
         this.add(leafer);
@@ -1809,7 +1912,7 @@ let App = class App extends Leafer {
     }
     __onPropertyChange() {
         if (Debug.showHitView)
-            this.children.forEach(leafer => { leafer.forceUpdate('surface'); });
+            this.children.forEach(leafer => leafer.forceUpdate('surface'));
     }
     __onCreated() {
         this.created = this.children.every(child => child.created);
@@ -1822,23 +1925,20 @@ let App = class App extends Leafer {
         if (this.children.every(child => child.viewReady))
             super.__onViewReady();
     }
-    __checkViewCompleted() {
-        return this.children.every(item => item.viewCompleted);
-    }
     __onChildRenderEnd(e) {
         this.renderer.addBlock(e.renderBounds);
         if (this.viewReady)
             this.renderer.update();
     }
     __render(canvas, _options) {
-        this.children.forEach(leafer => { canvas.copyWorld(leafer.canvas); });
+        this.children.forEach(leafer => canvas.copyWorld(leafer.canvas));
     }
     __onResize(event) {
-        this.children.forEach(leafer => { leafer.resize(event); });
+        this.children.forEach(leafer => leafer.resize(event));
         super.__onResize(event);
     }
     __checkUpdateLayout() {
-        this.children.forEach(leafer => { leafer.__layout.checkUpdate(); });
+        this.children.forEach(leafer => leafer.__layout.update());
     }
     __getChildConfig(userConfig) {
         let config = Object.assign({}, this.config);
@@ -1854,7 +1954,7 @@ let App = class App extends Leafer {
     __listenChildEvents(leafer) {
         leafer.once(LayoutEvent.END, () => this.__onReady());
         leafer.once(RenderEvent.START, () => this.__onCreated());
-        leafer.once(RenderEvent.END, (e) => this.__onRenderEnd(e));
+        leafer.once(RenderEvent.END, () => this.__onViewReady());
         if (this.realCanvas)
             this.__eventIds.push(leafer.on_(RenderEvent.END, this.__onChildRenderEnd, this));
     }
@@ -1863,4 +1963,4 @@ App = __decorate([
     registerUI()
 ], App);
 
-export { Animate, App, Box, Canvas, ColorConvert, Effect, Ellipse, Export, Frame, Group, Image, Leafer, LeaferTypeCreator, Line, Paint, Path, Pen, Polygon, Rect, RectRender, Star, Text, TextConvert, UI, UIBounds, UIHit, UIRender, effectType, resizeType };
+export { Animate, App, Box, BoxData, Canvas, CanvasData, ColorConvert, Effect, Ellipse, EllipseData, Export, Frame, FrameData, Group, GroupData, Image, ImageData, Leafer, LeaferData, LeaferTypeCreator, Line, LineData, Paint, Path, PathData, Pen, PenData, Polygon, PolygonData, Rect, RectData, RectRender, Star, StarData, Text, TextConvert, TextData, UI, UIBounds, UIData, UIHit, UIRender, UnitConvert, effectType, resizeType };