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

package/Libraries/Text/TextNativeComponent.js

@@ -48,6 +48,13 @@ const textViewConfig = {
     dataDetectorType: true,
     android_hyphenationFrequency: true,
     lineBreakStrategyIOS: true,
+    // [macOS] Text is a view too: ParagraphProps derives from ViewProps, which
+    // on macOS already carries these. Only the view config stood in the way --
+    // a prop missing from validAttributes never reaches C++ at all.
+    tooltip: true,
+    focusable: true,
+    enableFocusRing: true,
+    // macOS]
   },
   directEventTypes: {
     topTextLayout: {

package/Libraries/Text/TextProps.js

@@ -234,9 +234,22 @@ type TextBaseProps = Readonly<{
  *
  * @build-types emit-as-interface Uniwind compatibility
  */
+// [macOS] Text carries the same three view props react-native-macos gives it.
+// They work because ParagraphProps derives from ViewProps, which on macOS is
+// HostPlatformViewProps.
+export type TextPropsMacOS = Readonly<{
+  /** @platform macos */
+  tooltip?: ?string,
+  /** @platform macos */
+  focusable?: ?boolean,
+  /** @platform macos */
+  enableFocusRing?: ?boolean,
+}>;
+
 export type TextProps = Readonly<{
   ...TextPointerEventProps,
   ...TextPropsIOS,
+  ...TextPropsMacOS, // [macOS]
   ...TextPropsAndroid,
   ...TextBaseProps,
   ...AccessibilityProps,

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;
@@ -213,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.

package/macos/UIKitCompat/UIKit/UIText.m

@@ -78,8 +78,11 @@
 
 @end
 
-@implementation UITextField {
+@implementation RCTUIKitCompatTextField {
   NSDictionary<NSAttributedStringKey, id> *_typingAttributes;
+  NSMutableArray<NSArray *> *_controlEventTargets;
+  NSString *_placeholder;
+  BOOL _reportedEndEditing;
 }
 
 UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
@@ -143,6 +146,73 @@ UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
   }
 }
 
+/**
+ * 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;
@@ -265,13 +335,23 @@ UIKIT_COMPAT_TEXT_INPUT_GEOMETRY
   return nil;
 }
 
+/**
+ * The plain and attributed placeholders are one value on NSTextField: setting
+ * `placeholderAttributedString` clears `placeholderString`, and the reverse.
+ * UIKit keeps both, and React Native relies on that -- it sets `placeholder`,
+ * builds `attributedPlaceholder` from it, and rebuilds that again whenever the
+ * text attributes change. Reading the plain one back through AppKit returns nil
+ * the second time round, so the placeholder is rebuilt as empty and silently
+ * disappears. Hold the string here instead.
+ */
 - (NSString *)placeholder
 {
-  return self.placeholderString;
+  return _placeholder ?: self.placeholderString;
 }
 
 - (void)setPlaceholder:(NSString *)placeholder
 {
+  _placeholder = [placeholder copy];
   self.placeholderString = placeholder;
 }
 
@@ -280,16 +360,154 @@ 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
 {
-  self.target = target;
-  self.action = action;
+  id delegate = self.delegate;
+  return [delegate conformsToProtocol:@protocol(UITextFieldDelegate)] ? delegate : nil;
 }
 
-- (void)removeTarget:(__unused id)target action:(__unused SEL)action forControlEvents:(__unused UIControlEvents)events
+// 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 = nil;
-  self.action = NULL;
+  [super textDidBeginEditing:notification];
+  _reportedEndEditing = NO;
+  [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];
+}
+
+/**
+ * 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
+{
+  [super textDidEndEditing:notification];
+
+  NSNumber *movement = notification.userInfo[@"NSTextMovement"];
+  BOOL submitted = movement.integerValue == NSReturnTextMovement;
+  id<UITextFieldDelegate> delegate = [self uikitCompat_uiDelegate];
+
+  // AppKit ends editing on Return and then re-establishes the field editor with
+  // the text selected, so this runs again on the next click -- a second blur
+  // with no focus in between. Report the end once per editing session.
+  if (_reportedEndEditing) {
+    return;
+  }
+  _reportedEndEditing = YES;
+
+  // 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.
+  // The answer says whether the field should also give up focus: that is
+  // `submitBehavior`, which distinguishes `submit` from `blurAndSubmit`.
+  BOOL shouldBlurOnSubmit = NO;
+  if (submitted && [delegate respondsToSelector:@selector(textFieldShouldReturn:)]) {
+    shouldBlurOnSubmit = [delegate textFieldShouldReturn:self];
+  }
+
+  UIControlEvents events = UIControlEventEditingDidEnd;
+  if (submitted) {
+    events |= UIControlEventEditingDidEndOnExit;
+  }
+  [self uikitCompat_sendActionsForControlEvents:events];
+
+  if ([delegate respondsToSelector:@selector(textFieldDidEndEditing:)]) {
+    [delegate textFieldDidEndEditing:self];
+  }
+
+  if (submitted && shouldBlurOnSubmit) {
+    // Asynchronously: AppKit is still unwinding this edit, and taking the
+    // responder away underneath it leaves a caret drawn in a field that no
+    // longer has focus.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (self.currentEditor != nil) {
+        [self.window makeFirstResponder:nil];
+      }
+    });
+  }
 }
 
 - (id<UITextDropDelegate>)textDropDelegate
@@ -354,6 +572,123 @@ 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;

package/package.json

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