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

package/Libraries/AppDelegate/RCTDefaultReactNativeFactoryDelegate.mm

@@ -0,0 +1,123 @@
+/*
+ * 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 "RCTDefaultReactNativeFactoryDelegate.h"
+#import <ReactCommon/RCTHost.h>
+#import "RCTAppSetupUtils.h"
+#import "RCTDependencyProvider.h"
+
+#import <react/nativemodule/defaults/DefaultTurboModules.h>
+
+@implementation RCTDefaultReactNativeFactoryDelegate
+
+@synthesize dependencyProvider;
+
+- (NSURL *_Nullable)sourceURLForBridge:(nonnull RCTBridge *)bridge
+{
+  [NSException raise:@"RCTBridgeDelegate::sourceURLForBridge not implemented"
+              format:@"Subclasses must implement a valid sourceURLForBridge method"];
+  return nil;
+}
+
+- (UIViewController *)createRootViewController
+{
+  return [UIViewController new];
+}
+
+- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions
+{
+  return [[RCTBridge alloc] initWithDelegate:delegate launchOptions:launchOptions];
+}
+
+- (void)setRootView:(UIView *)rootView toRootViewController:(UIViewController *)rootViewController
+{
+  rootViewController.view = rootView;
+}
+
+- (void)customizeRootView:(RCTRootView *)rootView
+{
+  // Override point for customization after application launch.
+}
+
+- (UIView *)createRootViewWithBridge:(RCTBridge *)bridge
+                          moduleName:(NSString *)moduleName
+                           initProps:(NSDictionary *)initProps
+{
+  BOOL enableFabric = self.newArchEnabled;
+  UIView *rootView = RCTAppSetupDefaultRootView(bridge, moduleName, initProps, enableFabric);
+
+#if !TARGET_OS_TV
+  rootView.backgroundColor = [UIColor systemBackgroundColor];
+#endif
+
+  return rootView;
+}
+
+- (RCTColorSpace)defaultColorSpace
+{
+  return RCTColorSpaceSRGB;
+}
+
+- (NSURL *_Nullable)bundleURL
+{
+  [NSException raise:@"RCTAppDelegate::bundleURL not implemented"
+              format:@"Subclasses must implement a valid getBundleURL method"];
+  return nullptr;
+}
+
+- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents
+{
+  return self.dependencyProvider ? self.dependencyProvider.thirdPartyFabricComponents : @{};
+}
+
+- (void)hostDidStart:(RCTHost *)host
+{
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+  return facebook::react::DefaultTurboModules::getTurboModule(name, jsInvoker);
+}
+
+#pragma mark - RCTArchConfiguratorProtocol
+
+- (BOOL)newArchEnabled
+{
+#if RCT_NEW_ARCH_ENABLED
+  return YES;
+#else
+  return NO;
+#endif
+}
+
+- (BOOL)bridgelessEnabled
+{
+  return self.newArchEnabled;
+}
+
+- (BOOL)fabricEnabled
+{
+  return self.newArchEnabled;
+}
+
+- (BOOL)turboModuleEnabled
+{
+  return self.newArchEnabled;
+}
+
+- (Class)getModuleClassFromName:(const char *)name
+{
+  return nullptr;
+}
+
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+{
+  return nullptr;
+}
+
+@end

package/Libraries/AppDelegate/RCTReactNativeFactory.h

@@ -0,0 +1,98 @@
+/*
+ * 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/RCTBridgeDelegate.h>
+#import <React/RCTConvert.h>
+#import <UIKit/UIKit.h>
+#import "RCTArchConfiguratorProtocol.h"
+#import "RCTDependencyProvider.h"
+#import "RCTRootViewFactory.h"
+#import "RCTUIConfiguratorProtocol.h"
+
+#if defined(__cplusplus) // Don't conform to protocols requiring C++ when it's not defined.
+#import <React/RCTComponentViewFactory.h>
+#import <ReactCommon/RCTHost.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+
+#endif
+
+@class RCTBridge;
+@protocol RCTComponentViewProtocol;
+@class RCTSurfacePresenterBridgeAdapter;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTReactNativeFactoryDelegate <
+    RCTBridgeDelegate,
+    RCTUIConfiguratorProtocol,
+#if defined(__cplusplus) // Don't conform to protocols requiring C++ when it's not defined.
+    RCTHostDelegate,
+    RCTTurboModuleManagerDelegate,
+    RCTComponentViewFactoryComponentProvider,
+#endif
+    RCTArchConfiguratorProtocol>
+
+/// Return the bundle URL for the main bundle.
+- (NSURL *__nullable)bundleURL;
+
+@property (nonatomic, strong) id<RCTDependencyProvider> dependencyProvider;
+
+@optional
+/**
+ * It creates a `RCTBridge` using a delegate and some launch options.
+ * By default, it is invoked passing `self` as a delegate.
+ * You can override this function to customize the logic that creates the RCTBridge
+ *
+ * @parameter: delegate - an object that implements the `RCTBridgeDelegate` protocol.
+ * @parameter: launchOptions - a dictionary with a set of options.
+ *
+ * @returns: a newly created instance of RCTBridge.
+ */
+- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions;
+
+/**
+ * It creates a `UIView` starting from a bridge, a module name and a set of initial properties.
+ * By default, it is invoked using the bridge created by `createBridgeWithDelegate:launchOptions` and
+ * the name in the `self.moduleName` variable.
+ * You can override this function to customize the logic that creates the Root View.
+ *
+ * @parameter: bridge - an instance of the `RCTBridge` object.
+ * @parameter: moduleName - the name of the app, used by Metro to resolve the module.
+ * @parameter: initProps - a set of initial properties.
+ *
+ * @returns: a UIView properly configured with a bridge for React Native.
+ */
+- (UIView *)createRootViewWithBridge:(RCTBridge *)bridge
+                          moduleName:(NSString *)moduleName
+                           initProps:(NSDictionary *)initProps;
+
+/// This method returns a map of Component Descriptors and Components classes that needs to be registered in the
+/// new renderer. The Component Descriptor is a string which represent the name used in JS to refer to the native
+/// component. The default implementation returns an empty dictionary. Subclasses can override this method to register
+/// the required components.
+///
+/// @return a dictionary that associate a component for the new renderer with his descriptor.
+- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents;
+
+@end
+
+@interface RCTReactNativeFactory : NSObject
+
+- (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate;
+
+@property (nonatomic, nullable) RCTBridge *bridge;
+@property (nonatomic, strong, nullable) NSString *moduleName;
+@property (nonatomic, strong, nullable) NSDictionary *initialProps;
+@property (nonatomic, strong, nonnull) RCTRootViewFactory *rootViewFactory;
+
+@property (nonatomic, nullable) RCTSurfacePresenterBridgeAdapter *bridgeAdapter;
+
+@property (nonatomic, weak) id<RCTReactNativeFactoryDelegate> delegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/Libraries/AppDelegate/RCTReactNativeFactory.mm

@@ -0,0 +1,266 @@
+/*
+ * 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 "RCTReactNativeFactory.h"
+#import <React/RCTColorSpaceUtils.h>
+#import <React/RCTLog.h>
+#import <React/RCTRootView.h>
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTHost.h>
+#import <objc/runtime.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#import <react/renderer/graphics/ColorComponents.h>
+#import "RCTAppSetupUtils.h"
+
+#if RN_DISABLE_OSS_PLUGIN_HEADER
+#import <RCTTurboModulePlugin/RCTTurboModulePlugin.h>
+#else
+#import <React/CoreModulesPlugins.h>
+#endif
+#import <React/RCTComponentViewFactory.h>
+#import <React/RCTComponentViewProtocol.h>
+#if USE_HERMES
+#import <ReactCommon/RCTHermesInstance.h>
+#else
+#import <ReactCommon/RCTJscInstance.h>
+#endif
+#import <react/nativemodule/defaults/DefaultTurboModules.h>
+
+#import "RCTDependencyProvider.h"
+
+using namespace facebook::react;
+
+@interface RCTReactNativeFactory () <
+    RCTComponentViewFactoryComponentProvider,
+    RCTHostDelegate,
+    RCTTurboModuleManagerDelegate>
+@end
+
+@implementation RCTReactNativeFactory
+
+- (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate
+{
+  if (self = [super init]) {
+    self.delegate = delegate;
+    [self _setUpFeatureFlags];
+
+    auto newArchEnabled = [self newArchEnabled];
+    auto fabricEnabled = [self fabricEnabled];
+
+    RCTSetNewArchEnabled(newArchEnabled);
+    [RCTColorSpaceUtils applyDefaultColorSpace:[self defaultColorSpace]];
+    RCTEnableTurboModule([self turboModuleEnabled]);
+
+    self.rootViewFactory = [self createRCTRootViewFactory];
+
+    if (newArchEnabled || fabricEnabled) {
+      [RCTComponentViewFactory currentComponentViewFactory].thirdPartyFabricComponentsProvider = self;
+    }
+  }
+
+  return self;
+}
+
+#pragma mark - RCTUIConfiguratorProtocol
+
+- (RCTColorSpace)defaultColorSpace
+{
+  if ([_delegate respondsToSelector:@selector(defaultColorSpace)]) {
+    return [_delegate defaultColorSpace];
+  }
+
+  return RCTColorSpaceSRGB;
+}
+
+- (NSURL *_Nullable)bundleURL
+{
+  if (![_delegate respondsToSelector:@selector(bundleURL)]) {
+    [NSException raise:@"RCTReactNativeFactoryDelegate::bundleURL not implemented"
+                format:@"Delegate must implement a valid getBundleURL method"];
+  }
+
+  return _delegate.bundleURL;
+}
+
+#pragma mark - RCTArchConfiguratorProtocol
+
+- (BOOL)newArchEnabled
+{
+  if ([_delegate respondsToSelector:@selector(newArchEnabled)]) {
+    return _delegate.newArchEnabled;
+  }
+
+#if RCT_NEW_ARCH_ENABLED
+  return YES;
+#else
+  return NO;
+#endif
+}
+
+- (BOOL)fabricEnabled
+{
+  if ([_delegate respondsToSelector:@selector(fabricEnabled)]) {
+    return _delegate.fabricEnabled;
+  }
+
+  return [self newArchEnabled];
+}
+
+- (BOOL)turboModuleEnabled
+{
+  if ([_delegate respondsToSelector:@selector(turboModuleEnabled)]) {
+    return _delegate.turboModuleEnabled;
+  }
+
+  return [self newArchEnabled];
+}
+
+- (BOOL)bridgelessEnabled
+{
+  if ([_delegate respondsToSelector:@selector(bridgelessEnabled)]) {
+    return _delegate.bridgelessEnabled;
+  }
+
+  return [self newArchEnabled];
+}
+
+#pragma mark - RCTTurboModuleManagerDelegate
+
+- (Class)getModuleClassFromName:(const char *)name
+{
+#if RN_DISABLE_OSS_PLUGIN_HEADER
+  return RCTTurboModulePluginClassProvider(name);
+#else
+  return RCTCoreModulesClassProvider(name);
+#endif
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+  if ([_delegate respondsToSelector:@selector(getTurboModule:jsInvoker:)]) {
+    return [_delegate getTurboModule:name jsInvoker:jsInvoker];
+  }
+
+  return facebook::react::DefaultTurboModules::getTurboModule(name, jsInvoker);
+}
+
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+{
+  return RCTAppSetupDefaultModuleFromClass(moduleClass, self.delegate.dependencyProvider);
+}
+
+#pragma mark - RCTComponentViewFactoryComponentProvider
+
+- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents
+{
+  if ([_delegate respondsToSelector:@selector(thirdPartyFabricComponents)]) {
+    return _delegate.thirdPartyFabricComponents;
+  }
+
+  return self.delegate.dependencyProvider ? self.delegate.dependencyProvider.thirdPartyFabricComponents : @{};
+}
+
+#pragma mark - RCTHostDelegate
+
+- (void)hostDidStart:(RCTHost *)host
+{
+  if ([_delegate respondsToSelector:@selector(hostDidStart:)]) {
+    [_delegate hostDidStart:host];
+  }
+}
+
+- (RCTRootViewFactory *)createRCTRootViewFactory
+{
+  __weak __typeof(self) weakSelf = self;
+  RCTBundleURLBlock bundleUrlBlock = ^{
+    auto *strongSelf = weakSelf;
+    return strongSelf.bundleURL;
+  };
+
+  RCTRootViewFactoryConfiguration *configuration =
+      [[RCTRootViewFactoryConfiguration alloc] initWithBundleURLBlock:bundleUrlBlock
+                                                       newArchEnabled:self.fabricEnabled
+                                                   turboModuleEnabled:self.turboModuleEnabled
+                                                    bridgelessEnabled:self.bridgelessEnabled];
+
+  configuration.createRootViewWithBridge = ^UIView *(RCTBridge *bridge, NSString *moduleName, NSDictionary *initProps) {
+    return [weakSelf.delegate createRootViewWithBridge:bridge moduleName:moduleName initProps:initProps];
+  };
+
+  configuration.createBridgeWithDelegate = ^RCTBridge *(id<RCTBridgeDelegate> delegate, NSDictionary *launchOptions) {
+    return [weakSelf.delegate createBridgeWithDelegate:delegate launchOptions:launchOptions];
+  };
+
+  configuration.customizeRootView = ^(UIView *_Nonnull rootView) {
+    [weakSelf.delegate customizeRootView:(RCTRootView *)rootView];
+  };
+
+  configuration.sourceURLForBridge = ^NSURL *_Nullable(RCTBridge *_Nonnull bridge)
+  {
+    return [weakSelf.delegate sourceURLForBridge:bridge];
+  };
+
+  if ([self.delegate respondsToSelector:@selector(extraModulesForBridge:)]) {
+    configuration.extraModulesForBridge = ^NSArray<id<RCTBridgeModule>> *_Nonnull(RCTBridge *_Nonnull bridge)
+    {
+      return [weakSelf.delegate extraModulesForBridge:bridge];
+    };
+  }
+
+  if ([self.delegate respondsToSelector:@selector(extraLazyModuleClassesForBridge:)]) {
+    configuration.extraLazyModuleClassesForBridge =
+        ^NSDictionary<NSString *, Class> *_Nonnull(RCTBridge *_Nonnull bridge)
+    {
+      return [weakSelf.delegate extraLazyModuleClassesForBridge:bridge];
+    };
+  }
+
+  if ([self.delegate respondsToSelector:@selector(bridge:didNotFindModule:)]) {
+    configuration.bridgeDidNotFindModule = ^BOOL(RCTBridge *_Nonnull bridge, NSString *_Nonnull moduleName) {
+      return [weakSelf.delegate bridge:bridge didNotFindModule:moduleName];
+    };
+  }
+
+  return [[RCTRootViewFactory alloc] initWithTurboModuleDelegate:self hostDelegate:self configuration:configuration];
+}
+
+#pragma mark - Feature Flags
+
+class RCTAppDelegateBridgelessFeatureFlags : public ReactNativeFeatureFlagsDefaults {
+ public:
+  bool enableBridgelessArchitecture() override
+  {
+    return true;
+  }
+  bool enableFabricRenderer() override
+  {
+    return true;
+  }
+  bool useTurboModules() override
+  {
+    return true;
+  }
+  bool useNativeViewConfigsInBridgelessMode() override
+  {
+    return true;
+  }
+};
+
+- (void)_setUpFeatureFlags
+{
+  static dispatch_once_t setupFeatureFlagsToken;
+  dispatch_once(&setupFeatureFlagsToken, ^{
+    if ([self bridgelessEnabled]) {
+      ReactNativeFeatureFlags::override(std::make_unique<RCTAppDelegateBridgelessFeatureFlags>());
+    }
+  });
+}
+
+@end

package/Libraries/AppDelegate/RCTRootViewFactory.mm

@@ -270,7 +270,7 @@
 - (std::shared_ptr<facebook::react::JSRuntimeFactory>)createJSRuntimeFactory
 {
 #if USE_HERMES
-  return std::make_shared<facebook::react::RCTHermesInstance>(nullptr, nullptr, /* allocInOldGenBeforeTTI */ false);
+  return std::make_shared<facebook::react::RCTHermesInstance>(nullptr, /* allocInOldGenBeforeTTI */ false);
 #else
   return std::make_shared<facebook::react::RCTJscInstance>();
 #endif

package/Libraries/AppDelegate/React-RCTAppDelegate.podspec

@@ -73,7 +73,6 @@ Pod::Spec.new do |s|
   s.dependency "React-RCTNetwork"
   s.dependency "React-RCTImage"
   s.dependency "React-CoreModules"
-  s.dependency "React-nativeconfig"
   s.dependency "React-RCTFBReactNativeSpec"
   s.dependency "React-defaultsnativemodule"
 

package/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.d.ts

@@ -105,7 +105,7 @@ export interface DrawerLayoutAndroidProps extends ViewProps {
    * The navigation view that will be rendered to the side of the
    * screen and can be pulled in.
    */
-  renderNavigationView: () => JSX.Element;
+  renderNavigationView: () => React.JSX.Element;
 
   /**
    * Make the drawer take the entire screen and draw the background of

package/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.js

@@ -10,5 +10,7 @@
 
 'use strict';
 
+import typeof DrawerLayoutAndroid from './DrawerLayoutAndroid.android';
+
 module.exports =
-  require('../UnimplementedViews/UnimplementedView') as $FlowFixMe;
+  require('../UnimplementedViews/UnimplementedView') as $FlowFixMe as DrawerLayoutAndroid;

package/Libraries/Components/LayoutConformance/LayoutConformance.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+import type * as React from 'react';
+
+type LayoutConformanceProps = {
+  /**
+   * strict: Layout in accordance with W3C spec, even when breaking
+   * compatibility: Layout with the same behavior as previous versions of React Native
+   */
+  mode: 'strict' | 'compatibility';
+  children: React.ReactNode;
+};
+
+export const experimental_LayoutConformance: React.ComponentType<LayoutConformanceProps>;

package/Libraries/Components/LayoutConformance/LayoutConformance.js

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import StyleSheet from '../../StyleSheet/StyleSheet';
+import LayoutConformanceNativeComponent from './LayoutConformanceNativeComponent';
+import * as React from 'react';
+
+type Props = $ReadOnly<{
+  /**
+   * strict: Layout in accordance with W3C spec, even when breaking
+   * compatibility: Layout with the same behavior as previous versions of React Native
+   */
+  mode: 'strict' | 'compatibility',
+
+  children: React.Node,
+}>;
+
+// We want a graceful fallback for apps using legacy arch, but need to know
+// ahead of time whether the component is available, so we test for global.
+// This does not correctly handle mixed arch apps (which is okay, since we just
+// degrade the error experience).
+const isFabricUIManagerInstalled = global?.nativeFabricUIManager != null;
+
+function LayoutConformance(props: Props): React.Node {
+  return (
+    <LayoutConformanceNativeComponent {...props} style={styles.container} />
+  );
+}
+
+function UnimplementedLayoutConformance(props: Props): React.Node {
+  if (__DEV__) {
+    const warnOnce = require('../../Utilities/warnOnce');
+
+    warnOnce(
+      'layoutconformance-unsupported',
+      '"LayoutConformance" is only supported in the New Architecture',
+    );
+  }
+
+  return props.children;
+}
+
+export default (isFabricUIManagerInstalled
+  ? LayoutConformance
+  : UnimplementedLayoutConformance) as component(...Props);
+
+const styles = StyleSheet.create({
+  container: {
+    display: 'contents',
+  },
+});

package/Libraries/Components/LayoutConformance/LayoutConformanceNativeComponent.js

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+import * as NativeComponentRegistry from '../../NativeComponent/NativeComponentRegistry';
+
+type Props = $ReadOnly<{
+  mode: 'strict' | 'compatibility',
+  ...ViewProps,
+}>;
+
+const LayoutConformanceNativeComponent: HostComponent<Props> =
+  NativeComponentRegistry.get<Props>('LayoutConformance', () => ({
+    uiViewClassName: 'LayoutConformance',
+    validAttributes: {
+      mode: true,
+    },
+  }));
+
+export default LayoutConformanceNativeComponent;

package/Libraries/Components/Pressable/Pressable.d.ts

@@ -20,7 +20,7 @@ import {
 import {View} from '../View/View';
 import {AccessibilityProps} from '../View/ViewAccessibility';
 import {ViewProps} from '../View/ViewPropTypes';
-import {TVParallaxProperties} from '../../../types/index';
+import {TVParallaxProperties} from '../../../types/public/ReactNativeTVTypes';
 
 export interface PressableStateCallbackType {
   readonly pressed: boolean;

package/Libraries/Components/TextInput/RCTTextInputViewConfig.js

@@ -162,6 +162,7 @@ const RCTTextInputViewConfig = {
       onChangeSync: true,
       onKeyPressSync: true,
     }),
+    disableKeyboardShortcuts: true,
   },
 };
 

package/Libraries/Components/TextInput/TextInput.d.ts

@@ -136,6 +136,11 @@ export interface DocumentSelectionState extends EventEmitter {
  * @see https://reactnative.dev/docs/textinput#props
  */
 export interface TextInputIOSProps {
+  /**
+   * If true, the keyboard shortcuts (undo/redo and copy buttons) are disabled. The default value is false.
+   */
+  disableKeyboardShortcuts?: boolean | undefined;
+
   /**
    * enum('never', 'while-editing', 'unless-editing', 'always')
    * When the clear button should appear on the right side of the text view

package/Libraries/Components/TextInput/TextInput.flow.js

@@ -216,6 +216,12 @@ export type enterKeyHintType =
 type PasswordRules = string;
 
 type IOSProps = $ReadOnly<{|
+  /**
+   * If true, the keyboard shortcuts (undo/redo and copy buttons) are disabled. The default value is false.
+   * @platform ios
+   */
+  disableKeyboardShortcuts?: ?boolean,
+
   /**
    * When the clear button should appear on the right side of the text view.
    * This property is supported only for single-line TextInput component.