@leafer-ui/miniapp 1.9.10 → 1.9.12

package/dist/miniapp.module.js

@@ -3840,7 +3840,12 @@ class TaskProcessor {
     runTask() {
         const task = this.list[this.index];
         if (!task) {
-            this.nextTask();
+            this.timer = setTimeout(() => this.nextTask());
+            return;
+        }
+        if (task.isCancel) {
+            this.index++;
+            this.runTask();
             return;
         }
         task.run().then(() => {
@@ -3871,16 +3876,15 @@ class TaskProcessor {
     }
     setParallelList() {
         let task;
+        const {config: config, list: list, index: index} = this;
         this.parallelList = [];
         this.parallelSuccessNumber = 0;
-        let end = this.index + this.config.parallel;
-        if (end > this.list.length) end = this.list.length;
-        for (let i = this.index; i < end; i++) {
-            task = this.list[i];
-            if (task.parallel) {
-                this.parallelList.push(task);
-            } else {
-                break;
+        let end = index + config.parallel;
+        if (end > list.length) end = list.length;
+        if (config.parallel > 1) {
+            for (let i = index; i < end; i++) {
+                task = list[i];
+                if (task.parallel) this.parallelList.push(task); else break;
             }
         }
     }
@@ -6815,7 +6819,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.10";
+const version = "1.9.12";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -9925,7 +9929,7 @@ class UIEvent extends Event {
     }
 }
 
-const {float: float, sign: sign} = MathHelper, {min: min, max: max$2, abs: abs$2} = Math;
+const {min: min, max: max$2, abs: abs$2} = Math, {float: float, sign: sign} = MathHelper, {minX: minX, maxX: maxX, minY: minY, maxY: maxY} = BoundsHelper;
 
 const tempContent = new Bounds, tempDragBounds = new Bounds;
 
@@ -9975,26 +9979,27 @@ const DragBoundsHelper = {
         tempContent.set(content).scaleOf(origin, scale.x, scale.y);
         const originLeftScale = (origin.x - content.x) / content.width, originRightScale = 1 - originLeftScale;
         const originTopScale = (origin.y - content.y) / content.height, originBottomScale = 1 - originTopScale;
-        let correctScaleX, correctScaleY, aScale, bScale, aSize, bSize;
+        let correctScaleX = 1, correctScaleY = 1, aScale, bScale, aSize, bSize;
         if (D.isInnerMode(content, dragBounds, dragBoundsType, "width")) {
-            correctScaleX = scale.x < 0 ? 1 / scale.x : 1;
-            if (scale.x < 0) tempContent.scaleOf(origin, correctScaleX, 1);
+            if (scale.x < 0) tempContent.scaleOf(origin, correctScaleX = 1 / scale.x, 1);
             aSize = float(tempContent.minX - tempDragBounds.minX);
             bSize = float(tempDragBounds.maxX - tempContent.maxX);
             aScale = originLeftScale && aSize > 0 ? 1 + aSize / (originLeftScale * tempContent.width) : 1;
             bScale = originRightScale && bSize > 0 ? 1 + bSize / (originRightScale * tempContent.width) : 1;
             correctScaleX *= max$2(aScale, bScale);
         } else {
-            if (scale.x < 0) tempContent.unsign();
+            if (scale.x < 0) {
+                if (float(minX(content) - minX(dragBounds)) <= 0 || float(maxX(dragBounds) - maxX(content)) <= 0) tempContent.scaleOf(origin, correctScaleX = 1 / scale.x, 1);
+                tempContent.unsign();
+            }
             aSize = float(tempDragBounds.minX - tempContent.minX);
             bSize = float(tempContent.maxX - tempDragBounds.maxX);
             aScale = originLeftScale && aSize > 0 ? 1 - aSize / (originLeftScale * tempContent.width) : 1;
             bScale = originRightScale && bSize > 0 ? 1 - bSize / (originRightScale * tempContent.width) : 1;
-            correctScaleX = min(aScale, bScale);
+            correctScaleX *= min(aScale, bScale);
         }
         if (D.isInnerMode(content, dragBounds, dragBoundsType, "height")) {
-            correctScaleY = scale.y < 0 ? 1 / scale.y : 1;
-            if (scale.y < 0) tempContent.scaleOf(origin, 1, correctScaleY);
+            if (scale.y < 0) tempContent.scaleOf(origin, 1, correctScaleY = 1 / scale.y);
             aSize = float(tempContent.minY - tempDragBounds.minY);
             bSize = float(tempDragBounds.maxY - tempContent.maxY);
             aScale = originTopScale && aSize > 0 ? 1 + aSize / (originTopScale * tempContent.height) : 1;
@@ -10006,12 +10011,15 @@ const DragBoundsHelper = {
                 correctScaleY = sign(correctScaleY) * aScale;
             }
         } else {
-            if (scale.y < 0) tempContent.unsign();
+            if (scale.y < 0) {
+                if (float(minY(content) - minY(dragBounds)) <= 0 || float(maxY(dragBounds) - maxY(content)) <= 0) tempContent.scaleOf(origin, 1, correctScaleY = 1 / scale.y);
+                tempContent.unsign();
+            }
             aSize = float(tempDragBounds.minY - tempContent.minY);
             bSize = float(tempContent.maxY - tempDragBounds.maxY);
             aScale = originTopScale && aSize > 0 ? 1 - aSize / (originTopScale * tempContent.height) : 1;
             bScale = originBottomScale && bSize > 0 ? 1 - bSize / (originBottomScale * tempContent.height) : 1;
-            correctScaleY = min(aScale, bScale);
+            correctScaleY *= min(aScale, bScale);
         }
         scale.x *= isFinite(correctScaleX) ? correctScaleX : 1;
         scale.y *= isFinite(correctScaleY) ? correctScaleY : 1;
@@ -11091,9 +11099,9 @@ const ui$1 = UI.prototype;
 
 ui$1.__updateHitCanvas = function() {
     if (this.__box) this.__box.__updateHitCanvas();
-    const leafer = this.leafer || this.parent && this.parent.leafer;
-    if (!leafer) return;
-    const data = this.__, {hitCanvasManager: hitCanvasManager} = leafer;
+    const {hitCanvasManager: hitCanvasManager} = this.leafer || this.parent && this.parent.leafer || {};
+    if (!hitCanvasManager) return;
+    const data = this.__;
     const isHitPixelFill = (data.__isAlphaPixelFill || data.__isCanvas) && data.hitFill === "pixel";
     const isHitPixelStroke = data.__isAlphaPixelStroke && data.hitStroke === "pixel";
     const isHitPixel = isHitPixelFill || isHitPixelStroke;
@@ -12289,11 +12297,11 @@ function getShadowRenderSpread(_ui, shadow) {
 
 function getShadowTransform(ui, canvas, _shape, shadow, outBounds, otherScale, isInnerShaodw) {
     if (shadow.spread) {
-        const spreadScale = 1 + shadow.spread * 2 / ui.__layout.strokeBounds.width * otherScale * (isInnerShaodw ? -1 : 1);
+        const spread = shadow.spread * 2 * otherScale * (isInnerShaodw ? -1 : 1), {width: width, height: height} = ui.__layout.strokeBounds;
         tempMatrix.set().scaleOfOuter({
             x: (outBounds.x + outBounds.width / 2) * canvas.pixelRatio,
             y: (outBounds.y + outBounds.height / 2) * canvas.pixelRatio
-        }, spreadScale);
+        }, 1 + spread / width, 1 + spread / height);
         return tempMatrix;
     }
     return undefined;