@leafer/miniapp 1.9.5 → 1.9.6

package/dist/miniapp.module.js

@@ -372,7 +372,7 @@ function getMatrixData() {
 
 const {sin: sin$6, cos: cos$6, acos: acos, sqrt: sqrt$5} = Math;
 
-const {float: float$2} = MathHelper;
+const {float: float$3} = MathHelper;
 
 const tempPoint$4 = {};
 
@@ -614,12 +614,12 @@ const MatrixHelper = {
                 const cosR = c / scaleY;
                 rotation = PI_2 - (d > 0 ? acos(-cosR) : -acos(cosR));
             }
-            const cosR = float$2(cos$6(rotation));
+            const cosR = float$3(cos$6(rotation));
             const sinR = sin$6(rotation);
-            scaleX = float$2(scaleX), scaleY = float$2(scaleY);
-            skewX = cosR ? float$2((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
-            skewY = cosR ? float$2((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
-            rotation = float$2(rotation / OneRadian);
+            scaleX = float$3(scaleX), scaleY = float$3(scaleY);
+            skewX = cosR ? float$3((c / scaleY + sinR) / cosR / OneRadian, 9) : 0;
+            skewY = cosR ? float$3((b / scaleX - sinR) / cosR / OneRadian, 9) : 0;
+            rotation = float$3(rotation / OneRadian);
         } else {
             scaleX = a;
             scaleY = d;
@@ -1141,7 +1141,7 @@ const {tempPointBounds: tempPointBounds$1, setPoint: setPoint$5, addPoint: addPo
 
 const {toOuterPoint: toOuterPoint$2} = MatrixHelper;
 
-const {float: float$1, fourNumber: fourNumber$1} = MathHelper;
+const {float: float$2, fourNumber: fourNumber$1} = MathHelper;
 
 const {floor: floor$3, ceil: ceil$3} = Math;
 
@@ -1324,10 +1324,10 @@ const BoundsHelper = {
         }
     },
     float(t, maxLength) {
-        t.x = float$1(t.x, maxLength);
-        t.y = float$1(t.y, maxLength);
-        t.width = float$1(t.width, maxLength);
-        t.height = float$1(t.height, maxLength);
+        t.x = float$2(t.x, maxLength);
+        t.y = float$2(t.y, maxLength);
+        t.width = float$2(t.width, maxLength);
+        t.height = float$2(t.height, maxLength);
     },
     add(t, bounds, isPoint) {
         right$4 = t.x + t.width;
@@ -5463,6 +5463,8 @@ LeaferEvent.RESTART = "leafer.restart";
 
 LeaferEvent.END = "leafer.end";
 
+LeaferEvent.UPDATE_MODE = "leafer.update_mode";
+
 LeaferEvent.TRANSFORM = "leafer.transform";
 
 LeaferEvent.MOVE = "leafer.move";
@@ -6749,7 +6751,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.5";
+const version = "1.9.6";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7628,7 +7630,7 @@ class Picker {
             item = path.list[i];
             if (!item.__.hittable) break;
             hittablePath.addAt(item, 0);
-            if (!item.__.hitChildren) break;
+            if (!item.__.hitChildren || item.isLeafer && item.mode === "draw") break;
         }
         return hittablePath;
     }
@@ -8085,8 +8087,6 @@ class TextData extends UIData {
             if (!boxStyle) box.parent = t, box.__world = t.__world, boxLayout.boxBounds = layout.boxBounds;
             box.set(value);
             if (boxLayout.strokeChanged) layout.strokeChange();
-            if (boxLayout.renderChanged) layout.renderChange();
-            box.__updateChange();
         } else if (box) {
             t.__box = box.parent = null;
             box.destroy();
@@ -8156,7 +8156,7 @@ const UIBounds = {
     __updateRenderSpread() {
         let width = 0;
         const {shadow: shadow, innerShadow: innerShadow, blur: blur, backgroundBlur: backgroundBlur, filter: filter, renderSpread: renderSpread} = 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));
+        if (shadow) width = Effect.getShadowSpread(this, shadow);
         if (blur) width = Math.max(width, blur);
         if (filter) width += Filter.getSpread(filter);
         if (renderSpread) width += renderSpread;
@@ -8169,36 +8169,69 @@ const UIBounds = {
     }
 };
 
+const {float: float$1} = MathHelper;
+
+const tempContent = new Bounds, tempMerge = new Bounds, tempIntersect = new Bounds;
+
 const DragBoundsHelper = {
+    limitMove(leaf, move) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, move, true);
+        D$2.axisMove(leaf, move);
+    },
+    limitScaleOf(leaf, origin, scale) {
+        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
+        if (dragBounds) D$2.getValidScaleOf(leaf.__localBoxBounds, D$2.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, true);
+    },
+    axisMove(leaf, move) {
+        const {draggable: draggable} = leaf;
+        if (draggable === "x") move.y = 0;
+        if (draggable === "y") move.x = 0;
+    },
+    getDragBounds(leaf) {
+        const {dragBounds: dragBounds} = leaf;
+        return dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds;
+    },
+    isInnerMode(content, dragBounds, dragBoundsType, sideType) {
+        return dragBoundsType === "inner" || dragBoundsType === "auto" && content[sideType] > dragBounds[sideType];
+    },
     getValidMove(content, dragBounds, dragBoundsType, move, change) {
         const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height;
         const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
         if (!change) move = Object.assign({}, move);
-        const isBiggerWidth = content.width > dragBounds.width;
-        const isBiggerHeight = content.height > dragBounds.height;
-        if (isBiggerWidth && dragBoundsType !== "outer") {
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
             if (x > dragBounds.x) move.x += dragBounds.x - x; else if (right < boundsRight) move.x += boundsRight - right;
         } else {
             if (x < dragBounds.x) move.x += dragBounds.x - x; else if (right > boundsRight) move.x += boundsRight - right;
         }
-        if (isBiggerHeight && dragBoundsType !== "outer") {
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
             if (y > dragBounds.y) move.y += dragBounds.y - y; else if (bottom < boundsBottom) move.y += boundsBottom - bottom;
         } else {
             if (y < dragBounds.y) move.y += dragBounds.y - y; else if (bottom > boundsBottom) move.y += boundsBottom - bottom;
         }
-        move.x = MathHelper.float(move.x);
-        move.y = MathHelper.float(move.y);
+        move.x = float$1(move.x);
+        move.y = float$1(move.y);
         return move;
     },
-    axisMove(leaf, move) {
-        const {draggable: draggable} = leaf;
-        if (draggable === "x") move.y = 0;
-        if (draggable === "y") move.x = 0;
-    },
-    limitMove(leaf, move) {
-        const {dragBounds: dragBounds, dragBoundsType: dragBoundsType} = leaf;
-        if (dragBounds) D$2.getValidMove(leaf.__localBoxBounds, dragBounds === "parent" ? leaf.parent.boxBounds : dragBounds, dragBoundsType, move, true);
-        D$2.axisMove(leaf, move);
+    getValidScaleOf(content, dragBounds, dragBoundsType, origin, scale, change) {
+        if (!change) scale = Object.assign({}, scale);
+        let fitScaleX, fitScaleY;
+        tempContent.set(content).scaleOf(origin, scale.x, scale.y).unsign();
+        tempMerge.set(tempContent).add(dragBounds);
+        tempIntersect.set(tempContent).intersect(dragBounds);
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
+            fitScaleX = tempMerge.width / tempContent.width;
+        } else {
+            fitScaleX = tempIntersect.width / tempContent.width;
+        }
+        if (D$2.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
+            fitScaleY = tempMerge.height / tempContent.height;
+        } else {
+            fitScaleY = tempIntersect.height / tempContent.height;
+        }
+        scale.x = float$1(tempIntersect.width) ? scale.x * fitScaleX : 1;
+        scale.y = float$1(tempIntersect.height) ? scale.y * fitScaleY : 1;
+        return scale;
     }
 };
 
@@ -8216,7 +8249,7 @@ const UIRender = {
         }
         if (data.__useEffect) {
             const {shadow: shadow, fill: fill, stroke: stroke} = data, otherEffect = data.innerShadow || data.blur || data.backgroundBlur || data.filter;
-            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
+            stintSet$1(data, "__isFastShadow", shadow && !otherEffect && shadow.length < 2 && !shadow[0].spread && !Effect.isTransformShadow(shadow[0]) && fill && !data.__isTransparentFill && !(isArray(fill) && fill.length > 1) && (this.useFastShadow || !stroke || stroke && data.strokeAlign === "inside"));
             data.__useEffect = !!(shadow || otherEffect);
         }
         data.__checkSingle();
@@ -8854,7 +8887,9 @@ let Leafer = Leafer_1 = class Leafer extends Group {
             } else if (attrName === "zIndex") {
                 this.canvas.zIndex = newValue;
                 setTimeout(() => this.parent && this.parent.__updateSortChildren());
-            }
+            } else if (attrName === "mode") this.emit(LeaferEvent.UPDATE_MODE, {
+                mode: newValue
+            });
         }
         return super.__setAttr(attrName, newValue);
     }
@@ -9037,6 +9072,8 @@ __decorate([ dataProcessor(LeaferData) ], Leafer.prototype, "__", void 0);
 
 __decorate([ boundsType() ], Leafer.prototype, "pixelRatio", void 0);
 
+__decorate([ dataType("normal") ], Leafer.prototype, "mode", void 0);
+
 Leafer = Leafer_1 = __decorate([ registerUI() ], Leafer);
 
 let Rect = class Rect extends UI {
@@ -9229,57 +9266,9 @@ __decorate([ pathType(0) ], Ellipse.prototype, "endAngle", void 0);
 
 Ellipse = __decorate([ registerUI() ], Ellipse);
 
-const {moveTo: moveTo$2, lineTo: lineTo$2, drawPoints: drawPoints$1} = PathCommandDataHelper;
-
-const {rotate: rotate$3, getAngle: getAngle$2, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
-
-let Line = class Line extends UI {
-    get __tag() {
-        return "Line";
-    }
-    get toPoint() {
-        const {width: width, rotation: rotation} = this.__;
-        const to = getPointData();
-        if (width) to.x = width;
-        if (rotation) rotate$3(to, rotation);
-        return to;
-    }
-    set toPoint(value) {
-        this.width = getDistance$3(defaultPoint, value);
-        this.rotation = getAngle$2(defaultPoint, value);
-        if (this.height) this.height = 0;
-    }
-    __updatePath() {
-        const data = this.__;
-        const path = data.path = [];
-        if (data.points) {
-            drawPoints$1(path, data.points, data.curve, data.closed);
-        } else {
-            moveTo$2(path, 0, 0);
-            lineTo$2(path, this.width, 0);
-        }
-    }
-};
-
-__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);
-
-__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
-
-Line = __decorate([ registerUI() ], Line);
-
 const {sin: sin$2, cos: cos$2, PI: PI$2} = Math;
 
-const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath$1, drawPoints: drawPoints} = PathCommandDataHelper;
-
-const line = Line.prototype;
+const {moveTo: moveTo$2, lineTo: lineTo$2, closePath: closePath$1, drawPoints: drawPoints$1} = PathCommandDataHelper;
 
 let Polygon = class Polygon extends UI {
     get __tag() {
@@ -9289,19 +9278,17 @@ let Polygon = class Polygon extends UI {
         const data = this.__;
         const path = data.path = [];
         if (data.points) {
-            drawPoints(path, data.points, data.curve, true);
+            drawPoints$1(path, data.points, data.curve, true);
         } else {
             const {width: width, height: height, sides: sides} = data;
             const rx = width / 2, ry = height / 2;
-            moveTo$1(path, rx, 0);
+            moveTo$2(path, rx, 0);
             for (let i = 1; i < sides; i++) {
-                lineTo$1(path, rx + rx * sin$2(i * 2 * PI$2 / sides), ry - ry * cos$2(i * 2 * PI$2 / sides));
+                lineTo$2(path, rx + rx * sin$2(i * 2 * PI$2 / sides), ry - ry * cos$2(i * 2 * PI$2 / sides));
             }
             closePath$1(path);
         }
     }
-    __updateRenderPath() {}
-    __updateBoxBounds() {}
 };
 
 __decorate([ dataProcessor(PolygonData) ], Polygon.prototype, "__", void 0);
@@ -9312,15 +9299,11 @@ __decorate([ pathType() ], Polygon.prototype, "points", void 0);
 
 __decorate([ pathType(0) ], Polygon.prototype, "curve", void 0);
 
-__decorate([ rewrite(line.__updateRenderPath) ], Polygon.prototype, "__updateRenderPath", null);
-
-__decorate([ rewrite(line.__updateBoxBounds) ], Polygon.prototype, "__updateBoxBounds", null);
-
 Polygon = __decorate([ rewriteAble(), registerUI() ], Polygon);
 
 const {sin: sin$1, cos: cos$1, PI: PI$1} = Math;
 
-const {moveTo: moveTo, lineTo: lineTo, closePath: closePath} = PathCommandDataHelper;
+const {moveTo: moveTo$1, lineTo: lineTo$1, closePath: closePath} = PathCommandDataHelper;
 
 let Star = class Star extends UI {
     get __tag() {
@@ -9330,9 +9313,9 @@ let Star = class Star extends UI {
         const {width: width, height: height, corners: corners, innerRadius: innerRadius} = this.__;
         const rx = width / 2, ry = height / 2;
         const path = this.__.path = [];
-        moveTo(path, rx, 0);
+        moveTo$1(path, rx, 0);
         for (let i = 1; i < corners * 2; i++) {
-            lineTo(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin$1(i * PI$1 / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos$1(i * PI$1 / corners));
+            lineTo$1(path, rx + (i % 2 === 0 ? rx : rx * innerRadius) * sin$1(i * PI$1 / corners), ry - (i % 2 === 0 ? ry : ry * innerRadius) * cos$1(i * PI$1 / corners));
         }
         closePath(path);
     }
@@ -9346,6 +9329,52 @@ __decorate([ pathType(.382) ], Star.prototype, "innerRadius", void 0);
 
 Star = __decorate([ registerUI() ], Star);
 
+const {moveTo: moveTo, lineTo: lineTo, drawPoints: drawPoints} = PathCommandDataHelper;
+
+const {rotate: rotate$3, getAngle: getAngle$2, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
+
+let Line = class Line extends UI {
+    get __tag() {
+        return "Line";
+    }
+    get toPoint() {
+        const {width: width, rotation: rotation} = this.__;
+        const to = getPointData();
+        if (width) to.x = width;
+        if (rotation) rotate$3(to, rotation);
+        return to;
+    }
+    set toPoint(value) {
+        this.width = getDistance$3(defaultPoint, value);
+        this.rotation = getAngle$2(defaultPoint, value);
+        if (this.height) this.height = 0;
+    }
+    __updatePath() {
+        const data = this.__;
+        const path = data.path = [];
+        if (data.points) {
+            drawPoints(path, data.points, data.curve, data.closed);
+        } else {
+            moveTo(path, 0, 0);
+            lineTo(path, this.width, 0);
+        }
+    }
+};
+
+__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);
+
+__decorate([ pathType(false) ], Line.prototype, "closed", void 0);
+
+Line = __decorate([ registerUI() ], Line);
+
 let Image = class Image extends Rect {
     get __tag() {
         return "Image";
@@ -9493,10 +9522,6 @@ let Text = class Text extends UI {
         DataHelper.stintSet(this, "isOverflow", !includes(b, contentBounds));
         if (this.isOverflow) setList(data.__textBoxBounds = {}, [ b, contentBounds ]), layout.renderChanged = true; else data.__textBoxBounds = b;
     }
-    __onUpdateSize() {
-        if (this.__box) this.__box.__onUpdateSize();
-        super.__onUpdateSize();
-    }
     __updateRenderSpread() {
         let width = super.__updateRenderSpread();
         if (!width) width = this.isOverflow ? 1 : 0;
@@ -9507,6 +9532,11 @@ let Text = class Text extends UI {
         copyAndSpread$1(renderBounds, this.__.__textBoxBounds, renderSpread);
         if (this.__box) this.__box.__layout.renderBounds = renderBounds;
     }
+    __updateChange() {
+        super.__updateChange();
+        const box = this.__box;
+        if (box) box.__onUpdateSize(), box.__updateChange();
+    }
     __drawRenderPath(canvas) {
         canvas.font = this.__.__font;
     }
@@ -12096,12 +12126,18 @@ function shadow$1(ui, current, shape) {
             }
             worldCanvas ? other.copyWorld(worldCanvas, nowWorld, nowWorld, "destination-out") : other.copyWorld(shape.canvas, shapeBounds, bounds, "destination-out");
         }
-        LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
+        if (Effect.isTransformShadow(item)) Effect.renderTransformShadow(ui, current, other, copyBounds, item); else LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end) other.clearWorld(copyBounds);
     });
     other.recycle(copyBounds);
 }
 
+function getShadowSpread(_ui, shadow) {
+    let width = 0;
+    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));
+    return width;
+}
+
 function drawWorldShadow(canvas, outBounds, spreadScale, shape) {
     const {bounds: bounds, shapeBounds: shapeBounds} = shape;
     if (Platform.fullImageShadow) {
@@ -12179,7 +12215,11 @@ const EffectModule = {
     shadow: shadow$1,
     innerShadow: innerShadow,
     blur: blur,
-    backgroundBlur: backgroundBlur
+    backgroundBlur: backgroundBlur,
+    getShadowSpread: getShadowSpread,
+    isTransformShadow(_shadow) {
+        return undefined;
+    }
 };
 
 const {excludeRenderBounds: excludeRenderBounds} = LeafBoundsHelper;
@@ -12687,16 +12727,17 @@ function toTextChar(row) {
 }
 
 function decorationText(drawData, style) {
-    let type;
+    let type, offset = 0;
     const {fontSize: fontSize, textDecoration: textDecoration} = style;
     drawData.decorationHeight = fontSize / 11;
     if (isObject(textDecoration)) {
         type = textDecoration.type;
         if (textDecoration.color) drawData.decorationColor = ColorConvert.string(textDecoration.color);
+        if (textDecoration.offset) offset = Math.min(fontSize * .3, Math.max(textDecoration.offset, -fontSize * .15));
     } else type = textDecoration;
     switch (type) {
       case "under":
-        drawData.decorationY = [ fontSize * .15 ];
+        drawData.decorationY = [ fontSize * .15 + offset ];
         break;
 
       case "delete":
@@ -12704,7 +12745,7 @@ function decorationText(drawData, style) {
         break;
 
       case "under-delete":
-        drawData.decorationY = [ fontSize * .15, -fontSize * .35 ];
+        drawData.decorationY = [ fontSize * .15 + offset, -fontSize * .35 ];
     }
 }
 
@@ -13049,7 +13090,7 @@ class EditSelect extends Group {
     }
     get running() {
         const {editor: editor} = this;
-        return this.hittable && editor.visible && editor.hittable && editor.mergeConfig.selector;
+        return this.hittable && editor.visible && editor.hittable && editor.mergeConfig.selector && this.app.mode === "normal";
     }
     get isMoveMode() {
         return this.app && this.app.interaction.moveMode;
@@ -13351,17 +13392,13 @@ const EditDataHelper = {
         }
         toPoint(around || align, boxBounds, origin, true);
         if (dragBounds) {
-            const allowBounds = dragBounds === "parent" ? target.parent.boxBounds : dragBounds;
-            const childBounds = new Bounds(target.__localBoxBounds);
-            if (BoundsHelper.includes(new Bounds(allowBounds).spread(.1), childBounds)) {
-                childBounds.scaleOf(target.getLocalPointByInner(origin), scaleX, scaleY);
-                if (!BoundsHelper.includes(allowBounds, childBounds)) {
-                    const realBounds = childBounds.getIntersect(allowBounds);
-                    const fitScaleX = realBounds.width / childBounds.width, fitScaleY = realBounds.height / childBounds.height;
-                    if (useScaleX) scaleX *= fitScaleX;
-                    if (useScaleY) scaleY *= fitScaleY;
-                }
-            }
+            const scaleData = {
+                x: scaleX,
+                y: scaleY
+            };
+            DragBoundsHelper.limitScaleOf(target, origin, scaleData);
+            scaleX = scaleData.x;
+            scaleY = scaleData.y;
         }
         if (useScaleX && widthRange) {
             const nowWidth = boxBounds.width * target.scaleX;
@@ -14922,7 +14959,9 @@ let Editor = class Editor extends Group {
     listenTargetEvents() {
         if (!this.targetEventIds.length) {
             const {app: app, leafer: leafer, targetLeafer: targetLeafer, editMask: editMask} = this;
-            this.targetEventIds = [ leafer.on_(RenderEvent.START, this.onRenderStart, this), targetLeafer && targetLeafer.on_(PropertyEvent.SCROLL, this.onChildScroll, this), app.on_(RenderEvent.CHILD_START, this.onAppRenderStart, this) ];
+            this.targetEventIds = [ leafer.on_(RenderEvent.START, this.onRenderStart, this), targetLeafer && targetLeafer.on_(PropertyEvent.SCROLL, this.onChildScroll, this), app.on_(RenderEvent.CHILD_START, this.onAppRenderStart, this), app.on_(LeaferEvent.UPDATE_MODE, data => {
+                if (data.mode && data.mode !== "normal") this.cancel();
+            }) ];
             if (editMask.visible) editMask.forceRender();
         }
     }
@@ -19202,6 +19241,8 @@ const ExportModule = {
                     renderBounds: renderBounds,
                     trimBounds: trimBounds
                 };
+                const app = leafer && leafer.app;
+                if (app && app.canvasManager) app.canvasManager.clearRecycled();
             }
         } catch (error) {
             result = {