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

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

@@ -0,0 +1,113 @@
+package com.apollohg.editor
+
+import android.text.style.AbsoluteSizeSpan
+import android.text.style.ForegroundColorSpan
+import android.text.style.StyleSpan
+import android.text.style.TypefaceSpan
+
+internal data class HardwareKeyEventSignature(
+    val keyCode: Int,
+    val downTime: Long,
+    val repeatCount: Int
+)
+
+internal data class ParsedRenderPatch(
+    val baseDocumentVersion: String?,
+    val startIndex: Int,
+    val deleteCount: Int,
+    val renderBlocks: org.json.JSONArray
+)
+
+internal data class RenderReplaceRange(val start: Int, val endExclusive: Int)
+
+internal data class ParagraphSpanSnapshot(
+    val span: Any,
+    val start: Int,
+    val end: Int,
+    val flags: Int
+)
+
+internal data class PatchApplyTrace(
+    val applied: Boolean,
+    val eligibilityNanos: Long,
+    val buildRenderNanos: Long,
+    val applyRenderNanos: Long
+)
+
+internal data class ImageSelectionRange(val start: Int, val end: Int)
+
+internal data class LogicalSelectionSnapshot(
+    val scalarAnchor: Int,
+    val scalarHead: Int,
+    val utf16Anchor: Int,
+    val utf16Head: Int,
+    val documentVersion: String?
+)
+
+internal data class ImageSpanHit(val span: BlockImageSpan, val start: Int, val end: Int)
+
+internal data class ImageGesture(
+    val target: BlockImageSpan,
+    val pointerId: Int,
+    val downX: Float,
+    val downY: Float
+)
+
+internal data class LocalTextDrag(
+    val scalarFrom: Int,
+    val scalarTo: Int,
+    val documentVersion: String?,
+    val editorId: Long
+)
+
+internal data class NativeTextMutation(
+    val scalarFrom: Int,
+    val scalarTo: Int,
+    val replacementText: String,
+    val resultingText: String,
+    val replacementStartUtf16: Int,
+    val replacementEndUtf16: Int,
+    val selectionScalarAnchor: Int?,
+    val selectionScalarHead: Int?
+)
+
+internal data class NativeTextMutationAfterBlurWindow(
+    val editorId: Long,
+    val authorizedTextRevision: Long,
+    val deadlineMs: Long,
+    var didAdoptMutation: Boolean = false
+)
+
+internal data class NativeTextMutationAdoptionSuppression(
+    val editorId: Long,
+    val authorizedTextRevision: Long
+)
+
+internal data class ExternalTextCompositionState(
+    val sessionId: String,
+    var latestText: String,
+    val replacementStartUtf16: Int,
+    val replacementEndUtf16: Int,
+    val startingAuthorizedText: String,
+    val startingAuthorizedRenderedText: CharSequence?
+)
+
+internal interface TransientComposingTextStyleSpan
+
+internal class TransientComposingSizeSpan(sizePx: Int) :
+    AbsoluteSizeSpan(sizePx, false),
+    TransientComposingTextStyleSpan
+
+internal class TransientComposingColorSpan(color: Int) :
+    ForegroundColorSpan(color),
+    TransientComposingTextStyleSpan
+
+internal class TransientComposingTypefaceSpan(family: String) :
+    TypefaceSpan(family),
+    TransientComposingTextStyleSpan
+
+internal class TransientComposingStyleSpan(style: Int) :
+    StyleSpan(style),
+    TransientComposingTextStyleSpan
+
+internal data class OptimisticInlineSpan(val span: Any, val flags: Int)

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

@@ -0,0 +1,92 @@
+package com.apollohg.editor
+
+import android.text.Spanned
+import android.view.MotionEvent
+import com.apollohg.editor.EditorEditText.Companion.MARKER_TAP_HORIZONTAL_SLOP_DP
+
+/**
+ * Task-marker taps are recognized as a paired DOWN+UP on the same marker
+ * within touch slop. DOWN is never consumed (so scrolls and selection
+ * gestures that start on a checkbox keep working); only the matching UP
+ * is consumed.
+ */
+internal fun EditorEditText.handleTaskListMarkerTap(event: MotionEvent): Boolean {
+    when (event.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+            pendingTaskMarkerDownScalar = taskListMarkerScalarHitAt(event.x, event.y)
+            pendingTaskMarkerDownX = event.x
+            pendingTaskMarkerDownY = event.y
+            return false
+        }
+
+        MotionEvent.ACTION_MOVE -> {
+            if (pendingTaskMarkerDownScalar != null && !withinTouchSlop(event)) {
+                pendingTaskMarkerDownScalar = null
+            }
+            return false
+        }
+
+        MotionEvent.ACTION_UP -> {
+            val downScalar = pendingTaskMarkerDownScalar ?: return false
+            pendingTaskMarkerDownScalar = null
+            if (!withinTouchSlop(event)) return false
+            val upScalar = taskListMarkerScalarHitAt(event.x, event.y) ?: return false
+            if (upScalar != downScalar) return false
+            if (!commitExternalTextCompositionBeforeInteractionIfNeeded()) return true
+            val authoritativeScalar = taskListMarkerScalarHitAt(event.x, event.y) ?: return true
+            toggleTaskItemCheckedAtSelectionScalarInRust(
+                authoritativeScalar,
+                authoritativeScalar
+            )
+            performClick()
+            return true
+        }
+
+        MotionEvent.ACTION_CANCEL -> {
+            pendingTaskMarkerDownScalar = null
+            return false
+        }
+
+        else -> return false
+    }
+}
+
+internal fun EditorEditText.withinTouchSlop(event: MotionEvent): Boolean =
+    kotlin.math.abs(event.x - pendingTaskMarkerDownX) <= touchSlopPx &&
+        kotlin.math.abs(event.y - pendingTaskMarkerDownY) <= touchSlopPx
+
+internal fun EditorEditText.taskListMarkerScalarHitAt(x: Float, y: Float): Int? {
+    val spanned = text as? Spanned ?: return null
+    val textLayout = layout ?: return null
+    if (spanned.isEmpty()) return null
+
+    val localX = x + scrollX - totalPaddingLeft
+    val localY = y + scrollY - totalPaddingTop
+    if (localY < 0) return null
+
+    val line = textLayout.getLineForVertical(localY.toInt().coerceAtLeast(0))
+    val lineTop = textLayout.editorTextLineTop(line).toFloat()
+    val lineBottom = textLayout.editorTextLineBottom(line).toFloat()
+    if (localY < lineTop || localY > lineBottom) {
+        return null
+    }
+    val lineStart = textLayout.getLineStart(line).coerceIn(0, spanned.length)
+    val lineEnd = textLayout.getLineEnd(line).coerceIn(lineStart, spanned.length)
+    val markerEnd = renderedTaskListMarkerEnd(spanned, lineStart, lineEnd) ?: return null
+    val markerRight = textLayout.getPrimaryHorizontal(markerEnd).coerceAtLeast(
+        textLayout.getPrimaryHorizontal(lineStart)
+    ) + MARKER_TAP_HORIZONTAL_SLOP_DP * resources.displayMetrics.density
+    if (localX > markerRight) {
+        return null
+    }
+
+    // Confirmed hit: only now pay for the String conversion the
+    // PositionBridge scalar math requires.
+    val currentText = spanned.toString()
+    val snappedUtf16 = PositionBridge.snapToScalarBoundary(
+        lineStart,
+        currentText,
+        biasForward = true
+    )
+    return PositionBridge.utf16ToScalar(snappedUtf16, currentText)
+}

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

@@ -0,0 +1,327 @@
+package com.apollohg.editor
+
+import android.text.Editable
+import android.text.Selection
+import android.text.Spanned
+import android.text.style.AbsoluteSizeSpan
+import android.text.style.BackgroundColorSpan
+import android.text.style.ForegroundColorSpan
+import android.text.style.StrikethroughSpan
+import android.text.style.StyleSpan
+import android.text.style.UnderlineSpan
+
+/**
+ * Handle committed text from the IME (typed characters, autocomplete).
+ *
+ * Called by [EditorInputConnection.commitText]. Routes the text through
+ * the Rust editor instead of directly inserting into the EditText.
+ */
+internal fun EditorEditText.handleTextCommitImpl(text: String, newCursorPosition: Int = 1) {
+    val startedAt = System.nanoTime()
+    if (!isEditable) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=notEditable textLength=${text.length}"
+        )
+        return
+    }
+    if (isApplyingRustState) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=applyingRust textLength=${text.length}"
+        )
+        return
+    }
+    val selectionRange = normalizedUtf16SelectionRange()
+    if (selectionRange == null) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=noSelection textLength=${text.length}"
+        )
+        return
+    }
+    if (isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=atomBoundary textLength=${text.length}"
+        )
+        return
+    }
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        val (start, end) = selectionRange
+        editable.replace(start, end, text)
+        recordImeTraceForTesting(
+            "handleTextCommitDirect",
+            "textLength=${text.length} utf16Sel=$start..$end totalUs=${nanosToMicros(
+                System.nanoTime() - startedAt
+            )}"
+        )
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=destroyedEditor textLength=${text.length}"
+        )
+        return
+    }
+
+    if (text == "\n") {
+        recordImeTraceForTesting(
+            "handleTextCommit",
+            "route=return utf16Sel=${selectionRange.first}..${selectionRange.second}"
+        )
+        handleReturnKey()
+        recordImeTraceForTesting(
+            "handleTextCommitDone",
+            "route=return totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+        )
+        return
+    }
+
+    val currentText = this.text?.toString() ?: ""
+    val scalarSelectionRange = normalizedScalarSelectionRange(currentText)
+    if (scalarSelectionRange == null) {
+        recordImeTraceForTesting(
+            "handleTextCommitNoop",
+            "reason=noScalarSelection textLength=${text.length}"
+        )
+        return
+    }
+    val (scalarStart, scalarEnd) = scalarSelectionRange
+    val requestedCursor = requestedCursorScalar(
+        scalarStart,
+        scalarEnd,
+        currentText,
+        text,
+        newCursorPosition
+    )
+    recordImeTraceForTesting(
+        "handleTextCommit",
+        "textLength=${text.length} cursor=$newCursorPosition utf16Sel=${selectionRange.first}..${selectionRange.second} scalarSel=$scalarStart..$scalarEnd requestedCursor=$requestedCursor"
+    )
+    val didApplyOptimisticVisibleText = applyOptimisticPlainTextCommitIfPossible(
+        startUtf16 = selectionRange.first,
+        endUtf16 = selectionRange.second,
+        committedText = text,
+        newCursorPosition = newCursorPosition,
+        logicalCursorAfter = requestedCursor
+            ?: scalarStart + text.codePointCount(0, text.length)
+    )
+    if (didApplyOptimisticVisibleText) {
+        recordImeTraceForTesting(
+            "optimisticVisibleTextCommit",
+            "textLength=${text.length} utf16Sel=${selectionRange.first}..${selectionRange.second}"
+        )
+    }
+    insertPlainTextRangeInRust(
+        scalarStart,
+        scalarEnd,
+        text,
+        requestedCursorScalar = requestedCursor
+    )
+    recordImeTraceForTesting(
+        "handleTextCommitDone",
+        "textLength=${text.length} totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+    )
+}
+
+internal fun EditorEditText.applyOptimisticPlainTextCommitIfPossible(
+    startUtf16: Int,
+    endUtf16: Int,
+    committedText: String,
+    newCursorPosition: Int,
+    logicalCursorAfter: Int
+): Boolean {
+    if (newCursorPosition != 1) return false
+    if (startUtf16 != endUtf16) return false
+    if (committedText.isEmpty()) return false
+    if (committedText.codePointCount(0, committedText.length) != 1) return false
+    if (committedText.indexOf('\n') >= 0 || committedText.indexOf('\r') >= 0) return false
+    if (hasCompositionTrackingForEditor()) return false
+    val editable = text ?: return false
+    val currentText = editable.toString()
+    if (currentText != lastAuthorizedText) return false
+    if (startUtf16 < 0 || endUtf16 < startUtf16 || endUtf16 > editable.length) return false
+    val spanned = editable as? Spanned
+    if (spanned != null &&
+        spannedRangeContainsImageSpan(spanned, startUtf16, endUtf16)
+    ) {
+        return false
+    }
+
+    val inlineSpans = spanned?.let {
+        optimisticInlineSpansForInsertion(it, startUtf16)
+    }.orEmpty()
+    var didApply = false
+    runWithTransientInputMutationGuard {
+        editable.replace(startUtf16, endUtf16, committedText)
+        val insertedEnd = startUtf16 + committedText.length
+        applyOptimisticInlineSpans(editable, startUtf16, insertedEnd, inlineSpans)
+        rememberLogicalSelection(
+            scalarAnchor = logicalCursorAfter,
+            scalarHead = logicalCursorAfter,
+            utf16Anchor = insertedEnd,
+            utf16Head = insertedEnd
+        )
+        Selection.setSelection(editable, insertedEnd, insertedEnd)
+        didApply = true
+        true
+    }
+    if (didApply) {
+        pendingOptimisticRenderText = editable.toString()
+    }
+    return didApply
+}
+
+internal fun EditorEditText.optimisticInlineSpansForInsertion(
+    spanned: Spanned,
+    insertionStart: Int
+): List<OptimisticInlineSpan> {
+    if (spanned.isEmpty()) return emptyList()
+    val sourceIndex = when {
+        insertionStart > 0 -> insertionStart - 1
+        insertionStart < spanned.length -> insertionStart
+        else -> return emptyList()
+    }
+    val queryStart = sourceIndex.coerceIn(0, spanned.length - 1)
+    val queryEnd = (queryStart + 1).coerceAtMost(spanned.length)
+    val spans = mutableListOf<OptimisticInlineSpan>()
+    spanned.getSpans(queryStart, queryEnd, Any::class.java).forEach { span ->
+        if (spanned.getSpanStart(span) > queryStart || spanned.getSpanEnd(span) <= queryStart) {
+            return@forEach
+        }
+        cloneOptimisticInlineSpan(span)?.let { clone ->
+            spans.add(OptimisticInlineSpan(clone, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE))
+        }
+    }
+    return spans
+}
+
+internal fun EditorEditText.cloneOptimisticInlineSpan(span: Any): Any? = when (span) {
+    is ForegroundColorSpan -> ForegroundColorSpan(span.foregroundColor)
+    is BackgroundColorSpan -> BackgroundColorSpan(span.backgroundColor)
+    is AbsoluteSizeSpan -> AbsoluteSizeSpan(span.size, span.dip)
+    is StyleSpan -> StyleSpan(span.style)
+    is UnderlineSpan -> UnderlineSpan()
+    is StrikethroughSpan -> StrikethroughSpan()
+    else -> null
+}
+
+internal fun EditorEditText.applyOptimisticInlineSpans(
+    editable: Editable,
+    start: Int,
+    end: Int,
+    inlineSpans: List<OptimisticInlineSpan>
+) {
+    if (start >= end || end > editable.length) return
+    var hasColor = false
+    var hasSize = false
+    inlineSpans.forEach { spec ->
+        hasColor = hasColor || spec.span is ForegroundColorSpan
+        hasSize = hasSize || spec.span is AbsoluteSizeSpan
+        editable.setSpan(spec.span, start, end, spec.flags)
+    }
+    val textStyle = theme?.effectiveTextStyle("paragraph")
+    if (!hasColor) {
+        editable.setSpan(
+            ForegroundColorSpan(textStyle?.color ?: baseTextColor),
+            start,
+            end,
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+    }
+    if (!hasSize) {
+        val resolvedTextSize =
+            textStyle?.fontSize?.times(resources.displayMetrics.density) ?: baseFontSize
+        editable.setSpan(
+            AbsoluteSizeSpan(resolvedTextSize.toInt(), false),
+            start,
+            end,
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+    }
+}
+
+internal fun EditorEditText.applyVisibleCompositionCommitForPendingImeOperationForEditorImpl(
+    committedText: String,
+    replacementStartUtf16: Int,
+    replacementEndUtf16: Int,
+    newCursorPosition: Int
+): Boolean {
+    val editable = text ?: return false
+    val currentText = editable.toString()
+    val (startUtf16, endUtf16) = PositionBridge.snapRangeToScalarBoundaries(
+        replacementStartUtf16,
+        replacementEndUtf16,
+        currentText
+    )
+    if (startUtf16 > endUtf16 || endUtf16 > editable.length) return false
+    var didApply = false
+    runWithTransientInputMutationGuard {
+        editable.replace(startUtf16, endUtf16, committedText)
+        val insertedEnd = startUtf16 + committedText.length
+        val requestedCursor = when {
+            newCursorPosition > 0 -> insertedEnd + newCursorPosition - 1
+            newCursorPosition < 0 -> startUtf16 + newCursorPosition
+            else -> insertedEnd
+        }.coerceIn(0, editable.length)
+        Selection.setSelection(editable, requestedCursor, requestedCursor)
+        didApply = true
+        true
+    }
+    if (didApply) {
+        pendingOptimisticRenderText = null
+    }
+    return didApply
+}
+
+internal fun EditorEditText.commitVisibleCompositionMutationForPendingImeOperationImpl(
+    committedText: String,
+    newCursorPosition: Int
+): Boolean {
+    if (committedText.isEmpty()) return false
+    val currentText = text?.toString() ?: return false
+    val mutation = nativeTextMutationFromAuthorizedDiff(currentText) ?: return false
+    val tokenRange = committedTokenRangeAroundMutation(
+        currentText,
+        mutation.replacementStartUtf16,
+        mutation.replacementEndUtf16
+    ) ?: run {
+        recordImeTraceForTesting(
+            "alreadyVisibleCompositionNoop",
+            "reason=noToken committedLength=${committedText.length} visibleRange=${mutation.replacementStartUtf16}..${mutation.replacementEndUtf16}"
+        )
+        return false
+    }
+    val visibleToken = currentText.substring(tokenRange.first, tokenRange.second)
+    if (visibleToken != committedText) {
+        recordImeTraceForTesting(
+            "alreadyVisibleCompositionNoop",
+            "reason=tokenMismatch committedLength=${committedText.length} tokenLength=${visibleToken.length} visibleRange=${mutation.replacementStartUtf16}..${mutation.replacementEndUtf16}"
+        )
+        return false
+    }
+
+    val authorizedText = lastAuthorizedText
+    val requestedCursor = requestedCursorScalar(
+        mutation.scalarFrom,
+        mutation.scalarTo,
+        authorizedText,
+        mutation.replacementText,
+        newCursorPosition
+    )
+    recordImeTraceForTesting(
+        "alreadyVisibleCompositionApply",
+        "range=${mutation.scalarFrom}..${mutation.scalarTo} replacementLength=${mutation.replacementText.length} committedLength=${committedText.length} requestedCursor=$requestedCursor"
+    )
+    pendingOptimisticRenderText = null
+    insertPlainTextRangeInRust(
+        mutation.scalarFrom,
+        mutation.scalarTo,
+        mutation.replacementText,
+        requestedCursorScalar = requestedCursor
+    )
+    return true
+}

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

@@ -0,0 +1,84 @@
+package com.apollohg.editor
+
+internal fun EditorEditText.prepareForToolbarCommandWithExternalOwner(): Boolean {
+    if (!isEditable || isApplyingRustState || !hasLiveEditor()) return false
+    if (externalTextComposition == null) return true
+    return commitExternalTextCompositionBeforeInteractionIfNeeded() &&
+        prepareForExternalEditorUpdate()
+}
+
+internal fun EditorEditText.performToolbarToggleMarkImpl(markName: String) {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.toggleMark(markName, selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarToggleListImpl(listType: String, isActive: Boolean) {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        val update = if (isActive) {
+            driver.unwrapFromList(selection.first, selection.second)
+        } else {
+            driver.wrapInList(listType, selection.first, selection.second)
+        }
+        update?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarToggleBlockquoteImpl() {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.toggleBlockquote(selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarToggleHeadingImpl(level: Int) {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    if (level !in 1..6) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.toggleHeading(level, selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarIndentListItemImpl() {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.indentListItem(selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarOutdentListItemImpl() {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.outdentListItem(selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarInsertNodeImpl(nodeType: String) {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.insertNode(nodeType, selection.first, selection.second)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarUndoImpl() {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    v2Driver?.let { driver ->
+        driver.undo()?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.performToolbarRedoImpl() {
+    if (!prepareForToolbarCommandWithExternalOwner()) return
+    v2Driver?.let { driver ->
+        driver.redo()?.let { applyUpdateJSON(it) }
+    }
+}