react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -11,6 +11,7 @@ import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNME
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.findNextFocusableView;
 
 import android.animation.ObjectAnimator;
 import android.animation.ValueAnimator;
@@ -31,6 +32,7 @@ import android.widget.ScrollView;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
+import androidx.core.view.ViewCompat.FocusRealDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
@@ -39,6 +41,7 @@ import com.facebook.react.animated.NativeAnimatedModule;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.LengthPercentage;
 import com.facebook.react.uimanager.LengthPercentageType;
@@ -63,6 +66,7 @@ import com.facebook.react.views.scroll.ReactScrollViewHelper.ReactScrollViewScro
 import com.facebook.systrace.Systrace;
 import java.lang.reflect.Field;
 import java.util.List;
+import java.util.Set;
 
 /**
  * A simple subclass of ScrollView that doesn't dispatch measure and layout to its children and has
@@ -359,6 +363,19 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  public @Nullable View focusSearch(View focused, @FocusRealDirection int direction) {
+    if (ReactNativeFeatureFlags.enableCustomFocusSearchOnClippedElementsAndroid()) {
+      @Nullable View nextfocusableView = findNextFocusableView(this, focused, direction, false);
+
+      if (nextfocusableView != null) {
+        return nextfocusableView;
+      }
+    }
+
+    return super.focusSearch(focused, direction);
+  }
+
   /**
    * Since ReactScrollView handles layout changes on JS side, it does not call super.onlayout due to
    * which mIsLayoutDirty flag in ScrollView remains true and prevents scrolling to child when
@@ -402,9 +419,17 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
+    if (!mScrollEnabled) {
+      return 0;
+    }
+    return super.computeScrollDeltaToGetChildRectOnScreen(rect);
+  }
+
   @Override
   protected void onScrollChanged(int x, int y, int oldX, int oldY) {
-    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactScrollView.onScrollChanged");
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT, "ReactScrollView.onScrollChanged");
     try {
       super.onScrollChanged(x, y, oldX, oldY);
 
@@ -420,7 +445,7 @@ public class ReactScrollView extends ScrollView
             mOnScrollDispatchHelper.getYFlingVelocity());
       }
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+      Systrace.endSection(Systrace.TRACE_TAG_REACT);
     }
   }
 
@@ -528,22 +553,26 @@ public class ReactScrollView extends ScrollView
 
   @Override
   public void updateClippingRect() {
+    updateClippingRect(null);
+  }
+
+  @Override
+  public void updateClippingRect(@Nullable Set<Integer> excludedViewsSet) {
     if (!mRemoveClippedSubviews) {
       return;
     }
 
-    Systrace.beginSection(
-        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactScrollView.updateClippingRect");
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT, "ReactScrollView.updateClippingRect");
     try {
       Assertions.assertNotNull(mClippingRect);
 
       ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
       View contentView = getContentView();
       if (contentView instanceof ReactClippingViewGroup) {
-        ((ReactClippingViewGroup) contentView).updateClippingRect();
+        ((ReactClippingViewGroup) contentView).updateClippingRect(excludedViewsSet);
       }
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+      Systrace.endSection(Systrace.TRACE_TAG_REACT);
     }
   }
 
@@ -1092,7 +1121,7 @@ public class ReactScrollView extends ScrollView
     }
   }
 
-  public void setContentOffset(ReadableMap value) {
+  public void setContentOffset(@Nullable ReadableMap value) {
     // When contentOffset={{x:0,y:0}} with lazy load items, setContentOffset
     // is repeatedly called, causing an unexpected scroll to top behavior.
     // Avoid updating contentOffset if the value has not changed.

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewHelper.kt

@@ -11,15 +11,19 @@ import android.animation.Animator
 import android.animation.ValueAnimator
 import android.content.Context
 import android.graphics.Point
+import android.view.FocusFinder
 import android.view.View
 import android.view.ViewGroup
 import android.widget.OverScroller
+import androidx.core.view.ViewCompat.FocusRealDirection
 import com.facebook.common.logging.FLog
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.common.ReactConstants
+import com.facebook.react.fabric.FabricUIManager
 import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
+import com.facebook.react.uimanager.ReactClippingViewGroup
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
@@ -312,7 +316,12 @@ public object ReactScrollViewHelper {
       FLog.i(
           TAG, "updateFabricScrollState[%d] scrollX %d scrollY %d", scrollView.id, scrollX, scrollY)
     }
-    if (ViewUtil.getUIManagerType(scrollView.id) == UIManagerType.DEFAULT) {
+    if (ViewUtil.getUIManagerType(scrollView.id) == UIManagerType.LEGACY) {
+      return
+    }
+    // NOTE: if the state wrapper is null, we shouldn't even update
+    // the scroll state because there is a chance of going out of sync!
+    if (scrollView.stateWrapper == null) {
       return
     }
     val scrollState = scrollView.reactScrollViewScrollState
@@ -457,6 +466,70 @@ public object ReactScrollViewHelper {
     return Point(scroller.finalX, scroller.finalY)
   }
 
+  @JvmStatic
+  public fun findNextFocusableView(
+      host: ViewGroup,
+      focused: View,
+      @FocusRealDirection direction: Int,
+      horizontal: Boolean
+  ): View? {
+    val absDir = resolveAbsoluteDirection(direction, horizontal, host.getLayoutDirection())
+
+    /*
+     * Check if we can focus the next element in the absolute direction within the ScrollView this
+     * would mean the view is not clipped, if we can't, look into the shadow tree to find the next
+     * focusable element
+     */
+    val ff = FocusFinder.getInstance()
+    val result = ff.findNextFocus(host, focused, absDir)
+
+    if (result != null) {
+      return result
+    }
+
+    if (host !is ReactClippingViewGroup) {
+      return null
+    }
+
+    val uimanager =
+        UIManagerHelper.getUIManager(host.context as ReactContext, UIManagerType.FABRIC)
+            ?: return null
+
+    val nextFocusableViewId =
+        (uimanager as FabricUIManager).findNextFocusableElement(
+            host.getChildAt(0).id, focused.id, absDir) ?: return null
+
+    val ancestorIdList =
+        uimanager
+            .getRelativeAncestorList(host.getChildAt(0).id, nextFocusableViewId)
+            ?.toMutableSet() ?: return null
+
+    ancestorIdList.add(nextFocusableViewId)
+
+    host.updateClippingRect(ancestorIdList)
+
+    return host.findViewById(nextFocusableViewId)
+  }
+
+  @JvmStatic
+  public fun resolveAbsoluteDirection(
+      @FocusRealDirection direction: Int,
+      horizontal: Boolean,
+      layoutDirection: Int
+  ): Int {
+    val rtl: Boolean = layoutDirection == View.LAYOUT_DIRECTION_RTL
+
+    return if (direction == View.FOCUS_FORWARD || direction == View.FOCUS_BACKWARD) {
+      if (horizontal) {
+        if ((direction == View.FOCUS_FORWARD) != rtl) View.FOCUS_RIGHT else View.FOCUS_LEFT
+      } else {
+        if (direction == View.FOCUS_FORWARD) View.FOCUS_DOWN else View.FOCUS_UP
+      }
+    } else {
+      direction
+    }
+  }
+
   public interface ScrollListener {
     public fun onScroll(
         scrollView: ViewGroup?,

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.kt

@@ -0,0 +1,390 @@
+/*
+ * 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.scroll
+
+import android.graphics.Color
+import android.view.View
+import androidx.core.view.ViewCompat
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.RetryableMountingLayerException
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderColor
+import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderRadius
+import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderStyle
+import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderWidth
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
+import com.facebook.react.uimanager.PixelUtil.getDisplayMetricDensity
+import com.facebook.react.uimanager.PointerEvents.Companion.parsePointerEvents
+import com.facebook.react.uimanager.ReactClippingViewGroupHelper
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+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.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle.Companion.fromString
+import com.facebook.react.uimanager.style.LogicalEdge
+import com.facebook.react.views.scroll.ReactScrollViewCommandHelper.Companion.receiveCommand
+import com.facebook.react.views.scroll.ReactScrollViewCommandHelper.ScrollCommandHandler
+import com.facebook.react.views.scroll.ReactScrollViewCommandHelper.ScrollToCommandData
+import com.facebook.react.views.scroll.ReactScrollViewCommandHelper.ScrollToEndCommandData
+import com.facebook.react.views.scroll.ReactScrollViewHelper.parseOverScrollMode
+import com.facebook.react.views.scroll.ReactScrollViewHelper.parseSnapToAlignment
+import com.facebook.react.views.scroll.ScrollEventType.Companion.getJSEventName
+
+/**
+ * View manager for [ReactScrollView] components.
+ *
+ * Note that [ReactScrollView] and [ReactHorizontalScrollView] are exposed to JS as a single
+ * ScrollView component, configured via the `horizontal` boolean property.
+ */
+@ReactModule(name = ReactScrollViewManager.REACT_CLASS)
+public open class ReactScrollViewManager
+@JvmOverloads
+constructor(private val fpsListener: FpsListener? = null) :
+    ViewGroupManager<ReactScrollView>(), ScrollCommandHandler<ReactScrollView> {
+
+  override fun getName(): String = REACT_CLASS
+
+  public override fun createViewInstance(context: ThemedReactContext): ReactScrollView =
+      ReactScrollView(context, fpsListener)
+
+  @ReactProp(name = "scrollEnabled", defaultBoolean = true)
+  public fun setScrollEnabled(view: ReactScrollView, value: Boolean) {
+    view.setScrollEnabled(value)
+
+    // Set focusable to match whether scroll is enabled. This improves keyboarding
+    // experience by not making scrollview a tab stop when you cannot interact with it.
+    view.isFocusable = value
+  }
+
+  @ReactProp(name = "showsVerticalScrollIndicator", defaultBoolean = true)
+  public fun setShowsVerticalScrollIndicator(view: ReactScrollView, value: Boolean) {
+    view.isVerticalScrollBarEnabled = value
+  }
+
+  @ReactProp(name = "decelerationRate")
+  public fun setDecelerationRate(view: ReactScrollView, decelerationRate: Float) {
+    view.setDecelerationRate(decelerationRate)
+  }
+
+  @ReactProp(name = "disableIntervalMomentum")
+  public fun setDisableIntervalMomentum(view: ReactScrollView, disableIntervalMomentum: Boolean) {
+    view.setDisableIntervalMomentum(disableIntervalMomentum)
+  }
+
+  @ReactProp(name = "snapToInterval")
+  public fun setSnapToInterval(view: ReactScrollView, snapToInterval: Float) {
+    // snapToInterval needs to be exposed as a float because of the Javascript interface.
+    val density = getDisplayMetricDensity()
+    view.setSnapInterval((snapToInterval * density).toInt())
+  }
+
+  @ReactProp(name = "snapToOffsets")
+  public fun setSnapToOffsets(view: ReactScrollView, snapToOffsets: ReadableArray?) {
+    if (snapToOffsets == null || snapToOffsets.size() == 0) {
+      view.setSnapOffsets(null)
+      return
+    }
+
+    val density = getDisplayMetricDensity()
+    val offsets: MutableList<Int> = ArrayList()
+    for (i in 0 until snapToOffsets.size()) {
+      offsets.add((snapToOffsets.getDouble(i) * density).toInt())
+    }
+    view.setSnapOffsets(offsets)
+  }
+
+  @ReactProp(name = "snapToAlignment")
+  public fun setSnapToAlignment(view: ReactScrollView, alignment: String?) {
+    view.setSnapToAlignment(parseSnapToAlignment(alignment))
+  }
+
+  @ReactProp(name = "snapToStart")
+  public fun setSnapToStart(view: ReactScrollView, snapToStart: Boolean) {
+    view.setSnapToStart(snapToStart)
+  }
+
+  @ReactProp(name = "snapToEnd")
+  public fun setSnapToEnd(view: ReactScrollView, snapToEnd: Boolean) {
+    view.setSnapToEnd(snapToEnd)
+  }
+
+  @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
+  public fun setRemoveClippedSubviews(view: ReactScrollView, removeClippedSubviews: Boolean) {
+    view.removeClippedSubviews = removeClippedSubviews
+  }
+
+  /**
+   * Computing momentum events is potentially expensive since we post a runnable on the UI thread to
+   * see when it is done. We only do that if {@param sendMomentumEvents} is set to true. This is
+   * handled automatically in js by checking if there is a listener on the momentum events.
+   *
+   * @param view
+   * @param sendMomentumEvents
+   */
+  @ReactProp(name = "sendMomentumEvents")
+  public fun setSendMomentumEvents(view: ReactScrollView, sendMomentumEvents: Boolean) {
+    view.setSendMomentumEvents(sendMomentumEvents)
+  }
+
+  /**
+   * Tag used for logging scroll performance on this scroll view. Will force momentum events to be
+   * turned on (see setSendMomentumEvents).
+   *
+   * @param view
+   * @param scrollPerfTag
+   */
+  @ReactProp(name = "scrollPerfTag")
+  public fun setScrollPerfTag(view: ReactScrollView, scrollPerfTag: String?) {
+    view.setScrollPerfTag(scrollPerfTag)
+  }
+
+  @ReactProp(name = "pagingEnabled")
+  public fun setPagingEnabled(view: ReactScrollView, pagingEnabled: Boolean) {
+    view.setPagingEnabled(pagingEnabled)
+  }
+
+  /**
+   * When set, fills the rest of the scrollview with a color to avoid setting a background and
+   * creating unnecessary overdraw.
+   *
+   * @param view
+   * @param color
+   */
+  @ReactProp(name = "endFillColor", defaultInt = Color.TRANSPARENT, customType = "Color")
+  public fun setBottomFillColor(view: ReactScrollView, color: Int) {
+    view.setEndFillColor(color)
+  }
+
+  /** Controls overScroll behaviour */
+  @ReactProp(name = "overScrollMode")
+  public open fun setOverScrollMode(view: ReactScrollView, value: String?) {
+    view.overScrollMode = parseOverScrollMode(value)
+  }
+
+  @ReactProp(name = "nestedScrollEnabled")
+  public fun setNestedScrollEnabled(view: ReactScrollView?, value: Boolean) {
+    if (view != null) {
+      ViewCompat.setNestedScrollingEnabled(view, value)
+    }
+  }
+
+  override fun getCommandsMap(): Map<String, Int>? = ReactScrollViewCommandHelper.getCommandsMap()
+
+  @Deprecated(
+      message =
+          "ReceiveCommand with an int commandId param is deprecated. Use the overload where commandId is a string.",
+      ReplaceWith("receiveCommand(scrollView, commandId, args)"))
+  override fun receiveCommand(scrollView: ReactScrollView, commandId: Int, args: ReadableArray?) {
+    receiveCommand(this, scrollView, commandId, args)
+  }
+
+  override fun receiveCommand(
+      scrollView: ReactScrollView,
+      commandId: String,
+      args: ReadableArray?
+  ) {
+    receiveCommand<ReactScrollView>(this, scrollView, commandId, args)
+  }
+
+  override fun flashScrollIndicators(scrollView: ReactScrollView) {
+    scrollView.flashScrollIndicators()
+  }
+
+  override fun scrollTo(scrollView: ReactScrollView, data: ScrollToCommandData) {
+    scrollView.abortAnimation()
+    if (data.mAnimated) {
+      scrollView.reactSmoothScrollTo(data.mDestX, data.mDestY)
+    } else {
+      scrollView.scrollTo(data.mDestX, data.mDestY)
+    }
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              ViewProps.BORDER_RADIUS,
+              ViewProps.BORDER_TOP_LEFT_RADIUS,
+              ViewProps.BORDER_TOP_RIGHT_RADIUS,
+              ViewProps.BORDER_BOTTOM_RIGHT_RADIUS,
+              ViewProps.BORDER_BOTTOM_LEFT_RADIUS],
+      defaultFloat = Float.NaN)
+  public fun setBorderRadius(view: ReactScrollView?, index: Int, borderRadius: Float) {
+    if (view != null) {
+      val radius =
+          if (java.lang.Float.isNaN(borderRadius)) null
+          else LengthPercentage(borderRadius, LengthPercentageType.POINT)
+      setBorderRadius(view, BorderRadiusProp.entries[index], radius)
+    }
+  }
+
+  @ReactProp(name = "borderStyle")
+  public fun setBorderStyle(view: ReactScrollView?, borderStyle: String?) {
+    if (view != null) {
+      val parsedBorderStyle = if (borderStyle == null) null else fromString(borderStyle)
+      setBorderStyle(view, parsedBorderStyle)
+    }
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              ViewProps.BORDER_WIDTH,
+              ViewProps.BORDER_LEFT_WIDTH,
+              ViewProps.BORDER_RIGHT_WIDTH,
+              ViewProps.BORDER_TOP_WIDTH,
+              ViewProps.BORDER_BOTTOM_WIDTH],
+      defaultFloat = Float.NaN)
+  public fun setBorderWidth(view: ReactScrollView?, index: Int, width: Float) {
+    if (view != null) {
+      setBorderWidth(view, LogicalEdge.entries[index], width)
+    }
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              "borderColor",
+              "borderLeftColor",
+              "borderRightColor",
+              "borderTopColor",
+              "borderBottomColor"],
+      customType = "Color")
+  @Suppress("UNUSED_PARAMETER")
+  public fun setBorderColor(view: ReactScrollView?, index: Int, color: Int?) {
+    if (view != null) {
+      setBorderColor(view, LogicalEdge.ALL, color)
+    }
+  }
+
+  @ReactProp(name = "overflow")
+  public fun setOverflow(view: ReactScrollView, overflow: String?) {
+    view.setOverflow(overflow)
+  }
+
+  override fun scrollToEnd(scrollView: ReactScrollView, data: ScrollToEndCommandData) {
+    // ScrollView always has one child - the scrollable area. However, it's possible today that we
+    // execute this method as view command before the child view is mounted. Here we will retry the
+    // view commands as a workaround.
+    val child =
+        scrollView.getChildAt(0)
+            ?: throw RetryableMountingLayerException(
+                "scrollToEnd called on ScrollView without child")
+
+    // ScrollView always has one child - the scrollable area
+    val bottom = child.height + scrollView.paddingBottom
+    scrollView.abortAnimation()
+    if (data.mAnimated) {
+      scrollView.reactSmoothScrollTo(scrollView.scrollX, bottom)
+    } else {
+      scrollView.scrollTo(scrollView.scrollX, bottom)
+    }
+  }
+
+  @ReactProp(name = "persistentScrollbar")
+  public fun setPersistentScrollbar(view: ReactScrollView, value: Boolean) {
+    view.isScrollbarFadingEnabled = !value
+  }
+
+  @ReactProp(name = "fadingEdgeLength")
+  public fun setFadingEdgeLength(view: ReactScrollView, value: Int) {
+    if (value > 0) {
+      view.isVerticalFadingEdgeEnabled = true
+      view.setFadingEdgeLength(value)
+    } else {
+      view.isVerticalFadingEdgeEnabled = false
+      view.setFadingEdgeLength(0)
+    }
+  }
+
+  @ReactProp(name = "contentOffset", customType = "Point")
+  public fun setContentOffset(view: ReactScrollView, value: ReadableMap?) {
+    view.setContentOffset(value)
+  }
+
+  @ReactProp(name = "maintainVisibleContentPosition")
+  public fun setMaintainVisibleContentPosition(view: ReactScrollView, value: ReadableMap?) {
+    if (value != null) {
+      view.setMaintainVisibleContentPosition(
+          MaintainVisibleScrollPositionHelper.Config.fromReadableMap(value))
+    } else {
+      view.setMaintainVisibleContentPosition(null)
+    }
+  }
+
+  override fun updateState(
+      view: ReactScrollView,
+      props: ReactStylesDiffMap,
+      stateWrapper: StateWrapper
+  ): Any? {
+    view.setStateWrapper(stateWrapper)
+    return null
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+    val baseEventTypeConstants = super.getExportedCustomDirectEventTypeConstants()
+    val eventTypeConstants = baseEventTypeConstants ?: HashMap()
+    eventTypeConstants.putAll(createExportedCustomDirectEventTypeConstants())
+    return eventTypeConstants
+  }
+
+  @ReactProp(name = ViewProps.POINTER_EVENTS)
+  public fun setPointerEvents(view: ReactScrollView, pointerEventsStr: String?) {
+    view.pointerEvents = parsePointerEvents(pointerEventsStr)
+  }
+
+  @ReactProp(name = "scrollEventThrottle")
+  public fun setScrollEventThrottle(view: ReactScrollView, scrollEventThrottle: Int) {
+    view.scrollEventThrottle = scrollEventThrottle
+  }
+
+  @ReactProp(name = "horizontal")
+  @Suppress("UNUSED_PARAMETER")
+  public fun setHorizontal(view: ReactScrollView?, horizontal: Boolean) {
+    // Do Nothing: Align with static ViewConfigs
+  }
+
+  @ReactProp(name = "isInvertedVirtualizedList")
+  public fun setIsInvertedVirtualizedList(view: ReactScrollView, applyFix: Boolean) {
+    // Usually when inverting the scroll view we are using scaleY: -1 on the list
+    // and on the parent container. HOWEVER, starting from android API 33 there is
+    // a bug that can cause an ANR due to that. Thus we are using different transform
+    // commands to circumvent the ANR. This however causes the vertical scrollbar to
+    // be on the wrong side. Thus we are moving it to the other side, when the list
+    // is inverted.
+    // See also:
+    //  - https://github.com/facebook/react-native/issues/35350
+    //  - https://issuetracker.google.com/issues/287304310
+    if (applyFix) {
+      view.verticalScrollbarPosition = View.SCROLLBAR_POSITION_LEFT
+    } else {
+      view.verticalScrollbarPosition = View.SCROLLBAR_POSITION_DEFAULT
+    }
+  }
+
+  public companion object {
+    public const val REACT_CLASS: String = "RCTScrollView"
+
+    public fun createExportedCustomDirectEventTypeConstants(): Map<String, Any> =
+        mapOf(
+            getJSEventName(ScrollEventType.SCROLL) to mapOf("registrationName" to "onScroll"),
+            getJSEventName(ScrollEventType.BEGIN_DRAG) to
+                mapOf("registrationName" to "onScrollBeginDrag"),
+            getJSEventName(ScrollEventType.END_DRAG) to
+                mapOf("registrationName" to "onScrollEndDrag"),
+            getJSEventName(ScrollEventType.MOMENTUM_BEGIN) to
+                mapOf("registrationName" to "onMomentumScrollBegin"),
+            getJSEventName(ScrollEventType.MOMENTUM_END) to
+                mapOf("registrationName" to "onMomentumScrollEnd"))
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ScrollEvent.kt

@@ -53,7 +53,9 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
       scrollViewWidth: Int,
       scrollViewHeight: Int,
   ) {
-    super.init(surfaceId, viewTag)
+    val timestampMs = SystemClock.uptimeMillis()
+    super.init(surfaceId, viewTag, timestampMs)
+
     this.scrollEventType = scrollEventType
     this.scrollX = scrollX
     this.scrollY = scrollY
@@ -63,7 +65,7 @@ public class ScrollEvent private constructor() : Event<ScrollEvent>() {
     this.contentHeight = contentHeight
     this.scrollViewWidth = scrollViewWidth
     this.scrollViewHeight = scrollViewHeight
-    this.timestamp = SystemClock.uptimeMillis()
+    this.timestamp = timestampMs
   }
 
   override fun getEventName(): String =

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/ReactSwipeRefreshLayout.kt

@@ -9,6 +9,7 @@ package com.facebook.react.views.swiperefresh
 
 import android.view.MotionEvent
 import android.view.ViewConfiguration
+import android.view.ViewGroup
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.PixelUtil

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/RefreshEvent.kt

@@ -23,7 +23,7 @@ internal class RefreshEvent : Event<RefreshEvent> {
     return "topRefresh"
   }
 
-  override fun getEventData(): WritableMap? {
+  override fun getEventData(): WritableMap {
     return Arguments.createMap()
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/SwipeRefreshLayoutManager.kt

@@ -52,7 +52,7 @@ internal open class SwipeRefreshLayoutManager :
       val colorValues = IntArray(colors.size())
       for (i in 0..<colors.size()) {
         if (colors.getType(i) == ReadableType.Map) {
-          colorValues[i] = ColorPropConverter.getColor(colors.getMap(i), view.context)
+          colorValues[i] = ColorPropConverter.getColor(colors.getMap(i), view.context, 0)
         } else {
           colorValues[i] = colors.getInt(i)
         }

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchEvent.kt

@@ -23,7 +23,7 @@ internal class ReactSwitchEvent(surfaceId: Int, viewId: Int, private val isCheck
 
   override fun getEventName(): String = EVENT_NAME
 
-  public override fun getEventData(): WritableMap? =
+  public override fun getEventData(): WritableMap =
       Arguments.createMap().apply {
         putInt("target", viewTag)
         putBoolean("value", isChecked)

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchShadowNode.kt

@@ -8,12 +8,16 @@
 package com.facebook.react.views.switchview
 
 import android.view.View
+import com.facebook.react.common.annotations.LegacyArchitectureShadowNodeWithCxxImpl
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
 import com.facebook.react.uimanager.LayoutShadowNode
 import com.facebook.yoga.YogaMeasureFunction
 import com.facebook.yoga.YogaMeasureMode
 import com.facebook.yoga.YogaMeasureOutput
 import com.facebook.yoga.YogaNode
 
+@LegacyArchitecture
+@LegacyArchitectureShadowNodeWithCxxImpl
 internal class ReactSwitchShadowNode : LayoutShadowNode(), YogaMeasureFunction {
   private var width = 0
   private var height = 0