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

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/{DrawCommandSpan.kt → CanvasEffectSpan.kt}

@@ -9,13 +9,12 @@ package com.facebook.react.views.text.internal.span
 
 import android.graphics.Canvas
 import android.text.Layout
-import android.text.style.UpdateAppearance
 
 /**
- * May be overridden to implement character styles which are applied by [PreparedLayoutTextView]
- * during the drawing of text, against the underlying Android canvas
+ * A span which draws a static effect on top of text. [onPreDraw] and [onDraw] hooks are called
+ * during [PreparedLayoutTextView] drawing, providing glyph layout information for custom rendering.
  */
-public abstract class DrawCommandSpan : UpdateAppearance, ReactSpan {
+public abstract class CanvasEffectSpan : TextEffectSpan {
   /**
    * Called before the text is drawn. This happens after the Paragraph component has drawn its
    * background, but may be called before text spans with their own background color are drawn.

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/CustomStyleSpan.kt

@@ -33,13 +33,30 @@ internal class CustomStyleSpan(
     val fontFeatureSettings: String?,
     val fontFamily: String?,
     private val assetManager: AssetManager,
+    private val fontWeightAdjustment: Int = 0,
 ) : MetricAffectingSpan(), ReactSpan {
   override fun updateDrawState(ds: TextPaint) {
-    apply(ds, privateStyle, privateWeight, fontFeatureSettings, fontFamily, assetManager)
+    apply(
+        ds,
+        privateStyle,
+        privateWeight,
+        fontFeatureSettings,
+        fontFamily,
+        assetManager,
+        fontWeightAdjustment,
+    )
   }
 
   override fun updateMeasureState(paint: TextPaint) {
-    apply(paint, privateStyle, privateWeight, fontFeatureSettings, fontFamily, assetManager)
+    apply(
+        paint,
+        privateStyle,
+        privateWeight,
+        fontFeatureSettings,
+        fontFamily,
+        assetManager,
+        fontWeightAdjustment,
+    )
   }
 
   val style: Int
@@ -66,12 +83,15 @@ internal class CustomStyleSpan(
         fontFeatureSettingsParam: String?,
         family: String?,
         assetManager: AssetManager,
+        fontWeightAdjustment: Int,
     ) {
       val typeface =
           ReactTypefaceUtils.applyStyles(paint.typeface, style, weight, family, assetManager)
+      val adjustedTypeface =
+          ReactTypefaceUtils.applyFontWeightAdjustment(typeface, fontWeightAdjustment)
       paint.apply {
         fontFeatureSettings = fontFeatureSettingsParam
-        setTypeface(typeface)
+        setTypeface(adjustedTypeface)
         isSubpixelText = true
         isLinearText = true
       }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactStrikethroughSpan.kt

@@ -7,7 +7,34 @@
 
 package com.facebook.react.views.text.internal.span
 
-import android.text.style.StrikethroughSpan
+import android.graphics.Canvas
+import android.graphics.Color
+import android.text.Layout
+import com.facebook.react.views.text.TextDecorationStyle
+import com.facebook.react.views.text.drawSpannedDecoration
 
-/** Wraps [StrikethroughSpan] as a [ReactSpan]. */
-internal class ReactStrikethroughSpan : StrikethroughSpan(), ReactSpan
+/**
+ * Draws a strikethrough whose color and style may differ from the text. The line is painted in
+ * `onDraw` after the layout renders its text. We do NOT extend
+ * [android.text.style.StrikethroughSpan] here: the framework's `Layout.draw` paints the
+ * strikethrough using `paint.color` with no field to override, so painting it ourselves is the only
+ * way to get a distinct color or non-solid style.
+ *
+ * `color == Color.TRANSPARENT` falls back to the text foreground color.
+ */
+internal class ReactStrikethroughSpan(
+    private val color: Int = Color.TRANSPARENT,
+    private val style: TextDecorationStyle = TextDecorationStyle.SOLID,
+) : CanvasEffectSpan(), ReactSpan {
+
+  override fun onDraw(start: Int, end: Int, canvas: Canvas, layout: Layout) {
+    drawSpannedDecoration(start, end, canvas, layout, color, style) { paint, baseline, _ ->
+      // Strikethrough sits near the x-height midline. `fontMetrics.ascent`
+      // is negative and `descent` is positive, so the sum / 2 gives a
+      // small negative offset from the baseline; the trailing `+ 1f`
+      // nudges it down to match the visual position users expect.
+      val fm = paint.fontMetrics
+      baseline + (fm.ascent + fm.descent) / 2f + 1f
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactUnderlineSpan.kt

@@ -7,7 +7,29 @@
 
 package com.facebook.react.views.text.internal.span
 
-import android.text.style.UnderlineSpan
+import android.graphics.Canvas
+import android.graphics.Color
+import android.text.Layout
+import com.facebook.react.views.text.TextDecorationStyle
+import com.facebook.react.views.text.drawSpannedDecoration
 
-/** Wraps [UnderlineSpan] as a [ReactSpan]. */
-internal class ReactUnderlineSpan : UnderlineSpan(), ReactSpan
+/**
+ * Draws an underline whose color and style may differ from the text. The underline is painted in
+ * `onDraw` (after the layout renders its text) so it lands on top of any descenders. We do NOT
+ * extend [android.text.style.UnderlineSpan] here: the framework's `Layout.draw` reads `paint.color`
+ * for underline color regardless of `paint.underlineColor`, so painting it ourselves is the only
+ * way to get a distinct color or non-solid style.
+ *
+ * `color == Color.TRANSPARENT` falls back to the text foreground color.
+ */
+internal class ReactUnderlineSpan(
+    private val color: Int = Color.TRANSPARENT,
+    private val style: TextDecorationStyle = TextDecorationStyle.SOLID,
+) : CanvasEffectSpan(), ReactSpan {
+
+  override fun onDraw(start: Int, end: Int, canvas: Canvas, layout: Layout) {
+    drawSpannedDecoration(start, end, canvas, layout, color, style) { _, baseline, thickness ->
+      baseline + thickness + 1f
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/SetSpanOperation.kt

@@ -16,7 +16,7 @@ import kotlin.math.max
 internal class SetSpanOperation(
     private val start: Int,
     private val end: Int,
-    @JvmField val what: ReactSpan,
+    @JvmField val what: Any,
 ) {
   /**
    * @param builder Spannable string builder

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/StatefulSpan.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.views.text.internal.span
+
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+
+/**
+ * Marker interface for spans that hold per-view mutable state (e.g. animation particles, dismiss
+ * flags). When a [PreparedLayout] contains stateful spans, [PreparedLayoutTextView] clones the
+ * spannable so that each view gets independent state even when layouts are shared from a cache.
+ */
+@UnstableReactNativeAPI
+public interface StatefulSpan : TextEffectSpan {
+  /** Returns a fresh instance with the same configuration but independent mutable state. */
+  public fun clone(): StatefulSpan
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/TextEffectSpan.kt

@@ -0,0 +1,19 @@
+/*
+ * 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.views.text.internal.span
+
+/**
+ * Marker interface implemented by every span that may be returned from a
+ * [com.facebook.react.views.text.TextEffectSpanFactory]. Constraining the factory's return type to
+ * this interface means a `List` (or any other non-span value) is rejected at compile time, which
+ * was previously possible because the contract was typed as `Any`.
+ *
+ * Built-in span families ([CanvasEffectSpan], [StatefulSpan], including [AnimatedEffectSpan])
+ * implement this directly so that user spans extending them satisfy the contract automatically.
+ */
+public interface TextEffectSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/TouchableSpan.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.views.text.internal.span
+
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+
+/**
+ * Interface for spans that receive touch events from [PreparedLayoutTextView]. Unlike
+ * [ClickableSpan] which only provides an onClick callback with no position information,
+ * TouchableSpan receives layout-relative coordinates, enabling position-aware interactions such as
+ * dismiss animations originating from the tap point.
+ */
+@UnstableReactNativeAPI
+public interface TouchableSpan {
+  /**
+   * Called when a touch event occurs on text covered by this span.
+   *
+   * @param action the [MotionEvent] action (e.g. [MotionEvent.ACTION_DOWN], [ACTION_UP])
+   * @param layoutX x coordinate relative to the text layout
+   * @param layoutY y coordinate relative to the text layout
+   * @return true if the event was consumed
+   */
+  public fun onTouchEvent(action: Int, layoutX: Float, layoutY: Float): Boolean
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditText.kt

@@ -22,6 +22,7 @@ import android.text.Spannable
 import android.text.SpannableStringBuilder
 import android.text.Spanned
 import android.text.TextPaint
+import android.text.TextUtils
 import android.text.TextWatcher
 import android.text.method.KeyListener
 import android.text.method.QwertyKeyListener
@@ -40,6 +41,7 @@ import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.graphics.withTranslation
 import androidx.core.util.Predicate
 import androidx.core.view.ViewCompat
 import com.facebook.common.logging.FLog
@@ -69,10 +71,12 @@ import com.facebook.react.uimanager.style.LogicalEdge
 import com.facebook.react.uimanager.style.Overflow
 import com.facebook.react.views.text.ReactTextUpdate
 import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.facebook.react.views.text.ReactTypefaceUtils.getFontWeightAdjustment
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontStyle
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
 import com.facebook.react.views.text.TextAttributes
 import com.facebook.react.views.text.TextLayoutManager
+import com.facebook.react.views.text.internal.span.CanvasEffectSpan
 import com.facebook.react.views.text.internal.span.CustomLetterSpacingSpan
 import com.facebook.react.views.text.internal.span.CustomLineHeightSpan
 import com.facebook.react.views.text.internal.span.CustomStyleSpan
@@ -137,6 +141,7 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
   private var selectTextOnFocus = false
   private var placeholder: String? = null
   private var overflow = Overflow.VISIBLE
+  private var wasMultiline = false
 
   public var stateWrapper: StateWrapper? = null
   internal var disableTextDiffing: Boolean = false
@@ -375,11 +380,20 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
       // Avoid refocusing to a new view on old versions of Android by default
       // by preventing `requestFocus()` on the rootView from moving focus to any child.
       // https://cs.android.com/android/_/android/platform/frameworks/base/+/bdc66cb5a0ef513f4306edf9156cc978b08e06e4
-      val rootViewGroup = rootView as ViewGroup
-      val oldDescendantFocusability = rootViewGroup.descendantFocusability
-      rootViewGroup.descendantFocusability = ViewGroup.FOCUS_BLOCK_DESCENDANTS
-      super.clearFocus()
-      rootViewGroup.descendantFocusability = oldDescendantFocusability
+      //
+      // getRootView() returns the view itself when it is detached from the window, so the root
+      // is not necessarily a ViewGroup: an IME editor action delivered over Binder can race the
+      // removal of this view from the hierarchy. There is no focus to move in that case, so a
+      // plain clearFocus() is enough.
+      val rootViewGroup = rootView as? ViewGroup
+      if (rootViewGroup != null) {
+        val oldDescendantFocusability = rootViewGroup.descendantFocusability
+        rootViewGroup.descendantFocusability = ViewGroup.FOCUS_BLOCK_DESCENDANTS
+        super.clearFocus()
+        rootViewGroup.descendantFocusability = oldDescendantFocusability
+      } else {
+        super.clearFocus()
+      }
     }
     hideSoftKeyboard()
   }
@@ -541,14 +555,41 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
     super.setTypeface(tf)
 
     /**
-     * If set forces multiline on input, because of a restriction on Android source that enables
-     * multiline only for inputs of type Text and Multiline on method
+     * Keep the single-line state in sync with the multiline input type flag.
+     *
+     * When multiline is on we must force [isSingleLine] off, because of a restriction on Android
+     * source that enables multiline only for inputs of type Text and Multiline on method
      * [android.widget.TextView.isMultilineInputType]} Source:
      * [TextView.java](https://android.googlesource.com/platform/frameworks/base/+/jb-release/core/java/android/widget/TextView.java)
+     *
+     * When multiline is off we must force [isSingleLine] back on. [TextView.setInputType] only
+     * re-applies the single-line layout (maxLines, horizontal scrolling) when its internal
+     * single-line flag actually changes; because we force it off above whenever multiline is on,
+     * that flag can be stale and the reset is skipped, leaving the placeholder/hint wrapped across
+     * multiple lines after multiline is toggled back off. Setting it explicitly guarantees the
+     * reset. We skip secure text so we don't replace its password transformation method with the
+     * single-line one.
      */
     if (isMultiline) {
       isSingleLine = false
+    } else if (!isSecureText) {
+      isSingleLine = true
+    }
+
+    // Restoring the single-line input type above is not enough on its own when multiline is toggled
+    // off: under Fabric the view is not re-measured while its measured size is unchanged, so the
+    // placeholder/hint is rebuilt at draw time (which lays the hint out at the view's physical
+    // width) and stays wrapped across multiple lines. Forcing a re-measure at the current bounds
+    // rebuilds the hint as a single line, matching the initial mount.
+    if (wasMultiline && !isMultiline && isLaidOut && width > 0 && height > 0) {
+      forceLayout()
+      measure(
+          View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+          View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY),
+      )
+      layout(left, top, right, bottom)
     }
+    wasMultiline = isMultiline
 
     // We override the KeyListener so that all keys on the soft input keyboard as well as hardware
     // keyboards work. Some KeyListeners like DigitsKeyListener will display the keyboard but not
@@ -648,7 +689,7 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
   public fun canUpdateWithEventCount(eventCounter: Int): Boolean = eventCounter >= nativeEventCount
 
   private fun maybeSetText(reactTextUpdate: ReactTextUpdate) {
-    if (isSecureText && (text == reactTextUpdate.text)) {
+    if (isSecureText && TextUtils.equals(text, reactTextUpdate.text)) {
       return
     }
 
@@ -846,7 +887,14 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
             fontFeatureSettings != null
     ) {
       workingText.setSpan(
-          CustomStyleSpan(fontStyle, fontWeight, fontFeatureSettings, fontFamily, context.assets),
+          CustomStyleSpan(
+              fontStyle,
+              fontWeight,
+              fontFeatureSettings,
+              fontFamily,
+              context.assets,
+              getFontWeightAdjustment(context),
+          ),
           0,
           workingText.length,
           spanFlags,
@@ -1129,6 +1177,30 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
       clipToPaddingBox(this, canvas)
     }
 
+    val spanned = text as? Spanned
+    if (spanned != null) {
+      val layout = layout
+      if (layout != null) {
+        val drawSpans = spanned.getSpans(0, spanned.length, CanvasEffectSpan::class.java)
+        if (drawSpans.isNotEmpty()) {
+          canvas.withTranslation(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat()) {
+            for (span in drawSpans) {
+              span.onPreDraw(spanned.getSpanStart(span), spanned.getSpanEnd(span), this, layout)
+            }
+          }
+
+          super.onDraw(canvas)
+
+          canvas.withTranslation(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat()) {
+            for (span in drawSpans) {
+              span.onDraw(spanned.getSpanStart(span), spanned.getSpanEnd(span), this, layout)
+            }
+          }
+          return
+        }
+      }
+    }
+
     super.onDraw(canvas)
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputManager.kt

@@ -69,6 +69,7 @@ import com.facebook.react.views.text.DefaultStyleValuesUtil.getDefaultTextColorH
 import com.facebook.react.views.text.ReactTextUpdate
 import com.facebook.react.views.text.ReactTextUpdate.Companion.buildReactTextUpdateFromState
 import com.facebook.react.views.text.ReactTextViewManagerCallback
+import com.facebook.react.views.text.ReactTypefaceUtils.getFontWeightAdjustment
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontVariant
 import com.facebook.react.views.text.TextAttributeProps
 import com.facebook.react.views.text.TextLayoutManager
@@ -557,6 +558,8 @@ public open class ReactTextInputManager public constructor() :
       when (textAlign) {
         null,
         "auto" -> view.gravityHorizontal = Gravity.NO_GRAVITY
+        "start" -> view.gravityHorizontal = Gravity.START
+        "end" -> view.gravityHorizontal = Gravity.END
         "left" -> view.gravityHorizontal = Gravity.LEFT
         "right" -> view.gravityHorizontal = Gravity.RIGHT
         "center" -> view.gravityHorizontal = Gravity.CENTER_HORIZONTAL
@@ -1016,6 +1019,7 @@ public open class ReactTextInputManager public constructor() :
     val spanned =
         TextLayoutManager.getOrCreateSpannableForText(
             view.context.assets,
+            getFontWeightAdjustment(view.context),
             attributedString,
             reactTextViewManagerCallback,
         )

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

@@ -60,7 +60,6 @@ import com.facebook.react.uimanager.ReactClippingViewGroup
 import com.facebook.react.uimanager.ReactClippingViewGroupHelper.calculateClippingRect
 import com.facebook.react.uimanager.ReactOverflowViewWithInset
 import com.facebook.react.uimanager.ReactPointerEventsView
-import com.facebook.react.uimanager.ReactZIndexedViewGroup
 import com.facebook.react.uimanager.style.BorderRadiusProp
 import com.facebook.react.uimanager.style.BorderStyle
 import com.facebook.react.uimanager.style.LogicalEdge
@@ -83,7 +82,6 @@ public open class ReactViewGroup public constructor(context: Context?) :
     ReactClippingViewGroup,
     ReactPointerEventsView,
     ReactHitSlopView,
-    ReactZIndexedViewGroup,
     ReactOverflowViewWithInset {
 
   public override val overflowInset: Rect = Rect()
@@ -129,7 +127,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
    * override all possible add methods for [ViewGroup] so that we can control this process whenever
    * the option is set. We also override [ViewGroup#getChildAt] and [ViewGroup#getChildCount] so
    * those methods may return views that are not attached. This is risky but allows us to perform a
-   * correct cleanup in `NativeViewHierarchyManager`.
+   * correct cleanup.
    */
   internal var _removeClippedSubviews = false
 
@@ -240,7 +238,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   @SuppressLint("MissingSuperCall")
   override fun requestLayout() {
     // No-op, terminate `requestLayout` here, UIManager handles laying out children and
-    // `layout` is called on all RN-managed views by `NativeViewHierarchyManager`
+    // `layout` is called on all RN-managed views by the UIManager
   }
 
   @TargetApi(23)
@@ -652,19 +650,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
     }
   }
 
-  /**
-   * No-op implementation for backward compatibility. Z-order is now managed at the C++ layer in
-   * Fabric.
-   */
-  override fun getZIndexMappedChildIndex(index: Int): Int = index
-
-  /**
-   * No-op implementation for backward compatibility. Z-order is now managed at the C++ layer in
-   * Fabric.
-   */
-  override fun updateDrawingOrder() {
-    // No-op: Z-order is managed at the C++ layer
-  }
+  override fun shouldDelayChildPressedState(): Boolean = false
 
   override fun dispatchSetPressed(pressed: Boolean) {
     // Prevents the ViewGroup from dispatching the pressed state

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

@@ -150,6 +150,14 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     }
   }
 
+  @ReactProp(name = ViewProps.EXPERIMENTAL_BACKGROUND_IMAGE, customType = "BackgroundImage")
+  public open fun setExperimentalBackgroundImage(
+      view: ReactViewGroup,
+      backgroundImage: ReadableArray?,
+  ) {
+    setBackgroundImage(view, backgroundImage)
+  }
+
   @ReactProp(name = ViewProps.BACKGROUND_SIZE, customType = "BackgroundSize")
   public open fun setBackgroundSize(view: ReactViewGroup, backgroundSize: ReadableArray?) {
     if (backgroundSize != null && backgroundSize.size() > 0) {

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

@@ -125,6 +125,7 @@ internal fun Window.setStatusBarStyle(style: String?) {
 
 @Suppress("DEPRECATION")
 private fun Window.statusBarHide() {
+  if (!decorView.isAttachedToWindow) return
   if (isEdgeToEdgeFeatureFlagOn) {
     WindowInsetsControllerCompat(this, decorView).run {
       systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
@@ -144,6 +145,7 @@ private fun Window.statusBarHide() {
 
 @Suppress("DEPRECATION")
 private fun Window.statusBarShow() {
+  if (!decorView.isAttachedToWindow) return
   if (isEdgeToEdgeFeatureFlagOn) {
     WindowInsetsControllerCompat(this, decorView).run {
       systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE

package/ReactAndroid/src/main/java/com/facebook/react/views/virtual/VirtualViewRenderState.kt

@@ -8,7 +8,7 @@
 package com.facebook.react.views.virtual
 
 /**
- * Represents the the render state of children in the most recent commit.
+ * Represents the render state of children in the most recent commit.
  *
  * This enables `ReactVirtualView` to know whether a previously emitted `VirtualViewModeChangeEvent`
  * has been committed, in order to only emit subsequent events that would change it.

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

@@ -15,7 +15,6 @@ import androidx.annotation.VisibleForTesting
 import com.facebook.common.logging.FLog
 import com.facebook.react.R
 import com.facebook.react.common.build.ReactBuildConfig
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.uimanager.ReactClippingViewGroup
 import com.facebook.react.uimanager.ReactRoot
 import com.facebook.react.views.scroll.VirtualView
@@ -287,13 +286,13 @@ public class ReactVirtualView(context: Context) :
     return null
   }
 
-  internal inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-    if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-      FLog.d("$DEBUG_TAG:[$virtualViewID]:$subtag", block())
+  private companion object {
+    private val ENABLE_DEBUG_LOGS: Boolean = ReactBuildConfig.DEBUG && false
+  }
+
+  private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
+    if (ENABLE_DEBUG_LOGS) {
+      FLog.d("ReactVirtualView:[$virtualViewID]:$subtag", block())
     }
   }
 }
-
-private const val DEBUG_TAG: String = "ReactVirtualView"
-private val IS_DEBUG_BUILD =
-    ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD || ReactBuildConfig.ENABLE_PERFETTO

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

@@ -0,0 +1,45 @@
+/*
+ * 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 class YogaAlign(public val intValue: Int) {
+  AUTO(0),
+  FLEX_START(1),
+  CENTER(2),
+  FLEX_END(3),
+  STRETCH(4),
+  BASELINE(5),
+  SPACE_BETWEEN(6),
+  SPACE_AROUND(7),
+  SPACE_EVENLY(8),
+  START(9),
+  END(10);
+
+  public fun intValue(): Int = intValue
+
+  public companion object {
+    @JvmStatic
+    public fun fromInt(value: Int): YogaAlign =
+        when (value) {
+          0 -> AUTO
+          1 -> FLEX_START
+          2 -> CENTER
+          3 -> FLEX_END
+          4 -> STRETCH
+          5 -> BASELINE
+          6 -> SPACE_BETWEEN
+          7 -> SPACE_AROUND
+          8 -> SPACE_EVENLY
+          9 -> START
+          10 -> END
+          else -> throw IllegalArgumentException("Unknown enum value: $value")
+        }
+  }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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 class YogaBoxSizing(public val intValue: Int) {
+  BORDER_BOX(0),
+  CONTENT_BOX(1);
+
+  public fun intValue(): Int = intValue
+
+  public companion object {
+    @JvmStatic
+    public fun fromInt(value: Int): YogaBoxSizing =
+        when (value) {
+          0 -> BORDER_BOX
+          1 -> CONTENT_BOX
+          else -> throw IllegalArgumentException("Unknown enum value: $value")
+        }
+  }
+}

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

@@ -19,8 +19,23 @@ public abstract class YogaConfig {
 
   public abstract fun setErrata(errata: YogaErrata)
 
+  /**
+   * Sets the errata bitmask directly from an [Int]. Use this when combining multiple [YogaErrata]
+   * values (e.g., `YogaErrata.CLASSIC.intValue() and
+   * YogaErrata.STRETCH_FLEX_BASIS.intValue().inv()`) — the [YogaErrata] enum cannot represent
+   * arbitrary bitmask combinations.
+   */
+  public abstract fun setErrata(errata: Int)
+
   public abstract fun getErrata(): YogaErrata
 
+  /**
+   * Returns the errata bitmask as a raw [Int]. Use this companion to [setErrata] (Int) when the
+   * stored bitmask combines bits in a way the [YogaErrata] enum cannot represent — calling
+   * [getErrata] in that case throws [IllegalArgumentException] from `YogaErrata.fromInt`.
+   */
+  public abstract fun getErrataInt(): Int
+
   public abstract fun setLogger(logger: YogaLogger?)
 
   public abstract fun getLogger(): YogaLogger?

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

@@ -50,9 +50,15 @@ private constructor(@JvmField protected var nativePointer: Long) : YogaConfig()
     YogaNative.jni_YGConfigSetErrataJNI(nativePointer, errata.intValue())
   }
 
+  public override fun setErrata(errata: Int) {
+    YogaNative.jni_YGConfigSetErrataJNI(nativePointer, errata)
+  }
+
   public override fun getErrata(): YogaErrata =
       YogaErrata.fromInt(YogaNative.jni_YGConfigGetErrataJNI(nativePointer))
 
+  public override fun getErrataInt(): Int = YogaNative.jni_YGConfigGetErrataJNI(nativePointer)
+
   public override fun setLogger(logger: YogaLogger?) {
     _logger = logger
     YogaNative.jni_YGConfigSetLoggerJNI(nativePointer, logger)