leafer-game 2.2.3 → 2.2.5

package/dist/web.js

@@ -268,7 +268,7 @@ var LeaferUI = function(exports) {
             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 : [];
@@ -308,21 +308,21 @@ var LeaferUI = function(exports) {
         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;
     const tempScaleData$1 = {};
     const MathHelper = {
@@ -829,7 +829,7 @@ var LeaferUI = function(exports) {
             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);
@@ -837,7 +837,7 @@ var LeaferUI = function(exports) {
             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;
@@ -878,7 +878,7 @@ var LeaferUI = function(exports) {
         }
     };
     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) {
             this.set(x, y);
@@ -2527,7 +2527,7 @@ var LeaferUI = function(exports) {
     };
     const {sin: sin$4, cos: cos$4, hypot: hypot, atan2: atan2$1, ceil: ceil$1, abs: abs$6, PI: PI$3, sqrt: sqrt$3, pow: pow$1} = Math;
     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;
     const tempPoint$4 = {};
     const BezierHelper = {
@@ -2603,8 +2603,8 @@ var LeaferUI = function(exports) {
                     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;
@@ -2629,7 +2629,10 @@ var LeaferUI = function(exports) {
             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);
@@ -2644,7 +2647,7 @@ var LeaferUI = function(exports) {
             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);
@@ -2663,7 +2666,7 @@ var LeaferUI = function(exports) {
                 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);
@@ -4477,7 +4480,7 @@ var LeaferUI = function(exports) {
                 if (!excludeNames.includes(name) && (!exclude || !exclude.includes(name))) {
                     if (module.prototype) {
                         const d = getDescriptor(module.prototype, name);
-                        if (d.writable) target.prototype[name] = module.prototype[name];
+                        if (d) Object.defineProperty(target.prototype, name, d);
                     } else {
                         target.prototype[name] = module[name];
                     }
@@ -6389,11 +6392,11 @@ var LeaferUI = function(exports) {
             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);
             }
-            if (this.isFrame) child.__bindFrame(this);
             this.__layout.affectChildrenSort && this.__layout.childrenSortChange();
         }
         addMany(...children) {
@@ -6603,7 +6606,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "2.2.3";
+    const version = "2.2.5";
     const debug$5 = Debug.get("LeaferCanvas");
     class LeaferCanvas extends LeaferCanvasBase {
         set zIndex(zIndex) {
@@ -7579,7 +7582,7 @@ var LeaferUI = function(exports) {
             if (child.__hitWorld(point, onlyHitMask && child.mask === "path" ? true : undefined)) {
                 const {parent: parent, mask: mask} = child;
                 if (parent && parent.__hasMask && mask && !(mask === "clipping" || mask === "clipping-path")) {
-                    if (!parent.children.some(item => !item.mask && item.__hitWorld(point))) return;
+                    if (!parent.children.some(item => !item.mask && this.isHitLeaf(item, point))) return;
                 }
                 const leaf = proxy || child, {hitThrough: hitThrough} = child, {findList: findList} = this;
                 if (hitThrough) {
@@ -7589,6 +7592,15 @@ var LeaferUI = function(exports) {
                 findList.add(leaf);
             }
         }
+        isHitLeaf(leaf, point) {
+            if (leaf.isBranch) {
+                const {findList: findList} = this, old = findList.length;
+                this.eachFind([ leaf ], false);
+                const count = findList.length - old;
+                for (let i = 0; i < count; i++) findList.remove(findList.indexAt(findList.length - 1));
+                return !!count;
+            } else return leaf.__hitWorld(point);
+        }
         clear() {
             this.point = null;
             this.findList = null;
@@ -8924,7 +8936,7 @@ var LeaferUI = function(exports) {
     __decorate([ surfaceType("#FFFFFF") ], exports.Frame.prototype, "fill", void 0);
     __decorate([ affectRenderBoundsType("hide") ], exports.Frame.prototype, "overflow", void 0);
     exports.Frame = __decorate([ registerUI() ], exports.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 = {};
     exports.Ellipse = class Ellipse extends exports.UI {
         get __tag() {
             return "Ellipse";
@@ -8938,34 +8950,28 @@ var LeaferUI = function(exports) {
             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) {
@@ -9050,7 +9056,7 @@ var LeaferUI = function(exports) {
     __decorate([ pathType(0) ], exports.Star.prototype, "startAngle", void 0);
     exports.Star = __decorate([ registerUI() ], exports.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;
     exports.Line = class Line extends exports.UI {
         get __tag() {
             return "Line";
@@ -9067,7 +9073,7 @@ var LeaferUI = function(exports) {
         }
         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() {
@@ -10662,7 +10668,8 @@ var LeaferUI = function(exports) {
         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;
@@ -11603,7 +11610,7 @@ var LeaferUI = function(exports) {
         return gap === "auto" ? value < 0 ? 0 : value : value;
     }
     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;
         if (x || y) translate(transform, x, y); else if (scaleX > 0 && scaleY > 0) transform.onlyScale = true;
@@ -11625,7 +11632,7 @@ var LeaferUI = function(exports) {
         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);
@@ -11858,7 +11865,7 @@ var LeaferUI = function(exports) {
             if (isTransparent) data.isTransparent = true;
         }
     }
-    const {getAngle: getAngle, getDistance: getDistance$2} = PointHelper;
+    const {getAngle: getAngle$1, getDistance: getDistance$2} = PointHelper;
     const {get: get, rotateOfOuter: rotateOfOuter, scaleOfOuter: scaleOfOuter} = MatrixHelper;
     const {toPoint: toPoint$1} = AroundHelper;
     const realFrom$1 = {};
@@ -11881,7 +11888,7 @@ var LeaferUI = function(exports) {
         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);
@@ -14123,7 +14130,7 @@ var LeaferUI = function(exports) {
         }
     };
     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 = {};
     const HighCurveHelper = {
         transform(data, matrix) {
@@ -14159,16 +14166,19 @@ var LeaferUI = function(exports) {
         },
         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;
@@ -14185,7 +14195,9 @@ var LeaferUI = function(exports) {
 
                   case Z:
                     closed = true;
+                    distance = getDistanceFrom(x, y, startX, startY);
                     i += 1;
+                    break;
 
                   default:
                     distance = 0;
@@ -14206,25 +14218,26 @@ var LeaferUI = function(exports) {
             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);
@@ -14254,7 +14267,19 @@ var LeaferUI = function(exports) {
                     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;
@@ -14268,26 +14293,27 @@ var LeaferUI = function(exports) {
             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;
@@ -14318,8 +14344,24 @@ var LeaferUI = function(exports) {
                     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;