@leafer-ui/miniapp 1.11.2 → 1.12.1

package/dist/miniapp.module.js

@@ -4056,16 +4056,27 @@ const ImageManager = {
     recycle(image) {
         image.use--;
         setTimeout(() => {
-            if (!image.use) I$1.recycledList.push(image);
+            if (!image.use) {
+                if (Platform.image.isLarge(image)) {
+                    if (image.url) Resource.remove(image.url);
+                } else {
+                    image.clearLevels();
+                    I$1.recycledList.push(image);
+                }
+            }
         });
     },
-    clearRecycled() {
+    recyclePaint(paint) {
+        I$1.recycle(paint.image);
+    },
+    clearRecycled(force) {
         const list = I$1.recycledList;
-        if (list.length > I$1.maxRecycled) {
-            list.forEach(image => !image.use && image.url && Resource.remove(image.url));
+        if (list.length > I$1.maxRecycled || force) {
+            list.forEach(image => (!image.use || force) && image.url && Resource.remove(image.url));
             list.length = 0;
         }
     },
+    clearLevels() {},
     hasAlphaPixel(config) {
         return FileHelper.alphaPixelTypes.some(item => I$1.isFormat(item, config));
     },
@@ -4080,7 +4091,7 @@ const ImageManager = {
         return false;
     },
     destroy() {
-        I$1.recycledList = [];
+        this.clearRecycled(true);
     }
 };
 
@@ -4183,11 +4194,15 @@ class LeaferImage {
         Platform.image.setPatternTransform(pattern, transform, paint);
         return pattern;
     }
+    clearLevels(_checkUse) {}
     destroy() {
+        this.clearLevels();
+        const {view: view} = this;
+        if (view && view.close) view.close();
         this.config = {
             url: ""
         };
-        this.cache = null;
+        this.cache = this.view = null;
         this.waitComplete.length = 0;
     }
 }
@@ -4936,10 +4951,53 @@ const BranchHelper = {
             if (exclude && exclude === branch) continue;
             updateBounds$3(branch);
         }
+    },
+    move(branch, x, y) {
+        let w;
+        const {children: children} = branch;
+        for (let i = 0, len = children.length; i < len; i++) {
+            branch = children[i];
+            w = branch.__world;
+            w.e += x;
+            w.f += y;
+            w.x += x;
+            w.y += y;
+            if (branch.isBranch) move$3(branch, x, y);
+        }
+    },
+    scale(branch, x, y, scaleX, scaleY, a, b) {
+        let w;
+        const {children: children} = branch;
+        const changeScaleX = scaleX - 1;
+        const changeScaleY = scaleY - 1;
+        for (let i = 0, len = children.length; i < len; i++) {
+            branch = children[i];
+            w = branch.__world;
+            w.a *= scaleX;
+            w.d *= scaleY;
+            if (w.b || w.c) {
+                w.b *= scaleX;
+                w.c *= scaleY;
+            }
+            if (w.e === w.x && w.f === w.y) {
+                w.x = w.e += (w.e - a) * changeScaleX + x;
+                w.y = w.f += (w.f - b) * changeScaleY + y;
+            } else {
+                w.e += (w.e - a) * changeScaleX + x;
+                w.f += (w.f - b) * changeScaleY + y;
+                w.x += (w.x - a) * changeScaleX + x;
+                w.y += (w.y - b) * changeScaleY + y;
+            }
+            w.width *= scaleX;
+            w.height *= scaleY;
+            w.scaleX *= scaleX;
+            w.scaleY *= scaleY;
+            if (branch.isBranch) scale$1(branch, x, y, scaleX, scaleY, a, b);
+        }
     }
 };
 
-const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack} = BranchHelper;
+const {pushAllChildBranch: pushAllChildBranch$1, pushAllBranchStack: pushAllBranchStack, updateBoundsByBranchStack: updateBoundsByBranchStack, move: move$3, scale: scale$1} = BranchHelper;
 
 const WaitHelper = {
     run(wait) {
@@ -5966,6 +6024,7 @@ const LeafBounds = {
 const LeafRender = {
     __render(canvas, options) {
         if (options.shape) return this.__renderShape(canvas, options);
+        if (options.cellList && !options.cellList.has(this)) return;
         if (this.__worldOpacity) {
             const data = this.__;
             if (data.bright && !options.topRendering) return options.topList.add(this);
@@ -6502,10 +6561,10 @@ let Leaf = class Leaf {
     hit(_world, _hitRadius) {
         return true;
     }
-    __hitWorld(_point) {
+    __hitWorld(_point, _forceHitFill) {
         return true;
     }
-    __hit(_local) {
+    __hit(_local, _forceHitFill) {
         return true;
     }
     __hitFill(_inner) {
@@ -6864,7 +6923,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.11.2";
+const version = "1.12.1";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7134,7 +7193,7 @@ class Watcher {
         return this.hasAdd || this.hasRemove || this.hasVisible;
     }
     get updatedList() {
-        if (this.hasRemove) {
+        if (this.hasRemove && this.config.usePartLayout) {
             const updatedList = new LeafList;
             this.__updatedList.list.forEach(item => {
                 if (item.leafer) updatedList.add(item);
@@ -7169,16 +7228,18 @@ class Watcher {
         if (this.running) this.target.emit(RenderEvent.REQUEST);
     }
     __onAttrChange(event) {
-        this.__updatedList.add(event.target);
+        if (this.config.usePartLayout) this.__updatedList.add(event.target);
         this.update();
     }
     __onChildEvent(event) {
-        if (event.type === ChildEvent.ADD) {
-            this.hasAdd = true;
-            this.__pushChild(event.child);
-        } else {
-            this.hasRemove = true;
-            this.__updatedList.add(event.parent);
+        if (this.config.usePartLayout) {
+            if (event.type === ChildEvent.ADD) {
+                this.hasAdd = true;
+                this.__pushChild(event.child);
+            } else {
+                this.hasRemove = true;
+                this.__updatedList.add(event.parent);
+            }
         }
         this.update();
     }
@@ -7295,7 +7356,9 @@ const debug$4 = Debug.get("Layouter");
 class Layouter {
     constructor(target, userConfig) {
         this.totalTimes = 0;
-        this.config = {};
+        this.config = {
+            usePartLayout: true
+        };
         this.__levelList = new LeafLevelList;
         this.target = target;
         if (userConfig) this.config = DataHelper.default(userConfig, this.config);
@@ -7340,7 +7403,7 @@ class Layouter {
         this.totalTimes++;
         this.layouting = true;
         this.target.emit(WatchEvent.REQUEST);
-        if (this.totalTimes > 1) {
+        if (this.totalTimes > 1 && this.config.usePartLayout) {
             this.partLayout();
         } else {
             this.fullLayout();
@@ -7457,7 +7520,7 @@ class Renderer {
     }
     update(change = true) {
         if (!this.changed) this.changed = change;
-        this.__requestRender();
+        if (!this.requestTime) this.__requestRender();
     }
     requestLayout() {
         this.target.emit(LayoutEvent.REQUEST);
@@ -7564,7 +7627,7 @@ class Renderer {
         Run.end(t);
     }
     __render(bounds, realBounds) {
-        const {canvas: canvas} = this, includes = bounds.includes(this.target.__world), options = includes ? {
+        const {canvas: canvas, target: target} = this, includes = bounds.includes(target.__world), options = includes ? {
             includes: includes
         } : {
             bounds: bounds,
@@ -7572,12 +7635,16 @@ class Renderer {
         };
         if (this.needFill) canvas.fillWorld(bounds, this.config.fill);
         if (Debug.showRepaint) Debug.drawRepaint(canvas, bounds);
-        Platform.render(this.target, canvas, options);
+        if (this.config.useCellRender) options.cellList = this.getCellList();
+        Platform.render(target, canvas, options);
         this.renderBounds = realBounds = realBounds || bounds;
         this.renderOptions = options;
         this.totalBounds.isEmpty() ? this.totalBounds = realBounds : this.totalBounds.add(realBounds);
         canvas.updateRender(realBounds);
     }
+    getCellList() {
+        return undefined;
+    }
     addBlock(block) {
         if (!this.updateBlocks) this.updateBlocks = [];
         this.updateBlocks.push(block);
@@ -7792,7 +7859,7 @@ class Picker {
             hit = child.__.hitRadius ? true : hitRadiusPoint$1(child.__world, point);
             if (child.isBranch) {
                 if (hit || child.__ignoreHitWorld) {
-                    if (child.isBranchLeaf && child.__.__clipAfterFill && !child.__hitWorld(point)) continue;
+                    if (child.isBranchLeaf && child.__.__clipAfterFill && !child.__hitWorld(point, true)) continue;
                     if (child.topChildren) this.eachFind(child.topChildren, false);
                     this.eachFind(child.children, child.__onlyHitMask);
                     if (child.isBranchLeaf) this.hitChild(child, point);
@@ -8234,6 +8301,11 @@ class TextData extends UIData {
         }
         this._boxStyle = value;
     }
+    __getInputData(names, options) {
+        const data = super.__getInputData(names, options);
+        if (data.textEditing) delete data.textEditing;
+        return data;
+    }
 }
 
 class ImageData extends RectData {
@@ -11106,7 +11178,7 @@ leaf.hit = function(worldPoint, hitRadius = 0) {
     }) : this.__hitWorld(worldRadiusPoint);
 };
 
-leaf.__hitWorld = function(point) {
+leaf.__hitWorld = function(point, forceHitFill) {
     const data = this.__;
     if (!data.hitSelf) return false;
     const world = this.__world, layout = this.__layout;
@@ -11124,7 +11196,7 @@ leaf.__hitWorld = function(point) {
         this.__updateHitCanvas();
         if (!layout.boundsChanged) layout.hitCanvasChanged = false;
     }
-    return this.__hit(inner);
+    return this.__hit(inner, forceHitFill);
 };
 
 leaf.__hitFill = function(inner) {
@@ -11191,12 +11263,12 @@ ui$1.__updateHitCanvas = function() {
     h.setStrokeOptions(data);
 };
 
-ui$1.__hit = function(inner) {
+ui$1.__hit = function(inner, forceHitFill) {
     if (this.__box && this.__box.__hit(inner)) return true;
     const data = this.__;
     if (data.__isHitPixel && this.__hitPixel(inner)) return true;
     const {hitFill: hitFill} = data;
-    const needHitFillPath = (data.fill || data.__isCanvas) && (hitFill === "path" || hitFill === "pixel" && !(data.__isAlphaPixelFill || data.__isCanvas)) || hitFill === "all";
+    const needHitFillPath = (data.fill || data.__isCanvas) && (hitFill === "path" || hitFill === "pixel" && !(data.__isAlphaPixelFill || data.__isCanvas)) || hitFill === "all" || forceHitFill;
     if (needHitFillPath && this.__hitFill(inner)) return true;
     const {hitStroke: hitStroke, __maxStrokeWidth: strokeWidth} = data;
     const needHitStrokePath = data.stroke && (hitStroke === "path" || hitStroke === "pixel" && !data.__isAlphaPixelStroke) || hitStroke === "all";
@@ -11685,6 +11757,7 @@ function getLeafPaint(attrName, paint, ui) {
     const {boxBounds: boxBounds} = ui.__layout;
     switch (paint.type) {
       case "image":
+        if (!paint.url) return undefined;
         leafPaint = PaintImage.image(ui, attrName, paint, boxBounds, !recycleMap || !recycleMap[paint.url]);
         break;
 
@@ -12089,7 +12162,7 @@ function checkImage(paint, drawImage, ui, canvas, renderOptions) {
             if (data.repeat) {
                 drawImage = false;
             } else if (!(originPaint.changeful || Platform.name === "miniapp" && ResizeEvent.isResizing(ui) || exporting)) {
-                drawImage = Platform.image.isLarge(image, scaleX, scaleY);
+                drawImage = Platform.image.isLarge(image, scaleX, scaleY) || image.width * scaleX > 8096 || image.height * scaleY > 8096;
             }
         }
         if (drawImage) {
@@ -12148,7 +12221,7 @@ function recycleImage(attrName, data) {
             if (url) {
                 if (!recycleMap) recycleMap = {};
                 recycleMap[url] = true;
-                ImageManager.recycle(image);
+                ImageManager.recyclePaint(paint);
                 if (image.loading) {
                     if (!input) {
                         input = data.__input && data.__input[attrName] || [];