@depup/react-native 0.85.0-depup.0 → 0.86.0-depup.49

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.kt

@@ -12,6 +12,7 @@ package com.facebook.react.views.view
 import android.annotation.SuppressLint
 import android.annotation.TargetApi
 import android.content.Context
+import android.content.res.Configuration
 import android.graphics.BlendMode
 import android.graphics.Canvas
 import android.graphics.Paint
@@ -28,6 +29,7 @@ import com.facebook.react.R
 import com.facebook.react.bridge.ReactNoCrashSoftException
 import com.facebook.react.bridge.ReactSoftExceptionLogger
 import com.facebook.react.bridge.ReactSoftExceptionLogger.logSoftException
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil.assertOnUiThread
 import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
 import com.facebook.react.common.ReactConstants.TAG
@@ -37,6 +39,7 @@ import com.facebook.react.touch.OnInterceptTouchEventListener
 import com.facebook.react.touch.ReactHitSlopView
 import com.facebook.react.touch.ReactInterceptingViewGroup
 import com.facebook.react.uimanager.BackgroundStyleApplicator.clipToPaddingBox
+import com.facebook.react.uimanager.BackgroundStyleApplicator.getPaddingBoxRect
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBackgroundColor
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderColor
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderRadius
@@ -58,8 +61,6 @@ import com.facebook.react.uimanager.ReactClippingViewGroupHelper.calculateClippi
 import com.facebook.react.uimanager.ReactOverflowViewWithInset
 import com.facebook.react.uimanager.ReactPointerEventsView
 import com.facebook.react.uimanager.ReactZIndexedViewGroup
-import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
 import com.facebook.react.uimanager.style.BorderRadiusProp
 import com.facebook.react.uimanager.style.BorderStyle
 import com.facebook.react.uimanager.style.LogicalEdge
@@ -155,6 +156,9 @@ public open class ReactViewGroup public constructor(context: Context?) :
       null
   private var focusOnAttach = false
 
+  internal var nativeBackgroundMap: ReadableMap? = null
+  internal var nativeForegroundMap: ReadableMap? = null
+
   init {
     initView()
   }
@@ -166,9 +170,6 @@ public open class ReactViewGroup public constructor(context: Context?) :
    */
   private fun initView() {
     clipChildren = false
-    if (ReactNativeFeatureFlags.syncAndroidClipToPaddingWithOverflow()) {
-      clipToPadding = false
-    }
 
     _removeClippedSubviews = false
     inSubviewClippingLoop = false
@@ -185,6 +186,8 @@ public open class ReactViewGroup public constructor(context: Context?) :
     backfaceOpacity = 1f
     backfaceVisible = true
     childrenRemovedWhileTransitioning = null
+    nativeBackgroundMap = null
+    nativeForegroundMap = null
   }
 
   internal open fun recycleView() {
@@ -591,6 +594,29 @@ public open class ReactViewGroup public constructor(context: Context?) :
     }
   }
 
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    if (nativeBackgroundMap != null) {
+      applyNativeBackground(nativeBackgroundMap)
+    }
+    if (nativeForegroundMap != null) {
+      applyNativeForeground(nativeForegroundMap)
+    }
+  }
+
+  internal fun applyNativeBackground(map: ReadableMap?) {
+    nativeBackgroundMap = map
+    setFeedbackUnderlay(
+        this,
+        map?.let { ReactDrawableHelper.createDrawableFromJSDescription(context, it) },
+    )
+  }
+
+  internal fun applyNativeForeground(map: ReadableMap?) {
+    nativeForegroundMap = map
+    foreground = map?.let { ReactDrawableHelper.createDrawableFromJSDescription(context, it) }
+  }
+
   override fun onViewAdded(child: View) {
     assertOnUiThread()
     checkViewClippingTag(child, false)
@@ -822,12 +848,42 @@ public open class ReactViewGroup public constructor(context: Context?) :
           } else {
             Overflow.fromString(overflow)
           }
-      if (ReactNativeFeatureFlags.syncAndroidClipToPaddingWithOverflow()) {
-        clipToPadding = _overflow != Overflow.VISIBLE
-      }
       invalidate()
     }
 
+  /**
+   * Returns the clip bounds for this view based on the overflow property.
+   *
+   * When overflow is hidden or scroll, returns the padding box rect (the area inside the borders)
+   * so that systems querying [View.getClipBounds] can determine the view's clipping region. Returns
+   * null when overflow is visible (no clipping).
+   */
+  override fun getClipBounds(): Rect? {
+    if (
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
+            _overflow != null &&
+            _overflow != Overflow.VISIBLE
+    ) {
+      val rect = Rect()
+      getPaddingBoxRect(this, rect)
+      return rect
+    }
+    return super.getClipBounds()
+  }
+
+  /** See [getClipBounds]. */
+  override fun getClipBounds(outRect: Rect): Boolean {
+    if (
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
+            _overflow != null &&
+            _overflow != Overflow.VISIBLE
+    ) {
+      getPaddingBoxRect(this, outRect)
+      return true
+    }
+    return super.getClipBounds(outRect)
+  }
+
   override fun setOverflowInset(left: Int, top: Int, right: Int, bottom: Int) {
     if (
         needsIsolatedLayer(this) &&
@@ -851,11 +907,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   }
 
   override fun draw(canvas: Canvas) {
-    if (
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q &&
-            getUIManagerType(this) == UIManagerType.FABRIC &&
-            needsIsolatedLayer(this)
-    ) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && needsIsolatedLayer(this)) {
       // Check if the view is a stacking context and has children, if it does, do the rendering
       // offscreen and then composite back. This follows the idea of group isolation on blending
       // https://www.w3.org/TR/compositing-1/#isolationblending
@@ -890,11 +942,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
     }
 
     var mixBlendMode: BlendMode? = null
-    if (
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q &&
-            getUIManagerType(this) == UIManagerType.FABRIC &&
-            needsIsolatedLayer(this)
-    ) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && needsIsolatedLayer(this)) {
       mixBlendMode = child.getTag(R.id.mix_blend_mode) as? BlendMode
       if (mixBlendMode != null) {
         val p = Paint()
@@ -997,12 +1045,12 @@ public open class ReactViewGroup public constructor(context: Context?) :
     } else if (axOrderParentOrderList != null) {
       // view is a container so add its children normally
       if (!isFocusable) {
-        super.addChildrenForAccessibility(outChildren)
+        safeAddChildrenForAccessibility(outChildren)
         return
 
         // If this view can coopt, turn the focusability off its children but add them to the tree
       } else if (isFocusable && (contentDescription == null || contentDescription == "")) {
-        super.addChildrenForAccessibility(outChildren)
+        safeAddChildrenForAccessibility(outChildren)
         for (i in 0..<childCount) {
           ReactAxOrderHelper.disableFocusForSubtree(getChildAt(i), axOrderParentOrderList)
         }
@@ -1012,7 +1060,23 @@ public open class ReactViewGroup public constructor(context: Context?) :
         return
       }
     } else {
+      safeAddChildrenForAccessibility(outChildren)
+    }
+  }
+
+  private fun safeAddChildrenForAccessibility(outChildren: ArrayList<View>) {
+    try {
       super.addChildrenForAccessibility(outChildren)
+    } catch (error: IllegalArgumentException) {
+      // Android 16 can race while building accessibility child lists during fast re-parenting.
+      if (error.message?.contains("descendant of this view") == true) {
+        logSoftException(
+            ReactSoftExceptionLogger.Categories.RVG_ADD_CHILDREN_FOR_ACCESSIBILITY,
+            error,
+        )
+      } else {
+        throw error
+      }
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewManager.kt

@@ -22,7 +22,6 @@ import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.LengthPercentage
-import com.facebook.react.uimanager.LengthPercentageType
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.uimanager.ReactAxOrderHelper
@@ -32,8 +31,6 @@ import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewProps
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.uimanager.annotations.ReactPropGroup
-import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil
 import com.facebook.react.uimanager.style.BackgroundImageLayer
 import com.facebook.react.uimanager.style.BackgroundPosition
 import com.facebook.react.uimanager.style.BackgroundRepeat
@@ -138,37 +135,33 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.BACKGROUND_IMAGE, customType = "BackgroundImage")
   public open fun setBackgroundImage(view: ReactViewGroup, backgroundImage: ReadableArray?) {
-    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
-      if (backgroundImage != null && backgroundImage.size() > 0) {
-        val backgroundImageLayers = ArrayList<BackgroundImageLayer>(backgroundImage.size())
-        for (i in 0 until backgroundImage.size()) {
-          val backgroundImageMap = backgroundImage.getMap(i)
-          val layer = BackgroundImageLayer.parse(backgroundImageMap, view.context)
-          if (layer != null) {
-            backgroundImageLayers.add(layer)
-          }
+    if (backgroundImage != null && backgroundImage.size() > 0) {
+      val backgroundImageLayers = ArrayList<BackgroundImageLayer>(backgroundImage.size())
+      for (i in 0 until backgroundImage.size()) {
+        val backgroundImageMap = backgroundImage.getMap(i)
+        val layer = BackgroundImageLayer.parse(backgroundImageMap, view.context)
+        if (layer != null) {
+          backgroundImageLayers.add(layer)
         }
-        BackgroundStyleApplicator.setBackgroundImage(view, backgroundImageLayers)
-      } else {
-        BackgroundStyleApplicator.setBackgroundImage(view, null)
       }
+      BackgroundStyleApplicator.setBackgroundImage(view, backgroundImageLayers)
+    } else {
+      BackgroundStyleApplicator.setBackgroundImage(view, null)
     }
   }
 
   @ReactProp(name = ViewProps.BACKGROUND_SIZE, customType = "BackgroundSize")
   public open fun setBackgroundSize(view: ReactViewGroup, backgroundSize: ReadableArray?) {
-    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
-      if (backgroundSize != null && backgroundSize.size() > 0) {
-        val backgroundSizes = ArrayList<BackgroundSize>(backgroundSize.size())
-        for (i in 0 until backgroundSize.size()) {
-          val backgroundSizeValue = backgroundSize.getDynamic(i)
-          val parsedBackgroundSize = BackgroundSize.parse(backgroundSizeValue)
-          if (parsedBackgroundSize != null) {
-            backgroundSizes.add(parsedBackgroundSize)
-          }
+    if (backgroundSize != null && backgroundSize.size() > 0) {
+      val backgroundSizes = ArrayList<BackgroundSize>(backgroundSize.size())
+      for (i in 0 until backgroundSize.size()) {
+        val backgroundSizeValue = backgroundSize.getDynamic(i)
+        val parsedBackgroundSize = BackgroundSize.parse(backgroundSizeValue)
+        if (parsedBackgroundSize != null) {
+          backgroundSizes.add(parsedBackgroundSize)
         }
-        BackgroundStyleApplicator.setBackgroundSize(view, backgroundSizes)
       }
+      BackgroundStyleApplicator.setBackgroundSize(view, backgroundSizes.ifEmpty { null })
     } else {
       BackgroundStyleApplicator.setBackgroundSize(view, null)
     }
@@ -176,39 +169,35 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.BACKGROUND_POSITION, customType = "BackgroundPosition")
   public open fun setBackgroundPosition(view: ReactViewGroup, backgroundPosition: ReadableArray?) {
-    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
-      if (backgroundPosition != null && backgroundPosition.size() > 0) {
-        val backgroundPositions = ArrayList<BackgroundPosition>(backgroundPosition.size())
-        for (i in 0 until backgroundPosition.size()) {
-          val backgroundPositionMap = backgroundPosition.getMap(i)
-          val parsedBackgroundPosition = BackgroundPosition.parse(backgroundPositionMap)
-          if (parsedBackgroundPosition != null) {
-            backgroundPositions.add(parsedBackgroundPosition)
-          }
+    if (backgroundPosition != null && backgroundPosition.size() > 0) {
+      val backgroundPositions = ArrayList<BackgroundPosition>(backgroundPosition.size())
+      for (i in 0 until backgroundPosition.size()) {
+        val backgroundPositionMap = backgroundPosition.getMap(i)
+        val parsedBackgroundPosition = BackgroundPosition.parse(backgroundPositionMap)
+        if (parsedBackgroundPosition != null) {
+          backgroundPositions.add(parsedBackgroundPosition)
         }
-        BackgroundStyleApplicator.setBackgroundPosition(view, backgroundPositions)
-      } else {
-        BackgroundStyleApplicator.setBackgroundPosition(view, null)
       }
+      BackgroundStyleApplicator.setBackgroundPosition(view, backgroundPositions.ifEmpty { null })
+    } else {
+      BackgroundStyleApplicator.setBackgroundPosition(view, null)
     }
   }
 
   @ReactProp(name = ViewProps.BACKGROUND_REPEAT, customType = "BackgroundRepeat")
   public open fun setBackgroundRepeat(view: ReactViewGroup, backgroundRepeat: ReadableArray?) {
-    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
-      if (backgroundRepeat != null && backgroundRepeat.size() > 0) {
-        val backgroundRepeats = ArrayList<BackgroundRepeat>(backgroundRepeat.size())
-        for (i in 0 until backgroundRepeat.size()) {
-          val backgroundRepeatMap = backgroundRepeat.getMap(i)
-          val parsedBackgroundRepeat = BackgroundRepeat.parse(backgroundRepeatMap)
-          if (parsedBackgroundRepeat != null) {
-            backgroundRepeats.add(parsedBackgroundRepeat)
-          }
+    if (backgroundRepeat != null && backgroundRepeat.size() > 0) {
+      val backgroundRepeats = ArrayList<BackgroundRepeat>(backgroundRepeat.size())
+      for (i in 0 until backgroundRepeat.size()) {
+        val backgroundRepeatMap = backgroundRepeat.getMap(i)
+        val parsedBackgroundRepeat = BackgroundRepeat.parse(backgroundRepeatMap)
+        if (parsedBackgroundRepeat != null) {
+          backgroundRepeats.add(parsedBackgroundRepeat)
         }
-        BackgroundStyleApplicator.setBackgroundRepeat(view, backgroundRepeats)
-      } else {
-        BackgroundStyleApplicator.setBackgroundRepeat(view, null)
       }
+      BackgroundStyleApplicator.setBackgroundRepeat(view, backgroundRepeats.ifEmpty { null })
+    } else {
+      BackgroundStyleApplicator.setBackgroundRepeat(view, null)
     }
   }
 
@@ -256,17 +245,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
           ]
   )
   public open fun setBorderRadius(view: ReactViewGroup, index: Int, rawBorderRadius: Dynamic) {
-    var borderRadius = LengthPercentage.setFromDynamic(rawBorderRadius)
-
-    // We do not support percentage border radii on Paper in order to be consistent with iOS (to
-    // avoid developer surprise if it works on one platform but not another).
-    if (
-        ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC &&
-            borderRadius != null &&
-            borderRadius.type == LengthPercentageType.PERCENT
-    ) {
-      borderRadius = null
-    }
+    val borderRadius = LengthPercentage.setFromDynamic(rawBorderRadius)
 
     BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], borderRadius)
   }
@@ -326,15 +305,12 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = "nativeBackgroundAndroid")
   public open fun setNativeBackground(view: ReactViewGroup, background: ReadableMap?) {
-    val bg =
-        background?.let { ReactDrawableHelper.createDrawableFromJSDescription(view.context, it) }
-    BackgroundStyleApplicator.setFeedbackUnderlay(view, bg)
+    view.applyNativeBackground(background)
   }
 
   @ReactProp(name = "nativeForegroundAndroid")
   public open fun setNativeForeground(view: ReactViewGroup, foreground: ReadableMap?) {
-    view.foreground =
-        foreground?.let { ReactDrawableHelper.createDrawableFromJSDescription(view.context, it) }
+    view.applyNativeForeground(foreground)
   }
 
   @ReactProp(name = ViewProps.NEEDS_OFFSCREEN_ALPHA_COMPOSITING)

package/ReactAndroid/src/main/java/com/facebook/react/views/view/WindowUtil.kt

@@ -7,14 +7,19 @@
 
 package com.facebook.react.views.view
 
+import android.app.Activity
 import android.graphics.Color
 import android.os.Build
+import android.view.View
 import android.view.Window
+import android.view.WindowInsetsController
 import android.view.WindowManager
+import androidx.annotation.VisibleForTesting
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.util.AndroidVersion
 import com.facebook.react.views.common.UiModeUtils
 
 // The light scrim color used in the platform API 29+
@@ -31,12 +36,38 @@ internal val DarkNavigationBarColor = Color.argb(0x80, 0x1b, 0x1b, 0x1b)
  * as enabled elsewhere in the application.
  */
 public var isEdgeToEdgeFeatureFlagOn: Boolean = false
-  private set
+  @VisibleForTesting internal set
 
 public fun setEdgeToEdgeFeatureFlagOn() {
   isEdgeToEdgeFeatureFlagOn = true
 }
 
+internal fun updateEdgeToEdgeFeatureFlag(activity: Activity) {
+  // When the app targets SDK 35+, edge-to-edge may be enforced by the OS even if the
+  // feature flag wasn't explicitly set. In that case, turn the flag on to match.
+  if (AndroidVersion.isAtLeastTargetSdk35(activity)) {
+    if (Build.VERSION.SDK_INT >= AndroidVersion.VERSION_CODE_BAKLAVA) {
+      // The device is running Android 16+ (where edge-to-edge is always enforced)
+      isEdgeToEdgeFeatureFlagOn = true
+    } else {
+      val attributes = intArrayOf(AndroidVersion.ATTR_WINDOW_OPT_OUT_EDGE_TO_EDGE_ENFORCEMENT)
+      val typedArray = activity.theme.obtainStyledAttributes(attributes)
+
+      // The device is running Android 15 with / without opting out
+      isEdgeToEdgeFeatureFlagOn =
+          try {
+            !typedArray.getBoolean(0, false)
+          } finally {
+            typedArray.recycle()
+          }
+    }
+  }
+
+  if (isEdgeToEdgeFeatureFlagOn) {
+    activity.window.enableEdgeToEdge()
+  }
+}
+
 @Suppress("DEPRECATION")
 internal fun Window.setStatusBarTranslucency(isTranslucent: Boolean) {
   // If the status bar is translucent hook into the window insets calculations
@@ -65,6 +96,33 @@ internal fun Window.setStatusBarVisibility(isHidden: Boolean) {
   }
 }
 
+@Suppress("DEPRECATION")
+internal fun Window.setStatusBarStyle(style: String?) {
+  if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
+    if ("dark-content" == style) {
+      // dark-content means dark icons on a light status bar
+      insetsController?.setSystemBarsAppearance(
+          WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
+          WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
+      )
+    } else {
+      insetsController?.setSystemBarsAppearance(
+          0,
+          WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
+      )
+    }
+  } else {
+    var systemUiVisibilityFlags = decorView.systemUiVisibility
+    systemUiVisibilityFlags =
+        if ("dark-content" == style) {
+          systemUiVisibilityFlags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
+        } else {
+          systemUiVisibilityFlags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
+        }
+    decorView.systemUiVisibility = systemUiVisibilityFlags
+  }
+}
+
 @Suppress("DEPRECATION")
 private fun Window.statusBarHide() {
   if (isEdgeToEdgeFeatureFlagOn) {
@@ -106,23 +164,37 @@ private fun Window.statusBarShow() {
 internal fun Window.enableEdgeToEdge() {
   WindowCompat.setDecorFitsSystemWindows(this, false)
 
+  val insetsController = WindowInsetsControllerCompat(this, decorView)
   val isDarkMode = UiModeUtils.isDarkMode(context)
 
+  statusBarColor = Color.TRANSPARENT
+
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+    navigationBarColor = Color.TRANSPARENT
+
+    val attributes = intArrayOf(android.R.attr.enforceNavigationBarContrast)
+    val typedArray = context.theme.obtainStyledAttributes(attributes)
+
+    val enforceNavigationBarContrast =
+        try {
+          typedArray.getBoolean(0, true)
+        } finally {
+          typedArray.recycle()
+        }
+
     isStatusBarContrastEnforced = false
-    isNavigationBarContrastEnforced = true
-  }
+    isNavigationBarContrastEnforced = enforceNavigationBarContrast
 
-  statusBarColor = Color.TRANSPARENT
-  navigationBarColor =
-      when {
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q -> Color.TRANSPARENT
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && !isDarkMode -> LightNavigationBarColor
-        else -> DarkNavigationBarColor
-      }
-
-  WindowInsetsControllerCompat(this, decorView).run {
-    isAppearanceLightNavigationBars = !isDarkMode
+    if (enforceNavigationBarContrast) {
+      insetsController.isAppearanceLightNavigationBars = !isDarkMode
+    }
+  } else {
+    val isAppearanceLightNavigationBars =
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && !isDarkMode
+
+    navigationBarColor =
+        if (isAppearanceLightNavigationBars) LightNavigationBarColor else DarkNavigationBarColor
+    insetsController.isAppearanceLightNavigationBars = isAppearanceLightNavigationBars
   }
 
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {

package/ReactAndroid/src/main/java/com/facebook/soloader/annotation/SoLoaderLibrary.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.soloader.annotation
+
+/**
+ * Stub annotation for open-source Gradle builds. The real implementation lives in
+ * fbandroid/java/com/facebook/soloader/annotation/ and is used by the internal Buck build for
+ * compile-time validation of native library merging.
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.CLASS)
+internal annotation class SoLoaderLibrary(vararg val value: String)

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaAlign.java

@@ -18,7 +18,9 @@ public enum YogaAlign {
   BASELINE(5),
   SPACE_BETWEEN(6),
   SPACE_AROUND(7),
-  SPACE_EVENLY(8);
+  SPACE_EVENLY(8),
+  START(9),
+  END(10);
 
   private final int mIntValue;
 
@@ -41,6 +43,8 @@ public enum YogaAlign {
       case 6: return SPACE_BETWEEN;
       case 7: return SPACE_AROUND;
       case 8: return SPACE_EVENLY;
+      case 9: return START;
+      case 10: return END;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaConfigJNIFinalizer.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.yoga
+
+public class YogaConfigJNIFinalizer public constructor() : YogaConfigJNIBase() {
+
+  /*
+   * This is a valid use of finalize. No other mechanism is appropriate.
+   * YogaConfigJNIFinalizer exists specifically to release JNI-allocated native
+   * memory (via jni_YGConfigFreeJNI) when the Java object is garbage collected.
+   * This is the established pattern for JNI prevented leak classes in Yoga.
+   */
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    freeNatives()
+  }
+
+  public fun freeNatives() {
+    if (nativePointer != 0L) {
+      val pointer = nativePointer
+      nativePointer = 0
+      YogaNative.jni_YGConfigFreeJNI(pointer)
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaDisplay.java

@@ -12,7 +12,8 @@ package com.facebook.yoga;
 public enum YogaDisplay {
   FLEX(0),
   NONE(1),
-  CONTENTS(2);
+  CONTENTS(2),
+  GRID(3);
 
   private final int mIntValue;
 
@@ -29,6 +30,7 @@ public enum YogaDisplay {
       case 0: return FLEX;
       case 1: return NONE;
       case 2: return CONTENTS;
+      case 3: return GRID;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaExperimentalFeature.java

@@ -10,7 +10,8 @@
 package com.facebook.yoga;
 
 public enum YogaExperimentalFeature {
-  WEB_FLEX_BASIS(0);
+  WEB_FLEX_BASIS(0),
+  FIX_FLEX_BASIS_FIT_CONTENT(1);
 
   private final int mIntValue;
 
@@ -25,6 +26,7 @@ public enum YogaExperimentalFeature {
   public static YogaExperimentalFeature fromInt(int value) {
     switch (value) {
       case 0: return WEB_FLEX_BASIS;
+      case 1: return FIX_FLEX_BASIS_FIT_CONTENT;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaGridTrackType.java

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+
+// @generated by enums.py
+
+package com.facebook.yoga;
+
+public enum YogaGridTrackType {
+  AUTO(0),
+  POINTS(1),
+  PERCENT(2),
+  FR(3),
+  MINMAX(4);
+
+  private final int mIntValue;
+
+  YogaGridTrackType(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaGridTrackType fromInt(int value) {
+    switch (value) {
+      case 0: return AUTO;
+      case 1: return POINTS;
+      case 2: return PERCENT;
+      case 3: return FR;
+      case 4: return MINMAX;
+      default: throw new IllegalArgumentException("Unknown enum value: " + value);
+    }
+  }
+}