react-native 0.0.0-263478b91 → 0.0.0-268efb102

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

@@ -24,14 +24,19 @@ using namespace facebook::react;
   CALayer *_borderLayer;
   BOOL _needsInvalidateLayer;
   BOOL _isJSResponder;
+  BOOL _removeClippedSubviews;
+  NSMutableArray<UIView *> *_reactSubviews;
   NSSet<NSString *> *_Nullable _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
 }
 
+@synthesize removeClippedSubviews = _removeClippedSubviews;
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {
     static auto const defaultProps = std::make_shared<ViewProps const>();
     _props = defaultProps;
+    _reactSubviews = [NSMutableArray new];
     self.multipleTouchEnabled = YES;
   }
   return self;
@@ -86,6 +91,81 @@ using namespace facebook::react;
   return concreteComponentDescriptorProvider<ViewComponentDescriptor>();
 }
 
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RCTAssert(
+      childComponentView.superview == nil,
+      @"Attempt to mount already mounted component view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+      self,
+      childComponentView,
+      @(index),
+      @([childComponentView.superview tag]));
+
+  if (_removeClippedSubviews) {
+    [_reactSubviews insertObject:childComponentView atIndex:index];
+  } else {
+    [self insertSubview:childComponentView atIndex:index];
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  if (_removeClippedSubviews) {
+    [_reactSubviews removeObjectAtIndex:index];
+  } else {
+    RCTAssert(
+        childComponentView.superview == self,
+        @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+        self,
+        childComponentView,
+        @(index));
+    RCTAssert(
+        (self.subviews.count > index) && [self.subviews objectAtIndex:index] == childComponentView,
+        @"Attempt to unmount a view which has a different index. (parent: %@, child: %@, index: %@, actual index: %@, tag at index: %@)",
+        self,
+        childComponentView,
+        @(index),
+        @([self.subviews indexOfObject:childComponentView]),
+        @([[self.subviews objectAtIndex:index] tag]));
+  }
+
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
+{
+  if (!_removeClippedSubviews) {
+    // Use default behavior if unmounting is disabled
+    return [super updateClippedSubviewsWithClipRect:clipRect relativeToView:clipView];
+  }
+
+  if (_reactSubviews.count == 0) {
+    // Do nothing if we have no subviews
+    return;
+  }
+
+  if (CGSizeEqualToSize(self.bounds.size, CGSizeZero)) {
+    // Do nothing if layout hasn't happened yet
+    return;
+  }
+
+  // Convert clipping rect to local coordinates
+  clipRect = [clipView convertRect:clipRect toView:self];
+
+  // Mount / unmount views
+  for (UIView *view in _reactSubviews) {
+    if (CGRectIntersectsRect(clipRect, view.frame)) {
+      // View is at least partially visible, so remount it if unmounted
+      [self addSubview:view];
+      // View is visible, update clipped subviews
+      [view updateClippedSubviewsWithClipRect:clipRect relativeToView:self];
+    } else if (view.superview) {
+      // View is completely outside the clipRect, so unmount it
+      [view removeFromSuperview];
+    }
+  }
+}
+
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
 {
   RCTAssert(props, @"`props` must not be `null`.");
@@ -113,6 +193,14 @@ using namespace facebook::react;
     needsInvalidateLayer = YES;
   }
 
+  if (RCTGetRemoveClippedSubviewsEnabled() &&
+      oldViewProps.removeClippedSubviews != newViewProps.removeClippedSubviews) {
+    _removeClippedSubviews = newViewProps.removeClippedSubviews;
+    if (_removeClippedSubviews && self.subviews.count > 0) {
+      _reactSubviews = [NSMutableArray arrayWithArray:self.subviews];
+    }
+  }
+
   // `backgroundColor`
   if (oldViewProps.backgroundColor != newViewProps.backgroundColor) {
     self.backgroundColor = RCTUIColorFromSharedColor(newViewProps.backgroundColor);
@@ -243,11 +331,25 @@ using namespace facebook::react;
 
   // `accessibilityIgnoresInvertColors`
   if (oldViewProps.accessibilityIgnoresInvertColors != newViewProps.accessibilityIgnoresInvertColors) {
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* __IPHONE_11_0 */
-    if (@available(iOS 11.0, *)) {
-      self.accessibilityIgnoresInvertColors = newViewProps.accessibilityIgnoresInvertColors;
+    self.accessibilityIgnoresInvertColors = newViewProps.accessibilityIgnoresInvertColors;
+  }
+
+  // `accessibilityValue`
+  if (oldViewProps.accessibilityValue != newViewProps.accessibilityValue) {
+    if (newViewProps.accessibilityValue.text.hasValue()) {
+      self.accessibilityElement.accessibilityValue =
+          RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityValue.text.value());
+    } else if (
+        newViewProps.accessibilityValue.now.hasValue() && newViewProps.accessibilityValue.min.hasValue() &&
+        newViewProps.accessibilityValue.max.hasValue()) {
+      CGFloat val = (CGFloat)(newViewProps.accessibilityValue.now.value()) /
+          (newViewProps.accessibilityValue.max.value() - newViewProps.accessibilityValue.min.value());
+      self.accessibilityElement.accessibilityValue =
+          [NSNumberFormatter localizedStringFromNumber:@(val) numberStyle:NSNumberFormatterPercentStyle];
+      ;
+    } else {
+      self.accessibilityElement.accessibilityValue = nil;
     }
-#endif
   }
 
   // `testId`
@@ -322,6 +424,8 @@ using namespace facebook::react;
   _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;
   _eventEmitter.reset();
   _isJSResponder = NO;
+  _removeClippedSubviews = NO;
+  _reactSubviews = [NSMutableArray new];
 }
 
 - (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(NSSet<NSString *> *_Nullable)props
@@ -630,7 +734,7 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   NSMutableArray<UIAccessibilityCustomAction *> *customActions = [NSMutableArray array];
   for (auto const &accessibilityAction : accessibilityActions) {
     [customActions
-        addObject:[[UIAccessibilityCustomAction alloc] initWithName:RCTNSStringFromString(accessibilityAction)
+        addObject:[[UIAccessibilityCustomAction alloc] initWithName:RCTNSStringFromString(accessibilityAction.name)
                                                              target:self
                                                            selector:@selector(didActivateAccessibilityCustomAction:)]];
   }

package/React/Fabric/Mounting/RCTComponentViewFactory.mm

@@ -17,6 +17,7 @@
 #import <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #import <react/renderer/componentregistry/componentNameByReactViewName.h>
 #import <react/renderer/componentregistry/native/NativeComponentRegistryBinding.h>
+#import <react/renderer/core/PropsParserContext.h>
 #import <react/renderer/core/ReactPrimitives.h>
 
 #ifdef RN_DISABLE_OSS_PLUGIN_HEADER

package/React/Fabric/Mounting/RCTMountingManager.h

@@ -13,6 +13,7 @@
 #import <react/renderer/core/ReactPrimitives.h>
 #import <react/renderer/mounting/MountingCoordinator.h>
 #import <react/renderer/mounting/ShadowView.h>
+#import <react/utils/ContextContainer.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -26,6 +27,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak) id<RCTMountingManagerDelegate> delegate;
 @property (nonatomic, strong) RCTComponentViewRegistry *componentViewRegistry;
 
+- (void)setContextContainer:(facebook::react::ContextContainer::Shared)contextContainer;
+
 /**
  * Designates the view as a rendering viewport of a React Native surface.
  * The provided view must not have any subviews, and the caller is not supposed to interact with the view hierarchy

package/React/Fabric/Mounting/RCTMountingManager.mm

@@ -10,6 +10,7 @@
 #import <better/map.h>
 
 #import <React/RCTAssert.h>
+#import <React/RCTComponent.h>
 #import <React/RCTFollyConvert.h>
 #import <React/RCTLog.h>
 #import <React/RCTUtils.h>
@@ -26,6 +27,18 @@
 
 using namespace facebook::react;
 
+static SurfaceId RCTSurfaceIdForView(UIView *view)
+{
+  do {
+    if (RCTIsReactRootView(@(view.tag))) {
+      return view.tag;
+    }
+    view = view.superview;
+  } while (view != nil);
+
+  return -1;
+}
+
 static void RCTPerformMountInstructions(
     ShadowViewMutationList const &mutations,
     RCTComponentViewRegistry *registry,
@@ -136,6 +149,7 @@ static void RCTPerformMountInstructions(
   RCTMountingTransactionObserverCoordinator _observerCoordinator;
   BOOL _transactionInFlight;
   BOOL _followUpTransactionRequired;
+  ContextContainer::Shared _contextContainer;
 }
 
 - (instancetype)init
@@ -147,6 +161,11 @@ static void RCTPerformMountInstructions(
   return self;
 }
 
+- (void)setContextContainer:(ContextContainer::Shared)contextContainer
+{
+  _contextContainer = contextContainer;
+}
+
 - (void)attachSurfaceToView:(UIView *)view surfaceId:(SurfaceId)surfaceId
 {
   RCTAssertMainQueue();
@@ -276,8 +295,10 @@ static void RCTPerformMountInstructions(
 {
   RCTAssertMainQueue();
   UIView<RCTComponentViewProtocol> *componentView = [_componentViewRegistry findComponentViewWithTag:reactTag];
+  SurfaceId surfaceId = RCTSurfaceIdForView(componentView);
   SharedProps oldProps = [componentView props];
-  SharedProps newProps = componentDescriptor.cloneProps(oldProps, RawProps(convertIdToFollyDynamic(props)));
+  SharedProps newProps = componentDescriptor.cloneProps(
+      PropsParserContext{surfaceId, *_contextContainer.get()}, oldProps, RawProps(convertIdToFollyDynamic(props)));
 
   NSSet<NSString *> *propKeys = componentView.propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN ?: [NSSet new];
   propKeys = [propKeys setByAddingObjectsFromArray:props.allKeys];
@@ -290,11 +311,9 @@ static void RCTPerformMountInstructions(
   if (props[@"transform"] &&
       !CATransform3DEqualToTransform(
           RCTCATransform3DFromTransformMatrix(newViewProps.transform), componentView.layer.transform)) {
-    RCTLogWarn(@"transform was not applied during [RCTViewComponentView updateProps:oldProps:]");
     componentView.layer.transform = RCTCATransform3DFromTransformMatrix(newViewProps.transform);
   }
   if (props[@"opacity"] && componentView.layer.opacity != (float)newViewProps.opacity) {
-    RCTLogWarn(@"opacity was not applied during [RCTViewComponentView updateProps:oldProps:]");
     componentView.layer.opacity = newViewProps.opacity;
   }
 }

package/React/Fabric/Mounting/UIView+ComponentViewProtocol.h

@@ -44,6 +44,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(nullable NSSet<NSString *> *)props;
 - (nullable NSSet<NSString *> *)propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
 
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/React/Fabric/Mounting/UIView+ComponentViewProtocol.mm

@@ -156,4 +156,16 @@ using namespace facebook::react;
   return nil;
 }
 
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
+{
+  clipRect = [clipView convertRect:clipRect toView:self];
+
+  // Normal views don't support unmounting, so all
+  // this does is forward message to our subviews,
+  // in case any of those do support it
+  for (UIView *subview in self.subviews) {
+    [subview updateClippedSubviewsWithClipRect:clipRect relativeToView:self];
+  }
+}
+
 @end

package/React/Fabric/RCTConversions.h

@@ -141,6 +141,9 @@ inline UIAccessibilityTraits RCTUIAccessibilityTraitsFromAccessibilityTraits(
   if ((accessibilityTraits & AccessibilityTraits::Switch) != AccessibilityTraits::None) {
     result |= AccessibilityTraitSwitch;
   }
+  if ((accessibilityTraits & AccessibilityTraits::TabBar) != AccessibilityTraits::None) {
+    result |= UIAccessibilityTraitTabBar;
+  }
   return result;
 };
 

package/React/Fabric/RCTScheduler.mm

@@ -30,10 +30,19 @@ class SchedulerDelegateProxy : public SchedulerDelegate {
     [scheduler.delegate schedulerDidFinishTransaction:mountingCoordinator];
   }
 
-  void schedulerDidRequestPreliminaryViewAllocation(SurfaceId surfaceId, const ShadowView &shadowView) override
+  void schedulerDidRequestPreliminaryViewAllocation(SurfaceId surfaceId, const ShadowNode &shadowNode) override
   {
     // Does nothing.
-    // Preemptive allocation of native views on iOS does not require this call.
+    // This delegate method is not currently used on iOS.
+  }
+
+  void schedulerDidCloneShadowNode(
+      SurfaceId surfaceId,
+      const ShadowNode &oldShadowNode,
+      const ShadowNode &newShadowNode) override
+  {
+    // Does nothing.
+    // This delegate method is not currently used on iOS.
   }
 
   void schedulerDidDispatchCommand(
@@ -101,7 +110,6 @@ class LayoutAnimationDelegateProxy : public LayoutAnimationStatusDelegate, publi
   std::shared_ptr<SchedulerDelegateProxy> _delegateProxy;
   std::shared_ptr<LayoutAnimationDelegateProxy> _layoutAnimationDelegateProxy;
   RunLoopObserver::Unique _uiRunLoopObserver;
-  BOOL _layoutAnimationsEnabled;
 }
 
 - (instancetype)initWithToolbox:(SchedulerToolbox)toolbox
@@ -109,14 +117,22 @@ class LayoutAnimationDelegateProxy : public LayoutAnimationStatusDelegate, publi
   if (self = [super init]) {
     auto reactNativeConfig =
         toolbox.contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
-    _layoutAnimationsEnabled = reactNativeConfig->getBool("react_fabric:enabled_layout_animations_ios");
 
     _delegateProxy = std::make_shared<SchedulerDelegateProxy>((__bridge void *)self);
 
-    if (_layoutAnimationsEnabled) {
+    if (reactNativeConfig->getBool("react_fabric:enabled_layout_animations_ios")) {
       _layoutAnimationDelegateProxy = std::make_shared<LayoutAnimationDelegateProxy>((__bridge void *)self);
-      _animationDriver =
-          std::make_shared<LayoutAnimationDriver>(toolbox.runtimeExecutor, _layoutAnimationDelegateProxy.get());
+      _animationDriver = std::make_shared<LayoutAnimationDriver>(
+          toolbox.runtimeExecutor, toolbox.contextContainer, _layoutAnimationDelegateProxy.get());
+      if (reactNativeConfig->getBool("react_fabric:enabled_skip_invalidated_key_frames_ios")) {
+        _animationDriver->enableSkipInvalidatedKeyFrames();
+      }
+      if (reactNativeConfig->getBool("react_fabric:enable_crash_on_missing_component_descriptor")) {
+        _animationDriver->enableCrashOnMissingComponentDescriptor();
+      }
+      if (reactNativeConfig->getBool("react_fabric:enable_simulate_image_props_memory_access")) {
+        _animationDriver->enableSimulateImagePropsMemoryAccess();
+      }
       _uiRunLoopObserver =
           toolbox.mainRunLoopObserverFactory(RunLoopObserver::Activity::BeforeWaiting, _layoutAnimationDelegateProxy);
       _uiRunLoopObserver->setDelegate(_layoutAnimationDelegateProxy.get());

package/React/Fabric/RCTSurfacePresenter.mm

@@ -27,11 +27,8 @@
 
 #import <react/config/ReactNativeConfig.h>
 #import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
-#import <react/renderer/components/root/RootShadowNode.h>
-#import <react/renderer/core/LayoutConstraints.h>
-#import <react/renderer/core/LayoutContext.h>
+#import <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #import <react/renderer/scheduler/AsynchronousEventBeat.h>
-#import <react/renderer/scheduler/AsynchronousEventBeatV2.h>
 #import <react/renderer/scheduler/SchedulerToolbox.h>
 #import <react/renderer/scheduler/SynchronousEventBeat.h>
 #import <react/utils/ContextContainer.h>
@@ -91,12 +88,12 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
 {
   if (self = [super init]) {
     assert(contextContainer && "RuntimeExecutor must be not null.");
-
     _runtimeExecutor = runtimeExecutor;
     _contextContainer = contextContainer;
 
     _surfaceRegistry = [[RCTSurfaceRegistry alloc] init];
     _mountingManager = [[RCTMountingManager alloc] init];
+    _mountingManager.contextContainer = contextContainer;
     _mountingManager.delegate = self;
 
     _observers = [NSMutableArray array];
@@ -128,6 +125,7 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
 {
   std::lock_guard<std::mutex> lock(_schedulerLifeCycleMutex);
   _contextContainer = contextContainer;
+  _mountingManager.contextContainer = contextContainer;
 }
 
 - (RuntimeExecutor)runtimeExecutor
@@ -253,14 +251,14 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
 {
   auto reactNativeConfig = _contextContainer->at<std::shared_ptr<ReactNativeConfig const>>("ReactNativeConfig");
 
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:scrollview_on_demand_mounting_ios")) {
-    RCTExperimentSetOnDemandViewMounting(YES);
-  }
-
   if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:preemptive_view_allocation_disabled_ios")) {
     RCTExperimentSetPreemptiveViewAllocationDisabled(YES);
   }
 
+  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_remove_clipped_subviews_ios")) {
+    RCTSetRemoveClippedSubviewsEnabled(YES);
+  }
+
   auto componentRegistryFactory =
       [factory = wrapManagedObject(_mountingManager.componentViewRegistry.componentViewFactory)](
           EventDispatcher::Weak const &eventDispatcher, ContextContainer::Shared const &contextContainer) {
@@ -273,7 +271,19 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = _contextContainer;
   toolbox.componentRegistryFactory = componentRegistryFactory;
+
+  auto weakRuntimeScheduler = _contextContainer->find<std::weak_ptr<RuntimeScheduler>>("RuntimeScheduler");
+  auto runtimeScheduler = weakRuntimeScheduler.hasValue() ? weakRuntimeScheduler.value().lock() : nullptr;
+  if (runtimeScheduler) {
+    runtimeScheduler->setEnableYielding(
+        reactNativeConfig->getBool("react_native_new_architecture:runtimescheduler_enable_yielding_ios"));
+    runtimeExecutor = [runtimeScheduler](std::function<void(jsi::Runtime & runtime)> &&callback) {
+      runtimeScheduler->scheduleWork(std::move(callback));
+    };
+  }
+
   toolbox.runtimeExecutor = runtimeExecutor;
+
   toolbox.mainRunLoopObserverFactory = [](RunLoopObserver::Activity activities,
                                           RunLoopObserver::WeakOwner const &owner) {
     return std::make_unique<MainRunLoopObserver>(activities, owner);
@@ -283,37 +293,18 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
     toolbox.backgroundExecutor = RCTGetBackgroundExecutor();
   }
 
-#ifdef REACT_NATIVE_DEBUG
-  auto optionalBridge = _contextContainer->find<std::shared_ptr<void>>("Bridge");
-  if (optionalBridge) {
-    RCTBridge *bridge = unwrapManagedObjectWeakly(optionalBridge.value());
-    toolbox.garbageCollectionTrigger = [bridge]() {
-      RCTCxxBridge *batchedBridge = (RCTCxxBridge *)([bridge batchedBridge] ?: bridge);
-      if ([batchedBridge respondsToSelector:@selector(forceGarbageCollection)]) {
-        [batchedBridge forceGarbageCollection];
-      }
-    };
-  }
-#endif
-
-  toolbox.synchronousEventBeatFactory = [runtimeExecutor](EventBeat::SharedOwnerBox const &ownerBox) {
-    auto runLoopObserver =
-        std::make_unique<MainRunLoopObserver const>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
-    return std::make_unique<SynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor);
-  };
-
-  auto enableV2AsynchronousEventBeat =
-      reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_asynchronous_event_beat_v2_ios");
+  toolbox.synchronousEventBeatFactory =
+      [runtimeExecutor, runtimeScheduler = runtimeScheduler](EventBeat::SharedOwnerBox const &ownerBox) {
+        auto runLoopObserver =
+            std::make_unique<MainRunLoopObserver const>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
+        return std::make_unique<SynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor, runtimeScheduler);
+      };
 
-  toolbox.asynchronousEventBeatFactory = [runtimeExecutor, enableV2AsynchronousEventBeat](
-                                             EventBeat::SharedOwnerBox const &ownerBox) -> std::unique_ptr<EventBeat> {
+  toolbox.asynchronousEventBeatFactory =
+      [runtimeExecutor](EventBeat::SharedOwnerBox const &ownerBox) -> std::unique_ptr<EventBeat> {
     auto runLoopObserver =
         std::make_unique<MainRunLoopObserver const>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
-    if (enableV2AsynchronousEventBeat) {
-      return std::make_unique<AsynchronousEventBeatV2>(std::move(runLoopObserver), runtimeExecutor);
-    } else {
-      return std::make_unique<AsynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor);
-    }
+    return std::make_unique<AsynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor);
   };
 
   RCTScheduler *scheduler = [[RCTScheduler alloc] initWithToolbox:toolbox];

package/React/Fabric/RCTSurfacePresenterBridgeAdapter.h

@@ -6,8 +6,8 @@
  */
 
 #import <Foundation/Foundation.h>
+#import <ReactCommon/RuntimeExecutor.h>
 #import <UIKit/UIKit.h>
-
 #import <react/utils/ContextContainer.h>
 
 NS_ASSUME_NONNULL_BEGIN
@@ -15,6 +15,8 @@ NS_ASSUME_NONNULL_BEGIN
 @class RCTSurfacePresenter;
 @class RCTBridge;
 
+facebook::react::RuntimeExecutor RCTRuntimeExecutorFromBridge(RCTBridge *bridge);
+
 /*
  * Controls a life-cycle of a Surface Presenter based on Bridge's life-cycle.
  * We are moving away from using Bridge.
@@ -32,7 +34,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /*
  * Controls a stored instance of the Bridge. A consumer can re-set the stored Bridge using that method; the class is
- * responsible to coordinate this change with a SurfacePresetner accordingly.
+ * responsible to coordinate this change with a SurfacePresenter accordingly.
  */
 @property (nonatomic, weak) RCTBridge *bridge;
 

package/React/Fabric/RCTSurfacePresenterBridgeAdapter.mm

@@ -41,7 +41,7 @@ static ContextContainer::Shared RCTContextContainerFromBridge(RCTBridge *bridge)
   return contextContainer;
 }
 
-static RuntimeExecutor RCTRuntimeExecutorFromBridge(RCTBridge *bridge)
+RuntimeExecutor RCTRuntimeExecutorFromBridge(RCTBridge *bridge)
 {
   RCTAssert(bridge, @"RCTRuntimeExecutorFromBridge: Bridge must not be nil.");
 

package/React/Fabric/RCTSurfaceRegistry.h

@@ -17,7 +17,7 @@ typedef void (^RCTSurfaceEnumeratorBlock)(NSEnumerator<RCTFabricSurface *> *enum
 
 /**
  * Registry of Surfaces.
- * Incapsulates storing Surface objects and querying them by root tag.
+ * Encapsulates storing Surface objects and querying them by root tag.
  * All methods of the registry are thread-safe.
  * The registry stores Surface objects as weak references.
  */

package/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -10,7 +10,6 @@
 #import <React/RCTUtils.h>
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIGestureRecognizerSubclass.h>
-#import <UIKit/UIKit.h>
 
 #import "RCTConversions.h"
 #import "RCTTouchableComponentViewProtocol.h"
@@ -83,8 +82,7 @@ static void UpdateActiveTouchWithUITouch(
     ActiveTouch &activeTouch,
     UITouch *uiTouch,
     UIView *rootComponentView,
-    CGPoint rootViewOriginOffset,
-    NSTimeInterval unixTimestampBasis)
+    CGPoint rootViewOriginOffset)
 {
   CGPoint offsetPoint = [uiTouch locationInView:activeTouch.componentView];
   CGPoint screenPoint = [uiTouch locationInView:uiTouch.window];
@@ -95,18 +93,14 @@ static void UpdateActiveTouchWithUITouch(
   activeTouch.touch.screenPoint = RCTPointFromCGPoint(screenPoint);
   activeTouch.touch.pagePoint = RCTPointFromCGPoint(pagePoint);
 
-  activeTouch.touch.timestamp = unixTimestampBasis + uiTouch.timestamp;
+  activeTouch.touch.timestamp = uiTouch.timestamp;
 
   if (RCTForceTouchAvailable()) {
     activeTouch.touch.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);
   }
 }
 
-static ActiveTouch CreateTouchWithUITouch(
-    UITouch *uiTouch,
-    UIView *rootComponentView,
-    CGPoint rootViewOriginOffset,
-    NSTimeInterval unixTimestampBasis)
+static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponentView, CGPoint rootViewOriginOffset)
 {
   ActiveTouch activeTouch = {};
 
@@ -123,7 +117,7 @@ static ActiveTouch CreateTouchWithUITouch(
     componentView = componentView.superview;
   }
 
-  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset, unixTimestampBasis);
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
   return activeTouch;
 }
 
@@ -173,12 +167,6 @@ struct PointerHasher {
    */
   __weak UIView *_rootComponentView;
   IdentifierPool<11> _identifierPool;
-
-  /*
-   * See Touch.h and usage. This gives us a time-basis for a monotonic
-   * clock that acts like a timestamp of milliseconds elapsed since UNIX epoch.
-   */
-  NSTimeInterval _unixEpochBasisTime;
 }
 
 - (instancetype)init
@@ -193,8 +181,6 @@ struct PointerHasher {
     self.delaysTouchesEnded = NO;
 
     self.delegate = self;
-
-    _unixEpochBasisTime = [[NSDate date] timeIntervalSince1970] - [NSProcessInfo processInfo].systemUptime;
   }
 
   return self;
@@ -222,7 +208,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 - (void)_registerTouches:(NSSet<UITouch *> *)touches
 {
   for (UITouch *touch in touches) {
-    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset, _unixEpochBasisTime);
+    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
     activeTouch.touch.identifier = _identifierPool.dequeue();
     _activeTouches.emplace(touch, activeTouch);
   }
@@ -237,7 +223,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
       continue;
     }
 
-    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset, _unixEpochBasisTime);
+    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
   }
 }
 

package/React/Fabric/Surface/RCTFabricSurface.mm

@@ -10,6 +10,7 @@
 #import <mutex>
 
 #import <React/RCTAssert.h>
+#import <React/RCTConstants.h>
 #import <React/RCTConversions.h>
 #import <React/RCTFollyConvert.h>
 #import <React/RCTI18nUtil.h>
@@ -60,6 +61,8 @@ using namespace facebook::react;
 
     [_surfacePresenter registerSurface:self];
 
+    [self setMinimumSize:CGSizeZero maximumSize:RCTViewportSize()];
+
     [self _updateLayoutContext];
 
     [[NSNotificationCenter defaultCenter] addObserver:self

package/React/Modules/RCTEventEmitter.h

@@ -6,13 +6,12 @@
  */
 
 #import <React/RCTBridge.h>
-#import <React/RCTJSInvokerModule.h>
 
 /**
  * RCTEventEmitter is an abstract base class to be used for modules that emit
  * events to be observed by JS.
  */
-@interface RCTEventEmitter : NSObject <RCTBridgeModule, RCTJSInvokerModule, RCTInvalidating>
+@interface RCTEventEmitter : NSObject <RCTBridgeModule, RCTInvalidating>
 
 @property (nonatomic, weak) RCTBridge *bridge;
 @property (nonatomic, weak) RCTModuleRegistry *moduleRegistry;