@apollohg/react-native-rich-text-editor 2.0.0

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

@@ -0,0 +1,68 @@
+package com.apollohg.editor
+
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewGroup
+
+internal fun NativeEditorExpoView.atomChildAtImpl(index: Int): View? =
+    reactChildren.getOrNull(index)
+
+internal fun NativeEditorExpoView.addAtomChildImpl(child: View, index: Int) {
+    reactChildren.remove(child)
+    reactChildren.add(index.coerceIn(0, reactChildren.size), child)
+    val atomKey = atomKey(child)
+    if (atomKey == null) {
+        (child.parent as? ViewGroup)?.removeView(child)
+        addNativeAtomView(child, childCount)
+        return
+    }
+    (child.parent as? ViewGroup)?.removeView(child)
+    richTextView.mountAtomChild(child, atomKey)
+    richTextView.orderAtomChildren(reactChildren)
+}
+
+internal fun NativeEditorExpoView.removeAtomChildAtImpl(index: Int) {
+    reactChildren.getOrNull(index)?.let(::removeAtomChild)
+}
+
+internal fun NativeEditorExpoView.removeAtomChildImpl(child: View) {
+    reactChildren.remove(child)
+    if (!richTextView.unmountAtomChild(child)) {
+        (child.parent as? ViewGroup)?.removeView(child)
+    }
+}
+
+internal fun NativeEditorExpoView.emitAtomLayout(
+    widthPx: Float,
+    positions: List<AtomLayoutPosition>
+) {
+    val density = resources.displayMetrics.density.takeIf { it > 0f } ?: 1f
+    val contentOrigin = Rect()
+    offsetDescendantRectToMyCoords(richTextView.editorContentFrame, contentOrigin)
+    val event = mapOf<String, Any>(
+        "width" to widthPx / density,
+        "positions" to positions.map { position ->
+            mapOf(
+                "key" to position.key,
+                "x" to position.xPx / density,
+                "y" to position.yPx / density,
+                "hostX" to (contentOrigin.left + position.xPx) / density,
+                "hostY" to (contentOrigin.top + position.yPx) / density,
+                "height" to position.heightPx / density,
+                "width" to position.widthPx / density
+            )
+        },
+        "viewport" to mapOf(
+            "y" to richTextView.editorScrollView.scrollY / density,
+            "height" to richTextView.editorScrollView.height / density
+        ),
+        "editorId" to eventEditorId(richTextView.editorId)
+    )
+    onAtomLayoutForTesting?.invoke(event) ?: onAtomLayout(event)
+}
+
+internal fun NativeEditorExpoView.atomKey(child: View): String? {
+    val nativeId = child.getTag(com.facebook.react.R.id.view_tag_native_id) as? String
+    if (nativeId == null || !nativeId.startsWith(ATOM_NATIVE_ID_PREFIX)) return null
+    return nativeId.removePrefix(ATOM_NATIVE_ID_PREFIX).takeIf(String::isNotEmpty)
+}

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

@@ -0,0 +1,126 @@
+package com.apollohg.editor
+
+/** Public v2 handles are decimal strings; [RichTextEditorView] uses an opaque local token. */
+internal fun NativeEditorExpoView.publicHandleForViewToken(viewToken: Long): String? =
+    EditorV2Registry.handleForViewToken(viewToken)
+
+/** Events never expose a signed widget token as a v2 editor id. */
+internal fun NativeEditorExpoView.eventEditorId(viewToken: Long): String =
+    publicHandleForViewToken(viewToken) ?: "0"
+
+internal fun NativeEditorExpoView.setEditorHandleImpl(handle: String?) {
+    val viewToken = handle?.let(EditorV2Registry::viewTokenForHandle)
+    setEditorId(viewToken ?: 0L)
+}
+
+/**
+ * Internal-only widget binding. This token is allocated by
+ * [EditorV2Registry] and is never a public session identifier.
+ */
+internal fun NativeEditorExpoView.setEditorIdImpl(id: Long) {
+    if (id != 0L && NativeEditorViewRegistry.isDestroyed(id)) {
+        setEditorId(0L)
+        return
+    }
+    val previousEditorId = richTextView.editorId
+    if (previousEditorId != id) {
+        cancelActiveExternalTextComposition("lifecycle")
+        invalidateAutoGrowContentHeightEmission()
+        drainPendingEditorUpdateEvents()
+        clearEditorErrorBinding("editorRebind")
+    }
+    if (previousEditorId == id && richTextView.editorEditText.editorId == id) {
+        if (id != 0L && isAttachedToNativeWindow) {
+            if (!NativeEditorViewRegistry.register(id, this)) {
+                handleEditorDestroyed(id)
+                return
+            }
+            bindEditorErrorCallbackIfLive(id)
+            applyPendingEditorResetUpdateIfNeeded()
+            applyPendingEditorUpdateIfNeeded()
+            applyPendingThemeIfNeeded()
+            applyPendingAtomsIfNeeded()
+            refreshReadyStateIfSettled()
+            applyAutoFocusIfNeeded()
+        } else if (id != 0L) {
+            NativeEditorViewRegistry.unregister(
+                id,
+                this,
+                blockCommandsUntilRegistered = true
+            )
+        }
+        richTextView.emitAtomLayoutIfAvailable(force = true)
+        return
+    }
+    if (previousEditorId != id) {
+        NativeEditorViewRegistry.unregister(previousEditorId, this)
+        lastDocumentVersion = null
+        renderedDocumentRevision = null
+        cancelPendingToolbarRefocus()
+        cancelPendingEditorUpdateRetry()
+        if (pendingEditorUpdateEditorId != null && pendingEditorUpdateEditorId != id) {
+            clearPendingEditorUpdateState()
+        }
+        if (pendingEditorResetUpdateEditorId != null && pendingEditorResetUpdateEditorId != id) {
+            clearPendingEditorResetUpdateState()
+        }
+        appliedEditorUpdateRevision = 0L
+        appliedEditorResetUpdateRevision = 0L
+        consumedEditorUpdateRevision = 0L
+        consumedEditorUpdateEditorId = null
+        consumedEditorResetUpdateRevision = 0L
+        consumedEditorResetUpdateEditorId = null
+        clearPendingViewCommandUpdateRetry()
+        cancelPendingThemeRetry()
+        if (hasPendingTheme) {
+            pendingThemeRetry.bind(id)
+        }
+        cancelPendingAtomsRetry()
+        if (hasPendingAtoms) {
+            pendingAtomsRetry.bind(id)
+        }
+        cancelPendingBlurRetry()
+        clearPendingNativeActionRetry()
+        clearMentionQueryState(resetLastEvent = true)
+        lastReadyEditorId = null
+    }
+    if (!isAttachedToNativeWindow) {
+        richTextView.setEditorIdWhileDetached(id)
+        if (id != 0L) {
+            NativeEditorViewRegistry.unregister(
+                id,
+                this,
+                blockCommandsUntilRegistered = true
+            )
+        } else {
+            toolbarState = NativeToolbarState.empty
+            keyboardToolbarView.applyState(toolbarState)
+        }
+        richTextView.emitAtomLayoutIfAvailable(force = true)
+        return
+    }
+
+    if (hasPendingEditorResetUpdateForEditor(id) || hasPendingEditorUpdateForEditor(id)) {
+        richTextView.setEditorIdWhileDetached(id)
+        richTextView.rebindEditorIfNeeded(notifyListener = false)
+    } else {
+        richTextView.editorId = id
+    }
+    if (id != 0L) {
+        if (!NativeEditorViewRegistry.register(id, this)) {
+            handleEditorDestroyed(id)
+            return
+        }
+        bindEditorErrorCallbackIfLive(id)
+    } else {
+        toolbarState = NativeToolbarState.empty
+        keyboardToolbarView.applyState(toolbarState)
+    }
+    applyPendingEditorResetUpdateIfNeeded()
+    applyPendingEditorUpdateIfNeeded()
+    applyPendingThemeIfNeeded()
+    applyPendingAtomsIfNeeded()
+    refreshReadyStateIfSettled()
+    applyAutoFocusIfNeeded()
+    richTextView.emitAtomLayoutIfAvailable(force = true)
+}

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

@@ -0,0 +1,208 @@
+package com.apollohg.editor
+
+import android.view.MotionEvent
+
+internal fun NativeEditorExpoView.markRecentToolbarTouchForTestingImpl() {
+    markRecentToolbarTouch()
+}
+
+internal fun NativeEditorExpoView.shouldPreserveFocusAfterToolbarTouchForTestingImpl(): Boolean =
+    shouldPreserveFocusAfterToolbarTouch()
+
+internal fun NativeEditorExpoView.setEditorFocusedForOutsideTapDecisionForTestingImpl(
+    isFocused: Boolean?
+) {
+    editorFocusedForOutsideTapOverrideForTesting = isFocused
+}
+
+internal fun NativeEditorExpoView.setAttachedToNativeWindowForTestingImpl(isAttached: Boolean) {
+    isAttachedToNativeWindow = isAttached
+}
+
+internal fun NativeEditorExpoView.handleAttachedToWindowForTestingImpl() {
+    handleAttachedToWindow()
+}
+
+internal fun NativeEditorExpoView.traceOutsideTapImpl(message: String) {
+    onOutsideTapTraceForTesting?.invoke(message)
+}
+
+internal fun NativeEditorExpoView.handleDetachedFromWindowForTestingImpl() {
+    prepareForDetachFromWindow()
+    richTextView.editorEditText.retireInputConnectionForHostDetach()
+    handleDetachedFromWindow()
+}
+
+internal fun NativeEditorExpoView.performBlurForTestingImpl(deferKeyboardDismiss: Boolean = false) {
+    performBlur(deferKeyboardDismiss = deferKeyboardDismiss, allowRetry = true)
+}
+
+internal fun NativeEditorExpoView.pendingBlurRetryAttemptsForTestingImpl(): Int =
+    pendingBlurRetryAttempts
+
+internal fun NativeEditorExpoView.pendingDetachPreflightRetryAttemptsForTestingImpl(): Int =
+    pendingDetachPreflightRetryAttempts
+
+internal fun NativeEditorExpoView.hasPendingOutsideTapBlurForTestingImpl(): Boolean =
+    pendingOutsideTapBlur != null
+
+internal fun NativeEditorExpoView.isOutsideTapBlurHandlerInstalledForTestingImpl(): Boolean =
+    outsideTapWindow != null
+
+internal fun NativeEditorExpoView.hasPendingKeyboardDismissForTestingImpl(): Boolean =
+    pendingKeyboardDismiss != null
+
+internal fun NativeEditorExpoView.hasPendingPreflightWakeForTestingImpl(): Boolean =
+    pendingPreflightWakeScheduled
+
+internal fun NativeEditorExpoView.hasPendingToolbarRefocusForTestingImpl(): Boolean =
+    pendingToolbarRefocus != null
+
+internal fun NativeEditorExpoView.isKeyboardToolbarAttachedForTestingImpl(): Boolean =
+    keyboardToolbarView.parent != null
+
+internal fun NativeEditorExpoView.currentImeBottomForTestingImpl(): Int = currentImeBottom
+
+internal fun NativeEditorExpoView.setCurrentImeBottomForTestingImpl(bottom: Int) {
+    currentImeBottom = bottom
+}
+
+internal fun NativeEditorExpoView.updateAttachedKeyboardToolbarForInsetsForTestingImpl() {
+    updateAttachedKeyboardToolbarForInsets()
+}
+
+internal fun NativeEditorExpoView.scheduleToolbarRefocusForTestingImpl() {
+    scheduleToolbarRefocus()
+}
+
+internal fun NativeEditorExpoView.focusFromToolbarPreserveForTestingImpl() {
+    focusInternal(cancelPendingOutsideTapBlur = false)
+}
+
+internal fun NativeEditorExpoView.applyAutoFocusForTestingImpl() {
+    applyAutoFocusIfNeeded()
+}
+
+internal fun NativeEditorExpoView.installOutsideTapBlurHandlerForTestingImpl() {
+    installOutsideTapBlurHandlerIfNeeded()
+}
+
+internal fun NativeEditorExpoView.uninstallOutsideTapBlurHandlerForTestingImpl() {
+    uninstallOutsideTapBlurHandler()
+}
+
+internal fun NativeEditorExpoView.setOutsideTapCycleBreakDispatcherForTestingImpl(
+    dispatcher: ((MotionEvent) -> Boolean)?
+): Boolean {
+    val window = resolveActivity(context)?.window ?: return false
+    return NativeEditorOutsideTapDispatcher.setCycleBreakDispatcherForTesting(window, dispatcher)
+}
+
+internal fun NativeEditorExpoView.clearOutsideTapRouteViewReferenceAndReconcileForTestingImpl():
+    NativeEditorOutsideTapRouteTestState {
+    val window = resolveActivity(context)?.window
+        ?: return NativeEditorOutsideTapRouteTestState(
+            isRegistered = false,
+            hasCallbackReconciler = false
+        )
+    return NativeEditorOutsideTapDispatcher.clearViewReferenceAndReconcileForTesting(window, this)
+}
+
+internal fun NativeEditorExpoView.dispatchOutsideTapWindowEventForTestingImpl(
+    event: MotionEvent
+): Boolean {
+    val window = resolveActivity(context)?.window ?: return false
+    return NativeEditorOutsideTapDispatcher.dispatchForTesting(window, event)
+}
+
+internal fun NativeEditorExpoView.schedulePendingPreflightWakeForTestingImpl() {
+    schedulePendingPreflightWake()
+}
+
+internal fun NativeEditorExpoView.hasPendingNativeActionForTestingImpl(): Boolean =
+    pendingNativeAction != null
+
+internal fun NativeEditorExpoView.pendingNativeActionRetryAttemptsForTestingImpl(): Int =
+    pendingNativeActionRetryAttempts
+
+internal fun NativeEditorExpoView.lastDocumentVersionForTestingImpl(): String? = lastDocumentVersion
+
+internal fun NativeEditorExpoView.setLastDocumentVersionForTestingImpl(documentVersion: String?) {
+    lastDocumentVersion = documentVersion
+}
+
+internal fun NativeEditorExpoView.refreshToolbarStateFromEditorSelectionForTestingImpl(): String? =
+    refreshToolbarStateFromEditorSelection()
+
+internal fun NativeEditorExpoView.handleToolbarItemPressForTestingImpl(item: NativeToolbarItem) {
+    handleToolbarItemPress(item)
+}
+
+internal fun NativeEditorExpoView.insertMentionSuggestionForTestingImpl(
+    suggestion: NativeMentionSuggestion
+) {
+    insertMentionSuggestion(suggestion)
+}
+
+internal fun NativeEditorExpoView.wakePendingPreflightWorkForTestingImpl() {
+    wakePendingPreflightWork()
+}
+
+internal fun NativeEditorExpoView.emitEditorReadyForTestingImpl(
+    editorUpdateRevision: Long? = null
+): Boolean = emitEditorReady(editorUpdateRevision)
+
+internal fun NativeEditorExpoView.pendingEditorUpdateJsonForTestingImpl(): String? =
+    pendingEditorUpdateJson
+
+internal fun NativeEditorExpoView.pendingEditorUpdateRevisionForTestingImpl(): Long =
+    pendingEditorUpdateRevision
+
+internal fun NativeEditorExpoView.pendingEditorResetUpdateJsonForTestingImpl(): String? =
+    pendingEditorResetUpdateJson
+
+internal fun NativeEditorExpoView.pendingEditorResetUpdateRevisionForTestingImpl(): Long =
+    pendingEditorResetUpdateRevision
+
+internal fun NativeEditorExpoView.setAppliedEditorUpdateRevisionForTestingImpl(
+    editorUpdateRevision: Long
+) {
+    appliedEditorUpdateRevision = editorUpdateRevision
+}
+
+internal fun NativeEditorExpoView.pendingEditorUpdateEditorIdForTestingImpl(): Long? =
+    pendingEditorUpdateEditorId
+
+internal fun NativeEditorExpoView.pendingEditorResetUpdateEditorIdForTestingImpl(): Long? =
+    pendingEditorResetUpdateEditorId
+
+internal fun NativeEditorExpoView.pendingViewCommandUpdateJsonForTestingImpl(): String? =
+    pendingViewCommandUpdateJson
+
+internal fun NativeEditorExpoView.pendingViewCommandUpdateRetryAttemptsForTestingImpl(): Int =
+    pendingViewCommandUpdateRetryAttempts
+
+internal fun NativeEditorExpoView.scheduleViewCommandUpdateRetryForTestingImpl(updateJson: String) {
+    scheduleViewCommandUpdateRetry(updateJson)
+}
+
+internal fun NativeEditorExpoView.pendingThemeJsonForTestingImpl(): String? =
+    pendingThemeJson.takeIf {
+        hasPendingTheme
+    }
+
+internal fun NativeEditorExpoView.pendingAtomsJsonForTestingImpl(): String? =
+    pendingAtomsJson.takeIf {
+        hasPendingAtoms
+    }
+
+internal fun NativeEditorExpoView.lastAtomsJsonForTestingImpl(): String? = lastAtomsJson
+
+internal fun NativeEditorExpoView.lastThemeJsonForTestingImpl(): String? = lastThemeJson
+
+internal fun NativeEditorExpoView.pendingThemeRetryAttemptsForTestingImpl(): Int =
+    pendingThemeRetry.attempts
+
+internal fun NativeEditorExpoView.applyPendingThemeForTestingImpl() {
+    applyPendingThemeIfNeeded()
+}

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

@@ -0,0 +1,146 @@
+package com.apollohg.editor
+
+import android.os.Looper
+import com.apollohg.editor.NativeEditorExpoView.EditorErrorBinding
+import com.apollohg.editor.NativeEditorExpoView.PendingEditorErrorEvent
+
+internal fun NativeEditorExpoView.bindEditorErrorCallbackIfLive(viewToken: Long) {
+    if (!isAttachedToNativeWindow || richTextView.editorId != viewToken ||
+        richTextView.editorEditText.editorId != viewToken
+    ) {
+        return
+    }
+    val adapter = EditorV2Registry.adapterForViewToken(viewToken) ?: return
+    val editorId = publicHandleForViewToken(viewToken) ?: return
+    val existing = editorErrorBinding
+    if (existing?.adapter === adapter && existing.viewToken == viewToken &&
+        existing.editorId == editorId
+    ) {
+        return
+    }
+    clearEditorErrorBinding("claim")
+    val binding = EditorErrorBinding(
+        adapter = adapter,
+        editorId = editorId,
+        viewToken = viewToken,
+        callbackToken = nextNativeEditorErrorCallbackToken.incrementAndGet(),
+        generation = ++nextEditorErrorBindingGeneration
+    )
+    editorErrorBinding = binding
+    adapter.bindAutonomousErrorOwner(
+        binding.callbackToken,
+        callback = { error -> queueEditorError(binding, error) },
+        onReleased = { releaseEditorErrorBinding(binding) }
+    )
+}
+
+internal fun NativeEditorExpoView.releaseEditorErrorBinding(binding: EditorErrorBinding) {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+        mainHandler.post { releaseEditorErrorBinding(binding) }
+        return
+    }
+    if (editorErrorBinding != binding) return
+    editorErrorBinding = null
+    nextEditorErrorBindingGeneration += 1
+    clearPendingEditorErrorDispatchQueue("ownerReleased")
+}
+
+internal fun NativeEditorExpoView.clearEditorErrorBinding(reason: String) {
+    val binding = editorErrorBinding
+    editorErrorBinding = null
+    nextEditorErrorBindingGeneration += 1
+    binding?.adapter?.clearAutonomousErrorOwner(binding.callbackToken)
+    clearPendingEditorErrorDispatchQueue(reason)
+}
+
+internal fun NativeEditorExpoView.queueEditorError(
+    binding: EditorErrorBinding,
+    error: EditorV2Error
+) {
+    val event = PendingEditorErrorEvent(
+        adapter = binding.adapter,
+        editorId = binding.editorId,
+        viewToken = binding.viewToken,
+        callbackToken = binding.callbackToken,
+        bindingGeneration = binding.generation,
+        error = error
+    )
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+        enqueueEditorError(event)
+    } else {
+        mainHandler.post { enqueueEditorError(event) }
+    }
+}
+
+internal fun NativeEditorExpoView.enqueueEditorError(event: PendingEditorErrorEvent) {
+    if (!isLiveEditorErrorBinding(event)) return
+    pendingEditorErrorEvents.addLast(event)
+    if (!pendingEditorErrorDispatchScheduled) {
+        pendingEditorErrorDispatchScheduled = true
+        val generation = ++pendingEditorErrorDispatchGeneration
+        mainHandler.post {
+            if (generation != pendingEditorErrorDispatchGeneration) return@post
+            pendingEditorErrorDispatchScheduled = false
+            drainPendingEditorErrorEvents()
+        }
+    }
+}
+
+internal fun NativeEditorExpoView.drainPendingEditorErrorEvents() {
+    while (pendingEditorErrorEvents.isNotEmpty()) {
+        // Remove before dispatch so a reentrant lifecycle transition cannot deliver it twice.
+        val event = pendingEditorErrorEvents.removeFirst()
+        if (!isLiveEditorErrorBinding(event)) continue
+        val payload = mapOf<String, Any>(
+            "editorId" to event.editorId,
+            "error" to event.error.toJSMap()
+        )
+        dispatchEditorError(payload)
+    }
+}
+
+internal fun NativeEditorExpoView.dispatchEditorError(payload: Map<String, Any>) {
+    onEditorErrorForTesting?.let { callback ->
+        callback(payload)
+        return
+    }
+    if (!appContext.hasActiveReactInstance) return
+    onEditorError(payload)
+}
+
+internal fun NativeEditorExpoView.isLiveEditorErrorBinding(
+    event: PendingEditorErrorEvent
+): Boolean {
+    val binding = editorErrorBinding ?: return false
+    return isAttachedToNativeWindow &&
+        !NativeEditorViewRegistry.isDestroyed(event.viewToken) &&
+        binding.adapter === event.adapter &&
+        binding.editorId == event.editorId &&
+        binding.viewToken == event.viewToken &&
+        binding.callbackToken == event.callbackToken &&
+        binding.generation == event.bindingGeneration &&
+        richTextView.editorId == event.viewToken &&
+        richTextView.editorEditText.editorId == event.viewToken &&
+        publicHandleForViewToken(event.viewToken) == event.editorId &&
+        EditorV2Registry.adapterForViewToken(event.viewToken) === event.adapter &&
+        event.adapter.ownsAutonomousErrorOwner(event.callbackToken)
+}
+
+internal fun NativeEditorExpoView.clearPendingEditorErrorDispatchQueue(reason: String) {
+    val clearedCount = pendingEditorErrorEvents.size
+    pendingEditorErrorEvents.clear()
+    pendingEditorErrorDispatchScheduled = false
+    pendingEditorErrorDispatchGeneration += 1
+    if (clearedCount > 0) {
+        richTextView.editorEditText.recordImeTraceForTesting(
+            "nativeViewEditorErrorQueueCleared",
+            "reason=$reason count=$clearedCount"
+        )
+    }
+}
+
+internal fun NativeEditorExpoView.pendingEditorErrorEventCountForTestingImpl(): Int =
+    pendingEditorErrorEvents.size
+
+internal fun NativeEditorExpoView.editorErrorCallbackTokenForTestingImpl(): Long? =
+    editorErrorBinding?.callbackToken

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

@@ -0,0 +1,150 @@
+package com.apollohg.editor
+
+import com.apollohg.editor.NativeEditorExpoView.Companion.EDITOR_UPDATE_EVENT_DEBOUNCE_MS
+import com.apollohg.editor.NativeEditorExpoView.Companion.nanosToMicros
+import com.apollohg.editor.NativeEditorExpoView.NativeCommitKey
+import com.apollohg.editor.NativeEditorExpoView.PendingEditorUpdateEvent
+import com.apollohg.editor.NativeEditorExpoView.PreflightUpdateEvent
+import org.json.JSONObject
+
+internal fun NativeEditorExpoView.documentVersionFromUpdateJSON(updateJSON: String?): String? =
+    try {
+        if (updateJSON == null) {
+            null
+        } else {
+            canonicalV2U64(JSONObject(updateJSON).opt("documentVersion") as? String)
+        }
+    } catch (_: Throwable) {
+        null
+    }
+
+internal fun NativeEditorExpoView.noteDocumentVersionFromUpdateJSON(updateJSON: String?) {
+    documentVersionFromUpdateJSON(updateJSON)?.let { version ->
+        lastDocumentVersion = version
+    }
+}
+
+internal fun NativeEditorExpoView.isSupersededEditorUpdate(updateJson: String): Boolean {
+    val rendered = renderedDocumentRevision?.toULongOrNull() ?: return false
+    val incoming = documentVersionFromUpdateJSON(updateJson)?.toULongOrNull() ?: return false
+    return incoming < rendered
+}
+
+internal fun NativeEditorExpoView.preflightUpdateEventFromJSON(
+    updateJSON: String?
+): PreflightUpdateEvent? {
+    val update = updateJSON ?: return null
+    val documentRevision = documentVersionFromUpdateJSON(update) ?: return null
+    return PreflightUpdateEvent(updateJSON = update, documentRevision = documentRevision)
+}
+
+internal fun NativeEditorExpoView.addPreflightUpdateToEvent(
+    event: MutableMap<String, Any>,
+    preflightUpdate: PreflightUpdateEvent?
+) {
+    preflightUpdate ?: return
+    event["updateJson"] = preflightUpdate.updateJSON
+    event["documentRevision"] = preflightUpdate.documentRevision
+}
+
+internal fun NativeEditorExpoView.emitAddonEvent(payload: Map<String, Any>) {
+    onAddonEventForTesting?.invoke(payload) ?: onAddonEvent(payload)
+}
+
+internal fun NativeEditorExpoView.pendingEditorUpdateEventCountForTestingImpl(): Int =
+    pendingEditorUpdateEvents.size
+
+internal fun NativeEditorExpoView.schedulePendingEditorUpdateDispatch() {
+    pendingEditorUpdateDispatchScheduled = true
+    val generation = ++pendingEditorUpdateDispatchGeneration
+    mainHandler.postDelayed({
+        if (generation != pendingEditorUpdateDispatchGeneration) return@postDelayed
+        pendingEditorUpdateDispatchScheduled = false
+        drainPendingEditorUpdateEvents()
+    }, EDITOR_UPDATE_EVENT_DEBOUNCE_MS)
+}
+
+internal fun NativeEditorExpoView.drainPendingEditorUpdateEvents() {
+    if (pendingEditorUpdateEvents.isEmpty()) return
+    val startedAt = System.nanoTime()
+    var drainedCount = 0
+    while (pendingEditorUpdateEvents.isNotEmpty()) {
+        val event = pendingEditorUpdateEvents.removeFirst()
+        pendingEditorUpdateKeys.remove(NativeCommitKey(event.editorId, event.documentRevision))
+        if (event.editorId != eventEditorId(richTextView.editorId)) {
+            richTextView.editorEditText.recordImeTraceForTesting(
+                "nativeViewEditorUpdateSkipped",
+                "reason=staleEditor queuedEditor=${event.editorId} currentEditor=${eventEditorId(
+                    richTextView.editorId
+                )}"
+            )
+            continue
+        }
+        val isCurrentRevision = event.documentRevision == renderedDocumentRevision
+        dispatchEditorUpdate(event, emitToJS = true, applyViewState = isCurrentRevision)
+        drainedCount += 1
+    }
+    richTextView.editorEditText.recordImeTraceForTesting(
+        "nativeViewEditorUpdateDrained",
+        "count=$drainedCount totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+    )
+}
+
+internal fun NativeEditorExpoView.dispatchEditorUpdate(
+    event: PendingEditorUpdateEvent,
+    emitToJS: Boolean,
+    applyViewState: Boolean = true
+) {
+    val updateJSON = event.viewUpdateJSON
+    val startedAt = System.nanoTime()
+    if (applyViewState) noteDocumentVersionFromUpdateJSON(updateJSON)
+    val noteNanos = System.nanoTime() - startedAt
+    val toolbarStartedAt = System.nanoTime()
+    if (applyViewState) {
+        NativeToolbarState.fromUpdateJson(updateJSON)?.let { state ->
+            toolbarState = state
+            keyboardToolbarView.applyState(state)
+        }
+    }
+    val toolbarNanos = System.nanoTime() - toolbarStartedAt
+    val mentionStartedAt = System.nanoTime()
+    if (applyViewState) refreshMentionQuery()
+    val mentionNanos = System.nanoTime() - mentionStartedAt
+    val retryStartedAt = System.nanoTime()
+    if (applyViewState) {
+        clearPendingNativeActionRetryIfScopeChanged()
+        schedulePendingPreflightWake()
+        richTextView.refreshRemoteSelections()
+    }
+    val retryNanos = System.nanoTime() - retryStartedAt
+    if (applyViewState && heightBehavior == EditorHeightBehavior.AUTO_GROW) {
+        post {
+            requestLayout()
+            emitContentHeightIfNeeded(force = false)
+        }
+    }
+    val emitStartedAt = System.nanoTime()
+    if (emitToJS) {
+        val payload = mapOf<String, Any>(
+            "updateJson" to event.atomicUpdateJSON,
+            "editorId" to event.editorId,
+            "documentRevision" to event.documentRevision
+        )
+        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)}"
+    )
+}