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

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

@@ -0,0 +1,191 @@
+package com.apollohg.editor
+
+import android.graphics.Rect
+import android.text.Annotation
+import android.text.Layout
+import android.text.Spanned
+import com.apollohg.editor.EditorEditText.AccessibleAnnotation
+import com.apollohg.editor.EditorEditText.AccessibleAnnotationTarget
+import com.apollohg.editor.EditorEditText.InteractiveAnnotationHit
+import com.apollohg.editor.EditorEditText.LinkHit
+import com.apollohg.editor.EditorEditText.MentionHit
+
+internal fun EditorEditText.textOffsetHitAt(x: Float, y: Float): Pair<Spanned, Int>? {
+    val spannable = text as? Spanned ?: return null
+    val layout = layout ?: return null
+    if (spannable.isEmpty()) return null
+
+    val localX = x - totalPaddingLeft + scrollX
+    val localY = y - totalPaddingTop + scrollY
+    if (localY < 0f || localY > layout.height.toFloat()) {
+        return null
+    }
+
+    val line = layout.getLineForVertical(localY.toInt())
+    val lineLeft = layout.getLineLeft(line)
+    val lineRight = layout.getLineRight(line)
+    if (localX < lineLeft || localX > lineRight) {
+        return null
+    }
+
+    val offset = layout.getOffsetForHorizontal(line, localX)
+        .coerceIn(0, maxOf(spannable.length - 1, 0))
+    return spannable to offset
+}
+
+internal fun EditorEditText.mentionHitAtImpl(x: Float, y: Float): MentionHit? {
+    val (spannable, offset) = textOffsetHitAt(x, y) ?: return null
+    val annotations = spannable.getSpans(
+        offset,
+        (offset + 1).coerceAtMost(spannable.length),
+        Annotation::class.java
+    )
+    val mentionAnnotation = annotations.firstOrNull {
+        it.key == "nativeVoidNodeType" && it.value == "mention"
+    } ?: return null
+    val docPos = annotations.firstOrNull { it.key == "nativeDocPos" }
+        ?.value
+        ?.viewerMentionDocPos() ?: return null
+    val start = spannable.getSpanStart(mentionAnnotation)
+    val end = spannable.getSpanEnd(mentionAnnotation)
+    if (start < 0 || end <= start) {
+        return null
+    }
+
+    return MentionHit(
+        docPos = docPos,
+        label = spannable.subSequence(start, end).toString()
+    )
+}
+
+internal fun EditorEditText.linkHitAtImpl(x: Float, y: Float): LinkHit? {
+    val (spannable, offset) = textOffsetHitAt(x, y) ?: return null
+    val annotations = spannable.getSpans(
+        offset,
+        (offset + 1).coerceAtMost(spannable.length),
+        Annotation::class.java
+    )
+    val linkAnnotation = annotations.firstOrNull {
+        it.key == RenderBridge.NATIVE_LINK_HREF_ANNOTATION && it.value.isNotBlank()
+    } ?: return null
+    val start = spannable.getSpanStart(linkAnnotation)
+    val end = spannable.getSpanEnd(linkAnnotation)
+    if (start < 0 || end <= start) {
+        return null
+    }
+
+    return LinkHit(
+        href = linkAnnotation.value,
+        text = spannable.subSequence(start, end).toString()
+    )
+}
+
+internal fun EditorEditText.accessibleAnnotationsImpl(): List<AccessibleAnnotation> {
+    val spannable = text as? Spanned ?: return emptyList()
+    val textLayout = layout ?: return emptyList()
+    val annotations = spannable.getSpans(0, spannable.length, Annotation::class.java)
+    val results = mutableListOf<Pair<Int, AccessibleAnnotation>>()
+    annotations.forEach { annotation ->
+        val start = spannable.getSpanStart(annotation)
+        val end = spannable.getSpanEnd(annotation)
+        if (start < 0 || end <= start) return@forEach
+        val label = spannable.subSequence(start, end).toString()
+        val target = when {
+            annotation.key == RenderBridge.NATIVE_LINK_HREF_ANNOTATION &&
+                annotation.value.isNotBlank() -> AccessibleAnnotationTarget.Link(
+                href = annotation.value,
+                text = label
+            )
+
+            annotation.key == "nativeVoidNodeType" && annotation.value == "mention" -> {
+                val docPos = annotations.firstOrNull { candidate ->
+                    candidate.key == "nativeDocPos" &&
+                        spannable.getSpanStart(candidate) == start &&
+                        spannable.getSpanEnd(candidate) == end
+                }?.value?.viewerMentionDocPos() ?: return@forEach
+                AccessibleAnnotationTarget.Mention(docPos, label)
+            }
+
+            else -> return@forEach
+        }
+        val role = when (target) {
+            is AccessibleAnnotationTarget.Link -> "link"
+            is AccessibleAnnotationTarget.Mention -> "mention"
+        }
+        results += start to AccessibleAnnotation(
+            target = target,
+            label = label,
+            role = role,
+            bounds = annotationBounds(textLayout, start, end),
+            annotation = annotation,
+            start = start,
+            end = end
+        )
+    }
+    return results.sortedBy { it.first }.map { it.second }
+}
+
+internal fun EditorEditText.interactiveAnnotationHitAtImpl(
+    x: Float,
+    y: Float
+): InteractiveAnnotationHit? {
+    val (spannable, offset) = textOffsetHitAt(x, y) ?: return null
+    val annotations = spannable.getSpans(
+        offset,
+        (offset + 1).coerceAtMost(spannable.length),
+        Annotation::class.java
+    )
+    val mentionAnnotation = annotations.firstOrNull {
+        it.key == "nativeVoidNodeType" && it.value == "mention"
+    }
+    val annotation = mentionAnnotation ?: annotations.firstOrNull {
+        it.key == RenderBridge.NATIVE_LINK_HREF_ANNOTATION && it.value.isNotBlank()
+    } ?: return null
+    val start = spannable.getSpanStart(annotation)
+    val end = spannable.getSpanEnd(annotation)
+    if (start < 0 || end <= start) return null
+    val label = spannable.subSequence(start, end).toString()
+    val target = if (annotation === mentionAnnotation) {
+        val docPos = annotations.firstOrNull {
+            it.key == "nativeDocPos" &&
+                spannable.getSpanStart(it) == start &&
+                spannable.getSpanEnd(it) == end
+        }?.value?.viewerMentionDocPos() ?: return null
+        AccessibleAnnotationTarget.Mention(docPos, label)
+    } else {
+        AccessibleAnnotationTarget.Link(annotation.value, label)
+    }
+    return InteractiveAnnotationHit(target, annotation, start, end)
+}
+
+/** Annotation values are decimal Rust u32 positions, never signed editor offsets. */
+private fun String.viewerMentionDocPos(): Long? =
+    toLongOrNull()?.takeIf { it in 0L..UInt.MAX_VALUE.toLong() }
+
+internal fun EditorEditText.annotationBounds(textLayout: Layout, start: Int, end: Int): Rect {
+    val firstLine = textLayout.getLineForOffset(start)
+    val lastLine = textLayout.getLineForOffset((end - 1).coerceAtLeast(start))
+    val bounds = Rect()
+    for (line in firstLine..lastLine) {
+        val segmentStart = maxOf(start, textLayout.getLineStart(line))
+        val segmentEnd = minOf(end, textLayout.getLineEnd(line))
+        val left = totalPaddingLeft + minOf(
+            textLayout.getPrimaryHorizontal(segmentStart),
+            textLayout.getPrimaryHorizontal(segmentEnd)
+        ) - scrollX
+        val right = totalPaddingLeft + maxOf(
+            textLayout.getPrimaryHorizontal(segmentStart),
+            textLayout.getPrimaryHorizontal(segmentEnd)
+        ) - scrollX
+        val lineBounds = Rect(
+            kotlin.math.floor(left.toDouble()).toInt(),
+            totalPaddingTop + textLayout.editorTextLineTop(line) - scrollY,
+            kotlin.math.ceil(right.toDouble()).toInt().coerceAtLeast(
+                kotlin.math.floor(left.toDouble()).toInt() + 1
+            ),
+            totalPaddingTop + textLayout.editorTextLineBottom(line) - scrollY
+        )
+        if (bounds.isEmpty) bounds.set(lineBounds) else bounds.union(lineBounds)
+    }
+    return bounds
+}

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

@@ -0,0 +1,100 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.graphics.RectF
+import android.os.Build
+import android.util.AttributeSet
+import android.util.TypedValue
+import kotlin.math.abs
+
+internal fun EditorEditText.setEditorAccessibilityHintImpl(hint: CharSequence?) {
+    editorAccessibilityHint = hint
+}
+
+internal fun EditorEditText.nativeCursorDrawRectImpl(): RectF? {
+    if (isCollapsedAtomBoundarySelection(selectionStart, selectionEnd)) {
+        isCursorVisible = false
+        return null
+    }
+    val textLayout = layout ?: return null
+    val offset = selectionEnd.coerceIn(0, textLayout.text.length)
+    val bounds = CaretGeometry.verticalBounds(textLayout, offset, paint, textLayout.text)
+    // Match Android's cursor pixel snapping and viewport-edge clamping.
+    val horizontal = maxOf(0.5f, textLayout.getPrimaryHorizontal(offset) - 0.5f)
+    val viewportWidth = width - compoundPaddingLeft - compoundPaddingRight
+    val left = when {
+        horizontal - scrollX >= viewportWidth - 1f -> scrollX + viewportWidth - caretWidthPx
+        abs(horizontal - scrollX) <= 1f -> scrollX.toFloat()
+        else -> horizontal.toInt().toFloat()
+    }
+    return RectF(left, bounds.top, left + caretWidthPx, bounds.bottom)
+}
+
+internal fun EditorEditText.resolveCaretWidth(attrs: AttributeSet?, defStyleAttr: Int): Float {
+    val attributes = context.obtainStyledAttributes(
+        attrs,
+        intArrayOf(android.R.attr.textCursorDrawable),
+        defStyleAttr,
+        0
+    )
+    try {
+        val drawable = attributes.getDrawable(0)
+        if (drawable != null) {
+            val padding = Rect()
+            drawable.getPadding(padding)
+            // Native cursor drawables include transparent horizontal insets.
+            val width = drawable.intrinsicWidth - padding.left - padding.right
+            if (width > 0) return width.toFloat()
+        }
+    } finally {
+        attributes.recycle()
+    }
+    return 2f * resources.displayMetrics.density
+}
+
+/**
+ * The native caret is tinted by the theme's `colorControlActivated`; resolve
+ * the same value so the replacement keeps the platform appearance, falling
+ * back to the text color when the attribute is not a color.
+ */
+internal fun EditorEditText.resolveCaretColor(): Int {
+    val resolved = TypedValue()
+    val found = context.theme.resolveAttribute(
+        android.R.attr.colorControlActivated,
+        resolved,
+        true
+    )
+    val isColor = resolved.type >= TypedValue.TYPE_FIRST_COLOR_INT &&
+        resolved.type <= TypedValue.TYPE_LAST_COLOR_INT
+    return if (found && isColor) resolved.data else currentTextColor
+}
+
+internal fun EditorEditText.clipLegacyNativeCursorTail(canvas: Canvas) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) return
+    if (!CaretGeometry.shouldRender(
+            isFocused,
+            hasWindowFocus(),
+            selectionStart,
+            selectionEnd
+        )
+    ) {
+        return
+    }
+    val textLayout = layout ?: return
+    val offset = selectionEnd.coerceIn(0, textLayout.text.length)
+    val bounds = CaretGeometry.verticalBounds(textLayout, offset, paint, textLayout.text)
+    val lineBottom = textLayout.editorTextLineBottom(textLayout.getLineForOffset(offset)).toFloat()
+    if (bounds.bottom >= lineBottom) return
+
+    val centerX = totalPaddingLeft + textLayout.getPrimaryHorizontal(offset)
+    val halfWidth = maxOf(caretWidthPx, 2f * resources.displayMetrics.density)
+    legacyCursorClipPaint.color = baseBackgroundColor
+    canvas.drawRect(
+        centerX - halfWidth,
+        totalPaddingTop + bounds.bottom,
+        centerX + halfWidth,
+        totalPaddingTop + lineBottom,
+        legacyCursorClipPaint
+    )
+}

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

@@ -0,0 +1,101 @@
+package com.apollohg.editor
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.view.accessibility.AccessibilityNodeInfo
+
+internal fun EditorEditText.isMutatingContextMenuItem(id: Int): Boolean =
+    id == android.R.id.paste ||
+        id == android.R.id.pasteAsPlainText ||
+        id == android.R.id.cut
+
+internal fun EditorEditText.prepareForExternalInteractionMutation(): Boolean =
+    commitExternalTextCompositionBeforeInteractionIfNeeded() &&
+        prepareForExternalEditorUpdate()
+
+internal fun EditorEditText.handlePaste(plainTextOnly: Boolean) {
+    val selectionRange = normalizedUtf16SelectionRange()
+    if (selectionRange != null &&
+        isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)
+    ) {
+        return
+    }
+    if (editorId == 0L) {
+        baseTextContextMenuItem(
+            if (plainTextOnly) android.R.id.pasteAsPlainText else android.R.id.paste
+        )
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+    if (!prepareForExternalInteractionMutation()) return
+
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+        ?: return
+    val clip = clipboard.primaryClip ?: return
+    if (clip.itemCount == 0) return
+
+    val item = clip.getItemAt(0)
+
+    val htmlText = item.htmlText
+    if (!plainTextOnly && htmlText != null) {
+        pasteHTML(htmlText)
+        return
+    }
+
+    val plainText = item.text?.toString() ?: item.coerceToText(context)?.toString()
+    if (plainText != null) {
+        pastePlainText(plainText)
+    }
+}
+
+internal fun EditorEditText.handleCut() {
+    if (editorId == 0L) {
+        baseTextContextMenuItem(android.R.id.cut)
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+    if (!prepareForExternalInteractionMutation()) return
+
+    val currentText = text?.toString() ?: return
+    val (selectionStart, selectionEnd) = normalizedUtf16SelectionRange(currentText) ?: return
+    if (selectionStart == selectionEnd) return
+
+    val (utf16Start, utf16End) = PositionBridge.snapRangeToScalarBoundaries(
+        selectionStart,
+        selectionEnd,
+        currentText
+    )
+    if (utf16Start >= utf16End) return
+
+    val selectedText = currentText.substring(utf16Start, utf16End)
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+    clipboard?.setPrimaryClip(ClipData.newPlainText(null, selectedText))
+
+    val scalarStart = PositionBridge.utf16ToScalar(utf16Start, currentText)
+    val scalarEnd = PositionBridge.utf16ToScalar(utf16End, currentText)
+    deleteRangeInRust(scalarStart, scalarEnd)
+}
+
+internal fun EditorEditText.handleAccessibilitySetText(arguments: android.os.Bundle?): Boolean {
+    val replacement = arguments
+        ?.getCharSequence(
+            android.view.accessibility.AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE
+        )
+        ?.toString()
+        ?: return false
+    if (editorId == 0L) {
+        return baseAccessibilityAction(
+            android.view.accessibility.AccessibilityNodeInfo.ACTION_SET_TEXT,
+            arguments
+        )
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return false
+    if (!prepareForExternalInteractionMutation()) return false
+
+    val currentText = text?.toString() ?: return false
+    val scalarStart = 0
+    val scalarEnd = currentText.codePointCount(0, currentText.length)
+    insertPlainTextRangeInRust(scalarStart, scalarEnd, replacement)
+    return true
+}

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

@@ -0,0 +1,220 @@
+package com.apollohg.editor
+
+import android.graphics.Typeface
+import android.text.Editable
+import android.text.Spanned
+import android.view.inputmethod.BaseInputConnection
+
+internal fun EditorEditText.authorizedUtf16RangeImpl(start: Int, end: Int): Pair<Int, Int> {
+    if (start == end) {
+        val snapped = PositionBridge.snapToScalarBoundary(
+            start,
+            lastAuthorizedText,
+            biasForward = true
+        )
+        return snapped to snapped
+    }
+    return PositionBridge.snapRangeToScalarBoundaries(start, end, lastAuthorizedText)
+}
+
+internal fun EditorEditText.isCurrentTextAuthorizedForEditorImpl(): Boolean =
+    (text?.toString() ?: "") == lastAuthorizedText
+
+internal fun EditorEditText.captureCompositionReplacementRangeIfNeededImpl() {
+    if (didInvalidateCompositionReplacementRange) return
+    if (compositionReplacementRange() != null) return
+    val (start, end) = normalizedUtf16SelectionRange() ?: return
+    setCompositionReplacementRange(start, end)
+}
+
+internal fun EditorEditText.setCompositionReplacementRangeImpl(start: Int, end: Int) {
+    if (didInvalidateCompositionReplacementRange) return
+    val replacementRange = authorizedUtf16Range(start, end)
+    composingReplacementStartUtf16 = replacementRange.first
+    composingReplacementEndUtf16 = replacementRange.second
+    composingReplacementAuthorizedTextRevision = lastAuthorizedTextRevision
+    didInvalidateCompositionReplacementRange = false
+}
+
+internal fun EditorEditText.compositionReplacementRangeImpl(): Pair<Int, Int>? {
+    val start = composingReplacementStartUtf16 ?: return null
+    val end = composingReplacementEndUtf16 ?: return null
+    if (composingReplacementAuthorizedTextRevision != lastAuthorizedTextRevision) {
+        clearCompositionTrackingForEditor()
+        didInvalidateCompositionReplacementRange = true
+        return null
+    }
+    return start to end
+}
+
+internal fun EditorEditText.authorizedSelectionForTransientInputRestore(
+    currentStart: Int,
+    currentEnd: Int
+): Pair<Int, Int>? {
+    compositionReplacementRange()?.let { return it }
+    return if (
+        currentStart >= 0 &&
+        currentEnd >= 0 &&
+        currentStart <= lastAuthorizedText.length &&
+        currentEnd <= lastAuthorizedText.length
+    ) {
+        currentStart to currentEnd
+    } else {
+        null
+    }
+}
+
+internal fun EditorEditText.consumeInvalidatedCompositionReplacementRangeForEditorImpl(): Boolean {
+    val invalidated = didInvalidateCompositionReplacementRange
+    didInvalidateCompositionReplacementRange = false
+    return invalidated
+}
+
+internal fun EditorEditText.hasInvalidatedCompositionReplacementRangeForEditorImpl(): Boolean =
+    didInvalidateCompositionReplacementRange
+
+internal fun EditorEditText.setComposingTextForEditorImpl(text: String?) {
+    composingText = text
+}
+
+internal fun EditorEditText.composingTextForEditorImpl(): String? = composingText
+
+internal fun EditorEditText.applyTransientComposingTextStyleForEditorImpl() {
+    val editable = text ?: return
+    removeTransientComposingTextStyleSpans(editable)
+
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0 || start >= end || end > editable.length) return
+
+    val textStyle = theme?.effectiveTextStyle("paragraph")
+    val resolvedTextSize =
+        textStyle?.fontSize?.times(resources.displayMetrics.density) ?: baseFontSize
+    val resolvedTextColor = textStyle?.color ?: baseTextColor
+
+    editable.setSpan(
+        TransientComposingSizeSpan(resolvedTextSize.toInt()),
+        start,
+        end,
+        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+    )
+    editable.setSpan(
+        TransientComposingColorSpan(resolvedTextColor),
+        start,
+        end,
+        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+    )
+
+    val typefaceStyle = textStyle?.typefaceStyle() ?: Typeface.NORMAL
+    if (typefaceStyle != Typeface.NORMAL) {
+        editable.setSpan(
+            TransientComposingStyleSpan(typefaceStyle),
+            start,
+            end,
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+    }
+
+    val fontFamily = textStyle?.fontFamily?.takeIf { it.isNotBlank() }
+    if (fontFamily != null) {
+        editable.setSpan(
+            TransientComposingTypefaceSpan(fontFamily),
+            start,
+            end,
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+    }
+    invalidateImeTextCoordinateMapperForEditor()
+}
+
+internal fun EditorEditText.removeTransientComposingTextStyleSpans(editable: Editable) {
+    editable
+        .getSpans(0, editable.length, TransientComposingTextStyleSpan::class.java)
+        .forEach(editable::removeSpan)
+    invalidateImeTextCoordinateMapperForEditor()
+}
+
+internal fun EditorEditText.composingTextFromVisibleReplacementForEditorImpl(): String? {
+    val (start, end) = compositionReplacementRange() ?: return null
+    val authorizedText = lastAuthorizedText
+    val currentText = text?.toString() ?: return null
+    if (start < 0 || end < start || end > authorizedText.length) return null
+
+    val authorizedPrefix = authorizedText.substring(0, start)
+    val authorizedSuffix = authorizedText.substring(end)
+    if (!currentText.startsWith(authorizedPrefix)) return null
+    if (!currentText.endsWith(authorizedSuffix)) return null
+
+    val replacementEnd = currentText.length - authorizedSuffix.length
+    if (replacementEnd < authorizedPrefix.length) return null
+    return currentText.substring(authorizedPrefix.length, replacementEnd)
+}
+
+internal fun EditorEditText.clearCompositionTrackingForEditorImpl() {
+    composingText = null
+    composingReplacementStartUtf16 = null
+    composingReplacementEndUtf16 = null
+    composingReplacementAuthorizedTextRevision = null
+}
+
+internal fun EditorEditText.hasCompositionTrackingForEditor(): Boolean = composingText != null ||
+    composingReplacementStartUtf16 != null ||
+    composingReplacementEndUtf16 != null ||
+    composingReplacementAuthorizedTextRevision != null
+
+internal fun EditorEditText.retireInputConnectionForEditor() {
+    recordImeTraceForTesting("retireInputConnection")
+    activeInputConnection?.clearCompositionTrackingForEditor()
+    invalidateInputConnectionsForEditor()
+    clearCompositionTrackingForEditor()
+    clearCompositionInvalidationForEditor()
+    clearNativeComposingSpans()
+}
+
+internal fun EditorEditText.retireInputConnectionForHostDetachImpl() {
+    retireInputConnectionForEditor()
+}
+
+internal fun EditorEditText.isEditorDestroyedForInputImpl(): Boolean =
+    editorId != 0L && NativeEditorViewRegistry.isDestroyed(editorId)
+
+internal fun EditorEditText.hasLiveEditor(): Boolean =
+    editorId != 0L && !isEditorDestroyedForInput()
+
+internal fun EditorEditText.discardTransientInputForDestroyedEditorIfNeeded(): Boolean {
+    if (!isEditorDestroyedForInput()) return false
+    cancelExternalTextCompositionForLifecycleIfNeeded()
+    retireInputConnectionForEditor()
+    clearNativeTextMutationAfterBlurWindow()
+    clearNativeTextMutationAdoptionSuppression()
+    return true
+}
+
+internal fun EditorEditText.discardTransientInputAndRestoreAuthorizedTextForEditor() {
+    cancelExternalTextCompositionForLifecycleIfNeeded()
+    retireInputConnectionForEditor()
+    clearNativeTextMutationAfterBlurWindow()
+    restoreAuthorizedTextSnapshotForEditor()
+    suppressNativeTextMutationAdoptionForCurrentRevision()
+}
+
+internal fun EditorEditText.restoreAuthorizedTextSnapshotForEditor() {
+    if ((text?.toString() ?: "") == lastAuthorizedText) return
+    val authorizedSnapshot = lastAuthorizedRenderedText ?: lastAuthorizedText
+    val wasApplyingRustState = isApplyingRustState
+    isApplyingRustState = true
+    beginBatchEdit()
+    try {
+        setText(authorizedSnapshot)
+    } finally {
+        endBatchEdit()
+        isApplyingRustState = wasApplyingRustState
+    }
+}
+
+internal fun EditorEditText.restartInputAfterCompositionInvalidationIfNeeded(
+    shouldRestart: Boolean
+) {
+    if (!shouldRestart) return
+    restartInputForEditorIfFocused("focused")
+}