@leafer-ui/miniapp 2.2.3 → 2.2.5

package/dist/miniapp.module.js

@@ -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$5(endAngle - startAngle) === 360;
+            if (closedAngle) totalRadian = -PI2; else totalRadian -= PI2;
+        }
         const parts = ceil(abs$5(totalRadian / PI_2));
         const partRadian = totalRadian / parts;
         const partRadian4Sin = sin$3(partRadian / 4);
@@ -4770,7 +4773,7 @@ function useModule(module, exclude) {
             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];
                 }
@@ -6802,11 +6805,11 @@ 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);
         }
-        if (this.isFrame) child.__bindFrame(this);
         this.__layout.affectChildrenSort && this.__layout.childrenSortChange();
     }
     addMany(...children) {
@@ -7020,7 +7023,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.2.3";
+const version = "2.2.5";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() {
@@ -7992,7 +7995,7 @@ class Picker {
         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) {
@@ -8002,6 +8005,15 @@ class Picker {
             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;
@@ -9515,34 +9527,28 @@ let Ellipse = class Ellipse extends UI {
         if (hasAngle) closedAngle = abs$3(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, width, ry);
-                        set$1(tempCenter, rx, ry);
+                        closePath$2(path);
+                        set$1(tempPoint, rx + innerRx, ry), set$1(tempCenter, rx, ry);
                         rotate$2(tempPoint, endAngle, tempCenter, rx, ry);
                         moveTo$3(path, tempPoint.x, tempPoint.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) {
@@ -11442,7 +11448,8 @@ ui$1.__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;