fix(hit-testing): ignore views with non-invertible transforms (scale 0)

Views with `transform: [{scaleY: 0}]` or `{scaleX: 0}` were still receiving
touches on both iOS and Android. The symptoms looked different: Android
"inherited" a hit region from a sibling view; iOS collapsed the touch point
onto the degenerate axis. Both reduce to the same root cause: when a
transform can't be inverted, the platform APIs silently fall back to stale
or degenerate data during hit testing.

Android: `TouchTargetHelper.getChildPoint` called `Matrix.invert(inverseMatrix)`
without checking its return value. `Matrix.invert` returns false for a
non-invertible matrix and leaves its destination unchanged. Because
`inverseMatrix` is a class-level field reused across every child-point
conversion, a failure meant we applied the previous view's inverse to the
current view's touch point, the exact "inherits from another view" symptom.
It also explains why shrinking a view from `scaleY: 0.9` to `0.0` left a 90%
hit region: the 0.9 frame had populated the cache. Made `getChildPoint` return
Boolean and skip children whose matrix cannot be inverted.

iOS: `CGAffineTransformInvert` returns the original matrix when it can't
invert, so `-[UIView convertPoint:fromView:]` collapses the touch point onto
the degenerate axis and `-pointInside:` still reports a hit. Added a small
`RCTLayerTransformCollapsesAxis` helper that rejects the hit when the 2x2
projection of `self.layer.transform` has determinant ~ 0. Applied in both
`RCTViewComponentView.mm` (new arch) and `RCTView.m` (legacy arch).

Tests:
* `TouchTargetHelperTest` covers initial scaleX/scaleY: 0, zero-scale parent,
  the "inherits from sibling" regression, the 0.9 to 0.0 transition, and the
  touch-path accumulator.
* `RCTViewComponentViewTests` gets parallel iOS cases.
* RNTester: added a "Zero-scale hit test" entry under Transforms so this
  stays visually verifiable.

Fixes #50797

Author: qflen

packages/react-native/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -718,6 +718,20 @@ - (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(NSSet<NSString *
   return _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
 }
 
+// Rejects hit tests against views whose 2D transform collapses an axis (e.g. `scaleX: 0`,
+// `scaleY: 0`, or any other non-invertible affine). Such views are visually degenerate, and
+// UIKit's `-convertPoint:fromView:` falls back to the original matrix when
+// `CGAffineTransformInvert` can't invert — so without this check the degenerate transform is
+// applied to the touch point and the view can still register hits along the collapsed axis.
+static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
+{
+  CATransform3D t = layer.transform;
+  // Determinant of the 2x2 projection onto the XY plane. Anything non-zero is invertible; we
+  // treat values within float epsilon as zero to avoid numerical issues near machine precision.
+  CGFloat det = t.m11 * t.m22 - t.m12 * t.m21;
+  return fabs(det) < (CGFloat)1e-6;
+}
+
 - (UIView *)betterHitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
   // This is a classic textbook implementation of `hitTest:` with a couple of improvements:
@@ -754,6 +768,9 @@ - (UIView *)betterHitTest:(CGPoint)point withEvent:(UIEvent *)event
 
 - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
+  if (RCTLayerTransformCollapsesAxis(self.layer)) {
+    return nil;
+  }
   switch (_props->pointerEvents) {
     case PointerEventsMode::Auto:
       return [self betterHitTest:point withEvent:event];

packages/react-native/React/Tests/Mounting/RCTViewComponentViewTests.mm

@@ -142,4 +142,45 @@ - (void)testUnmountAfterToggleOffCleansUpReactSubviews
   XCTAssertNil(child2.superview);
 }
 
+#pragma mark - hitTest against non-invertible transforms (#50797)
+
+- (void)testHitTestReturnsNilForZeroScaleYView
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+  view.layer.transform = CATransform3DMakeScale(1, 0, 1);
+
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
+- (void)testHitTestReturnsNilForZeroScaleXView
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+  view.layer.transform = CATransform3DMakeScale(0, 1, 1);
+
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
+- (void)testHitTestReturnsSelfForIdentityTransform
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+
+  XCTAssertEqual([view hitTest:CGPointMake(50, 50) withEvent:nil], view);
+}
+
+- (void)testHitTestAfterScaleTransitionedToZeroReturnsNil
+{
+  // #50797 variant: a view scaled to 0.9 first and then to 0.0 should stop receiving hits.
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+
+  view.layer.transform = CATransform3DMakeScale(1, 0.9, 1);
+  XCTAssertEqual([view hitTest:CGPointMake(50, 50) withEvent:nil], view);
+
+  view.layer.transform = CATransform3DMakeScale(1, 0, 1);
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
 @end

packages/react-native/React/Views/RCTView.m

@@ -179,13 +179,31 @@ - (void)setPointerEvents:(RCTPointerEvents)pointerEvents
   }
 }
 
+// Rejects hit tests against views whose 2D transform collapses an axis (e.g. `scaleX: 0`,
+// `scaleY: 0`, or any other non-invertible affine). Such views are visually degenerate, and
+// UIKit's `-convertPoint:fromView:` falls back to the original matrix when
+// `CGAffineTransformInvert` can't invert — so without this check the degenerate transform is
+// applied to the touch point and the view can still register hits along the collapsed axis.
+static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
+{
+  CATransform3D t = layer.transform;
+  // Determinant of the 2x2 projection onto the XY plane. Anything non-zero is invertible; we
+  // treat values within float epsilon as zero to avoid numerical issues near machine precision.
+  CGFloat det = t.m11 * t.m22 - t.m12 * t.m21;
+  return fabs(det) < (CGFloat)1e-6;
+}
+
 - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
   BOOL canReceiveTouchEvents = ([self isUserInteractionEnabled] && ![self isHidden]);
   if (!canReceiveTouchEvents) {
     return nil;
   }
 
+  if (RCTLayerTransformCollapsesAxis(self.layer)) {
+    return nil;
+  }
+
   // `hitSubview` is the topmost subview which was hit. The hit point can
   // be outside the bounds of `view` (e.g., if -clipsToBounds is NO).
   UIView *hitSubview = nil;

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/uimanager/TouchTargetHelper.kt

@@ -212,7 +212,11 @@ public object TouchTargetHelper {
       for (i in childrenCount - 1 downTo 0) {
         val child = viewGroup.getChildAt(i)
         val childPoint = tempPoint
-        getChildPoint(eventCoords[0], eventCoords[1], viewGroup, child, childPoint)
+        if (!getChildPoint(eventCoords[0], eventCoords[1], viewGroup, child, childPoint)) {
+          // Child's transform is non-invertible (e.g. scaleX: 0 or scaleY: 0): the child is
+          // visually degenerate, so it must not receive touches.
+          continue
+        }
         // The childPoint value will contain the view coordinates relative to the child.
         // We need to store the existing X,Y for the viewGroup away as it is possible this child
         // will not actually be the target and so we restore them if not
@@ -277,29 +281,38 @@ public object TouchTargetHelper {
   /**
    * Returns the coordinates of a touch in the child View. It is transform-aware and will invert the
    * transform Matrix to find the true local points. This code is taken from {@link
-   * ViewGroup#isTransformedTouchPointInView()}
+   * ViewGroup#isTransformedTouchPointInView()}.
+   *
+   * Returns `true` when [outLocalPoint] was populated with coordinates in the child's coordinate
+   * space. Returns `false` when the child's transform matrix is not invertible (for example
+   * `scaleX: 0` or `scaleY: 0`). On `false`, [outLocalPoint] is left in an indeterminate state and
+   * callers must skip the child — the shared [inverseMatrix] field is retained from the previous
+   * successful `invert`, so using it here would leak coordinates from another view.
    */
   private fun getChildPoint(
       x: Float,
       y: Float,
       parent: ViewGroup,
       child: View,
       outLocalPoint: PointF,
-  ) {
+  ): Boolean {
     var localX = x + parent.scrollX - child.left
     var localY = y + parent.scrollY - child.top
     val matrix = child.matrix
     if (!matrix.isIdentity) {
+      val inverseMatrix = inverseMatrix
+      if (!matrix.invert(inverseMatrix)) {
+        return false
+      }
       val localXY = matrixTransformCoords
       localXY[0] = localX
       localXY[1] = localY
-      val inverseMatrix = inverseMatrix
-      matrix.invert(inverseMatrix)
       inverseMatrix.mapPoints(localXY)
       localX = localXY[0]
       localY = localXY[1]
     }
     outLocalPoint.set(localX, localY)
+    return true
   }
 
   /**

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/uimanager/TouchTargetHelperTest.kt

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager
+
+import android.content.Context
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlagsForTests
+import com.facebook.react.views.view.ReactViewGroup
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+/**
+ * Regression tests for facebook/react-native#50797: a view with a non-invertible transform (e.g.
+ * `scaleX: 0` or `scaleY: 0`) must not receive touches, and must not silently reuse the cached
+ * inverse matrix of a previously-processed view.
+ */
+@RunWith(RobolectricTestRunner::class)
+class TouchTargetHelperTest {
+
+  private lateinit var context: Context
+  private lateinit var root: ViewGroup
+
+  @Before
+  fun setUp() {
+    ReactNativeFeatureFlagsForTests.setUp()
+    context = RuntimeEnvironment.getApplication()
+    root = FrameLayout(context)
+    root.id = ROOT_TAG
+    root.measure(500, 500)
+    root.layout(0, 0, 500, 500)
+  }
+
+  @Test
+  fun normalChild_receivesTouchInsideItsBounds() {
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(child)
+    child.layout(0, 0, 200, 200)
+
+    val tag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    assertThat(tag).isEqualTo(CHILD_TAG)
+  }
+
+  @Test
+  fun zeroScaleY_childDoesNotReceiveTouch() {
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(child)
+    child.layout(0, 0, 200, 200)
+    child.scaleY = 0f
+
+    val tag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    // Touch falls through to the root because the child is visually degenerate.
+    assertThat(tag).isEqualTo(ROOT_TAG)
+  }
+
+  @Test
+  fun zeroScaleX_childDoesNotReceiveTouch() {
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(child)
+    child.layout(0, 0, 200, 200)
+    child.scaleX = 0f
+
+    val tag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    assertThat(tag).isEqualTo(ROOT_TAG)
+  }
+
+  @Test
+  fun zeroScaleYParent_childInsideIsNotTouchable() {
+    val parent = ReactViewGroup(context)
+    parent.id = PARENT_TAG
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(parent)
+    parent.addView(child)
+    parent.layout(0, 0, 200, 200)
+    child.layout(0, 0, 200, 200)
+    parent.scaleY = 0f
+
+    val tag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    // Neither the zero-scaled parent nor its child should receive the touch.
+    assertThat(tag).isEqualTo(ROOT_TAG)
+  }
+
+  @Test
+  fun zeroScaleY_doesNotInheritHitRegionFromSibling() {
+    // This is the exact #50797 symptom: a zero-scaled subtree "inherits" the hit region of
+    // another view because `Matrix.invert` fails silently and the cached inverse from the
+    // previous successful invert is reused.
+    val scaledSibling = ReactViewGroup(context)
+    scaledSibling.id = SIBLING_TAG
+    val zeroScaled = ReactViewGroup(context)
+    zeroScaled.id = CHILD_TAG
+    root.addView(scaledSibling)
+    root.addView(zeroScaled)
+    // Sibling: a normally-hit-testable view with a non-identity (invertible) transform, so that
+    // `inverseMatrix` gets populated during traversal.
+    scaledSibling.layout(0, 0, 200, 200)
+    scaledSibling.scaleY = 0.5f
+    // Zero-scaled view is placed somewhere the touch would only land on if the sibling's
+    // inverse matrix were (wrongly) applied to it.
+    zeroScaled.layout(300, 300, 500, 500)
+    zeroScaled.scaleY = 0f
+
+    val tag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    // Must hit the sibling (visible, scale 0.5) — never the zero-scaled view.
+    assertThat(tag).isEqualTo(SIBLING_TAG)
+  }
+
+  @Test
+  fun scaleTransitionedToZero_stopsReceivingTouches() {
+    // Second variant of #50797: a view whose scale shrinks from 0.9 to 0 keeps responding to
+    // touches over its previous hit region because the cached inverse from the 0.9 frame is
+    // reused after `invert` fails.
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(child)
+    child.layout(0, 0, 200, 200)
+
+    // Warm the cache with an invertible transform.
+    child.scaleY = 0.9f
+    val warmTag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+    assertThat(warmTag).isEqualTo(CHILD_TAG)
+
+    // Now collapse the view.
+    child.scaleY = 0f
+    val coldTag = TouchTargetHelper.findTargetTagForTouch(100f, 100f, root)
+
+    assertThat(coldTag).isEqualTo(ROOT_TAG)
+  }
+
+  @Test
+  fun zeroScaleChild_doesNotAppearInTouchPath() {
+    val child = ReactViewGroup(context)
+    child.id = CHILD_TAG
+    root.addView(child)
+    child.layout(0, 0, 200, 200)
+    child.scaleY = 0f
+
+    val eventCoords = FloatArray(2)
+    val path = TouchTargetHelper.findTargetPathAndCoordinatesForTouch(100f, 100f, root, eventCoords)
+
+    val ids: List<Int> = path.map(TouchTargetHelper.ViewTarget::getViewId)
+    assertThat(ids).doesNotContain(CHILD_TAG)
+  }
+
+  private companion object {
+    const val ROOT_TAG = 1
+    const val PARENT_TAG = 2
+    const val CHILD_TAG = 3
+    const val SIBLING_TAG = 4
+  }
+}