@apollohg/react-native-prose-editor 0.5.9 → 0.5.11

package/android/src/main/java/com/apollohg/editor/EditorEditText.kt

@@ -38,9 +38,9 @@ import uniffi.editor_core.*  // UniFFI-generated bindings
  *
  * ## Composition Handling
  *
- * For CJK input methods, composing text is handled normally by the base
- * [InputConnection]. When composition finalizes, we capture the result and
- * route it through Rust.
+ * For CJK input methods, swipe keyboards, and some autocorrect flows, composing
+ * text is rendered transiently by the base [InputConnection]. The final commit
+ * is routed through Rust against the original authorized selection.
  *
  * ## Thread Safety
  *
@@ -190,6 +190,8 @@ class EditorEditText @JvmOverloads constructor(
     private var lastAppliedRenderAppearanceRevision: Long = 0L
     internal var onDeleteRangeInRustForTesting: ((Int, Int) -> Unit)? = null
     internal var onDeleteBackwardAtSelectionScalarInRustForTesting: ((Int, Int) -> Unit)? = null
+    internal var onInsertTextInRustForTesting: ((String, Int) -> Unit)? = null
+    internal var onReplaceTextInRustForTesting: ((Int, Int, String) -> Unit)? = null
 
     fun lastRenderAppliedPatch(): Boolean = lastRenderAppliedPatchForTesting
     fun lastApplyUpdateTrace(): ApplyUpdateTrace? = lastApplyUpdateTraceForTesting
@@ -549,6 +551,18 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
+    internal fun caretRect(): RectF? {
+        val textLayout = layout ?: return null
+        val selectionOffset = selectionEnd.takeIf { it >= 0 } ?: return null
+        val clampedOffset = selectionOffset.coerceIn(0, textLayout.text.length)
+        val line = textLayout.getLineForOffset(clampedOffset)
+        val caretLeft = textLayout.getPrimaryHorizontal(clampedOffset)
+        val left = totalPaddingLeft + caretLeft - scrollX
+        val top = totalPaddingTop + textLayout.getLineTop(line) - scrollY
+        val bottom = totalPaddingTop + textLayout.getLineBottom(line) - scrollY
+        return RectF(left, top.toFloat(), left + 1f, bottom.toFloat())
+    }
+
     // ── Input Handling: Text Commit ─────────────────────────────────────
 
     /**
@@ -583,16 +597,48 @@ class EditorEditText @JvmOverloads constructor(
             // Range selection: atomic replace via Rust.
             val scalarStart = PositionBridge.utf16ToScalar(start, currentText)
             val scalarEnd = PositionBridge.utf16ToScalar(end, currentText)
-            val updateJSON = editorReplaceTextScalar(
-                editorId.toULong(), scalarStart.toUInt(), scalarEnd.toUInt(), text
-            )
-            applyUpdateJSON(updateJSON)
+            replaceTextRangeInRust(scalarStart, scalarEnd, text)
         } else {
             val scalarPos = PositionBridge.utf16ToScalar(start, currentText)
             insertTextInRust(text, scalarPos)
         }
     }
 
+    internal fun runWithTransientInputMutationGuard(block: () -> Boolean): Boolean {
+        val wasApplyingRustState = isApplyingRustState
+        isApplyingRustState = true
+        return try {
+            block()
+        } finally {
+            isApplyingRustState = wasApplyingRustState
+        }
+    }
+
+    fun handleCompositionCommit(text: String, replacementStartUtf16: Int, replacementEndUtf16: Int) {
+        if (!isEditable) return
+        if (isApplyingRustState) return
+        if (editorId == 0L) return
+
+        if (text == "\n") {
+            handleReturnKey()
+            return
+        }
+
+        val authorizedText = lastAuthorizedText
+        val startUtf16 = minOf(replacementStartUtf16, replacementEndUtf16)
+            .coerceIn(0, authorizedText.length)
+        val endUtf16 = maxOf(replacementStartUtf16, replacementEndUtf16)
+            .coerceIn(0, authorizedText.length)
+        val scalarStart = PositionBridge.utf16ToScalar(startUtf16, authorizedText)
+        val scalarEnd = PositionBridge.utf16ToScalar(endUtf16, authorizedText)
+
+        if (scalarStart != scalarEnd) {
+            replaceTextRangeInRust(scalarStart, scalarEnd, text)
+        } else {
+            insertTextInRust(text, scalarStart)
+        }
+    }
+
     // ── Input Handling: Deletion ────────────────────────────────────────
 
     /**
@@ -699,35 +745,6 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
-    // ── Input Handling: Composition ─────────────────────────────────────
-
-    /**
-     * Handle finalization of IME composition (CJK input, swipe keyboard).
-     *
-     * Called by [EditorInputConnection.finishComposingText] after the base
-     * InputConnection has finalized the composing text.
-     */
-    /**
-     * Handle finalization of IME composition.
-     *
-     * @param composedText The finalized composed text captured from the InputConnection.
-     */
-    fun handleCompositionFinished(composedText: String?) {
-        if (!isEditable) return
-        if (isApplyingRustState) return
-        if (editorId == 0L) return
-        if (composedText.isNullOrEmpty()) return
-
-        // The cursor is at the end of the composed text. Calculate the insert
-        // position as cursor - composed_length (in scalar offsets).
-        val currentText = text?.toString() ?: ""
-        val cursorUtf16 = selectionStart
-        val cursorScalar = PositionBridge.utf16ToScalar(cursorUtf16, currentText)
-        val composedScalarLen = composedText.codePointCount(0, composedText.length)
-        val insertPos = if (cursorScalar >= composedScalarLen) cursorScalar - composedScalarLen else 0
-        insertTextInRust(composedText, insertPos)
-    }
-
     // ── Input Handling: Return Key ──────────────────────────────────────
 
     /**
@@ -1078,10 +1095,28 @@ class EditorEditText @JvmOverloads constructor(
      * Insert text at a scalar position via the Rust editor.
      */
     private fun insertTextInRust(text: String, atScalarPos: Int) {
+        onInsertTextInRustForTesting?.let { callback ->
+            callback(text, atScalarPos)
+            return
+        }
         val updateJSON = editorInsertTextScalar(editorId.toULong(), atScalarPos.toUInt(), text)
         applyUpdateJSON(updateJSON)
     }
 
+    private fun replaceTextRangeInRust(scalarFrom: Int, scalarTo: Int, text: String) {
+        onReplaceTextInRustForTesting?.let { callback ->
+            callback(scalarFrom, scalarTo, text)
+            return
+        }
+        val updateJSON = editorReplaceTextScalar(
+            editorId.toULong(),
+            scalarFrom.toUInt(),
+            scalarTo.toUInt(),
+            text
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     /**
      * Delete a scalar range via the Rust editor.
      *

package/android/src/main/java/com/apollohg/editor/EditorInputConnection.kt

@@ -1,6 +1,7 @@
 package com.apollohg.editor
 
 import android.view.KeyEvent
+import android.view.inputmethod.BaseInputConnection
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputConnectionWrapper
 
@@ -16,11 +17,11 @@ import android.view.inputmethod.InputConnectionWrapper
  *
  * ## Composition (IME) Handling
  *
- * For CJK input methods (and swipe keyboards), [setComposingText] and
- * [finishComposingText] are used. During composition, we let the base [InputConnection]
- * handle composing text normally so the user sees their in-progress input with the
- * composing underline. When composition finalizes ([finishComposingText]), we capture
- * the result and route it through Rust.
+ * For CJK input methods, swipe keyboards, and some autocorrect flows, [setComposingText],
+ * [commitText], and [finishComposingText] are used together. During composition, we let
+ * the base [InputConnection] render transient composing text, but keep the original
+ * Rust-authorized replacement range so the final committed text lands at the correct
+ * document position.
  *
  * ## Key Events
  *
@@ -70,6 +71,8 @@ class EditorInputConnection(
 
     /** Tracks the current composing text for CJK/swipe input. */
     private var composingText: String? = null
+    private var composingReplacementStartUtf16: Int? = null
+    private var composingReplacementEndUtf16: Int? = null
 
     /**
      * Called when the IME commits finalized text (single character, word,
@@ -82,7 +85,26 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.commitText(text, newCursorPosition)
         }
-        text?.toString()?.let { editorView.handleTextCommit(it) }
+        if (editorView.editorId == 0L) {
+            return super.commitText(text, newCursorPosition)
+        }
+
+        val committedText = text?.toString()
+        val replacementRange = trackedCompositionReplacementRange()
+        if (replacementRange != null && committedText != null) {
+            clearCompositionTracking()
+            editorView.runWithTransientInputMutationGuard {
+                super.finishComposingText()
+            }
+            editorView.handleCompositionCommit(
+                committedText,
+                replacementRange.first,
+                replacementRange.second
+            )
+        } else {
+            clearCompositionTracking()
+            committedText?.let { editorView.handleTextCommit(it) }
+        }
         return true
     }
 
@@ -99,6 +121,13 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.deleteSurroundingText(beforeLength, afterLength)
         }
+        if (trackedCompositionReplacementRange() != null) {
+            val result = editorView.runWithTransientInputMutationGuard {
+                super.deleteSurroundingText(beforeLength, afterLength)
+            }
+            refreshComposingTextFromEditable()
+            return result
+        }
         editorView.handleDelete(beforeLength, afterLength)
         return true
     }
@@ -108,6 +137,13 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.deleteSurroundingTextInCodePoints(beforeLength, afterLength)
         }
+        if (trackedCompositionReplacementRange() != null) {
+            val result = editorView.runWithTransientInputMutationGuard {
+                super.deleteSurroundingTextInCodePoints(beforeLength, afterLength)
+            }
+            refreshComposingTextFromEditable()
+            return result
+        }
 
         val currentText = editorView.text?.toString().orEmpty()
         val cursor = editorView.selectionStart.coerceAtLeast(0)
@@ -132,12 +168,27 @@ class EditorInputConnection(
      *
      * We let the base InputConnection handle this normally so the user sees
      * the composing text with its underline decoration. The text is NOT sent
-     * to Rust during composition — only when [finishComposingText] is called.
+     * to Rust during composition — only when the IME commits or finishes it.
      */
     override fun setComposingText(text: CharSequence?, newCursorPosition: Int): Boolean {
         if (!editorView.isEditable) return super.setComposingText(text, newCursorPosition)
+        if (editorView.editorId == 0L) return super.setComposingText(text, newCursorPosition)
+        captureCompositionReplacementRangeIfNeeded()
         composingText = text?.toString()
-        return super.setComposingText(text, newCursorPosition)
+        return editorView.runWithTransientInputMutationGuard {
+            super.setComposingText(text, newCursorPosition)
+        }
+    }
+
+    override fun setComposingRegion(start: Int, end: Int): Boolean {
+        if (!editorView.isEditable) return super.setComposingRegion(start, end)
+        if (editorView.editorId == 0L) return super.setComposingRegion(start, end)
+        val authorizedLength = editorView.text?.length ?: 0
+        composingReplacementStartUtf16 = minOf(start, end).coerceIn(0, authorizedLength)
+        composingReplacementEndUtf16 = maxOf(start, end).coerceIn(0, authorizedLength)
+        return editorView.runWithTransientInputMutationGuard {
+            super.setComposingRegion(start, end)
+        }
     }
 
     /**
@@ -149,22 +200,60 @@ class EditorInputConnection(
      */
     override fun finishComposingText(): Boolean {
         if (!editorView.isEditable) return super.finishComposingText()
+        if (editorView.editorId == 0L) return super.finishComposingText()
         val composed = composingText
-        composingText = null
+        val replacementRange = trackedCompositionReplacementRange()
+        clearCompositionTracking()
 
         // Prevent selection sync while the base connection commits the composed
         // text, since the Rust document doesn't have it yet.
-        editorView.isApplyingRustState = true
-        val result = super.finishComposingText()
-        editorView.isApplyingRustState = false
+        val result = editorView.runWithTransientInputMutationGuard {
+            super.finishComposingText()
+        }
 
         // Now route the composed text through Rust.
-        if (!editorView.isApplyingRustState) {
-            editorView.handleCompositionFinished(composed)
+        if (replacementRange != null && !composed.isNullOrEmpty()) {
+            editorView.handleCompositionCommit(
+                composed,
+                replacementRange.first,
+                replacementRange.second
+            )
         }
         return result
     }
 
+    private fun captureCompositionReplacementRangeIfNeeded() {
+        if (trackedCompositionReplacementRange() != null) return
+        val start = editorView.selectionStart.coerceAtLeast(0)
+        val end = editorView.selectionEnd.coerceAtLeast(0)
+        val authorizedLength = editorView.text?.length ?: 0
+        composingReplacementStartUtf16 = minOf(start, end).coerceIn(0, authorizedLength)
+        composingReplacementEndUtf16 = maxOf(start, end).coerceIn(0, authorizedLength)
+    }
+
+    private fun trackedCompositionReplacementRange(): Pair<Int, Int>? {
+        val start = composingReplacementStartUtf16 ?: return null
+        val end = composingReplacementEndUtf16 ?: return null
+        return start to end
+    }
+
+    private fun clearCompositionTracking() {
+        composingText = null
+        composingReplacementStartUtf16 = null
+        composingReplacementEndUtf16 = null
+    }
+
+    private fun refreshComposingTextFromEditable() {
+        val editable = editorView.text ?: return
+        val start = BaseInputConnection.getComposingSpanStart(editable)
+        val end = BaseInputConnection.getComposingSpanEnd(editable)
+        if (start < 0 || end < 0 || start > end || end > editable.length) {
+            composingText = null
+            return
+        }
+        composingText = editable.subSequence(start, end).toString()
+    }
+
     /**
      * Called for hardware keyboard key events.
      *

package/android/src/main/java/com/apollohg/editor/NativeEditorExpoView.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.Rect
 import android.graphics.RectF
+import android.os.SystemClock
 import android.view.Gravity
 import android.view.MotionEvent
 import android.view.View
@@ -61,7 +62,8 @@ class NativeEditorExpoView(
     private var lastEmittedContentHeight = 0
     private var outsideTapWindowCallback: Window.Callback? = null
     private var previousWindowCallback: Window.Callback? = null
-    private var toolbarFrameInWindow: RectF? = null
+    private var toolbarFramesInWindow: List<RectF> = emptyList()
+    private var lastToolbarTouchUptimeMs: Long? = null
     private var addons = NativeEditorAddons(null)
     private var mentionQueryState: MentionQueryState? = null
     private var lastMentionEventJson: String? = null
@@ -91,7 +93,7 @@ class NativeEditorExpoView(
         ViewCompat.setOnApplyWindowInsetsListener(keyboardToolbarView) { _, insets ->
             currentImeBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
             updateKeyboardToolbarLayout()
-            updateKeyboardToolbarVisibility()
+            updateAttachedKeyboardToolbarForInsets()
             insets
         }
 
@@ -101,6 +103,12 @@ class NativeEditorExpoView(
                 installOutsideTapBlurHandlerIfNeeded()
                 refreshMentionQuery()
             } else {
+                if (shouldPreserveFocusAfterToolbarTouch()) {
+                    richTextView.editorEditText.post {
+                        focus()
+                    }
+                    return@setOnFocusChangeListener
+                }
                 uninstallOutsideTapBlurHandler()
                 clearMentionQueryState()
             }
@@ -195,23 +203,52 @@ class NativeEditorExpoView(
         if (lastToolbarFrameJson == toolbarFrameJson) return
         lastToolbarFrameJson = toolbarFrameJson
         if (toolbarFrameJson.isNullOrBlank()) {
-            toolbarFrameInWindow = null
+            toolbarFramesInWindow = emptyList()
             return
         }
 
-        toolbarFrameInWindow = try {
+        toolbarFramesInWindow = try {
             val json = JSONObject(toolbarFrameJson)
-            RectF(
-                json.optDouble("x").toFloat(),
-                json.optDouble("y").toFloat(),
-                (json.optDouble("x") + json.optDouble("width")).toFloat(),
-                (json.optDouble("y") + json.optDouble("height")).toFloat()
-            )
+            val frames = json.optJSONArray("frames")
+            if (frames != null) {
+                buildList {
+                    for (index in 0 until frames.length()) {
+                        frames.optJSONObject(index)?.toToolbarFrame()?.let { add(it) }
+                    }
+                }
+            } else {
+                listOfNotNull(json.toToolbarFrame())
+            }
         } catch (_: Throwable) {
-            null
+            emptyList()
         }
     }
 
+    private fun JSONObject.toToolbarFrame(): RectF? {
+        val x = optDouble("x", Double.NaN)
+        val y = optDouble("y", Double.NaN)
+        val width = optDouble("width", Double.NaN)
+        val height = optDouble("height", Double.NaN)
+        if (
+            x.isNaN() || x.isInfinite() ||
+            y.isNaN() || y.isInfinite() ||
+            width.isNaN() || width.isInfinite() ||
+            height.isNaN() || height.isInfinite()
+        ) {
+            return null
+        }
+        if (width <= 0.0 || height <= 0.0) {
+            return null
+        }
+
+        return RectF(
+            x.toFloat(),
+            y.toFloat(),
+            (x + width).toFloat(),
+            (y + height).toFloat()
+        )
+    }
+
     fun setPendingEditorUpdateJson(editorUpdateJson: String?) {
         pendingEditorUpdateJson = editorUpdateJson
     }
@@ -230,14 +267,33 @@ class NativeEditorExpoView(
 
     fun focus() {
         richTextView.editorEditText.requestFocus()
+        richTextView.editorEditText.post {
+            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+            imm?.showSoftInput(richTextView.editorEditText, InputMethodManager.SHOW_IMPLICIT)
+        }
     }
 
     fun blur() {
+        clearRecentToolbarTouch()
         richTextView.editorEditText.clearFocus()
         val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
         imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
     }
 
+    fun getCaretRectJson(): String? {
+        if (width <= 0 || height <= 0) return null
+        val rect = richTextView.caretRect() ?: return null
+        val density = resources.displayMetrics.density
+        return JSONObject()
+            .put("x", rect.left / density)
+            .put("y", rect.top / density)
+            .put("width", rect.width() / density)
+            .put("height", rect.height() / density)
+            .put("editorWidth", width / density)
+            .put("editorHeight", height / density)
+            .toString()
+    }
+
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         uninstallOutsideTapBlurHandler()
@@ -404,24 +460,85 @@ class NativeEditorExpoView(
         if (isTouchInsideKeyboardToolbar(event)) {
             return false
         }
-        val toolbarFrame = toolbarFrameInWindow
-        if (toolbarFrame != null) {
-            // toolbarFrame is in DP (from React Native's measureInWindow),
-            // but rawX/rawY are in pixels — convert before comparing.
-            val density = resources.displayMetrics.density
-            val frameInPx = RectF(
+        if (isTouchInsideStandaloneToolbar(event)) {
+            markRecentToolbarTouch()
+            return false
+        }
+        val rect = Rect()
+        richTextView.editorEditText.getGlobalVisibleRect(rect)
+        return !rect.contains(event.rawX.toInt(), event.rawY.toInt())
+    }
+
+    private fun markRecentToolbarTouch() {
+        lastToolbarTouchUptimeMs = SystemClock.uptimeMillis()
+    }
+
+    private fun clearRecentToolbarTouch() {
+        lastToolbarTouchUptimeMs = null
+    }
+
+    private fun shouldPreserveFocusAfterToolbarTouch(): Boolean {
+        val lastToolbarTouch = lastToolbarTouchUptimeMs ?: return false
+        val elapsedMs = SystemClock.uptimeMillis() - lastToolbarTouch
+        return elapsedMs in 0L..TOOLBAR_FOCUS_PRESERVE_MS
+    }
+
+    internal fun markRecentToolbarTouchForTesting() {
+        markRecentToolbarTouch()
+    }
+
+    internal fun shouldPreserveFocusAfterToolbarTouchForTesting(): Boolean =
+        shouldPreserveFocusAfterToolbarTouch()
+
+    private fun isTouchInsideStandaloneToolbar(event: MotionEvent): Boolean {
+        val visibleWindowFrame = Rect()
+        getWindowVisibleDisplayFrame(visibleWindowFrame)
+        return isPointInsideStandaloneToolbar(event.rawX, event.rawY, visibleWindowFrame)
+    }
+
+    internal fun isPointInsideStandaloneToolbarForTesting(
+        rawX: Float,
+        rawY: Float,
+        visibleWindowFrame: Rect
+    ): Boolean = isPointInsideStandaloneToolbar(rawX, rawY, visibleWindowFrame)
+
+    private fun isPointInsideStandaloneToolbar(
+        rawX: Float,
+        rawY: Float,
+        visibleWindowFrame: Rect
+    ): Boolean {
+        if (toolbarFramesInWindow.isEmpty()) {
+            return false
+        }
+        // toolbarFrame is in DP from React Native's measureInWindow. On Android
+        // that is window-relative after visible-window insets are subtracted,
+        // while rawX/rawY are screen pixels. Fabric/newer implementations may
+        // differ here, so accept both window-relative and raw-screen comparisons.
+        val density = resources.displayMetrics.density
+        val hitSlopPx = TOOLBAR_HIT_SLOP_DP * density
+        val eventX = rawX - visibleWindowFrame.left
+        val eventY = rawY - visibleWindowFrame.top
+        for (toolbarFrame in toolbarFramesInWindow) {
+            val windowFrameInPx = RectF(
                 toolbarFrame.left * density,
                 toolbarFrame.top * density,
                 toolbarFrame.right * density,
                 toolbarFrame.bottom * density
-            )
-            if (frameInPx.contains(event.rawX, event.rawY)) {
-                return false
+            ).apply {
+                inset(-hitSlopPx, -hitSlopPx)
+            }
+            val screenFrameInPx = RectF(windowFrameInPx).apply {
+                offset(visibleWindowFrame.left.toFloat(), visibleWindowFrame.top.toFloat())
+            }
+            if (
+                windowFrameInPx.contains(rawX, rawY) ||
+                windowFrameInPx.contains(eventX, eventY) ||
+                screenFrameInPx.contains(rawX, rawY)
+            ) {
+                return true
             }
         }
-        val rect = Rect()
-        richTextView.editorEditText.getGlobalVisibleRect(rect)
-        return !rect.contains(event.rawX.toInt(), event.rawY.toInt())
+        return false
     }
 
     private fun isTouchInsideKeyboardToolbar(event: MotionEvent): Boolean {
@@ -433,6 +550,11 @@ class NativeEditorExpoView(
         return rect.contains(event.rawX.toInt(), event.rawY.toInt())
     }
 
+    private companion object {
+        private const val TOOLBAR_HIT_SLOP_DP = 8f
+        private const val TOOLBAR_FOCUS_PRESERVE_MS = 750L
+    }
+
     private fun resolveActivity(context: Context): Activity? {
         var current: Context? = context
         while (current is ContextWrapper) {
@@ -658,6 +780,11 @@ class NativeEditorExpoView(
         keyboardToolbarView.layoutParams = params
     }
 
+    private fun updateAttachedKeyboardToolbarForInsets() {
+        keyboardToolbarView.visibility = if (currentImeBottom > 0) View.VISIBLE else View.INVISIBLE
+        updateEditorViewportInset()
+    }
+
     private fun updateKeyboardToolbarVisibility() {
         val shouldAttach =
             showsToolbar &&

package/android/src/main/java/com/apollohg/editor/NativeEditorModule.kt

@@ -380,6 +380,10 @@ class NativeEditorModule : Module() {
                 view.blur()
             }
 
+            AsyncFunction("getCaretRect") { view: NativeEditorExpoView ->
+                view.getCaretRectJson()
+            }
+
             AsyncFunction("applyEditorUpdate") { view: NativeEditorExpoView, updateJson: String ->
                 view.applyEditorUpdate(updateJson)
             }

package/android/src/main/java/com/apollohg/editor/NativeToolbar.kt

@@ -11,6 +11,7 @@ import android.view.View
 import android.view.ViewOutlineProvider
 import android.widget.HorizontalScrollView
 import android.widget.LinearLayout
+import androidx.appcompat.R as AppCompatR
 import androidx.appcompat.widget.AppCompatButton
 import androidx.appcompat.widget.PopupMenu
 import androidx.appcompat.widget.AppCompatTextView
@@ -834,7 +835,7 @@ internal class EditorKeyboardToolbarView(context: Context) : HorizontalScrollVie
                     0.38f
                 )
                 active -> theme?.buttonActiveColor ?: resolveColorAttr(
-                    MaterialR.attr.colorPrimary,
+                    AppCompatR.attr.colorPrimary,
                     android.R.attr.textColorPrimary
                 )
                 else -> theme?.buttonColor ?: resolveColorAttr(

package/android/src/main/java/com/apollohg/editor/RichTextEditorView.kt

@@ -301,6 +301,16 @@ class RichTextEditorView @JvmOverloads constructor(
         )
     }
 
+    internal fun caretRect(): RectF? {
+        val rect = editorEditText.caretRect() ?: return null
+        return RectF(
+            editorViewport.left + editorScrollView.left + editorEditText.left + rect.left,
+            editorViewport.top + editorScrollView.top + editorEditText.top + rect.top - editorScrollView.scrollY,
+            editorViewport.left + editorScrollView.left + editorEditText.left + rect.right,
+            editorViewport.top + editorScrollView.top + editorEditText.top + rect.bottom - editorScrollView.scrollY
+        )
+    }
+
     internal fun maximumImageWidthPx(): Float {
         val availableWidth =
             maxOf(editorEditText.width, editorEditText.measuredWidth) -

package/dist/EditorToolbar.d.ts

@@ -91,6 +91,18 @@ export type EditorToolbarItem = EditorToolbarLeafItem | EditorToolbarGroupItem |
     type: 'separator';
     key?: string;
 };
+export interface EditorToolbarFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function isEditorToolbarFocusPreservationActive(): boolean;
+export declare function useEditorToolbarFrames(): readonly EditorToolbarFrame[];
+export declare function _setEditorToolbarFrameForTests(id: number, frame: EditorToolbarFrame | null): void;
+export declare function _resetEditorToolbarFrameRegistryForTests(): void;
+export declare function _beginEditorToolbarInteractionForTests(): void;
+export declare function _endEditorToolbarInteractionForTests(): void;
 export declare const DEFAULT_EDITOR_TOOLBAR_ITEMS: readonly EditorToolbarItem[];
 export interface EditorToolbarProps {
     /** Currently active marks and nodes from the Rust engine. */
@@ -145,5 +157,10 @@ export interface EditorToolbarProps {
     theme?: EditorToolbarTheme;
     /** Whether to render the built-in top separator line. */
     showTopBorder?: boolean;
+    /**
+     * Keep NativeRichTextEditor focused when this toolbar is rendered outside
+     * the editor wrapper. Defaults to true.
+     */
+    preserveEditorFocus?: boolean;
 }
-export declare function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic, onToggleUnderline, onToggleStrike, onToggleBulletList, onToggleHeading, onToggleBlockquote, onToggleOrderedList, onIndentList, onOutdentList, onInsertHorizontalRule, onInsertLineBreak, onUndo, onRedo, onToggleMark, onToggleListType, onInsertNodeType, onRunCommand, onToolbarAction, onRequestLink, onRequestImage, toolbarItems, theme, showTopBorder, }: EditorToolbarProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic, onToggleUnderline, onToggleStrike, onToggleBulletList, onToggleHeading, onToggleBlockquote, onToggleOrderedList, onIndentList, onOutdentList, onInsertHorizontalRule, onInsertLineBreak, onUndo, onRedo, onToggleMark, onToggleListType, onInsertNodeType, onRunCommand, onToolbarAction, onRequestLink, onRequestImage, toolbarItems, theme, showTopBorder, preserveEditorFocus, }: EditorToolbarProps): import("react/jsx-runtime").JSX.Element;