not-react-native-macos 0.87.1-rc.6 → 0.87.1-rc.7

package/Libraries/AppState/AppState.js

@@ -88,7 +88,11 @@ class AppStateImpl {
         new NativeEventEmitter(
           // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
           // If you want to use the native module on other platforms, please remove this condition and test its behavior
-          Platform.OS !== 'ios' ? null : NativeAppState,
+          // [macOS] macOS uses this parameter too: the module is an
+          // RCTEventEmitter subclass here, exactly as it is on iOS.
+          Platform.OS !== 'ios' && Platform.OS !== 'macos'
+            ? null
+            : NativeAppState,
         );
       this._emitter = emitter;
 

package/Libraries/Components/Button.js

@@ -234,7 +234,8 @@ const Button: component(
   const buttonStyles: Array<ViewStyleProp> = [styles.button];
   const textStyles: Array<TextStyleProp> = [styles.text];
   if (color) {
-    if (Platform.OS === 'ios') {
+    // [macOS] Apple platforms tint the label; Android tints the background.
+    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
       textStyles.push({color: color});
     } else {
       buttonStyles.push({backgroundColor: color});

package/Libraries/Components/Keyboard/Keyboard.js

@@ -77,7 +77,11 @@ class KeyboardImpl {
     new NativeEventEmitter(
       // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
       // If you want to use the native module on other platforms, please remove this condition and test its behavior
-      Platform.OS !== 'ios' ? null : NativeKeyboardObserver,
+      // [macOS] macOS uses this parameter too: the module is an
+      // RCTEventEmitter subclass here, exactly as it is on iOS.
+      Platform.OS !== 'ios' && Platform.OS !== 'macos'
+        ? null
+        : NativeKeyboardObserver,
     );
 
   constructor() {

package/Libraries/Components/ScrollView/ScrollView.js

@@ -1101,7 +1101,11 @@ class ScrollView extends React.Component<ScrollViewProps, ScrollViewState> {
       },
       animated?: boolean, // deprecated, put this inside the rect argument instead
     ) => {
-      invariant(Platform.OS === 'ios', 'zoomToRect is not implemented');
+      // [macOS] The AppKit scroll view zooms as well.
+      invariant(
+        Platform.OS === 'ios' || Platform.OS === 'macos',
+        'zoomToRect is not implemented',
+      );
       if ('animated' in rect) {
         this._animated = rect.animated;
         delete rect.animated;

package/Libraries/Components/TextInput/TextInput.js

@@ -75,7 +75,11 @@ if (Platform.OS === 'android') {
   AndroidTextInput = require('./AndroidTextInputNativeComponent').default;
   AndroidTextInputCommands =
     require('./AndroidTextInputNativeComponent').Commands;
-} else if (Platform.OS === 'ios') {
+  // [macOS] macOS uses the same two Apple-platform components. Without this
+  // branch neither module is ever required, both locals stay undefined, and
+  // the render below -- also gated on `ios` -- returns nothing at all: a
+  // TextInput silently renders as empty space, with no error anywhere.
+} else if (Platform.OS === 'ios' || Platform.OS === 'macos') {
   RCTSinglelineTextInputView =
     require('./RCTSingelineTextInputNativeComponent').default;
   RCTSinglelineTextInputNativeCommands =
@@ -564,7 +568,8 @@ function InternalTextInput(props: TextInputProps): React.Node {
     }
   }
 
-  if (Platform.OS === 'ios') {
+  // [macOS] The Apple-platform render path; see the require above.
+  if (Platform.OS === 'ios' || Platform.OS === 'macos') {
     const RCTTextInputView =
       props.multiline === true
         ? RCTMultilineTextInputView

package/Libraries/Components/TextInput/TextInputState.js

@@ -87,7 +87,9 @@ function focusTextInput(textField: ?HostInstance) {
 
   if (textField != null) {
     const fieldCanBeFocused =
-      currentlyFocusedInputRef !== textField &&
+      // [macOS] On a desktop any view can hold focus, so the currently focused
+      // *input* is not a reliable answer to whether this field already has it.
+      (Platform.OS === 'macos' || currentlyFocusedInputRef !== textField) &&
       // $FlowFixMe[prop-missing] - `currentProps` is missing in `NativeMethods`
       textField.currentProps?.editable !== false;
 
@@ -95,7 +97,9 @@ function focusTextInput(textField: ?HostInstance) {
       return;
     }
     focusInput(textField);
-    if (Platform.OS === 'ios') {
+    // [macOS] The commands are declared by the Apple-platform native
+    // components, which macOS shares.
+    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
       // This isn't necessarily a single line text input
       // But commands don't actually care as long as the thing being passed in
       // actually has a command with that name. So this should work with single
@@ -126,7 +130,9 @@ function blurTextInput(textField: ?HostInstance) {
 
   if (currentlyFocusedInputRef === textField && textField != null) {
     blurInput(textField);
-    if (Platform.OS === 'ios') {
+    // [macOS] The commands are declared by the Apple-platform native
+    // components, which macOS shares.
+    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
       // This isn't necessarily a single line text input
       // But commands don't actually care as long as the thing being passed in
       // actually has a command with that name. So this should work with single

package/Libraries/EventEmitter/NativeEventEmitter.js

@@ -71,7 +71,12 @@ export default class NativeEventEmitter<
    *      an invariant error if undefined.
    */
   constructor(nativeModule?: ?NativeModule) {
-    if (Platform.OS === 'ios') {
+    // [macOS] Same requirement on macOS: the module backing the emitter is an
+    // RCTEventEmitter subclass here too, so a null one is a bug rather than a
+    // platform difference. This only holds because the callers that used to
+    // pass `Platform.OS !== 'ios' ? null : NativeX` now pass the module on
+    // macOS as well -- widening this without those is an import-time crash.
+    if (Platform.OS === 'ios' || Platform.OS === 'macos') {
       invariant(
         nativeModule != null,
         '`new NativeEventEmitter()` requires a non-null argument.',

package/Libraries/Linking/Linking.js

@@ -23,7 +23,12 @@ type LinkingEventDefinitions = {
 
 class LinkingImpl extends NativeEventEmitter<LinkingEventDefinitions> {
   constructor() {
-    super(Platform.OS === 'ios' ? nullthrows(NativeLinkingManager) : undefined);
+    // [macOS] RCTLinkingManager is built for macOS too.
+    super(
+      Platform.OS === 'ios' || Platform.OS === 'macos'
+        ? nullthrows(NativeLinkingManager)
+        : undefined,
+    );
   }
 
   /**

package/Libraries/Modal/Modal.js

@@ -43,7 +43,11 @@ const ModalEventEmitter =
     ? new NativeEventEmitter<ModalEventDefinitions>(
         // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
         // If you want to use the native module on other platforms, please remove this condition and test its behavior
-        Platform.OS !== 'ios' ? null : NativeModalManager,
+        // [macOS] macOS uses this parameter too: the module is an
+        // RCTEventEmitter subclass here, exactly as it is on iOS.
+        Platform.OS !== 'ios' && Platform.OS !== 'macos'
+          ? null
+          : NativeModalManager,
       )
     : null;
 

package/Libraries/Pressability/HoverState.js

@@ -53,6 +53,11 @@ if (Platform.OS === 'web') {
     document.addEventListener('touchstart', disableHover, true);
     document.addEventListener('touchmove', disableHover, true);
     document.addEventListener('mousemove', enableHover, true);
+    // [macOS] A Mac always has a pointer, and unlike the web there is no touch
+    // input to disable hover for. Without this `onHoverIn` / `onHoverOut` never
+    // fire on Pressable, because Pressability checks this flag first.
+  } else if (Platform.OS === 'macos') {
+    isEnabled = true;
   }
 }
 

package/Libraries/PushNotificationIOS/PushNotificationIOS.js

@@ -67,7 +67,11 @@ const PushNotificationEmitter =
   new NativeEventEmitter<NativePushNotificationIOSEventDefinitions>(
     // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
     // If you want to use the native module on other platforms, please remove this condition and test its behavior
-    Platform.OS !== 'ios' ? null : NativePushNotificationManagerIOS,
+    // [macOS] macOS uses this parameter too: the module is an
+    // RCTEventEmitter subclass here, exactly as it is on iOS.
+    Platform.OS !== 'ios' && Platform.OS !== 'macos'
+      ? null
+      : NativePushNotificationManagerIOS,
   );
 
 const _notifHandlers = new Map<string, void | EventSubscription>();

package/Libraries/ReactNative/PaperUIManager.js

@@ -155,7 +155,8 @@ function lazifyViewManagerConfig(viewName: string) {
  * only needed for iOS, which puts the constants in the ViewManager
  * namespace instead of UIManager, unlike Android.
  */
-if (Platform.OS === 'ios') {
+// [macOS] Apple platforms namespace view-manager constants the same way.
+if (Platform.OS === 'ios' || Platform.OS === 'macos') {
   Object.keys(getConstants()).forEach(viewName => {
     lazifyViewManagerConfig(viewName);
   });

package/Libraries/Utilities/DevSettings.js

@@ -53,7 +53,11 @@ if (__DEV__) {
   const emitter = new NativeEventEmitter<DevSettingsEventDefinitions>(
     // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
     // If you want to use the native module on other platforms, please remove this condition and test its behavior
-    Platform.OS !== 'ios' ? null : NativeDevSettings,
+    // [macOS] macOS uses this parameter too: the module is an
+    // RCTEventEmitter subclass here, exactly as it is on iOS.
+    Platform.OS !== 'ios' && Platform.OS !== 'macos'
+      ? null
+      : NativeDevSettings,
   );
   const subscriptions = new Map<string, EventSubscription>();
 

package/Libraries/Utilities/HMRClient.js

@@ -192,7 +192,8 @@ const HMRClient: HMRClientNativeInterface = {
 Try the following to fix the issue:
 - Ensure that Metro is running and available on the same network`;
 
-      if (Platform.OS === 'ios') {
+      // [macOS] The AppDelegate advice is just as true here.
+      if (Platform.OS === 'ios' || Platform.OS === 'macos') {
         error += `
 - Ensure that the Metro URL is correctly set in AppDelegate`;
       } else {
@@ -349,7 +350,8 @@ function flushEarlyLogs(client: MetroHMRClient) {
 
 function dismissRedbox() {
   if (
-    Platform.OS === 'ios' &&
+    // [macOS] RedBox is an Apple-platform module; macOS has it too.
+    (Platform.OS === 'ios' || Platform.OS === 'macos') &&
     NativeRedBox != null &&
     NativeRedBox.dismiss != null
   ) {

package/Libraries/WebSocket/WebSocket.js

@@ -141,7 +141,11 @@ class WebSocket extends EventTarget {
     this._eventEmitter = new NativeEventEmitter(
       // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
       // If you want to use the native module on other platforms, please remove this condition and test its behavior
-      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+      // [macOS] macOS uses this parameter too: the module is an
+      // RCTEventEmitter subclass here, exactly as it is on iOS.
+      Platform.OS !== 'ios' && Platform.OS !== 'macos'
+        ? null
+        : NativeWebSocketModule,
     );
     this._socketId = nextWebSocketId++;
     this._registerEvents();

package/Libraries/WebSocket/WebSocketInterceptor.js

@@ -169,7 +169,11 @@ const WebSocketInterceptor = {
     eventEmitter = new NativeEventEmitter(
       // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
       // If you want to use the native module on other platforms, please remove this condition and test its behavior
-      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+      // [macOS] macOS uses this parameter too: the module is an
+      // RCTEventEmitter subclass here, exactly as it is on iOS.
+      Platform.OS !== 'ios' && Platform.OS !== 'macos'
+        ? null
+        : NativeWebSocketModule,
     );
     WebSocketInterceptor._registerEvents();
 

package/macos/UIKitCompat/UIKit/UIText.h

@@ -158,6 +158,35 @@ typedef NS_ENUM(NSInteger, UIKeyboardAppearance) {
 // UIKit's per-field default attributes. NSTextField applies typing attributes
 // through its field editor instead, so these are stored and applied on edit.
 @property (nonatomic, copy, nullable) NSDictionary<NSAttributedStringKey, id> *defaultTextAttributes;
+// The attributes newly typed text takes on. NSTextField has no such property:
+// editing happens in the window's shared field editor, which is an NSTextView
+// and does. Reads and writes are forwarded there while editing, and held here
+// otherwise so the value survives between edits.
+@property (nonatomic, copy, null_resettable) NSDictionary<NSAttributedStringKey, id> *typingAttributes;
+// NSTextField spells the styled value attributedStringValue.
+@property (nonatomic, copy, nullable) NSAttributedString *attributedText;
+// NSControl spells it alignment.
+@property (nonatomic, assign) NSTextAlignment textAlignment;
+// UIKit's clear button. NSTextField has no equivalent, so this is stored and
+// otherwise unused -- a Mac text field does not show one.
+@property (nonatomic, assign) UITextFieldViewMode clearButtonMode;
+// UIKit hangs custom keyboards and toolbars off the responder. AppKit has no
+// software keyboard, so these are stored and never presented.
+@property (nonatomic, strong, nullable) UIView *inputView;
+@property (nonatomic, strong, nullable) UIView *inputAccessoryView;
+// Traits UITextInputTraits declares as @optional. A protocol property creates
+// no storage, so each one an ObjC class is expected to answer has to be
+// synthesized by that class -- omitting them is an unrecognized selector at
+// the first access, not a compile error.
+@property (nonatomic, assign) UITextSmartInsertDeleteType smartInsertDeleteType;
+@property (nonatomic, assign) UITextSmartQuotesType smartQuotesType;
+@property (nonatomic, assign) UITextSmartDashesType smartDashesType;
+@property (nonatomic, copy, nullable) NSString *textContentType;
+@property (nonatomic, strong, nullable) id passwordRules;
+@property (nonatomic, assign) BOOL enablesReturnKeyAutomatically;
+// UIKit tints the caret and selection through the view; AppKit takes it from
+// the field editor's insertion-point colour.
+@property (nonatomic, strong, nullable) UIColor *tintColor;
 // NSTextField spells it placeholderAttributedString.
 @property (nonatomic, copy, nullable) NSAttributedString *attributedPlaceholder;
 // UIResponder's editing-menu hook; NSResponder has -validateUserInterfaceItem:.
@@ -219,6 +248,27 @@ typedef NS_ENUM(NSInteger, UIKeyboardAppearance) {
 @property (nonatomic, assign) UIReturnKeyType returnKeyType;
 @property (nonatomic, copy, nullable) NSString *text;
 @property (nonatomic, weak, nullable) id<UITextDropDelegate> textDropDelegate;
+// As on UITextField: UITextInputTraits declares these @optional, so a class
+// expected to answer them has to synthesize its own storage.
+@property (nonatomic, assign) UITextAutocapitalizationType autocapitalizationType;
+@property (nonatomic, assign) UITextAutocorrectionType autocorrectionType;
+@property (nonatomic, assign) UITextSpellCheckingType spellCheckingType;
+@property (nonatomic, assign) UIKeyboardAppearance keyboardAppearance;
+@property (nonatomic, assign) UITextSmartInsertDeleteType smartInsertDeleteType;
+@property (nonatomic, assign) UITextSmartQuotesType smartQuotesType;
+@property (nonatomic, assign) UITextSmartDashesType smartDashesType;
+@property (nonatomic, assign, getter=isSecureTextEntry) BOOL secureTextEntry;
+@property (nonatomic, assign) BOOL enablesReturnKeyAutomatically;
+@property (nonatomic, copy, nullable) NSString *textContentType;
+@property (nonatomic, strong, nullable) id passwordRules;
+// UIKit's text view scrolls itself. NSTextView is the document view of an
+// enclosing NSScrollView, so this forwards to that.
+@property (nonatomic, assign, getter=isScrollEnabled) BOOL scrollEnabled;
+@property (nonatomic, assign) CGPoint contentOffset;
+@property (nonatomic, assign) CGFloat zoomScale;
+@property (nonatomic, strong, nullable) UIView *inputView;
+@property (nonatomic, strong, nullable) UIView *inputAccessoryView;
+@property (nonatomic, assign) UIDataDetectorTypes dataDetectorTypes;
 @end
 
 // UIKit's editing notifications. AppKit posts NSControlTextDidChange and

package/macos/UIKitCompat/UIKit/UIText.m

@@ -78,10 +78,141 @@
 
 @end
 
-@implementation UITextField
+@implementation UITextField {
+  NSDictionary<NSAttributedStringKey, id> *_typingAttributes;
+}
 
 UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
 
+/**
+ * The live field editor, when this field is the one being edited.
+ *
+ * `-fieldEditor:forObject:` with NO does not create one, so this is nil unless
+ * editing is actually under way -- which is what makes it safe to ask for on
+ * every access.
+ */
+- (NSTextView *)uikitCompat_activeFieldEditor
+{
+  NSText *editor = [self.window fieldEditor:NO forObject:self];
+  if ([editor isKindOfClass:[NSTextView class]] && self.currentEditor == editor) {
+    return (NSTextView *)editor;
+  }
+  return nil;
+}
+
+@synthesize smartInsertDeleteType = _smartInsertDeleteType;
+@synthesize smartQuotesType = _smartQuotesType;
+@synthesize smartDashesType = _smartDashesType;
+@synthesize textContentType = _textContentType;
+@synthesize passwordRules = _passwordRules;
+@synthesize enablesReturnKeyAutomatically = _enablesReturnKeyAutomatically;
+
+/**
+ * Marked text is an in-progress IME composition. AppKit tracks it on the field
+ * editor, so there is nothing marked when the field is not being edited.
+ */
+- (UITextRange *)markedTextRange
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor == nil || !editor.hasMarkedText) {
+    return nil;
+  }
+  NSRange range = editor.markedRange;
+  return [UITextRange rangeWithStart:[UITextPosition positionWithOffset:(NSInteger)range.location]
+                                 end:[UITextPosition positionWithOffset:(NSInteger)(range.location + range.length)]];
+}
+
+- (UITextInputMode *)textInputMode
+{
+  // UIKit reports the software keyboard's language. AppKit has no software
+  // keyboard, and no caller here does more than null-check the result.
+  return nil;
+}
+
+- (UIColor *)tintColor
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  return editor != nil ? editor.insertionPointColor : nil;
+}
+
+- (void)setTintColor:(UIColor *)tintColor
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor != nil && tintColor != nil) {
+    editor.insertionPointColor = tintColor;
+  }
+}
+
+- (NSAttributedString *)attributedText
+{
+  return self.attributedStringValue;
+}
+
+- (void)setAttributedText:(NSAttributedString *)attributedText
+{
+  self.attributedStringValue = attributedText ?: [[NSAttributedString alloc] initWithString:@""];
+}
+
+- (NSTextAlignment)textAlignment
+{
+  return self.alignment;
+}
+
+- (void)setTextAlignment:(NSTextAlignment)textAlignment
+{
+  self.alignment = textAlignment;
+}
+
+/**
+ * The selection, which on AppKit lives in the field editor rather than the
+ * field. With no editor there is nothing selected, and UIKit reports nil for
+ * a field that is not being edited too.
+ */
+- (UITextRange *)selectedTextRange
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor == nil) {
+    return nil;
+  }
+  NSRange range = editor.selectedRange;
+  return [UITextRange rangeWithStart:[UITextPosition positionWithOffset:(NSInteger)range.location]
+                                 end:[UITextPosition positionWithOffset:(NSInteger)(range.location + range.length)]];
+}
+
+- (void)setSelectedTextRange:(UITextRange *)selectedTextRange
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor == nil || selectedTextRange == nil) {
+    return;
+  }
+  NSInteger start = MAX((NSInteger)0, selectedTextRange.start.offset);
+  NSInteger end = MAX(start, selectedTextRange.end.offset);
+  NSInteger length = (NSInteger)self.stringValue.length;
+  start = MIN(start, length);
+  end = MIN(end, length);
+  editor.selectedRange = NSMakeRange((NSUInteger)start, (NSUInteger)(end - start));
+}
+
+- (NSDictionary<NSAttributedStringKey, id> *)typingAttributes
+{
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor != nil) {
+    return editor.typingAttributes;
+  }
+  // Between edits there is no field editor to ask. UIKit's own default for a
+  // field that was never typed into is its default text attributes.
+  return _typingAttributes ?: self.defaultTextAttributes ?: @{};
+}
+
+- (void)setTypingAttributes:(NSDictionary<NSAttributedStringKey, id> *)typingAttributes
+{
+  _typingAttributes = [typingAttributes copy];
+  NSTextView *editor = [self uikitCompat_activeFieldEditor];
+  if (editor != nil) {
+    editor.typingAttributes = _typingAttributes ?: @{};
+  }
+}
+
 - (UITextPosition *)endOfDocument
 {
   return [UITextPosition positionWithOffset:(NSInteger)self.stringValue.length];
@@ -223,6 +354,85 @@ UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
 
 @implementation UITextView
 
+@synthesize autocapitalizationType = _autocapitalizationType;
+@synthesize autocorrectionType = _autocorrectionType;
+@synthesize spellCheckingType = _spellCheckingType;
+@synthesize keyboardAppearance = _keyboardAppearance;
+@synthesize smartInsertDeleteType = _smartInsertDeleteType;
+@synthesize smartQuotesType = _smartQuotesType;
+@synthesize smartDashesType = _smartDashesType;
+@synthesize secureTextEntry = _secureTextEntry;
+@synthesize enablesReturnKeyAutomatically = _enablesReturnKeyAutomatically;
+@synthesize textContentType = _textContentType;
+@synthesize passwordRules = _passwordRules;
+@synthesize inputView = _inputView;
+@synthesize inputAccessoryView = _inputAccessoryView;
+@synthesize dataDetectorTypes = _dataDetectorTypes;
+@synthesize zoomScale = _zoomScale;
+
+/**
+ * UIKit's text view scrolls on its own. NSTextView is the document view inside
+ * an NSScrollView, so scrolling is a property of the enclosing view -- and
+ * there may not be one, when the text view is used unwrapped.
+ */
+- (BOOL)isScrollEnabled
+{
+  NSScrollView *scrollView = self.enclosingScrollView;
+  return scrollView != nil ? (scrollView.hasVerticalScroller || scrollView.hasHorizontalScroller) : NO;
+}
+
+- (void)setScrollEnabled:(BOOL)scrollEnabled
+{
+  NSScrollView *scrollView = self.enclosingScrollView;
+  scrollView.hasVerticalScroller = scrollEnabled;
+  scrollView.hasHorizontalScroller = NO;
+}
+
+- (CGPoint)contentOffset
+{
+  NSScrollView *scrollView = self.enclosingScrollView;
+  return scrollView != nil ? scrollView.contentView.bounds.origin : CGPointZero;
+}
+
+- (void)setContentOffset:(CGPoint)contentOffset
+{
+  [self.enclosingScrollView.contentView scrollToPoint:contentOffset];
+}
+
+- (UITextInputMode *)textInputMode
+{
+  // No software keyboard on macOS; callers only null-check this.
+  return nil;
+}
+
+- (UITextRange *)markedTextRange
+{
+  if (!self.hasMarkedText) {
+    return nil;
+  }
+  NSRange range = self.markedRange;
+  return [UITextRange rangeWithStart:[UITextPosition positionWithOffset:(NSInteger)range.location]
+                                 end:[UITextPosition positionWithOffset:(NSInteger)(range.location + range.length)]];
+}
+
+- (UITextRange *)selectedTextRange
+{
+  NSRange range = self.selectedRange;
+  return [UITextRange rangeWithStart:[UITextPosition positionWithOffset:(NSInteger)range.location]
+                                 end:[UITextPosition positionWithOffset:(NSInteger)(range.location + range.length)]];
+}
+
+- (void)setSelectedTextRange:(UITextRange *)selectedTextRange
+{
+  if (selectedTextRange == nil) {
+    return;
+  }
+  NSInteger length = (NSInteger)self.string.length;
+  NSInteger start = MIN(MAX((NSInteger)0, selectedTextRange.start.offset), length);
+  NSInteger end = MIN(MAX(start, selectedTextRange.end.offset), length);
+  self.selectedRange = NSMakeRange((NSUInteger)start, (NSUInteger)(end - start));
+}
+
 UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
 
 - (UITextPosition *)endOfDocument

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-react-native-macos",
-  "version": "0.87.1-rc.6",
+  "version": "0.87.1-rc.7",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {

package/src/private/animated/NativeAnimatedHelper.js

@@ -489,7 +489,11 @@ export default {
       nativeEventEmitter = new NativeEventEmitter(
         // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
         // If you want to use the native module on other platforms, please remove this condition and test its behavior
-        Platform.OS !== 'ios' ? null : NativeAnimatedModule,
+        // [macOS] macOS uses this parameter too: the module is an
+        // RCTEventEmitter subclass here, exactly as it is on iOS.
+        Platform.OS !== 'ios' && Platform.OS !== 'macos'
+          ? null
+          : NativeAnimatedModule,
       );
     }
     return nativeEventEmitter;

package/src/private/specs_DEPRECATED/modules/NativeExceptionsManager.js

@@ -70,7 +70,12 @@ const ExceptionsManager = {
     NativeModule.reportSoftException(message, stack, exceptionId);
   },
   dismissRedbox(): void {
-    if (Platform.OS !== 'ios' && NativeModule.dismissRedbox) {
+    // [macOS] RedBox is dismissed natively on Apple platforms.
+    if (
+      Platform.OS !== 'ios' &&
+      Platform.OS !== 'macos' &&
+      NativeModule.dismissRedbox
+    ) {
       // TODO(T53311281): This is a noop on iOS now. Implement it.
       NativeModule.dismissRedbox();
     }