@openeditor/react-native-prose-editor 0.0.8 → 0.0.10

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

@@ -408,7 +408,7 @@ private object NativeEditorOutsideTapDispatcher {
         private fun scheduleOutsideTapCandidate(view: NativeEditorExpoView, event: MotionEvent) {
             val editorRect = Rect()
             val editorRectOnDown = if (
-                view.richTextView.editorEditText.getGlobalVisibleRect(editorRect) &&
+                view.richTextView.getGlobalVisibleRect(editorRect) &&
                 !editorRect.isEmpty
             ) {
                 editorRect
@@ -466,7 +466,7 @@ private object NativeEditorOutsideTapDispatcher {
         ): Boolean {
             val editorRectOnDown = candidate.editorRectOnDown ?: return false
             val currentRect = Rect()
-            if (!view.richTextView.editorEditText.getGlobalVisibleRect(currentRect)) {
+            if (!view.richTextView.getGlobalVisibleRect(currentRect)) {
                 return true
             }
             val dx = currentRect.left - editorRectOnDown.left
@@ -582,7 +582,7 @@ private object NativeEditorOutsideTapDispatcher {
 class NativeEditorExpoView(
     context: Context,
     appContext: AppContext
-) : ExpoView(context, appContext), EditorEditText.EditorListener {
+) : ExpoView(context, appContext) {
 
     private enum class ToolbarPlacement {
         KEYBOARD,
@@ -725,7 +725,8 @@ class NativeEditorExpoView(
 
     init {
         addView(richTextView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
-        richTextView.editorEditText.editorListener = this
+        richTextView.onSelectionChange = ::onSelectionChanged
+        richTextView.onEditorUpdate = ::onEditorUpdate
         richTextView.onBeforeDetachedFromWindow = {
             prepareForDetachFromWindow()
         }
@@ -743,8 +744,7 @@ class NativeEditorExpoView(
             insets
         }
 
-        // Observe EditText focus changes.
-        richTextView.editorEditText.setOnFocusChangeListener { _, hasFocus ->
+        richTextView.onFocusChange = focusChange@{ hasFocus ->
             if (hasFocus) {
                 cancelPendingToolbarRefocus()
                 installOutsideTapBlurHandlerIfNeeded()
@@ -753,7 +753,7 @@ class NativeEditorExpoView(
             } else {
                 if (consumeToolbarFocusPreservationForBlur()) {
                     scheduleToolbarRefocus()
-                    return@setOnFocusChangeListener
+                    return@focusChange
                 }
                 uninstallOutsideTapBlurHandler()
                 clearMentionQueryState()
@@ -777,7 +777,7 @@ class NativeEditorExpoView(
         if (previousEditorId != id) {
             invalidateAutoGrowContentHeightEmission()
         }
-        if (previousEditorId == id && richTextView.editorEditText.editorId == id) {
+        if (previousEditorId == id) {
             if (id != 0L && isAttachedToNativeWindow) {
                 if (!NativeEditorViewRegistry.register(id, this)) {
                     handleEditorDestroyed(id)
@@ -918,7 +918,7 @@ class NativeEditorExpoView(
         clearPendingNativeActionRetry()
         lastAddonsJson = addonsJson
         addons = NativeEditorAddons.fromJson(addonsJson)
-        keyboardToolbarView.applyMentionTheme(richTextView.editorEditText.theme?.mentions ?: addons.mentions?.theme)
+        keyboardToolbarView.applyMentionTheme(richTextView.editorTheme?.mentions ?: addons.mentions?.theme)
         refreshMentionQuery()
     }
 
@@ -942,19 +942,19 @@ class NativeEditorExpoView(
     }
 
     fun setAutoCapitalize(autoCapitalize: String?) {
-        richTextView.editorEditText.setAutoCapitalize(autoCapitalize)
+        richTextView.setAutoCapitalize(autoCapitalize)
     }
 
     fun setAutoCorrect(autoCorrect: Boolean?) {
-        richTextView.editorEditText.setAutoCorrect(autoCorrect)
+        richTextView.setAutoCorrect(autoCorrect)
     }
 
     fun setKeyboardType(keyboardType: String?) {
-        richTextView.editorEditText.setKeyboardType(keyboardType)
+        richTextView.setKeyboardType(keyboardType)
     }
 
     fun setEditable(editable: Boolean) {
-        if (richTextView.editorEditText.isEditable == editable) return
+        if (richTextView.editorIsEditable == editable) return
         if (!editable) {
             cancelPendingToolbarRefocus()
             clearPendingNativeActionRetry()
@@ -1117,7 +1117,7 @@ class NativeEditorExpoView(
         if (hasPendingEditorResetUpdateForCurrentEditor()) return
         if (hasPendingEditorUpdateForCurrentEditor()) return
         if (!isAttachedToNativeWindow) return
-        if (richTextView.editorEditText.editorId != richTextView.editorId) return
+        if (richTextView.editorId == 0L) return
         refreshToolbarStateFromEditorSelection()
         refreshMentionQuery()
         emitEditorReadyIfNeeded()
@@ -1259,10 +1259,9 @@ class NativeEditorExpoView(
             pastFastRetryBudget &&
             !pendingEditorUpdateForcedRecoveryAttempted &&
             richTextView.editorId != 0L &&
-            richTextView.editorEditText.editorId == richTextView.editorId
+            richTextView.editorId != 0L
         ) {
             pendingEditorUpdateForcedRecoveryAttempted = true
-            richTextView.editorEditText.discardTransientNativeInputForExternalRecovery()
         }
         if (!pastFastRetryBudget) {
             pendingEditorUpdateRetryAttempts += 1
@@ -1313,7 +1312,7 @@ class NativeEditorExpoView(
         }
         if (
             blockThemePreflightForTesting ||
-            !richTextView.editorEditText.prepareForExternalEditorUpdate()
+            richTextView.hasActiveComposition()
         ) {
             schedulePendingThemeRetry()
             return
@@ -1444,7 +1443,7 @@ class NativeEditorExpoView(
     }
 
     private fun currentNativeActionScope(action: PendingNativeAction): PendingNativeActionScope {
-        val selection = richTextView.editorEditText.currentScalarSelection()
+        val selection = richTextView.currentScalarSelection()
         val mentionScope = when (action) {
             is PendingNativeAction.MentionSuggestionSelect ->
                 mentionQueryState ?: addons.mentions?.let { currentMentionQueryState(it.trigger) }
@@ -1477,7 +1476,7 @@ class NativeEditorExpoView(
         ) {
             return false
         }
-        val selection = richTextView.editorEditText.currentScalarSelection()
+        val selection = richTextView.currentScalarSelection()
         if (scope.selectionAnchor != selection?.first || scope.selectionHead != selection?.second) {
             return false
         }
@@ -1505,7 +1504,7 @@ class NativeEditorExpoView(
     }
 
     private fun isEditorEffectivelyFocusedForNativeAction(): Boolean =
-        richTextView.editorEditText.hasFocus() ||
+        richTextView.isEditorFocused ||
             (pendingToolbarRefocus != null && pendingToolbarRefocusEditorId == richTextView.editorId)
 
     private fun clearPendingNativeActionRetryIfScopeChanged() {
@@ -1636,11 +1635,10 @@ class NativeEditorExpoView(
         }
         cancelPendingKeyboardDismiss()
         cancelPendingBlurRetry()
-        richTextView.editorEditText.requestFocus()
-        richTextView.editorEditText.post {
+        richTextView.focusEditor()
+        richTextView.post {
             if (!canFocusCurrentEditor()) return@post
-            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-            imm?.showSoftInput(richTextView.editorEditText, InputMethodManager.SHOW_IMPLICIT)
+            richTextView.focusEditor()
         }
     }
 
@@ -1654,13 +1652,12 @@ class NativeEditorExpoView(
 
     private fun performBlur(deferKeyboardDismiss: Boolean, allowRetry: Boolean) {
         if (handleDestroyedCurrentEditorIfNeeded()) return
-        if (!richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+        if (richTextView.hasActiveComposition()) {
             if (allowRetry && pendingBlurRetryAttempts < MAX_PENDING_UPDATE_RETRY_ATTEMPTS) {
                 schedulePendingBlurRetry(deferKeyboardDismiss)
                 return
             }
             if (handleDestroyedCurrentEditorIfNeeded()) return
-            richTextView.editorEditText.restoreAuthorizedTextIfNeeded()
         }
         completeBlur(deferKeyboardDismiss)
     }
@@ -1668,24 +1665,24 @@ class NativeEditorExpoView(
     private fun completeBlur(deferKeyboardDismiss: Boolean) {
         cancelPendingBlurRetry()
         traceOutsideTap(
-            "complete blur deferKeyboardDismiss=$deferKeyboardDismiss focusedBefore=${richTextView.editorEditText.hasFocus()}"
+            "complete blur deferKeyboardDismiss=$deferKeyboardDismiss focusedBefore=${richTextView.isEditorFocused}"
         )
-        richTextView.editorEditText.clearFocus()
-        traceOutsideTap("complete blur focusedAfter=${richTextView.editorEditText.hasFocus()}")
+        richTextView.blurEditor()
+        traceOutsideTap("complete blur focusedAfter=${richTextView.isEditorFocused}")
         if (deferKeyboardDismiss) {
             val dismiss = Runnable {
                 pendingKeyboardDismiss = null
-                if (!richTextView.editorEditText.hasFocus()) {
+                if (!richTextView.isEditorFocused) {
                     val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-                    imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
+                    imm?.hideSoftInputFromWindow(richTextView.windowToken, 0)
                 }
             }
             pendingKeyboardDismiss = dismiss
-            richTextView.editorEditText.post(dismiss)
+            richTextView.post(dismiss)
             return
         }
         val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-        imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
+        imm?.hideSoftInputFromWindow(richTextView.windowToken, 0)
     }
 
     private fun schedulePendingBlurRetry(deferKeyboardDismiss: Boolean) {
@@ -1734,12 +1731,12 @@ class NativeEditorExpoView(
             focusInternal(cancelPendingOutsideTapBlur = false)
         }
         pendingToolbarRefocus = refocus
-        richTextView.editorEditText.post(refocus)
+        richTextView.post(refocus)
     }
 
     private fun cancelPendingToolbarRefocus() {
         pendingToolbarRefocus?.let {
-            richTextView.editorEditText.removeCallbacks(it)
+            richTextView.removeCallbacks(it)
             pendingToolbarRefocus = null
         }
         pendingToolbarRefocusEditorId = null
@@ -1748,29 +1745,29 @@ class NativeEditorExpoView(
 
     private fun scheduleOutsideTapBlur() {
         cancelPendingOutsideTapBlur()
-        traceOutsideTap("schedule outside blur focused=${richTextView.editorEditText.hasFocus()}")
+        traceOutsideTap("schedule outside blur focused=${richTextView.isEditorFocused}")
         val blur = Runnable {
             pendingOutsideTapBlur = null
-            traceOutsideTap("run outside blur focused=${richTextView.editorEditText.hasFocus()}")
-            if (richTextView.editorEditText.hasFocus()) {
+            traceOutsideTap("run outside blur focused=${richTextView.isEditorFocused}")
+            if (richTextView.isEditorFocused) {
                 blurWithDeferredKeyboardDismiss()
             }
         }
         pendingOutsideTapBlur = blur
-        richTextView.editorEditText.postDelayed(blur, OUTSIDE_TAP_BLUR_DELAY_MS)
+        richTextView.postDelayed(blur, OUTSIDE_TAP_BLUR_DELAY_MS)
     }
 
     private fun cancelPendingOutsideTapBlur() {
         pendingOutsideTapBlur?.let {
             traceOutsideTap("cancel outside blur")
-            richTextView.editorEditText.removeCallbacks(it)
+            richTextView.removeCallbacks(it)
             pendingOutsideTapBlur = null
         }
     }
 
     private fun cancelPendingKeyboardDismiss() {
         pendingKeyboardDismiss?.let {
-            richTextView.editorEditText.removeCallbacks(it)
+            richTextView.removeCallbacks(it)
             pendingKeyboardDismiss = null
         }
     }
@@ -1805,7 +1802,7 @@ class NativeEditorExpoView(
     }
 
     internal fun handleEditorDestroyed(editorId: Long) {
-        if (richTextView.editorId != editorId && richTextView.editorEditText.editorId != editorId) {
+        if (richTextView.editorId != editorId) {
             return
         }
         cancelPendingEditorUpdateRetry()
@@ -1822,12 +1819,9 @@ class NativeEditorExpoView(
         uninstallOutsideTapBlurHandler()
         detachKeyboardToolbarIfNeeded()
         richTextView.setViewportBottomInsetPx(0)
-        val editText = richTextView.editorEditText
-        if (editText.hasFocus()) {
-            editText.clearFocus()
-        }
+        richTextView.blurEditor()
         val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-        imm?.hideSoftInputFromWindow(editText.windowToken, 0)
+        imm?.hideSoftInputFromWindow(richTextView.windowToken, 0)
         clearMentionQueryState(resetLastEvent = true)
         pendingEditorUpdateJson = null
         pendingEditorUpdateEditorId = null
@@ -1849,7 +1843,7 @@ class NativeEditorExpoView(
 
     private fun handleDestroyedCurrentEditorIfNeeded(): Boolean {
         val editorId = richTextView.editorId.takeIf { it != 0L }
-            ?: richTextView.editorEditText.editorId.takeIf { it != 0L }
+            ?: richTextView.editorId.takeIf { it != 0L }
             ?: return false
         if (!NativeEditorViewRegistry.isDestroyed(editorId)) return false
         handleEditorDestroyed(editorId)
@@ -1888,7 +1882,7 @@ class NativeEditorExpoView(
         val editorId = richTextView.editorId
         if (editorId == 0L) return false
         if (!isAttachedToNativeWindow) return false
-        if (richTextView.editorEditText.editorId != editorId) return false
+        if (richTextView.editorId != editorId) return false
         if (hasPendingEditorResetUpdateForCurrentEditor()) return false
         if (hasPendingEditorUpdateForCurrentEditor()) return false
         lastReadyEditorId = editorId
@@ -1913,8 +1907,8 @@ class NativeEditorExpoView(
     private fun prepareForDetachFromWindow() {
         if (handleDestroyedCurrentEditorIfNeeded()) return
         val editorId = richTextView.editorId
-        if (editorId == 0L || richTextView.editorEditText.editorId == 0L) return
-        if (richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+        if (editorId == 0L) return
+        if (!richTextView.hasActiveComposition()) {
             cancelPendingDetachPreflightRetry()
             richTextView.clearDeferredEditorUnbind()
             return
@@ -1927,7 +1921,6 @@ class NativeEditorExpoView(
         if (pendingDetachPreflightRetryScheduled) return
         if (pendingDetachPreflightRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS) {
             if (handleDestroyedCurrentEditorIfNeeded()) return
-            richTextView.editorEditText.restoreAuthorizedTextIfNeeded()
             cancelPendingDetachPreflightRetry()
             richTextView.unbindEditorForDetachedViewIfNeeded()
             return
@@ -1946,7 +1939,7 @@ class NativeEditorExpoView(
                 return@postDelayed
             }
             if (handleDestroyedCurrentEditorIfNeeded()) return@postDelayed
-            if (richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+            if (!richTextView.hasActiveComposition()) {
                 cancelPendingDetachPreflightRetry()
                 richTextView.unbindEditorForDetachedViewIfNeeded()
                 return@postDelayed
@@ -2015,49 +2008,7 @@ class NativeEditorExpoView(
 
     private fun emitContentHeightIfNeeded(force: Boolean) {
         if (heightBehavior != EditorHeightBehavior.AUTO_GROW) return
-        val editText = richTextView.editorEditText
-        val resolvedEditHeight = editText.resolveAutoGrowHeight()
-        val resolvedContainerHeight =
-            resolvedEditHeight +
-                richTextView.paddingTop +
-                richTextView.paddingBottom +
-                paddingTop +
-                paddingBottom
-        val contentHeight = (
-            when {
-                editText.isLaidOut && (editText.layout?.height ?: 0) > 0 -> {
-                    maxOf(
-                        (editText.layout?.height ?: 0) +
-                            editText.compoundPaddingTop +
-                            editText.compoundPaddingBottom +
-                            richTextView.paddingTop +
-                            richTextView.paddingBottom +
-                            paddingTop +
-                            paddingBottom,
-                        resolvedContainerHeight
-                    )
-                }
-                richTextView.measuredHeight > 0 -> {
-                    maxOf(
-                        richTextView.measuredHeight + paddingTop + paddingBottom,
-                        resolvedContainerHeight
-                    )
-                }
-                editText.measuredHeight > 0 -> {
-                    maxOf(
-                        editText.measuredHeight +
-                            richTextView.paddingTop +
-                            richTextView.paddingBottom +
-                            paddingTop +
-                            paddingBottom,
-                        resolvedContainerHeight
-                    )
-                }
-                else -> {
-                    resolvedContainerHeight
-                }
-            }
-        ).coerceAtLeast(0)
+        val contentHeight = (richTextView.measuredHeight + paddingTop + paddingBottom).coerceAtLeast(0)
         if (contentHeight <= 0) return
         val editorId = richTextView.editorId
         if (
@@ -2103,10 +2054,7 @@ class NativeEditorExpoView(
         clearPendingViewCommandUpdateRetry()
         isApplyingJSUpdate = true
         val applied = try {
-            richTextView.editorEditText.applyUpdateJSON(
-                updateJson,
-                refreshInputConnectionForExternalUpdate = true
-            )
+            richTextView.applyEditorUpdate(updateJson)
             clearPendingEditorUpdateDispatchQueue("jsResetUpdate")
             true
         } catch (error: Throwable) {
@@ -2123,7 +2071,7 @@ class NativeEditorExpoView(
 
     private fun isEditorReadyForNativeUpdate(): Boolean {
         val editorId = richTextView.editorId
-        return editorId == 0L || (isAttachedToNativeWindow && richTextView.editorEditText.editorId == editorId)
+        return editorId == 0L || (isAttachedToNativeWindow && richTextView.editorId == editorId)
     }
 
     private fun applyEditorUpdate(
@@ -2156,7 +2104,7 @@ class NativeEditorExpoView(
         }
         if (
             blockEditorUpdatePreflightForTesting ||
-            !richTextView.editorEditText.prepareForExternalEditorUpdate()
+            richTextView.hasActiveComposition()
         ) {
             if (scheduleViewCommandRetry) {
                 scheduleViewCommandUpdateRetry(updateJson)
@@ -2165,10 +2113,7 @@ class NativeEditorExpoView(
         }
         isApplyingJSUpdate = true
         return try {
-            richTextView.editorEditText.applyUpdateJSON(
-                updateJson,
-                refreshInputConnectionForExternalUpdate = true
-            )
+            richTextView.applyEditorUpdate(updateJson)
             clearPendingEditorUpdateDispatchQueue("jsUpdate")
             true
         } catch (error: Throwable) {
@@ -2201,7 +2146,7 @@ class NativeEditorExpoView(
                 blockedReason = "detached"
             )
         }
-        if (richTextView.editorId != 0L && richTextView.editorEditText.editorId != richTextView.editorId) {
+        if (richTextView.editorId == 0L) {
             return NativeEditorViewRegistry.commandPreparationJSON(
                 ready = false,
                 blockedReason = "detached"
@@ -2213,18 +2158,17 @@ class NativeEditorExpoView(
         isApplyingJSUpdate = true
         return try {
             onBeforePrepareForEditorCommandForTesting?.invoke()
-            val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
             NativeEditorViewRegistry.commandPreparationJSON(
-                ready = preparation.ready,
-                updateJSON = preparation.updateJSON,
-                blockedReason = if (preparation.ready) null else "composition"
+                ready = !richTextView.hasActiveComposition(),
+                updateJSON = editorGetSelectionState(richTextView.editorId.toULong()),
+                blockedReason = if (richTextView.hasActiveComposition()) "composition" else null
             )
         } finally {
             isApplyingJSUpdate = false
         }
     }
 
-    override fun onSelectionChanged(anchor: Int, head: Int) {
+    private fun onSelectionChanged(anchor: Int, head: Int) {
         val stateJson = refreshToolbarStateFromEditorSelection()
         refreshMentionQuery()
         clearPendingNativeActionRetryIfScopeChanged()
@@ -2244,7 +2188,7 @@ class NativeEditorExpoView(
         onSelectionChangeForTesting?.invoke(event) ?: onSelectionChange(event)
     }
 
-    override fun onEditorUpdate(updateJSON: String) {
+    private fun onEditorUpdate(updateJSON: String) {
         if (isApplyingJSUpdate) {
             dispatchEditorUpdate(
                 PendingEditorUpdateEvent(
@@ -2261,10 +2205,6 @@ class NativeEditorExpoView(
                 updateJSON = updateJSON
             )
         )
-        richTextView.editorEditText.recordImeTraceForTesting(
-            "nativeViewEditorUpdateQueued",
-            "queue=${pendingEditorUpdateEvents.size} jsonLength=${updateJSON.length}"
-        )
         schedulePendingEditorUpdateDispatch()
     }
 
@@ -2288,19 +2228,11 @@ class NativeEditorExpoView(
         while (pendingEditorUpdateEvents.isNotEmpty()) {
             val event = pendingEditorUpdateEvents.removeFirst()
             if (event.editorId != richTextView.editorId) {
-                richTextView.editorEditText.recordImeTraceForTesting(
-                    "nativeViewEditorUpdateSkipped",
-                    "reason=staleEditor queuedEditor=${event.editorId} currentEditor=${richTextView.editorId}"
-                )
                 continue
             }
             dispatchEditorUpdate(event, emitToJS = true)
             drainedCount += 1
         }
-        richTextView.editorEditText.recordImeTraceForTesting(
-            "nativeViewEditorUpdateDrained",
-            "count=$drainedCount totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
-        )
     }
 
     private fun clearPendingEditorUpdateDispatchQueue(reason: String) {
@@ -2309,10 +2241,6 @@ class NativeEditorExpoView(
         pendingEditorUpdateEvents.clear()
         pendingEditorUpdateDispatchScheduled = false
         pendingEditorUpdateDispatchGeneration += 1
-        richTextView.editorEditText.recordImeTraceForTesting(
-            "nativeViewEditorUpdateQueueCleared",
-            "reason=$reason count=$clearedCount"
-        )
     }
 
     private fun dispatchEditorUpdate(event: PendingEditorUpdateEvent, emitToJS: Boolean) {
@@ -2348,11 +2276,6 @@ class NativeEditorExpoView(
             )
             onEditorUpdateForTesting?.invoke(payload) ?: onEditorUpdate(payload)
         }
-        val totalNanos = System.nanoTime() - startedAt
-        richTextView.editorEditText.recordImeTraceForTesting(
-            "nativeViewEditorUpdateDispatch",
-            "emitToJS=$emitToJS jsonLength=${updateJSON.length} noteUs=${nanosToMicros(noteNanos)} toolbarUs=${nanosToMicros(toolbarNanos)} mentionUs=${nanosToMicros(mentionNanos)} retryUs=${nanosToMicros(retryNanos)} emitUs=${nanosToMicros(System.nanoTime() - emitStartedAt)} totalUs=${nanosToMicros(totalNanos)}"
-        )
     }
 
     private fun installOutsideTapBlurHandlerIfNeeded() {
@@ -2371,17 +2294,17 @@ class NativeEditorExpoView(
         cancelPendingOutsideTapBlurHandlerInstallRetry()
         val retry = Runnable {
             pendingOutsideTapHandlerInstallRetry = null
-            if (richTextView.editorEditText.hasFocus()) {
+            if (richTextView.isEditorFocused) {
                 installOutsideTapBlurHandlerIfNeeded()
             }
         }
         pendingOutsideTapHandlerInstallRetry = retry
-        richTextView.editorEditText.postDelayed(retry, OUTSIDE_TAP_HANDLER_INSTALL_RETRY_DELAY_MS)
+        richTextView.postDelayed(retry, OUTSIDE_TAP_HANDLER_INSTALL_RETRY_DELAY_MS)
     }
 
     private fun cancelPendingOutsideTapBlurHandlerInstallRetry() {
         pendingOutsideTapHandlerInstallRetry?.let {
-            richTextView.editorEditText.removeCallbacks(it)
+            richTextView.removeCallbacks(it)
             pendingOutsideTapHandlerInstallRetry = null
         }
     }
@@ -2420,7 +2343,7 @@ class NativeEditorExpoView(
         traceOutsideTap("handle decision=$decision")
         when (decision) {
             NativeEditorOutsideTapDecision.IGNORE -> {
-                if (!richTextView.editorEditText.hasFocus()) {
+                if (!richTextView.isEditorFocused) {
                     cancelPendingOutsideTapBlur()
                 }
             }
@@ -2442,7 +2365,7 @@ class NativeEditorExpoView(
     }
 
     private fun isEditorFocusedForOutsideTapDecision(): Boolean =
-        editorFocusedForOutsideTapOverrideForTesting ?: richTextView.editorEditText.hasFocus()
+        editorFocusedForOutsideTapOverrideForTesting ?: richTextView.isEditorFocused
 
     private fun isTouchOutsideEditor(event: MotionEvent): Boolean {
         if (isTouchInsideKeyboardToolbar(event)) {
@@ -2454,7 +2377,7 @@ class NativeEditorExpoView(
             return false
         }
         val rect = Rect()
-        richTextView.editorEditText.getGlobalVisibleRect(rect)
+        richTextView.getGlobalVisibleRect(rect)
         val isOutside = !rect.contains(event.rawX.toInt(), event.rawY.toInt())
         if (isOutside) {
             clearRecentToolbarTouch()
@@ -2712,7 +2635,7 @@ class NativeEditorExpoView(
 
     private fun refreshMentionQuery() {
         val mentions = addons.mentions
-        if (mentions == null || !richTextView.editorEditText.hasFocus()) {
+        if (mentions == null || !richTextView.isEditorFocused) {
             clearMentionQueryState()
             emitMentionQueryChange("", "@", 0, 0, false)
             return
@@ -2727,7 +2650,7 @@ class NativeEditorExpoView(
 
         mentionQueryState = queryState
         val suggestions = filteredMentionSuggestions(queryState, mentions)
-        keyboardToolbarView.applyMentionTheme(richTextView.editorEditText.theme?.mentions ?: mentions.theme)
+        keyboardToolbarView.applyMentionTheme(richTextView.editorTheme?.mentions ?: mentions.theme)
         syncKeyboardToolbarMentionSuggestions(suggestions)
         emitMentionQueryChange(
             queryState.query,
@@ -2748,21 +2671,29 @@ class NativeEditorExpoView(
     }
 
     private fun currentMentionQueryState(trigger: String): MentionQueryState? {
-        val editor = richTextView.editorEditText
+        val editor = richTextView.activeEditText ?: return null
         if (editor.selectionStart != editor.selectionEnd) return null
         val text = editor.text?.toString() ?: return null
         val cursorUtf16 = editor.selectionStart
         val cursorScalar = PositionBridge.utf16ToScalar(cursorUtf16, text)
-        return resolveMentionQueryState(
+        val local = resolveMentionQueryState(
             text = text,
             cursorScalar = cursorScalar,
             trigger = trigger,
             isCaretInsideMention = isCaretInsideMention(cursorUtf16)
+        ) ?: return null
+        val anchorUtf16 = PositionBridge.scalarToUtf16(local.anchor, text)
+        val headUtf16 = PositionBridge.scalarToUtf16(local.head, text)
+        val anchorDoc = richTextView.activeDocPositionForUtf16Offset(anchorUtf16) ?: return null
+        val headDoc = richTextView.activeDocPositionForUtf16Offset(headUtf16) ?: return null
+        return local.copy(
+            anchor = editorDocToScalar(richTextView.editorId.toULong(), anchorDoc.toUInt()).toInt(),
+            head = editorDocToScalar(richTextView.editorId.toULong(), headDoc.toUInt()).toInt()
         )
     }
 
     private fun isCaretInsideMention(cursorUtf16: Int): Boolean {
-        val editable = richTextView.editorEditText.text ?: return false
+        val editable = richTextView.activeEditText?.text ?: return false
         val checkOffsets = listOf(cursorUtf16, (cursorUtf16 - 1).coerceAtLeast(0))
         return checkOffsets.any { offset ->
             editable.getSpans(offset, offset, android.text.Annotation::class.java).any { span ->
@@ -2873,7 +2804,7 @@ class NativeEditorExpoView(
         allowPreflightRetry: Boolean = true
     ) {
         if (handleDestroyedCurrentEditorIfNeeded()) return
-        if (!richTextView.editorEditText.isEditable) {
+        if (!richTextView.editorIsEditable) {
             clearPendingNativeActionRetry()
             return
         }
@@ -2886,8 +2817,7 @@ class NativeEditorExpoView(
             }
             return
         }
-        val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
-        if (!preparation.ready) {
+        if (richTextView.hasActiveComposition()) {
             if (allowPreflightRetry) {
                 schedulePendingNativeActionRetry(
                     PendingNativeAction.MentionSuggestionSelect(suggestion)
@@ -2895,7 +2825,7 @@ class NativeEditorExpoView(
             }
             return
         }
-        val preflightUpdateJSON = preparation.updateJSON
+        val preflightUpdateJSON = editorGetSelectionState(richTextView.editorId.toULong())
         noteDocumentVersionFromUpdateJSON(preflightUpdateJSON)
         clearPendingNativeActionRetry()
         val queryState = currentMentionQueryState(mentions.trigger) ?: run {
@@ -2932,7 +2862,8 @@ class NativeEditorExpoView(
             queryState.head.toUInt(),
             docJson.toString()
         )
-        richTextView.editorEditText.applyUpdateJSON(updateJson)
+        richTextView.applyEditorUpdate(updateJson)
+        onEditorUpdate(updateJson)
         emitMentionSelect(mentions.trigger, suggestion, attrs)
         lastMentionEventJson = null
         clearMentionQueryState()
@@ -2989,7 +2920,7 @@ class NativeEditorExpoView(
 
     private fun updateKeyboardToolbarLayout() {
         val params = keyboardToolbarView.layoutParams as? FrameLayout.LayoutParams ?: return
-        val toolbarTheme = richTextView.editorEditText.theme?.toolbar
+        val toolbarTheme = richTextView.editorTheme?.toolbar
         val density = resources.displayMetrics.density
         params.gravity = Gravity.BOTTOM or Gravity.START
         val horizontalInsetPx = ((toolbarTheme?.resolvedHorizontalInset() ?: 0f) * density).toInt()
@@ -3013,8 +2944,8 @@ class NativeEditorExpoView(
             showsToolbar &&
                 canFocusCurrentEditor() &&
                 toolbarPlacement == ToolbarPlacement.KEYBOARD &&
-                richTextView.editorEditText.isEditable &&
-                richTextView.editorEditText.hasFocus()
+                richTextView.editorIsEditable &&
+                richTextView.isEditorFocused
 
         if (!shouldAttach) {
             keyboardToolbarView.visibility = View.GONE
@@ -3033,8 +2964,8 @@ class NativeEditorExpoView(
             heightBehavior == EditorHeightBehavior.FIXED &&
                 showsToolbar &&
                 toolbarPlacement == ToolbarPlacement.KEYBOARD &&
-                richTextView.editorEditText.isEditable &&
-                richTextView.editorEditText.hasFocus() &&
+                richTextView.editorIsEditable &&
+                richTextView.isEditorFocused &&
                 currentImeBottom > 0
 
         if (!shouldReserveToolbarSpace) {
@@ -3044,7 +2975,7 @@ class NativeEditorExpoView(
 
         val hostWidth = (resolveActivity(context)?.findViewById<ViewGroup>(android.R.id.content)?.width ?: width)
             .coerceAtLeast(0)
-        val toolbarTheme = richTextView.editorEditText.theme?.toolbar
+        val toolbarTheme = richTextView.editorTheme?.toolbar
         val density = resources.displayMetrics.density
         val horizontalInsetPx = ((toolbarTheme?.resolvedHorizontalInset() ?: 0f) * density).toInt()
         if (forceMeasureToolbar || keyboardToolbarView.measuredHeight == 0) {
@@ -3059,7 +2990,10 @@ class NativeEditorExpoView(
 
     private fun handleListToggle(listType: String) {
         val isActive = toolbarState.nodes[listType] == true
-        richTextView.editorEditText.performToolbarToggleList(listType, isActive)
+        richTextView.performEditorCommand {
+            if (isActive) editorUnwrapFromList(richTextView.editorId.toULong())
+            else editorWrapInList(richTextView.editorId.toULong(), listType)
+        }
     }
 
     private fun handleToolbarItemPress(
@@ -3067,7 +3001,7 @@ class NativeEditorExpoView(
         allowPreflightRetry: Boolean = true
     ) {
         if (handleDestroyedCurrentEditorIfNeeded()) return
-        if (!richTextView.editorEditText.isEditable) {
+        if (!richTextView.editorIsEditable) {
             clearPendingNativeActionRetry()
             return
         }
@@ -3090,31 +3024,38 @@ class NativeEditorExpoView(
                 }
                 return
             }
-            val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
-            if (!preparation.ready) {
+            if (richTextView.hasActiveComposition()) {
                 if (allowPreflightRetry) {
                     schedulePendingNativeActionRetry(PendingNativeAction.ToolbarItemPress(item))
                 }
                 return
             }
-            preflightUpdateJSON = preparation.updateJSON
+            preflightUpdateJSON = editorGetSelectionState(richTextView.editorId.toULong())
             noteDocumentVersionFromUpdateJSON(preflightUpdateJSON)
             clearPendingNativeActionRetry()
         }
         if (handleDestroyedCurrentEditorIfNeeded()) return
         when (item.type) {
-            ToolbarItemKind.mark -> item.mark?.let { richTextView.editorEditText.performToolbarToggleMark(it) }
-            ToolbarItemKind.heading -> item.headingLevel?.let { richTextView.editorEditText.performToolbarToggleHeading(it) }
-            ToolbarItemKind.blockquote -> richTextView.editorEditText.performToolbarToggleBlockquote()
+            ToolbarItemKind.mark -> item.mark?.let { mark ->
+                richTextView.performEditorCommand { editorToggleMark(richTextView.editorId.toULong(), mark) }
+            }
+            ToolbarItemKind.heading -> item.headingLevel?.let { level ->
+                richTextView.performEditorCommand { editorToggleHeading(richTextView.editorId.toULong(), level.toUByte()) }
+            }
+            ToolbarItemKind.blockquote -> richTextView.performEditorCommand {
+                editorToggleBlockquote(richTextView.editorId.toULong())
+            }
             ToolbarItemKind.list -> item.listType?.name?.let { handleListToggle(it) }
             ToolbarItemKind.command -> when (item.command) {
-                ToolbarCommand.indentList -> richTextView.editorEditText.performToolbarIndentListItem()
-                ToolbarCommand.outdentList -> richTextView.editorEditText.performToolbarOutdentListItem()
-                ToolbarCommand.undo -> richTextView.editorEditText.performToolbarUndo()
-                ToolbarCommand.redo -> richTextView.editorEditText.performToolbarRedo()
+                ToolbarCommand.indentList -> richTextView.performEditorCommand { editorIndentListItem(richTextView.editorId.toULong()) }
+                ToolbarCommand.outdentList -> richTextView.performEditorCommand { editorOutdentListItem(richTextView.editorId.toULong()) }
+                ToolbarCommand.undo -> richTextView.performEditorCommand { editorUndo(richTextView.editorId.toULong()) }
+                ToolbarCommand.redo -> richTextView.performEditorCommand { editorRedo(richTextView.editorId.toULong()) }
                 null -> Unit
             }
-            ToolbarItemKind.node -> item.nodeType?.let { richTextView.editorEditText.performToolbarInsertNode(it) }
+            ToolbarItemKind.node -> item.nodeType?.let { nodeType ->
+                richTextView.performEditorCommand { editorInsertNode(richTextView.editorId.toULong(), nodeType) }
+            }
             ToolbarItemKind.action -> item.key?.let {
                 if (handleDestroyedCurrentEditorIfNeeded()) return
                 val payload = mutableMapOf<String, Any>(