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

package/android/src/sharedTest/java/com/apollohg/editor/NativePerformanceSupport.kt

@@ -1,482 +0,0 @@
-package com.openeditor.editor
-
-import android.graphics.Color
-import java.util.Locale
-import kotlin.math.sqrt
-import org.json.JSONArray
-import org.json.JSONObject
-import uniffi.editor_core.*
-
-internal data class TimingStats(
-    val name: String,
-    val samplesNanos: List<Long>
-) {
-    val averageMillis: Double = samplesNanos.average() / 1_000_000.0
-
-    private val relativeStdDev: Double = run {
-        if (samplesNanos.size <= 1) {
-            0.0
-        } else {
-            val average = samplesNanos.average()
-            val variance = samplesNanos
-                .map { sample -> (sample - average) * (sample - average) }
-                .average()
-            if (average == 0.0) 0.0 else sqrt(variance) / average
-        }
-    }
-
-    fun summaryString(tag: String = "NativePerformanceTest"): String {
-        val formattedSamples = samplesNanos.joinToString(", ") { sample ->
-            String.format(Locale.US, "%.3f", sample / 1_000_000.0)
-        }
-        return buildString {
-            append("[")
-            append(tag)
-            append("] ")
-            append(name)
-            append(" avg=")
-            append(String.format(Locale.US, "%.3fms", averageMillis))
-            append(" rsd=")
-            append(String.format(Locale.US, "%.3f%%", relativeStdDev * 100.0))
-            append(" samplesMs=[")
-            append(formattedSamples)
-            append("]")
-        }
-    }
-}
-
-internal data class ApplyUpdateTraceStats(
-    val name: String,
-    val traces: List<EditorEditText.ApplyUpdateTrace>
-) {
-    private fun average(selector: (EditorEditText.ApplyUpdateTrace) -> Long): Double =
-        if (traces.isEmpty()) 0.0 else traces.map(selector).average() / 1_000_000.0
-
-    fun summaryString(tag: String = "NativePerformanceTest"): String {
-        return buildString {
-            append("[")
-            append(tag)
-            append("] ")
-            append(name)
-            append(" avgMs={")
-            append("parse=")
-            append(String.format(Locale.US, "%.3f", average { it.parseNanos }))
-            append(", resolveBlocks=")
-            append(String.format(Locale.US, "%.3f", average { it.resolveRenderBlocksNanos }))
-            append(", patchEligibility=")
-            append(String.format(Locale.US, "%.3f", average { it.patchEligibilityNanos }))
-            append(", buildRender=")
-            append(String.format(Locale.US, "%.3f", average { it.buildRenderNanos }))
-            append(", applyRender=")
-            append(String.format(Locale.US, "%.3f", average { it.applyRenderNanos }))
-            append(", selection=")
-            append(String.format(Locale.US, "%.3f", average { it.selectionNanos }))
-            append(", postApply=")
-            append(String.format(Locale.US, "%.3f", average { it.postApplyNanos }))
-            append(", total=")
-            append(String.format(Locale.US, "%.3f", average { it.totalNanos }))
-            append("} patchUsage=")
-            append(traces.count { it.usedPatch })
-            append("/")
-            append(traces.size)
-            append(" skippedRender=")
-            append(traces.count { it.skippedRender })
-            append("/")
-            append(traces.size)
-        }
-    }
-}
-
-internal object NativePerformanceFixtureFactory {
-    private const val blockCount = 96
-    private const val paragraphCharacterCount = 180
-    private const val patchInsertIndex = 24
-
-    fun largeRenderJson(): String = largeRenderElements().toString()
-
-    fun largeDocumentJson(): String = JSONObject()
-        .put("type", "doc")
-        .put("content", largeDocumentContent())
-        .toString()
-
-    fun largeUpdateJson(): String {
-        val renderBlocks = largeRenderBlocks()
-        return JSONObject()
-            .put("renderBlocks", renderBlocks)
-            .toString()
-    }
-
-    fun largePatchedUpdateJson(): String {
-        val originalBlocks = largeRenderBlocks()
-        val insertedBlock = emptyParagraphRenderBlock()
-        val patchedBlocks = JSONArray()
-        for (index in 0 until originalBlocks.length()) {
-            if (index == patchInsertIndex) {
-                patchedBlocks.put(insertedBlock)
-            }
-            patchedBlocks.put(cloneJsonArray(originalBlocks.optJSONArray(index) ?: JSONArray()))
-        }
-        if (patchInsertIndex >= originalBlocks.length()) {
-            patchedBlocks.put(insertedBlock)
-        }
-
-        val startIndex = if (patchInsertIndex > 0) patchInsertIndex - 1 else 0
-        val oldDeleteCount = when {
-            originalBlocks.length() == 0 -> 0
-            patchInsertIndex == 0 -> minOf(1, originalBlocks.length())
-            patchInsertIndex >= originalBlocks.length() -> 1
-            else -> 2
-        }
-        val patchBlocks = JSONArray()
-        for (index in startIndex until minOf(patchedBlocks.length(), startIndex + oldDeleteCount + 1)) {
-            patchBlocks.put(cloneJsonArray(patchedBlocks.optJSONArray(index) ?: JSONArray()))
-        }
-
-        return JSONObject()
-            .put(
-                "renderPatch",
-                JSONObject()
-                    .put("startIndex", startIndex)
-                    .put("deleteCount", oldDeleteCount)
-                    .put("renderBlocks", patchBlocks)
-            )
-            .toString()
-    }
-
-    fun loadLargeDocumentIntoEditor(editorId: ULong): String {
-        editorSetJson(editorId, largeDocumentJson())
-        return editorGetCurrentState(editorId)
-    }
-
-    fun remoteSelections(
-        totalScalar: Int,
-        peerCount: Int = 6,
-        selectionWidth: Int = 0
-    ): List<RemoteSelectionDecoration> {
-        val upperBound = maxOf(1, totalScalar - 1)
-        val colors = listOf(
-            Color.parseColor("#007AFF"),
-            Color.parseColor("#34C759"),
-            Color.parseColor("#FF9500"),
-            Color.parseColor("#FF2D55"),
-            Color.parseColor("#AF52DE"),
-            Color.parseColor("#30B0C7"),
-        )
-
-        return evenlySpacedValues(1, upperBound, peerCount)
-            .mapIndexed { index, scalar ->
-                val head = if (selectionWidth > 0 && index % 2 == 1) {
-                    minOf(upperBound, scalar + selectionWidth)
-                } else {
-                    scalar
-                }
-                RemoteSelectionDecoration(
-                    clientId = index + 1,
-                    anchor = scalar,
-                    head = head,
-                    color = colors[index % colors.size],
-                    name = "Peer ${index + 1}",
-                    isFocused = true
-                )
-            }
-    }
-
-    fun typingCursorOffset(renderedText: CharSequence): Int =
-        selectionScrubOffsets(renderedText, points = 1).firstOrNull() ?: 0
-
-    fun selectionScrubOffsets(renderedText: CharSequence, points: Int): List<Int> {
-        val candidates = renderedText
-            .mapIndexedNotNull { index, char ->
-                when (char) {
-                    '\uFFFC', '\u200B', '\n', '\r' -> null
-                    else -> index
-                }
-            }
-
-        if (candidates.isEmpty()) {
-            return listOf(0)
-        }
-
-        return evenlySpacedValues(0, candidates.lastIndex, points).map { candidates[it] }
-    }
-
-    private fun largeDocumentContent(): JSONArray {
-        val content = JSONArray()
-        content.put(
-            JSONObject()
-                .put("type", "h1")
-                .put("content", JSONArray().put(textNode(textFragment(seed = 10_000, minCharacterCount = 40))))
-        )
-
-        for (index in 0 until blockCount) {
-            if (index > 0 && index % 18 == 0) {
-                content.put(JSONObject().put("type", "horizontalRule"))
-            }
-
-            when {
-                index % 12 == 5 -> {
-                    content.put(
-                        JSONObject()
-                            .put("type", "blockquote")
-                            .put(
-                                "content",
-                                JSONArray().put(
-                                    JSONObject()
-                                        .put("type", "paragraph")
-                                        .put(
-                                            "content",
-                                            richInlineDocContent(
-                                                seed = index,
-                                                totalCharacters = paragraphCharacterCount
-                                            )
-                                        )
-                                )
-                            )
-                    )
-                }
-
-                index % 9 == 3 -> {
-                    content.put(
-                        JSONObject()
-                            .put("type", "h2")
-                            .put(
-                                "content",
-                                JSONArray().put(
-                                    textNode(
-                                        textFragment(seed = index + 2_000, minCharacterCount = 72)
-                                    )
-                                )
-                            )
-                    )
-                }
-
-                else -> {
-                    content.put(
-                        JSONObject()
-                            .put("type", "paragraph")
-                            .put(
-                                "content",
-                                richInlineDocContent(
-                                    seed = index,
-                                    totalCharacters = paragraphCharacterCount
-                                )
-                            )
-                    )
-                }
-            }
-        }
-
-        return content
-    }
-
-    private fun richInlineDocContent(seed: Int, totalCharacters: Int): JSONArray {
-        val text = textFragment(seed = seed, minCharacterCount = totalCharacters)
-        val cutA = text.length / 4
-        val cutB = text.length / 2
-        val cutC = (text.length * 3) / 4
-
-        val content = JSONArray()
-        appendTextNode(content, text.substring(0, cutA))
-        appendTextNode(content, text.substring(cutA, cutB), JSONArray().put("bold"))
-        appendTextNode(content, text.substring(cutB, cutC), JSONArray().put("italic"))
-        appendTextNode(
-            content,
-            text.substring(cutC),
-            JSONArray().put(
-                JSONObject()
-                    .put("type", "link")
-                    .put(
-                        "attrs",
-                        JSONObject()
-                            .put("href", "https://example.com/item/$seed")
-                            .put("target", "_blank")
-                            .put("rel", "noopener noreferrer nofollow")
-                            .put("class", JSONObject.NULL)
-                            .put("title", JSONObject.NULL)
-                    )
-            )
-        )
-        return content
-    }
-
-    private fun appendTextNode(content: JSONArray, text: String, marks: JSONArray? = null) {
-        if (text.isEmpty()) return
-        val node = textNode(text)
-        if (marks != null && marks.length() > 0) {
-            node.put("marks", marks)
-        }
-        content.put(node)
-    }
-
-    private fun textNode(text: String): JSONObject =
-        JSONObject()
-            .put("type", "text")
-            .put("text", text)
-
-    private fun evenlySpacedValues(start: Int, endInclusive: Int, count: Int): List<Int> {
-        if (count <= 1 || endInclusive <= start) {
-            return listOf(start.coerceAtMost(endInclusive))
-        }
-
-        return (0 until count).map { index ->
-            start + (((endInclusive - start).toLong() * index.toLong()) / (count - 1).toLong()).toInt()
-        }
-    }
-
-    private fun largeRenderElements(): JSONArray = flattenRenderBlocks(largeRenderBlocks())
-
-    private fun largeRenderBlocks(): JSONArray {
-        val blocks = JSONArray()
-
-        blocks.put(
-            JSONArray().apply {
-                appendBlockStart(this, nodeType = "h1", depth = 0)
-                appendTextRun(this, textFragment(seed = 10_000, minCharacterCount = 40))
-                appendBlockEnd(this)
-            }
-        )
-
-        for (index in 0 until blockCount) {
-            if (index > 0 && index % 18 == 0) {
-                blocks.put(
-                    JSONArray().apply {
-                        appendHorizontalRule(this)
-                    }
-                )
-            }
-
-            blocks.put(
-                JSONArray().apply {
-                    when {
-                        index % 12 == 5 -> {
-                            appendBlockStart(this, nodeType = "blockquote", depth = 0)
-                            appendBlockStart(this, nodeType = "paragraph", depth = 1)
-                            appendRichInlineContent(
-                                this,
-                                seed = index,
-                                totalCharacters = paragraphCharacterCount
-                            )
-                            appendBlockEnd(this)
-                            appendBlockEnd(this)
-                        }
-
-                        index % 9 == 3 -> {
-                            appendBlockStart(this, nodeType = "h2", depth = 0)
-                            appendTextRun(
-                                this,
-                                textFragment(seed = index + 2_000, minCharacterCount = 72)
-                            )
-                            appendBlockEnd(this)
-                        }
-
-                        else -> {
-                            appendBlockStart(this, nodeType = "paragraph", depth = 0)
-                            appendRichInlineContent(
-                                this,
-                                seed = index,
-                                totalCharacters = paragraphCharacterCount
-                            )
-                            appendBlockEnd(this)
-                        }
-                    }
-                }
-            )
-        }
-
-        return blocks
-    }
-
-    private fun flattenRenderBlocks(blocks: JSONArray): JSONArray {
-        val flattened = JSONArray()
-        for (blockIndex in 0 until blocks.length()) {
-            val block = blocks.optJSONArray(blockIndex) ?: continue
-            for (elementIndex in 0 until block.length()) {
-                flattened.put(block.optJSONObject(elementIndex))
-            }
-        }
-        return flattened
-    }
-
-    private fun emptyParagraphRenderBlock(): JSONArray =
-        JSONArray().apply {
-            appendBlockStart(this, nodeType = "paragraph", depth = 0)
-            appendTextRun(this, "\u200B")
-            appendBlockEnd(this)
-        }
-
-    private fun cloneJsonArray(array: JSONArray): JSONArray = JSONArray(array.toString())
-
-    private fun appendRichInlineContent(
-        elements: JSONArray,
-        seed: Int,
-        totalCharacters: Int
-    ) {
-        val text = textFragment(seed = seed, minCharacterCount = totalCharacters)
-        val cutA = text.length / 4
-        val cutB = text.length / 2
-        val cutC = (text.length * 3) / 4
-
-        appendTextRun(elements, text.substring(0, cutA))
-        appendTextRun(elements, text.substring(cutA, cutB), marks = JSONArray().put("bold"))
-        appendTextRun(elements, text.substring(cutB, cutC), marks = JSONArray().put("italic"))
-        appendTextRun(
-            elements,
-            text.substring(cutC),
-            marks = JSONArray().put(
-                JSONObject()
-                    .put("type", "link")
-                    .put("href", "https://example.com/item/$seed")
-            )
-        )
-    }
-
-    private fun appendBlockStart(elements: JSONArray, nodeType: String, depth: Int) {
-        elements.put(
-            JSONObject()
-                .put("type", "blockStart")
-                .put("nodeType", nodeType)
-                .put("depth", depth)
-        )
-    }
-
-    private fun appendBlockEnd(elements: JSONArray) {
-        elements.put(JSONObject().put("type", "blockEnd"))
-    }
-
-    private fun appendHorizontalRule(elements: JSONArray) {
-        elements.put(
-            JSONObject()
-                .put("type", "voidBlock")
-                .put("nodeType", "horizontalRule")
-                .put("docPos", 0)
-        )
-    }
-
-    private fun appendTextRun(elements: JSONArray, text: String, marks: JSONArray = JSONArray()) {
-        elements.put(
-            JSONObject()
-                .put("type", "textRun")
-                .put("text", text)
-                .put("marks", marks)
-        )
-    }
-
-    private fun textFragment(seed: Int, minCharacterCount: Int): String {
-        val words = listOf(
-            "alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", "india",
-            "juliet", "kilo", "lima", "mike", "november", "oscar", "papa", "quebec", "romeo",
-            "sierra", "tango", "uniform", "victor", "whiskey", "xray", "yankee", "zulu",
-        )
-
-        val builder = StringBuilder()
-        var cursor = 0
-        while (builder.length < minCharacterCount) {
-            if (builder.isNotEmpty()) {
-                builder.append(' ')
-            }
-            builder.append(words[(seed + cursor) % words.size])
-            cursor += 1
-        }
-        return builder.substring(0, minCharacterCount)
-    }
-}

package/android/src/test/java/com/apollohg/editor/CaretGeometryTest.kt

@@ -1,137 +0,0 @@
-package com.openeditor.editor
-
-import android.graphics.Color
-import android.text.SpannableStringBuilder
-import android.text.Spanned
-import android.text.StaticLayout
-import android.text.TextPaint
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
-
-/**
- * Unit tests for [CaretGeometry] — the caret must clip to the rendered glyph
- * height and never extend into the paragraph gap that [ParagraphSpacerSpan]
- * adds below the line via inflated descent.
- */
-@RunWith(RobolectricTestRunner::class)
-@Config(sdk = [34])
-class CaretGeometryTest {
-
-    private fun layoutFor(text: CharSequence, paint: TextPaint): StaticLayout =
-        StaticLayout.Builder.obtain(text, 0, text.length, paint, WIDTH_PX).build()
-
-    @Test
-    fun `caret bottom clips paragraph spacer descent to the glyph height`() {
-        val text = SpannableStringBuilder("Hello\nWorld")
-        // Inter-block spacer inflates the descent of line 0 (the "Hello\n" line),
-        // exactly as RenderBridge applies it between blocks.
-        text.setSpan(
-            ParagraphSpacerSpan(spacingPx = SPACER_PX, baseFontSize = FONT_SIZE_PX, textColor = Color.BLACK),
-            5,
-            6,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        val paint = TextPaint().apply { textSize = FONT_SIZE_PX.toFloat() }
-        val layout = layoutFor(text, paint)
-        val line = 0
-
-        // Reproduction guard: the spacer really did inflate the layout descent.
-        assertTrue(
-            "ParagraphSpacerSpan should inflate layout descent in this reproduction",
-            layout.getLineDescent(line) > paint.fontMetrics.descent
-        )
-
-        val bounds = CaretGeometry.verticalBounds(layout, offset = 5, paint = paint)
-
-        assertEquals(
-            "caret top should be the line top",
-            layout.getLineTop(line).toFloat(),
-            bounds.top,
-            TOLERANCE_PX
-        )
-        assertEquals(
-            "caret bottom should be baseline + raw font descent, not the inflated getLineBottom",
-            layout.getLineBaseline(line) + paint.fontMetrics.descent,
-            bounds.bottom,
-            TOLERANCE_PX
-        )
-        assertTrue(
-            "caret must not extend into the paragraph gap below the line",
-            bounds.bottom < layout.getLineBottom(line)
-        )
-    }
-
-    @Test
-    fun `caret height is identical with and without the paragraph spacer`() {
-        val paint = TextPaint().apply { textSize = FONT_SIZE_PX.toFloat() }
-
-        val plain = layoutFor(SpannableStringBuilder("Hello\nWorld"), paint)
-
-        val spaced = SpannableStringBuilder("Hello\nWorld")
-        spaced.setSpan(
-            ParagraphSpacerSpan(spacingPx = SPACER_PX, baseFontSize = FONT_SIZE_PX, textColor = Color.BLACK),
-            5,
-            6,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-        )
-        val spacedLayout = layoutFor(spaced, paint)
-
-        // Sanity: the spacer changed the layout (line 1 sits lower).
-        assertTrue(
-            "spacer should push the following line down",
-            spacedLayout.getLineTop(1) > plain.getLineTop(1)
-        )
-
-        val plainBounds = CaretGeometry.verticalBounds(plain, offset = 5, paint = paint)
-        val spacedBounds = CaretGeometry.verticalBounds(spacedLayout, offset = 5, paint = paint)
-
-        assertEquals(
-            "caret top must not depend on the paragraph spacer",
-            plainBounds.top,
-            spacedBounds.top,
-            TOLERANCE_PX
-        )
-        assertEquals(
-            "caret height must be the rendered glyph height regardless of paragraph spacing",
-            plainBounds.bottom,
-            spacedBounds.bottom,
-            TOLERANCE_PX
-        )
-    }
-
-    @Test
-    fun `caret renders only when focused, window-focused, and selection collapsed`() {
-        assertTrue(
-            "collapsed caret in a focused field should render",
-            CaretGeometry.shouldRender(focused = true, windowFocused = true, selectionStart = 3, selectionEnd = 3)
-        )
-        assertFalse(
-            "no caret when the field is not focused",
-            CaretGeometry.shouldRender(focused = false, windowFocused = true, selectionStart = 3, selectionEnd = 3)
-        )
-        assertFalse(
-            "no caret when the window is not focused",
-            CaretGeometry.shouldRender(focused = true, windowFocused = false, selectionStart = 3, selectionEnd = 3)
-        )
-        assertFalse(
-            "no caret for a range selection (highlight shown instead)",
-            CaretGeometry.shouldRender(focused = true, windowFocused = true, selectionStart = 3, selectionEnd = 5)
-        )
-        assertFalse(
-            "no caret when there is no selection",
-            CaretGeometry.shouldRender(focused = true, windowFocused = true, selectionStart = -1, selectionEnd = -1)
-        )
-    }
-
-    private companion object {
-        const val WIDTH_PX = 200
-        const val FONT_SIZE_PX = 16
-        const val SPACER_PX = 40
-        const val TOLERANCE_PX = 0.01f
-    }
-}