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

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

@@ -142,9 +142,19 @@ typedef NS_ENUM(NSInteger, UIKeyboardAppearance) {
 - (void)textViewDidBeginEditing:(id)textView;
 - (void)textViewDidChange:(id)textView;
 - (void)textViewDidEndEditing:(id)textView;
+- (void)textViewDidChangeSelection:(id)textView;
 @end
 
-@interface UITextField : NSTextField <UITextInput, UITextInputTraits>
+// The runtime name is deliberately not `UITextField`.
+//
+// The compile-time name is what this shim is for, and @compatibility_alias
+// gives that without registering the name with the ObjC runtime. That matters:
+// several Apple frameworks decide whether a process is Catalyst by asking
+// NSClassFromString for a UIKit class. macOS's one-time-code AutoFill does it
+// for the field that holds focus, and answering yes sends it into
+// UIKitMacHelper, which dlopens a UIKit.framework that does not exist on this
+// platform and takes the process down with it.
+@interface RCTUIKitCompatTextField : NSTextField <UITextInput, UITextInputTraits>
 @property (nonatomic, assign) UIKeyboardType keyboardType;
 @property (nonatomic, assign) UIReturnKeyType returnKeyType;
 @property (nonatomic, assign) UITextAutocapitalizationType autocapitalizationType;
@@ -158,6 +168,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:.
@@ -184,6 +223,7 @@ typedef NS_ENUM(NSInteger, UIKeyboardAppearance) {
 - (void)removeTarget:(nullable id)target action:(nullable SEL)action forControlEvents:(UIControlEvents)controlEvents;
 @property (nonatomic, weak, nullable) id<UITextDropDelegate> textDropDelegate;
 @end
+@compatibility_alias UITextField RCTUIKitCompatTextField;
 
 // UIKit's per-rect selection geometry. NSTextView exposes selection as ranges,
 // so this is a value object the text layer fills in.
@@ -219,6 +259,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,209 @@
 
 @end
 
-@implementation UITextField
+@implementation RCTUIKitCompatTextField {
+  NSDictionary<NSAttributedStringKey, id> *_typingAttributes;
+  NSMutableArray<NSArray *> *_controlEventTargets;
+}
 
 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;
+  }
+}
+
+/**
+ * NSTextField arrives configured as a form control: bezelled, opaque, and with
+ * its own focus ring. React Native draws all of that itself on the view that
+ * owns this one, so the field has to be stripped back to just the text.
+ *
+ * `selectable` is the one that matters for behaviour rather than looks. AppKit
+ * will not begin editing a field it cannot select -- `acceptsFirstResponder`
+ * returns NO, the click does nothing, and no field editor is ever installed.
+ */
+
+/**
+ * A click on text input must never drag the window.
+ *
+ * React Native's view defaults `mouseDownCanMoveWindow` to YES, matching
+ * AppKit, and AppKit asks the view under the cursor before delivering the
+ * event at all -- so a text view that inherits YES swallows its own clicks and
+ * starts a zero-pixel window drag instead. There is no mouseDown to debug,
+ * which is what makes it worth a comment.
+ */
+- (BOOL)mouseDownCanMoveWindow
+{
+  return NO;
+}
+
+- (void)uikitCompat_configureForTextInput
+{
+  [super setEditable:YES];
+  self.selectable = YES;
+  self.bezeled = NO;
+  self.bordered = NO;
+  self.drawsBackground = NO;
+  self.focusRingType = NSFocusRingTypeNone;
+  self.usesSingleLineMode = YES;
+  self.cell.scrollable = YES;
+  self.cell.wraps = NO;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self uikitCompat_configureForTextInput];
+  }
+  return self;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder
+{
+  if (self = [super initWithCoder:coder]) {
+    [self uikitCompat_configureForTextInput];
+  }
+  return self;
+}
+
+/**
+ * React Native has no `editable` on UITextField, so RCTUITextField maps the
+ * prop onto `enabled` -- and overrides `isEditable` to answer from it. That
+ * leaves AppKit's own editable and selectable flags untouched, which is what
+ * actually decides whether a click starts editing. Keep them in step here,
+ * where the mapping is visible, rather than asking upstream to know about it.
+ */
+- (void)setEnabled:(BOOL)enabled
+{
+  [super setEnabled:enabled];
+  [super setEditable:enabled];
+  self.selectable = enabled;
+}
+
+- (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];
@@ -149,16 +348,131 @@ UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
   return [self respondsToSelector:action];
 }
 
-- (void)addTarget:(id)target action:(SEL)action forControlEvents:(__unused UIControlEvents)controlEvents
+/**
+ * UIKit registers a target/action pair per control event; NSControl carries
+ * exactly one pair, fired when editing *ends*. Collapsing the two loses the
+ * distinction that matters most here -- RCTBackedTextFieldDelegateAdapter
+ * registers for EditingChanged and EditingDidEndOnExit, and with one slot the
+ * second registration silently replaces the first. The result is an input that
+ * accepts typing and never reports it, which is how `onChangeText` came to
+ * never fire.
+ *
+ * So the pairs are kept per event here, and driven from the AppKit
+ * notifications that actually correspond to them.
+ */
+- (void)addTarget:(id)target action:(SEL)action forControlEvents:(UIControlEvents)controlEvents
+{
+  if (target == nil || action == NULL) {
+    return;
+  }
+  if (_controlEventTargets == nil) {
+    _controlEventTargets = [NSMutableArray new];
+  }
+  [_controlEventTargets addObject:@[
+    [NSValue valueWithNonretainedObject:target],
+    [NSValue valueWithPointer:action],
+    @(controlEvents),
+  ]];
+}
+
+- (void)removeTarget:(id)target action:(SEL)action forControlEvents:(UIControlEvents)events
+{
+  NSMutableArray *kept = [NSMutableArray new];
+  for (NSArray *entry in _controlEventTargets) {
+    id entryTarget = [entry[0] nonretainedObjectValue];
+    SEL entryAction = (SEL)[entry[1] pointerValue];
+    UIControlEvents entryEvents = (UIControlEvents)[entry[2] unsignedIntegerValue];
+    BOOL matches = (target == nil || entryTarget == target) && (action == NULL || entryAction == action) &&
+        (entryEvents & events) != 0;
+    if (!matches) {
+      [kept addObject:entry];
+    }
+  }
+  _controlEventTargets = kept;
+}
+
+- (void)uikitCompat_sendActionsForControlEvents:(UIControlEvents)controlEvents
+{
+  // Copied first: an action is free to add or remove targets while running.
+  for (NSArray *entry in [_controlEventTargets copy]) {
+    if (((UIControlEvents)[entry[2] unsignedIntegerValue] & controlEvents) == 0) {
+      continue;
+    }
+    id target = [entry[0] nonretainedObjectValue];
+    SEL action = (SEL)[entry[1] pointerValue];
+    if ([target respondsToSelector:action]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+      [target performSelector:action withObject:self];
+#pragma clang diagnostic pop
+    }
+  }
+}
+
+/**
+ * The delegate, as UIKit's protocol rather than AppKit's.
+ *
+ * NSTextField calls `controlTextDidBeginEditing:` and friends; the adapter on
+ * the React Native side implements `textFieldDidBeginEditing:` and friends.
+ * Same events, different selectors, so nothing was ever called -- which is why
+ * `onFocus`, `onBlur` and `onSubmitEditing` stayed silent while typing itself
+ * worked.
+ */
+- (id<UITextFieldDelegate>)uikitCompat_uiDelegate
+{
+  id delegate = self.delegate;
+  return [delegate conformsToProtocol:@protocol(UITextFieldDelegate)] ? delegate : nil;
+}
+
+// NSControl's own hooks, called by the field editor. Preferred over the
+// matching notifications: the notifications are posted onward to the control's
+// delegate, and observing them from the control itself turned out not to see
+// begin and end at all.
+- (void)textDidBeginEditing:(NSNotification *)notification
 {
-  self.target = target;
-  self.action = action;
+  [super textDidBeginEditing:notification];
+  [self uikitCompat_sendActionsForControlEvents:UIControlEventEditingDidBegin];
+
+  id<UITextFieldDelegate> delegate = [self uikitCompat_uiDelegate];
+  if ([delegate respondsToSelector:@selector(textFieldDidBeginEditing:)]) {
+    [delegate textFieldDidBeginEditing:self];
+  }
+}
+
+- (void)textDidChange:(NSNotification *)notification
+{
+  [super textDidChange:notification];
+  [self uikitCompat_sendActionsForControlEvents:UIControlEventEditingChanged];
 }
 
-- (void)removeTarget:(__unused id)target action:(__unused SEL)action forControlEvents:(__unused UIControlEvents)events
+/**
+ * AppKit reports *why* editing ended in the notification's text movement.
+ * Return is what UIKit calls EditingDidEndOnExit -- the submit -- while
+ * clicking away or tabbing out is a plain EditingDidEnd.
+ */
+- (void)textDidEndEditing:(NSNotification *)notification
 {
-  self.target = nil;
-  self.action = NULL;
+  [super textDidEndEditing:notification];
+
+  NSNumber *movement = notification.userInfo[@"NSTextMovement"];
+  BOOL submitted = movement.integerValue == NSReturnTextMovement;
+  id<UITextFieldDelegate> delegate = [self uikitCompat_uiDelegate];
+
+  // Return is a submit before it is an end-of-editing, and the order matters:
+  // onSubmitEditing should carry the text, which onBlur may go on to clear.
+  if (submitted && [delegate respondsToSelector:@selector(textFieldShouldReturn:)]) {
+    [delegate textFieldShouldReturn:self];
+  }
+
+  UIControlEvents events = UIControlEventEditingDidEnd;
+  if (submitted) {
+    events |= UIControlEventEditingDidEndOnExit;
+  }
+  [self uikitCompat_sendActionsForControlEvents:events];
+
+  if ([delegate respondsToSelector:@selector(textFieldDidEndEditing:)]) {
+    [delegate textFieldDidEndEditing:self];
+  }
 }
 
 - (id<UITextDropDelegate>)textDropDelegate
@@ -223,6 +537,202 @@ UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
 
 @implementation UITextView
 
+/**
+ * The delegate, as UIKit's protocol rather than AppKit's -- the same mismatch
+ * UITextField has. NSTextView tells its delegate through `textDidChange:` and
+ * `textViewDidChangeSelection:`; the React Native adapter listens for
+ * `textViewDidChange:` and the rest of the UIKit set. Without the bridge a
+ * multiline input accepts typing and reports none of it.
+ */
+
+/**
+ * A click on text input must never drag the window.
+ *
+ * React Native's view defaults `mouseDownCanMoveWindow` to YES, matching
+ * AppKit, and AppKit asks the view under the cursor before delivering the
+ * event at all -- so a text view that inherits YES swallows its own clicks and
+ * starts a zero-pixel window drag instead. There is no mouseDown to debug,
+ * which is what makes it worth a comment.
+ */
+- (BOOL)mouseDownCanMoveWindow
+{
+  return NO;
+}
+
+/**
+ * NSTextView sizes itself to its text; UITextView fills the frame it is given.
+ * Left alone, a multiline input collapses to a single line's height -- it looks
+ * right, because React Native's own view draws the background behind it, but
+ * only that top strip is hit-testable, so clicking anywhere below the first
+ * line does nothing at all.
+ *
+ * Fixed height with a width-tracking container is what matches UITextView:
+ * the text wraps to the width, and the view keeps whatever height layout gave
+ * it.
+ */
+- (void)uikitCompat_configureForTextInput
+{
+  self.drawsBackground = NO;
+  self.richText = NO;
+  self.importsGraphics = NO;
+  self.allowsUndo = YES;
+  self.minSize = NSMakeSize(0, 0);
+  self.maxSize = NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX);
+  self.verticallyResizable = NO;
+  self.horizontallyResizable = NO;
+  self.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  self.textContainer.widthTracksTextView = YES;
+  self.textContainer.heightTracksTextView = YES;
+  self.textContainer.lineFragmentPadding = 0;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self uikitCompat_configureForTextInput];
+  }
+  return self;
+}
+
+- (instancetype)initWithFrame:(NSRect)frame textContainer:(NSTextContainer *)container
+{
+  if (self = [super initWithFrame:frame textContainer:container]) {
+    [self uikitCompat_configureForTextInput];
+  }
+  return self;
+}
+
+- (id<UITextViewDelegate>)uikitCompat_uiDelegate
+{
+  id delegate = self.delegate;
+  return [delegate conformsToProtocol:@protocol(UITextViewDelegate)] ? delegate : nil;
+}
+
+// NSTextView funnels every edit through here, including paste, drops and
+// undo -- which a keystroke-level hook would miss.
+- (void)didChangeText
+{
+  [super didChangeText];
+  id<UITextViewDelegate> delegate = [self uikitCompat_uiDelegate];
+  if ([delegate respondsToSelector:@selector(textViewDidChange:)]) {
+    [delegate textViewDidChange:self];
+  }
+}
+
+- (void)setSelectedRange:(NSRange)range affinity:(NSSelectionAffinity)affinity stillSelecting:(BOOL)stillSelecting
+{
+  [super setSelectedRange:range affinity:affinity stillSelecting:stillSelecting];
+  id<UITextViewDelegate> delegate = [self uikitCompat_uiDelegate];
+  if ([delegate respondsToSelector:@selector(textViewDidChangeSelection:)]) {
+    [delegate textViewDidChangeSelection:self];
+  }
+}
+
+// NSTextView is its own responder rather than borrowing the window's field
+// editor, so begin and end editing are the responder transitions themselves.
+- (BOOL)becomeFirstResponder
+{
+  if (![super becomeFirstResponder]) {
+    return NO;
+  }
+  id<UITextViewDelegate> delegate = [self uikitCompat_uiDelegate];
+  if ([delegate respondsToSelector:@selector(textViewDidBeginEditing:)]) {
+    [delegate textViewDidBeginEditing:self];
+  }
+  return YES;
+}
+
+- (BOOL)resignFirstResponder
+{
+  if (![super resignFirstResponder]) {
+    return NO;
+  }
+  id<UITextViewDelegate> delegate = [self uikitCompat_uiDelegate];
+  if ([delegate respondsToSelector:@selector(textViewDidEndEditing:)]) {
+    [delegate textViewDidEndEditing:self];
+  }
+  return YES;
+}
+
+@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.8",
   "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();
     }