basalt-appkit 0.0.0-rc5 → 0.1.0

package/native/appkit/AppKitTextInput.mm

@@ -1,16 +1,41 @@
 #import "AppKitTextInput.h"
 
+#include "TextChecking.h"
+
+#include "FontScaling.h"
+
 #import "AppKitTextPeer.h"
 
 #import "CoreTextLayout.h"
 
 #include <react/renderer/components/iostextinput/TextInputProps.h>
 
+#include <glog/logging.h>
+
 #include <algorithm>
 #include <cmath>
 #include <string_view>
 
 // The bridge between AppKit's delegate protocol and the C++ manager, for the
+// A colour the app asked for, or nil when it asked for nothing.
+//
+// nil is the whole point: `SharedColor`'s unset value is zero, so a conversion
+// that always answered a colour would make "the app said nothing" and "the app
+// said transparent black" the same request, and every caret would come out
+// black. Explicitly sRGB, for the reason `toColor` in CoreTextLayout.mm is: a
+// device colour space shifts every colour on a wide-gamut display, and a field
+// that does not match Linux is the bug this project is least able to afford.
+static NSColor *_Nullable RnColourOrNil(facebook::react::SharedColor colour) {
+  if (!colour) {
+    return nil;
+  }
+  const auto components = facebook::react::colorComponentsFromColor(colour);
+  return [NSColor colorWithSRGBRed:components.red
+                             green:components.green
+                              blue:components.blue
+                             alpha:components.alpha];
+}
+
 // same reason the touch dispatcher and the scroll manager have one.
 @interface RnAppKitTextInputDelegate
     : NSObject <NSTextFieldDelegate, NSTextViewDelegate, RnAppKitTextPeerOwner>
@@ -127,8 +152,23 @@ static NSInteger RnTagOf(id object) {
     doCommandBySelector:(SEL)selector {
   (void)textView;
   if (selector == @selector(insertNewline:) && _manager != nullptr) {
-    _manager->handleSubmit(static_cast<facebook::react::Tag>(RnTagOf(control)));
-    return YES;
+    // YES means "used up", which is what stops AppKit inserting a newline --
+    // and for `submitBehavior: 'newline'` on a single-line field there is
+    // nothing to insert anyway, so either answer looks the same.
+    return _manager->handleSubmit(static_cast<facebook::react::Tag>(RnTagOf(control))) ? YES
+                                                                                      : NO;
+  }
+  return NO;
+}
+
+// The same key on the multiline peer, which is an NSTextView and posts through
+// NSTextViewDelegate rather than NSControl's. Without this a `submitBehavior`
+// of `submit` on a multiline field would insert a newline *and* report
+// nothing: the field's own insertion is what has to be refused.
+- (BOOL)textView:(NSTextView *)textView doCommandBySelector:(SEL)selector {
+  if (selector == @selector(insertNewline:) && _manager != nullptr) {
+    return _manager->handleSubmit(static_cast<facebook::react::Tag>(RnTagOf(textView))) ? YES
+                                                                                       : NO;
   }
   return NO;
 }
@@ -254,8 +294,10 @@ void AppKitTextInputManager::update(RnAppKitView *view, const ShadowView &shadow
   // text on dark. buildTextAttributes is what the style becomes, and it was
   // written for the text layer with this as its eventual second caller.
   //
-  // fontSizeMultiplier is 1: nothing on this platform scales text for
-  // accessibility settings yet, and passing 0 would multiply the size away.
+  // 1, and not the text scale, although this is the argument React Native leaves
+  // for one: buildTextAttributes applies the scale itself through
+  // core/FontScaling.h, so passing it here would square it. The field still
+  // scales, and still stops when `allowFontScaling={false}`.
   NSDictionary<NSAttributedStringKey, id> *attributes =
       buildTextAttributes(props->getEffectiveTextAttributes(1.0F));
   NSParagraphStyle *paragraph = attributes[NSParagraphStyleAttributeName];
@@ -294,6 +336,43 @@ void AppKitTextInputManager::update(RnAppKitView *view, const ShadowView &shadow
     }
   }
 
+  // The three colours React Native has for a field, which this host read none
+  // of until 2026-10-10: the placeholder, the selection and the caret.
+  //
+  // Each crosses as nil when the app did not ask, which is the distinction that
+  // matters: `SharedColor`'s unset value is zero, so passing it through
+  // unconditionally would paint every caret black and every selection
+  // transparent. nil leaves AppKit's own colour alone.
+  //
+  // `cursorColor` falls back to `selectionColor`, which is React Native's
+  // documented contract rather than an invention here: `selectionColor` is "the
+  // highlight, selection handle and cursor color of the text input", and
+  // `cursorColor` exists to override the caret on its own. The GTK host reads
+  // the pair the same way, and on iOS both are the view's tintColor.
+  NSColor *const selectionColour =
+      RnColourOrNil(props->selectionColor);
+  NSColor *caretColour =
+      props->cursorColor ? RnColourOrNil(props->cursorColor) : selectionColour;
+
+  // `caretHidden`, through the same channel and winning over both of the above:
+  // a caret the app asked to hide is hidden whatever colour it also asked for.
+  // Clear rather than nil, nil meaning "AppKit's own" -- which is a visible
+  // caret. An NSTextView draws its insertion point as a filled rectangle, so a
+  // clear one is drawn and invisible.
+  if (props->traits.caretHidden) {
+    caretColour = NSColor.clearColor;
+  }
+  RnPeerSetEditorColours(entry.field, selectionColour, caretColour);
+
+  // `clearTextOnFocus` and `selectTextOnFocus`, remembered for the moment focus
+  // arrives -- which is long after the props do. See `handleFocus`.
+  entry.clearTextOnFocus = props->traits.clearTextOnFocus;
+  entry.selectTextOnFocus = props->traits.selectTextOnFocus;
+
+  // `submitBehavior`, resolved by React Native rather than here: `Default` is
+  // `newline` for a multiline field and `blurAndSubmit` for a single-line one.
+  entry.submitBehavior = props->getNonDefaultSubmitBehavior();
+
   if (props->placeholder.empty()) {
     RnPeerSetPlaceholder(entry.field, nil);
   } else {
@@ -302,17 +381,64 @@ void AppKitTextInputManager::update(RnAppKitView *view, const ShadowView &shadow
       placeholder = @"";
     }
     // Styled like the text, so a placeholder in a 20pt field is not 13pt.
+    //
+    // `placeholderTextColor` when the app asked, and the system's placeholder
+    // grey otherwise. This host painted the grey unconditionally until
+    // 2026-10-10 and the backlog recorded the prop as done, which is what the
+    // support page's per-row audit caught: an app asking for a red placeholder
+    // got grey.
     NSMutableDictionary *placeholderAttributes = [attributes mutableCopy];
-    placeholderAttributes[NSForegroundColorAttributeName] = NSColor.placeholderTextColor;
+    NSColor *const asked = RnColourOrNil(props->placeholderTextColor);
+    placeholderAttributes[NSForegroundColorAttributeName] =
+        asked != nil ? asked : NSColor.placeholderTextColor;
     RnPeerSetPlaceholder(entry.field,
                          [[NSAttributedString alloc] initWithString:placeholder
                                                          attributes:placeholderAttributes]);
   }
 
+  // `contextMenuHidden`, which the peers answer from `-menuForEvent:`.
+  RnPeerSetContextMenuHidden(entry.field, props->traits.contextMenuHidden);
+
   // `editable` is the prop; `readOnly` is the newer spelling of its inverse,
   // and React Native honours both.
   RnPeerSetEditable(entry.field, props->traits.editable && !props->readOnly);
 
+  // `spellCheck` and `autoCorrect`, resolved in core/TextChecking.h so that the
+  // two hosts agree that unset is not false. AppKit has both, on the NSTextView
+  // a field is or borrows; GTK has only the first, as an input hint.
+  const auto checking = [](std::optional<bool> asked) {
+    switch (basalt::textCheckingFlag(asked)) {
+      case basalt::TextCheckingFlag::On:
+        return RnTextCheckingOn;
+      case basalt::TextCheckingFlag::Off:
+        return RnTextCheckingOff;
+      case basalt::TextCheckingFlag::Unset:
+        break;
+    }
+    return RnTextCheckingUnset;
+  };
+  RnPeerSetTextChecking(entry.field,
+                        checking(props->traits.spellCheck),
+                        checking(props->traits.autoCorrect));
+  // And both in the dump, as the app asked for them, in the words GTK prints.
+  const auto name = [](std::optional<bool> asked) -> NSString * {
+    const char *word = basalt::textCheckingName(basalt::textCheckingFlag(asked));
+    return word != nullptr ? @(word) : nil;
+  };
+  entry.view.rnSpellCheck = name(props->traits.spellCheck);
+  entry.view.rnAutoCorrect = name(props->traits.autoCorrect);
+
+  // `autoCapitalize` and `keyboardType`, reported and not acted on: this
+  // platform has no per-field automatic capitalisation and no software
+  // keyboard. backlog/platform-macos.md says so with the calls that do not
+  // exist, and the GTK host honours both.
+  entry.view.rnAutoCapitalize = @(basalt::autoCapitalizeName(props->traits.autocapitalizationType));
+  entry.view.rnKeyboardType = @(basalt::keyboardTypeName(props->traits.keyboardType));
+  // And the two hiding props, for the dump: each is the absence of something,
+  // so the dump is the only place anything can see that they arrived.
+  entry.view.rnCaretHidden = props->traits.caretHidden;
+  entry.view.rnContextMenuHidden = props->traits.contextMenuHidden;
+
   // Zero means no limit, and so does the absurd default React Native uses when
   // the prop is absent.
   RnPeerSetMaxLength(entry.field,
@@ -321,7 +447,65 @@ void AppKitTextInputManager::update(RnAppKitView *view, const ShadowView &shadow
                          : 0);
 
   if (inserted && props->autoFocus) {
-    [entry.view.window makeFirstResponder:entry.field];
+    // Recorded, not performed: see flushAutoFocus in the header for why here is
+    // too early. `inserted` is the only moment the prop can be acted on at all,
+    // since it is the only moment this manager can tell a new field from an
+    // updated one, so the tag is kept and the focusing happens later.
+    pendingAutoFocus_.push_back(tag);
+  }
+}
+
+void AppKitTextInputManager::flushAutoFocus() {
+  if (pendingAutoFocus_.empty()) {
+    return;
+  }
+  // Taken by value and cleared first, so a field that has since been removed, or
+  // one whose window is still not there, does not leave the list growing.
+  const std::vector<Tag> pending = std::move(pendingAutoFocus_);
+  pendingAutoFocus_.clear();
+
+  for (const Tag tag : pending) {
+    const auto it = entries_.find(tag);
+    if (it == entries_.end()) {
+      continue;
+    }
+    // Not silently. `makeFirstResponder:` answers whether it took, messaging a
+    // nil window is a no-op rather than an error, and this used to discard both:
+    // an autoFocus that did nothing looked exactly like one that worked. The
+    // window is non-nil on every path there is today, a view being in the
+    // window's hierarchy from the moment the surface root is set, so these are
+    // claims about what is believed rather than cases anyone has seen.
+    NSWindow *const window = it->second.view.window;
+    if (window == nil) {
+      LOG(WARNING) << "autoFocus: tag " << tag << " is not in a window yet";
+      continue;
+    }
+    if (![window makeFirstResponder:it->second.field]) {
+      LOG(WARNING) << "autoFocus: tag " << tag << " refused first responder";
+      continue;
+    }
+
+    // A field that asked to select its text on focus keeps what
+    // `becomeFirstResponder` gave it, which is the whole selection: the collapse
+    // below is what `selectTextOnFocus` is the absence of.
+    if (it->second.selectTextOnFocus) {
+      continue;
+    }
+
+    // And then collapse the selection, which is the whole of the bug GTK had.
+    // `NSTextField` installs the window's shared field editor on becoming first
+    // responder and selects all of its text, so autoFocus on a field with a
+    // `defaultValue` armed the next keystroke to replace it. The repository had
+    // already written the symptom down without recognising it: the paste role's
+    // scenario says "both hosts here replace", and a paste replaces what is
+    // selected.
+    //
+    // A caret at the end is what focusing a field is meant to leave, and what
+    // `gtk_text_grab_focus_without_selecting` gives on the other host.
+    // `NSTextView` keeps its own collapsed selection and needs none of this;
+    // setting it anyway costs nothing and keeps the two from drifting.
+    const NSUInteger length = RnPeerText(it->second.field).length;
+    RnPeerSetSelection(it->second.field, NSMakeRange(length, 0));
   }
 }
 
@@ -409,14 +593,35 @@ void AppKitTextInputManager::handleChanged(Tag tag) {
   }
 }
 
-void AppKitTextInputManager::handleSubmit(Tag tag) {
+bool AppKitTextInputManager::handleSubmit(Tag tag) {
   Entry *entry = entryFor(tag);
   if (entry == nullptr) {
-    return;
+    return false;
+  }
+  // **`submitBehavior` decides what Return does**, already resolved to one of
+  // the three: `newline` inserts one, `submit` reports a submit, and
+  // `blurAndSubmit` reports one and gives up focus. React Native's default is
+  // the last for a single-line field and the first for a multiline one, so a
+  // field that never set the prop behaves as it does on iOS -- where this host
+  // used to keep focus whatever the prop said, because an NSTextField does.
+  if (entry->submitBehavior == facebook::react::SubmitBehavior::Newline) {
+    // Not used up: a multiline peer inserts the newline, and a single-line one
+    // has nowhere to put it and does nothing.
+    return false;
   }
   if (const auto emitter = emitterFor(tag)) {
     emitter->onSubmitEditing(metricsFor(*entry));
   }
+  if (entry->submitBehavior == facebook::react::SubmitBehavior::BlurAndSubmit) {
+    // Handing focus back to the window is the closest thing AppKit has to
+    // "unfocus this", which the `blur` command says at more length. It ends the
+    // edit, so the delegate reports a blur and JavaScript sees onBlur.
+    NSWindow *window = entry->view.window;
+    if (window != nil && window.firstResponder != window) {
+      [window makeFirstResponder:window];
+    }
+  }
+  return true;
 }
 
 void AppKitTextInputManager::handleFocus(Tag tag) {
@@ -427,6 +632,28 @@ void AppKitTextInputManager::handleFocus(Tag tag) {
   if (const auto emitter = emitterFor(tag)) {
     emitter->onFocus(metricsFor(*entry));
   }
+
+  // `clearTextOnFocus` before `selectTextOnFocus`, which is the only order that
+  // means anything: selecting what has just been cleared is selecting nothing,
+  // and clearing what has just been selected throws the selection away. Both
+  // hosts do them in this order for that reason.
+  if (entry->clearTextOnFocus && RnPeerText(entry->field).length > 0) {
+    // Reported, not applied silently. A controlled field whose text was cleared
+    // behind JavaScript's back is a field that puts the old value back on the
+    // next unrelated render, with the user having done nothing -- so the clear
+    // goes through the same path a keystroke does.
+    RnPeerSetText(entry->field, @"");
+    handleChanged(tag);
+  }
+
+  if (entry->selectTextOnFocus) {
+    // An NSTextField selects everything on becoming first responder, and this
+    // host collapses that by hand -- see `flushAutoFocus`, where the prop is
+    // the reason not to. An NSTextView does not, so the selection is made here
+    // for both and neither depends on which peer it is.
+    RnPeerSetSelection(entry->field,
+                       NSMakeRange(0, RnPeerText(entry->field).length));
+  }
 }
 
 bool AppKitTextInputManager::handleKeyDown(void *event) {

package/native/appkit/AppKitTextPeer.h

@@ -46,6 +46,66 @@ NSRange RnPeerSelection(NSView *_Nullable peer);
 void RnPeerSetSelection(NSView *_Nullable peer, NSRange range);
 
 void RnPeerSetEditable(NSView *_Nullable peer, BOOL editable);
+
+// `contextMenuHidden`: whether a right-click or a Control-click opens the
+// peer's own editing menu.
+//
+// AppKit builds that menu on demand through `-menuForEvent:`, so the peers
+// refuse there rather than having a menu taken away from them -- which is the
+// one place that covers both gestures, and leaves the menu intact for a field
+// that stops asking.
+void RnPeerSetContextMenuHidden(NSView *_Nullable peer, BOOL hidden);
+BOOL RnPeerContextMenuHidden(NSView *_Nullable peer);
+
+// `spellCheck` and `autoCorrect`, as three states: see core/TextChecking.h for
+// why unset is not false. Mirrored here rather than taken from that header
+// because this one is plain Objective-C and its callers should stay that way.
+typedef NS_ENUM(NSInteger, RnTextChecking) {
+  RnTextCheckingUnset,
+  RnTextCheckingOn,
+  RnTextCheckingOff,
+};
+
+// Applies both, and remembers them.
+//
+// Remembering is the point: the two properties live on an NSTextView, and a
+// single-line field is an NSTextField which *borrows* one -- its field editor,
+// which exists only while it is focused. So a field asked before it is focused
+// has nowhere to put them, and the peer applies them again when the editor
+// appears.
+void RnPeerSetTextChecking(NSView *_Nullable peer,
+                           RnTextChecking spellCheck,
+                           RnTextChecking autoCorrect);
+
+// What the peer was last asked for, which is not always what AppKit did with
+// it: macOS gates continuous spell checking on a user-wide setting
+// (`NSAllowContinuousSpellChecking`), and refuses a per-view request when the
+// person has turned the feature off for everything. So the request is what a
+// test can assert on any machine, and AppKit's answer is asserted only where
+// the machine allows it.
+RnTextChecking RnPeerSpellCheck(NSView *_Nullable peer);
+RnTextChecking RnPeerAutoCorrect(NSView *_Nullable peer);
+
+// `selectionColor` and `cursorColor`, which live on the same NSTextView the
+// spell-checking flags do and are remembered for the same reason: a single-line
+// field borrows the window's field editor and only has one while it is focused.
+// So these are stored and applied again in `becomeFirstResponder`.
+//
+// Null means "the app did not ask", which leaves AppKit's own colour alone --
+// the system accent for a selection and the text colour for a caret. That is a
+// third state rather than a default, exactly as it is for the checking flags:
+// `SharedColor`'s unset value is zero, and passing that through would paint
+// every caret black.
+//
+// The caret is `insertionPointColor` and the selection is the background colour
+// inside `selectedTextAttributes`, which is a dictionary this replaces one key
+// of rather than wholesale: the rest of it is AppKit's, including whether the
+// selection dims when the window loses focus.
+void RnPeerSetEditorColours(NSView *_Nullable peer,
+                            NSColor *_Nullable selection,
+                            NSColor *_Nullable caret);
+NSColor *_Nullable RnPeerSelectionColour(NSView *_Nullable peer);
+NSColor *_Nullable RnPeerCaretColour(NSView *_Nullable peer);
 void RnPeerSetTextStyle(NSView *_Nullable peer, NSFont *_Nullable font,
                         NSColor *_Nullable colour, NSTextAlignment alignment);