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

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
@@ -583,16 +585,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 +733,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 +1083,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/ios/EditorCore.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libeditor_core.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libeditor_core.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libeditor_core.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libeditor_core.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/RichTextEditorView.swift

@@ -704,7 +704,8 @@ private final class ImageResizeOverlayView: UIView {
 /// For CJK input methods, `setMarkedText` / `unmarkText` are used. During
 /// composition (marked text), we let UITextView handle it normally so the
 /// user sees their composing text. When composition finalizes (`unmarkText`),
-/// we capture the result and route it through Rust.
+/// we commit the final text through Rust at the original Rust-authorized
+/// replacement range.
 ///
 /// ## Thread Safety
 ///
@@ -970,9 +971,12 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     private var pendingDeferredImageSelectionRange: NSRange?
     private var pendingDeferredImageSelectionGeneration: UInt64 = 0
 
-    /// Stores the text that was composed during a marked text session,
-    /// captured when `unmarkText` is called.
-    private var composedText: String?
+    /// Stores the Rust-authorized scalar range replaced by the active marked
+    /// text session. UIKit mutates visible TextKit state during composition,
+    /// so final commits must not infer their range from the transient cursor.
+    private var markedTextReplacementScalarRange: (from: UInt32, to: UInt32)?
+    private var markedTextReplacementUtf16Range: NSRange?
+    private var markedTextCompositionText: String?
 
     private let editorLayoutManager: EditorLayoutManager
 
@@ -1580,6 +1584,13 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            let replacementRange = trackedMarkedTextReplacementRange()
+            finishTransientMarkedTextMutation()
+            commitMarkedText(text, replacementRange: replacementRange)
+            return
+        }
+
         // Handle Enter/Return as a block split operation.
         if text == "\n" {
             performInterceptedInput {
@@ -1664,6 +1675,15 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            performTransientTextMutation {
+                super.deleteBackward()
+            }
+            refreshMarkedTextCompositionText()
+            isComposing = markedTextRange != nil || markedTextReplacementScalarRange != nil
+            return
+        }
+
         guard let selectedRange = selectedTextRange else { return }
         Self.inputLog.debug(
             "[deleteBackward] selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
@@ -1858,6 +1878,13 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            let replacementRange = trackedMarkedTextReplacementRange()
+            finishTransientMarkedTextMutation()
+            commitMarkedText(text, replacementRange: replacementRange)
+            return
+        }
+
         let scalarRange = PositionBridge.textRangeToScalarRange(range, in: self)
         Self.inputLog.debug(
             "[replace] text=\(self.preview(text), privacy: .public) scalarRange=\(scalarRange.from)-\(scalarRange.to) selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
@@ -1884,46 +1911,178 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// decoration). The text is NOT sent to Rust during composition.
     override func setMarkedText(_ markedText: String?, selectedRange: NSRange) {
         ensureInternalTextViewDelegate()
-        isComposing = true
+        if markedText != nil {
+            captureMarkedTextReplacementRangeIfNeeded()
+        }
+        isComposing = markedText != nil || markedTextReplacementScalarRange != nil
         Self.inputLog.debug(
             "[setMarkedText] marked=\(self.preview(markedText ?? ""), privacy: .public) nsRange=\(selectedRange.location),\(selectedRange.length) selection=\(self.selectionSummary(), privacy: .public)"
         )
-        super.setMarkedText(markedText, selectedRange: selectedRange)
+        performTransientTextMutation {
+            super.setMarkedText(markedText, selectedRange: selectedRange)
+        }
+        if markedText == nil {
+            clearMarkedTextTracking()
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+        } else {
+            refreshMarkedTextCompositionText(fallback: markedText)
+        }
     }
 
     /// Called when composition is finalized (user selects a candidate or
     /// presses space/enter to commit).
     ///
-    /// At this point, the composed text is final. We capture it and send
-    /// it to Rust as a single insertion. `unmarkText` in UITextView will
-    /// replace the marked text with the final text in the text storage,
-    /// but we intercept at a higher level.
+    /// At this point, the composed text is final. We capture it and commit it
+    /// to Rust at the original replacement range captured before UIKit mutated
+    /// the transient text storage.
     override func unmarkText() {
         ensureInternalTextViewDelegate()
-        // Capture the finalized composed text before UIKit clears it.
-        composedText = markedTextRange.flatMap { text(in: $0) }
+        let composedText = currentMarkedTextForCommit()
+        let replacementRange = trackedMarkedTextReplacementRange()
 
-        // Prevent selection sync while UIKit commits the marked text, since
-        // the Rust document doesn't have the composed text yet.
-        isApplyingRustState = true
-        super.unmarkText()
-        isApplyingRustState = false
-        isComposing = false
+        finishTransientMarkedTextMutation()
 
-        // Now route the composed text through Rust. The cursor is at the end
-        // of the composed text, so the insert position is cursor - length.
-        if let composed = composedText, !composed.isEmpty, editorId != 0 {
-            let cursorPos = PositionBridge.cursorScalarOffset(in: self)
-            let composedScalars = UInt32(composed.unicodeScalars.count)
-            let insertPos = cursorPos >= composedScalars ? cursorPos - composedScalars : 0
+        if let composed = composedText, !composed.isEmpty {
             Self.inputLog.debug(
-                "[unmarkText] composed=\(self.preview(composed), privacy: .public) cursorPos=\(cursorPos) insertPos=\(insertPos) selection=\(self.selectionSummary(), privacy: .public)"
+                "[unmarkText] composed=\(self.preview(composed), privacy: .public) replacement=\(self.previewMarkedTextReplacementRange(replacementRange), privacy: .public) selection=\(self.selectionSummary(), privacy: .public)"
+            )
+            commitMarkedText(composed, replacementRange: replacementRange)
+        } else {
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+        }
+    }
+
+    private func captureMarkedTextReplacementRangeIfNeeded() {
+        guard markedTextReplacementScalarRange == nil else { return }
+
+        guard let selectedRange = selectedTextRange else {
+            let scalarPos = PositionBridge.cursorScalarOffset(in: self)
+            markedTextReplacementScalarRange = (from: scalarPos, to: scalarPos)
+            markedTextReplacementUtf16Range = NSRange(
+                location: Int(scalarPos),
+                length: 0
             )
+            return
+        }
+
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        let startUtf16 = offset(from: beginningOfDocument, to: selectedRange.start)
+        let endUtf16 = offset(from: beginningOfDocument, to: selectedRange.end)
+
+        markedTextReplacementScalarRange = (from: scalarRange.from, to: scalarRange.to)
+        markedTextReplacementUtf16Range = NSRange(
+            location: min(startUtf16, endUtf16),
+            length: abs(endUtf16 - startUtf16)
+        )
+    }
+
+    private func trackedMarkedTextReplacementRange() -> (from: UInt32, to: UInt32)? {
+        if let markedTextReplacementScalarRange {
+            return markedTextReplacementScalarRange
+        }
+        guard let selectedRange = selectedTextRange else { return nil }
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        return (from: scalarRange.from, to: scalarRange.to)
+    }
+
+    private func clearMarkedTextTracking() {
+        markedTextReplacementScalarRange = nil
+        markedTextReplacementUtf16Range = nil
+        markedTextCompositionText = nil
+        isComposing = false
+    }
+
+    private func finishTransientMarkedTextMutation() {
+        performTransientTextMutation {
+            super.unmarkText()
+        }
+        clearMarkedTextTracking()
+    }
+
+    private func performTransientTextMutation(_ action: () -> Void) {
+        let wasApplyingRustState = isApplyingRustState
+        isApplyingRustState = true
+        action()
+        isApplyingRustState = wasApplyingRustState
+    }
+
+    private func currentMarkedTextForCommit() -> String? {
+        markedTextRange.flatMap { text(in: $0) }
+            ?? markedTextCompositionText
+            ?? transientMarkedTextFromAuthorizedDiff()
+    }
+
+    private func refreshMarkedTextCompositionText(fallback: String? = nil) {
+        markedTextCompositionText = markedTextRange.flatMap { text(in: $0) }
+            ?? transientMarkedTextFromAuthorizedDiff()
+            ?? fallback
+    }
+
+    private func transientMarkedTextFromAuthorizedDiff() -> String? {
+        guard let replacementRange = markedTextReplacementUtf16Range else { return nil }
+
+        let currentText = textStorage.string as NSString
+        let authorizedText = lastAuthorizedText as NSString
+        let replacementEnd = replacementRange.location + replacementRange.length
+        guard replacementRange.location >= 0,
+              replacementEnd <= authorizedText.length
+        else {
+            return nil
+        }
+
+        let insertedLength = currentText.length - (authorizedText.length - replacementRange.length)
+        guard insertedLength >= 0,
+              replacementRange.location + insertedLength <= currentText.length
+        else {
+            return nil
+        }
+
+        return currentText.substring(
+            with: NSRange(location: replacementRange.location, length: insertedLength)
+        )
+    }
+
+    private func commitMarkedText(
+        _ text: String,
+        replacementRange: (from: UInt32, to: UInt32)?
+    ) {
+        guard editorId != 0 else { return }
+        guard let replacementRange else {
             performInterceptedInput {
-                insertTextInRust(composed, at: insertPos)
+                insertTextInRust(text, at: PositionBridge.cursorScalarOffset(in: self))
             }
+            return
         }
-        composedText = nil
+
+        performInterceptedInput {
+            if replacementRange.from == replacementRange.to {
+                insertTextInRust(text, at: replacementRange.from)
+            } else {
+                replaceTextRangeInRust(
+                    from: replacementRange.from,
+                    to: replacementRange.to,
+                    with: text
+                )
+            }
+        }
+    }
+
+    private func restoreAuthorizedTextAfterCancelledCompositionIfNeeded() {
+        guard editorId != 0 else { return }
+        guard textStorage.string != lastAuthorizedText else { return }
+
+        let stateJSON = editorGetCurrentState(id: editorId)
+        applyUpdateJSON(stateJSON)
+    }
+
+    private func previewMarkedTextReplacementRange(
+        _ range: (from: UInt32, to: UInt32)?
+    ) -> String {
+        guard let range else { return "none" }
+        let utf16 = markedTextReplacementUtf16Range
+            .map { "\($0.location)..<\($0.location + $0.length)" }
+            ?? "none"
+        return "scalar=\(range.from)..<\(range.to) utf16=\(utf16)"
     }
 
     // MARK: - Paste Handling
@@ -1993,7 +2152,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     func textViewDidChangeSelection(_ textView: UITextView) {
         guard textView === self else { return }
         ensureInternalTextViewDelegate()
-        guard !isApplyingRustState else { return }
+        guard !isApplyingRustState, !isComposing else { return }
         if normalizeSelectionForEmptyBlockAutocapitalizationIfNeeded() {
             return
         }
@@ -2174,7 +2333,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     }
 
     private func syncSelectionToRustAndNotifyDelegate() {
-        guard !isApplyingRustState, editorId != 0 else { return }
+        guard !isApplyingRustState, !isComposing, editorId != 0 else { return }
         guard let range = selectedTextRange else { return }
 
         let anchor = PositionBridge.textViewToScalar(range.start, in: self)
@@ -2768,6 +2927,19 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         applyUpdateJSON(updateJSON)
     }
 
+    private func replaceTextRangeInRust(from: UInt32, to: UInt32, with text: String) {
+        Self.inputLog.debug(
+            "[rust.replaceTextScalar] text=\(self.preview(text), privacy: .public) scalar=\(from)-\(to) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = editorReplaceTextScalar(
+            id: editorId,
+            scalarFrom: from,
+            scalarTo: to,
+            text: text
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     private func insertNodeInRust(_ nodeType: String) {
         guard let selection = currentScalarSelection() else { return }
         Self.inputLog.debug(
@@ -4205,7 +4377,7 @@ extension EditorTextView: NSTextStorageDelegate {
         guard editedMask.contains(.editedCharacters) else { return }
 
         // Skip if this change came from our own Rust apply path.
-        guard !isApplyingRustState, !isInterceptingInput else { return }
+        guard !isApplyingRustState, !isInterceptingInput, !isComposing else { return }
 
         // Skip if no editor is bound yet (nothing to reconcile against).
         guard editorId != 0 else { return }
@@ -4247,7 +4419,7 @@ extension EditorTextView: NSTextStorageDelegate {
             guard let self else { return }
             self.reconciliationWorkScheduled = false
 
-            guard !self.isApplyingRustState, !self.isInterceptingInput else { return }
+            guard !self.isApplyingRustState, !self.isInterceptingInput, !self.isComposing else { return }
             guard self.editorId != 0 else { return }
             guard self.textStorage.string != self.lastAuthorizedText else { return }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@apollohg/react-native-prose-editor",
-    "version": "0.5.9",
+    "version": "0.5.10",
     "description": "Native rich text editor with Rust core for React Native",
     "license": "Apache-2.0",
     "homepage": "https://github.com/apollohg/react-native-prose-editor",