react-native-tvos 0.85.0-0rc1 → 0.85.2-0

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

@@ -39,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
@@ -139,6 +140,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private boolean mEmittedOverScrollSinceScrollBegin = false;
   private boolean mScrollsChildToFocus = true;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactHorizontalScrollView(Context context) {
     this(context, null);
@@ -251,9 +254,23 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mScrollEnabled && super.canScrollHorizontally(direction);
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      // Jump instantly to the target position instead of animating.
+      scrollTo(mScroller.getFinalX(), mScroller.getFinalY());
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -400,6 +417,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getLeftFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -623,7 +644,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    // Temporarily block HorizontalScrollView's internal scrollToChild from running
+    // during super.requestChildFocus — we've already handled scrolling in requestChildFocus.
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   @Override
@@ -839,21 +864,41 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   public boolean arrowScroll(int direction) {
     boolean handled = false;
 
-    if (mPagingEnabled) {
+    if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+      // When snapToAlignment is "item", find the next focusable and request focus directly.
+      // This avoids super.arrowScroll() which starts its own scroll animation that conflicts
+      // with tryScrollSnapToChild's snap scrolling.
+      // requestChildFocus → tryScrollSnapToChild handles scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        handled = true;
+      }
+    } else if (mPagingEnabled) {
       mPagedArrowScrolling = true;
 
       if (getChildCount() > 0) {
         View currentFocused = findFocus();
         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
         View rootChild = getContentView();
-        if (isDescendantOf(rootChild, nextFocused)) {
-          if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
-            smoothScrollToNextPage(direction);
+        if (rootChild != null && nextFocused != null && isDescendantOf(rootChild, nextFocused)) {
+          if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+            // When snapToAlignment is "item", don't use smoothScrollToNextPage (which scrolls
+            // by full page width and ignores snapToItemPadding). Instead just request focus —
+            // requestChildFocus → tryScrollSnapToChild handles scrolling with correct padding.
+            nextFocused.requestFocus();
+          } else {
+            if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
+              smoothScrollToNextPage(direction);
+            }
+            nextFocused.requestFocus();
           }
-          nextFocused.requestFocus();
           handled = true;
         } else {
-          smoothScrollToNextPage(direction);
+          if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+            smoothScrollToNextPage(direction);
+          }
           handled = true;
         }
       }
@@ -1652,7 +1697,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

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

@@ -169,6 +169,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactHorizontalScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(
       view: ReactHorizontalScrollView,

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

@@ -24,6 +24,7 @@ import android.graphics.Rect;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
+import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
@@ -38,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
@@ -136,6 +138,8 @@ public class ReactScrollView extends ScrollView
   private boolean mEmittedOverScrollSinceScrollBegin;
   private boolean mScrollsChildToFocus = true;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactScrollView(Context context) {
     this(context, null);
@@ -366,6 +370,10 @@ public class ReactScrollView extends ScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getTopFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -544,6 +552,24 @@ public class ReactScrollView extends ScrollView
     return true;
   }
 
+  @Override
+  public boolean arrowScroll(int direction) {
+    if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+      // When snapToAlignment is "item", find the next focusable and request focus directly.
+      // This avoids super.arrowScroll() which starts its own scroll animation that conflicts
+      // with tryScrollSnapToChild's snap scrolling.
+      // requestChildFocus → tryScrollSnapToChild handles scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        return true;
+      }
+      return false;
+    }
+    return super.arrowScroll(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
@@ -567,7 +593,9 @@ public class ReactScrollView extends ScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   @Override
@@ -619,9 +647,23 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      // Jump instantly to the target position instead of animating.
+      scrollTo(mScroller.getFinalX(), mScroller.getFinalY());
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -1396,7 +1438,11 @@ public class ReactScrollView extends ScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

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

@@ -153,6 +153,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(view: ReactScrollView, removeClippedSubviews: Boolean) {
     view.removeClippedSubviews = removeClippedSubviews

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextView.java

@@ -30,6 +30,7 @@ import androidx.appcompat.widget.TintContextWrapper;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.customview.widget.ExploreByTouchHelper;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
@@ -153,14 +154,38 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     //         mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED |
     // LAYOUT_DIRECTION_INHERIT;
     setEnabled(true);
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      setFocusable(View.FOCUSABLE_AUTO);
-    }
+    // Changed from FOCUSABLE_AUTO to NOT_FOCUSABLE to prevent Android TV's
+    // focus engine from landing on text views when no other views are available
+    setFocusable(View.NOT_FOCUSABLE);
 
     setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     updateView(); // call after changing ellipsizeLocation in particular
   }
 
+  // On Android TV, prevent text views from becoming focusable.
+  // ReactTextAnchorViewManager.setAccessible() ties isFocusable to the
+  // "accessible" prop, which causes Android TV's D-pad focus engine to land
+  // on text views inside recycled list items (FlashList), triggering
+  // requestChildFocus -> scrollToChild scroll jumps.
+  // On non-TV devices, focusability is left unchanged for accessibility.
+  @Override
+  public void setFocusable(boolean focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(false);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
+  @Override
+  public void setFocusable(int focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(View.NOT_FOCUSABLE);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
   private static WritableMap inlineViewJson(
       int visibility, int index, int left, int top, int right, int bottom) {
     WritableMap json = Arguments.createMap();

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

@@ -925,6 +925,11 @@ public open class ReactTextInputManager public constructor() :
                   reactContext.surfaceId,
                   editText.id,
                   editText.text.toString(),
+                  action = when (actionId) {
+                    EditorInfo.IME_ACTION_NEXT -> ReactTextInputSubmitEditingEvent.ACTION_NEXT
+                    EditorInfo.IME_ACTION_PREVIOUS -> ReactTextInputSubmitEditingEvent.ACTION_PREVIOUS
+                    else -> ReactTextInputSubmitEditingEvent.ACTION_SUBMIT
+                  },
               )
           )
         }

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

@@ -11,11 +11,12 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-/** Event emitted by EditText native view when the user submits the text. */
+/** Event emitted by EditText native view when the user triggers an IME editor action. */
 internal class ReactTextInputSubmitEditingEvent(
     surfaceId: Int,
     viewId: Int,
     private val text: String,
+    private val action: String = ACTION_SUBMIT,
 ) : Event<ReactTextInputSubmitEditingEvent>(surfaceId, viewId) {
   override fun getEventName(): String = EVENT_NAME
 
@@ -23,6 +24,7 @@ internal class ReactTextInputSubmitEditingEvent(
     return Arguments.createMap().apply {
       putInt("target", viewTag)
       putString("text", text)
+      putString("action", action)
     }
   }
 
@@ -30,5 +32,8 @@ internal class ReactTextInputSubmitEditingEvent(
 
   companion object {
     private const val EVENT_NAME = "topSubmitEditing"
+    const val ACTION_SUBMIT = "submit"
+    const val ACTION_NEXT = "next"
+    const val ACTION_PREVIOUS = "previous"
   }
 }

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

@@ -634,7 +634,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
       index++
     }
 
-    return firstFocusableElement!!
+    return firstFocusableElement
   }
 
   private fun moveFocusToFirstFocusable(viewGroup: ReactViewGroup): Boolean {

package/ReactApple/RCTAnimatedModuleProvider/RCTAnimatedModuleProvider.mm

@@ -70,10 +70,7 @@
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
                                                       jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
 {
-  if (facebook::react::ReactNativeFeatureFlags::cxxNativeAnimatedEnabled() &&
-      // initialization is moved to DefaultTurboModules when using shared animated backend
-      // TODO: T257053961 deprecate RCTAnimatedModuleProvider.
-      !facebook::react::ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+  if (facebook::react::ReactNativeFeatureFlags::cxxNativeAnimatedEnabled()) {
     if (name == facebook::react::AnimatedModule::kModuleName) {
       __weak RCTAnimatedModuleProvider *weakSelf = self;
       auto provider = std::make_shared<facebook::react::NativeAnimatedNodesManagerProvider>(

package/ReactApple/RCTSwiftUI/RCTSwiftUI.podspec

@@ -25,7 +25,7 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "*.{h,m,swift}"
+  s.source_files           = podspec_sources("*.{h,m,swift}", "")
   s.public_header_files    = "*.h"
   s.module_name            = "RCTSwiftUI"
   s.header_dir             = "RCTSwiftUI"

package/ReactCommon/React-Fabric.podspec

@@ -60,6 +60,7 @@ Pod::Spec.new do |s|
     ss.source_files         = podspec_sources("react/renderer/animated/**/*.{m,mm,cpp,h}", "react/renderer/animated/**/*.{h}")
     ss.exclude_files        = "react/renderer/animated/tests"
     ss.header_dir           = "react/renderer/animated"
+    ss.header_mappings_dir  = "react/renderer/animated"
   end
 
   s.subspec "animations" do |ss|

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -14,15 +14,15 @@
 
 #define REACT_NATIVE_VERSION_MAJOR 0
 #define REACT_NATIVE_VERSION_MINOR 85
-#define REACT_NATIVE_VERSION_PATCH 0
+#define REACT_NATIVE_VERSION_PATCH 2
 
 namespace facebook::react {
 
 struct ReactNativeVersionType {
   int32_t Major = 0;
   int32_t Minor = 85;
-  int32_t Patch = 0;
-  std::string_view Prerelease = "0rc1";
+  int32_t Patch = 2;
+  std::string_view Prerelease = "0";
 };
 
 constexpr ReactNativeVersionType ReactNativeVersion;

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<7f1c4037925fc37dcdcba51df968d503>>
+ * @generated SignedSource<<dc3f7d9199a0f5a94b0669de35fef7a4>>
  */
 
 /**
@@ -96,7 +96,7 @@ class ReactNativeFeatureFlagsDefaults : public ReactNativeFeatureFlagsProvider {
   }
 
   bool enableCustomFocusSearchOnClippedElementsAndroid() override {
-    return true;
+    return false;
   }
 
   bool enableDestroyShadowTreeRevisionAsync() override {

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsOverridesOSSExperimental.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<6a047fa1d33ea17ebd7ba8d0680ee1cc>>
+ * @generated SignedSource<<6ded821dda8049a32168bf82333dd4c3>>
  */
 
 /**
@@ -27,6 +27,10 @@ class ReactNativeFeatureFlagsOverridesOSSExperimental : public ReactNativeFeatur
  public:
     ReactNativeFeatureFlagsOverridesOSSExperimental() = default;
 
+  bool cxxNativeAnimatedEnabled() override {
+    return true;
+  }
+
   bool enableAccessibilityOrder() override {
     return true;
   }
@@ -42,6 +46,10 @@ class ReactNativeFeatureFlagsOverridesOSSExperimental : public ReactNativeFeatur
   bool preventShadowTreeCommitExhaustion() override {
     return true;
   }
+
+  bool useSharedAnimatedBackend() override {
+    return true;
+  }
 };
 
 } // namespace facebook::react

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm

@@ -461,7 +461,9 @@ void ObjCTurboModule::performVoidMethodInvocation(
     @try {
       [inv invokeWithTarget:strongModule];
     } @catch (NSException *exception) {
-      throw convertNSExceptionToJSError(runtime, exception, std::string{moduleName}, methodNameStr);
+      // Void methods are always async, re-throw instead of converting to
+      // JSError, same as the async branch in performMethodInvocation.
+      @throw exception;
     } @finally {
       [retainedObjectsForInvocation removeAllObjects];
     }

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -515,7 +515,10 @@ void NativeAnimatedNodesManager::handleAnimatedEvent(
     // frames.
     if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
       if (auto animationBackend = animationBackend_.lock()) {
-        animationBackend->trigger();
+        animationBackend->pushAnimationMutations(
+            [this](AnimationTimestamp timestamp) -> AnimationMutations {
+              return pullAnimationMutations(timestamp);
+            });
       }
     } else {
       onRender();

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -24,10 +24,17 @@ static inline Props::Shared cloneProps(
       shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
   Props::Shared newProps;
   if (animatedProps.rawProps) {
-    newProps = shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext,
-        shadowNode.getProps(),
-        std::move(*animatedProps.rawProps));
+    if (ReactNativeFeatureFlags::enableFabricCommitBranching()) {
+      newProps = shadowNode.getComponentDescriptor().cloneProps(
+          propsParserContext,
+          shadowNode.getProps(),
+          std::move(*animatedProps.rawProps));
+    } else {
+      newProps = shadowNode.getComponentDescriptor().cloneProps(
+          propsParserContext,
+          shadowNode.getProps(),
+          RawProps(*animatedProps.rawProps));
+    }
   } else {
     newProps = shadowNode.getComponentDescriptor().cloneProps(
         propsParserContext, shadowNode.getProps(), {});
@@ -51,31 +58,27 @@ AnimationBackend::AnimationBackend(
   react_native_assert(uiManager_.expired() == false);
 }
 
-void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
-  std::vector<CallbackWithId> callbacksCopy;
-  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
-  std::set<SurfaceId> asyncFlushSurfaces;
+void AnimationBackend::unpackMutations(
+    AnimationMutations& mutations,
+    std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates,
+    std::set<SurfaceId>& asyncFlushSurfaces) {
+  for (auto& mutation : mutations.batch) {
+    const auto family = mutation.family;
+    react_native_assert(family != nullptr);
 
-  {
-    std::lock_guard lock(mutex_);
-    callbacksCopy = callbacks;
+    auto& [families, updates, hasLayoutUpdates] =
+        surfaceUpdates[family->getSurfaceId()];
+    hasLayoutUpdates |= mutation.hasLayoutUpdates;
+    families.insert(family);
+    updates[mutation.tag] = std::move(mutation.props);
   }
 
-  for (auto& callbackWithId : callbacksCopy) {
-    auto mutations = callbackWithId.callback(timestamp);
-    asyncFlushSurfaces.merge(mutations.asyncFlushSurfaces);
-    for (auto& mutation : mutations.batch) {
-      const auto family = mutation.family;
-      react_native_assert(family != nullptr);
-
-      auto& [families, updates, hasLayoutUpdates] =
-          surfaceUpdates[family->getSurfaceId()];
-      hasLayoutUpdates |= mutation.hasLayoutUpdates;
-      families.insert(family);
-      updates[mutation.tag] = std::move(mutation.props);
-    }
-  }
+  asyncFlushSurfaces.merge(mutations.asyncFlushSurfaces);
+}
 
+void AnimationBackend::applySurfaceUpdates(
+    std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates,
+    const std::set<SurfaceId>& asyncFlushSurfaces) {
   animatedPropsRegistry_->update(surfaceUpdates);
 
   for (auto& [surfaceId, updates] : surfaceUpdates) {
@@ -89,6 +92,30 @@ void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
   requestAsyncFlushForSurfaces(asyncFlushSurfaces);
 }
 
+void AnimationBackend::applyMutations(AnimationMutations mutations) {
+  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
+  std::set<SurfaceId> asyncFlushSurfaces;
+  unpackMutations(mutations, surfaceUpdates, asyncFlushSurfaces);
+  applySurfaceUpdates(surfaceUpdates, asyncFlushSurfaces);
+}
+
+void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
+  std::vector<CallbackWithId> callbacksCopy;
+
+  {
+    std::lock_guard lock(mutex_);
+    callbacksCopy = callbacks;
+  }
+
+  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
+  std::set<SurfaceId> asyncFlushSurfaces;
+  for (auto& callbackWithId : callbacksCopy) {
+    auto mutations = callbackWithId.callback(timestamp);
+    unpackMutations(mutations, surfaceUpdates, asyncFlushSurfaces);
+  }
+  applySurfaceUpdates(surfaceUpdates, asyncFlushSurfaces);
+}
+
 CallbackId AnimationBackend::start(const Callback& callback) {
   std::lock_guard lock(mutex_);
 
@@ -123,6 +150,12 @@ void AnimationBackend::trigger() {
   onAnimationFrame(std::chrono::steady_clock::now().time_since_epoch());
 }
 
+void AnimationBackend::pushAnimationMutations(const Callback& callback) {
+  auto timestamp = animationChoreographer_->now();
+  auto mutations = callback(timestamp);
+  applyMutations(std::move(mutations));
+}
+
 void AnimationBackend::commitUpdates(
     SurfaceId surfaceId,
     SurfaceUpdates& surfaceUpdates) {

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.h

@@ -60,10 +60,19 @@ class AnimationBackend : public UIManagerAnimationBackend {
 
   void onAnimationFrame(AnimationTimestamp timestamp) override;
   void trigger() override;
+  void pushAnimationMutations(const Callback &callback) override;
   CallbackId start(const Callback &callback) override;
   void stop(CallbackId callbackId) override;
 
  private:
+  void unpackMutations(
+      AnimationMutations &mutations,
+      std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates,
+      std::set<SurfaceId> &asyncFlushSurfaces);
+  void applySurfaceUpdates(
+      std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates,
+      const std::set<SurfaceId> &asyncFlushSurfaces);
+  void applyMutations(AnimationMutations mutations);
   std::vector<CallbackWithId> callbacks;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
   std::shared_ptr<AnimationChoreographer> animationChoreographer_;

package/ReactCommon/react/renderer/animationbackend/AnimationChoreographer.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -21,6 +22,10 @@ class AnimationChoreographer {
 
   virtual void resume() = 0;
   virtual void pause() = 0;
+  virtual AnimationTimestamp now() const
+  {
+    return HighResTimeStamp::now().toChronoSteadyClockTimePoint().time_since_epoch();
+  }
   void setAnimationBackend(std::weak_ptr<UIManagerAnimationBackend> animationBackend)
   {
     animationBackend_ = animationBackend;

package/ReactCommon/react/renderer/components/scrollview/BaseScrollViewProps.cpp

@@ -41,6 +41,15 @@ BaseScrollViewProps::BaseScrollViewProps(
                     "snapToItemPadding",
                     sourceProps.snapToItemPadding,
                     (Float)0)),
+      scrollAnimationEnabled(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.scrollAnimationEnabled
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "scrollAnimationEnabled",
+                    sourceProps.scrollAnimationEnabled,
+                    true)),
 #endif
       alwaysBounceHorizontal(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
@@ -410,6 +419,7 @@ void BaseScrollViewProps::setProp(
 #if TARGET_OS_TV
     RAW_SET_PROP_SWITCH_CASE_BASIC(showsScrollIndex);
     RAW_SET_PROP_SWITCH_CASE_BASIC(snapToItemPadding);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollAnimationEnabled);
 #endif
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceHorizontal);
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceVertical);