Port TextInput-test.js to Fantom and remove the legacy Jest test (#56559)

Summary:

Migrates the remaining meaningful coverage from `TextInput-test.js` (Jest with snapshots) over to `TextInput-itest.js` (Fantom) so we can rely on a single test file that exercises the real renderer instead of a heavily-mocked one.

Changes in `TextInput-itest.js`:
- Add a `focus()` test verifying that focusing a `TextInput` unfocuses any previously focused one (mirrors Jest's "should unfocus when other TextInput is focused").
- Add a top-level `has the correct displayName` test.
- Add a new set of `props` describes that assert the props from the original Jest snapshot tests reach the mounting layer via `getRenderedOutput({props: [...]}).toJSX()`:
  - `id and nativeID`: `id` → `nativeID` mapping, `nativeID` pass-through, and `id` precedence over `nativeID`.
  - `testID`: pass-through.
  - `aria-label and accessibilityLabel`: `aria-label` → `accessibilityLabel` mapping and `accessibilityLabel` pass-through.
  - `aria-* and accessibilityState`: `aria-busy/checked/disabled/expanded/selected` mapped into `accessibilityState`.
  - `accessibilityRole`: pass-through.
  - `style`: `backgroundColor` propagated as a native color value.

Tests intentionally NOT ported:
- Inherited `HostInstance` method presence checks (`focus`, `blur`, `setNativeProps`, `measure`, `measureInWindow`, `measureLayout`): they are guaranteed by Flow typing on `ReactNativeElement`, exercised in `ReactNativeElement-itest.js`, and Flow's `method-unbinding` rule prevents the simple `toBeInstanceOf(Function)` check without `$FlowFixMe` (which is forbidden by project rules).
- `focus() should not do anything if the TextInput is not editable`: `TextInputState.focusTextInput` reads `textField.currentProps?.editable`, but in the new architecture `currentProps` is not exposed on the public `ReactNativeElement` instance, so the check is effectively bypassed. The Jest test only passed by monkey-patching `currentProps`. Documenting this as expected behavior in Fantom would mask a real bug.
- `should give precedence to textContentType when set`: `textContentType` is iOS-only and Fantom defaults to Android (`AndroidTextInput`).

Files removed:
- `Libraries/Components/TextInput/__tests__/TextInput-test.js`
- `Libraries/Components/TextInput/__tests__/__snapshots__/TextInput-test.js.snap`

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D101977225

Author: rubennorte

packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js

@@ -148,6 +148,138 @@ describe('<TextInput>', () => {
         expect(blurEvent).toHaveBeenCalledTimes(1);
       });
     });
+
+    describe('id and nativeID', () => {
+      it(`has 'id' propagated as 'nativeID' to the mounting layer`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has 'nativeID' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput nativeID="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has a precedence of 'id' over 'nativeID'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" nativeID="gamma" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+    });
+
+    describe('testID', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput testID="my-test-id" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['testID']}).toJSX()).toEqual(
+          <rn-androidTextInput testID="my-test-id" />,
+        );
+      });
+    });
+
+    describe('aria-label and accessibilityLabel', () => {
+      it(`has 'aria-label' propagated as 'accessibilityLabel'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput aria-label="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+
+      it(`has 'accessibilityLabel' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityLabel="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+    });
+
+    describe('aria-* and accessibilityState', () => {
+      it(`maps 'aria-*' state props to 'accessibilityState'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(
+            <TextInput
+              aria-busy={true}
+              aria-checked={true}
+              aria-disabled={true}
+              aria-expanded={true}
+              aria-selected={true}
+            />,
+          );
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityState']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput accessibilityState="{disabled:true,selected:true,checked:Checked,busy:true,expanded:true}" />,
+        );
+      });
+    });
+
+    describe('accessibilityRole', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityRole="button" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityRole']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityRole="button" />);
+      });
+    });
+
+    describe('style', () => {
+      it('propagates style values to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput style={{backgroundColor: 'white'}} />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['backgroundColor']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput backgroundColor="rgba(255, 255, 255, 1)" />,
+        );
+      });
+    });
   });
 
   describe('ref', () => {
@@ -276,6 +408,43 @@ describe('<TextInput>', () => {
           'Command {type: "AndroidTextInput", nativeID: "text-input", name: "focus"}',
         ]);
       });
+
+      it('unfocuses any previously focused TextInput when a new one is focused', () => {
+        const root = Fantom.createRoot();
+        const ref1 = createRef<TextInputInstance>();
+        const ref2 = createRef<TextInputInstance>();
+
+        Fantom.runTask(() => {
+          root.render(
+            <>
+              <TextInput nativeID="text-input-1" ref={ref1} />
+              <TextInput nativeID="text-input-2" ref={ref2} />
+            </>,
+          );
+        });
+
+        const instance1 = nullthrows(ref1.current);
+        const instance2 = nullthrows(ref2.current);
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(false);
+
+        Fantom.runTask(() => {
+          instance1.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(true);
+        expect(instance2.isFocused()).toBe(false);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance1);
+
+        Fantom.runTask(() => {
+          instance2.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(true);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance2);
+      });
     });
 
     describe('blur()', () => {
@@ -459,4 +628,8 @@ describe('<TextInput>', () => {
       });
     });
   });
+
+  it('has the correct displayName', () => {
+    expect(TextInput.displayName).toBe('TextInput');
+  });
 });