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

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

@@ -0,0 +1,347 @@
+package com.apollohg.editor
+
+import android.text.Annotation
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import org.json.JSONObject
+
+internal fun EditorEditText.parseRenderPatch(raw: org.json.JSONObject?): ParsedRenderPatch? {
+    if (raw == null) return null
+    val renderBlocks = raw.optJSONArray("renderBlocks") ?: return null
+    val baseDocumentVersion = if (raw.has("baseDocumentVersion")) {
+        canonicalV2U64(raw.opt("baseDocumentVersion") as? String) ?: return null
+    } else {
+        null
+    }
+    return ParsedRenderPatch(
+        baseDocumentVersion = baseDocumentVersion,
+        startIndex = raw.optInt("startIndex", -1),
+        deleteCount = raw.optInt("deleteCount", -1),
+        renderBlocks = renderBlocks
+    ).takeIf { it.startIndex >= 0 && it.deleteCount >= 0 }
+}
+
+internal fun EditorEditText.patchMatchesCurrentRenderBlocks(
+    patch: ParsedRenderPatch,
+    updateDocumentVersion: String?
+): Boolean = if (patch.baseDocumentVersion == null) {
+    updateDocumentVersion == null && currentRenderBlocksDocumentVersion == null
+} else {
+    patch.baseDocumentVersion == currentRenderBlocksDocumentVersion
+}
+
+internal fun EditorEditText.retainCurrentRenderBlocks(
+    blocks: org.json.JSONArray?,
+    documentVersion: String?,
+    needFullApply: Boolean
+) {
+    currentRenderBlocksJson = blocks?.let(::cloneJsonArray)
+    currentRenderBlocksDocumentVersion = documentVersion.takeIf { blocks != null }
+    currentRenderBlocksNeedFullApply = blocks != null && needFullApply
+}
+
+internal fun EditorEditText.invalidateCurrentRenderBlocks() {
+    currentRenderBlocksJson = null
+    currentRenderBlocksDocumentVersion = null
+    currentRenderBlocksNeedFullApply = false
+}
+
+internal fun EditorEditText.recoverRenderPatchBaseMismatch(
+    notifyListener: Boolean,
+    refreshInputConnectionForExternalUpdate: Boolean
+): Boolean {
+    invalidateCurrentRenderBlocks()
+    if (recoveringRenderPatchBaseMismatch) return false
+    val adapter = v2Driver as? EditorV2Adapter ?: return false
+    val recovery = adapter.recoverNativeRender() ?: return false
+    recoveringRenderPatchBaseMismatch = true
+    return try {
+        applyUpdateJSON(
+            recovery,
+            notifyListener = notifyListener,
+            refreshInputConnectionForExternalUpdate = refreshInputConnectionForExternalUpdate
+        )
+    } finally {
+        recoveringRenderPatchBaseMismatch = false
+    }
+}
+
+internal fun EditorEditText.hasTopLevelChildMetadata(content: Spanned): Boolean =
+    content.getSpans(0, content.length, Annotation::class.java).any {
+        it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION
+    }
+
+internal fun EditorEditText.firstCharacterOffsetForTopLevelChildIndex(
+    content: Spanned,
+    index: Int
+): Int? {
+    val targetValue = index.toString()
+    return content
+        .getSpans(0, content.length, Annotation::class.java)
+        .asSequence()
+        .filter {
+            it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION &&
+                it.value == targetValue
+        }
+        .mapNotNull { span ->
+            val spanStart = content.getSpanStart(span)
+            val spanEnd = content.getSpanEnd(span)
+            if (spanStart < 0 || spanEnd <= spanStart) {
+                null
+            } else {
+                var candidate = spanStart
+                while (candidate < spanEnd && candidate < content.length) {
+                    when (content[candidate]) {
+                        '\n', '\r' -> {
+                            val isHardBreak = content.getSpans(
+                                candidate,
+                                candidate + 1,
+                                Annotation::class.java
+                            ).any {
+                                it.key == "nativeVoidNodeType" &&
+                                    EditorNodeTypes.isHardBreak(it.value) &&
+                                    content.getSpanStart(it) <= candidate &&
+                                    content.getSpanEnd(it) > candidate
+                            }
+                            if (isHardBreak) return@mapNotNull candidate
+                            candidate += 1
+                        }
+
+                        else -> return@mapNotNull candidate
+                    }
+                }
+                null
+            }
+        }
+        .minOrNull()
+}
+
+internal fun EditorEditText.replacementRangeForRenderPatch(
+    content: Spanned,
+    startIndex: Int,
+    deleteCount: Int
+): RenderReplaceRange? {
+    val start = firstCharacterOffsetForTopLevelChildIndex(content, startIndex)
+        ?: if (deleteCount == 0) content.length else return null
+    val endExclusive = firstCharacterOffsetForTopLevelChildIndex(content, startIndex + deleteCount)
+        ?: content.length
+    if (start > endExclusive) return null
+    return RenderReplaceRange(start = start, endExclusive = endExclusive)
+}
+
+internal fun EditorEditText.spannedRangeContainsImageSpan(
+    content: Spanned,
+    start: Int,
+    endExclusive: Int
+): Boolean {
+    if (start >= endExclusive) return false
+    return content.getSpans(start, endExclusive, BlockImageSpan::class.java).isNotEmpty()
+}
+
+internal fun EditorEditText.spannedContainsImageSpan(content: Spanned): Boolean =
+    spannedRangeContainsImageSpan(content, 0, content.length)
+
+internal fun EditorEditText.spannedRangeContainsUnstableAtom(
+    content: Spanned,
+    start: Int,
+    endExclusive: Int
+): Boolean {
+    if (start >= endExclusive) return false
+    return content.getSpans(start, endExclusive, AtomBlockSpan::class.java)
+        .any { !it.hasStableAtomId }
+}
+
+internal fun EditorEditText.spannedContainsUnstableAtom(content: Spanned): Boolean =
+    spannedRangeContainsUnstableAtom(content, 0, content.length)
+
+internal fun EditorEditText.buildPatchedSpannable(
+    patch: ParsedRenderPatch,
+    includeTrailingInterBlockSeparator: Boolean
+): android.text.SpannableStringBuilder = RenderBridge.buildSpannableFromBlocks(
+    patch.renderBlocks,
+    startIndex = patch.startIndex,
+    includeTrailingInterBlockSeparator = includeTrailingInterBlockSeparator,
+    baseFontSize = baseFontSize,
+    textColor = baseTextColor,
+    theme = theme,
+    density = resources.displayMetrics.density,
+    hostView = this,
+    atomConfiguration = atomRenderConfiguration,
+    reuseImages = false
+)
+
+internal fun EditorEditText.cloneJsonArray(array: org.json.JSONArray): org.json.JSONArray =
+    org.json.JSONArray().also { clone ->
+        for (index in 0 until array.length()) {
+            clone.put(array.opt(index))
+        }
+    }
+
+internal fun EditorEditText.normalizedJsonValue(value: Any?): Any? =
+    if (value === org.json.JSONObject.NULL) null else value
+
+internal fun EditorEditText.jsonValuesEqual(left: Any?, right: Any?): Boolean {
+    val normalizedLeft = normalizedJsonValue(left)
+    val normalizedRight = normalizedJsonValue(right)
+    if (normalizedLeft === normalizedRight) return true
+    if (normalizedLeft == null || normalizedRight == null) return false
+
+    if (normalizedLeft is org.json.JSONArray && normalizedRight is org.json.JSONArray) {
+        if (normalizedLeft.length() != normalizedRight.length()) return false
+        for (index in 0 until normalizedLeft.length()) {
+            if (!jsonValuesEqual(normalizedLeft.opt(index), normalizedRight.opt(index))) {
+                return false
+            }
+        }
+        return true
+    }
+
+    if (normalizedLeft is org.json.JSONObject && normalizedRight is org.json.JSONObject) {
+        if (normalizedLeft.length() != normalizedRight.length()) return false
+        val keys = normalizedLeft.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            if (!normalizedRight.has(key)) return false
+            if (!jsonValuesEqual(normalizedLeft.opt(key), normalizedRight.opt(key))) {
+                return false
+            }
+        }
+        return true
+    }
+
+    if (normalizedLeft is Number && normalizedRight is Number) {
+        return normalizedLeft.toDouble() == normalizedRight.toDouble()
+    }
+
+    return normalizedLeft == normalizedRight
+}
+
+internal fun EditorEditText.renderBlocksEqual(
+    current: org.json.JSONArray,
+    updated: org.json.JSONArray
+): Boolean {
+    if (current.length() != updated.length()) return false
+    for (index in 0 until current.length()) {
+        if (!jsonValuesEqual(current.opt(index), updated.opt(index))) {
+            return false
+        }
+    }
+    return true
+}
+
+internal fun EditorEditText.mergeRenderBlocks(
+    current: org.json.JSONArray,
+    patch: ParsedRenderPatch
+): org.json.JSONArray? {
+    if (
+        patch.startIndex < 0 ||
+        patch.deleteCount < 0 ||
+        patch.startIndex > current.length() ||
+        patch.startIndex + patch.deleteCount > current.length()
+    ) {
+        return null
+    }
+
+    return org.json.JSONArray().also { merged ->
+        for (index in 0 until patch.startIndex) {
+            merged.put(current.opt(index))
+        }
+        for (index in 0 until patch.renderBlocks.length()) {
+            merged.put(patch.renderBlocks.opt(index))
+        }
+        for (index in (patch.startIndex + patch.deleteCount) until current.length()) {
+            merged.put(current.opt(index))
+        }
+    }
+}
+
+internal fun EditorEditText.applyRenderPatchIfPossible(
+    patch: ParsedRenderPatch,
+    preserveInputConnectionForExternalUpdate: Boolean
+): PatchApplyTrace {
+    val eligibilityStartedAt = System.nanoTime()
+    if (patch.deleteCount == 0 && patch.renderBlocks.length() == 0) {
+        return PatchApplyTrace(
+            applied = true,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+    }
+    if (patch.deleteCount != patch.renderBlocks.length()) {
+        return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+    }
+    val content = text as? Spanned ?: return PatchApplyTrace(
+        applied = false,
+        eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+        buildRenderNanos = 0L,
+        applyRenderNanos = 0L
+    )
+    if (!hasTopLevelChildMetadata(content)) {
+        return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+    }
+
+    val replaceRange = replacementRangeForRenderPatch(content, patch.startIndex, patch.deleteCount)
+        ?: return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+    if (
+        spannedRangeContainsImageSpan(content, replaceRange.start, replaceRange.endExclusive) ||
+        spannedRangeContainsUnstableAtom(content, replaceRange.start, replaceRange.endExclusive)
+    ) {
+        return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+    }
+    val eligibilityNanos = System.nanoTime() - eligibilityStartedAt
+
+    val buildStartedAt = System.nanoTime()
+    val patchedSpannable = buildPatchedSpannable(
+        patch,
+        includeTrailingInterBlockSeparator = replaceRange.endExclusive < content.length
+    )
+    val buildRenderNanos = System.nanoTime() - buildStartedAt
+    if (
+        spannedContainsImageSpan(patchedSpannable) ||
+        spannedContainsUnstableAtom(patchedSpannable)
+    ) {
+        return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = eligibilityNanos,
+            buildRenderNanos = buildRenderNanos,
+            applyRenderNanos = 0L
+        )
+    }
+
+    val applyStartedAt = System.nanoTime()
+    applyRenderedSpannable(
+        spannable = patchedSpannable,
+        replaceRange = replaceRange,
+        replacedTopLevelStartIndex = patch.startIndex,
+        replacedTopLevelDeleteCount = patch.deleteCount,
+        usedPatch = true,
+        preserveInputConnectionForExternalUpdate = preserveInputConnectionForExternalUpdate
+    )
+    return PatchApplyTrace(
+        applied = true,
+        eligibilityNanos = eligibilityNanos,
+        buildRenderNanos = buildRenderNanos,
+        applyRenderNanos = System.nanoTime() - applyStartedAt
+    )
+}

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

@@ -0,0 +1,313 @@
+package com.apollohg.editor
+
+import android.text.Annotation
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+
+internal fun EditorEditText.applyFullRenderPreservingEditorState(
+    spannable: CharSequence,
+    restoreScrollAfterLayout: Boolean = false
+) {
+    val previousSelectionStart = selectionStart
+    val previousSelectionEnd = selectionEnd
+    val previousScrollX = scrollX
+    val previousScrollY = scrollY
+    applyRenderedSpannable(spannable, usedPatch = false)
+    if (previousSelectionStart >= 0 && previousSelectionEnd >= 0) {
+        val length = text?.length ?: 0
+        setSelection(
+            previousSelectionStart.coerceIn(0, length),
+            previousSelectionEnd.coerceIn(0, length)
+        )
+    }
+    preserveScrollPosition(previousScrollX, previousScrollY)
+    if (restoreScrollAfterLayout) {
+        post { preserveScrollPosition(previousScrollX, previousScrollY) }
+    }
+}
+
+internal fun EditorEditText.applyRenderedSpannable(
+    spannable: CharSequence,
+    replaceRange: RenderReplaceRange? = null,
+    replacedTopLevelStartIndex: Int? = null,
+    replacedTopLevelDeleteCount: Int = 0,
+    usedPatch: Boolean,
+    preserveInputConnectionForExternalUpdate: Boolean = false
+) {
+    onBeforeRenderRefresh?.invoke()
+    val startedAt = System.nanoTime()
+    val previousScrollX = scrollX
+    val previousScrollY = scrollY
+    val hadCompositionTracking = hasCompositionTrackingForEditor()
+    val styleOnly =
+        reuseImagesDuringThemeUpdate && replaceRange == null &&
+            text?.toString() == spannable.toString()
+    var shouldRestartInput = false
+    val mode = if (replaceRange != null) "replace" else "setText"
+    val precedingParagraphSpans = replaceRange
+        ?.let { paragraphSpansEndingAt(it.start) }
+        .orEmpty()
+    val followingParagraphSpans = replaceRange
+        ?.let { paragraphSpansStartingAt(it.endExclusive) }
+        .orEmpty()
+    val replacedImageSpans = (text as? Spanned)?.let { current ->
+        if (replaceRange == null) {
+            current.getSpans(0, current.length, BlockImageSpan::class.java).toList()
+        } else if (replaceRange.start < replaceRange.endExclusive) {
+            current.getSpans(
+                replaceRange.start,
+                replaceRange.endExclusive,
+                BlockImageSpan::class.java
+            ).filter { span ->
+                current.getSpanStart(span) < replaceRange.endExclusive &&
+                    current.getSpanEnd(span) > replaceRange.start
+            }
+        } else {
+            emptyList()
+        }
+    }.orEmpty()
+    val retainedImages = (spannable as? Spanned)?.getSpans(
+        0,
+        spannable.length,
+        BlockImageSpan::class.java
+    )?.toSet().orEmpty()
+    replacedImageSpans.filter { it !in retainedImages }.forEach(BlockImageSpan::close)
+    isApplyingRustState = true
+    beginBatchEdit()
+    try {
+        if (styleOnly && spannable is Spanned) {
+            editableText.getSpans(0, editableText.length, Any::class.java).filter {
+                editableText.getSpanFlags(it) and Spanned.SPAN_COMPOSING == 0 &&
+                    (
+                        it is android.text.style.CharacterStyle ||
+                            it is android.text.style.ParagraphStyle ||
+                            it is Annotation ||
+                            it is CodeBlockMetadataSpan
+                        )
+            }.forEach(editableText::removeSpan)
+            spannable.getSpans(0, spannable.length, Any::class.java).forEach {
+                editableText.setSpan(
+                    it,
+                    spannable.getSpanStart(it),
+                    spannable.getSpanEnd(it),
+                    spannable.getSpanFlags(it)
+                )
+            }
+        } else if (replaceRange != null) {
+            if (replacedTopLevelStartIndex != null) {
+                removeParagraphSpansOwnedByTopLevelRange(
+                    replacedTopLevelStartIndex,
+                    replacedTopLevelDeleteCount
+                )
+            }
+            editableText.getSpans(
+                replaceRange.start,
+                replaceRange.endExclusive,
+                Annotation::class.java
+            )
+                .filter {
+                    it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION &&
+                        editableText.getSpanStart(it) >= replaceRange.start &&
+                        editableText.getSpanEnd(it) <= replaceRange.endExclusive
+                }
+                .forEach(editableText::removeSpan)
+            editableText.replace(replaceRange.start, replaceRange.endExclusive, spannable)
+            precedingParagraphSpans.forEach { snapshot ->
+                editableText.setSpan(
+                    snapshot.span,
+                    snapshot.start,
+                    snapshot.end,
+                    snapshot.flags
+                )
+            }
+            val replacementDelta =
+                spannable.length - (replaceRange.endExclusive - replaceRange.start)
+            followingParagraphSpans.forEach { snapshot ->
+                editableText.setSpan(
+                    snapshot.span,
+                    snapshot.start + replacementDelta,
+                    snapshot.end + replacementDelta,
+                    snapshot.flags
+                )
+            }
+        } else {
+            setText(spannable)
+        }
+        lastAuthorizedText = text?.toString().orEmpty()
+        lastAuthorizedRenderedText = text?.let { SpannableStringBuilder(it) }
+        lastAuthorizedTextRevision += 1L
+        clearNativeTextMutationAdoptionSuppression()
+        if (styleOnly) {
+            // Existing composing spans remain attached to the same Editable.
+        } else if (hadCompositionTracking && preserveInputConnectionForExternalUpdate) {
+            clearInputStateForExternalReplacementPreservingConnection()
+            shouldRestartInput = true
+        } else if (hadCompositionTracking) {
+            retireInputConnectionForEditor()
+            shouldRestartInput = true
+        } else {
+            clearCompositionTrackingForEditor()
+        }
+        lastRenderAppliedPatchForTesting = usedPatch
+        clearNativeTextMutationAfterBlurWindow()
+    } finally {
+        endBatchEdit()
+        isApplyingRustState = false
+    }
+    recordImeTraceForTesting(
+        "applyRenderedSpannable",
+        "mode=$mode usedPatch=$usedPatch incomingLength=${spannable.length} " +
+            "replace=${replaceRange?.start}..${replaceRange?.endExclusive} " +
+            "hadComposition=$hadCompositionTracking restartInput=$shouldRestartInput " +
+            "applyUs=${nanosToMicros(
+                System.nanoTime() - startedAt
+            )} scroll=$previousScrollX,$previousScrollY->$scrollX,$scrollY laidOut=$isLaidOut"
+    )
+    invalidateRenderedContent()
+    restartInputAfterCompositionInvalidationIfNeeded(shouldRestartInput)
+    refreshCodeHighlighting()
+}
+
+internal fun EditorEditText.paragraphSpansEndingAt(offset: Int): List<ParagraphSpanSnapshot> =
+    editableText
+        .getSpans(0, editableText.length, Any::class.java)
+        .filter { span ->
+            editableText.getSpanEnd(span) == offset &&
+                editableText.getSpanFlags(span) and Spanned.SPAN_PARAGRAPH == Spanned.SPAN_PARAGRAPH
+        }
+        .map { span ->
+            ParagraphSpanSnapshot(
+                span = span,
+                start = editableText.getSpanStart(span),
+                end = editableText.getSpanEnd(span),
+                flags = editableText.getSpanFlags(span)
+            )
+        }
+
+internal fun EditorEditText.paragraphSpansStartingAt(offset: Int): List<ParagraphSpanSnapshot> =
+    editableText
+        .getSpans(0, editableText.length, Any::class.java)
+        .filter { span ->
+            editableText.getSpanStart(span) == offset &&
+                (
+                    editableText.getSpanFlags(span) and Spanned.SPAN_PARAGRAPH ==
+                        Spanned.SPAN_PARAGRAPH ||
+                        (
+                            span is Annotation &&
+                                span.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION
+                            )
+                    )
+        }
+        .map { span ->
+            ParagraphSpanSnapshot(
+                span = span,
+                start = editableText.getSpanStart(span),
+                end = editableText.getSpanEnd(span),
+                flags = editableText.getSpanFlags(span)
+            )
+        }
+
+internal fun EditorEditText.removeParagraphSpansOwnedByTopLevelRange(
+    startIndex: Int,
+    deleteCount: Int
+) {
+    if (deleteCount <= 0) return
+    val endIndex = startIndex + deleteCount
+    val topLevelAnnotations = editableText
+        .getSpans(0, editableText.length, Annotation::class.java)
+        .asSequence()
+        .filter { it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION }
+        .mapNotNull { annotation ->
+            val index = annotation.value.toIntOrNull() ?: return@mapNotNull null
+            Triple(
+                editableText.getSpanStart(annotation),
+                editableText.getSpanEnd(annotation),
+                index
+            )
+        }
+        .sortedBy { it.first }
+        .toList()
+
+    editableText
+        .getSpans(0, editableText.length, Any::class.java)
+        .filter { span ->
+            editableText.getSpanFlags(span) and Spanned.SPAN_PARAGRAPH == Spanned.SPAN_PARAGRAPH
+        }
+        .filter { span ->
+            val spanStart = editableText.getSpanStart(span)
+            val spanEnd = editableText.getSpanEnd(span)
+            val ownerIndex = topLevelAnnotations.firstOrNull { annotation ->
+                annotation.first < spanEnd && annotation.second > spanStart
+            }?.third
+            ownerIndex != null && ownerIndex >= startIndex && ownerIndex < endIndex
+        }
+        .forEach(editableText::removeSpan)
+}
+
+internal fun EditorEditText.invalidateRenderedContent() {
+    invalidate()
+    postInvalidateOnAnimation()
+}
+
+internal fun EditorEditText.authorizeVisibleTextForMatchedOptimisticRender(
+    spannable: CharSequence
+) {
+    val startedAt = System.nanoTime()
+    val visibleText = text?.toString().orEmpty()
+    lastAuthorizedText = visibleText
+    lastAuthorizedRenderedText = text?.let { SpannableStringBuilder(it) }
+        ?: SpannableStringBuilder(spannable)
+    lastAuthorizedTextRevision += 1L
+    clearNativeTextMutationAdoptionSuppression()
+    clearCompositionTrackingForEditor()
+    lastRenderAppliedPatchForTesting = false
+    clearNativeTextMutationAfterBlurWindow()
+    recordImeTraceForTesting(
+        "reuseOptimisticVisibleTextRender",
+        "textLength=${visibleText.length} " +
+            "applyUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+    )
+}
+
+/**
+ * Apply a render JSON string (just render elements, no update wrapper).
+ *
+ * Used for initial content loading (set_html / set_json return render
+ * elements directly, not wrapped in an EditorUpdate).
+ *
+ * @param renderJSON The JSON array string of render elements.
+ */
+internal fun EditorEditText.applyRenderJSONImpl(renderJSON: String) {
+    standaloneRenderJSON = renderJSON
+    cancelPendingImageLoads()
+    restartImageLoadsOnAttach = false
+    val startedAt = System.nanoTime()
+    val spannable = RenderBridge.buildSpannable(
+        renderJSON,
+        baseFontSize,
+        baseTextColor,
+        theme,
+        resources.displayMetrics.density,
+        this,
+        atomRenderConfiguration
+    )
+
+    val previousScrollX = scrollX
+    val previousScrollY = scrollY
+
+    explicitSelectedImageRange = null
+    invalidateCurrentRenderBlocks()
+    pendingOptimisticRenderText = null
+    applyRenderedSpannable(spannable, usedPatch = false)
+    onContentSizeMayChange?.invoke()
+    onSelectionOrContentMayChange?.invoke()
+    if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
+        requestLayout()
+    } else {
+        preserveScrollPosition(previousScrollX, previousScrollY)
+    }
+    recordImeTraceForTesting(
+        "applyRenderJSON",
+        "jsonLength=${renderJSON.length} totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+    )
+}