not-react-native-macos 0.87.1-rc.5 → 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/Components/View/ViewPropTypes.js

@@ -22,6 +22,7 @@ import type {
   LayoutChangeEvent,
   LayoutRectangle,
   MouseEvent,
+  NativeSyntheticEvent, // [macOS] DragEvent below is built on it
   PointerEvent,
 } from '../../Types/CoreEventTypes';
 import type {
@@ -146,7 +147,73 @@ export type HandledKeyEvent = Readonly<{
   shiftKey?: ?boolean,
 }>;
 
+/**
+ * A dragged file, or dragged image data with no file behind it -- in which case
+ * `uri` is a data: URL rather than a path.
+ *
+ * @platform macos
+ */
+export type DataTransferFile = Readonly<{
+  name: string,
+  type: string,
+  uri: string,
+  size?: number,
+  width?: number,
+  height?: number,
+}>;
+
+/**
+ * The pasteboard contents of a drag, shaped like the DOM DataTransfer.
+ *
+ * @platform macos
+ */
+export type DataTransfer = Readonly<{
+  files: $ReadOnlyArray<DataTransferFile>,
+  items: $ReadOnlyArray<Readonly<{kind: string, type: string}>>,
+  types: $ReadOnlyArray<string>,
+}>;
+
+export type DragEvent = NativeSyntheticEvent<
+  Readonly<{
+    clientX: number,
+    clientY: number,
+    pageX: number,
+    pageY: number,
+    screenX: number,
+    screenY: number,
+    altKey: boolean,
+    ctrlKey: boolean,
+    metaKey: boolean,
+    shiftKey: boolean,
+    button: number,
+    dataTransfer: DataTransfer,
+  }>,
+>;
+
 type MacOSViewProps = Readonly<{
+  /**
+   * What kinds of dragged content the view accepts: 'fileUrl', 'image',
+   * 'string'. Required for the drag handlers to fire at all -- AppKit routes a
+   * drag only to views that registered for one of the pasteboard types it
+   * carries.
+   *
+   * @platform macos
+   */
+  draggedTypes?: ?$ReadOnlyArray<'fileUrl' | 'image' | 'string'>,
+
+  /**
+   * Called as a drag enters, leaves, or is released over the view.
+   *
+   * @platform macos
+   */
+  onDragEnter?: ?(event: DragEvent) => void,
+
+  /** @platform macos */
+  onDragLeave?: ?(event: DragEvent) => void,
+
+  /** @platform macos */
+  onDrop?: ?(event: DragEvent) => void,
+
   /**
    * Keys this view handles itself, suppressing AppKit's own interpretation of
    * them -- Tab moving focus, Escape cancelling, an unclaimed key beeping.

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/NativeComponent/BaseViewConfig.macos.js

@@ -44,11 +44,15 @@ const directEventTypes = {
   topAuxClick: {registrationName: 'onAuxClick'},
   topMouseEnter: {registrationName: 'onMouseEnter'},
   topMouseLeave: {registrationName: 'onMouseLeave'},
+  topDragEnter: {registrationName: 'onDragEnter'},
+  topDragLeave: {registrationName: 'onDragLeave'},
+  topDrop: {registrationName: 'onDrop'},
 };
 
 const validAttributesForNonEventProps = {
   acceptsFirstMouse: true,
   allowsVibrancy: true,
+  draggedTypes: true,
   enableFocusRing: true,
   focusable: true,
   keyDownEvents: true,
@@ -60,6 +64,9 @@ const validAttributesForNonEventProps = {
 const validAttributesForEventProps = ConditionallyIgnoredEventHandlers({
   onAuxClick: true,
   onDoubleClick: true,
+  onDragEnter: true,
+  onDragLeave: true,
+  onDrop: true,
   onKeyDown: true,
   onKeyUp: true,
   onMouseEnter: true,

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/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -23,6 +23,11 @@
 #import <React/RCTLinearGradient.h>
 #import <React/RCTLocalizedString.h>
 #import <React/RCTRadialGradient.h>
+#if TARGET_OS_OSX // [macOS] drag and drop: RCTDataURL for dragged image data,
+                  // UTType to name what was dropped.
+#import <React/RCTUtils.h>
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+#endif // macOS]
 #import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/renderer/components/view/ViewComponentDescriptor.h>
 #import <react/renderer/components/view/ViewEventEmitter.h>
@@ -664,6 +669,38 @@ static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
   if (oldViewProps.hostPlatformEvents != newViewProps.hostPlatformEvents) {
     [self _updateMouseTracking:newViewProps.hostPlatformEvents.wantsMouseTracking()];
   }
+
+  if (oldViewProps.draggedTypes != newViewProps.draggedTypes) {
+    [self _updateDraggedTypes:newViewProps.draggedTypes];
+  }
+}
+
+/**
+ * AppKit delivers a drag only to views that registered for one of the
+ * pasteboard types it carries, so without this the drag handlers are
+ * unreachable. The three names are the kinds React Native models; each maps to
+ * the pasteboard types AppKit actually uses for it.
+ */
+- (void)_updateDraggedTypes:(const std::vector<std::string> &)draggedTypes
+{
+  [self unregisterDraggedTypes];
+
+  if (draggedTypes.empty()) {
+    return;
+  }
+
+  NSMutableArray<NSPasteboardType> *types = [NSMutableArray arrayWithCapacity:draggedTypes.size()];
+  for (const auto &draggedType : draggedTypes) {
+    if (draggedType == "fileUrl") {
+      [types addObject:NSPasteboardTypeFileURL];
+    } else if (draggedType == "image") {
+      [types addObject:NSPasteboardTypePNG];
+      [types addObject:NSPasteboardTypeTIFF];
+    } else if (draggedType == "string") {
+      [types addObject:NSPasteboardTypeString];
+    }
+  }
+  [self registerForDraggedTypes:types];
 }
 
 /**
@@ -741,6 +778,150 @@ static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
   }
 }
 
+#pragma mark - Drag and Drop Events
+
+/**
+ * The pasteboard, shaped like the DOM DataTransfer so a drop handler reads the
+ * same on macOS as on the web.
+ *
+ * Dragged files are reported by path. Dragged image *data* -- an image dragged
+ * out of a browser, say, with no file behind it -- has no path to give, so it
+ * is reported as a data: URL instead; `uri` is what a consumer feeds to
+ * <Image> either way.
+ */
+- (DataTransfer)_dataTransferForPasteboard:(NSPasteboard *)pasteboard
+{
+  DataTransfer dataTransfer{};
+
+  NSArray<NSURL *> *fileURLs = [pasteboard readObjectsForClasses:@[ [NSURL class] ]
+                                                         options:@{NSPasteboardURLReadingFileURLsOnlyKey : @YES}]
+      ?: @[];
+
+  for (NSURL *fileURL in fileURLs) {
+    BOOL isDirectory = NO;
+    if (![NSFileManager.defaultManager fileExistsAtPath:fileURL.path isDirectory:&isDirectory] || isDirectory) {
+      continue;
+    }
+
+    UTType *type = [UTType typeWithFilenameExtension:fileURL.pathExtension];
+    NSString *mimeType = type.preferredMIMEType;
+    std::string typeString = mimeType != nil ? mimeType.UTF8String : "";
+
+    DataTransferFile file = {
+        .name = fileURL.lastPathComponent != nil ? fileURL.lastPathComponent.UTF8String : "",
+        .type = typeString,
+        .uri = fileURL.path != nil ? fileURL.path.UTF8String : "",
+    };
+
+    NSNumber *fileSize = nil;
+    if ([fileURL getResourceValue:&fileSize forKey:NSURLFileSizeKey error:NULL]) {
+      file.size = fileSize.intValue;
+    }
+
+    if ([mimeType hasPrefix:@"image/"]) {
+      NSImage *image = [[NSImage alloc] initWithContentsOfURL:fileURL];
+      CGImageRef cgImage = [image CGImageForProposedRect:NULL context:nil hints:nil];
+      if (cgImage != NULL) {
+        file.width = static_cast<int>(CGImageGetWidth(cgImage));
+        file.height = static_cast<int>(CGImageGetHeight(cgImage));
+      }
+    }
+
+    dataTransfer.files.push_back(file);
+    dataTransfer.items.push_back({.kind = "file", .type = typeString});
+    dataTransfer.types.push_back(typeString);
+  }
+
+  NSPasteboardType imageType = [pasteboard availableTypeFromArray:@[ NSPasteboardTypePNG, NSPasteboardTypeTIFF ]];
+  if (imageType != nil && fileURLs.count == 0) {
+    NSString *mimeType = [imageType isEqualToString:NSPasteboardTypePNG] ? UTTypePNG.preferredMIMEType
+                                                                        : UTTypeTIFF.preferredMIMEType;
+    NSData *imageData = [pasteboard dataForType:imageType];
+    std::string typeString = mimeType != nil ? mimeType.UTF8String : "";
+
+    NSString *dataURL = RCTDataURL(mimeType, imageData).absoluteString;
+    DataTransferFile file = {
+        .name = "",
+        .type = typeString,
+        .uri = dataURL != nil ? dataURL.UTF8String : "",
+    };
+    file.size = static_cast<int>(imageData.length);
+
+    NSImage *image = [[NSImage alloc] initWithData:imageData];
+    CGImageRef cgImage = [image CGImageForProposedRect:NULL context:nil hints:nil];
+    if (cgImage != NULL) {
+      file.width = static_cast<int>(CGImageGetWidth(cgImage));
+      file.height = static_cast<int>(CGImageGetHeight(cgImage));
+    }
+
+    dataTransfer.files.push_back(file);
+    dataTransfer.items.push_back({.kind = "image", .type = typeString});
+    dataTransfer.types.push_back(typeString);
+  }
+
+  return dataTransfer;
+}
+
+- (DragEvent)_dragEventFromDraggingInfo:(id<NSDraggingInfo>)info
+{
+  NSPoint inWindow = info.draggingLocation;
+  NSPoint inView = [self convertPoint:inWindow fromView:nil];
+  NSEventModifierFlags flags = self.window.currentEvent.modifierFlags;
+
+  DragEvent event = {};
+  event.clientX = inView.x;
+  event.clientY = inView.y;
+  event.pageX = inWindow.x;
+  event.pageY = inWindow.y;
+  event.screenX = inWindow.x;
+  event.screenY = inWindow.y;
+  event.altKey = static_cast<bool>(flags & NSEventModifierFlagOption);
+  event.ctrlKey = static_cast<bool>(flags & NSEventModifierFlagControl);
+  event.shiftKey = static_cast<bool>(flags & NSEventModifierFlagShift);
+  event.metaKey = static_cast<bool>(flags & NSEventModifierFlagCommand);
+  event.dataTransfer = [self _dataTransferForPasteboard:info.draggingPasteboard];
+  return event;
+}
+
+- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
+{
+  if (_eventEmitter != nullptr) {
+    _eventEmitter->onDragEnter([self _dragEventFromDraggingInfo:sender]);
+  }
+
+  // The answer is the cursor the user sees, so it has to reflect what this view
+  // would actually accept -- claiming a drag the pasteboard cannot satisfy shows
+  // a drop cursor over content that will refuse it.
+  if ([sender.draggingPasteboard availableTypeFromArray:self.registeredDraggedTypes] == nil) {
+    return NSDragOperationNone;
+  }
+
+  NSDragOperation offered = sender.draggingSourceOperationMask;
+  if (offered & NSDragOperationLink) {
+    return NSDragOperationLink;
+  }
+  if (offered & NSDragOperationCopy) {
+    return NSDragOperationCopy;
+  }
+  return NSDragOperationNone;
+}
+
+- (void)draggingExited:(id<NSDraggingInfo>)sender
+{
+  if (_eventEmitter != nullptr) {
+    _eventEmitter->onDragLeave([self _dragEventFromDraggingInfo:sender]);
+  }
+}
+
+- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender
+{
+  if (_eventEmitter == nullptr) {
+    return NO;
+  }
+  _eventEmitter->onDrop([self _dragEventFromDraggingInfo:sender]);
+  return YES;
+}
+
 #pragma mark - Keyboard Events
 
 /**

package/React/React-RCTFabric.podspec

@@ -50,6 +50,10 @@ Pod::Spec.new do |s|
   s.module_name            = module_name
   s.weak_framework         = "JavaScriptCore"
   s.framework              = "MobileCoreServices"
+  # [macOS] Drag and drop names what was dropped with UTType. On iOS the symbols
+  # come in with MobileCoreServices; the macOS remap of that is CoreServices,
+  # which does not carry them.
+  s.osx.framework          = "UniformTypeIdentifiers"
   s.pod_target_xcconfig    = {
     "HEADER_SEARCH_PATHS" => header_search_paths,
     "OTHER_CFLAGS" => "$(inherited) " + new_arch_flags,

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewEventEmitter.cpp

@@ -11,7 +11,8 @@
 
 namespace facebook::react {
 
-static jsi::Value mouseEventPayload(jsi::Runtime &runtime, const HostPlatformViewEventEmitter::MouseEvent &event)
+// Returns an Object, not a Value: dragEventPayload starts from one and adds to it.
+static jsi::Object mouseEventPayload(jsi::Runtime &runtime, const MouseEvent &event)
 {
   auto payload = jsi::Object(runtime);
   payload.setProperty(runtime, "clientX", event.clientX);
@@ -71,4 +72,63 @@ RCT_MACOS_MOUSE_EVENT(onAuxClick)
 RCT_MACOS_KEY_EVENT(onKeyDown)
 RCT_MACOS_KEY_EVENT(onKeyUp)
 
+static jsi::Value dragEventPayload(jsi::Runtime &runtime, const DragEvent &event)
+{
+  auto dataTransfer = jsi::Object(runtime);
+
+  auto files = jsi::Array(runtime, event.dataTransfer.files.size());
+  for (size_t i = 0; i < event.dataTransfer.files.size(); i++) {
+    const auto &file = event.dataTransfer.files[i];
+    auto entry = jsi::Object(runtime);
+    entry.setProperty(runtime, "name", jsi::String::createFromUtf8(runtime, file.name));
+    entry.setProperty(runtime, "type", jsi::String::createFromUtf8(runtime, file.type));
+    entry.setProperty(runtime, "uri", jsi::String::createFromUtf8(runtime, file.uri));
+    // Absent rather than zero when unknown: a directory has no meaningful size,
+    // and only an image has dimensions.
+    if (file.size.has_value()) {
+      entry.setProperty(runtime, "size", *file.size);
+    }
+    if (file.width.has_value()) {
+      entry.setProperty(runtime, "width", *file.width);
+    }
+    if (file.height.has_value()) {
+      entry.setProperty(runtime, "height", *file.height);
+    }
+    files.setValueAtIndex(runtime, i, entry);
+  }
+  dataTransfer.setProperty(runtime, "files", files);
+
+  auto items = jsi::Array(runtime, event.dataTransfer.items.size());
+  for (size_t i = 0; i < event.dataTransfer.items.size(); i++) {
+    const auto &item = event.dataTransfer.items[i];
+    auto entry = jsi::Object(runtime);
+    entry.setProperty(runtime, "kind", jsi::String::createFromUtf8(runtime, item.kind));
+    entry.setProperty(runtime, "type", jsi::String::createFromUtf8(runtime, item.type));
+    items.setValueAtIndex(runtime, i, entry);
+  }
+  dataTransfer.setProperty(runtime, "items", items);
+
+  auto types = jsi::Array(runtime, event.dataTransfer.types.size());
+  for (size_t i = 0; i < event.dataTransfer.types.size(); i++) {
+    types.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, event.dataTransfer.types[i]));
+  }
+  dataTransfer.setProperty(runtime, "types", types);
+
+  auto payload = mouseEventPayload(runtime, event);
+  payload.setProperty(runtime, "dataTransfer", dataTransfer);
+  return payload;
+}
+
+#define RCT_MACOS_DRAG_EVENT(name)                                                    \
+  void HostPlatformViewEventEmitter::name(const DragEvent &event) const               \
+  {                                                                                   \
+    dispatchEvent(#name, [event](jsi::Runtime &runtime) {                             \
+      return dragEventPayload(runtime, event);                                        \
+    });                                                                               \
+  }
+
+RCT_MACOS_DRAG_EVENT(onDragEnter)
+RCT_MACOS_DRAG_EVENT(onDragLeave)
+RCT_MACOS_DRAG_EVENT(onDrop)
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewEventEmitter.h

@@ -12,6 +12,7 @@
 #include <react/renderer/components/view/BaseViewEventEmitter.h>
 
 #include "KeyEvent.h"
+#include "MouseEvent.h"
 
 namespace facebook::react {
 
@@ -20,25 +21,10 @@ class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
   using BaseViewEventEmitter::BaseViewEventEmitter;
 
   /**
-   * A mouse crossing into or out of the view. There is no touch equivalent, so
-   * these have no counterpart in BaseViewEventEmitter.
+   * Named here as well so `HostPlatformViewEventEmitter::MouseEvent` keeps
+   * working; the type itself is free-standing, in MouseEvent.h.
    */
-  struct MouseEvent {
-    Float clientX{};
-    Float clientY{};
-    Float screenX{};
-    Float screenY{};
-    Float pageX{};
-    Float pageY{};
-
-    bool altKey{false};
-    bool ctrlKey{false};
-    bool shiftKey{false};
-    bool metaKey{false};
-
-    /** DOM button numbering: 0 left, 1 middle, 2 right. */
-    int button{0};
-  };
+  using MouseEvent = ::facebook::react::MouseEvent;
 
   void onMouseEnter(const MouseEvent &event) const;
   void onMouseLeave(const MouseEvent &event) const;
@@ -47,6 +33,16 @@ class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
 
   void onKeyDown(const KeyEvent &event) const;
   void onKeyUp(const KeyEvent &event) const;
+
+  /**
+   * A drag passing over or finishing on the view. Only reported for views that
+   * registered interest through the `draggedTypes` prop -- AppKit routes a drag
+   * to the topmost view that registered for one of the pasteboard types it
+   * carries, and ignores the rest.
+   */
+  void onDragEnter(const DragEvent &event) const;
+  void onDragLeave(const DragEvent &event) const;
+  void onDrop(const DragEvent &event) const;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewEvents.h

@@ -20,7 +20,7 @@
 namespace facebook::react {
 
 struct HostPlatformViewEvents {
-  std::bitset<8> bits{};
+  std::bitset<16> bits{};
 
   enum class Offset : std::size_t {
     MouseEnter = 0,
@@ -29,6 +29,9 @@ struct HostPlatformViewEvents {
     AuxClick = 3,
     KeyDown = 4,
     KeyUp = 5,
+    DragEnter = 6,
+    DragLeave = 7,
+    Drop = 8,
   };
 
   constexpr bool operator[](Offset offset) const
@@ -36,7 +39,7 @@ struct HostPlatformViewEvents {
     return bits[static_cast<std::size_t>(offset)];
   }
 
-  std::bitset<8>::reference operator[](Offset offset)
+  std::bitset<16>::reference operator[](Offset offset)
   {
     return bits[static_cast<std::size_t>(offset)];
   }

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -35,6 +35,9 @@ static inline HostPlatformViewEvents convertRawProp(
   RCT_MACOS_CONVERT_EVENT("onAuxClick", AuxClick);
   RCT_MACOS_CONVERT_EVENT("onKeyDown", KeyDown);
   RCT_MACOS_CONVERT_EVENT("onKeyUp", KeyUp);
+  RCT_MACOS_CONVERT_EVENT("onDragEnter", DragEnter);
+  RCT_MACOS_CONVERT_EVENT("onDragLeave", DragLeave);
+  RCT_MACOS_CONVERT_EVENT("onDrop", Drop);
 
 #undef RCT_MACOS_CONVERT_EVENT
 
@@ -63,6 +66,7 @@ HostPlatformViewProps::HostPlatformViewProps(
       RCT_MACOS_PROP(enableFocusRing),
       RCT_MACOS_PROP(keyDownEvents),
       RCT_MACOS_PROP(keyUpEvents),
+      RCT_MACOS_PROP(draggedTypes),
       RCT_MACOS_PROP(tooltip),
       RCT_MACOS_PROP(acceptsFirstMouse),
       RCT_MACOS_PROP(allowsVibrancy),
@@ -105,10 +109,14 @@ void HostPlatformViewProps::setProp(
     RCT_MACOS_EVENT_CASE(AuxClick);
     RCT_MACOS_EVENT_CASE(KeyDown);
     RCT_MACOS_EVENT_CASE(KeyUp);
+    RCT_MACOS_EVENT_CASE(DragEnter);
+    RCT_MACOS_EVENT_CASE(DragLeave);
+    RCT_MACOS_EVENT_CASE(Drop);
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
     RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(draggedTypes);
     RAW_SET_PROP_SWITCH_CASE_BASIC(tooltip);
     RAW_SET_PROP_SWITCH_CASE_BASIC(acceptsFirstMouse);
     RAW_SET_PROP_SWITCH_CASE_BASIC(allowsVibrancy);

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewProps.h

@@ -57,6 +57,14 @@ class HostPlatformViewProps : public BaseViewProps {
   std::vector<HandledKey> keyDownEvents{};
   std::vector<HandledKey> keyUpEvents{};
 
+  /**
+   * Which kinds of dragged content the view accepts: "fileUrl", "image",
+   * "string". Empty means the view takes no part in drag and drop -- AppKit
+   * routes a drag only to views that registered for one of its pasteboard
+   * types, so this is what makes onDragEnter/onDrop reachable at all.
+   */
+  std::vector<std::string> draggedTypes{};
+
   /** The view's help tag. std::nullopt leaves any inherited tooltip alone. */
   std::optional<std::string> tooltip{};
 

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -27,7 +27,7 @@ inline bool formsView(const ViewProps &props)
   // has to attach to something, and mouse tracking needs an NSTrackingArea
   // owner. Flattening is otherwise invisible -- the handler simply never fires.
   return props.focusable || props.tooltip.has_value() || props.hostPlatformEvents.bits.any() ||
-      !props.keyDownEvents.empty() || !props.keyUpEvents.empty();
+      !props.keyDownEvents.empty() || !props.keyUpEvents.empty() || !props.draggedTypes.empty();
 }
 
 inline bool isKeyboardFocusable(const ViewProps &props)

package/ReactCommon/react/renderer/components/view/platform/macos/react/renderer/components/view/MouseEvent.h

@@ -0,0 +1,81 @@
+/*
+ * 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.
+ */
+
+// [macOS] Pointer and drag payloads, which only a desktop platform reports.
+//
+// Free-standing rather than nested in the event emitter, because
+// microsoft/react-native-macos puts `facebook::react::MouseEvent` and
+// `DragEvent` here and third-party Fabric components name them directly.
+
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+/** A mouse crossing, click or drag position. Fields follow the DOM MouseEvent. */
+struct MouseEvent {
+  /** Pointer location in the target view. */
+  Float clientX{0};
+  Float clientY{0};
+
+  /** Pointer location in the window. */
+  Float screenX{0};
+  Float screenY{0};
+
+  /**
+   * Pointer location in the window as well. The DOM distinguishes page from
+   * screen coordinates; AppKit has no document scroll offset to make them
+   * differ, so both report the window position.
+   */
+  Float pageX{0};
+  Float pageY{0};
+
+  bool altKey{false};
+  bool ctrlKey{false};
+  bool shiftKey{false};
+  bool metaKey{false};
+
+  /** DOM button numbering: 0 primary, 1 auxiliary, 2 secondary. */
+  int button{0};
+};
+
+/** One dragged file, described the way the DOM File interface does. */
+struct DataTransferFile {
+  std::string name{};
+  std::string type{};
+
+  /** A file path for a dragged file, or a data: URL for dragged image data. */
+  std::string uri{};
+
+  std::optional<int> size{};
+  std::optional<int> width{};
+  std::optional<int> height{};
+};
+
+struct DataTransferItem {
+  /** "file" or "image". */
+  std::string kind{};
+  std::string type{};
+};
+
+/** The pasteboard contents of a drag, shaped like the DOM DataTransfer. */
+struct DataTransfer {
+  std::vector<DataTransferFile> files{};
+  std::vector<DataTransferItem> items{};
+  std::vector<std::string> types{};
+};
+
+struct DragEvent : MouseEvent {
+  DataTransfer dataTransfer{};
+};
+
+} // namespace facebook::react

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.5",
+  "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();
     }