@leafer-game/miniapp 2.2.2 → 2.2.4

package/dist/miniapp.module.js

@@ -253,7 +253,7 @@ const FourNumberHelper = {
         return to;
     },
     setTemp(top, right, bottom, left) {
-        return set$3(tempFour, top, right, bottom, left);
+        return set$4(tempFour, top, right, bottom, left);
     },
     toTempAB(a, b, change) {
         tempTo = change ? isNumber(a) ? b : a : [];
@@ -293,22 +293,22 @@ const FourNumberHelper = {
     max(t, other, change) {
         if (isNumber(t) && isNumber(other)) return max$5(t, other);
         toTempAB(t, other, change);
-        return set$3(tempTo, max$5(tempA[0], tempB[0]), max$5(tempA[1], tempB[1]), max$5(tempA[2], tempB[2]), max$5(tempA[3], tempB[3]));
+        return set$4(tempTo, max$5(tempA[0], tempB[0]), max$5(tempA[1], tempB[1]), max$5(tempA[2], tempB[2]), max$5(tempA[3], tempB[3]));
     },
     add(t, other, change) {
         if (isNumber(t) && isNumber(other)) return t + other;
         toTempAB(t, other, change);
-        return set$3(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
+        return set$4(tempTo, tempA[0] + tempB[0], tempA[1] + tempB[1], tempA[2] + tempB[2], tempA[3] + tempB[3]);
     },
     swapAndScale(t, scaleX, scaleY, change) {
         if (isNumber(t)) return scaleX === scaleY ? t * scaleX : [ t * scaleY, t * scaleX ];
         const to = change ? t : [];
         const [top, right, bottom, left] = t.length === 4 ? t : get$5(t);
-        return set$3(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
+        return set$4(to, bottom * scaleY, left * scaleX, top * scaleY, right * scaleX);
     }
 };
 
-const {set: set$3, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
+const {set: set$4, get: get$5, setTemp: setTemp, toTempAB: toTempAB} = FourNumberHelper;
 
 const {round: round$6, pow: pow$2, max: max$4, floor: floor$3, PI: PI$4} = Math;
 
@@ -835,7 +835,7 @@ const PointHelper = {
         return y1 + (y2 - y1) / 2;
     },
     getDistance(t, point) {
-        return getDistanceFrom(t.x, t.y, point.x, point.y);
+        return getDistanceFrom$1(t.x, t.y, point.x, point.y);
     },
     getDistanceFrom(x1, y1, x2, y2) {
         const x = abs$7(x2 - x1);
@@ -843,7 +843,7 @@ const PointHelper = {
         return sqrt$4(x * x + y * y);
     },
     getMinDistanceFrom(x1, y1, x2, y2, x3, y3) {
-        return min$2(getDistanceFrom(x1, y1, x2, y2), getDistanceFrom(x2, y2, x3, y3));
+        return min$2(getDistanceFrom$1(x1, y1, x2, y2), getDistanceFrom$1(x2, y2, x3, y3));
     },
     getAngle(t, to, radiusX, radiusY) {
         return getAtan2(t, to, radiusX, radiusY) / OneRadian;
@@ -886,7 +886,7 @@ const PointHelper = {
 
 const P$5 = PointHelper;
 
-const {getDistanceFrom: getDistanceFrom, copy: copy$9, setRadius: setRadius, getAtan2: getAtan2} = P$5;
+const {getDistanceFrom: getDistanceFrom$1, copy: copy$9, setRadius: setRadius, getAtan2: getAtan2} = P$5;
 
 class Point {
     constructor(x, y) {
@@ -2711,7 +2711,7 @@ const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$1, abs:
 
 const {setPoint: setPoint$1, addPoint: addPoint$1} = TwoPointBoundsHelper;
 
-const {set: set$2, toNumberPoints: toNumberPoints} = PointHelper;
+const {set: set$3, toNumberPoints: toNumberPoints} = PointHelper;
 
 const {M: M$6, L: L$7, C: C$5, Q: Q$4, Z: Z$6} = PathCommandMap;
 
@@ -2790,8 +2790,8 @@ const BezierHelper = {
                 setPoint$1(setPointBounds, fromX, fromY);
                 addPoint$1(setPointBounds, x1, y1);
             }
-            if (setStartPoint) set$2(setStartPoint, fromX, fromY);
-            if (setEndPoint) set$2(setEndPoint, x1, y1);
+            if (setStartPoint) set$3(setStartPoint, fromX, fromY);
+            if (setEndPoint) set$3(setEndPoint, x1, y1);
             return;
         }
         const anticlockwise = BAx * CBy - CBx * BAy < 0;
@@ -2816,7 +2816,10 @@ const BezierHelper = {
         if (endRadian < 0) endRadian += PI2;
         let totalRadian = endRadian - startRadian;
         if (totalRadian < 0) totalRadian += PI2; else if (totalRadian > PI2) totalRadian -= PI2;
-        if (anticlockwise) totalRadian -= PI2;
+        if (anticlockwise) {
+            const closedAngle = abs$6(endAngle - startAngle) === 360;
+            if (closedAngle) totalRadian = -PI2; else totalRadian -= PI2;
+        }
         const parts = ceil$1(abs$6(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$4(partRadian / 4);
@@ -2831,7 +2834,7 @@ const BezierHelper = {
         let fromX = cx + x, fromY = cy + y;
         if (data) data.push(data.length ? L$7 : M$6, fromX, fromY);
         if (setPointBounds) setPoint$1(setPointBounds, fromX, fromY);
-        if (setStartPoint) set$2(setStartPoint, fromX, fromY);
+        if (setStartPoint) set$3(setStartPoint, fromX, fromY);
         for (let i = 0; i < parts; i++) {
             endCos = cos$4(endRadian);
             endSin = sin$4(endRadian);
@@ -2850,7 +2853,7 @@ const BezierHelper = {
             startRadian = endRadian;
             endRadian += partRadian;
         }
-        if (setEndPoint) set$2(setEndPoint, cx + x, cy + y);
+        if (setEndPoint) set$3(setEndPoint, cx + x, cy + y);
     },
     quadraticCurveTo(data, fromX, fromY, x1, y1, toX, toY) {
         data.push(C$5, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY);
@@ -4168,7 +4171,7 @@ const ImageManager = {
     patternTasker: Resource.queue,
     get(config, type) {
         let image = Resource.get(config.url);
-        if (!image) Resource.set(config.url, image = type === "film" ? Creator.film(config) : Creator.image(config));
+        if (!image) Resource.set(config.url, image = Creator[type || "image"](config));
         image.use++;
         return image;
     },
@@ -6340,6 +6343,9 @@ let Leaf = class Leaf {
     get isLeafer() {
         return false;
     }
+    get isFrame() {
+        return false;
+    }
     get isBranch() {
         return false;
     }
@@ -6481,6 +6487,16 @@ let Leaf = class Leaf {
             }
         }
     }
+    __bindFrame(frame) {
+        if (this.isFrame && frame !== null) frame = this;
+        this.frame = frame;
+        if (this.isBranch) {
+            const {children: children} = this;
+            for (let i = 0, len = children.length; i < len; i++) {
+                children[i].__bindFrame(frame);
+            }
+        }
+    }
     setAttr(name, value) {
         this[name] = value;
     }
@@ -6789,6 +6805,7 @@ let Branch = class Branch extends Leaf {
         childLayout.boxChanged || childLayout.boxChange();
         childLayout.matrixChanged || childLayout.matrixChange();
         if (child.__bubbleMap) child.__emitLifeEvent(ChildEvent.ADD);
+        if (this.isFrame) child.__bindFrame(this);
         if (this.leafer) {
             child.__bindLeafer(this.leafer);
             if (this.leafer.created) this.__emitChildEvent(ChildEvent.ADD, child);
@@ -6848,6 +6865,7 @@ let Branch = class Branch extends Leaf {
                 if (this.leafer.hitCanvasManager) this.leafer.hitCanvasManager.clear();
             }
         }
+        if (this.isFrame) child.__bindFrame(null);
     }
     __emitChildEvent(type, child) {
         const event = new ChildEvent(type, child, this);
@@ -7005,7 +7023,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.2.1";
+const version = "2.2.4";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -8617,9 +8635,6 @@ let UI = UI_1 = class UI extends Leaf {
     get app() {
         return this.leafer && this.leafer.app;
     }
-    get isFrame() {
-        return false;
-    }
     set strokeWidthFixed(value) {
         this.strokeScaleFixed = value;
     }
@@ -9488,7 +9503,7 @@ __decorate([ affectRenderBoundsType("hide") ], Frame.prototype, "overflow", void
 
 Frame = __decorate([ registerUI() ], Frame);
 
-const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse} = PathCommandDataHelper, {tempPoint: tempPoint$1, set: set$1, rotate: rotate$2} = PointHelper, {abs: abs$4} = Math, tempCenter = {};
+const {moveTo: moveTo$3, closePath: closePath$2, ellipse: ellipse} = PathCommandDataHelper, {tempPoint: tempPoint$1, set: set$2, rotate: rotate$2} = PointHelper, {abs: abs$4} = Math, tempCenter = {};
 
 let Ellipse = class Ellipse extends UI {
     get __tag() {
@@ -9503,34 +9518,28 @@ let Ellipse = class Ellipse extends UI {
         if (hasAngle) closedAngle = abs$4(endAngle - startAngle) === 360;
         if (innerRadius) {
             const drawInnerEllipse = innerRadius < 1 || closed;
-            let outerStartAngle = startAngle, outerEndAngle = endAngle, outerAnticlockwise;
+            const innerRx = rx * innerRadius, innerRy = ry * innerRadius;
             if (hasAngle) {
+                ellipse(path, rx, ry, rx, ry, 0, startAngle, endAngle);
                 if (drawInnerEllipse) {
-                    ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius, 0, startAngle, endAngle);
                     if (closedAngle) {
-                        set$1(tempPoint$1, width, ry);
-                        set$1(tempCenter, rx, ry);
+                        closePath$2(path);
+                        set$2(tempPoint$1, rx + innerRx, ry), set$2(tempCenter, rx, ry);
                         rotate$2(tempPoint$1, endAngle, tempCenter, rx, ry);
                         moveTo$3(path, tempPoint$1.x, tempPoint$1.y);
                     }
-                    outerStartAngle = endAngle;
-                    outerEndAngle = startAngle;
-                    outerAnticlockwise = true;
+                    ellipse(path, rx, ry, innerRx, innerRy, 0, endAngle, startAngle, true);
                 } else {
                     if (!closedAngle) open = true;
                 }
             } else {
+                ellipse(path, rx, ry, rx, ry);
                 if (drawInnerEllipse) {
-                    ellipse(path, rx, ry, rx * innerRadius, ry * innerRadius);
                     closePath$2(path);
-                    moveTo$3(path, width, ry);
-                    outerStartAngle = 360;
-                    outerAnticlockwise = true;
-                } else {
-                    outerEndAngle = 360;
+                    moveTo$3(path, rx + innerRx, ry);
+                    ellipse(path, rx, ry, innerRx, innerRy, 0, 360, 0, true);
                 }
             }
-            ellipse(path, rx, ry, rx, ry, 0, outerStartAngle, outerEndAngle, outerAnticlockwise);
         } else {
             if (hasAngle) {
                 if (!closedAngle) {
@@ -9639,7 +9648,7 @@ Star = __decorate([ registerUI() ], Star);
 
 const {moveTo: moveTo, lineTo: lineTo, drawPoints: drawPoints} = PathCommandDataHelper;
 
-const {rotate: rotate$1, getAngle: getAngle$1, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
+const {rotate: rotate$1, getAngle: getAngle$2, getDistance: getDistance$3, defaultPoint: defaultPoint} = PointHelper;
 
 let Line = class Line extends UI {
     get __tag() {
@@ -9657,7 +9666,7 @@ let Line = class Line extends UI {
     }
     set toPoint(value) {
         this.width = getDistance$3(defaultPoint, value);
-        this.rotation = getAngle$1(defaultPoint, value);
+        this.rotation = getAngle$2(defaultPoint, value);
         if (this.height) this.height = 0;
     }
     __updatePath() {
@@ -11430,7 +11439,8 @@ ui$5.__hit = function(inner, forceHitFill) {
     const {hitFill: hitFill} = data;
     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 {hitStroke: hitStroke, strokeScaleFixed: strokeScaleFixed} = data;
+    const strokeWidth = data.__maxStrokeWidth * (strokeScaleFixed ? this.getRenderScaleData(true, strokeScaleFixed, false).scaleX : 1);
     const needHitStrokePath = data.stroke && (hitStroke === "path" || hitStroke === "pixel" && !data.__isAlphaPixelStroke) || hitStroke === "all";
     if (!needHitFillPath && !needHitStrokePath) return false;
     const radiusWidth = inner.radiusX * 2;
@@ -12205,7 +12215,7 @@ function getGapValue(gap, size, totalSize, rows) {
 
 let origin = {}, tempMatrix$1 = getMatrixData();
 
-const {get: get$2, set: set, rotateOfOuter: rotateOfOuter$1, translate: translate, scaleOfOuter: scaleOfOuter$1, multiplyParent: multiplyParent, scale: scaleHelper, rotate: rotate, skew: skewHelper} = MatrixHelper;
+const {get: get$2, set: set$1, rotateOfOuter: rotateOfOuter$1, translate: translate, scaleOfOuter: scaleOfOuter$1, multiplyParent: multiplyParent, scale: scaleHelper, rotate: rotate, skew: skewHelper} = MatrixHelper;
 
 function stretchMode(data, box, scaleX, scaleY) {
     const transform = get$2(), {x: x, y: y} = box;
@@ -12230,7 +12240,7 @@ function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew, clipScaleX, c
     layout(transform, box, x, y, scaleX, scaleY, rotation, skew);
     if (clipScaleX) {
         if (rotation || skew) {
-            set(tempMatrix$1);
+            set$1(tempMatrix$1);
             scaleOfOuter$1(tempMatrix$1, box, clipScaleX, clipScaleY);
             multiplyParent(transform, tempMatrix$1);
         } else scaleOfOuter$1(transform, box, clipScaleX, clipScaleY);
@@ -12481,7 +12491,7 @@ function applyStops(data, gradient, stops, opacity) {
     }
 }
 
-const {getAngle: getAngle, getDistance: getDistance$2} = PointHelper;
+const {getAngle: getAngle$1, getDistance: getDistance$2} = PointHelper;
 
 const {get: get, rotateOfOuter: rotateOfOuter, scaleOfOuter: scaleOfOuter} = MatrixHelper;
 
@@ -12510,7 +12520,7 @@ function getTransform(box, from, to, stretch, rotate90) {
     let transform;
     const {width: width, height: height} = box;
     if (width !== height || stretch) {
-        const angle = getAngle(from, to);
+        const angle = getAngle$1(from, to);
         transform = get();
         if (rotate90) {
             scaleOfOuter(transform, from, width / height * (stretch || 1), 1);
@@ -15003,7 +15013,7 @@ const HighBezierHelper = {
 
 const {getDistance: getDistance} = HighBezierHelper;
 
-const {M: M, L: L, C: C, Z: Z} = PathCommandMap, {float: float} = MathHelper;
+const {M: M, L: L, C: C, Z: Z} = PathCommandMap, {float: float} = MathHelper, {set: set, getAngle: getAngle, getDistanceFrom: getDistanceFrom, getDistancePoint: getDistancePoint} = PointHelper;
 
 const tempPoint = {}, tempFrom = {};
 
@@ -15041,16 +15051,19 @@ const HighCurveHelper = {
     },
     getMotionPathData(data) {
         let total = 0, distance, segments = [];
-        let i = 0, x = 0, y = 0, toX, toY, command, closed;
+        let i = 0, x = 0, y = 0, startX = 0, startY = 0, toX, toY, command, closed;
         const len = data.length;
         while (i < len) {
             command = data[i];
             switch (command) {
               case M:
+                startX = data[i + 1];
+                startY = data[i + 2];
+
               case L:
                 toX = data[i + 1];
                 toY = data[i + 2];
-                distance = command === L && i > 0 ? PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                distance = command === L && i > 0 ? getDistanceFrom(x, y, toX, toY) : 0;
                 x = toX;
                 y = toY;
                 i += 3;
@@ -15067,7 +15080,9 @@ const HighCurveHelper = {
 
               case Z:
                 closed = true;
+                distance = getDistanceFrom(x, y, startX, startY);
                 i += 1;
+                break;
 
               default:
                 distance = 0;
@@ -15088,25 +15103,26 @@ const HighCurveHelper = {
         if (offsetX) motionDistance += offsetX;
         if (motionDistance > total) motionDistance = motionDistance % total;
         let nowDistance = 0, distance, to = {};
-        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        let i = 0, index = 0, x = 0, y = 0, startX = 0, startY = 0, toX, toY, command;
         let x1, y1, x2, y2, t;
         const len = data.length;
         while (i < len) {
             command = data[i];
             switch (command) {
               case M:
+                startX = data[i + 1];
+                startY = data[i + 2];
+
               case L:
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
                 if (nowDistance + distance >= motionDistance || !distanceData.total) {
-                    to.x = toX;
-                    to.y = toY;
+                    set(to, toX, toY);
                     if (i) {
-                        tempFrom.x = x;
-                        tempFrom.y = y;
-                        PointHelper.getDistancePoint(tempFrom, to, motionDistance - nowDistance, true);
-                        to.rotation = PointHelper.getAngle(tempFrom, to);
+                        set(tempFrom, x, y);
+                        getDistancePoint(tempFrom, to, motionDistance - nowDistance, true);
+                        to.rotation = getAngle(tempFrom, to);
                         return to;
                     } else {
                         const nextPoint = HighCurveHelper.getDistancePoint(distanceData, motionPrecision, motionPrecision, offsetX);
@@ -15136,7 +15152,19 @@ const HighCurveHelper = {
                 break;
 
               case Z:
+                toX = startX;
+                toY = startY;
+                distance = segments[index];
+                if (nowDistance + distance >= motionDistance) {
+                    set(tempFrom, x, y), set(to, toX, toY);
+                    getDistancePoint(tempFrom, to, motionDistance - nowDistance, true);
+                    to.rotation = getAngle(tempFrom, to);
+                    return to;
+                }
+                x = toX;
+                y = toY;
                 i += 1;
+                break;
 
               default:
                 distance = 0;
@@ -15150,26 +15178,27 @@ const HighCurveHelper = {
         const {segments: segments, data: data} = distanceData, path = [];
         motionDistance = UnitConvert.number(motionDistance, distanceData.total);
         let total = 0, distance, cutDistance, to = {};
-        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        let i = 0, index = 0, x = 0, y = 0, startX = 0, startY = 0, toX, toY, command;
         let x1, y1, x2, y2, t;
         const len = data.length;
         while (i < len) {
             command = data[i];
             switch (command) {
               case M:
+                startX = data[i + 1];
+                startY = data[i + 2];
+
               case L:
                 toX = data[i + 1];
                 toY = data[i + 2];
                 distance = segments[index];
                 if (total + distance > motionDistance || !distanceData.total) {
                     if (!i) x = toX, y = toY;
-                    tempFrom.x = x;
-                    tempFrom.y = y;
-                    to.x = toX;
-                    to.y = toY;
+                    set(tempFrom, x, y);
+                    set(to, toX, toY);
                     cutDistance = float(motionDistance - total);
                     if (cutDistance) {
-                        PointHelper.getDistancePoint(tempFrom, to, cutDistance, true);
+                        getDistancePoint(tempFrom, to, cutDistance, true);
                         path.push(command, to.x, to.y);
                     }
                     return path;
@@ -15200,8 +15229,24 @@ const HighCurveHelper = {
                 break;
 
               case Z:
+                toX = startX;
+                toY = startY;
+                distance = segments[index];
+                if (total + distance > motionDistance) {
+                    set(tempFrom, x, y);
+                    set(to, toX, toY);
+                    cutDistance = float(motionDistance - total);
+                    if (cutDistance) {
+                        getDistancePoint(tempFrom, to, cutDistance, true);
+                        path.push(L, to.x, to.y);
+                    }
+                    return path;
+                }
+                x = toX;
+                y = toY;
                 i += 1;
                 path.push(command);
+                break;
 
               default:
                 distance = 0;