not-react-native-macos 0.87.1-rc.3 → 0.87.1-rc.5

package/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -10,6 +10,7 @@
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <QuartzCore/QuartzCore.h>
+#import <algorithm> // [macOS] std::find, for matching a press against keyDownEvents
 #import <objc/runtime.h>
 #import <ranges>
 
@@ -55,6 +56,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   NSMutableSet<NSString *> *_accessibilityOrderNativeIDs;
   RCTSwiftUIContainerViewWrapper *_swiftUIWrapper;
   BOOL _focusable;
+#if TARGET_OS_OSX // [macOS
+  // AppKit reads these rather than being told them, so they are answered from
+  // stored values by the overrides further down.
+  BOOL _allowsVibrancy;
+  BOOL _mouseDownCanMoveWindow;
+  NSTrackingArea *_mouseTrackingArea;
+#endif // macOS]
 }
 
 #ifdef RCT_DYNAMIC_FRAMEWORKS
@@ -69,6 +77,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (self = [super initWithFrame:frame]) {
     _props = ViewShadowNode::defaultSharedProps();
     _reactSubviews = [NSMutableArray new];
+#if TARGET_OS_OSX // [macOS] mirror HostPlatformViewProps' defaults
+    _mouseDownCanMoveWindow = YES;
+    _allowsVibrancy = NO;
+#endif // macOS]
 #if !TARGET_OS_TV
     self.multipleTouchEnabled = YES;
 #endif
@@ -608,9 +620,275 @@ static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
 
   _needsInvalidateLayer = _needsInvalidateLayer || needsInvalidateLayer;
 
+#if TARGET_OS_OSX // [macOS
+  [self _updateMacOSProps:oldViewProps newProps:newViewProps];
+#endif // macOS]
+
   _props = std::static_pointer_cast<const ViewProps>(props);
 }
 
+#if TARGET_OS_OSX // [macOS
+/**
+ * The props AppKit has and UIKit does not. They are declared in
+ * HostPlatformViewProps, so `ViewProps` already carries them on this platform.
+ */
+- (void)_updateMacOSProps:(const ViewProps &)oldViewProps newProps:(const ViewProps &)newViewProps
+{
+  if (oldViewProps.tooltip != newViewProps.tooltip) {
+    self.toolTip = newViewProps.tooltip.has_value() ? RCTNSStringFromString(*newViewProps.tooltip) : nil;
+  }
+
+  if (oldViewProps.acceptsFirstMouse != newViewProps.acceptsFirstMouse) {
+    self.acceptsFirstMouse = newViewProps.acceptsFirstMouse;
+  }
+
+  if (oldViewProps.mouseDownCanMoveWindow != newViewProps.mouseDownCanMoveWindow) {
+    _mouseDownCanMoveWindow = newViewProps.mouseDownCanMoveWindow;
+  }
+
+  if (oldViewProps.enableFocusRing != newViewProps.enableFocusRing) {
+    self.enableFocusRing = newViewProps.enableFocusRing;
+  }
+
+  // -allowsVibrancy and -canBecomeKeyView are read by AppKit rather than set,
+  // so the values are stored and the overrides below answer from them.
+  if (oldViewProps.allowsVibrancy != newViewProps.allowsVibrancy) {
+    _allowsVibrancy = newViewProps.allowsVibrancy;
+    self.needsDisplay = YES;
+  }
+
+  if (oldViewProps.focusable != newViewProps.focusable) {
+    _focusable = newViewProps.focusable;
+  }
+
+  if (oldViewProps.hostPlatformEvents != newViewProps.hostPlatformEvents) {
+    [self _updateMouseTracking:newViewProps.hostPlatformEvents.wantsMouseTracking()];
+  }
+}
+
+/**
+ * A view only tracks the mouse while something is listening. Tracking every
+ * view would cost a dispatch per view per mouse move.
+ */
+- (void)_updateMouseTracking:(BOOL)wanted
+{
+  if (wanted == (_mouseTrackingArea != nil)) {
+    return;
+  }
+
+  if (!wanted) {
+    [self removeTrackingArea:_mouseTrackingArea];
+    _mouseTrackingArea = nil;
+    return;
+  }
+
+  _mouseTrackingArea = [[NSTrackingArea alloc]
+      initWithRect:NSZeroRect
+           options:NSTrackingMouseEnteredAndExited | NSTrackingActiveInKeyWindow | NSTrackingInVisibleRect
+             owner:self
+          userInfo:nil];
+  [self addTrackingArea:_mouseTrackingArea];
+}
+
+- (HostPlatformViewEventEmitter::MouseEvent)_mouseEventFromNSEvent:(NSEvent *)event
+{
+  NSPoint inWindow = event.locationInWindow;
+  NSPoint inView = [self convertPoint:inWindow fromView:nil];
+  NSPoint onScreen = self.window != nil ? [self.window convertPointToScreen:inWindow] : inWindow;
+
+  HostPlatformViewEventEmitter::MouseEvent mouseEvent = {};
+  mouseEvent.clientX = inView.x;
+  mouseEvent.clientY = inView.y;
+  mouseEvent.pageX = inWindow.x;
+  mouseEvent.pageY = inWindow.y;
+  mouseEvent.screenX = onScreen.x;
+  mouseEvent.screenY = onScreen.y;
+  return mouseEvent;
+}
+
+- (void)mouseEntered:(NSEvent *)event
+{
+  [super mouseEntered:event];
+  if (_eventEmitter != nullptr) {
+    _eventEmitter->onMouseEnter([self _mouseEventFromNSEvent:event]);
+  }
+}
+
+- (void)mouseExited:(NSEvent *)event
+{
+  [super mouseExited:event];
+  if (_eventEmitter != nullptr) {
+    _eventEmitter->onMouseLeave([self _mouseEventFromNSEvent:event]);
+  }
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [super mouseUp:event];
+  const auto &viewProps = static_cast<const ViewProps &>(*_props);
+  if (_eventEmitter != nullptr && event.clickCount == 2 &&
+      viewProps.hostPlatformEvents[HostPlatformViewEvents::Offset::DoubleClick]) {
+    _eventEmitter->onDoubleClick([self _mouseEventFromNSEvent:event]);
+  }
+}
+
+- (void)rightMouseUp:(NSEvent *)event
+{
+  [super rightMouseUp:event];
+  const auto &viewProps = static_cast<const ViewProps &>(*_props);
+  if (_eventEmitter != nullptr && viewProps.hostPlatformEvents[HostPlatformViewEvents::Offset::AuxClick]) {
+    _eventEmitter->onAuxClick([self _mouseEventFromNSEvent:event]);
+  }
+}
+
+#pragma mark - Keyboard Events
+
+/**
+ * The W3C `key` name for a press, per https://www.w3.org/TR/uievents-key/.
+ *
+ * `charactersIgnoringModifiers` already gives the right answer for anything
+ * printable. The cases below are the ones where it gives a private-use unichar
+ * (the arrows, the function keys) or a control character (Return, Delete)
+ * instead of a name. Tab and Escape are matched on keyCode rather than
+ * character because AppKit reports them as \t and \e, which would otherwise
+ * arrive as those literal characters.
+ *
+ * Naming follows the cross-platform reconciliation react-native-windows and
+ * react-native-macos both use, so a key handler is portable between them.
+ */
+static NSString *RCTKeyFromNSEvent(NSEvent *event)
+{
+  NSString *characters = event.charactersIgnoringModifiers;
+  unichar code = characters.length > 0 ? [characters characterAtIndex:0] : 0;
+
+  switch (event.keyCode) {
+    case 48:
+      return @"Tab";
+    case 53:
+      return @"Escape";
+    default:
+      break;
+  }
+
+  switch (code) {
+    case NSEnterCharacter:
+    case NSNewlineCharacter:
+    case NSCarriageReturnCharacter:
+      return @"Enter";
+    case NSLeftArrowFunctionKey:
+      return @"ArrowLeft";
+    case NSRightArrowFunctionKey:
+      return @"ArrowRight";
+    case NSUpArrowFunctionKey:
+      return @"ArrowUp";
+    case NSDownArrowFunctionKey:
+      return @"ArrowDown";
+    case NSBackspaceCharacter:
+    case NSDeleteCharacter:
+      return @"Backspace";
+    case NSDeleteFunctionKey:
+      return @"Delete";
+    case NSHomeFunctionKey:
+      return @"Home";
+    case NSEndFunctionKey:
+      return @"End";
+    case NSPageUpFunctionKey:
+      return @"PageUp";
+    case NSPageDownFunctionKey:
+      return @"PageDown";
+    default:
+      break;
+  }
+
+  if (code >= NSF1FunctionKey && code <= NSF12FunctionKey) {
+    return [NSString stringWithFormat:@"F%u", (unsigned)(code - NSF1FunctionKey + 1)];
+  }
+
+  return characters;
+}
+
+/**
+ * Emits the press and reports whether the view claimed it.
+ *
+ * Claiming matters because AppKit interprets an unclaimed key itself once the
+ * responder chain is done with it: Tab moves focus, Escape cancels, anything
+ * else beeps. A view says which keys it means to act on through `keyDownEvents`
+ * / `keyUpEvents`, and only those suppress the default behaviour. Listening via
+ * `onKeyDown` alone deliberately does not, so observing a key does not change
+ * what it does.
+ */
+- (BOOL)_handleKeyboardEvent:(NSEvent *)event
+{
+  NSEventModifierFlags flags = event.modifierFlags;
+  KeyEvent keyEvent = {
+      .key = RCTStringFromNSString(RCTKeyFromNSEvent(event)),
+      .altKey = static_cast<bool>(flags & NSEventModifierFlagOption),
+      .ctrlKey = static_cast<bool>(flags & NSEventModifierFlagControl),
+      .shiftKey = static_cast<bool>(flags & NSEventModifierFlagShift),
+      .metaKey = static_cast<bool>(flags & NSEventModifierFlagCommand),
+      .capsLockKey = static_cast<bool>(flags & NSEventModifierFlagCapsLock),
+      .numericPadKey = static_cast<bool>(flags & NSEventModifierFlagNumericPad),
+      .helpKey = static_cast<bool>(flags & NSEventModifierFlagHelp),
+      .functionKey = static_cast<bool>(flags & NSEventModifierFlagFunction),
+  };
+
+  BOOL isKeyDown = event.type == NSEventTypeKeyDown;
+  const auto &viewProps = static_cast<const ViewProps &>(*_props);
+
+  // Calling super walks the responder chain, which is the view hierarchy, so
+  // every ancestor view would emit the same press. Fabric bubbles the event
+  // through the shadow tree on its own, so only the innermost view should emit.
+  // The flag rides on the NSEvent because that is the one object the whole
+  // chain shares.
+  static const char kEmittedKey = 0;
+  if (_eventEmitter != nullptr && !((NSNumber *)objc_getAssociatedObject(event, &kEmittedKey)).boolValue) {
+    if (isKeyDown) {
+      _eventEmitter->onKeyDown(keyEvent);
+    } else {
+      _eventEmitter->onKeyUp(keyEvent);
+    }
+    objc_setAssociatedObject(event, &kEmittedKey, @YES, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  }
+
+  const auto &handled = isKeyDown ? viewProps.keyDownEvents : viewProps.keyUpEvents;
+  return std::find(handled.cbegin(), handled.cend(), keyEvent) != handled.cend();
+}
+
+- (void)keyDown:(NSEvent *)event
+{
+  if (![self _handleKeyboardEvent:event]) {
+    [super keyDown:event];
+  }
+}
+
+- (void)keyUp:(NSEvent *)event
+{
+  if (![self _handleKeyboardEvent:event]) {
+    [super keyUp:event];
+  }
+}
+
+- (BOOL)allowsVibrancy
+{
+  return _allowsVibrancy;
+}
+
+- (BOOL)mouseDownCanMoveWindow
+{
+  return _mouseDownCanMoveWindow;
+}
+
+- (BOOL)canBecomeKeyView
+{
+  return _focusable;
+}
+
+- (BOOL)acceptsFirstResponder
+{
+  return _focusable || [super acceptsFirstResponder];
+}
+#endif // macOS]
+
 - (void)updateEventEmitter:(const EventEmitter::Shared &)eventEmitter
 {
   assert(std::dynamic_pointer_cast<const ViewEventEmitter>(eventEmitter));
@@ -1772,7 +2050,16 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 
 - (void)focus
 {
+#if TARGET_OS_OSX // [macOS] On AppKit -becomeFirstResponder is the window
+  // notifying the view that it happened, not the view asking. Sending it
+  // directly changes nothing: -makeFirstResponder: is the request. Without
+  // this, `focusable` views never receive key events, because nothing ever
+  // makes them first responder -- AppKit moves focus on Tab only, and only
+  // when Full Keyboard Access is on.
+  [self.window makeFirstResponder:self];
+#else // [macOS]
   [self becomeFirstResponder];
+#endif // [macOS]
 
 #if TARGET_OS_TV
   RCTSurfaceHostingProxyRootView *rootView = [self containingRootView];
@@ -1788,7 +2075,14 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 
 - (void)blur
 {
+#if TARGET_OS_OSX // [macOS] Symmetrically: resigning is granted by the window,
+  // and only if this view still holds the focus.
+  if (self.window.firstResponder == self) {
+    [self.window makeFirstResponder:nil];
+  }
+#else // [macOS]
   [self resignFirstResponder];
+#endif // [macOS]
 }
 
 - (BOOL)becomeFirstResponder

package/ReactCommon/React-Fabric.podspec

@@ -102,6 +102,10 @@ Pod::Spec.new do |s|
         "\"$(PODS_TARGET_SRCROOT)/react/renderer/components/legacyviewmanagerinterop/platform/ios\"",
         "\"$(PODS_TARGET_SRCROOT)/react/renderer/components/text/platform/cxx\"",
         "\"$(PODS_TARGET_SRCROOT)/react/renderer/components/textinput/platform/ios\"",
+        # [macOS] macOS has its own HostPlatformViewProps -- tooltip, focus ring,
+        # first mouse and the rest. Its directory has to come first so it wins
+        # over the shared C++ one. macOS]
+        "\"$(PODS_TARGET_SRCROOT)/react/renderer/components/view/platform/macos\"",
         "\"$(PODS_TARGET_SRCROOT)/react/renderer/components/view/platform/cxx\"",
       ]
     end
@@ -135,6 +139,11 @@ Pod::Spec.new do |s|
       sss.dependency             "React-renderercss"
       sss.dependency             "Yoga"
       sss.source_files         = podspec_sources(["react/renderer/components/view/*.{m,mm,cpp,h}", "react/renderer/components/view/platform/cxx/**/*.{m,mm,cpp,h}"], ["react/renderer/components/view/*.{h}", "react/renderer/components/view/platform/cxx/**/*.{h}"])
+      # [macOS] Swap the shared C++ host-platform view files for the macOS ones.
+      # Both define the same symbols, so this is a replacement, not an addition.
+      sss.osx.source_files     = podspec_sources(["react/renderer/components/view/*.{m,mm,cpp,h}", "react/renderer/components/view/platform/macos/**/*.{m,mm,cpp,h}"], ["react/renderer/components/view/*.{h}", "react/renderer/components/view/platform/macos/**/*.{h}"])
+      sss.osx.exclude_files    = "react/renderer/components/view/platform/cxx/**/*"
+      # macOS]
       sss.header_dir           = "react/renderer/components/view"
     end
 

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

@@ -0,0 +1,16 @@
+/*
+ * 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] Touch is the shared one; a mouse is reported through the same path.
+
+#pragma once
+
+#include <react/renderer/components/view/BaseTouch.h>
+
+namespace facebook::react {
+using HostPlatformTouch = BaseTouch;
+} // namespace facebook::react

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

@@ -0,0 +1,74 @@
+/*
+ * 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] See HostPlatformViewEventEmitter.h.
+
+#include "HostPlatformViewEventEmitter.h"
+
+namespace facebook::react {
+
+static jsi::Value mouseEventPayload(jsi::Runtime &runtime, const HostPlatformViewEventEmitter::MouseEvent &event)
+{
+  auto payload = jsi::Object(runtime);
+  payload.setProperty(runtime, "clientX", event.clientX);
+  payload.setProperty(runtime, "clientY", event.clientY);
+  payload.setProperty(runtime, "screenX", event.screenX);
+  payload.setProperty(runtime, "screenY", event.screenY);
+  payload.setProperty(runtime, "pageX", event.pageX);
+  payload.setProperty(runtime, "pageY", event.pageY);
+  payload.setProperty(runtime, "altKey", event.altKey);
+  payload.setProperty(runtime, "ctrlKey", event.ctrlKey);
+  payload.setProperty(runtime, "shiftKey", event.shiftKey);
+  payload.setProperty(runtime, "metaKey", event.metaKey);
+  payload.setProperty(runtime, "button", event.button);
+  // Pressability's click guard reads this to tell a real mouse click apart from
+  // one synthesised by the responder system, which would otherwise fire onPress
+  // twice.
+  payload.setProperty(runtime, "pointerType", "mouse");
+  return payload;
+}
+
+static jsi::Value keyEventPayload(jsi::Runtime &runtime, const KeyEvent &event)
+{
+  auto payload = jsi::Object(runtime);
+  payload.setProperty(runtime, "key", jsi::String::createFromUtf8(runtime, event.key));
+  payload.setProperty(runtime, "altKey", event.altKey);
+  payload.setProperty(runtime, "ctrlKey", event.ctrlKey);
+  payload.setProperty(runtime, "shiftKey", event.shiftKey);
+  payload.setProperty(runtime, "metaKey", event.metaKey);
+  payload.setProperty(runtime, "capsLockKey", event.capsLockKey);
+  payload.setProperty(runtime, "numericPadKey", event.numericPadKey);
+  payload.setProperty(runtime, "helpKey", event.helpKey);
+  payload.setProperty(runtime, "functionKey", event.functionKey);
+  return payload;
+}
+
+#define RCT_MACOS_MOUSE_EVENT(name)                                                   \
+  void HostPlatformViewEventEmitter::name(const MouseEvent &event) const              \
+  {                                                                                   \
+    dispatchEvent(#name, [event](jsi::Runtime &runtime) {                             \
+      return mouseEventPayload(runtime, event);                                       \
+    });                                                                               \
+  }
+
+RCT_MACOS_MOUSE_EVENT(onMouseEnter)
+RCT_MACOS_MOUSE_EVENT(onMouseLeave)
+RCT_MACOS_MOUSE_EVENT(onDoubleClick)
+RCT_MACOS_MOUSE_EVENT(onAuxClick)
+
+#define RCT_MACOS_KEY_EVENT(name)                                                     \
+  void HostPlatformViewEventEmitter::name(const KeyEvent &event) const                \
+  {                                                                                   \
+    dispatchEvent(#name, [event](jsi::Runtime &runtime) {                             \
+      return keyEventPayload(runtime, event);                                         \
+    });                                                                               \
+  }
+
+RCT_MACOS_KEY_EVENT(onKeyDown)
+RCT_MACOS_KEY_EVENT(onKeyUp)
+
+} // namespace facebook::react

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

@@ -0,0 +1,52 @@
+/*
+ * 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] Adds the pointer and key events AppKit can report and UIKit cannot.
+
+#pragma once
+
+#include <react/renderer/components/view/BaseViewEventEmitter.h>
+
+#include "KeyEvent.h"
+
+namespace facebook::react {
+
+class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
+ public:
+  using BaseViewEventEmitter::BaseViewEventEmitter;
+
+  /**
+   * A mouse crossing into or out of the view. There is no touch equivalent, so
+   * these have no counterpart in BaseViewEventEmitter.
+   */
+  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};
+  };
+
+  void onMouseEnter(const MouseEvent &event) const;
+  void onMouseLeave(const MouseEvent &event) const;
+  void onDoubleClick(const MouseEvent &event) const;
+  void onAuxClick(const MouseEvent &event) const;
+
+  void onKeyDown(const KeyEvent &event) const;
+  void onKeyUp(const KeyEvent &event) const;
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,61 @@
+/*
+ * 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] Which macOS-only handlers a view actually has.
+//
+// Installing an NSTrackingArea on every view to find out later would cost a
+// mouse-moved dispatch per view per move. The props carry a bitset instead, so
+// the view only tracks the mouse when something is listening -- the same
+// arrangement BaseViewProps uses for pointer and responder events.
+
+#pragma once
+
+#include <bitset>
+#include <cstddef>
+
+namespace facebook::react {
+
+struct HostPlatformViewEvents {
+  std::bitset<8> bits{};
+
+  enum class Offset : std::size_t {
+    MouseEnter = 0,
+    MouseLeave = 1,
+    DoubleClick = 2,
+    AuxClick = 3,
+    KeyDown = 4,
+    KeyUp = 5,
+  };
+
+  constexpr bool operator[](Offset offset) const
+  {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  std::bitset<8>::reference operator[](Offset offset)
+  {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  /** True when any macOS mouse handler is present. */
+  bool wantsMouseTracking() const
+  {
+    return (*this)[Offset::MouseEnter] || (*this)[Offset::MouseLeave];
+  }
+};
+
+inline bool operator==(const HostPlatformViewEvents &lhs, const HostPlatformViewEvents &rhs)
+{
+  return lhs.bits == rhs.bits;
+}
+
+inline bool operator!=(const HostPlatformViewEvents &lhs, const HostPlatformViewEvents &rhs)
+{
+  return lhs.bits != rhs.bits;
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,121 @@
+/*
+ * 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] See HostPlatformViewProps.h.
+
+#include "HostPlatformViewProps.h"
+
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+// The whole-map parsing path (feature flag off) needs a converter for the
+// bitset, mirroring the one propsConversions.h provides for ViewEvents.
+static inline HostPlatformViewEvents convertRawProp(
+    const PropsParserContext &context,
+    const RawProps &rawProps,
+    const HostPlatformViewEvents &sourceValue,
+    const HostPlatformViewEvents &defaultValue)
+{
+  HostPlatformViewEvents result{};
+  using Offset = HostPlatformViewEvents::Offset;
+
+#define RCT_MACOS_CONVERT_EVENT(name, offset)         \
+  result[Offset::offset] = convertRawProp(            \
+      context, rawProps, name, sourceValue[Offset::offset], defaultValue[Offset::offset])
+
+  RCT_MACOS_CONVERT_EVENT("onMouseEnter", MouseEnter);
+  RCT_MACOS_CONVERT_EVENT("onMouseLeave", MouseLeave);
+  RCT_MACOS_CONVERT_EVENT("onDoubleClick", DoubleClick);
+  RCT_MACOS_CONVERT_EVENT("onAuxClick", AuxClick);
+  RCT_MACOS_CONVERT_EVENT("onKeyDown", KeyDown);
+  RCT_MACOS_CONVERT_EVENT("onKeyUp", KeyUp);
+
+#undef RCT_MACOS_CONVERT_EVENT
+
+  return result;
+}
+
+// Two parsing paths exist and both have to be fed. With the iterator setter
+// feature flag on, props arrive one at a time through setProp and the
+// constructor just carries the previous value forward; with it off, the
+// constructor parses the whole RawProps map itself.
+#define RCT_MACOS_PROP(name)                                    \
+  name(ReactNativeFeatureFlags::enableCppPropsIteratorSetter()  \
+           ? sourceProps.name                                   \
+           : convertRawProp(context, rawProps, #name, sourceProps.name, {}))
+
+HostPlatformViewProps::HostPlatformViewProps(
+    const PropsParserContext &context,
+    const HostPlatformViewProps &sourceProps,
+    const RawProps &rawProps)
+    : BaseViewProps(context, sourceProps, rawProps),
+      hostPlatformEvents(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.hostPlatformEvents
+              : convertRawProp(context, rawProps, sourceProps.hostPlatformEvents, {})),
+      RCT_MACOS_PROP(focusable),
+      RCT_MACOS_PROP(enableFocusRing),
+      RCT_MACOS_PROP(keyDownEvents),
+      RCT_MACOS_PROP(keyUpEvents),
+      RCT_MACOS_PROP(tooltip),
+      RCT_MACOS_PROP(acceptsFirstMouse),
+      RCT_MACOS_PROP(allowsVibrancy),
+      RCT_MACOS_PROP(mouseDownCanMoveWindow)
+{
+}
+
+#undef RCT_MACOS_PROP
+
+void HostPlatformViewProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    const RawValue &value)
+{
+  // Every Props struct must call super unconditionally: several structs can
+  // share the same raw value, and skipping the call drops it for all of them.
+  BaseViewProps::setProp(context, hash, propName, value);
+
+  static auto defaults = HostPlatformViewProps{};
+
+// An `onX` prop is stored as a bit rather than a value: all the view needs to
+// know is whether anything is listening.
+#define RCT_MACOS_EVENT_CASE(eventType)                                \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): {                \
+    const auto offset = HostPlatformViewEvents::Offset::eventType;     \
+    HostPlatformViewEvents defaultEvents{};                            \
+    bool listening = defaultEvents[offset];                            \
+    if (value.hasValue()) {                                            \
+      fromRawValue(context, value, listening);                         \
+    }                                                                  \
+    hostPlatformEvents[offset] = listening;                            \
+    return;                                                            \
+  }
+
+  switch (hash) {
+    RCT_MACOS_EVENT_CASE(MouseEnter);
+    RCT_MACOS_EVENT_CASE(MouseLeave);
+    RCT_MACOS_EVENT_CASE(DoubleClick);
+    RCT_MACOS_EVENT_CASE(AuxClick);
+    RCT_MACOS_EVENT_CASE(KeyDown);
+    RCT_MACOS_EVENT_CASE(KeyUp);
+    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(tooltip);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(acceptsFirstMouse);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(allowsVibrancy);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(mouseDownCanMoveWindow);
+  }
+
+#undef RCT_MACOS_EVENT_CASE
+}
+
+} // namespace facebook::react