@leafer/miniapp 1.9.3 → 1.9.4

package/dist/miniapp.module.js

@@ -54,7 +54,7 @@ function isUndefined(value) {
 }
 
 function isNull(value) {
-    return value === undefined || value === null;
+    return value == null;
 }
 
 function isString(value) {
@@ -304,6 +304,9 @@ const MathHelper = {
         num = round$6(num * a) / a;
         return num === -0 ? 0 : num;
     },
+    sign(num) {
+        return num < 0 ? -1 : 1;
+    },
     getScaleData(scale, size, originSize, scaleData) {
         if (!scaleData) scaleData = {};
         if (size) {
@@ -659,7 +662,7 @@ const M$a = MatrixHelper;
 
 const {toInnerPoint: toInnerPoint$2, toOuterPoint: toOuterPoint$3} = MatrixHelper;
 
-const {sin: sin$5, cos: cos$5, abs: abs$6, sqrt: sqrt$4, atan2: atan2$2, min: min$1, round: round$5} = Math;
+const {sin: sin$5, cos: cos$5, abs: abs$7, sqrt: sqrt$4, atan2: atan2$2, min: min$1, round: round$5} = Math;
 
 const PointHelper = {
     defaultPoint: getPointData(),
@@ -752,8 +755,8 @@ const PointHelper = {
         return getDistanceFrom(t.x, t.y, point.x, point.y);
     },
     getDistanceFrom(x1, y1, x2, y2) {
-        const x = abs$6(x2 - x1);
-        const y = abs$6(y2 - y1);
+        const x = abs$7(x2 - x1);
+        const y = abs$7(y2 - y1);
         return sqrt$4(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
@@ -2540,7 +2543,7 @@ const RectHelper = {
     }
 };
 
-const {sin: sin$4, cos: cos$4, atan2: atan2$1, ceil: ceil$1, abs: abs$5, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
+const {sin: sin$4, cos: cos$4, atan2: atan2$1, ceil: ceil$1, abs: abs$6, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
 
 const {setPoint: setPoint$4, addPoint: addPoint$2} = TwoPointBoundsHelper;
 
@@ -2613,7 +2616,7 @@ const BezierHelper = {
         let endRadian = atan2$1(CBy, CBx);
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2;
-        if (totalRadian === PI$3 || abs$5(BAx + BAy) < 1e-12 || abs$5(CBx + CBy) < 1e-12) {
+        if (totalRadian === PI$3 || abs$6(BAx + BAy) < 1e-12 || abs$6(CBx + CBy) < 1e-12) {
             if (data) data.push(L$a, x1, y1);
             if (setPointBounds) {
                 setPoint$4(setPointBounds, fromX, fromY);
@@ -2646,7 +2649,7 @@ const BezierHelper = {
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2; else if (totalRadian > PI2) totalRadian -= PI2;
         if (anticlockwise) totalRadian -= PI2;
-        const parts = ceil$1(abs$5(totalRadian / PI_2));
+        const parts = ceil$1(abs$6(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$4(partRadian / 4);
         const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin$4(partRadian / 2);
@@ -3113,7 +3116,7 @@ const {M: M$7, L: L$8, C: C$6, Q: Q$5, Z: Z$6, N: N$4, D: D$5, X: X$4, G: G$4, F
 
 const {getMinDistanceFrom: getMinDistanceFrom, getRadianFrom: getRadianFrom} = PointHelper;
 
-const {tan: tan, min: min, abs: abs$4} = Math;
+const {tan: tan, min: min, abs: abs$5} = Math;
 
 const startPoint = {};
 
@@ -3171,7 +3174,7 @@ const PathCommandDataHelper = {
     arcTo(data, x1, y1, x2, y2, radius, lastX, lastY) {
         if (!isUndefined(lastX)) {
             const d = getMinDistanceFrom(lastX, lastY, x1, y1, x2, y2);
-            radius = min(radius, min(d / 2, d / 2 * abs$4(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
+            radius = min(radius, min(d / 2, d / 2 * abs$5(tan(getRadianFrom(lastX, lastY, x1, y1, x2, y2) / 2))));
         }
         data.push(U$4, x1, y1, x2, y2, radius);
     },
@@ -3969,7 +3972,7 @@ const I$1 = ImageManager;
 
 const {IMAGE: IMAGE, create: create$1} = IncrementId;
 
-const {floor: floor$2, max: max$1} = Math;
+const {floor: floor$2, max: max$2} = Math;
 
 class LeaferImage {
     get url() {
@@ -4058,7 +4061,7 @@ class LeaferImage {
             }
             if (data) return data;
         }
-        const canvas = Platform.origin.createCanvas(max$1(floor$2(width + (xGap || 0)), 1), max$1(floor$2(height + (yGap || 0)), 1));
+        const canvas = Platform.origin.createCanvas(max$2(floor$2(width + (xGap || 0)), 1), max$2(floor$2(height + (yGap || 0)), 1));
         const ctx = canvas.getContext("2d");
         if (opacity) ctx.globalAlpha = opacity;
         ctx.drawImage(this.view, 0, 0, width, height);
@@ -4102,7 +4105,7 @@ function createDescriptor(key, defaultValue) {
     return {
         get() {
             const v = this[privateKey];
-            return isUndefined(v) ? defaultValue : v;
+            return v == null ? defaultValue : v;
         },
         set(value) {
             this[privateKey] = value;
@@ -4388,21 +4391,21 @@ function defineDataProcessor(target, key, defaultValue) {
         };
     } else if (typeof defaultValue === "function") {
         property.get = function() {
-            let v = this[computedKey];
-            return v === undefined ? defaultValue(this.__leaf) : v;
+            const v = this[computedKey];
+            return v == null ? defaultValue(this.__leaf) : v;
         };
     } else if (isObject(defaultValue)) {
         const isEmpty = isEmptyData(defaultValue);
         property.get = function() {
-            let v = this[computedKey];
-            return v === undefined ? this[computedKey] = isEmpty ? {} : DataHelper.clone(defaultValue) : v;
+            const v = this[computedKey];
+            return v == null ? this[computedKey] = isEmpty ? {} : DataHelper.clone(defaultValue) : v;
         };
     }
     const isBox = target.isBranchLeaf;
     if (key === "width") {
         property.get = function() {
             const v = this[computedKey];
-            if (v === undefined) {
+            if (v == null) {
                 const t = this, naturalWidth = t.__naturalWidth, leaf = t.__leaf;
                 if (!defaultValue || leaf.pathInputed) return leaf.boxBounds.width;
                 if (naturalWidth) return t._height && t.__useNaturalRatio ? t._height * naturalWidth / t.__naturalHeight : naturalWidth;
@@ -4412,7 +4415,7 @@ function defineDataProcessor(target, key, defaultValue) {
     } else if (key === "height") {
         property.get = function() {
             const v = this[computedKey];
-            if (v === undefined) {
+            if (v == null) {
                 const t = this, naturalHeight = t.__naturalHeight, leaf = t.__leaf;
                 if (!defaultValue || leaf.pathInputed) return leaf.boxBounds.height;
                 if (naturalHeight) return t._width && t.__useNaturalRatio ? t._width * naturalHeight / t.__naturalWidth : naturalHeight;
@@ -5172,7 +5175,7 @@ class LeafLayout {
     }
     boxChange() {
         this.boxChanged = true;
-        this.localBoxChanged || this.localBoxChange();
+        this.localBoxChanged ? this.boundsChanged || (this.boundsChanged = true) : this.localBoxChange();
         this.hitCanvasChanged = true;
     }
     localBoxChange() {
@@ -5206,7 +5209,7 @@ class LeafLayout {
     }
     matrixChange() {
         this.matrixChanged = true;
-        this.localBoxChanged || this.localBoxChange();
+        this.localBoxChanged ? this.boundsChanged || (this.boundsChanged = true) : this.localBoxChange();
     }
     surfaceChange() {
         this.surfaceChanged = true;
@@ -6272,10 +6275,10 @@ let Leaf = class Leaf {
             relative.innerToWorld(world, to, distance);
             world = to ? to : world;
         }
-        toInnerPoint(this.worldTransform, world, to, distance);
+        toInnerPoint(this.scrollWorldTransform, world, to, distance);
     }
     innerToWorld(inner, to, distance, relative) {
-        toOuterPoint(this.worldTransform, inner, to, distance);
+        toOuterPoint(this.scrollWorldTransform, inner, to, distance);
         if (relative) relative.worldToInner(to ? to : inner, null, distance);
     }
     getBoxPoint(world, relative, distance, change) {
@@ -6739,7 +6742,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.9.3";
+const version = "1.9.4";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -9089,29 +9092,24 @@ let Box = class Box extends Group {
     }
     __updateStrokeBounds() {}
     __updateRenderBounds() {
-        let isOverflow;
+        let isOverflow, isScrollMode;
         if (this.children.length) {
-            const data = this.__, layout = this.__layout, {renderBounds: renderBounds, boxBounds: boxBounds} = layout;
+            const data = this.__, layout = this.__layout, {renderBounds: renderBounds, boxBounds: boxBounds} = layout, {overflow: overflow} = data;
             const childrenRenderBounds = layout.childrenRenderBounds || (layout.childrenRenderBounds = getBoundsData());
             super.__updateRenderBounds(childrenRenderBounds);
-            if (data.overflow.includes("scroll")) {
+            if (isScrollMode = overflow.includes("scroll")) {
                 add(childrenRenderBounds, boxBounds);
                 scroll(childrenRenderBounds, data);
             }
             this.__updateRectRenderBounds();
             isOverflow = !includes$1(boxBounds, childrenRenderBounds);
-            if (isOverflow && data.overflow === "show") add(renderBounds, childrenRenderBounds);
+            if (isOverflow && overflow === "show") add(renderBounds, childrenRenderBounds);
         } else this.__updateRectRenderBounds();
         DataHelper.stintSet(this, "isOverflow", isOverflow);
-        this.__checkScroll();
+        this.__checkScroll(isScrollMode);
     }
     __updateRectRenderBounds() {}
-    __updateWorldBounds() {
-        if (this.hasScroller) this.__updateScroll();
-        super.__updateWorldBounds();
-    }
-    __checkScroll() {}
-    __updateScroll() {}
+    __checkScroll(_isScrollMode) {}
     __updateRectChange() {}
     __updateChange() {
         super.__updateChange();
@@ -11835,7 +11833,7 @@ function ignoreRender(ui, value) {
 
 const {get: get$1, scale: scale$2, copy: copy$4} = MatrixHelper;
 
-const {floor: floor$1, max: max, abs: abs$3} = Math;
+const {floor: floor$1, max: max$1, abs: abs$4} = Math;
 
 function createPattern(ui, paint, pixelRatio) {
     let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true, paint.scaleFixed);
@@ -11848,8 +11846,8 @@ function createPattern(ui, paint, pixelRatio) {
         const xGap = gap && gap.x * scaleX;
         const yGap = gap && gap.y * scaleY;
         if (sx) {
-            sx = abs$3(sx);
-            sy = abs$3(sy);
+            sx = abs$4(sx);
+            sy = abs$4(sy);
             imageMatrix = get$1();
             copy$4(imageMatrix, transform);
             scale$2(imageMatrix, 1 / sx, 1 / sy);
@@ -11887,7 +11885,7 @@ function createPattern(ui, paint, pixelRatio) {
         }
         if (imageMatrix) {
             const canvasWidth = width + (xGap || 0), canvasHeight = height + (yGap || 0);
-            scale$2(imageMatrix, canvasWidth / max(floor$1(canvasWidth), 1), canvasHeight / max(floor$1(canvasHeight), 1));
+            scale$2(imageMatrix, canvasWidth / max$1(floor$1(canvasWidth), 1), canvasHeight / max$1(floor$1(canvasHeight), 1));
         }
         const canvas = image.getCanvas(width, height, data.opacity, data.filters, xGap, yGap);
         const pattern = image.getPattern(canvas, repeat || (Platform.origin.noRepeat || "no-repeat"), imageMatrix, paint);
@@ -12917,7 +12915,7 @@ function mergeConfigAttr() {
     return (target, key) => {
         defineKey(target, key, {
             get() {
-                const {config: config, element: element, dragPoint: dragPoint, editBox: editBox} = this, mergeConfig = Object.assign({}, config);
+                const {config: config, element: element, dragPoint: dragPoint, editBox: editBox, app: app} = this, mergeConfig = Object.assign({}, config);
                 if (element && element.editConfig) Object.assign(mergeConfig, element.editConfig);
                 if (editBox.config) Object.assign(mergeConfig, editBox.config);
                 if (dragPoint) {
@@ -12928,13 +12926,14 @@ function mergeConfigAttr() {
                         isNull(mergeConfig.lockRatio) && (mergeConfig.lockRatio = true);
                     }
                 }
+                if (isUndefined(mergeConfig.dragLimitAnimate)) mergeConfig.dragLimitAnimate = app && app.config.pointer.dragLimitAnimate;
                 return this.mergedConfig = mergeConfig;
             }
         });
     };
 }
 
-const {abs: abs$2} = Math;
+const {abs: abs$3} = Math;
 
 const {copy: copy$2, scale: scale$1} = MatrixHelper;
 
@@ -12977,7 +12976,7 @@ class Stroker extends UI {
                 leaf = list[i];
                 const {worldTransform: worldTransform, worldRenderBounds: worldRenderBounds} = leaf;
                 if (worldRenderBounds.width && worldRenderBounds.height && (!bounds || bounds.hit(worldRenderBounds, options.matrix))) {
-                    const aScaleX = abs$2(worldTransform.scaleX), aScaleY = abs$2(worldTransform.scaleY);
+                    const aScaleX = abs$3(worldTransform.scaleX), aScaleY = abs$3(worldTransform.scaleY);
                     copy$2(matrix$1, worldTransform);
                     matrix$1.half = strokeWidth % 2;
                     if (aScaleX !== aScaleY) {
@@ -12991,7 +12990,7 @@ class Stroker extends UI {
                         canvas.setWorld(matrix$1, options.matrix);
                         canvas.beginPath();
                         if (leaf.__.__useArrow) leaf.__drawPath(canvas); else leaf.__.__pathForRender ? leaf.__drawRenderPath(canvas) : leaf.__drawPathByBox(canvas);
-                        data.strokeWidth = strokeWidth / abs$2(worldTransform.scaleX);
+                        data.strokeWidth = strokeWidth / abs$3(worldTransform.scaleX);
                     }
                     if (stroke) isString(stroke) ? Paint.stroke(stroke, this, canvas) : Paint.strokes(stroke, this, canvas);
                     if (fill) isString(fill) ? Paint.fill(fill, this, canvas) : Paint.fills(fill, this, canvas);
@@ -13285,7 +13284,7 @@ const {topLeft: topLeft$1, top: top$1, topRight: topRight$1, right: right$2, bot
 
 const {toPoint: toPoint} = AroundHelper;
 
-const {within: within$2} = MathHelper;
+const {within: within$3, sign: sign$1} = MathHelper;
 
 const EditDataHelper = {
     getScaleData(target, startBounds, direction, totalMove, lockRatio, around, flipable, scaleMode) {
@@ -13298,8 +13297,8 @@ const EditDataHelper = {
         }
         const originChangedScaleX = target.scaleX / startBounds.scaleX;
         const originChangedScaleY = target.scaleY / startBounds.scaleY;
-        const signX = originChangedScaleX < 0 ? -1 : 1;
-        const signY = originChangedScaleY < 0 ? -1 : 1;
+        const signX = sign$1(originChangedScaleX);
+        const signY = sign$1(originChangedScaleY);
         const changedScaleX = scaleMode ? originChangedScaleX : signX * boxBounds.width / width;
         const changedScaleY = scaleMode ? originChangedScaleY : signY * boxBounds.height / height;
         totalMove.x *= scaleMode ? originChangedScaleX : signX;
@@ -13399,14 +13398,14 @@ const EditDataHelper = {
         }
         if (useScaleX && widthRange) {
             const nowWidth = boxBounds.width * target.scaleX;
-            scaleX = within$2(nowWidth * scaleX, widthRange) / nowWidth;
+            scaleX = within$3(nowWidth * scaleX, widthRange) / nowWidth;
         }
         if (useScaleY && heightRange) {
             const nowHeight = boxBounds.height * target.scaleY;
-            scaleY = within$2(nowHeight * scaleY, heightRange) / nowHeight;
+            scaleY = within$3(nowHeight * scaleY, heightRange) / nowHeight;
         }
-        if (useScaleX && Math.abs(scaleX * worldBoxBounds.width) < 1) scaleX = (scaleX < 0 ? -1 : 1) / worldBoxBounds.width;
-        if (useScaleY && Math.abs(scaleY * worldBoxBounds.height) < 1) scaleY = (scaleY < 0 ? -1 : 1) / worldBoxBounds.height;
+        if (useScaleX && Math.abs(scaleX * worldBoxBounds.width) < 1) scaleX = sign$1(scaleX) / worldBoxBounds.width;
+        if (useScaleY && Math.abs(scaleY * worldBoxBounds.height) < 1) scaleY = sign$1(scaleY) / worldBoxBounds.height;
         if (lockRatio && scaleX !== scaleY) scaleY = scaleX = Math.min(scaleX, scaleY);
         return {
             origin: origin,
@@ -13908,7 +13907,7 @@ class EditBox extends Group {
         if (pointType && pointType.includes("resize")) ResizeEvent.resizingKeys = editor.leafList.keys;
     }
     onDragEnd(e) {
-        if (this.moving) this.transformTool.onMove(e);
+        if (this.moving && this.mergeConfig.dragLimitAnimate && this.target.dragBounds) this.transformTool.onMove(e);
         this.dragPoint = null;
         this.resetDoing();
         const {name: name, pointType: pointType} = e.current;
@@ -14428,9 +14427,8 @@ EditorSkewEvent.SKEW = "editor.skew";
 
 class TransformTool {
     onMove(e) {
-        const {target: target, mergeConfig: mergeConfig, dragStartData: dragStartData, app: app} = this.editBox;
+        const {target: target, mergeConfig: mergeConfig, dragStartData: dragStartData} = this.editBox;
         let move, {dragLimitAnimate: dragLimitAnimate} = mergeConfig;
-        if (isUndefined(dragLimitAnimate)) dragLimitAnimate = app && app.config.pointer.dragLimitAnimate;
         const isMoveEnd = e.type === MoveEvent.END || e.type === DragEvent.END;
         const axisDrag = isString(target.draggable);
         const checkLimitMove = !dragLimitAnimate || isMoveEnd || axisDrag;
@@ -15584,6 +15582,8 @@ const MultiTouchHelper = {
     }
 };
 
+const {abs: abs$2, max: max} = Math, {sign: sign, within: within$2} = MathHelper;
+
 const WheelEventHelper = {
     getMove(event, config) {
         let {moveSpeed: moveSpeed} = config;
@@ -15592,8 +15592,9 @@ const WheelEventHelper = {
             deltaX = deltaY;
             deltaY = 0;
         }
-        if (deltaX > 50) deltaX = Math.max(50, deltaX / 3);
-        if (deltaY > 50) deltaY = Math.max(50, deltaY / 3);
+        const absX = abs$2(deltaX), absY = abs$2(deltaY);
+        if (absX > 50) deltaX = max(50, absX / 3) * sign(deltaX);
+        if (absY > 50) deltaY = max(50, absY / 3) * sign(deltaY);
         return {
             x: -deltaX * moveSpeed * 2,
             y: -deltaY * moveSpeed * 2
@@ -15611,11 +15612,9 @@ const WheelEventHelper = {
             zoom = !event.shiftKey && (event.metaKey || event.ctrlKey);
         }
         if (zoom) {
-            zoomSpeed = MathHelper.within(zoomSpeed, 0, 1);
+            zoomSpeed = within$2(zoomSpeed, 0, 1);
             const min = event.deltaY ? config.delta.y : config.delta.x;
-            scale = 1 - delta / (min * 4) * zoomSpeed;
-            if (scale < .5) scale = .5;
-            if (scale >= 1.5) scale = 1.5;
+            scale = within$2(1 - delta / (min * 4) * zoomSpeed, .5, 1.5);
         }
         return scale;
     }