Fix false positive activation points for SwiftUI elements (#315)

* calculating effective frame for activation point default logic

* Add unit tests for activation point default detection

Test the four key scenarios:
- Zero frame + zero activation point → treated as default
- Zero frame + valid path + valid activation point → treated as default
- Normal frame + center activation point → treated as default
- Normal frame + custom activation point → not default

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: RoyalPineapple

Example/UnitTests/AccessibilityHierarchyParserTests.swift

@@ -114,6 +114,106 @@ final class AccessibilityHierarchyParserTests: XCTestCase {
         // Now pad elements are sorted vertically and then left to right
         XCTAssertEqual(padAgain, ["C", "D", "B", "A"])
     }
+
+    // MARK: - Activation Point Default Detection
+
+    func testZeroFrameAndZeroActivationPointIsDefault() {
+        let container = UIView(frame: .init(x: 0, y: 0, width: 400, height: 400))
+
+        let element = ActivationPointTestView(frame: .init(x: 10, y: 10, width: 100, height: 50))
+        element.isAccessibilityElement = true
+        element.accessibilityLabel = "Zero"
+        element.overriddenFrame = .zero
+        element.overriddenActivationPoint = .zero
+        container.addSubview(element)
+
+        let markers = parseMarkers(in: container)
+        XCTAssertEqual(markers.count, 1)
+        XCTAssertTrue(markers[0].usesDefaultActivationPoint)
+    }
+
+    func testZeroFrameWithPathAndValidActivationPointIsDefault() {
+        let container = UIView(frame: .init(x: 0, y: 0, width: 400, height: 400))
+
+        let pathBounds = CGRect(x: 16, y: 16, width: 370, height: 48)
+        let element = ActivationPointTestView(frame: .init(x: 10, y: 10, width: 370, height: 48))
+        element.isAccessibilityElement = true
+        element.accessibilityLabel = "PathElement"
+        element.overriddenFrame = .zero
+        element.overriddenPath = UIBezierPath(rect: pathBounds)
+        element.overriddenActivationPoint = CGPoint(x: pathBounds.midX, y: pathBounds.midY)
+        container.addSubview(element)
+
+        let markers = parseMarkers(in: container)
+        XCTAssertEqual(markers.count, 1)
+        XCTAssertTrue(markers[0].usesDefaultActivationPoint)
+    }
+
+    func testNormalFrameWithCenterActivationPointIsDefault() {
+        let container = UIView(frame: .init(x: 0, y: 0, width: 400, height: 400))
+
+        let frame = CGRect(x: 50, y: 50, width: 200, height: 60)
+        let element = ActivationPointTestView(frame: frame)
+        element.isAccessibilityElement = true
+        element.accessibilityLabel = "Centered"
+        element.overriddenFrame = frame
+        element.overriddenActivationPoint = CGPoint(x: frame.midX, y: frame.midY)
+        container.addSubview(element)
+
+        let markers = parseMarkers(in: container)
+        XCTAssertEqual(markers.count, 1)
+        XCTAssertTrue(markers[0].usesDefaultActivationPoint)
+    }
+
+    func testNormalFrameWithCustomActivationPointIsNotDefault() {
+        let container = UIView(frame: .init(x: 0, y: 0, width: 400, height: 400))
+
+        let frame = CGRect(x: 50, y: 50, width: 200, height: 60)
+        let element = ActivationPointTestView(frame: frame)
+        element.isAccessibilityElement = true
+        element.accessibilityLabel = "Custom"
+        element.overriddenFrame = frame
+        element.overriddenActivationPoint = CGPoint(x: frame.maxX - 10, y: frame.midY)
+        container.addSubview(element)
+
+        let markers = parseMarkers(in: container)
+        XCTAssertEqual(markers.count, 1)
+        XCTAssertFalse(markers[0].usesDefaultActivationPoint)
+    }
+
+    // MARK: - Private Helpers
+
+    private func parseMarkers(in view: UIView) -> [AccessibilityMarker] {
+        let parser = AccessibilityHierarchyParser()
+        return parser.parseAccessibilityElements(
+            in: view,
+            userInterfaceLayoutDirectionProvider: TestUserInterfaceLayoutDirectionProvider(userInterfaceLayoutDirection: .leftToRight),
+            userInterfaceIdiomProvider: TestUserInterfaceIdiomProvider(userInterfaceIdiom: .phone)
+        )
+    }
+}
+
+// MARK: -
+
+private final class ActivationPointTestView: UIView {
+    var overriddenFrame: CGRect?
+    var overriddenActivationPoint: CGPoint?
+    var overriddenPath: UIBezierPath?
+
+    override var accessibilityFrame: CGRect {
+        get { overriddenFrame ?? super.accessibilityFrame }
+        set { overriddenFrame = newValue }
+    }
+
+    override var accessibilityActivationPoint: CGPoint {
+        get { overriddenActivationPoint ?? super.accessibilityActivationPoint }
+        set { overriddenActivationPoint = newValue }
+    }
+
+    override var accessibilityPath: UIBezierPath? {
+        get { overriddenPath ?? super.accessibilityPath }
+        set { overriddenPath = newValue }
+    }
 }
 
 // MARK: -

Sources/AccessibilitySnapshot/Parser/Swift/Classes/AccessibilityHierarchyParser.swift

@@ -300,9 +300,10 @@ public final class AccessibilityHierarchyParser {
                 userInputLabels: element.object.accessibilityUserInputLabels,
                 shape: Self.accessibilityShape(for: element.object, in: root),
                 activationPoint: root.convert(activationPoint, from: nil),
-                usesDefaultActivationPoint: activationPoint.approximatelyEquals(
-                    Self.defaultActivationPoint(for: element.object),
-                    tolerance: 1 / (root.window?.screen ?? UIScreen.main).scale
+                usesDefaultActivationPoint: Self.usesDefaultActivationPoint(
+                    element: element.object,
+                    activationPoint: activationPoint,
+                    screenScale: (root.window?.screen ?? UIScreen.main).scale
                 ),
                 customActions: element.object.accessibilityCustomActions?.map { AccessibilityMarker.CustomAction(name: $0.name, image: $0.image) } ?? [],
                 customContent: element.object.customContent,
@@ -633,6 +634,43 @@ private extension AccessibilityHierarchyParser {
         }
     }
 
+    /// Determines whether an element is using its default activation point.
+    ///
+    /// When both the activation point and frame are zero, the element hasn't set a custom activation
+    /// point — it's just reporting the default for a zero frame. This can happen with SwiftUI elements
+    /// whose `accessibilityFrame` is `.zero`.
+    static func usesDefaultActivationPoint(
+        element: NSObject,
+        activationPoint: CGPoint,
+        screenScale: CGFloat
+    ) -> Bool {
+        if activationPoint == .zero && element.accessibilityFrame == .zero {
+            return true
+        }
+
+        return activationPoint.approximatelyEquals(
+            defaultActivationPoint(for: element),
+            tolerance: 1 / screenScale
+        )
+    }
+
+    /// Returns the effective screen-coordinate frame for an accessibility element.
+    ///
+    /// Some SwiftUI elements provide an `accessibilityPath` but report a zero `accessibilityFrame`.
+    /// In those cases, the path bounds (which are already in screen coordinates) are used instead.
+    static func effectiveAccessibilityFrame(for element: NSObject) -> CGRect {
+        let frame = element.accessibilityFrame
+        if !frame.isEmpty {
+            return frame
+        }
+
+        if let path = element.accessibilityPath {
+            return path.bounds
+        }
+
+        return frame
+    }
+
     /// Returns the default value for an element's `accessibilityActivationPoint`.
     static func defaultActivationPoint(for element: NSObject) -> CGPoint {
         if let element = element as? UISlider {
@@ -646,8 +684,8 @@ private extension AccessibilityHierarchyParser {
 
         // By default, an element's activation point is the center of its accessibility frame, regardless of whether it
         // uses an accessibility path or frame as its shape.
-        let accessibilityFrame = element.accessibilityFrame
-        return CGPoint(x: accessibilityFrame.midX, y: accessibilityFrame.midY)
+        let frame = effectiveAccessibilityFrame(for: element)
+        return CGPoint(x: frame.midX, y: frame.midY)
     }
 }