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

package/android/src/androidTest/AndroidManifest.xml

@@ -1,8 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <application>
-        <activity
-            android:name="com.openeditor.editor.NativeEditorOutsideTapActivity"
-            android:exported="false"
-            android:theme="@style/Theme.AppCompat.Light.NoActionBar" />
-    </application>
-</manifest>

package/android/src/androidTest/java/com/apollohg/editor/MeasureHeightInstrumentedTest.kt

@@ -1,53 +0,0 @@
-package com.openeditor.editor
-
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-
-@RunWith(AndroidJUnit4::class)
-class MeasureHeightInstrumentedTest {
-
-    @Test
-    fun measureHeight_narrowerWidthProducesTallerResult() {
-        val longText = "word ".repeat(100)
-        val renderJSON = """[{"type":"blockStart","nodeType":"paragraph","depth":0},{"type":"textRun","text":"$longText"},{"type":"blockEnd"}]"""
-        val narrowHeight = RenderBridge.measureHeight(
-            json = renderJSON,
-            themeJson = null,
-            width = 100f,
-            density = 1f
-        )
-        val wideHeight = RenderBridge.measureHeight(
-            json = renderJSON,
-            themeJson = null,
-            width = 1000f,
-            density = 1f
-        )
-        assertTrue(
-            "Narrower width ($narrowHeight) should be taller than wider ($wideHeight)",
-            narrowHeight > wideHeight
-        )
-    }
-
-    @Test
-    fun measureHeight_largerFontProducesTallerResult() {
-        val renderJSON = """[{"type":"blockStart","nodeType":"paragraph","depth":0},{"type":"textRun","text":"Hello world"},{"type":"blockEnd"}]"""
-        val smallHeight = RenderBridge.measureHeight(
-            json = renderJSON,
-            themeJson = """{"text":{"fontSize":12}}""",
-            width = 375f,
-            density = 1f
-        )
-        val largeHeight = RenderBridge.measureHeight(
-            json = renderJSON,
-            themeJson = """{"text":{"fontSize":32}}""",
-            width = 375f,
-            density = 1f
-        )
-        assertTrue(
-            "Larger font ($largeHeight) should be taller than smaller ($smallHeight)",
-            largeHeight > smallHeight
-        )
-    }
-}

package/android/src/androidTest/java/com/apollohg/editor/NativeDeviceCollaborationInitialSyncTest.kt

@@ -1,241 +0,0 @@
-package com.openeditor.editor
-
-import android.app.Activity
-import android.app.Instrumentation
-import android.content.Context
-import android.graphics.Color
-import android.os.SystemClock
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import androidx.test.core.app.ActivityScenario
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.filters.LargeTest
-import androidx.test.platform.app.InstrumentationRegistry
-import expo.modules.core.ModuleRegistry
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.ModulesProvider
-import expo.modules.kotlin.modules.Module
-import java.lang.ref.WeakReference
-import java.util.concurrent.atomic.AtomicReference
-import org.json.JSONArray
-import org.json.JSONObject
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import uniffi.editor_core.editorCreate
-import uniffi.editor_core.editorDestroy
-import uniffi.editor_core.editorGetCurrentState
-import uniffi.editor_core.editorReplaceJson
-import uniffi.editor_core.editorSetJson
-
-@RunWith(AndroidJUnit4::class)
-@LargeTest
-class NativeDeviceCollaborationInitialSyncTest {
-    private val instrumentation: Instrumentation = InstrumentationRegistry.getInstrumentation()
-
-    @Test
-    fun propDrivenReplaceUpdateDisplaysRemoteDocumentWithoutTyping() {
-        ActivityScenario.launch(NativeEditorOutsideTapActivity::class.java).use { scenario ->
-            val editorRef = AtomicReference<NativeEditorExpoView>()
-            val editorId = editorCreate("{}").toLong()
-
-            try {
-                scenario.onActivity { activity ->
-                    editorRef.set(createMountedEditor(activity, editorId))
-                }
-                instrumentation.waitForIdleSync()
-                waitUntil("editor should bind initial id") {
-                    editorRef.get().richTextView.editorEditText.editorId == editorId
-                }
-
-                val updateJson = AtomicReference<String>()
-                scenario.onActivity {
-                    val update = editorReplaceJson(
-                        editorId.toULong(),
-                        documentJson("Remote replace sync")
-                    )
-                    updateJson.set(update)
-                    editorRef.get().setPendingEditorUpdateJson(update)
-                    editorRef.get().setPendingEditorUpdateEditorId(editorId)
-                    editorRef.get().setPendingEditorUpdateRevision(1)
-                    editorRef.get().applyPendingEditorUpdateIfNeeded()
-                }
-                instrumentation.waitForIdleSync()
-
-                waitUntil(
-                    "replace update should render remote document",
-                    detail = {
-                        "text=${editorRef.get().richTextView.editorEditText.text} " +
-                            "trace=${editorRef.get().richTextView.editorEditText.imeTraceSnapshotForTesting().joinToString("|")} " +
-                            "update=${updateJson.get()}"
-                    }
-                ) {
-                    editorRef.get().richTextView.editorEditText.text.toString() ==
-                        "Remote replace sync"
-                }
-            } finally {
-                editorDestroy(editorId.toULong())
-            }
-        }
-    }
-
-    @Test
-    fun propDrivenResetUpdateDisplaysRemoteDocumentWithoutTyping() {
-        ActivityScenario.launch(NativeEditorOutsideTapActivity::class.java).use { scenario ->
-            val editorRef = AtomicReference<NativeEditorExpoView>()
-            val editorId = editorCreate("{}").toLong()
-
-            try {
-                scenario.onActivity { activity ->
-                    editorRef.set(createMountedEditor(activity, editorId))
-                }
-                instrumentation.waitForIdleSync()
-                waitUntil("editor should bind initial id") {
-                    editorRef.get().richTextView.editorEditText.editorId == editorId
-                }
-
-                val updateJson = AtomicReference<String>()
-                scenario.onActivity {
-                    editorSetJson(editorId.toULong(), documentJson("Remote reset sync"))
-                    val update = editorGetCurrentState(editorId.toULong())
-                    updateJson.set(update)
-                    editorRef.get().setPendingEditorResetUpdateJson(update)
-                    editorRef.get().setPendingEditorResetUpdateEditorId(editorId)
-                    editorRef.get().setPendingEditorResetUpdateRevision(1)
-                    editorRef.get().applyPendingEditorResetUpdateIfNeeded()
-                }
-                instrumentation.waitForIdleSync()
-
-                waitUntil(
-                    "reset update should render remote document",
-                    detail = {
-                        "text=${editorRef.get().richTextView.editorEditText.text} " +
-                            "trace=${editorRef.get().richTextView.editorEditText.imeTraceSnapshotForTesting().joinToString("|")} " +
-                            "update=${updateJson.get()}"
-                    }
-                ) {
-                    editorRef.get().richTextView.editorEditText.text.toString() ==
-                        "Remote reset sync"
-                }
-            } finally {
-                editorDestroy(editorId.toULong())
-            }
-        }
-    }
-
-    private fun createMountedEditor(
-        activity: Activity,
-        editorId: Long
-    ): NativeEditorExpoView {
-        initializeSoLoaderIfAvailable(activity)
-        val root = FrameLayout(activity).apply {
-            setBackgroundColor(Color.WHITE)
-        }
-        val expoContext = testExpoContext(activity)
-        val editor = NativeEditorExpoView(expoContext.context, expoContext.appContext).apply {
-            clipToPadding = false
-            setShowToolbar(false)
-            onFocusChangeForTesting = {}
-            onAddonEventForTesting = {}
-            onEditorUpdateForTesting = {}
-            onEditorReadyForTesting = {}
-        }
-        root.addView(
-            editor,
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                dp(activity, 240)
-            ).apply {
-                topMargin = dp(activity, 48)
-                leftMargin = dp(activity, 16)
-                rightMargin = dp(activity, 16)
-            }
-        )
-        activity.setContentView(root)
-        editor.setEditorId(editorId)
-        return editor
-    }
-
-    private fun documentJson(text: String): String =
-        JSONObject()
-            .put("type", "doc")
-            .put(
-                "content",
-                JSONArray().put(
-                    JSONObject()
-                        .put("type", "paragraph")
-                        .put(
-                            "content",
-                            JSONArray().put(
-                                JSONObject()
-                                    .put("type", "text")
-                                    .put("text", text)
-                            )
-                        )
-                )
-            )
-            .toString()
-
-    private fun waitUntil(
-        description: String,
-        timeoutMs: Long = 4_000,
-        detail: () -> String = { "" },
-        condition: () -> Boolean
-    ) {
-        val start = SystemClock.uptimeMillis()
-        while (SystemClock.uptimeMillis() - start < timeoutMs) {
-            instrumentation.waitForIdleSync()
-            if (condition()) return
-            SystemClock.sleep(50)
-        }
-        assertTrue("$description\n${detail()}", condition())
-    }
-
-    private fun dp(context: Context, value: Int): Int =
-        (value * context.resources.displayMetrics.density).toInt()
-
-    private fun initializeSoLoaderIfAvailable(context: Context) {
-        try {
-            Class
-                .forName("com.facebook.soloader.SoLoader")
-                .getMethod(
-                    "init",
-                    Context::class.java,
-                    Boolean::class.javaPrimitiveType
-                )
-                .invoke(null, context, false)
-        } catch (_: Throwable) {
-            // Some test classpaths do not expose SoLoader directly; in that case the view can
-            // still be exercised as long as the React Native draw path does not require it.
-        }
-    }
-
-    private fun testExpoContext(activity: Activity): TestExpoContext {
-        val reactContext = Class
-            .forName("com.facebook.react.bridge.BridgeReactContext")
-            .getConstructor(Context::class.java)
-            .newInstance(activity) as Context
-
-        reactContext.javaClass
-            .getMethod("onHostResume", Activity::class.java)
-            .invoke(reactContext, activity)
-
-        val modulesProvider = object : ModulesProvider {
-            override fun getModulesList(): List<Class<out Module>> = emptyList()
-        }
-        val constructor = AppContext::class.java.constructors.first { constructor ->
-            constructor.parameterTypes.size == 3
-        }
-        val appContext = constructor.newInstance(
-            modulesProvider,
-            ModuleRegistry(emptyList(), emptyList()),
-            WeakReference(reactContext)
-        ) as AppContext
-        return TestExpoContext(reactContext, appContext)
-    }
-
-    private data class TestExpoContext(
-        val context: Context,
-        val appContext: AppContext
-    )
-}

package/android/src/androidTest/java/com/apollohg/editor/NativeDeviceImeRegressionTest.kt

@@ -1,338 +0,0 @@
-package com.openeditor.editor
-
-import android.app.Instrumentation
-import android.content.Context
-import android.text.Selection
-import android.view.inputmethod.BaseInputConnection
-import android.view.inputmethod.CompletionInfo
-import android.view.inputmethod.CorrectionInfo
-import android.view.inputmethod.EditorInfo
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.filters.LargeTest
-import androidx.test.platform.app.InstrumentationRegistry
-import java.util.concurrent.atomic.AtomicReference
-import org.json.JSONArray
-import org.json.JSONObject
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-
-@RunWith(AndroidJUnit4::class)
-@LargeTest
-class NativeDeviceImeRegressionTest {
-    private val instrumentation: Instrumentation = InstrumentationRegistry.getInstrumentation()
-    private val context = ApplicationProvider.getApplicationContext<Context>()
-
-    @Test
-    fun commitCompletionReplacesSelectedTextThroughRust() {
-        val result = runOnMainSyncWithResult {
-            val editText = createEditor("hel", selectionStart = 0, selectionEnd = 3)
-            var replacement: Replacement? = null
-            editText.onReplaceTextInRustForTesting = { scalarFrom, scalarTo, text ->
-                replacement = Replacement(scalarFrom, scalarTo, text)
-            }
-
-            val inputConnection = createInputConnection(editText)
-            assertTrue(inputConnection.commitCompletion(CompletionInfo(1L, 0, "hello")))
-
-            ImeResult(
-                replacement = replacement,
-                trace = editText.imeTraceSnapshotForTesting()
-            )
-        }
-
-        assertEquals(Replacement(0, 3, "hello"), result.replacement)
-        assertTraceContains(result.trace, "commitCompletion")
-    }
-
-    @Test
-    fun commitCorrectionCoversOldTextAndInferredTokenBoundaries() {
-        val explicit = runCorrectionScenario("teh", offset = 0, oldText = "teh", newText = "the")
-        assertEquals(Replacement(0, 3, "the"), explicit.replacement)
-        assertNull(explicit.inserted)
-        assertTraceContains(explicit.trace, "correctionExplicitApply")
-
-        val trailingPeriod = runCorrectionScenario("teh.", offset = 0, oldText = null, newText = "the")
-        assertEquals(Replacement(0, 3, "the"), trailingPeriod.replacement)
-        assertNull(trailingPeriod.inserted)
-        assertTraceContains(trailingPeriod.trace, "correctionInferredApply")
-
-        val punctuationOffset = runCorrectionScenario("teh.", offset = 3, oldText = null, newText = "the")
-        assertNull(punctuationOffset.replacement)
-        assertNull(punctuationOffset.inserted)
-        assertTraceContains(punctuationOffset.trace, "correctionInferredNoop")
-
-        val whitespaceOffset = runCorrectionScenario("teh ", offset = 3, oldText = null, newText = "the")
-        assertNull(whitespaceOffset.replacement)
-        assertNull(whitespaceOffset.inserted)
-        assertTraceContains(whitespaceOffset.trace, "correctionInferredNoop")
-
-        val hyphenated = runCorrectionScenario(
-            "dont-stop ",
-            offset = 4,
-            oldText = null,
-            newText = "don't-stop"
-        )
-        assertEquals(Replacement(0, 9, "don't-stop"), hyphenated.replacement)
-
-        val apostrophe = runCorrectionScenario("cant's ", offset = 4, oldText = null, newText = "can't")
-        assertEquals(Replacement(0, 6, "can't"), apostrophe.replacement)
-
-        val surrogate = runCorrectionScenario("te😀h ", offset = 3, oldText = null, newText = "term")
-        assertEquals(Replacement(0, 4, "term"), surrogate.replacement)
-    }
-
-    @Test
-    fun visibleCompositionCorrectionCommitDeleteAndPreflightAreRouted() {
-        val correction = runOnMainSyncWithResult {
-            val editText = createEditor("", selectionStart = 0, selectionEnd = 0)
-            var inserted: Inserted? = null
-            editText.onInsertTextInRustForTesting = { text, scalar ->
-                inserted = Inserted(text, scalar)
-                editText.applyUpdateJSON(renderUpdateJson(text), notifyListener = false)
-                editText.setSelection(text.length)
-            }
-
-            val inputConnection = createInputConnection(editText)
-            assertTrue(inputConnection.setComposingText("teh", 1))
-            assertTrue(inputConnection.commitCorrection(CorrectionInfo(0, "teh", "the")))
-
-            ImeResult(
-                inserted = inserted,
-                trace = editText.imeTraceSnapshotForTesting()
-            )
-        }
-
-        assertEquals(Inserted("the", 0), correction.inserted)
-        assertTraceContains(correction.trace, "setComposingText")
-        assertTraceContains(correction.trace, "commitCorrectionComposition")
-
-        val deletion = runOnMainSyncWithResult {
-            val editText = createEditor("", selectionStart = 0, selectionEnd = 0)
-            var inserted: Inserted? = null
-            editText.onInsertTextInRustForTesting = { text, scalar ->
-                inserted = Inserted(text, scalar)
-            }
-
-            val inputConnection = createInputConnection(editText)
-            assertTrue(inputConnection.setComposingText("abcd", 1))
-            assertTrue(inputConnection.deleteSurroundingText(1, 0))
-            assertTrue(inputConnection.finishComposingText())
-
-            ImeResult(
-                inserted = inserted,
-                trace = editText.imeTraceSnapshotForTesting()
-            )
-        }
-
-        assertEquals(Inserted("abc", 0), deletion.inserted)
-        assertTraceContains(deletion.trace, "finishComposingText")
-
-        val preflight = runOnMainSyncWithResult {
-            val editText = createEditor("", selectionStart = 0, selectionEnd = 0)
-            var inserted: Inserted? = null
-            editText.onInsertTextInRustForTesting = { text, scalar ->
-                inserted = Inserted(text, scalar)
-                editText.applyUpdateJSON(renderUpdateJson(text), notifyListener = false)
-            }
-
-            val inputConnection = createInputConnection(editText)
-            assertTrue(inputConnection.setComposingText("abc", 1))
-            val ready = editText.prepareForExternalEditorUpdate()
-
-            ImeResult(
-                inserted = inserted,
-                trace = editText.imeTraceSnapshotForTesting(),
-                ready = ready
-            )
-        }
-
-        assertTrue(preflight.ready)
-        assertEquals(Inserted("abc", 0), preflight.inserted)
-        assertTraceContains(preflight.trace, "finishComposingText")
-    }
-
-    @Test
-    fun nativeEditableAutocorrectBeforeAndAfterBlurIsAdoptedAndSelectionIsPreserved() {
-        val focused = runOnMainSyncWithResult {
-            val editText = createEditor("teh ", selectionStart = 4, selectionEnd = 4)
-            assertTrue(editText.requestFocus())
-            var replacement: Replacement? = null
-            editText.onReplaceTextInRustForTesting = { scalarFrom, scalarTo, text ->
-                replacement = Replacement(scalarFrom, scalarTo, text)
-            }
-
-            editText.text!!.replace(0, 3, "the")
-
-            ImeResult(
-                replacement = replacement,
-                selection = editText.selectionStart to editText.selectionEnd,
-                trace = editText.imeTraceSnapshotForTesting()
-            )
-        }
-
-        assertEquals(Replacement(1, 3, "he"), focused.replacement)
-        assertEquals(4 to 4, focused.selection)
-        assertTraceContains(focused.trace, "nativeMutationApply")
-
-        val afterBlur = runOnMainSyncWithResult {
-            val editText = createEditor("teh ", selectionStart = 4, selectionEnd = 4)
-            assertTrue(editText.requestFocus())
-            var replacement: Replacement? = null
-            editText.onReplaceTextInRustForTesting = { scalarFrom, scalarTo, text ->
-                replacement = Replacement(scalarFrom, scalarTo, text)
-            }
-
-            editText.clearFocus()
-            editText.runWithTransientInputMutationGuard {
-                editText.text!!.replace(0, 3, "the")
-                BaseInputConnection.setComposingSpans(editText.text!!)
-                true
-            }
-            val ready = editText.prepareForExternalEditorUpdate()
-
-            ImeResult(
-                replacement = replacement,
-                selection = editText.selectionStart to editText.selectionEnd,
-                trace = editText.imeTraceSnapshotForTesting(),
-                ready = ready
-            )
-        }
-
-        assertTrue(afterBlur.ready)
-        assertEquals(Replacement(1, 3, "he"), afterBlur.replacement)
-        assertEquals(4 to 4, afterBlur.selection)
-        assertTraceContains(afterBlur.trace, "nativeMutationApply")
-    }
-
-    @Test
-    fun staleAndInvalidCorrectionsDoNotFallBackToInsertion() {
-        val stale = runCorrectionScenario("tah ", offset = 0, oldText = "teh", newText = "the")
-        assertNull(stale.replacement)
-        assertNull(stale.inserted)
-        assertTraceContains(stale.trace, "correctionExplicitNoop")
-
-        val invalidExplicit = runCorrectionScenario("teh ", offset = -1, oldText = "teh", newText = "the")
-        assertNull(invalidExplicit.replacement)
-        assertNull(invalidExplicit.inserted)
-        assertTraceContains(invalidExplicit.trace, "commitCorrectionResult")
-
-        val invalidInferred = runCorrectionScenario("teh ", offset = -1, oldText = null, newText = "the")
-        assertNull(invalidInferred.replacement)
-        assertNull(invalidInferred.inserted)
-        assertTraceContains(invalidInferred.trace, "correctionInferredNoop")
-    }
-
-    private fun runCorrectionScenario(
-        text: String,
-        offset: Int,
-        oldText: String?,
-        newText: String
-    ): ImeResult =
-        runOnMainSyncWithResult {
-            val editText = createEditor(text, selectionStart = text.length, selectionEnd = text.length)
-            var replacement: Replacement? = null
-            var inserted: Inserted? = null
-            editText.onReplaceTextInRustForTesting = { scalarFrom, scalarTo, replacementText ->
-                replacement = Replacement(scalarFrom, scalarTo, replacementText)
-            }
-            editText.onInsertTextInRustForTesting = { insertedText, scalar ->
-                inserted = Inserted(insertedText, scalar)
-            }
-
-            val inputConnection = createInputConnection(editText)
-            assertTrue(inputConnection.commitCorrection(CorrectionInfo(offset, oldText, newText)))
-
-            ImeResult(
-                replacement = replacement,
-                inserted = inserted,
-                trace = editText.imeTraceSnapshotForTesting()
-            )
-        }
-
-    private fun createEditor(
-        text: String,
-        selectionStart: Int,
-        selectionEnd: Int
-    ): EditorEditText =
-        EditorEditText(context).apply {
-            applyUpdateJSON(renderUpdateJson(text), notifyListener = false)
-            Selection.setSelection(this.text, selectionStart, selectionEnd)
-            onSetSelectionScalarInRustForTesting = { _, _ -> }
-            editorId = 1
-            clearImeTraceForTesting()
-        }
-
-    private fun createInputConnection(editText: EditorEditText): EditorInputConnection {
-        val inputConnection = editText.onCreateInputConnection(EditorInfo())
-        assertTrue(inputConnection is EditorInputConnection)
-        return inputConnection as EditorInputConnection
-    }
-
-    private fun assertTraceContains(trace: List<String>, event: String) {
-        assertTrue(
-            "expected IME trace to contain $event but was $trace",
-            trace.any { it.startsWith(event) }
-        )
-    }
-
-    private fun renderUpdateJson(text: String): String =
-        JSONObject()
-            .put(
-                "renderBlocks",
-                JSONArray().put(
-                    JSONArray()
-                        .put(
-                            JSONObject()
-                                .put("type", "blockStart")
-                                .put("nodeType", "paragraph")
-                                .put("depth", 0)
-                        )
-                        .put(
-                            JSONObject()
-                                .put("type", "textRun")
-                                .put("text", text)
-                                .put("marks", JSONArray())
-                        )
-                        .put(JSONObject().put("type", "blockEnd"))
-                )
-            )
-            .toString()
-
-    @Suppress("UNCHECKED_CAST")
-    private fun <T> runOnMainSyncWithResult(block: () -> T): T {
-        val result = AtomicReference<Any?>()
-        val error = AtomicReference<Throwable?>()
-        instrumentation.runOnMainSync {
-            try {
-                result.set(block())
-            } catch (throwable: Throwable) {
-                error.set(throwable)
-            }
-        }
-        error.get()?.let { throw it }
-        return result.get() as T
-    }
-
-    private data class Replacement(
-        val scalarFrom: Int,
-        val scalarTo: Int,
-        val text: String
-    )
-
-    private data class Inserted(
-        val text: String,
-        val scalar: Int
-    )
-
-    private data class ImeResult(
-        val replacement: Replacement? = null,
-        val inserted: Inserted? = null,
-        val selection: Pair<Int, Int> = 0 to 0,
-        val trace: List<String> = emptyList(),
-        val ready: Boolean = false
-    )
-}