react-native-keyboard-controller 1.15.2 → 1.16.0

package/android/src/fabric/java/com/reactnativekeyboardcontroller/KeyboardControllerViewManager.kt

@@ -36,6 +36,12 @@ class KeyboardControllerViewManager(
     value: Boolean,
   ) = manager.setNavigationBarTranslucent(view as EdgeToEdgeReactViewGroup, value)
 
+  @ReactProp(name = "preserveEdgeToEdge")
+  override fun setPreserveEdgeToEdge(
+    view: ReactViewGroup,
+    value: Boolean,
+  ) = manager.setPreserveEdgeToEdge(view as EdgeToEdgeReactViewGroup, value)
+
   @ReactProp(name = "enabled")
   override fun setEnabled(
     view: ReactViewGroup,

package/android/src/fabric/java/com/reactnativekeyboardcontroller/KeyboardGestureAreaViewManager.kt

@@ -56,4 +56,12 @@ class KeyboardGestureAreaViewManager(
   ) {
     manager.setScrollKeyboardOffScreenWhenVisible(view as KeyboardGestureAreaReactViewGroup, value)
   }
+
+  @ReactProp(name = "textInputNativeID")
+  override fun setTextInputNativeID(
+    view: ReactViewGroup,
+    value: String?,
+  ) {
+    // no-op
+  }
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/extensions/EditText.kt

@@ -4,12 +4,13 @@ import android.os.Build
 import android.text.Editable
 import android.text.InputType
 import android.text.TextWatcher
+import android.view.Gravity
 import android.view.View
+import android.view.ViewTreeObserver.OnPreDrawListener
 import android.widget.EditText
 import com.facebook.react.views.scroll.ReactScrollView
 import com.facebook.react.views.textinput.ReactEditText
 import com.reactnativekeyboardcontroller.log.Logger
-import com.reactnativekeyboardcontroller.ui.FrameScheduler
 import java.lang.reflect.Field
 import kotlin.math.max
 import kotlin.math.min
@@ -78,6 +79,13 @@ fun EditText.addOnTextChangedListener(action: (String) -> Unit): TextWatcher {
     Logger.w(javaClass.simpleName, "Can not attach listener because casting failed: ${e.message}")
   } catch (e: NoSuchFieldException) {
     Logger.w(javaClass.simpleName, "Can not attach listener because field `mListeners` not found: ${e.message}")
+  } catch (e: IllegalArgumentException) {
+    Logger.w(
+      javaClass.simpleName,
+      "Can not attach listener to be the first in the list: ${e.message}. Attaching to the end...",
+    )
+    // it's plain EditText - it doesn't have the same problem as ReactEditText
+    this.addTextChangedListener(listener)
   }
 
   return listener
@@ -146,78 +154,96 @@ val EditText?.keyboardType: String
   }
 
 class KeyboardControllerSelectionWatcher(
-  private val editText: ReactEditText,
+  private val editText: EditText,
   private val action: (start: Int, end: Int, startX: Double, startY: Double, endX: Double, endY: Double) -> Unit,
 ) {
   private var lastSelectionStart: Int = -1
   private var lastSelectionEnd: Int = -1
+  private var lastEditTextHeight: Int = -1
 
-  private val frameScheduler =
-    FrameScheduler {
-      val start = editText.selectionStart
-      val end = editText.selectionEnd
-
-      if (lastSelectionStart != start || lastSelectionEnd != end) {
-        lastSelectionStart = start
-        lastSelectionEnd = end
+  private val preDrawListener: OnPreDrawListener =
+    object : OnPreDrawListener {
+      override fun onPreDraw(): Boolean {
+        val start = editText.selectionStart
+        val end = editText.selectionEnd
+        val editTextHeight = editText.height
 
         val view = editText
         val layout = view.layout
 
         if (layout === null) {
-          return@FrameScheduler
+          return true
+        }
+
+        if (lastSelectionStart != start || lastSelectionEnd != end || lastEditTextHeight != editTextHeight) {
+          lastSelectionStart = start
+          lastSelectionEnd = end
+          lastEditTextHeight = editTextHeight
+
+          val cursorPositionStartX: Float
+          val cursorPositionStartY: Float
+          val cursorPositionEndX: Float
+          val cursorPositionEndY: Float
+
+          val realStart = min(start, end)
+          val realEnd = max(start, end)
+
+          val lineStart = layout.getLineForOffset(realStart)
+          val baselineStart = layout.getLineTop(lineStart)
+
+          val textHeight = layout.height
+          val cursorWidth =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+              view.textCursorDrawable?.intrinsicWidth ?: 0
+            } else {
+              0
+            }
+          val gravity = editText.gravity and Gravity.VERTICAL_GRAVITY_MASK
+          val paddingVertical = editText.paddingTop + editText.paddingBottom
+          val lineHeightHalfHearted = editText.lineHeight / 2
+          val verticalOffset =
+            when (gravity) {
+              Gravity.CENTER_VERTICAL ->
+                (editTextHeight - paddingVertical - textHeight) / 2 + editText.paddingTop + lineHeightHalfHearted
+              Gravity.BOTTOM -> editTextHeight - textHeight - editText.paddingBottom + lineHeightHalfHearted
+              // Default to Gravity.TOP or other cases
+              else -> editText.paddingTop + lineHeightHalfHearted
+            }
+
+          cursorPositionStartX = layout.getPrimaryHorizontal(realStart)
+          cursorPositionStartY = (baselineStart + verticalOffset).toFloat()
+
+          val lineEnd = layout.getLineForOffset(realEnd)
+          val right = layout.getPrimaryHorizontal(realEnd)
+          val bottom = layout.getLineBottom(lineEnd)
+
+          cursorPositionEndX = right + cursorWidth
+          cursorPositionEndY = (bottom + verticalOffset).toFloat()
+
+          action(
+            start,
+            end,
+            cursorPositionStartX.dp,
+            cursorPositionStartY.dp,
+            cursorPositionEndX.dp,
+            cursorPositionEndY.dp,
+          )
         }
 
-        val cursorPositionStartX: Float
-        val cursorPositionStartY: Float
-        val cursorPositionEndX: Float
-        val cursorPositionEndY: Float
-
-        val realStart = min(start, end)
-        val realEnd = max(start, end)
-
-        val lineStart = layout.getLineForOffset(realStart)
-        val baselineStart = layout.getLineBaseline(lineStart)
-        val ascentStart = layout.getLineAscent(lineStart)
-
-        cursorPositionStartX = layout.getPrimaryHorizontal(realStart)
-        cursorPositionStartY = (baselineStart + ascentStart).toFloat()
-
-        val lineEnd = layout.getLineForOffset(realEnd)
-
-        val right = layout.getPrimaryHorizontal(realEnd)
-        val bottom = layout.getLineBottom(lineEnd) + layout.getLineAscent(lineEnd)
-        val cursorWidth =
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            view.textCursorDrawable?.intrinsicWidth ?: 0
-          } else {
-            0
-          }
-
-        cursorPositionEndX = right + cursorWidth
-        cursorPositionEndY = bottom.toFloat()
-
-        action(
-          start,
-          end,
-          cursorPositionStartX.dp,
-          cursorPositionStartY.dp,
-          cursorPositionEndX.dp,
-          cursorPositionEndY.dp,
-        )
+        return true
       }
     }
 
   fun setup() {
-    frameScheduler.start()
+    editText.viewTreeObserver.addOnPreDrawListener(preDrawListener)
   }
 
   fun destroy() {
-    frameScheduler.stop()
+    editText.viewTreeObserver.removeOnPreDrawListener(preDrawListener)
   }
 }
 
-fun ReactEditText.addOnSelectionChangedListener(
+fun EditText.addOnSelectionChangedListener(
   action: (start: Int, end: Int, startX: Double, startY: Double, endX: Double, endY: Double) -> Unit,
 ): () -> Unit {
   val listener = KeyboardControllerSelectionWatcher(this, action)

package/android/src/main/java/com/reactnativekeyboardcontroller/listeners/FocusedInputObserver.kt

@@ -4,10 +4,10 @@ import android.text.TextWatcher
 import android.view.View
 import android.view.View.OnLayoutChangeListener
 import android.view.ViewTreeObserver.OnGlobalFocusChangeListener
+import android.widget.EditText
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.events.FocusedInputLayoutChangedEvent
 import com.reactnativekeyboardcontroller.events.FocusedInputLayoutChangedEventData
@@ -46,7 +46,7 @@ class FocusedInputObserver(
   private val surfaceId = UIManagerHelper.getSurfaceId(view)
 
   // state variables
-  private var lastFocusedInput: ReactEditText? = null
+  private var lastFocusedInput: EditText? = null
   private var lastEventDispatched: FocusedInputLayoutChangedEventData = noFocusedInputEvent
   private var textWatcher: TextWatcher? = null
   private var selectionSubscription: (() -> Unit)? = null
@@ -105,7 +105,7 @@ class FocusedInputObserver(
         selectionSubscription?.invoke()
         lastFocusedInput = null
       }
-      if (newFocus is ReactEditText) {
+      if (newFocus is EditText) {
         lastFocusedInput = newFocus
         newFocus.addOnLayoutChangeListener(layoutListener)
         this.syncUpLayout()

package/android/src/main/java/com/reactnativekeyboardcontroller/listeners/KeyboardAnimationCallback.kt

@@ -2,6 +2,7 @@ package com.reactnativekeyboardcontroller.listeners
 
 import android.view.View
 import android.view.ViewTreeObserver.OnGlobalFocusChangeListener
+import android.widget.EditText
 import androidx.core.graphics.Insets
 import androidx.core.view.OnApplyWindowInsetsListener
 import androidx.core.view.ViewCompat
@@ -11,7 +12,6 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.constants.Keyboard
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
@@ -67,7 +67,7 @@ class KeyboardAnimationCallback(
   // listeners
   private val focusListener =
     OnGlobalFocusChangeListener { oldFocus, newFocus ->
-      if (newFocus is ReactEditText) {
+      if (newFocus is EditText) {
         viewTagFocused = newFocus.id
 
         // keyboard is visible and focus has been changed

package/android/src/main/java/com/reactnativekeyboardcontroller/managers/KeyboardControllerViewManagerImpl.kt

@@ -37,6 +37,13 @@ class KeyboardControllerViewManagerImpl(
     view.setNavigationBarTranslucent(isNavigationBarTranslucent)
   }
 
+  fun setPreserveEdgeToEdge(
+    view: EdgeToEdgeReactViewGroup,
+    isPreservingEdgeToEdge: Boolean,
+  ) {
+    view.setPreserveEdgeToEdge(isPreservingEdgeToEdge)
+  }
+
   fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
     val map: MutableMap<String, Any> =
       MapBuilder.of(

package/android/src/main/java/com/reactnativekeyboardcontroller/views/EdgeToEdgeReactViewGroup.kt

@@ -31,6 +31,7 @@ class EdgeToEdgeReactViewGroup(
   // props
   private var isStatusBarTranslucent = false
   private var isNavigationBarTranslucent = false
+  private var isPreservingEdgeToEdge = false
   private var active = false
 
   // internal class members
@@ -188,7 +189,10 @@ class EdgeToEdgeReactViewGroup(
   }
 
   private fun disable() {
-    this.goToEdgeToEdge(false)
+    if (!isPreservingEdgeToEdge) {
+      this.goToEdgeToEdge(false)
+    }
+
     this.setupWindowInsets()
     this.removeKeyboardCallbacks()
     modalAttachedWatcher.disable()
@@ -208,6 +212,10 @@ class EdgeToEdgeReactViewGroup(
     this.isNavigationBarTranslucent = isNavigationBarTranslucent
   }
 
+  fun setPreserveEdgeToEdge(isPreservingEdgeToEdge: Boolean) {
+    this.isPreservingEdgeToEdge = isPreservingEdgeToEdge
+  }
+
   fun setActive(active: Boolean) {
     this.active = active
 

package/android/src/paper/java/com/reactnativekeyboardcontroller/KeyboardControllerViewManager.kt

@@ -41,6 +41,14 @@ class KeyboardControllerViewManager(
     manager.setNavigationBarTranslucent(view, isNavigationBarTranslucent)
   }
 
+  @ReactProp(name = "preserveEdgeToEdge")
+  fun setPreserveEdgeToEdge(
+    view: EdgeToEdgeReactViewGroup,
+    isPreservingEdgeToEdge: Boolean,
+  ) {
+    manager.setPreserveEdgeToEdge(view, isPreservingEdgeToEdge)
+  }
+
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
     manager.getExportedCustomDirectEventTypeConstants()
 }

package/android/src/paper/java/com/reactnativekeyboardcontroller/KeyboardGestureAreaViewManager.kt

@@ -48,4 +48,13 @@ class KeyboardGestureAreaViewManager(
   ) {
     manager.setScrollKeyboardOffScreenWhenVisible(view, value)
   }
+
+  @Suppress("detekt:UnusedParameter")
+  @ReactProp(name = "textInputNativeID")
+  fun setTextInputNativeID(
+    view: KeyboardGestureAreaReactViewGroup,
+    value: String,
+  ) {
+    // no-op
+  }
 }

package/ios/animations/KeyboardAnimation.swift

@@ -23,14 +23,14 @@ public class KeyboardAnimation: KeyboardAnimationProtocol {
   // constructor variables
   let fromValue: Double
   let toValue: Double
-  let speed: Float
+  let speed: Double
   let timestamp: CFTimeInterval
 
   init(fromValue: Double, toValue: Double, animation: CAMediaTiming) {
     self.fromValue = fromValue
     self.toValue = toValue
     self.animation = animation
-    speed = animation.speed
+    speed = Double(animation.speed)
     timestamp = CACurrentMediaTime()
   }
 
@@ -63,7 +63,7 @@ public class KeyboardAnimation: KeyboardAnimationProtocol {
 
     while (upperBound - lowerBound) > tolerance {
       tGuess = (lowerBound + upperBound) / 2
-      let currentValue = valueAt(time: tGuess / Double(speed))
+      let currentValue = valueAt(time: tGuess / speed)
 
       // Adjust the condition to account for the direction of animation
       if (currentValue < value && isIncreasing) || (currentValue > value && !isIncreasing) {
@@ -73,6 +73,6 @@ public class KeyboardAnimation: KeyboardAnimationProtocol {
       }
     }
 
-    return tGuess / Double(speed)
+    return tGuess / speed
   }
 }

package/ios/animations/SpringAnimation.swift

@@ -16,6 +16,13 @@ public final class SpringAnimation: KeyboardAnimation {
   private let omega0: Double // Undamped angular frequency of the oscillator
   private let omega1: Double // Exponential decay
   private let v0: Double // Initial velocity
+  // pre-computed values
+  private let x0: Double
+  private let isUnderDamped: Bool
+  private let aUnder: Double
+  private let bUnder: Double
+  private let aCritical: Double
+  private let bCritical: Double
 
   // constructor variables
   private let stiffness: Double
@@ -33,24 +40,40 @@ public final class SpringAnimation: KeyboardAnimation {
     omega0 = sqrt(stiffness / mass) // Undamped angular frequency of the oscillator
     omega1 = omega0 * sqrt(1.0 - zeta * zeta) // Exponential decay
     v0 = -initialVelocity
+    x0 = toValue - fromValue
+    isUnderDamped = zeta < 1
+
+    if isUnderDamped {
+      // Under damped
+      aCritical = 0
+      bCritical = 0
+      aUnder = (v0 + zeta * omega0 * x0) / omega1
+      bUnder = x0
+    } else {
+      // Critically damped
+      aCritical = x0
+      bCritical = (v0 + omega0 * x0)
+      aUnder = 0
+      bUnder = 0
+    }
 
     super.init(fromValue: fromValue, toValue: toValue, animation: animation)
   }
 
   // public functions
   override func valueAt(time: Double) -> Double {
-    let t = time * Double(speed)
-    let x0 = toValue - fromValue
+    let t = time * speed
 
     var y: Double
-    if zeta < 1 {
+    if isUnderDamped {
       // Under damped
       let envelope = exp(-zeta * omega0 * t)
-      y = toValue - envelope * (((v0 + zeta * omega0 * x0) / omega1) * sin(omega1 * t) + x0 * cos(omega1 * t))
+      let angle = omega1 * t
+      y = toValue - envelope * (aUnder * sin(angle) + bUnder * cos(angle))
     } else {
       // Critically damped
       let envelope = exp(-omega0 * t)
-      y = toValue - envelope * (x0 + (v0 + omega0 * x0) * t)
+      y = toValue - envelope * (aCritical + bCritical * t)
     }
 
     return y

package/ios/animations/TimingAnimation.swift

@@ -33,19 +33,38 @@ public final class TimingAnimation: KeyboardAnimation {
     super.init(fromValue: fromValue, toValue: toValue, animation: animation)
   }
 
-  // public functions
+  // MARK: public functions
+
   override func valueAt(time: Double) -> Double {
-    let x = time * Double(speed)
-    let frames = (animation?.duration ?? 0.0) * Double(speed)
-    let fraction = min(x / frames, 1)
-    let t = findTForX(xTarget: fraction)
+    let duration = animation?.duration ?? 0.0
+    guard duration > 0 else { return toValue }
 
+    let fraction = min(time / duration, 1.0)
+    let t = findTForX(xTarget: fraction)
     let progress = bezierY(t: t)
 
-    return fromValue + (toValue - fromValue) * CGFloat(progress)
+    return fromValue + (toValue - fromValue) * progress
+  }
+
+  override func timingAt(value: Double) -> Double {
+    guard (toValue - fromValue) != 0 else { return 0 }
+
+    let targetY = (value - fromValue) / (toValue - fromValue)
+    let clampedY = max(min(targetY, 1.0), 0.0)
+
+    let t = findTForY(yTarget: clampedY)
+    let x = bezierX(t: t)
+
+    let duration = animation?.duration ?? 0.0
+    let time = x * duration / speed
+
+    return time
   }
 
   // private functions
+
+  // MARK: Bézier
+
   private func bezier(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
     let u = 1 - t
     let tt = t * t
@@ -70,39 +89,65 @@ public final class TimingAnimation: KeyboardAnimation {
     return bezier(t: t) { $0.x }
   }
 
-  private func findTForX(xTarget: CGFloat, epsilon: CGFloat = 0.0001, maxIterations: Int = 100) -> CGFloat {
-    var t: CGFloat = 0.5 // Start with an initial guess of t = 0.5
-    for _ in 0 ..< maxIterations {
-      let currentX = bezierX(t: t) // Compute the x-coordinate at t
-      let derivativeX = bezierXDerivative(t: t) // Compute the derivative at t
-      let xError = currentX - xTarget
-      if abs(xError) < epsilon {
-        return t
-      }
-      t -= xError / derivativeX // Newton-Raphson step
-      t = max(min(t, 1), 0) // Ensure t stays within bounds
+  private func bezierDerivative(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
+    let u = 1 - t
+    let term1 = (3 * u * u - 6 * t * u) * valueForPoint(p1)
+    let term2 = (6 * t * u - 3 * t * t) * valueForPoint(p2)
+    let term3 = 3 * t * t
+    return term1 + term2 + term3
+  }
+
+  private func bezierXDerivative(t: CGFloat) -> CGFloat {
+    bezierDerivative(t: t) { $0.x }
+  }
+
+  private func bezierYDerivative(t: CGFloat) -> CGFloat {
+    bezierDerivative(t: t) { $0.y }
+  }
+
+  private enum BezierComponent {
+    case x
+    case y
+  }
+
+  private func calculateComponents(t: CGFloat, component: BezierComponent) -> (value: CGFloat, derivative: CGFloat) {
+    switch component {
+    case .x:
+      return (bezierX(t: t), bezierXDerivative(t: t))
+    case .y:
+      return (bezierY(t: t), bezierYDerivative(t: t))
     }
-    return t // Return the approximation of t
   }
 
-  private func bezierDerivative(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
-    let u = 1 - t
-    let uu = u * u
-    let tt = t * t
-    let tu = t * u
+  // MARK: Newton Raphson
 
-    // term0 is evaluated as `0`, because P0(0, 0)
-    // let term0 = -3 * uu * valueForPoint(p0)
-    let term1 = (3 * uu - 6 * tu) * valueForPoint(p1)
-    let term2 = (6 * tu - 3 * tt) * valueForPoint(p2)
-    let term3 = 3 * tt // * valueForPoint(p3), because P3(1, 1)
+  private func findT(
+    target: CGFloat,
+    component: BezierComponent,
+    epsilon: CGFloat = 0.0001,
+    maxIterations: Int = 100
+  ) -> CGFloat {
+    var t: CGFloat = 0.5
+    for _ in 0 ..< maxIterations {
+      let (value, derivative) = calculateComponents(t: t, component: component)
+      let error = value - target
 
-    // Sum all terms to get the derivative
-    return term1 + term2 + term3
+      if abs(error) < epsilon {
+        break
+      }
+
+      t -= error / derivative
+      t = max(0, min(t, 1))
+    }
+    return t
   }
 
-  private func bezierXDerivative(t: CGFloat) -> CGFloat {
-    return bezierDerivative(t: t) { $0.x }
+  private func findTForX(xTarget: CGFloat) -> CGFloat {
+    findT(target: xTarget, component: .x)
+  }
+
+  private func findTForY(yTarget: CGFloat) -> CGFloat {
+    findT(target: yTarget, component: .y)
   }
 }
 

package/ios/delegates/KCTextInputCompositeDelegate.swift

@@ -51,6 +51,9 @@ class KCTextInputCompositeDelegate: NSObject, UITextViewDelegate, UITextFieldDel
   weak var textViewDelegate: UITextViewDelegate?
   weak var textFieldDelegate: UITextFieldDelegate?
 
+  // Keep track of which textField we’re observing (iOS < 13 only)
+  private weak var observedTextFieldForSelection: UITextField?
+
   public init(
     onSelectionChange: @escaping (_ event: NSDictionary) -> Void,
     onTextChange: @escaping (_ text: String?) -> Void
@@ -62,13 +65,35 @@ class KCTextInputCompositeDelegate: NSObject, UITextViewDelegate, UITextFieldDel
   // MARK: setters/getters
 
   public func setTextViewDelegate(delegate: UITextViewDelegate?) {
+    // remove KVO from any old textField
+    if let oldTextField = observedTextFieldForSelection {
+      removeSelectionRangeObserver(from: oldTextField)
+    }
+
     textViewDelegate = delegate
     textFieldDelegate = nil
+    observedTextFieldForSelection = nil
   }
 
-  public func setTextFieldDelegate(delegate: UITextFieldDelegate?) {
+  public func setTextFieldDelegate(delegate: UITextFieldDelegate?, textField: UITextField?) {
+    // remove KVO from any old textField
+    if let oldTextField = observedTextFieldForSelection {
+      removeSelectionRangeObserver(from: oldTextField)
+    }
+
     textFieldDelegate = delegate
     textViewDelegate = nil
+
+    // If iOS < 13, add KVO to the actual textField object
+    if #available(iOS 13.0, *) {
+      // rely on textFieldDidChangeSelection
+      observedTextFieldForSelection = nil
+    } else {
+      if let realTextField = textField {
+        addSelectionRangeObserver(to: realTextField)
+        observedTextFieldForSelection = realTextField
+      }
+    }
   }
 
   // Getter for the active delegate
@@ -116,9 +141,56 @@ class KCTextInputCompositeDelegate: NSObject, UITextViewDelegate, UITextFieldDel
       self.onTextChange(textField.text)
     }
 
+    if #unavailable(iOS 13.0) {
+      DispatchQueue.main.asyncAfter(deadline: .now() + UIUtils.nextFrame) {
+        updateSelectionPosition(textInput: textField, sendEvent: self.onSelectionChange)
+      }
+    }
+
     return textFieldDelegate?.textField?(textField, shouldChangeCharactersIn: range, replacementString: string) ?? true
   }
 
+  func textFieldDidEndEditing(_ textField: UITextField) {
+    textFieldDelegate?.textFieldDidEndEditing?(textField)
+
+    if #unavailable(iOS 13.0) {
+      removeSelectionRangeObserver(from: textField)
+      if observedTextFieldForSelection === textField {
+        observedTextFieldForSelection = nil
+      }
+    }
+  }
+
+  // MARK: KVO for iOS < 13
+
+  private func addSelectionRangeObserver(to textField: UITextField) {
+    textField.addObserver(
+      self,
+      forKeyPath: "selectedTextRange",
+      options: [.new],
+      context: nil
+    )
+  }
+
+  private func removeSelectionRangeObserver(from textField: UITextField) {
+    textField.removeObserver(self, forKeyPath: "selectedTextRange")
+  }
+
+  // swiftlint:disable:next block_based_kvo
+  override func observeValue(
+    forKeyPath keyPath: String?,
+    of object: Any?,
+    change: [NSKeyValueChangeKey: Any]?,
+    context: UnsafeMutableRawPointer?
+  ) {
+    guard keyPath == "selectedTextRange", let textField = object as? UITextField else {
+      super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+      return
+    }
+    // selection changed => forward the event
+    updateSelectionPosition(textInput: textField, sendEvent: onSelectionChange)
+  }
+
   // MARK: call forwarding
 
   override func responds(to aSelector: Selector!) -> Bool {

package/ios/extensions/Notification.swift

@@ -15,3 +15,7 @@ extension Notification {
     return (duration, keyboardFrame)
   }
 }
+
+extension Notification.Name {
+  static let shouldIgnoreKeyboardEvents = Notification.Name("shouldIgnoreKeyboardEvents")
+}