react-native-tvos 0.73.7-1 → 0.74.0-0

package/React/Fabric/RCTConversions.h

@@ -11,6 +11,7 @@
 #import <react/renderer/components/view/primitives.h>
 #import <react/renderer/core/LayoutPrimitives.h>
 #import <react/renderer/graphics/Color.h>
+#import <react/renderer/graphics/RCTPlatformColorUtils.h>
 #import <react/renderer/graphics/Transform.h>
 
 NS_ASSUME_NONNULL_BEGIN
@@ -36,24 +37,7 @@ inline std::string RCTStringFromNSString(NSString *string)
 
 inline UIColor *_Nullable RCTUIColorFromSharedColor(const facebook::react::SharedColor &sharedColor)
 {
-  if (!sharedColor) {
-    return nil;
-  }
-
-  if (*facebook::react::clearColor() == *sharedColor) {
-    return [UIColor clearColor];
-  }
-
-  if (*facebook::react::blackColor() == *sharedColor) {
-    return [UIColor blackColor];
-  }
-
-  if (*facebook::react::whiteColor() == *sharedColor) {
-    return [UIColor whiteColor];
-  }
-
-  auto components = facebook::react::colorComponentsFromColor(sharedColor);
-  return [UIColor colorWithRed:components.red green:components.green blue:components.blue alpha:components.alpha];
+  return RCTPlatformColorFromColor(*sharedColor);
 }
 
 inline CF_RETURNS_RETAINED CGColorRef _Nullable RCTCreateCGColorRefFromSharedColor(

package/React/Fabric/RCTSurfacePointerHandler.mm

@@ -632,7 +632,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   for (const auto &activePointer : activePointers) {
     PointerEvent pointerEvent = CreatePointerEventFromActivePointer(activePointer, eventType, _rootComponentView);
-    [self handleIncomingPointerEvent:pointerEvent onView:activePointer.componentView];
 
     SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(
         activePointer.componentView,
@@ -650,19 +649,13 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
         }
         case RCTPointerEventTypeEnd: {
           eventEmitter->onPointerUp(pointerEvent);
-
           if (pointerEvent.isPrimary && pointerEvent.button == 0 && IsPointerWithinInitialTree(activePointer)) {
             eventEmitter->onClick(pointerEvent);
           }
-
-          if (activePointer.shouldLeaveWhenReleased) {
-            [self handleIncomingPointerEvent:pointerEvent onView:nil];
-          }
           break;
         }
         case RCTPointerEventTypeCancel: {
           eventEmitter->onPointerCancel(pointerEvent);
-          [self handleIncomingPointerEvent:pointerEvent onView:nil];
           break;
         }
       }
@@ -785,110 +778,16 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   PointerEvent event = CreatePointerEventFromIncompleteHoverData(
       pointerId, pointerType, clientLocation, screenLocation, offsetLocation, modifierFlags);
 
-  [self handleIncomingPointerEvent:event onView:targetView];
   SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, offsetLocation);
   if (eventEmitter != nil) {
-    eventEmitter->onPointerMove(event);
-  }
-}
-#endif
-
-#pragma mark - Shared pointer handlers
-
-/**
- * Private method which is used for tracking the location of pointer events to manage the entering/leaving events.
- * The primary idea is that a pointer's presence & movement is dicated by a variety of underlying events such as down,
- * move, and up — and they should all be treated the same when it comes to tracking the entering & leaving of pointers
- * to views. This method accomplishes that by receiving the pointer event, the target view (can be null in cases when
- * the event indicates that the pointer has left the screen entirely), and a block/callback where the underlying event
- * should be fired.
- */
-- (NSOrderedSet<RCTReactTaggedView *> *)handleIncomingPointerEvent:(PointerEvent)event
-                                                            onView:(nullable UIView *)targetView
-{
-  NSInteger pointerId = event.pointerId;
-  CGPoint clientLocation = CGPointMake(event.clientPoint.x, event.clientPoint.y);
-
-  NSOrderedSet<RCTReactTaggedView *> *currentlyHoveredViews =
-      [_currentlyHoveredViewsPerPointer objectForKey:@(pointerId)];
-  if (currentlyHoveredViews == nil) {
-    currentlyHoveredViews = [NSOrderedSet orderedSet];
-  }
-
-  RCTReactTaggedView *targetTaggedView = [RCTReactTaggedView wrap:targetView];
-  RCTReactTaggedView *prevTargetTaggedView = [currentlyHoveredViews firstObject];
-  UIView *prevTargetView = prevTargetTaggedView.view;
-
-  NSOrderedSet<RCTReactTaggedView *> *eventPathViews = GetTouchableViewsInPathToRoot(targetView);
-
-  // Out
-  if (prevTargetView != nil && prevTargetTaggedView.tag != targetTaggedView.tag) {
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(prevTargetView, [_rootComponentView convertPoint:clientLocation toView:prevTargetView]);
-    if (eventEmitter != nil) {
-      eventEmitter->onPointerOut(event);
-    }
-  }
-
-  // Leaving
-
-  // pointerleave events need to be emitted from the deepest target to the root but
-  // we also need to efficiently keep track of if a view has a parent which is listening to the leave events,
-  // so we first iterate from the root to the target, collecting the views which need events fired for, of which
-  // we reverse iterate (now from target to root), actually emitting the events.
-  NSMutableOrderedSet<UIView *> *viewsToEmitLeaveEventsTo = [NSMutableOrderedSet orderedSet];
-
-  for (RCTReactTaggedView *taggedView in [currentlyHoveredViews reverseObjectEnumerator]) {
-    UIView *componentView = taggedView.view;
-
-    BOOL shouldEmitEvent = componentView != nil;
-
-    if (shouldEmitEvent && ![eventPathViews containsObject:taggedView]) {
-      [viewsToEmitLeaveEventsTo addObject:componentView];
-    }
-  }
-
-  for (UIView *componentView in [viewsToEmitLeaveEventsTo reverseObjectEnumerator]) {
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(componentView, [_rootComponentView convertPoint:clientLocation toView:componentView]);
-    if (eventEmitter != nil) {
-      eventEmitter->onPointerLeave(event);
-    }
-  }
-
-  // Over
-  if (targetView != nil && prevTargetTaggedView.tag != targetTaggedView.tag) {
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(targetView, [_rootComponentView convertPoint:clientLocation toView:targetView]);
-    if (eventEmitter != nil) {
-      eventEmitter->onPointerOver(event);
-    }
-  }
-
-  // Entering
-
-  // We only want to emit events to JS if there is a view that is currently listening to said event
-  // so we only send those event to the JS side if the element which has been entered is itself listening,
-  // or if one of its parents is listening in case those listeners care about the capturing phase. Adding the ability
-  // for native to distinguish between capturing listeners and not could be an optimization to further reduce the number
-  // of events we send to JS
-  for (RCTReactTaggedView *taggedView in [eventPathViews reverseObjectEnumerator]) {
-    UIView *componentView = taggedView.view;
-
-    BOOL shouldEmitEvent = componentView != nil;
-
-    if (shouldEmitEvent && ![currentlyHoveredViews containsObject:taggedView]) {
-      SharedTouchEventEmitter eventEmitter =
-          GetTouchEmitterFromView(componentView, [_rootComponentView convertPoint:clientLocation toView:componentView]);
-      if (eventEmitter != nil) {
-        eventEmitter->onPointerEnter(event);
-      }
+    switch (recognizer.state) {
+      case UIGestureRecognizerStateEnded:
+        eventEmitter->onPointerLeave(event);
+      default:
+        eventEmitter->onPointerMove(event);
     }
   }
-
-  [_currentlyHoveredViewsPerPointer setObject:eventPathViews forKey:@(pointerId)];
-
-  return eventPathViews;
 }
+#endif
 
 @end

package/React/Fabric/RCTSurfacePresenter.mm

@@ -27,6 +27,7 @@
 #import <React/RCTUtils.h>
 
 #import <react/config/ReactNativeConfig.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #import <react/renderer/components/text/BaseTextProps.h>
 #import <react/renderer/runtimescheduler/RuntimeScheduler.h>
@@ -256,22 +257,10 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
 {
   auto reactNativeConfig = _contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
 
-  if (reactNativeConfig && reactNativeConfig->getBool("rn_convergence:dispatch_pointer_events")) {
-    RCTSetDispatchW3CPointerEvents(YES);
-  }
-
   if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_cpp_props_iterator_setter_ios")) {
     CoreFeatures::enablePropIteratorSetter = true;
   }
 
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:use_native_state")) {
-    CoreFeatures::useNativeState = true;
-  }
-
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:cancel_image_downloads_on_recycle")) {
-    CoreFeatures::cancelImageDownloadsOnRecycle = true;
-  }
-
   if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_granular_scroll_view_state_updates_ios")) {
     CoreFeatures::enableGranularScrollViewStateUpdatesIOS = true;
   }
@@ -280,14 +269,6 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
     CoreFeatures::enableMountHooks = true;
   }
 
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:disable_scroll_event_throttle_requirement")) {
-    CoreFeatures::disableScrollEventThrottleRequirement = true;
-  }
-
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_default_async_batched_priority")) {
-    CoreFeatures::enableDefaultAsyncBatchedPriority = true;
-  }
-
   if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_cloneless_state_progression")) {
     CoreFeatures::enableClonelessStateProgression = true;
   }
@@ -321,7 +302,7 @@ static BackgroundExecutor RCTGetBackgroundExecutor()
     return std::make_unique<MainRunLoopObserver>(activities, owner);
   };
 
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_background_executor_ios")) {
+  if (ReactNativeFeatureFlags::enableBackgroundExecutor()) {
     toolbox.backgroundExecutor = RCTGetBackgroundExecutor();
   }
 

package/{Libraries/AppDelegate/RCTLegacyInteropComponents.h → React/Inspector/RCTCxxInspectorPackagerConnection.h}

@@ -6,13 +6,12 @@
  */
 
 #import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import "RCTInspectorPackagerConnection.h"
 
-NS_ASSUME_NONNULL_BEGIN
-
-@interface RCTLegacyInteropComponents : NSObject
-
-+ (NSArray<NSString *> *)legacyInteropComponents;
+#if RCT_DEV || RCT_REMOTE_PROFILE
 
+@interface RCTCxxInspectorPackagerConnection : NSObject <RCTInspectorPackagerConnectionProtocol>
 @end
 
-NS_ASSUME_NONNULL_END
+#endif

package/React/Inspector/RCTCxxInspectorPackagerConnection.mm

@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+#import <React/RCTInspectorPackagerConnection.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <React/RCTDefines.h>
+#import <React/RCTInspector.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <SocketRocket/SRWebSocket.h>
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+
+#import <chrono>
+#import <memory>
+
+#import "RCTCxxInspectorPackagerConnection.h"
+#import "RCTCxxInspectorPackagerConnectionDelegate.h"
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+using namespace facebook::react::jsinspector_modern;
+@interface RCTCxxInspectorPackagerConnection () {
+  std::unique_ptr<InspectorPackagerConnection> _cxxImpl;
+}
+@end
+
+@implementation RCTCxxInspectorPackagerConnection
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (instancetype)initWithURL:(NSURL *)url
+{
+  if (self = [super init]) {
+    _cxxImpl = std::make_unique<InspectorPackagerConnection>(
+        [url absoluteString].UTF8String,
+        [[NSBundle mainBundle] bundleIdentifier].UTF8String,
+        std::make_unique<RCTCxxInspectorPackagerConnectionDelegate>());
+  }
+  return self;
+}
+
+- (void)sendEventToAllConnections:(NSString *)event
+{
+  _cxxImpl->sendEventToAllConnections(event.UTF8String);
+}
+
+- (bool)isConnected
+{
+  return _cxxImpl->isConnected();
+}
+
+- (void)connect
+{
+  _cxxImpl->connect();
+}
+
+- (void)closeQuietly
+{
+  _cxxImpl->closeQuietly();
+}
+
+@end
+
+#endif

package/React/Inspector/RCTCxxInspectorPackagerConnectionDelegate.h

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+
+#import <chrono>
+#import <memory>
+#import <string>
+
+namespace facebook::react::jsinspector_modern {
+/**
+ * Glue between C++ and Objective-C for InspectorPackagerConnectionDelegate.
+ */
+class RCTCxxInspectorPackagerConnectionDelegate
+    : public InspectorPackagerConnectionDelegate {
+  class WebSocket : public IWebSocket {
+   public:
+    WebSocket(RCTCxxInspectorWebSocketAdapter* adapter);
+    virtual void send(std::string_view message) override;
+    virtual ~WebSocket() override;
+
+   private:
+    RCTCxxInspectorWebSocketAdapter* const _adapter;
+  };
+
+ public:
+  virtual std::unique_ptr<IWebSocket> connectWebSocket(
+      const std::string& url,
+      std::weak_ptr<IWebSocketDelegate> delegate) override;
+
+  virtual void scheduleCallback(
+      std::function<void(void)> callback,
+      std::chrono::milliseconds delayMs) override;
+};
+} // namespace facebook::react::jsinspector_modern
+
+#endif

package/React/Inspector/RCTCxxInspectorPackagerConnectionDelegate.mm

@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+#import "RCTCxxInspectorPackagerConnectionDelegate.h"
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <dispatch/dispatch.h>
+
+namespace facebook::react::jsinspector_modern {
+RCTCxxInspectorPackagerConnectionDelegate::WebSocket::WebSocket(RCTCxxInspectorWebSocketAdapter *adapter)
+    : _adapter(adapter)
+{
+}
+
+void RCTCxxInspectorPackagerConnectionDelegate::WebSocket::send(std::string_view message)
+{
+  [_adapter send:message];
+}
+
+RCTCxxInspectorPackagerConnectionDelegate::WebSocket::~WebSocket()
+{
+  [_adapter close];
+}
+
+std::unique_ptr<IWebSocket> RCTCxxInspectorPackagerConnectionDelegate::connectWebSocket(
+    const std::string &url,
+    std::weak_ptr<IWebSocketDelegate> delegate)
+{
+  auto *adapter = [[RCTCxxInspectorWebSocketAdapter alloc] initWithURL:url delegate:delegate];
+  return std::make_unique<WebSocket>(adapter);
+}
+
+void RCTCxxInspectorPackagerConnectionDelegate::scheduleCallback(
+    std::function<void(void)> callback,
+    std::chrono::milliseconds delayMs)
+{
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayMs.count() * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+    callback();
+  });
+}
+} // namespace facebook::react::jsinspector_modern
+
+#endif

package/React/Inspector/RCTCxxInspectorWebSocketAdapter.h

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#import <React/RCTDefines.h>
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+#import <memory>
+#import <string>
+
+@interface RCTCxxInspectorWebSocketAdapter : NSObject
+- (instancetype)initWithURL:(const std::string &)url
+                   delegate:(std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate>)delegate;
+- (void)send:(std::string_view)message;
+- (void)close;
+@end
+
+#endif

package/React/Inspector/RCTCxxInspectorWebSocketAdapter.mm

@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+
+#import "RCTCxxInspectorWebSocketAdapter.h"
+
+#if RCT_DEV || RCT_REMOTE_PROFILE
+
+#import <React/RCTInspector.h>
+#import <React/RCTInspectorPackagerConnection.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <SocketRocket/SRWebSocket.h>
+#import <jsinspector-modern/InspectorPackagerConnection.h>
+#import <memory>
+
+using namespace facebook::react::jsinspector_modern;
+
+namespace {
+NSString *NSStringFromUTF8StringView(std::string_view view)
+{
+  return [[NSString alloc] initWithBytes:(const char *)view.data() length:view.size() encoding:NSUTF8StringEncoding];
+}
+}
+@interface RCTCxxInspectorWebSocketAdapter () <SRWebSocketDelegate> {
+  std::weak_ptr<IWebSocketDelegate> _delegate;
+  SRWebSocket *_webSocket;
+}
+@end
+
+@implementation RCTCxxInspectorWebSocketAdapter
+- (instancetype)initWithURL:(const std::string &)url delegate:(std::weak_ptr<IWebSocketDelegate>)delegate
+{
+  if ((self = [super init])) {
+    _delegate = delegate;
+    _webSocket = [[SRWebSocket alloc] initWithURL:[NSURL URLWithString:NSStringFromUTF8StringView(url)]];
+    _webSocket.delegate = self;
+    [_webSocket open];
+  }
+  return self;
+}
+
+- (void)send:(std::string_view)message
+{
+  __weak RCTCxxInspectorWebSocketAdapter *weakSelf = self;
+  NSString *messageStr = NSStringFromUTF8StringView(message);
+  dispatch_async(dispatch_get_main_queue(), ^{
+    RCTCxxInspectorWebSocketAdapter *strongSelf = weakSelf;
+    if (strongSelf) {
+      [strongSelf->_webSocket send:messageStr];
+    }
+  });
+}
+
+- (void)close
+{
+  [_webSocket closeWithCode:1000 reason:@"End of session"];
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket didFailWithError:(NSError *)error
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didFailWithError([error code], [error description].UTF8String);
+  }
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket didReceiveMessageWithString:(NSString *)message
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didReceiveMessage([message UTF8String]);
+  }
+}
+
+- (void)webSocket:(__unused SRWebSocket *)webSocket
+    didCloseWithCode:(__unused NSInteger)code
+              reason:(__unused NSString *)reason
+            wasClean:(__unused BOOL)wasClean
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didClose();
+  }
+}
+
+@end
+
+#endif

package/React/Inspector/RCTInspector.mm

@@ -9,7 +9,7 @@
 
 #if RCT_DEV || RCT_REMOTE_PROFILE
 
-#include <jsinspector-modern/InspectorInterfaces.h>
+#import <jsinspector-modern/InspectorInterfaces.h>
 
 #import <React/RCTDefines.h>
 #import <React/RCTInspectorPackagerConnection.h>
@@ -67,7 +67,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
 
 + (NSArray<RCTInspectorPage *> *)pages
 {
-  std::vector<InspectorPage> pages = getInstance()->getPages();
+  std::vector<InspectorPageDescription> pages = getInstance()->getPages();
   NSMutableArray<RCTInspectorPage *> *array = [NSMutableArray arrayWithCapacity:pages.size()];
   for (size_t i = 0; i < pages.size(); i++) {
     RCTInspectorPage *pageWrapper = [[RCTInspectorPage alloc] initWithId:pages[i].id

package/React/Inspector/RCTInspectorPackagerConnection.h

@@ -10,21 +10,16 @@
 
 #if RCT_DEV || RCT_REMOTE_PROFILE
 
-@interface RCTBundleStatus : NSObject
-@property (atomic, assign) BOOL isLastBundleDownloadSuccess;
-@property (atomic, assign) NSTimeInterval bundleUpdateTimestamp;
-@end
-
-typedef RCTBundleStatus * (^RCTBundleStatusProvider)(void);
-
-@interface RCTInspectorPackagerConnection : NSObject
+@protocol RCTInspectorPackagerConnectionProtocol <NSObject>
 - (instancetype)initWithURL:(NSURL *)url;
 
 - (bool)isConnected;
 - (void)connect;
 - (void)closeQuietly;
 - (void)sendEventToAllConnections:(NSString *)event;
-- (void)setBundleStatusProvider:(RCTBundleStatusProvider)bundleStatusProvider;
+@end
+
+@interface RCTInspectorPackagerConnection : NSObject <RCTInspectorPackagerConnectionProtocol>
 @end
 
 @interface RCTInspectorRemoteConnection : NSObject

package/React/Inspector/RCTInspectorPackagerConnection.m

@@ -21,17 +21,12 @@
 
 const int RECONNECT_DELAY_MS = 2000;
 
-@implementation RCTBundleStatus
-@end
-
 @interface RCTInspectorPackagerConnection () <SRWebSocketDelegate> {
   NSURL *_url;
   NSMutableDictionary<NSString *, RCTInspectorLocalConnection *> *_inspectorConnections;
   SRWebSocket *_webSocket;
-  dispatch_queue_t _jsQueue;
   BOOL _closed;
   BOOL _suppressConnectionErrors;
-  RCTBundleStatusProvider _bundleStatusProvider;
 }
 @end
 
@@ -57,16 +52,10 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   if (self = [super init]) {
     _url = url;
     _inspectorConnections = [NSMutableDictionary new];
-    _jsQueue = dispatch_queue_create("com.facebook.react.WebSocketExecutor", DISPATCH_QUEUE_SERIAL);
   }
   return self;
 }
 
-- (void)setBundleStatusProvider:(RCTBundleStatusProvider)bundleStatusProvider
-{
-  _bundleStatusProvider = bundleStatusProvider;
-}
-
 - (void)handleProxyMessage:(NSDictionary<NSString *, id> *)message
 {
   NSString *event = message[@"event"];
@@ -150,19 +139,12 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   NSArray<RCTInspectorPage *> *pages = [RCTInspector pages];
   NSMutableArray *array = [NSMutableArray arrayWithCapacity:pages.count];
 
-  RCTBundleStatusProvider statusProvider = _bundleStatusProvider;
-  RCTBundleStatus *bundleStatus = statusProvider == nil ? nil : statusProvider();
-
   for (RCTInspectorPage *page in pages) {
     NSDictionary *jsonPage = @{
       @"id" : [@(page.id) stringValue],
       @"title" : page.title,
       @"app" : [[NSBundle mainBundle] bundleIdentifier],
       @"vm" : page.vm,
-      @"isLastBundleDownloadSuccess" : bundleStatus == nil ? [NSNull null]
-                                                           : @(bundleStatus.isLastBundleDownloadSuccess),
-      @"bundleUpdateTimestamp" : bundleStatus == nil ? [NSNull null]
-                                                     : @((long)bundleStatus.bundleUpdateTimestamp * 1000),
     };
     [array addObject:jsonPage];
   }
@@ -199,15 +181,8 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
 }
 
 // analogous to InspectorPackagerConnection.Connection.onMessage(...)
-- (void)webSocket:(__unused SRWebSocket *)webSocket didReceiveMessage:(id)opaqueMessage
+- (void)webSocket:(__unused SRWebSocket *)webSocket didReceiveMessageWithString:(nonnull NSString *)messageText
 {
-  // warn but don't die on unrecognized messages
-  if (![opaqueMessage isKindOfClass:[NSString class]]) {
-    RCTLogWarn(@"Unrecognized inspector message, object is of type: %@", [opaqueMessage class]);
-    return;
-  }
-
-  NSString *messageText = opaqueMessage;
   NSError *error = nil;
   id parsedJSON = RCTJSONParse(messageText, &error);
   if (error) {
@@ -247,7 +222,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   // timeouts, but our previous class, RCTSRWebSocket didn't have the same
   // implemented options. Might be worth reinvestigating for SRWebSocket?
   _webSocket = [[SRWebSocket alloc] initWithURL:_url];
-  [_webSocket setDelegateDispatchQueue:_jsQueue];
   _webSocket.delegate = self;
   [_webSocket open];
 }
@@ -282,7 +256,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
 - (void)sendToPackager:(NSDictionary *)messageObject
 {
   __weak RCTInspectorPackagerConnection *weakSelf = self;
-  dispatch_async(_jsQueue, ^{
+  dispatch_async(dispatch_get_main_queue(), ^{
     RCTInspectorPackagerConnection *strongSelf = weakSelf;
     if (strongSelf && !strongSelf->_closed) {
       NSError *error;

package/React/Modules/RCTEventEmitter.h

@@ -32,8 +32,6 @@
  */
 - (void)sendEventWithName:(NSString *)name body:(id)body;
 
-- (BOOL)canSendEvents_DEPRECATED;
-
 /**
  * These methods will be called when the first observer is added and when the
  * last observer is removed (or when dealloc is called), respectively. These