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

package/Libraries/vendor/emitter/EventEmitter.js

@@ -16,22 +16,22 @@ export interface EventSubscription {
 }
 
 export interface IEventEmitter<
-  TEventToArgsMap: $ReadOnly<Record<string, $ReadOnlyArray<UnsafeEventObject>>>,
+  TEventToArgsMap: Readonly<Record<string, ReadonlyArray<UnsafeEventObject>>>,
 > {
-  addListener<TEvent: $Keys<TEventToArgsMap>>(
+  addListener<TEvent: keyof TEventToArgsMap>(
     eventType: TEvent,
     listener: (...args: TEventToArgsMap[TEvent]) => unknown,
     context?: unknown,
   ): EventSubscription;
 
-  emit<TEvent: $Keys<TEventToArgsMap>>(
+  emit<TEvent: keyof TEventToArgsMap>(
     eventType: TEvent,
     ...args: TEventToArgsMap[TEvent]
   ): void;
 
-  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void;
+  removeAllListeners<TEvent: keyof TEventToArgsMap>(eventType?: ?TEvent): void;
 
-  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number;
+  listenerCount<TEvent: keyof TEventToArgsMap>(eventType: TEvent): number;
 }
 
 interface Registration<TArgs> {
@@ -41,7 +41,7 @@ interface Registration<TArgs> {
 }
 
 type Registry<
-  TEventToArgsMap: $ReadOnly<Record<string, $ReadOnlyArray<UnsafeEventObject>>>,
+  TEventToArgsMap: Readonly<Record<string, ReadonlyArray<UnsafeEventObject>>>,
 > = {
   [K in keyof TEventToArgsMap]: Set<Registration<TEventToArgsMap[K]>>,
 };
@@ -67,9 +67,9 @@ type Registry<
  *
  */
 export default class EventEmitter<
-  TEventToArgsMap: $ReadOnly<
-    Record<string, $ReadOnlyArray<UnsafeEventObject>>,
-  > = $ReadOnly<Record<string, $ReadOnlyArray<UnsafeEventObject>>>,
+  TEventToArgsMap: Readonly<
+    Record<string, ReadonlyArray<UnsafeEventObject>>,
+  > = Readonly<Record<string, ReadonlyArray<UnsafeEventObject>>>,
 > implements IEventEmitter<TEventToArgsMap>
 {
   #registry: Registry<TEventToArgsMap>;
@@ -83,7 +83,7 @@ export default class EventEmitter<
    * Registers a listener that is called when the supplied event is emitted.
    * Returns a subscription that has a `remove` method to undo registration.
    */
-  addListener<TEvent: $Keys<TEventToArgsMap>>(
+  addListener<TEvent: keyof TEventToArgsMap>(
     eventType: TEvent,
     listener: (...args: TEventToArgsMap[TEvent]) => unknown,
     context: unknown,
@@ -95,7 +95,7 @@ export default class EventEmitter<
     }
     const registrations = allocate<
       TEventToArgsMap,
-      $Keys<TEventToArgsMap>,
+      keyof TEventToArgsMap,
       TEventToArgsMap[TEvent],
     >(this.#registry, eventType);
     const registration: Registration<TEventToArgsMap[TEvent]> = {
@@ -116,7 +116,7 @@ export default class EventEmitter<
    * If a listener modifies the listeners registered for the same event, those
    * changes will not be reflected in the current invocation of `emit`.
    */
-  emit<TEvent: $Keys<TEventToArgsMap>>(
+  emit<TEvent: keyof TEventToArgsMap>(
     eventType: TEvent,
     ...args: TEventToArgsMap[TEvent]
   ): void {
@@ -126,7 +126,6 @@ export default class EventEmitter<
       // Copy `registrations` to take a snapshot when we invoke `emit`, in case
       // registrations are added or removed when listeners are invoked.
       for (const registration of Array.from(registrations)) {
-        // $FlowFixMe[incompatible-type]
         registration.listener.apply(registration.context, args);
       }
     }
@@ -135,9 +134,7 @@ export default class EventEmitter<
   /**
    * Removes all registered listeners.
    */
-  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(
-    eventType?: ?TEvent,
-  ): void {
+  removeAllListeners<TEvent: keyof TEventToArgsMap>(eventType?: ?TEvent): void {
     if (eventType == null) {
       // $FlowFixMe[incompatible-type]
       this.#registry = {};
@@ -149,7 +146,7 @@ export default class EventEmitter<
   /**
    * Returns the number of registered listeners for the supplied event.
    */
-  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number {
+  listenerCount<TEvent: keyof TEventToArgsMap>(eventType: TEvent): number {
     const registrations: ?Set<Registration<TEventToArgsMap[TEvent]>> =
       this.#registry[eventType];
     return registrations == null ? 0 : registrations.size;
@@ -157,9 +154,8 @@ export default class EventEmitter<
 }
 
 function allocate<
-  TEventToArgsMap: $ReadOnly<Record<string, $ReadOnlyArray<UnsafeEventObject>>>,
-  TEvent: $Keys<TEventToArgsMap>,
-  TEventArgs: TEventToArgsMap[TEvent],
+  TEventToArgsMap: Readonly<Record<string, ReadonlyArray<UnsafeEventObject>>>,
+  TEvent: keyof TEventToArgsMap,
 >(
   registry: Registry<TEventToArgsMap>,
   eventType: TEvent,

package/README.md

@@ -262,6 +262,58 @@ class Game2048 extends React.Component {
   
   - _TVTextScrollView_: On Apple TV, a ScrollView will not scroll unless there are focusable items inside it or above/below it.  This component works on both Apple TV and Android TV, using native code to allow scrolling using swipe gestures from the remote control.
 
+  - _ScrollView snap alignment_: The existing `snapToAlignment` prop has been extended with a new `'item'` value that enables per-item snap alignment on TV. Instead of snapping all items uniformly to `'start'`, `'center'`, or `'end'`, each child can specify its own alignment via the `scrollSnapAlign` View prop. Optional padding can be applied with `snapToItemPadding` on the ScrollView.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | snapToAlignment | `'item'` | Enables per-item snap alignment (TV only). Requires `snapToInterval` to be set. |
+  | snapToItemPadding | number? | Extra padding (in dp/pt) applied around items when snapping. Only used with `snapToAlignment="item"`. |
+
+  | Prop (View) | Value | Description |
+  |---|---|---|
+  | scrollSnapAlign | `'start'` \| `'center'` \| `'end'` | Controls where this item snaps inside its parent ScrollView. Only used when the parent has `snapToAlignment="item"`. |
+
+  ```jsx
+  <ScrollView
+    horizontal
+    snapToInterval={300}
+    snapToAlignment="item"
+    snapToItemPadding={20}>
+    <Pressable scrollSnapAlign="start" style={{width: 300}}>
+      <Text>Snaps to start</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="center" style={{width: 200}}>
+      <Text>Snaps to center</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="end" style={{width: 300}}>
+      <Text>Snaps to end</Text>
+    </Pressable>
+  </ScrollView>
+  ```
+
+  - _ScrollView animation control_: The `scrollAnimationEnabled` prop allows disabling scroll animations when focus changes on TV. When set to `false`, the scroll view jumps instantly to the focused item instead of animating. This only affects TV platforms and has no effect on mobile.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | scrollAnimationEnabled | boolean? | When `false`, disables animated scrolling on focus change. Defaults to `true`. TV only. |
+
+  ```jsx
+  <ScrollView horizontal scrollAnimationEnabled={false}>
+    <Pressable style={{width: 300}}><Text>Item 1</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 2</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 3</Text></Pressable>
+  </ScrollView>
+  ```
+
+  - _Interaction with existing ScrollView props_: The TV scroll props build on top of existing React Native ScrollView behavior. Here is how they interact:
+
+    - `snapToAlignment="item"` does not require `snapToInterval` to be set. It works as a standalone snapping mode where each child's `scrollSnapAlign` determines the snap position. If `snapToInterval` is also set, the interval is applied as an additional constraint after the item offset is computed.
+    - `snapToAlignment="item"` should not be combined with `pagingEnabled`. Both attempt to control scroll positioning independently, which leads to unpredictable behavior. Use one or the other.
+    - `snapToStart` and `snapToEnd` work independently of `snapToAlignment="item"`. They control edge behavior during swipe/drag momentum (whether the scroll view snaps to the first or last position), but do not affect focus driven item snapping.
+    - `scrollAnimationEnabled={false}` disables all scroll animations, including programmatic `scrollTo({animated: true})` calls. When disabled, all scrolling is instant.
+    - `decelerationRate` has no effect when `scrollAnimationEnabled={false}`, since there is no animation to decelerate.
+    - `scrollAnimationEnabled` and `snapToAlignment="item"` work well together. Snapping still occurs, but instantly instead of animated.
+
   - _VirtualizedList_: We extend `VirtualizedList` to make virtualization work well with focus management in mind. All of the improvements that we made are automatically available to all the VirtualizedList based components such as `FlatList`.
     - Defaults: VirtualizeList contents are automatically wrapped with a `TVFocusGuideView` with `trapFocus*` properties enabled depending on the orientation of the list. This default makes sure that focus doesn't leave the list accidentally due to a virtualization issue etc. until reaching the beginning or the end of the list.
     - New Props:

package/React/Base/RCTBridge.mm

@@ -583,7 +583,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
           }
           return strongSelf->_inspectorTarget->connect(std::move(remote));
         },
-        {.nativePageReloads = true, .prefersFuseboxFrontend = true});
+        {.nativePageReloads = true});
   }
 
   Class bridgeClass = self.bridgeClass;

package/React/Base/RCTBundleURLProvider.mm

@@ -10,6 +10,7 @@
 #import "RCTConstants.h"
 #import "RCTConvert.h"
 #import "RCTDefines.h"
+#import "RCTDevSupportHttpHeaders.h"
 #import "RCTLog.h"
 
 #import <jsinspector-modern/InspectorFlags.h>
@@ -30,6 +31,8 @@ static NSString *const kRCTJsLocationKey = @"RCT_jsLocation";
 static NSString *const kRCTEnableDevKey = @"RCT_enableDev";
 static NSString *const kRCTEnableMinificationKey = @"RCT_enableMinification";
 static NSString *const kRCTInlineSourceMapKey = @"RCT_inlineSourceMap";
+static const NSTimeInterval kRCTPackagerStatusRequestTimeout = 6;
+static const NSTimeInterval kRCTPackagerStatusRequestTimeoutGraceTime = 2;
 
 @implementation RCTBundleURLProvider
 
@@ -93,23 +96,41 @@ static NSURL *serverRootWithHostPort(NSString *hostPort, NSString *scheme)
   NSURL *url = [serverRootWithHostPort(hostPort, scheme) URLByAppendingPathComponent:@"status"];
 
   NSURLSession *session = [NSURLSession sharedSession];
-  NSURLRequest *request = [NSURLRequest requestWithURL:url
-                                           cachePolicy:NSURLRequestUseProtocolCachePolicy
-                                       timeoutInterval:10];
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url
+                                                         cachePolicy:NSURLRequestUseProtocolCachePolicy
+                                                     timeoutInterval:kRCTPackagerStatusRequestTimeout];
+  [[RCTDevSupportHttpHeaders sharedInstance] applyHeadersToRequest:request];
   __block NSURLResponse *response;
   __block NSData *data;
 
+  __block BOOL isRunning = NO;
   dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
   [[session dataTaskWithRequest:request
-              completionHandler:^(NSData *d, NSURLResponse *res, __unused NSError *err) {
+              completionHandler:^(NSData *d, NSURLResponse *res, NSError *err) {
                 data = d;
                 response = res;
+                NSString *status = [[NSString alloc] initWithData:d encoding:NSUTF8StringEncoding];
+                isRunning = [status isEqualToString:@"packager-status:running"];
+                if (!isRunning) {
+                  RCTLogWarn(
+                      @"Packager status check returned unexpected result for %@: %@, error: %@", url, status, err);
+                }
                 dispatch_semaphore_signal(semaphore);
               }] resume];
-  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
-
-  NSString *status = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-  return [status isEqualToString:@"packager-status:running"];
+  long result = dispatch_semaphore_wait(
+      semaphore,
+      dispatch_time(
+          DISPATCH_TIME_NOW,
+          (int64_t)((kRCTPackagerStatusRequestTimeout +
+                     // The request timeout does not cover all phases of the request (e.g. DNS resolution),
+                     // so the actual request might take slightly longer than the configured timeout.
+                     kRCTPackagerStatusRequestTimeoutGraceTime) *
+                    NSEC_PER_SEC)));
+  if (result != 0) {
+    RCTLogWarn(@"Packager status check timed out for %@", url);
+    return NO;
+  }
+  return isRunning;
 }
 
 - (NSString *)guessPackagerHost

package/React/Base/RCTConvert.mm

@@ -461,24 +461,7 @@ RCT_MULTI_ENUM_CONVERTER(
     }),
     UIDataDetectorTypePhoneNumber,
     unsignedLongLongValue)
-
-RCT_MULTI_ENUM_CONVERTER(
-    WKDataDetectorTypes,
-    (@{
-      @"phoneNumber" : @(WKDataDetectorTypePhoneNumber),
-      @"link" : @(WKDataDetectorTypeLink),
-      @"address" : @(WKDataDetectorTypeAddress),
-      @"calendarEvent" : @(WKDataDetectorTypeCalendarEvent),
-      @"trackingNumber" : @(WKDataDetectorTypeTrackingNumber),
-      @"flightNumber" : @(WKDataDetectorTypeFlightNumber),
-      @"lookupSuggestion" : @(WKDataDetectorTypeLookupSuggestion),
-      @"none" : @(WKDataDetectorTypeNone),
-      @"all" : @(WKDataDetectorTypeAll),
-    }),
-    WKDataDetectorTypePhoneNumber,
-    unsignedLongLongValue)
-
-#endif // !TARGET_OS_TV
+#endif
 
 RCT_ENUM_CONVERTER(
     UIKeyboardAppearance,
@@ -538,6 +521,8 @@ RCT_ENUM_CONVERTER(
       @"fullScreen" : @(UIModalPresentationFullScreen),
 #if !TARGET_OS_TV
       @"pageSheet" : @(UIModalPresentationPageSheet),
+#endif
+#if !TARGET_OS_TV || __TV_OS_VERSION_MIN_REQUIRED >= 260000
       @"formSheet" : @(UIModalPresentationFormSheet),
 #endif
       @"overFullScreen" : @(UIModalPresentationOverFullScreen),

package/React/Base/RCTDefines.h

@@ -95,14 +95,6 @@
 #define RCT_DEV_MENU RCT_DEV
 #endif
 
-#ifndef RCT_DEV_SETTINGS_ENABLE_PACKAGER_CONNECTION
-#if RCT_DEV && (__has_include("RCTPackagerConnection.h") || __has_include(<React/RCTPackagerConnection.h>))
-#define RCT_DEV_SETTINGS_ENABLE_PACKAGER_CONNECTION 1
-#else
-#define RCT_DEV_SETTINGS_ENABLE_PACKAGER_CONNECTION 0
-#endif
-#endif
-
 #if RCT_DEV
 #define RCT_IF_DEV(...) __VA_ARGS__
 #else
@@ -175,3 +167,10 @@
     @throw _RCTNotImplementedException(_cmd, [self class]);                                             \
   }                                                                                                     \
   _Pragma("clang diagnostic pop")
+
+/**
+ * Import system color support for all platforms
+ */
+#if __OBJC__
+#import "RCTTVColorSupport.h"
+#endif

package/React/Base/RCTDevSupportHttpHeaders.h

@@ -0,0 +1,24 @@
+/*
+ * 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 <Foundation/Foundation.h>
+
+/**
+ * Thread-safe singleton that holds custom HTTP headers to be applied
+ * to all devsupport network requests (bundle fetches, packager status
+ * checks, inspector and HMR WebSocket connections).
+ */
+@interface RCTDevSupportHttpHeaders : NSObject
+
++ (instancetype)sharedInstance;
+
+- (void)addRequestHeader:(NSString *)name value:(NSString *)value;
+- (void)removeRequestHeader:(NSString *)name;
+- (NSDictionary<NSString *, NSString *> *)allHeaders;
+- (void)applyHeadersToRequest:(NSMutableURLRequest *)request;
+
+@end

package/React/Base/RCTDevSupportHttpHeaders.m

@@ -0,0 +1,65 @@
+/*
+ * 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 "RCTDevSupportHttpHeaders.h"
+
+@implementation RCTDevSupportHttpHeaders {
+  NSMutableDictionary<NSString *, NSString *> *_headers;
+  dispatch_queue_t _queue;
+}
+
++ (instancetype)sharedInstance
+{
+  static RCTDevSupportHttpHeaders *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[RCTDevSupportHttpHeaders alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _headers = [NSMutableDictionary new];
+    _queue = dispatch_queue_create("com.facebook.react.RCTDevSupportHttpHeaders", DISPATCH_QUEUE_SERIAL);
+  }
+  return self;
+}
+
+- (void)addRequestHeader:(NSString *)name value:(NSString *)value
+{
+  dispatch_sync(_queue, ^{
+    self->_headers[name] = value;
+  });
+}
+
+- (void)removeRequestHeader:(NSString *)name
+{
+  dispatch_sync(_queue, ^{
+    [self->_headers removeObjectForKey:name];
+  });
+}
+
+- (NSDictionary<NSString *, NSString *> *)allHeaders
+{
+  __block NSDictionary<NSString *, NSString *> *snapshot;
+  dispatch_sync(_queue, ^{
+    snapshot = [self->_headers copy];
+  });
+  return snapshot;
+}
+
+- (void)applyHeadersToRequest:(NSMutableURLRequest *)request
+{
+  NSDictionary<NSString *, NSString *> *headers = [self allHeaders];
+  [headers enumerateKeysAndObjectsUsingBlock:^(NSString *headerName, NSString *headerValue, BOOL *stop) {
+    [request setValue:headerValue forHTTPHeaderField:headerName];
+  }];
+}
+
+@end

package/React/Base/RCTJavaScriptLoader.h

@@ -33,6 +33,7 @@ NS_ENUM(NSInteger){
 @property (nonatomic, copy) NSString *status;
 @property (strong, nonatomic) NSNumber *done;
 @property (strong, nonatomic) NSNumber *total;
+@property (strong, nonatomic) NSNumber *percent;
 
 @end
 

package/React/Base/RCTJavaScriptLoader.mm

@@ -53,8 +53,9 @@ static RCTSource *RCTSourceCreate(NSURL *url, NSData *data, int64_t length) NS_R
 {
   NSMutableString *desc = [NSMutableString new];
   [desc appendString:_status ?: @"Bundling"];
-
-  if ([_total integerValue] > 0 && [_done integerValue] > [_total integerValue]) {
+  if (_percent != nil) {
+    [desc appendFormat:@" %ld%%", (long)[_percent integerValue]];
+  } else if ([_total integerValue] > 0 && [_done integerValue] > [_total integerValue]) {
     [desc appendFormat:@" %ld%%", (long)100];
   } else if ([_total integerValue] > 0) {
     [desc appendFormat:@" %ld%%", (long)(100 * [_done integerValue] / [_total integerValue])];
@@ -348,6 +349,9 @@ static RCTLoadingProgress *progressEventFromData(NSData *rawData)
   progress.status = info[@"status"];
   progress.done = info[@"done"];
   progress.total = info[@"total"];
+  if (info[@"percent"] != nil) {
+    progress.percent = info[@"percent"];
+  }
   return progress;
 }
 

package/React/Base/RCTMultipartDataTask.h

@@ -7,6 +7,7 @@
 
 #import <Foundation/Foundation.h>
 
+#import <React/RCTDefines.h>
 #import <React/RCTMultipartStreamReader.h>
 
 typedef void (^RCTMultipartDataTaskCallback)(
@@ -16,6 +17,14 @@ typedef void (^RCTMultipartDataTaskCallback)(
     NSError *error,
     BOOL done);
 
+typedef NSURLRequest * _Nullable (^RCTMultipartDataTaskRequestInterceptor)(NSURLRequest *request);
+/**
+ * The block provided via this function can inspect/modify multipart data task
+ * requests before they are sent. Return a modified request to override, or nil
+ * to use the original request unchanged.
+ */
+RCT_EXTERN void RCTSetCustomMultipartDataTaskRequestInterceptor(RCTMultipartDataTaskRequestInterceptor /*interceptor*/);
+
 @interface RCTMultipartDataTask : NSObject
 
 - (instancetype)initWithURL:(NSURL *)url

package/React/Base/RCTMultipartDataTask.m

@@ -7,6 +7,15 @@
 
 #import "RCTMultipartDataTask.h"
 
+static RCTMultipartDataTaskRequestInterceptor multipartRequestInterceptor;
+
+void RCTSetCustomMultipartDataTaskRequestInterceptor(RCTMultipartDataTaskRequestInterceptor interceptor)
+{
+  multipartRequestInterceptor = interceptor;
+}
+
+#import "RCTDevSupportHttpHeaders.h"
+
 @interface RCTMultipartDataTask () <NSURLSessionDataDelegate, NSURLSessionDataDelegate>
 
 @end
@@ -40,7 +49,16 @@
                                                    delegateQueue:nil];
   NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:_url];
   [request addValue:@"multipart/mixed" forHTTPHeaderField:@"Accept"];
-  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request];
+  [[RCTDevSupportHttpHeaders sharedInstance] applyHeadersToRequest:request];
+  NSURLRequest *finalRequest = request;
+  if (multipartRequestInterceptor != nil) {
+    NSURLRequest *intercepted = multipartRequestInterceptor(request);
+    if (intercepted != nil) {
+      finalRequest = intercepted;
+    }
+  }
+  NSLog(@"[RCTMultipartDataTask] %@ %@", finalRequest.HTTPMethod ?: @"GET", finalRequest.URL.absoluteString);
+  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:finalRequest];
   [dataTask resume];
   [session finishTasksAndInvalidate];
 }

package/React/Base/RCTTVColorSupport.h

@@ -0,0 +1,17 @@
+/*
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+/**
+ * Category on UIColor providing systemBackgroundColor for all platforms.
+ * On tvOS, provides a custom implementation since systemBackgroundColor is not available.
+ * On other platforms, returns the system's systemBackgroundColor.
+ */
+@interface UIColor (RNTVSystemColors)
+
++ (UIColor *)rntv_systemBackgroundColor;
+
+@end

package/React/Base/RCTTVColorSupport.mm

@@ -0,0 +1,23 @@
+/*
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+@implementation UIColor (RNTVSystemColors)
+
++ (UIColor *)rntv_systemBackgroundColor {
+ #if TARGET_OS_TV
+   UIColor *lightColor = [UIColor whiteColor];
+   UIColor *darkColor = [UIColor blackColor];
+
+   return [UIColor colorWithDynamicProvider:^UIColor *(UITraitCollection *traitCollection) {
+     return (traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark) ? darkColor : lightColor;
+   }];
+ #else
+   return [UIColor systemBackgroundColor];
+ #endif
+}
+
+@end

package/React/Base/RCTUtils.mm

@@ -311,10 +311,12 @@ void RCTUnsafeExecuteOnMainQueueSync(dispatch_block_t block)
     return;
   }
 
+#if !TARGET_OS_TV
   if (ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS()) {
     unsafeExecuteOnMainThreadSync(block);
     return;
   }
+#endif
 
   dispatch_sync(dispatch_get_main_queue(), ^{
     block();
@@ -339,10 +341,12 @@ static void RCTUnsafeExecuteOnMainQueueOnceSync(dispatch_once_t *onceToken, disp
     return;
   }
 
+#if !TARGET_OS_TV
   if (ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS()) {
     unsafeExecuteOnMainThreadSync(block);
     return;
   }
+#endif
 
   dispatch_sync(dispatch_get_main_queue(), executeOnce);
 }
@@ -384,12 +388,10 @@ CGFloat RCTFontSizeMultiplier(void)
 }
 
 #if !TARGET_OS_TV
-
 UIDeviceOrientation RCTDeviceOrientation(void)
 {
   return [[UIDevice currentDevice] orientation];
 }
-
 #endif
 
 CGSize RCTScreenSize(void)
@@ -403,14 +405,15 @@ CGSize RCTScreenSize(void)
     });
   });
 
-#if TARGET_OS_TV
-  return CGSizeMake(portraitSize.height, portraitSize.width); // landscape
-#else
+#if !TARGET_OS_TV
   if (UIDeviceOrientationIsLandscape(RCTDeviceOrientation())) {
     return CGSizeMake(portraitSize.height, portraitSize.width);
   } else {
     return CGSizeMake(portraitSize.width, portraitSize.height);
   }
+#else
+  // tvOS doesn't have device orientation, always return landscape size
+  return CGSizeMake(portraitSize.height, portraitSize.width);
 #endif
 }
 
@@ -422,6 +425,9 @@ CGSize RCTViewportSize(void)
 
 CGSize RCTSwitchSize(void)
 {
+#if TARGET_OS_TV
+  return CGSizeMake(0, 0);
+#else
   static CGSize rctSwitchSize;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
@@ -434,6 +440,7 @@ CGSize RCTSwitchSize(void)
     });
   });
   return rctSwitchSize;
+#endif
 }
 
 CGFloat RCTRoundPixelValue(CGFloat value)
@@ -643,7 +650,9 @@ UIWindow *__nullable RCTKeyWindow(void)
     // We have apps internally that might use UIScenes which are not window scenes.
     // Calling keyWindow on a UIScene which is not a UIWindowScene can cause a crash
     UIWindowScene *windowScene = (UIWindowScene *)sceneToUse;
-    return windowScene.keyWindow;
+    if (@available(iOS 15.0, tvOS 15.0, *)) {
+      return windowScene.keyWindow;
+    }
   }
 
   return nil;

package/React/Base/RCTVersion.m

@@ -22,8 +22,8 @@ NSDictionary* RCTGetReactNativeVersion(void)
   dispatch_once(&onceToken, ^(void){
     __rnVersion = @{
                   RCTVersionMajor: @(0),
-                  RCTVersionMinor: @(84),
-                  RCTVersionPatch: @(1),
+                  RCTVersionMinor: @(85),
+                  RCTVersionPatch: @(0),
                   RCTVersionPrerelease: @"0",
                   };
   });