react-native-tvos 0.77.1-0 → 0.78.0-0

package/React/FBReactNativeSpec/FBReactNativeSpecJSI.h

@@ -25,8 +25,7 @@ public:
   virtual bool completeReactInstanceCreationOnBgThreadOnAndroid(jsi::Runtime &rt) = 0;
   virtual bool disableEventLoopOnBridgeless(jsi::Runtime &rt) = 0;
   virtual bool disableMountItemReorderingAndroid(jsi::Runtime &rt) = 0;
-  virtual bool enableAlignItemsBaselineOnFabricIOS(jsi::Runtime &rt) = 0;
-  virtual bool enableAndroidLineHeightCentering(jsi::Runtime &rt) = 0;
+  virtual bool enableAccumulatedUpdatesInRawPropsAndroid(jsi::Runtime &rt) = 0;
   virtual bool enableBridgelessArchitecture(jsi::Runtime &rt) = 0;
   virtual bool enableCppPropsIteratorSetter(jsi::Runtime &rt) = 0;
   virtual bool enableDeletionOfUnmountedViews(jsi::Runtime &rt) = 0;
@@ -34,10 +33,10 @@ public:
   virtual bool enableEventEmitterRetentionDuringGesturesOnAndroid(jsi::Runtime &rt) = 0;
   virtual bool enableFabricLogs(jsi::Runtime &rt) = 0;
   virtual bool enableFabricRenderer(jsi::Runtime &rt) = 0;
-  virtual bool enableFabricRendererExclusively(jsi::Runtime &rt) = 0;
   virtual bool enableFixForViewCommandRace(jsi::Runtime &rt) = 0;
   virtual bool enableGranularShadowTreeStateReconciliation(jsi::Runtime &rt) = 0;
   virtual bool enableIOSViewClipToPaddingBox(jsi::Runtime &rt) = 0;
+  virtual bool enableImagePrefetchingAndroid(jsi::Runtime &rt) = 0;
   virtual bool enableLayoutAnimationsOnAndroid(jsi::Runtime &rt) = 0;
   virtual bool enableLayoutAnimationsOnIOS(jsi::Runtime &rt) = 0;
   virtual bool enableLongTaskAPI(jsi::Runtime &rt) = 0;
@@ -49,9 +48,9 @@ public:
   virtual bool enableUIConsistency(jsi::Runtime &rt) = 0;
   virtual bool enableViewRecycling(jsi::Runtime &rt) = 0;
   virtual bool excludeYogaFromRawProps(jsi::Runtime &rt) = 0;
+  virtual bool fixDifferentiatorEmittingUpdatesWithWrongParentTag(jsi::Runtime &rt) = 0;
   virtual bool fixMappingOfEventPrioritiesBetweenFabricAndReact(jsi::Runtime &rt) = 0;
   virtual bool fixMountingCoordinatorReportedPendingTransactionsOnAndroid(jsi::Runtime &rt) = 0;
-  virtual bool fuseboxEnabledDebug(jsi::Runtime &rt) = 0;
   virtual bool fuseboxEnabledRelease(jsi::Runtime &rt) = 0;
   virtual bool initEagerTurboModulesOnNativeModulesQueueAndroid(jsi::Runtime &rt) = 0;
   virtual bool lazyAnimationCallbacks(jsi::Runtime &rt) = 0;
@@ -63,6 +62,7 @@ public:
   virtual bool useNativeViewConfigsInBridgelessMode(jsi::Runtime &rt) = 0;
   virtual bool useOptimisedViewPreallocationOnAndroid(jsi::Runtime &rt) = 0;
   virtual bool useOptimizedEventBatchingOnAndroid(jsi::Runtime &rt) = 0;
+  virtual bool useRawPropsJsiValue(jsi::Runtime &rt) = 0;
   virtual bool useRuntimeShadowNodeReferenceUpdate(jsi::Runtime &rt) = 0;
   virtual bool useTurboModuleInterop(jsi::Runtime &rt) = 0;
   virtual bool useTurboModules(jsi::Runtime &rt) = 0;
@@ -136,21 +136,13 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::disableMountItemReorderingAndroid, jsInvoker_, instance_);
     }
-    bool enableAlignItemsBaselineOnFabricIOS(jsi::Runtime &rt) override {
+    bool enableAccumulatedUpdatesInRawPropsAndroid(jsi::Runtime &rt) override {
       static_assert(
-          bridging::getParameterCount(&T::enableAlignItemsBaselineOnFabricIOS) == 1,
-          "Expected enableAlignItemsBaselineOnFabricIOS(...) to have 1 parameters");
+          bridging::getParameterCount(&T::enableAccumulatedUpdatesInRawPropsAndroid) == 1,
+          "Expected enableAccumulatedUpdatesInRawPropsAndroid(...) to have 1 parameters");
 
       return bridging::callFromJs<bool>(
-          rt, &T::enableAlignItemsBaselineOnFabricIOS, jsInvoker_, instance_);
-    }
-    bool enableAndroidLineHeightCentering(jsi::Runtime &rt) override {
-      static_assert(
-          bridging::getParameterCount(&T::enableAndroidLineHeightCentering) == 1,
-          "Expected enableAndroidLineHeightCentering(...) to have 1 parameters");
-
-      return bridging::callFromJs<bool>(
-          rt, &T::enableAndroidLineHeightCentering, jsInvoker_, instance_);
+          rt, &T::enableAccumulatedUpdatesInRawPropsAndroid, jsInvoker_, instance_);
     }
     bool enableBridgelessArchitecture(jsi::Runtime &rt) override {
       static_assert(
@@ -208,14 +200,6 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::enableFabricRenderer, jsInvoker_, instance_);
     }
-    bool enableFabricRendererExclusively(jsi::Runtime &rt) override {
-      static_assert(
-          bridging::getParameterCount(&T::enableFabricRendererExclusively) == 1,
-          "Expected enableFabricRendererExclusively(...) to have 1 parameters");
-
-      return bridging::callFromJs<bool>(
-          rt, &T::enableFabricRendererExclusively, jsInvoker_, instance_);
-    }
     bool enableFixForViewCommandRace(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::enableFixForViewCommandRace) == 1,
@@ -240,6 +224,14 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::enableIOSViewClipToPaddingBox, jsInvoker_, instance_);
     }
+    bool enableImagePrefetchingAndroid(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::enableImagePrefetchingAndroid) == 1,
+          "Expected enableImagePrefetchingAndroid(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::enableImagePrefetchingAndroid, jsInvoker_, instance_);
+    }
     bool enableLayoutAnimationsOnAndroid(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::enableLayoutAnimationsOnAndroid) == 1,
@@ -328,6 +320,14 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::excludeYogaFromRawProps, jsInvoker_, instance_);
     }
+    bool fixDifferentiatorEmittingUpdatesWithWrongParentTag(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::fixDifferentiatorEmittingUpdatesWithWrongParentTag) == 1,
+          "Expected fixDifferentiatorEmittingUpdatesWithWrongParentTag(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::fixDifferentiatorEmittingUpdatesWithWrongParentTag, jsInvoker_, instance_);
+    }
     bool fixMappingOfEventPrioritiesBetweenFabricAndReact(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::fixMappingOfEventPrioritiesBetweenFabricAndReact) == 1,
@@ -344,14 +344,6 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::fixMountingCoordinatorReportedPendingTransactionsOnAndroid, jsInvoker_, instance_);
     }
-    bool fuseboxEnabledDebug(jsi::Runtime &rt) override {
-      static_assert(
-          bridging::getParameterCount(&T::fuseboxEnabledDebug) == 1,
-          "Expected fuseboxEnabledDebug(...) to have 1 parameters");
-
-      return bridging::callFromJs<bool>(
-          rt, &T::fuseboxEnabledDebug, jsInvoker_, instance_);
-    }
     bool fuseboxEnabledRelease(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::fuseboxEnabledRelease) == 1,
@@ -440,6 +432,14 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::useOptimizedEventBatchingOnAndroid, jsInvoker_, instance_);
     }
+    bool useRawPropsJsiValue(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::useRawPropsJsiValue) == 1,
+          "Expected useRawPropsJsiValue(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::useRawPropsJsiValue, jsInvoker_, instance_);
+    }
     bool useRuntimeShadowNodeReferenceUpdate(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::useRuntimeShadowNodeReferenceUpdate) == 1,
@@ -2422,6 +2422,69 @@ private:
 };
 
 
+  class JSI_EXPORT NativeCPUTimeCxxSpecJSI : public TurboModule {
+protected:
+  NativeCPUTimeCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual double getCPUTimeNanos(jsi::Runtime &rt) = 0;
+  virtual bool hasAccurateCPUTimeNanosForBenchmarks(jsi::Runtime &rt) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeCPUTimeCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "CPUTimeCxx";
+
+protected:
+  NativeCPUTimeCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeCPUTimeCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativeCPUTimeCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeCPUTimeCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    double getCPUTimeNanos(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::getCPUTimeNanos) == 1,
+          "Expected getCPUTimeNanos(...) to have 1 parameters");
+
+      return bridging::callFromJs<double>(
+          rt, &T::getCPUTimeNanos, jsInvoker_, instance_);
+    }
+    bool hasAccurateCPUTimeNanosForBenchmarks(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::hasAccurateCPUTimeNanosForBenchmarks) == 1,
+          "Expected hasAccurateCPUTimeNanosForBenchmarks(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::hasAccurateCPUTimeNanosForBenchmarks, jsInvoker_, instance_);
+    }
+
+  private:
+    friend class NativeCPUTimeCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+
   class JSI_EXPORT NativeDeviceEventManagerCxxSpecJSI : public TurboModule {
 protected:
   NativeDeviceEventManagerCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
@@ -3488,6 +3551,152 @@ private:
 };
 
 
+  
+#pragma mark - NativeFantomRenderFormatOptions
+
+template <typename P0, typename P1>
+struct NativeFantomRenderFormatOptions {
+  P0 includeRoot;
+  P1 includeLayoutMetrics;
+  bool operator==(const NativeFantomRenderFormatOptions &other) const {
+    return includeRoot == other.includeRoot && includeLayoutMetrics == other.includeLayoutMetrics;
+  }
+};
+
+template <typename T>
+struct NativeFantomRenderFormatOptionsBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.includeRoot)>(rt, value.getProperty(rt, "includeRoot"), jsInvoker),
+      bridging::fromJs<decltype(types.includeLayoutMetrics)>(rt, value.getProperty(rt, "includeLayoutMetrics"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static bool includeRootToJs(jsi::Runtime &rt, decltype(types.includeRoot) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static bool includeLayoutMetricsToJs(jsi::Runtime &rt, decltype(types.includeLayoutMetrics) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "includeRoot", bridging::toJs(rt, value.includeRoot, jsInvoker));
+    result.setProperty(rt, "includeLayoutMetrics", bridging::toJs(rt, value.includeLayoutMetrics, jsInvoker));
+    return result;
+  }
+};
+
+class JSI_EXPORT NativeFantomCxxSpecJSI : public TurboModule {
+protected:
+  NativeFantomCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual void startSurface(jsi::Runtime &rt, double surfaceId, double viewportWidth, double viewportHeight, double devicePixelRatio) = 0;
+  virtual void stopSurface(jsi::Runtime &rt, double surfaceId) = 0;
+  virtual jsi::Array getMountingManagerLogs(jsi::Runtime &rt, double surfaceId) = 0;
+  virtual void flushMessageQueue(jsi::Runtime &rt) = 0;
+  virtual jsi::String getRenderedOutput(jsi::Runtime &rt, double surfaceId, jsi::Object config) = 0;
+  virtual void reportTestSuiteResultsJSON(jsi::Runtime &rt, jsi::String results) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeFantomCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "NativeFantomCxx";
+
+protected:
+  NativeFantomCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeFantomCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativeFantomCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeFantomCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    void startSurface(jsi::Runtime &rt, double surfaceId, double viewportWidth, double viewportHeight, double devicePixelRatio) override {
+      static_assert(
+          bridging::getParameterCount(&T::startSurface) == 5,
+          "Expected startSurface(...) to have 5 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::startSurface, jsInvoker_, instance_, std::move(surfaceId), std::move(viewportWidth), std::move(viewportHeight), std::move(devicePixelRatio));
+    }
+    void stopSurface(jsi::Runtime &rt, double surfaceId) override {
+      static_assert(
+          bridging::getParameterCount(&T::stopSurface) == 2,
+          "Expected stopSurface(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::stopSurface, jsInvoker_, instance_, std::move(surfaceId));
+    }
+    jsi::Array getMountingManagerLogs(jsi::Runtime &rt, double surfaceId) override {
+      static_assert(
+          bridging::getParameterCount(&T::getMountingManagerLogs) == 2,
+          "Expected getMountingManagerLogs(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Array>(
+          rt, &T::getMountingManagerLogs, jsInvoker_, instance_, std::move(surfaceId));
+    }
+    void flushMessageQueue(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::flushMessageQueue) == 1,
+          "Expected flushMessageQueue(...) to have 1 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::flushMessageQueue, jsInvoker_, instance_);
+    }
+    jsi::String getRenderedOutput(jsi::Runtime &rt, double surfaceId, jsi::Object config) override {
+      static_assert(
+          bridging::getParameterCount(&T::getRenderedOutput) == 3,
+          "Expected getRenderedOutput(...) to have 3 parameters");
+
+      return bridging::callFromJs<jsi::String>(
+          rt, &T::getRenderedOutput, jsInvoker_, instance_, std::move(surfaceId), std::move(config));
+    }
+    void reportTestSuiteResultsJSON(jsi::Runtime &rt, jsi::String results) override {
+      static_assert(
+          bridging::getParameterCount(&T::reportTestSuiteResultsJSON) == 2,
+          "Expected reportTestSuiteResultsJSON(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::reportTestSuiteResultsJSON, jsInvoker_, instance_, std::move(results));
+    }
+
+  private:
+    friend class NativeFantomCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+
   class JSI_EXPORT NativeFileReaderModuleCxxSpecJSI : public TurboModule {
 protected:
   NativeFileReaderModuleCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
@@ -4511,60 +4720,6 @@ private:
 };
 
 
-  class JSI_EXPORT NativeJSCSamplingProfilerCxxSpecJSI : public TurboModule {
-protected:
-  NativeJSCSamplingProfilerCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
-
-public:
-  virtual void operationComplete(jsi::Runtime &rt, double token, std::optional<jsi::String> result, std::optional<jsi::String> error) = 0;
-
-};
-
-template <typename T>
-class JSI_EXPORT NativeJSCSamplingProfilerCxxSpec : public TurboModule {
-public:
-  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
-    return delegate_.create(rt, propName);
-  }
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
-    return delegate_.getPropertyNames(runtime);
-  }
-
-  static constexpr std::string_view kModuleName = "JSCSamplingProfiler";
-
-protected:
-  NativeJSCSamplingProfilerCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule(std::string{NativeJSCSamplingProfilerCxxSpec::kModuleName}, jsInvoker),
-      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
-
-
-private:
-  class Delegate : public NativeJSCSamplingProfilerCxxSpecJSI {
-  public:
-    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
-      NativeJSCSamplingProfilerCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
-
-    }
-
-    void operationComplete(jsi::Runtime &rt, double token, std::optional<jsi::String> result, std::optional<jsi::String> error) override {
-      static_assert(
-          bridging::getParameterCount(&T::operationComplete) == 4,
-          "Expected operationComplete(...) to have 4 parameters");
-
-      return bridging::callFromJs<void>(
-          rt, &T::operationComplete, jsInvoker_, instance_, std::move(token), std::move(result), std::move(error));
-    }
-
-  private:
-    friend class NativeJSCSamplingProfilerCxxSpec;
-    T *instance_;
-  };
-
-  Delegate delegate_;
-};
-
-
   class JSI_EXPORT NativeKeyboardObserverCxxSpecJSI : public TurboModule {
 protected:
   NativeKeyboardObserverCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
@@ -7989,8 +8144,6 @@ protected:
 
 public:
   virtual double now(jsi::Runtime &rt) = 0;
-  virtual void mark(jsi::Runtime &rt, jsi::String name, double startTime) = 0;
-  virtual void measure(jsi::Runtime &rt, jsi::String name, double startTime, double endTime, std::optional<double> duration, std::optional<jsi::String> startMark, std::optional<jsi::String> endMark) = 0;
   virtual double markWithResult(jsi::Runtime &rt, jsi::String name, std::optional<double> startTime) = 0;
   virtual jsi::Array measureWithResult(jsi::Runtime &rt, jsi::String name, double startTime, double endTime, std::optional<double> duration, std::optional<jsi::String> startMark, std::optional<jsi::String> endMark) = 0;
   virtual void clearMarks(jsi::Runtime &rt, std::optional<jsi::String> entryName) = 0;
@@ -8045,22 +8198,6 @@ private:
       return bridging::callFromJs<double>(
           rt, &T::now, jsInvoker_, instance_);
     }
-    void mark(jsi::Runtime &rt, jsi::String name, double startTime) override {
-      static_assert(
-          bridging::getParameterCount(&T::mark) == 3,
-          "Expected mark(...) to have 3 parameters");
-
-      return bridging::callFromJs<void>(
-          rt, &T::mark, jsInvoker_, instance_, std::move(name), std::move(startTime));
-    }
-    void measure(jsi::Runtime &rt, jsi::String name, double startTime, double endTime, std::optional<double> duration, std::optional<jsi::String> startMark, std::optional<jsi::String> endMark) override {
-      static_assert(
-          bridging::getParameterCount(&T::measure) == 7,
-          "Expected measure(...) to have 7 parameters");
-
-      return bridging::callFromJs<void>(
-          rt, &T::measure, jsInvoker_, instance_, std::move(name), std::move(startTime), std::move(endTime), std::move(duration), std::move(startMark), std::move(endMark));
-    }
     double markWithResult(jsi::Runtime &rt, jsi::String name, std::optional<double> startTime) override {
       static_assert(
           bridging::getParameterCount(&T::markWithResult) == 3,

package/React/Fabric/Mounting/ComponentViews/InputAccessory/RCTInputAccessoryContentView.mm

@@ -53,9 +53,4 @@
   [self layoutIfNeeded];
 }
 
-- (BOOL)canBecomeFirstResponder
-{
-  return true;
-}
-
 @end

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.mm

@@ -67,28 +67,52 @@
  * ScrollView, we force it to be centered, but when you zoom or the content otherwise
  * becomes larger than the ScrollView, there is no padding around the content but it
  * can still fill the whole view.
+ * This implementation is based on https://petersteinberger.com/blog/2013/how-to-center-uiscrollview/.
  */
-- (void)setContentOffset:(CGPoint)contentOffset
+- (void)centerContentIfNeeded
 {
-  if (_isSetContentOffsetDisabled) {
+  if (!_centerContent) {
     return;
   }
 
-  if (_centerContent && !CGSizeEqualToSize(self.contentSize, CGSizeZero)) {
-    CGSize scrollViewSize = self.bounds.size;
-    if (self.contentSize.width <= scrollViewSize.width) {
-      contentOffset.x = -(scrollViewSize.width - self.contentSize.width) / 2.0;
-    }
-    if (self.contentSize.height <= scrollViewSize.height) {
-      contentOffset.y = -(scrollViewSize.height - self.contentSize.height) / 2.0;
-    }
+  CGSize contentSize = self.contentSize;
+  CGSize boundsSize = self.bounds.size;
+  if (CGSizeEqualToSize(contentSize, CGSizeZero) || CGSizeEqualToSize(boundsSize, CGSizeZero)) {
+    return;
+  }
+
+  CGFloat top = 0, left = 0;
+  if (contentSize.width < boundsSize.width) {
+    left = (boundsSize.width - contentSize.width) * 0.5f;
+  }
+  if (contentSize.height < boundsSize.height) {
+    top = (boundsSize.height - contentSize.height) * 0.5f;
   }
+  self.contentInset = UIEdgeInsetsMake(top, left, top, left);
+}
 
+- (void)setContentOffset:(CGPoint)contentOffset
+{
+  if (_isSetContentOffsetDisabled) {
+    return;
+  }
   super.contentOffset = CGPointMake(
       RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
       RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
 }
 
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+  [self centerContentIfNeeded];
+}
+
+- (void)didAddSubview:(UIView *)subview
+{
+  [super didAddSubview:subview];
+  [self centerContentIfNeeded];
+}
+
 - (BOOL)touchesShouldCancelInContentView:(UIView *)view
 {
   if ([_overridingDelegate respondsToSelector:@selector(touchesShouldCancelInContentView:)]) {
@@ -258,6 +282,11 @@
   }
 }
 
+- (void)scrollViewDidZoom:(__unused UIScrollView *)scrollView
+{
+  [self centerContentIfNeeded];
+}
+
 #pragma mark -
 
 - (BOOL)isHorizontal:(UIScrollView *)scrollView

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTPullToRefreshViewComponentView.mm

@@ -155,10 +155,10 @@ using namespace facebook::react;
 
 #pragma mark - Attaching & Detaching
 
-- (void)didMoveToWindow
+- (void)didMoveToSuperview
 {
-  [super didMoveToWindow];
-  if (self.window) {
+  [super didMoveToSuperview];
+  if (self.superview) {
     [self _attach];
   } else {
     [self _detach];

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -565,6 +565,17 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
   return metrics;
 }
 
+- (ScrollViewEventEmitter::EndDragMetrics)_scrollViewMetricsWithVelocity:(CGPoint)velocity
+                                                  andTargetContentOffset:(CGPoint)targetContentOffset
+{
+  ScrollViewEventEmitter::EndDragMetrics metrics = [self _scrollViewMetrics];
+  metrics.targetContentOffset.x = targetContentOffset.x;
+  metrics.targetContentOffset.y = targetContentOffset.y;
+  metrics.velocity.x = velocity.x;
+  metrics.velocity.y = velocity.y;
+  return metrics;
+}
+
 - (void)_updateStateWithContentOffset
 {
   if (!_state) {
@@ -620,6 +631,14 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
       targetContentOffset->y = scrollView.contentOffset.y + travel * _endDraggingSensitivityMultiplier;
     }
   }
+
+  if (!_eventEmitter) {
+    return;
+  }
+
+  auto metrics = [self _scrollViewMetricsWithVelocity:velocity andTargetContentOffset:*targetContentOffset];
+
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag(metrics);
 }
 
 - (BOOL)touchesShouldCancelInContentView:(__unused UIView *)view
@@ -690,8 +709,6 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     return;
   }
 
-  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag([self _scrollViewMetrics]);
-
   [self _updateStateWithContentOffset];
 
   if (!decelerate) {
@@ -788,7 +805,9 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     return;
   }
 
-  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag([self _scrollViewMetrics]);
+  auto metrics = [self _scrollViewMetricsWithVelocity:{} andTargetContentOffset:{}];
+  static_cast<const ScrollViewEventEmitter &>(*_eventEmitter).onScrollEndDrag(metrics);
+
   [self _updateStateWithContentOffset];
 }
 

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm

@@ -285,6 +285,11 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
     _backedTextInputView.inputAccessoryViewButtonLabel =
         RCTNSStringFromString(newTextInputProps.inputAccessoryViewButtonLabel);
   }
+
+  if (newTextInputProps.disableKeyboardShortcuts != oldTextInputProps.disableKeyboardShortcuts) {
+    _backedTextInputView.disableKeyboardShortcuts = newTextInputProps.disableKeyboardShortcuts;
+  }
+
   [super updateProps:props oldProps:oldProps];
 
   [self setDefaultInputAccessoryView];

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputUtils.mm

@@ -45,6 +45,7 @@ void RCTCopyBackedTextInput(
   toTextInput.textContentType = fromTextInput.textContentType;
   toTextInput.smartInsertDeleteType = fromTextInput.smartInsertDeleteType;
   toTextInput.passwordRules = fromTextInput.passwordRules;
+  toTextInput.disableKeyboardShortcuts = fromTextInput.disableKeyboardShortcuts;
 
   [toTextInput setSelectedTextRange:fromTextInput.selectedTextRange notifyDelegate:NO];
 }

package/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -1509,7 +1509,8 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 #endif
   const bool useCoreAnimationBorderRendering =
       borderMetrics.borderColors.isUniform() && borderMetrics.borderWidths.isUniform() &&
-      borderMetrics.borderStyles.isUniform() && borderMetrics.borderRadii.isUniform() &&
+      borderMetrics.borderStyles.isUniform() && borderMetrics.borderStyles.left == BorderStyle::Solid &&
+      borderMetrics.borderRadii.isUniform() &&
       (
           // iOS draws borders in front of the content whereas CSS draws them behind
           // the content. For this reason, only use iOS border drawing when clipping
@@ -1779,13 +1780,17 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 
 static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 {
-  NSMutableString *result = [NSMutableString stringWithString:@""];
+  // Result string is initialized lazily to prevent useless but costly allocations.
+  NSMutableString *result = nil;
   for (UIView *subview in view.subviews) {
     NSString *label = subview.accessibilityLabel;
     if (!label) {
       label = RCTRecursiveAccessibilityLabel(subview);
     }
     if (label && label.length > 0) {
+      if (result == nil) {
+        result = [NSMutableString string];
+      }
       if (result.length > 0) {
         [result appendString:@" "];
       }

package/React/Fabric/Mounting/RCTComponentViewFactory.mm

@@ -19,6 +19,7 @@
 #import <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #import <react/renderer/componentregistry/componentNameByReactViewName.h>
 #import <react/renderer/componentregistry/native/NativeComponentRegistryBinding.h>
+#import <react/renderer/components/view/LayoutConformanceComponentDescriptor.h>
 #import <react/renderer/core/PropsParserContext.h>
 #import <react/renderer/core/ReactPrimitives.h>
 
@@ -75,6 +76,8 @@ static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char
     componentViewFactory = [RCTComponentViewFactory new];
     [componentViewFactory registerComponentViewClass:[RCTRootComponentView class]];
     [componentViewFactory registerComponentViewClass:[RCTParagraphComponentView class]];
+    componentViewFactory->_providerRegistry.add(
+        concreteComponentDescriptorProvider<LayoutConformanceComponentDescriptor>());
 
     componentViewFactory->_providerRegistry.setComponentDescriptorProviderRequest(
         [](ComponentName requestedComponentName) {