fix: wrong selection coordinates on focus (#1234)

## 📜 Description

Fixed non-working `KeyboardAwareScrollView` on iOS.

## 💡 Motivation and Context

Turns out that selection is not available straight after input focus. To
fix this problem I decided to query selection in next frame:

```swift
      DispatchQueue.main.async {
        updateSelectionPosition(textInput: textInput, sendEvent: self.onSelectionChange)
      }
```

And it works, and works pretty well, but it introduces a regression on
iOS < 16. The thing is that starting from iOS 16 Apple started to use
TextKit 2. And in TextKit 2 all operations are async, so for iOS 16+
we'll get events like layout updated -> selection updated -> onStart ->
onMove, but on iOS 15 it will be layout updated -> onStart -> selection
updated -> onMove.

The original JS code assumed `selection` always arrives before onStart.
On iOS < 16, `onStart` now fires first, so `updateLayoutFromSelection()`
reads stale `lastSelection.value` from the previous focus session -
producing a wrong `ayout.value` used by `maybeScroll` throughout the
keyboard animation.

So I added `pendingSelectionForFocus` flag - a shared value that tracks
whether `onStart` fired for a focus change but the corresponding
selection event hasn't arrived yet.

In `onStart` - when focus changes, check if
`lastSelection.value?.target` matches the new target:
- **matches** (iOS 16+ flow — selection arrived first): call
`updateLayoutFromSelection()` as before
- **doesn't match** (iOS < 16 flow — selection is late): set
`layout.value = input.value` as a safe fallback (full input height
instead of cursor-precise height), set the pending flag

The immediate scroll for focus-change-without-keyboard-appearing
(`focusWasChanged && !keyboardWillAppear`) is skipped when pending,
since we don't have accurate layout data yet.

In `onSelectionChange` - when the target changes and the pending flag is
set:

- clear the flag
- call `updateLayoutFromSelection()` with the now-correct selection data
- If keyboard was already visible (no `onMove` expected), perform the
deferred scroll

This ensures `layout.value` is correct before `onMove` starts using it
for scroll interpolation.

In onEnd — `lastSelection.value` is cleared to `null `when the keyboard
fully hides (`e.height === 0)`. This prevents a subtle bug: when
re-focusing the same input at a different cursor position,
`lastSelection.value?.target` would still match `e.target` from the
previous session, making `onStart` incorrectly think fresh selection
data was available.

Closes
#1218

## 📢 Changelog

<!-- High level overview of important changes -->
<!-- For example: fixed status bar manipulation; added new types
declarations; -->
<!-- If your changes don't affect one of platform/language below - then
remove this platform/language -->

### JS

- added `pendingSelectionForFocus` flag;
- added logic for proper selection updates depending on the flag state;

### iOS

- dispatch selection in next frame on focus so that it becomes
available;

### E2E

- re-generated Android 28 test assets;

## 🤔 How Has This Been Tested?

Tested manually on:
- iPhone 16 Pro (iOS 26.2, simulator);
- e2e_emulator_28 (API 28, emulator);
- iPhone 13 Pro (iOS 15.5, simulator).

## 📸 Screenshots (if appropriate):

|iOS 15|iOS 26|
|-------|------|
|<video
src="https://github.com/user-attachments/assets/36f4cc76-74be-4190-8ca6-f80b341333d9">|<video
src="https://github.com/user-attachments/assets/cbeb2c96-541d-447a-844c-8082399737d1">|

## 📝 Checklist

- [x] CI successfully passed
- [x] I added new mocks and corresponding unit-tests if library API was
changed

Author: kirillzyusko

e2e/kit/assets/android/e2e_emulator_28/AwareScrollViewInputChanged.png

@@ -142,7 +142,9 @@ public class FocusedInputObserver: NSObject {
     setupObservers()
     // dispatch onSelectionChange on focus
     if let textInput = responder as? UITextInput {
-      updateSelectionPosition(textInput: textInput, sendEvent: onSelectionChange)
+      DispatchQueue.main.async {
+        updateSelectionPosition(textInput: textInput, sendEvent: self.onSelectionChange)
+      }
     }
 
     syncUpLayout()

ios/observers/FocusedInputObserver.swift

@@ -149,6 +149,7 @@ const KeyboardAwareScrollView = forwardRef<
     const lastSelection =
       useSharedValue<FocusedInputSelectionChangedEvent | null>(null);
     const ghostViewSpace = useSharedValue(-1);
+    const pendingSelectionForFocus = useSharedValue(false);
 
     const { height } = useWindowDimensions();
 
@@ -324,7 +325,18 @@ const KeyboardAwareScrollView = forwardRef<
         lastSelection.value = e;
 
         if (e.target !== lastTarget) {
-          // ignore this event, because "focus changed" event handled in `useSmoothKeyboardHandler`
+          if (pendingSelectionForFocus.value) {
+            // selection arrived after onStart - complete the deferred setup
+            pendingSelectionForFocus.value = false;
+            updateLayoutFromSelection();
+
+            // if keyboard was already visible (focus change, no onMove expected),
+            // perform the deferred scroll now
+            if (!keyboardWillAppear.value && keyboardHeight.value > 0) {
+              position.value += maybeScroll(keyboardHeight.value, true);
+            }
+          }
+
           return;
         }
         // caret in the end + end coordinates has been changed -> we moved to a new line
@@ -342,7 +354,12 @@ const KeyboardAwareScrollView = forwardRef<
 
         onChangeTextHandler();
       },
-      [scrollFromCurrentPosition, onChangeTextHandler],
+      [
+        scrollFromCurrentPosition,
+        onChangeTextHandler,
+        updateLayoutFromSelection,
+        maybeScroll,
+      ],
     );
 
     useFocusedInputHandler(
@@ -375,6 +392,7 @@ const KeyboardAwareScrollView = forwardRef<
             // on back transition need to interpolate as [0, keyboardHeight]
             initialKeyboardSize.value = 0;
             scrollPosition.value = scrollBeforeKeyboardMovement.value;
+            pendingSelectionForFocus.value = false;
           }
 
           if (
@@ -391,17 +409,31 @@ const KeyboardAwareScrollView = forwardRef<
           // focus was changed
           if (focusWasChanged) {
             tag.value = e.target;
-            // save position of focused text input when keyboard starts to move
-            updateLayoutFromSelection();
+
+            if (lastSelection.value?.target === e.target) {
+              // selection arrived before onStart - use it to update layout
+              updateLayoutFromSelection();
+              pendingSelectionForFocus.value = false;
+            } else {
+              // selection hasn't arrived yet for the new target.
+              // use input layout as-is; will be refined when selection arrives.
+              if (input.value) {
+                layout.value = input.value;
+              }
+              pendingSelectionForFocus.value = true;
+            }
+
             // save current scroll position - when keyboard will hide we'll reuse
             // this value to achieve smooth hide effect
             scrollBeforeKeyboardMovement.value = position.value;
           }
 
           if (focusWasChanged && !keyboardWillAppear.value) {
-            // update position on scroll value, so `onEnd` handler
-            // will pick up correct values
-            position.value += maybeScroll(e.height, true);
+            if (!pendingSelectionForFocus.value) {
+              // update position on scroll value, so `onEnd` handler
+              // will pick up correct values
+              position.value += maybeScroll(e.height, true);
+            }
           }
 
           ghostViewSpace.value =
@@ -435,6 +467,10 @@ const KeyboardAwareScrollView = forwardRef<
           keyboardHeight.value = e.height;
           scrollPosition.value = position.value;
 
+          if (e.height === 0) {
+            lastSelection.value = null;
+          }
+
           syncKeyboardFrame(e);
         },
       },