react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -6,36 +6,17 @@
  */
 
 #include "AnimationBackend.h"
+#include "AnimatedPropsRegistry.h"
+
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/animationbackend/AnimatedPropsSerializer.h>
 #include <react/renderer/graphics/Color.h>
 #include <chrono>
-#include <set>
-#include "AnimatedPropsRegistry.h"
+#include <utility>
 
 namespace facebook::react {
 
-static const auto layoutProps = std::set<PropName>{
-    WIDTH,           HEIGHT,        FLEX,          MARGIN,      PADDING,
-    POSITION,        BORDER_WIDTH,  ALIGN_CONTENT, ALIGN_ITEMS, ALIGN_SELF,
-    ASPECT_RATIO,    BOX_SIZING,    DISPLAY,       FLEX_BASIS,  FLEX_DIRECTION,
-    ROW_GAP,         COLUMN_GAP,    FLEX_GROW,     FLEX_SHRINK, FLEX_WRAP,
-    JUSTIFY_CONTENT, MAX_HEIGHT,    MAX_WIDTH,     MIN_HEIGHT,  MIN_WIDTH,
-    STYLE_OVERFLOW,  POSITION_TYPE, DIRECTION,     Z_INDEX,
-};
-
-UIManagerNativeAnimatedDelegateBackendImpl::
-    UIManagerNativeAnimatedDelegateBackendImpl(
-        std::weak_ptr<UIManagerAnimationBackend> animationBackend)
-    : animationBackend_(std::move(animationBackend)) {}
-
-void UIManagerNativeAnimatedDelegateBackendImpl::runAnimationFrame() {
-  if (auto animationBackendStrong = animationBackend_.lock()) {
-    animationBackendStrong->onAnimationFrame(
-        std::chrono::steady_clock::now().time_since_epoch().count() / 1000);
-  }
-}
-
 static inline Props::Shared cloneProps(
     AnimatedProps& animatedProps,
     const ShadowNode& shadowNode) {
@@ -61,32 +42,36 @@ static inline Props::Shared cloneProps(
 }
 
 AnimationBackend::AnimationBackend(
-    StartOnRenderCallback&& startOnRenderCallback,
-    StopOnRenderCallback&& stopOnRenderCallback,
-    DirectManipulationCallback&& directManipulationCallback,
-    FabricCommitCallback&& fabricCommitCallback,
-    UIManager* uiManager)
-    : startOnRenderCallback_(std::move(startOnRenderCallback)),
-      stopOnRenderCallback_(std::move(stopOnRenderCallback)),
-      directManipulationCallback_(std::move(directManipulationCallback)),
-      fabricCommitCallback_(std::move(fabricCommitCallback)),
-      animatedPropsRegistry_(std::make_shared<AnimatedPropsRegistry>()),
-      uiManager_(uiManager),
-      commitHook_(uiManager, animatedPropsRegistry_) {}
-
-void AnimationBackend::onAnimationFrame(double timestamp) {
+    std::shared_ptr<AnimationChoreographer> animationChoreographer,
+    std::shared_ptr<UIManager> uiManager)
+    : animatedPropsRegistry_(std::make_shared<AnimatedPropsRegistry>()),
+      animationChoreographer_(std::move(animationChoreographer)),
+      commitHook_(*uiManager, animatedPropsRegistry_),
+      uiManager_(std::move(uiManager)) {
+  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;
 
-  for (auto& callback : callbacks) {
-    auto muatations = callback(static_cast<float>(timestamp));
-    for (auto& mutation : muatations.batch) {
+  {
+    std::lock_guard lock(mutex_);
+    callbacksCopy = callbacks;
+  }
+
+  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.get());
+      families.insert(family);
       updates[mutation.tag] = std::move(mutation.props);
     }
   }
@@ -100,35 +85,56 @@ void AnimationBackend::onAnimationFrame(double timestamp) {
       synchronouslyUpdateProps(updates.propsMap);
     }
   }
+
+  requestAsyncFlushForSurfaces(asyncFlushSurfaces);
 }
 
-void AnimationBackend::start(const Callback& callback, bool isAsync) {
-  callbacks.push_back(callback);
-  // TODO: startOnRenderCallback_ should provide the timestamp from the
-  // platform
-  if (startOnRenderCallback_) {
-    startOnRenderCallback_(
-        [this]() {
-          onAnimationFrame(
-              std::chrono::steady_clock::now().time_since_epoch().count() /
-              1000);
-        },
-        isAsync);
+CallbackId AnimationBackend::start(const Callback& callback) {
+  std::lock_guard lock(mutex_);
+
+  auto callbackId = nextCallbackId_++;
+  callbacks.push_back({.callbackId = callbackId, .callback = callback});
+  if (!isRenderCallbackStarted_) {
+    animationChoreographer_->resume();
+    isRenderCallbackStarted_ = true;
   }
+
+  return callbackId;
 }
-void AnimationBackend::stop(bool isAsync) {
-  if (stopOnRenderCallback_) {
-    stopOnRenderCallback_(isAsync);
+
+void AnimationBackend::stop(CallbackId callbackId) {
+  std::lock_guard lock(mutex_);
+
+  auto it = std::find_if(callbacks.begin(), callbacks.end(), [&](auto& c) {
+    return c.callbackId == callbackId;
+  });
+  if (it == callbacks.end()) {
+    return;
   }
-  callbacks.clear();
+
+  callbacks.erase(it);
+  if (isRenderCallbackStarted_ && callbacks.empty()) {
+    animationChoreographer_->pause();
+    isRenderCallbackStarted_ = false;
+  }
+}
+
+void AnimationBackend::trigger() {
+  onAnimationFrame(std::chrono::steady_clock::now().time_since_epoch());
 }
 
 void AnimationBackend::commitUpdates(
     SurfaceId surfaceId,
     SurfaceUpdates& surfaceUpdates) {
+  auto uiManager = uiManager_.lock();
+  if (!uiManager) {
+    return;
+  }
+
   auto& surfaceFamilies = surfaceUpdates.families;
   auto& updates = surfaceUpdates.propsMap;
-  uiManager_->getShadowTreeRegistry().visit(
+
+  uiManager->getShadowTreeRegistry().visit(
       surfaceId, [&surfaceFamilies, &updates](const ShadowTree& shadowTree) {
         shadowTree.commit(
             [&surfaceFamilies,
@@ -140,15 +146,15 @@ void AnimationBackend::commitUpdates(
                           const ShadowNode& shadowNode,
                           const ShadowNodeFragment& fragment) {
                         auto newProps = ShadowNodeFragment::propsPlaceholder();
-                        if (surfaceFamilies.contains(&shadowNode.getFamily())) {
+                        if (surfaceFamilies.contains(
+                                shadowNode.getFamilyShared())) {
                           auto& animatedProps = updates.at(shadowNode.getTag());
                           newProps = cloneProps(animatedProps, shadowNode);
                         }
                         return shadowNode.clone(
                             {.props = newProps,
                              .children = fragment.children,
-                             .state = shadowNode.getState(),
-                             .runtimeShadowNodeReference = false});
+                             .state = shadowNode.getState()});
                       }));
             },
             {.mountSynchronously = true});
@@ -159,9 +165,58 @@ void AnimationBackend::synchronouslyUpdateProps(
     const std::unordered_map<Tag, AnimatedProps>& updates) {
   for (auto& [tag, animatedProps] : updates) {
     // TODO: We shouldn't repack it into dynamic, but for that a rewrite
-    // of directManipulationCallback_ is needed
+    // of synchronouslyUpdateViewOnUIThread is needed
     auto dyn = animationbackend::packAnimatedProps(animatedProps);
-    directManipulationCallback_(tag, std::move(dyn));
+    if (auto uiManager = uiManager_.lock()) {
+      uiManager->synchronouslyUpdateViewOnUIThread(tag, dyn);
+    }
+  }
+}
+
+void AnimationBackend::requestAsyncFlushForSurfaces(
+    const std::set<SurfaceId>& surfaces) {
+  react_native_assert(
+      jsInvoker_ != nullptr ||
+      surfaces.empty() && "jsInvoker_ was not provided");
+  std::weak_ptr<AnimatedPropsRegistry> weakAnimatedPropsRegistry =
+      animatedPropsRegistry_;
+  for (const auto& surfaceId : surfaces) {
+    // perform an empty commit on the js thread, to force the commit hook to
+    // push updated shadow nodes to react through RSNRU
+    jsInvoker_->invokeAsync(
+        [weakUIManager = uiManager_, surfaceId, weakAnimatedPropsRegistry]() {
+          auto uiManager = weakUIManager.lock();
+          if (!uiManager) {
+            return;
+          }
+          uiManager->getShadowTreeRegistry().visit(
+              surfaceId,
+              [weakAnimatedPropsRegistry](const ShadowTree& shadowTree) {
+                auto result = shadowTree.commit(
+                    [weakAnimatedPropsRegistry](
+                        const RootShadowNode& oldRootShadowNode) {
+                      return std::static_pointer_cast<RootShadowNode>(
+                          oldRootShadowNode.ShadowNode::clone({}));
+                    },
+                    {.source = ShadowTreeCommitSource::AnimationEndSync});
+                // To clear the registry, the updates neeed to be propagated to
+                // React with RSNRU. Without
+                // updateRuntimeShadowNodeReferencesOnCommitThread this won't
+                // happen if we do any commits on the main thread, since the
+                // runtimeShadowNodeReference_ is not propagated to nodes cloned
+                // outside of the JS thread. So when the flag is disabled we
+                // keep the updates in the registry and we will reapply them in
+                // a commit hook triggered by a rerender.
+                if (result == ShadowTree::CommitStatus::Succeeded &&
+                    ReactNativeFeatureFlags::
+                        updateRuntimeShadowNodeReferencesOnCommitThread()) {
+                  if (auto animatedPropsRegistry =
+                          weakAnimatedPropsRegistry.lock()) {
+                    animatedPropsRegistry->clear(shadowTree.getSurfaceId());
+                  }
+                }
+              });
+        });
   }
 }
 
@@ -169,4 +224,11 @@ void AnimationBackend::clearRegistry(SurfaceId surfaceId) {
   animatedPropsRegistry_->clear(surfaceId);
 }
 
+void AnimationBackend::registerJSInvoker(
+    std::shared_ptr<CallInvoker> jsInvoker) {
+  if (!jsInvoker_) {
+    jsInvoker_ = jsInvoker;
+  }
+}
+
 } // namespace facebook::react

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

@@ -7,31 +7,24 @@
 
 #pragma once
 
+#include <ReactCommon/CallInvoker.h>
 #include <folly/dynamic.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
 #include <functional>
+#include <memory>
+#include <set>
 #include <vector>
 #include "AnimatedProps.h"
-#include "AnimatedPropsBuilder.h"
 #include "AnimatedPropsRegistry.h"
 #include "AnimationBackendCommitHook.h"
+#include "AnimationChoreographer.h"
 
 namespace facebook::react {
 
 class AnimationBackend;
 
-class UIManagerNativeAnimatedDelegateBackendImpl : public UIManagerNativeAnimatedDelegate {
- public:
-  explicit UIManagerNativeAnimatedDelegateBackendImpl(std::weak_ptr<UIManagerAnimationBackend> animationBackend);
-
-  void runAnimationFrame() override;
-
- private:
-  std::weak_ptr<UIManagerAnimationBackend> animationBackend_;
-};
-
 struct AnimationMutation {
   Tag tag;
   std::shared_ptr<const ShadowNodeFamily> family;
@@ -41,37 +34,44 @@ struct AnimationMutation {
 
 struct AnimationMutations {
   std::vector<AnimationMutation> batch;
+  std::set<SurfaceId> asyncFlushSurfaces;
+};
+
+using Callback = std::function<AnimationMutations(AnimationTimestamp)>;
+
+struct CallbackWithId {
+  CallbackId callbackId;
+  Callback callback;
 };
 
 class AnimationBackend : public UIManagerAnimationBackend {
  public:
-  using Callback = std::function<AnimationMutations(float)>;
-  using StartOnRenderCallback = std::function<void(std::function<void()> &&, bool /* isAsync */)>;
-  using StopOnRenderCallback = std::function<void(bool /* isAsync */)>;
-  using DirectManipulationCallback = std::function<void(Tag, const folly::dynamic &)>;
-  using FabricCommitCallback = std::function<void(std::unordered_map<Tag, folly::dynamic> &)>;
-
-  std::vector<Callback> callbacks;
-  const StartOnRenderCallback startOnRenderCallback_;
-  const StopOnRenderCallback stopOnRenderCallback_;
-  const DirectManipulationCallback directManipulationCallback_;
-  const FabricCommitCallback fabricCommitCallback_;
-  std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
-  UIManager *uiManager_;
-  AnimationBackendCommitHook commitHook_;
+  using ResumeCallback = std::function<void()>;
+  using PauseCallback = std::function<void()>;
 
   AnimationBackend(
-      StartOnRenderCallback &&startOnRenderCallback,
-      StopOnRenderCallback &&stopOnRenderCallback,
-      DirectManipulationCallback &&directManipulationCallback,
-      FabricCommitCallback &&fabricCommitCallback,
-      UIManager *uiManager);
+      std::shared_ptr<AnimationChoreographer> animationChoreographer,
+      std::shared_ptr<UIManager> uiManager);
   void commitUpdates(SurfaceId surfaceId, SurfaceUpdates &surfaceUpdates);
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
+  void requestAsyncFlushForSurfaces(const std::set<SurfaceId> &surfaces);
   void clearRegistry(SurfaceId surfaceId) override;
+  void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) override;
 
-  void onAnimationFrame(double timestamp) override;
-  void start(const Callback &callback, bool isAsync);
-  void stop(bool isAsync) override;
+  void onAnimationFrame(AnimationTimestamp timestamp) override;
+  void trigger() override;
+  CallbackId start(const Callback &callback) override;
+  void stop(CallbackId callbackId) override;
+
+ private:
+  std::vector<CallbackWithId> callbacks;
+  std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
+  std::shared_ptr<AnimationChoreographer> animationChoreographer_;
+  AnimationBackendCommitHook commitHook_;
+  std::weak_ptr<UIManager> uiManager_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+  bool isRenderCallbackStarted_{false};
+  CallbackId nextCallbackId_{0};
+  std::mutex mutex_;
 };
 } // namespace facebook::react

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

@@ -7,13 +7,15 @@
 
 #include <react/renderer/animationbackend/AnimationBackendCommitHook.h>
 
+#include <utility>
+
 namespace facebook::react {
 
 AnimationBackendCommitHook::AnimationBackendCommitHook(
-    UIManager* uiManager,
+    UIManager& uiManager,
     std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry)
     : animatedPropsRegistry_(std::move(animatedPropsRegistry)) {
-  uiManager->registerCommitHook(*this);
+  uiManager.registerCommitHook(*this);
 }
 
 RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
@@ -21,7 +23,8 @@ RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
     const RootShadowNode::Shared& oldRootShadowNode,
     const RootShadowNode::Unshared& newRootShadowNode,
     const ShadowTreeCommitOptions& commitOptions) noexcept {
-  if (commitOptions.source != ShadowTreeCommitSource::React) {
+  if (commitOptions.source != ShadowTreeCommitSource::React &&
+      commitOptions.source != ShadowTreeCommitSource::AnimationEndSync) {
     return newRootShadowNode;
   }
 
@@ -32,17 +35,18 @@ RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
   if (surfaceFamilies.empty()) {
     return newRootShadowNode;
   }
-  return std::static_pointer_cast<RootShadowNode>(
-      newRootShadowNode->cloneMultiple(
+  auto clonedRootShadowNode =
+      std::static_pointer_cast<RootShadowNode>(newRootShadowNode->cloneMultiple(
           surfaceFamilies,
           [&surfaceFamilies, &updates](
               const ShadowNode& shadowNode,
               const ShadowNodeFragment& fragment) {
             auto newProps = ShadowNodeFragment::propsPlaceholder();
             std::shared_ptr<BaseViewProps> viewProps = nullptr;
-            if (surfaceFamilies.contains(&shadowNode.getFamily()) &&
-                updates.contains(shadowNode.getTag())) {
-              auto& snapshot = updates.at(shadowNode.getTag());
+            if (auto updatesIter = updates.find(shadowNode.getTag());
+                updatesIter != updates.end() &&
+                surfaceFamilies.contains(shadowNode.getFamilyShared())) {
+              auto& snapshot = updatesIter->second;
               if (!snapshot->propNames.empty() || snapshot->rawProps) {
                 PropsParserContext propsParserContext{
                     shadowNode.getSurfaceId(),
@@ -70,6 +74,12 @@ RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
                  .state = shadowNode.getState(),
                  .runtimeShadowNodeReference = true});
           }));
+
+  if (clonedRootShadowNode == nullptr) {
+    return newRootShadowNode;
+  }
+
+  return clonedRootShadowNode;
 }
 
 } // namespace facebook::react

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

@@ -19,7 +19,7 @@ class AnimationBackendCommitHook : public UIManagerCommitHook {
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
 
  public:
-  AnimationBackendCommitHook(UIManager *uiManager, std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry);
+  AnimationBackendCommitHook(UIManager &uiManager, std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry);
   RootShadowNode::Unshared shadowTreeWillCommit(
       const ShadowTree &shadowTree,
       const RootShadowNode::Shared &oldRootShadowNode,

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

@@ -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.
+ */
+
+#pragma once
+
+#include <react/renderer/uimanager/UIManagerAnimationBackend.h>
+
+namespace facebook::react {
+
+/*
+ * This class serves as an interface for native animation frame scheduling that can be used as abstraction in
+ * ReactCxxPlatform.
+ */
+class AnimationChoreographer {
+ public:
+  virtual ~AnimationChoreographer() = default;
+
+  virtual void resume() = 0;
+  virtual void pause() = 0;
+  void setAnimationBackend(std::weak_ptr<UIManagerAnimationBackend> animationBackend)
+  {
+    animationBackend_ = animationBackend;
+  }
+  void onAnimationFrame(AnimationTimestamp timestamp) const
+  {
+    if (auto animationBackend = animationBackend_.lock()) {
+      animationBackend->onAnimationFrame(timestamp);
+    }
+  }
+
+ private:
+  std::weak_ptr<UIManagerAnimationBackend> animationBackend_;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/CMakeLists.txt

@@ -20,7 +20,6 @@ target_link_libraries(react_renderer_animationbackend
       react_renderer_graphics
       react_renderer_mounting
       react_renderer_uimanager
-      react_renderer_scheduler
       glog
       folly_runtime
 )

package/ReactCommon/react/renderer/animations/LayoutAnimationKeyFrameManager.cpp

@@ -256,8 +256,7 @@ LayoutAnimationKeyFrameManager::pullTransaction(
       //   Catch delete+create (reparenting) (this should be optimized away at
       //   the diffing level eventually?)
       // TODO: to prevent this step we could tag Remove/Insert mutations as
-      // being moves on the Differ level, since we know that there? We could use
-      // TinyMap here, but it's not exposed by Differentiator (yet).
+      // being moves on the Differ level, since we know that there?
       std::unordered_set<Tag> insertedTags;
       std::unordered_set<Tag> deletedTags;
       std::unordered_set<Tag>

package/ReactCommon/react/renderer/attributedstring/AttributedString.h

@@ -9,7 +9,6 @@
 
 #include <react/renderer/attributedstring/TextAttributes.h>
 #include <react/renderer/core/Sealable.h>
-#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
 #include <react/renderer/mounting/ShadowView.h>
 #include <react/utils/hash_combine.h>

package/ReactCommon/react/renderer/attributedstring/AttributedStringBox.cpp

@@ -79,10 +79,4 @@ bool operator==(
   }
 }
 
-bool operator!=(
-    const AttributedStringBox& lhs,
-    const AttributedStringBox& rhs) {
-  return !(lhs == rhs);
-}
-
 } // namespace facebook::react

package/ReactCommon/react/renderer/attributedstring/AttributedStringBox.h

@@ -58,7 +58,6 @@ class AttributedStringBox final {
 };
 
 bool operator==(const AttributedStringBox &lhs, const AttributedStringBox &rhs);
-bool operator!=(const AttributedStringBox &lhs, const AttributedStringBox &rhs);
 
 } // namespace facebook::react
 

package/ReactCommon/react/renderer/attributedstring/ParagraphAttributes.cpp

@@ -36,10 +36,6 @@ bool ParagraphAttributes::operator==(const ParagraphAttributes& rhs) const {
       floatEquality(minimumFontScale, rhs.minimumFontScale);
 }
 
-bool ParagraphAttributes::operator!=(const ParagraphAttributes& rhs) const {
-  return !(*this == rhs);
-}
-
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE

package/ReactCommon/react/renderer/attributedstring/ParagraphAttributes.h

@@ -83,7 +83,6 @@ class ParagraphAttributes : public DebugStringConvertible {
   std::optional<TextAlignmentVertical> textAlignVertical{};
 
   bool operator==(const ParagraphAttributes &rhs) const;
-  bool operator!=(const ParagraphAttributes &rhs) const;
 
 #pragma mark - DebugStringConvertible
 

package/ReactCommon/react/renderer/attributedstring/conversions.h

@@ -1076,6 +1076,66 @@ inline MapBuffer toMapBuffer(const FontVariant &fontVariant)
   if ((int)fontVariant & (int)FontVariant::ProportionalNums) {
     builder.putString(index++, "proportional-nums");
   }
+  if ((int)fontVariant & (int)FontVariant::StylisticOne) {
+    builder.putString(index++, "stylistic-one");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticTwo) {
+    builder.putString(index++, "stylistic-two");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticThree) {
+    builder.putString(index++, "stylistic-three");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticFour) {
+    builder.putString(index++, "stylistic-four");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticFive) {
+    builder.putString(index++, "stylistic-five");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticSix) {
+    builder.putString(index++, "stylistic-six");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticSeven) {
+    builder.putString(index++, "stylistic-seven");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticEight) {
+    builder.putString(index++, "stylistic-eight");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticNine) {
+    builder.putString(index++, "stylistic-nine");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticTen) {
+    builder.putString(index++, "stylistic-ten");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticEleven) {
+    builder.putString(index++, "stylistic-eleven");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticTwelve) {
+    builder.putString(index++, "stylistic-twelve");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticThirteen) {
+    builder.putString(index++, "stylistic-thirteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticFourteen) {
+    builder.putString(index++, "stylistic-fourteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticFifteen) {
+    builder.putString(index++, "stylistic-fifteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticSixteen) {
+    builder.putString(index++, "stylistic-sixteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticSeventeen) {
+    builder.putString(index++, "stylistic-seventeen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticEighteen) {
+    builder.putString(index++, "stylistic-eighteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticNineteen) {
+    builder.putString(index++, "stylistic-nineteen");
+  }
+  if ((int)fontVariant & (int)FontVariant::StylisticTwenty) {
+    builder.putString(index++, "stylistic-twenty");
+  }
 
   return builder.build();
 }

package/ReactCommon/react/renderer/componentregistry/componentNameByReactViewName.cpp

@@ -27,12 +27,10 @@ std::string componentNameByReactViewName(std::string viewName) {
   if (viewName == "Text") {
     return "Paragraph";
   }
-
-  // TODO T63839307: remove this condition after deleting TextInlineImage from
-  // old renderer code
-  if (viewName == "TextInlineImage") {
-    return "Image";
+  if (viewName == "SelectableText") {
+    return "SelectableParagraph";
   }
+
   if (viewName == "VirtualText") {
     return "Text";
   }

package/ReactCommon/react/renderer/components/image/ImageProps.h

@@ -37,7 +37,7 @@ class ImageProps final : public ViewProps {
   Float resizeMultiplier{1.f};
   bool shouldNotifyLoadEvents{};
   SharedColor overlayColor{};
-  Float fadeDuration{};
+  Float fadeDuration{300.f};
   bool progressiveRenderingEnabled{};
 
 #ifdef RN_SERIALIZABLE_STATE

package/ReactCommon/react/renderer/components/legacyviewmanagerinterop/{LegacyViewManagerInteropComponentDescriptor.mm → platform/ios/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.mm}

@@ -14,9 +14,9 @@
 #include <React/RCTEventDispatcher.h>
 #include <React/RCTModuleData.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.h>
 #include <react/utils/ContextContainer.h>
 #include <react/utils/ManagedObjectWrapper.h>
-#include "LegacyViewManagerInteropState.h"
 #include "RCTLegacyViewManagerInteropCoordinator.h"
 
 namespace facebook::react {

package/ReactCommon/react/renderer/components/legacyviewmanagerinterop/{LegacyViewManagerInteropState.mm → platform/ios/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.mm}

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "LegacyViewManagerInteropState.h"
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.h>
 
 namespace facebook::react {
 } // namespace facebook::react