basalt-appkit 0.0.0-rc5 → 0.1.0

package/native/tests/test_appkit_textinput.mm

@@ -746,3 +746,822 @@ TEST(textinput_says_nothing_about_a_key_that_types_nothing) {
     manager.destroySurfaceRoot(kSurfaceId);
   }
 }
+
+// `spellCheck` and `autoCorrect`, which on this platform are two properties of
+// an NSTextView: a multiline field *is* one, and a single-line field borrows
+// one as its field editor while it is focused.
+//
+// What is asserted unconditionally is the *request*, because AppKit may decline
+// it: macOS gates continuous spell checking on a user-wide setting, and when
+// the person has turned spelling off for everything it refuses a per-view
+// request. Measured rather than guessed -- `NSAllowContinuousSpellChecking` is
+// 0 on the machine this was written on, and `setContinuousSpellCheckingEnabled:
+// YES` was ignored on a bare NSTextView with and without a window. AppKit's own
+// answer is asserted where the machine allows it, and the autocorrection flag
+// has no such gate and is asserted always.
+namespace {
+
+bool continuousSpellCheckingAllowed() {
+  NSNumber *allowed =
+      [NSUserDefaults.standardUserDefaults objectForKey:@"NSAllowContinuousSpellChecking"];
+  return allowed == nil || allowed.boolValue;
+}
+
+} // namespace
+
+TEST(textinput_spell_check_and_autocorrect_are_asked_for_on_a_multiline_field) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager,
+                                    10,
+                                    folly::dynamic::object("multiline", true)(
+                                        "spellCheck", true)("autoCorrect", true));
+
+    NSView *field = fieldOf(view);
+    EXPECT(RnPeerIsMultiline(field));
+    EXPECT(RnPeerSpellCheck(field) == RnTextCheckingOn);
+    EXPECT(RnPeerAutoCorrect(field) == RnTextCheckingOn);
+
+    NSTextView *editor = (NSTextView *)field;
+    // No gate on this one.
+    EXPECT(editor.isAutomaticSpellingCorrectionEnabled);
+    if (continuousSpellCheckingAllowed()) {
+      EXPECT(editor.isContinuousSpellCheckingEnabled);
+    }
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_spell_check_and_autocorrect_can_be_refused) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager,
+                                    10,
+                                    folly::dynamic::object("multiline", true)(
+                                        "spellCheck", false)("autoCorrect", false));
+
+    NSTextView *editor = (NSTextView *)fieldOf(view);
+    EXPECT(RnPeerSpellCheck(editor) == RnTextCheckingOff);
+    EXPECT(RnPeerAutoCorrect(editor) == RnTextCheckingOff);
+    // Refusing always sticks: the user setting above can only take the feature
+    // away, never force it on.
+    EXPECT(!editor.isContinuousSpellCheckingEnabled);
+    EXPECT(!editor.isAutomaticSpellingCorrectionEnabled);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// Unset is not false, which is the rule core/TextChecking.h exists for: a field
+// that says nothing keeps whatever AppKit does by default, and this asserts the
+// host did not decide for it.
+TEST(textinput_an_unset_checking_flag_leaves_appkits_own_answer) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+
+    // AppKit's defaults, read off a peer of its own rather than assumed: they
+    // are AppKit's business and have changed before.
+    NSTextView *bare = [[NSTextView alloc] initWithFrame:NSMakeRect(0, 0, 100, 40)];
+    const BOOL spellByDefault = bare.isContinuousSpellCheckingEnabled;
+    const BOOL correctByDefault = bare.isAutomaticSpellingCorrectionEnabled;
+
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("multiline", true));
+    NSTextView *editor = (NSTextView *)fieldOf(view);
+    EXPECT(RnPeerSpellCheck(editor) == RnTextCheckingUnset);
+    EXPECT(RnPeerAutoCorrect(editor) == RnTextCheckingUnset);
+    EXPECT_EQ(editor.isContinuousSpellCheckingEnabled, spellByDefault);
+    EXPECT_EQ(editor.isAutomaticSpellingCorrectionEnabled, correctByDefault);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And the single-line half, which is the awkward one: an NSTextField has
+// neither property, so the peer remembers the request and applies it to the
+// field editor when one appears.
+TEST(textinput_a_single_line_field_checks_its_editor_when_it_focuses) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("spellCheck", false)("autoCorrect", false));
+    NSView *field = fieldOf(view);
+    EXPECT(!RnPeerIsMultiline(field));
+    EXPECT(RnPeerSpellCheck(field) == RnTextCheckingOff);
+
+    // A window, because a field editor belongs to the *window* and an
+    // unparented field never gets one.
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    // Not released when closed: see test_appkit_services.mm for the double
+    // release that taught this suite to say so.
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    NSTextView *editor = (NSTextView *)((NSTextField *)field).currentEditor;
+    EXPECT(editor != nil);
+    EXPECT(editor != nil && !editor.isContinuousSpellCheckingEnabled);
+    EXPECT(editor != nil && !editor.isAutomaticSpellingCorrectionEnabled);
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// `autoCapitalize` and `keyboardType`, which this platform reports and cannot
+// act on: there is no per-field automatic capitalisation on macOS
+// (`NSSpellChecker`'s is the person's system setting) and no software keyboard
+// to choose a layout for.
+//
+// Asserted anyway, and in the words GTK prints: the dumps are diffed line by
+// line, so a field that asked for something has to say the same thing on both
+// hosts and the difference belongs in the support page rather than in a missing
+// line.
+TEST(textinput_reports_the_capitalisation_and_keyboard_it_cannot_honour) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager,
+                                    10,
+                                    folly::dynamic::object("autoCapitalize", "characters")(
+                                        "keyboardType", "email-address"));
+
+    const std::string dumped = [view describeTree].UTF8String;
+    EXPECT(dumped.find("autocapitalize=characters") != std::string::npos);
+    EXPECT(dumped.find("keyboard=email-address") != std::string::npos);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And the default, which React Native decides rather than this platform:
+// `sentences`, as on iOS. A field that mentions neither prop still reports
+// both, because both are plain enums with a default rather than optionals.
+TEST(textinput_reports_react_natives_own_defaults_for_the_pair) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("text", "plain"));
+
+    const std::string dumped = [view describeTree].UTF8String;
+    EXPECT(dumped.find("autocapitalize=sentences") != std::string::npos);
+    EXPECT(dumped.find("keyboard=default") != std::string::npos);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// --- The three colours a field has ------------------------------------------
+//
+// `placeholderTextColor`, `selectionColor` and `cursorColor`, which this host
+// read none of until 2026-10-10 -- and which the backlog recorded as done for
+// the first of them, because the system's placeholder grey looks like an
+// answer. The per-row support audit is what caught that.
+//
+// Each is a third state rather than a default: `SharedColor`'s unset value is
+// zero, so "the app said nothing" has to stay distinguishable from "the app
+// said black". nil is what crosses, and nil leaves AppKit's own colour alone.
+
+TEST(textinput_placeholder_takes_the_colour_the_app_asked_for) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager,
+        10,
+        folly::dynamic::object("placeholder", "Search")("placeholderTextColor", 0xffff0000));
+    NSView *field = fieldOf(view);
+
+    NSAttributedString *placeholder = RnPeerPlaceholder(field);
+    EXPECT(placeholder != nil);
+    if (placeholder == nil) {
+      manager.destroySurfaceRoot(kSurfaceId);
+      return;
+    }
+    NSColor *colour = [placeholder attribute:NSForegroundColorAttributeName
+                                     atIndex:0
+                              effectiveRange:nullptr];
+    EXPECT(colour != nil);
+    // Red, in sRGB, which is what the app asked for rather than the system's
+    // placeholder grey.
+    NSColor *const sRGB = [colour colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(sRGB != nil);
+    EXPECT(sRGB != nil && sRGB.redComponent > 0.9);
+    EXPECT(sRGB != nil && sRGB.greenComponent < 0.1);
+    EXPECT(sRGB != nil && sRGB.blueComponent < 0.1);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And a field that asked for nothing keeps the system's grey, which is the
+// third state: a host that resolved unset to a colour would paint every
+// placeholder transparent black.
+TEST(textinput_a_placeholder_with_no_colour_keeps_the_systems) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("placeholder", "Search"));
+    NSAttributedString *placeholder = RnPeerPlaceholder(fieldOf(view));
+    EXPECT(placeholder != nil);
+    if (placeholder != nil) {
+      NSColor *colour = [placeholder attribute:NSForegroundColorAttributeName
+                                       atIndex:0
+                                effectiveRange:nullptr];
+      EXPECT(colour == NSColor.placeholderTextColor);
+    }
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// The selection and the caret are remembered before they can be applied: a
+// single-line field borrows the window's field editor and has none until it is
+// focused, which is the same reason the spell-checking flags are remembered.
+TEST(textinput_selection_and_cursor_colours_are_remembered_for_the_editor) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager,
+        10,
+        folly::dynamic::object("selectionColor", 0xff00ff00)("cursorColor", 0xff0000ff));
+    NSView *field = fieldOf(view);
+
+    NSColor *selection =
+        [RnPeerSelectionColour(field) colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    NSColor *caret =
+        [RnPeerCaretColour(field) colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(selection != nil);
+    EXPECT(caret != nil);
+    EXPECT(selection != nil && selection.greenComponent > 0.9);
+    EXPECT(caret != nil && caret.blueComponent > 0.9);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// `cursorColor` falls back to `selectionColor`, which is React Native's
+// contract: `selectionColor` is the highlight *and* the cursor, and
+// `cursorColor` exists to override the second on its own. A field given only
+// the first should not have a theme-coloured caret.
+TEST(textinput_a_cursor_with_no_colour_of_its_own_follows_the_selection) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("selectionColor", 0xff00ff00));
+    NSView *field = fieldOf(view);
+
+    NSColor *caret =
+        [RnPeerCaretColour(field) colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(caret != nil);
+    EXPECT(caret != nil && caret.greenComponent > 0.9);
+
+    // And a field that asked for neither has neither, so AppKit's own colours
+    // stand.
+    RnAppKitView *plain = mountField(manager, 11, folly::dynamic::object("text", "x"));
+    EXPECT(RnPeerSelectionColour(fieldOf(plain)) == nil);
+    EXPECT(RnPeerCaretColour(fieldOf(plain)) == nil);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And they reach the real field editor when the field is focused, which is the
+// half the remembering exists for.
+TEST(textinput_the_field_editor_takes_the_colours_when_it_appears) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager,
+        10,
+        folly::dynamic::object("selectionColor", 0xff00ff00)("cursorColor", 0xff0000ff));
+    NSView *field = fieldOf(view);
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    NSTextView *editor = (NSTextView *)((NSTextField *)field).currentEditor;
+    EXPECT(editor != nil);
+    if (editor != nil) {
+      NSColor *caret = [editor.insertionPointColor
+          colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+      EXPECT(caret != nil && caret.blueComponent > 0.9);
+
+      NSColor *selection = [editor.selectedTextAttributes[NSBackgroundColorAttributeName]
+          colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+      EXPECT(selection != nil);
+      EXPECT(selection != nil && selection.greenComponent > 0.9);
+    }
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// A multiline peer is its own editor, so the colours go straight on -- and are
+// still remembered, so that reading them back says what the app asked for.
+TEST(textinput_a_multiline_field_takes_the_colours_directly) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager,
+        10,
+        folly::dynamic::object("multiline", true)("selectionColor", 0xff00ff00)(
+            "cursorColor", 0xff0000ff));
+    NSView *field = fieldOf(view);
+    EXPECT(RnPeerIsMultiline(field));
+
+    NSTextView *editor = (NSTextView *)field;
+    NSColor *caret =
+        [editor.insertionPointColor colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(caret != nil && caret.blueComponent > 0.9);
+    NSColor *selection = [editor.selectedTextAttributes[NSBackgroundColorAttributeName]
+        colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(selection != nil && selection.greenComponent > 0.9);
+    EXPECT(RnPeerSelectionColour(field) != nil);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// --- clearTextOnFocus and selectTextOnFocus ---------------------------------
+//
+// What happens when a field takes focus, which no host read until 2026-10-10.
+// Both are about the moment focus arrives rather than about the props, so both
+// need a real window: an NSTextField has no field editor until it is first
+// responder, and a selection with nowhere to live is not a selection.
+
+TEST(textinput_clear_text_on_focus_empties_the_field) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager, 10, folly::dynamic::object("text", "keep me")("clearTextOnFocus", true));
+    NSView *field = fieldOf(view);
+    EXPECT([RnPeerText(field) isEqualToString:@"keep me"]);
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    // Empty, and empty where the user can see it rather than only in the props.
+    EXPECT([RnPeerText(field) isEqualToString:@""]);
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And a field that did not ask keeps its text, which is the control: a host
+// that cleared unconditionally would pass the test above.
+TEST(textinput_a_field_that_did_not_ask_keeps_its_text_on_focus) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("text", "keep me"));
+    NSView *field = fieldOf(view);
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    EXPECT([RnPeerText(field) isEqualToString:@"keep me"]);
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// **`selectTextOnFocus` is not observable on the user-focus path on this host**,
+// and that is worth saying rather than pretending otherwise: an NSTextField
+// selects all of its text on becoming first responder whatever the prop says,
+// so a test that focused a field and found everything selected would pass with
+// the prop removed. It is a sabotage run that establishes that -- the first
+// version of this file had exactly that test, and it survived.
+//
+// What the prop changes is the *programmatic* path, where this host collapses
+// the selection on purpose, so that is where it is asserted: below, both ways
+// round.
+//
+// `autoFocus` with no `selectTextOnFocus` gets a caret at the end, which is
+// what this host goes out of its way to arrange: an NSTextField selects
+// everything on becoming first responder, and `flushAutoFocus` collapses that
+// because putting a caret in a field is what focusing one means. The prop is
+// what turns the collapse off, so this is the other side of the test above --
+// and it needs the window *before* the mount, `flushAutoFocus` having nowhere
+// to focus otherwise.
+TEST(textinput_auto_focus_alone_leaves_a_caret_rather_than_a_selection) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *root = manager.createSurfaceRoot(kSurfaceId);
+    [root setRnFrameX:0 y:0 width:400 height:300];
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:root];
+
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("text", "select me")("autoFocus", true));
+    NSView *field = fieldOf(view);
+    EXPECT(window.firstResponder == RnPeerEditor(field));
+    EXPECT(RnPeerSelection(field).length == 0);
+
+    // And the same field asking for the prop keeps the whole selection, which
+    // is the one line of difference between the two paths.
+    RnAppKitView *selecting = mountField(
+        manager,
+        11,
+        folly::dynamic::object("text", "select me")("autoFocus", true)("selectTextOnFocus", true));
+    EXPECT(RnPeerSelection(fieldOf(selecting)).length == 9);
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// Both at once, in the order that means something: cleared first, so there is
+// nothing left to select. A host that selected first would leave a selection
+// over text it then threw away.
+TEST(textinput_clearing_and_selecting_at_once_leaves_an_empty_field) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager,
+                                    10,
+                                    folly::dynamic::object("text", "both")("clearTextOnFocus", true)(
+                                        "selectTextOnFocus", true));
+    NSView *field = fieldOf(view);
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    EXPECT([RnPeerText(field) isEqualToString:@""]);
+    EXPECT(RnPeerSelection(field).length == 0);
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// --- caretHidden and contextMenuHidden ---------------------------------------
+//
+// Two props with no AppKit property between them, going in by different routes:
+// the caret through the same remembered colour `cursorColor` uses, the menu by
+// the peer refusing to build one.
+
+TEST(textinput_caret_hidden_asks_for_a_clear_insertion_point) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("caretHidden", true));
+    NSView *field = fieldOf(view);
+
+    // Clear rather than nil: nil means AppKit's own, which is a caret you can
+    // see. An NSTextView draws its insertion point as a filled rectangle, so a
+    // clear one is drawn and invisible.
+    NSColor *const caret = RnPeerCaretColour(field);
+    EXPECT(caret != nil);
+    if (caret != nil) {
+      EXPECT_NEAR([caret colorUsingColorSpace:NSColorSpace.sRGBColorSpace].alphaComponent,
+                  0.0,
+                  0.001);
+    }
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_caret_hidden_wins_over_a_cursor_colour) {
+  @autoreleasepool {
+    // A field that asked for both means the hidden one: it cannot be both red
+    // and invisible, and "hide it" is the more specific instruction.
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager, 10, folly::dynamic::object("caretHidden", true)("cursorColor", 0xffff0000));
+    NSColor *const caret =
+        [RnPeerCaretColour(fieldOf(view)) colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
+    EXPECT(caret != nil);
+    if (caret != nil) {
+      EXPECT_NEAR(caret.alphaComponent, 0.0, 0.001);
+    }
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_a_field_that_did_not_ask_keeps_its_caret) {
+  @autoreleasepool {
+    // The control: nothing remembered, so AppKit's own caret.
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("text", "visible"));
+    EXPECT(RnPeerCaretColour(fieldOf(view)) == nil);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+namespace {
+
+// A right-click, which is what `-menuForEvent:` is asked about.
+NSEvent *secondaryClick() {
+  return [NSEvent mouseEventWithType:NSEventTypeRightMouseDown
+                            location:NSMakePoint(10, 10)
+                       modifierFlags:0
+                           timestamp:0
+                        windowNumber:0
+                             context:nil
+                         eventNumber:1
+                          clickCount:1
+                            pressure:1];
+}
+
+} // namespace
+
+// `contextMenuHidden` on a **multiline** field, which is the half of the prop
+// this host can answer: the peer there is this file's own NSTextView subclass,
+// and it is the view the click lands on.
+//
+// A single-line field is the half it cannot, and that is measured rather than
+// assumed -- see the test below.
+TEST(textinput_context_menu_hidden_refuses_to_build_one_on_a_multiline_field) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager, 10, folly::dynamic::object("multiline", true)("contextMenuHidden", true));
+    NSView *area = fieldOf(view);
+    EXPECT(RnPeerContextMenuHidden(area));
+    // The behaviour rather than the flag: nil is how a view tells AppKit it has
+    // no context menu.
+    EXPECT([area menuForEvent:secondaryClick()] == nil);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_a_multiline_field_that_did_not_ask_keeps_its_context_menu) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager, 10, folly::dynamic::object("multiline", true));
+    NSView *area = fieldOf(view);
+    EXPECT(!RnPeerContextMenuHidden(area));
+    EXPECT([area menuForEvent:secondaryClick()] != nil);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// The single-line twin of the multiline test above, and the same claim: a
+// field that asked for `contextMenuHidden` shows no context menu. It sits
+// beside its twin because the difference between them is the whole of what
+// this host does not do yet, and reading the two together is the only way to
+// see it.
+//
+// The difference is which object AppKit asks. A multiline peer is this
+// project's own NSTextView subclass, so the click lands on a view that can
+// refuse, and `-menuForEvent:` returning nil is the whole of the prop. A
+// single-line field hands editing to the window's shared *field editor* the
+// moment it is focused, and that editor is a plain NSTextView nobody here
+// subclasses: it is the first responder, it is the view under the pointer, and
+// it is therefore the object that answers for the menu. The flag on the field
+// never gets asked. That is why this test focuses the field and questions
+// `currentEditor` rather than the peer -- questioning the peer would pass
+// today while a real right-click still opened Cut, Copy and Paste on a field
+// that had asked for none of them.
+//
+// Without this test the prop looks done on macOS: the flag is set, the tree
+// dump says `context-menu=hidden`, and the multiline half really does work, so
+// every assertion in the file passes while the common case -- a single-line
+// `<TextInput>` -- is unchanged. backlog/textinput.md records that taking the
+// editor's own menu away does not help either, because it rebuilds one inside
+// `-menuForEvent:`, so there is nothing to assert about `menu = nil`. What
+// closes it is supplying the field editor through
+// `-windowWillReturnFieldEditor:toObject:`, which is a window-level hook
+// rather than a prop-level one, and this test is what will say it worked.
+TEST(textinput_context_menu_hidden_refuses_to_build_one_on_a_single_line_field) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("contextMenuHidden", true));
+    NSView *field = fieldOf(view);
+    EXPECT(!RnPeerIsMultiline(field));
+    EXPECT(RnPeerContextMenuHidden(field));
+
+    // A window, because an unfocused NSTextField has no field editor at all
+    // and so nothing to ask: the editor is borrowed from the window when the
+    // field starts editing. Never ordered front, which is what the rest of
+    // this file's focus tests do too.
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                   styleMask:NSWindowStyleMaskTitled
+                                                     backing:NSBackingStoreBuffered
+                                                       defer:NO];
+    window.releasedWhenClosed = NO;
+    [window.contentView addSubview:manager.getSurfaceRoot(kSurfaceId)];
+    EXPECT([window makeFirstResponder:field]);
+
+    NSTextView *editor = (NSTextView *)((NSTextField *)field).currentEditor;
+    EXPECT(editor != nil);
+    if (editor != nil) {
+      // The behaviour rather than the flag, asked of the object that actually
+      // answers it: nil is how a view tells AppKit it has no context menu.
+      EXPECT([editor menuForEvent:secondaryClick()] == nil);
+    }
+
+    [window orderOut:nil];
+    [window close];
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// And what a single-line field does with the prop, which is carry it: the menu
+// a focused NSTextField shows belongs to the window's shared *field editor*,
+// an NSTextView this file does not own, and that view rebuilds its menu inside
+// `-menuForEvent:` -- assigning `menu = nil` on it does not stop it, which was
+// measured rather than guessed.
+//
+// So the flag reaches the peer and the peer is not the view being asked.
+// backlog/textinput.md names the route that would close it, which is supplying
+// the field editor through `-windowWillReturnFieldEditor:toObject:`.
+// And both are in the tree dump, which is where the cross-host diff reads them:
+// each is the absence of something, so there is nothing else to compare.
+TEST(textinput_the_hiding_props_are_reported_in_the_tree) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(
+        manager, 10, folly::dynamic::object("caretHidden", true)("contextMenuHidden", true));
+    const std::string hidden = [view describeTree].UTF8String;
+    EXPECT(hidden.find("caret=hidden") != std::string::npos);
+    EXPECT(hidden.find("context-menu=hidden") != std::string::npos);
+
+    RnAppKitView *plain = mountField(manager, 11, folly::dynamic::object("text", "visible"));
+    const std::string shown = [plain describeTree].UTF8String;
+    EXPECT(shown.find("caret=hidden") == std::string::npos);
+    EXPECT(shown.find("context-menu=hidden") == std::string::npos);
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_a_single_line_field_carries_the_prop_it_cannot_act_on) {
+  @autoreleasepool {
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager, 10, folly::dynamic::object("contextMenuHidden", true));
+    EXPECT(RnPeerContextMenuHidden(fieldOf(view)));
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+// --- submitBehavior ----------------------------------------------------------
+//
+// What Return does. React Native resolves the default itself --
+// `getNonDefaultSubmitBehavior()` answers `blurAndSubmit` for a single-line
+// field and `newline` for a multiline one -- and this host used to leave it to
+// AppKit instead: an NSTextField keeps focus on Return, so every field behaved
+// as `submit` whatever the prop said.
+//
+// Entered through the delegate callback AppKit uses, which is the seam the
+// manager is wired to: a real Return needs a window, a key window and a run
+// loop, and what it would reach is this method.
+namespace {
+
+// Return, as AppKit delivers it to a single-line field's delegate. Answers
+// whether the key was used up, which is what tells AppKit to insert nothing.
+bool pressReturn(basalt::AppKitMountingManager &manager, NSView *field) {
+  id<NSTextFieldDelegate> delegate = ((NSTextField *)field).delegate;
+  (void)manager;
+  // The field editor is the `textView` AppKit passes, and the manager ignores
+  // it -- which the cast here makes explicit rather than passing nil, since the
+  // parameter is declared non-null.
+  NSTextView *editor = (NSTextView *)((NSTextField *)field).currentEditor;
+  if (editor == nil) {
+    editor = [[NSTextView alloc] initWithFrame:NSZeroRect];
+  }
+  return [delegate control:(NSControl *)field
+                        textView:editor
+             doCommandBySelector:@selector(insertNewline:)] == YES;
+}
+
+} // namespace
+
+TEST(textinput_return_submits_by_default) {
+  @autoreleasepool {
+    basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view = mountField(manager,
+                                    90,
+                                    folly::dynamic::object("text", "query"),
+                                    recorder.emitter<TextInputEventEmitter>());
+
+    EXPECT(pressReturn(manager, fieldOf(view)));
+
+    const auto seen = recorder.seen();
+    EXPECT(!seen.empty());
+    EXPECT_EQ(seen.empty() ? std::string{} : seen.front(), std::string{"topSubmitEditing"});
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_submit_behavior_newline_reports_nothing) {
+  @autoreleasepool {
+    // The point of the prop: a chat input that inserts newlines must not send a
+    // message on Return. And the key is *not* used up, which is what lets a
+    // multiline field insert the newline itself.
+    basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager,
+                   91,
+                   folly::dynamic::object("text", "query")("submitBehavior", "newline"),
+                   recorder.emitter<TextInputEventEmitter>());
+
+    EXPECT(!pressReturn(manager, fieldOf(view)));
+    EXPECT(recorder.seen().empty());
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_submit_behavior_submit_reports_and_stays) {
+  @autoreleasepool {
+    basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager,
+                   92,
+                   folly::dynamic::object("text", "query")("submitBehavior", "submit"),
+                   recorder.emitter<TextInputEventEmitter>());
+
+    EXPECT(pressReturn(manager, fieldOf(view)));
+
+    // One event and no blur: `submit` is the half of the prop that keeps focus,
+    // and a blur would arrive as `topBlur` and `topEndEditing` through the
+    // delegate -- which is what the `blurAndSubmit` test below sees.
+    const auto seen = recorder.seen();
+    EXPECT_EQ(seen.size(), 1u);
+    EXPECT_EQ(seen.empty() ? std::string{} : seen[0], std::string{"topSubmitEditing"});
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}
+
+TEST(textinput_submit_behavior_blur_and_submit_gives_up_focus) {
+  @autoreleasepool {
+    // A real window, because giving up focus is a window's business: the field
+    // is made first responder and the key is what has to take that away.
+    basalt::testing::EventRecorder recorder;
+    basalt::AppKitMountingManager manager;
+    RnAppKitView *view =
+        mountField(manager,
+                   93,
+                   folly::dynamic::object("text", "query")("submitBehavior", "blurAndSubmit"),
+                   recorder.emitter<TextInputEventEmitter>());
+
+    NSWindow *window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 400, 300)
+                                                  styleMask:NSWindowStyleMaskTitled
+                                                    backing:NSBackingStoreBuffered
+                                                      defer:NO];
+    [window.contentView addSubview:view];
+    [window makeKeyAndOrderFront:nil];
+    NSView *field = fieldOf(view);
+    [window makeFirstResponder:field];
+    EXPECT(window.firstResponder != window);
+
+    EXPECT(pressReturn(manager, field));
+
+    // Focus handed back to the window, which is this host's "nothing is
+    // focused" -- the same move the `blur` command makes.
+    EXPECT(window.firstResponder == window);
+
+    // Among the events rather than the first: making the field first
+    // responder in a real window reports a focus and a selection on the way,
+    // which is the price of needing a window to ask about focus at all.
+    const auto seen = recorder.seen();
+    EXPECT(std::find(seen.begin(), seen.end(), std::string{"topSubmitEditing"}) != seen.end());
+
+    manager.destroySurfaceRoot(kSurfaceId);
+  }
+}