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

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

@@ -1,350 +0,0 @@
-package com.openeditor.editor
-
-import android.app.Instrumentation
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Color
-import android.os.Bundle
-import android.view.View
-import android.view.ViewGroup
-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.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import uniffi.editor_core.*
-
-@RunWith(AndroidJUnit4::class)
-@LargeTest
-class NativeDevicePerformanceTest {
-    private val instrumentation = InstrumentationRegistry.getInstrumentation()
-    private val context = ApplicationProvider.getApplicationContext<Context>()
-    private val baseFontSize = 16f
-    private val textColor = Color.BLACK
-
-    @Test
-    fun performance_renderBridgeLargeDocument() {
-        val renderJson = NativePerformanceFixtureFactory.largeRenderJson()
-
-        val stats = measureOperation("renderBridgeLargeDocument") {
-            val spannable = runOnMainSyncWithResult {
-                RenderBridge.buildSpannable(
-                    renderJson,
-                    baseFontSize,
-                    textColor,
-                    density = context.resources.displayMetrics.density
-                )
-            }
-
-            assertTrue("rendered spannable should not be empty", spannable.isNotEmpty())
-            if (spannable.isNotEmpty()) {
-                runOnMainSyncWithResult {
-                    spannable.getSpans(0, minOf(spannable.length, 1), Any::class.java)
-                }
-            }
-        }
-
-        reportStats(stats)
-        assertTrue("average render time should be positive", stats.averageMillis > 0.0)
-    }
-
-    @Test
-    fun performance_applyUpdateJsonLargeDocument() {
-        val updateJson = NativePerformanceFixtureFactory.largeUpdateJson()
-        val editText = runOnMainSyncWithResult {
-            EditorEditText(context).apply {
-                layoutParams = ViewGroup.LayoutParams(
-                    ViewGroup.LayoutParams.MATCH_PARENT,
-                    ViewGroup.LayoutParams.WRAP_CONTENT
-                )
-                setBaseStyle(baseFontSize, textColor, Color.WHITE)
-                applyUpdateJSON(updateJson, notifyListener = false)
-                layoutView(this, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-            }
-        }
-
-        val stats = measureOperation("applyUpdateJsonLargeDocument") {
-            runOnMainSyncWithResult {
-                editText.applyUpdateJSON(updateJson, notifyListener = false)
-                layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-            }
-
-            assertFalse("edit text should contain rendered content", editText.text.isNullOrEmpty())
-            assertNotNull("edit text should have a layout after applying update", editText.layout)
-        }
-
-        reportStats(stats)
-        assertTrue("average applyUpdateJSON time should be positive", stats.averageMillis > 0.0)
-    }
-
-    @Test
-    fun performance_applyRenderPatchLargeDocument() {
-        val initialUpdateJson = NativePerformanceFixtureFactory.largeUpdateJson()
-        val patchedUpdateJson = NativePerformanceFixtureFactory.largePatchedUpdateJson()
-        val editText = runOnMainSyncWithResult {
-            EditorEditText(context).apply {
-                layoutParams = ViewGroup.LayoutParams(
-                    ViewGroup.LayoutParams.MATCH_PARENT,
-                    ViewGroup.LayoutParams.WRAP_CONTENT
-                )
-                setBaseStyle(baseFontSize, textColor, Color.WHITE)
-            }
-        }
-
-        val stats = measureOperation(
-            name = "applyRenderPatchLargeDocument",
-            beforeEach = {
-                runOnMainSyncWithResult {
-                    editText.applyUpdateJSON(initialUpdateJson, notifyListener = false)
-                    layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-            }
-        ) {
-            runOnMainSyncWithResult {
-                editText.applyUpdateJSON(patchedUpdateJson, notifyListener = false)
-                layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-            }
-
-            assertFalse("edit text should contain rendered content", editText.text.isNullOrEmpty())
-        }
-
-        reportStats(stats)
-        assertTrue("average patch apply time should be positive", stats.averageMillis > 0.0)
-    }
-
-    @Test
-    fun performance_typingRoundTripLargeDocument() {
-        val editorId = editorCreate("{}").toLong()
-        try {
-            NativePerformanceFixtureFactory.loadLargeDocumentIntoEditor(editorId.toULong())
-            val editText = runOnMainSyncWithResult {
-                EditorEditText(context).apply {
-                    layoutParams = ViewGroup.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.WRAP_CONTENT
-                    )
-                    setBaseStyle(baseFontSize, textColor, Color.WHITE)
-                    bindEditor(editorId)
-                    layoutView(this, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-            }
-            val typingOffset = NativePerformanceFixtureFactory.typingCursorOffset(editText.text ?: "")
-
-            val stats = measureOperation("typingRoundTripLargeDocument") {
-                runOnMainSyncWithResult {
-                    editText.setSelection(typingOffset)
-                    editText.handleTextCommit("!")
-                    editText.handleDelete(1, 0)
-                    layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-
-                assertFalse("edit text should contain rendered content", editText.text.isNullOrEmpty())
-                assertNotNull("edit text should have a layout after typing", editText.layout)
-            }
-
-            reportStats(stats)
-            assertTrue("average typing time should be positive", stats.averageMillis > 0.0)
-        } finally {
-            editorDestroy(editorId.toULong())
-        }
-    }
-
-    @Test
-    fun performance_paragraphSplitRoundTripLargeDocument() {
-        val editorId = editorCreate("{}").toLong()
-        try {
-            val largeDocumentJson = NativePerformanceFixtureFactory.largeDocumentJson()
-            NativePerformanceFixtureFactory.loadLargeDocumentIntoEditor(editorId.toULong())
-            val editText = runOnMainSyncWithResult {
-                EditorEditText(context).apply {
-                    layoutParams = ViewGroup.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.WRAP_CONTENT
-                    )
-                    setBaseStyle(baseFontSize, textColor, Color.WHITE)
-                    bindEditor(editorId)
-                    layoutView(this, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-            }
-            val splitOffset = NativePerformanceFixtureFactory.typingCursorOffset(editText.text ?: "")
-
-            val stats = measureOperation(
-                name = "paragraphSplitRoundTripLargeDocument",
-                beforeEach = {
-                    runOnMainSyncWithResult {
-                        editorSetJson(editorId.toULong(), largeDocumentJson)
-                        editText.applyUpdateJSON(editorGetCurrentState(editorId.toULong()), notifyListener = false)
-                        editText.setSelection(splitOffset)
-                        layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                    }
-                }
-            ) {
-                runOnMainSyncWithResult {
-                    editText.handleTextCommit("\n")
-                    layoutView(editText, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-
-                assertNotNull("edit text should have a layout after paragraph split", editText.layout)
-            }
-
-            reportStats(stats)
-            assertTrue("average paragraph split time should be positive", stats.averageMillis > 0.0)
-        } finally {
-            editorDestroy(editorId.toULong())
-        }
-    }
-
-    @Test
-    fun performance_selectionScrubLargeDocument() {
-        val editorId = editorCreate("{}").toLong()
-        try {
-            NativePerformanceFixtureFactory.loadLargeDocumentIntoEditor(editorId.toULong())
-            val editText = runOnMainSyncWithResult {
-                EditorEditText(context).apply {
-                    layoutParams = ViewGroup.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.WRAP_CONTENT
-                    )
-                    setBaseStyle(baseFontSize, textColor, Color.WHITE)
-                    bindEditor(editorId)
-                    layoutView(this, widthPx = 1080, heightPx = 2400, heightMode = View.MeasureSpec.AT_MOST)
-                }
-            }
-            val scrubOffsets = NativePerformanceFixtureFactory.selectionScrubOffsets(
-                editText.text ?: "",
-                points = 48
-            )
-
-            val stats = measureOperation("selectionScrubLargeDocument") {
-                runOnMainSyncWithResult {
-                    for (offset in scrubOffsets) {
-                        editText.setSelection(offset)
-                    }
-                }
-
-                assertEquals(
-                    "selection should land on the final scrub offset",
-                    scrubOffsets.last(),
-                    editText.selectionStart
-                )
-            }
-
-            reportStats(stats)
-            assertTrue("average selection scrub time should be positive", stats.averageMillis > 0.0)
-        } finally {
-            editorDestroy(editorId.toULong())
-        }
-    }
-
-    @Test
-    fun performance_remoteSelectionOverlayRefreshMultiPeerLargeDocument() {
-        val updateJson = NativePerformanceFixtureFactory.largeUpdateJson()
-        val richTextView = runOnMainSyncWithResult {
-            RichTextEditorView(context).apply {
-                configure(textSizePx = baseFontSize, textColor = textColor, backgroundColor = Color.WHITE)
-                setRemoteSelectionEditorIdForTesting(1L)
-                setRemoteSelectionScalarResolverForTesting { _, docPos -> docPos }
-                editorEditText.applyUpdateJSON(updateJson, notifyListener = false)
-                layoutView(this, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
-            }
-        }
-
-        val totalScalar = richTextView.editorEditText.text?.length ?: 0
-        val selections = NativePerformanceFixtureFactory.remoteSelections(
-            totalScalar,
-            peerCount = 24,
-            selectionWidth = 24
-        )
-        runOnMainSyncWithResult {
-            richTextView.setRemoteSelections(selections)
-            layoutView(richTextView, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
-        }
-
-        val bitmap = Bitmap.createBitmap(1080, 1600, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-
-        val stats = measureOperation("remoteSelectionOverlayRefreshMultiPeerLargeDocument") {
-            val hasVisibleCaret = runOnMainSyncWithResult {
-                bitmap.eraseColor(Color.TRANSPARENT)
-                richTextView.setRemoteSelections(selections)
-                layoutView(richTextView, widthPx = 1080, heightPx = 1600, heightMode = View.MeasureSpec.EXACTLY)
-                richTextView.draw(canvas)
-                richTextView.remoteSelectionDebugSnapshotsForTesting().any { it.caretRect != null }
-            }
-
-            assertTrue("remote selection overlay should resolve visible carets", hasVisibleCaret)
-            assertEquals("expected one snapshot per peer", selections.size, richTextView.remoteSelectionDebugSnapshotsForTesting().size)
-        }
-
-        reportStats(stats)
-        assertTrue("average remote selection refresh time should be positive", stats.averageMillis > 0.0)
-    }
-
-    private fun layoutView(
-        view: View,
-        widthPx: Int,
-        heightPx: Int,
-        heightMode: Int
-    ) {
-        val widthSpec = View.MeasureSpec.makeMeasureSpec(widthPx, View.MeasureSpec.EXACTLY)
-        val heightSpec = View.MeasureSpec.makeMeasureSpec(heightPx, heightMode)
-        view.measure(widthSpec, heightSpec)
-        view.layout(0, 0, view.measuredWidth, view.measuredHeight)
-    }
-
-    private fun measureOperation(
-        name: String,
-        warmupIterations: Int = 3,
-        measuredIterations: Int = 5,
-        beforeEach: (() -> Unit)? = null,
-        block: () -> Unit
-    ): TimingStats {
-        repeat(warmupIterations) {
-            beforeEach?.invoke()
-            block()
-        }
-
-        val samples = MutableList(measuredIterations) {
-            beforeEach?.invoke()
-            val startedAt = System.nanoTime()
-            block()
-            System.nanoTime() - startedAt
-        }
-
-        return TimingStats(name, samples)
-    }
-
-    private fun reportStats(stats: TimingStats) {
-        instrumentation.sendStatus(
-            0,
-            Bundle().apply {
-                putString(
-                    Instrumentation.REPORT_KEY_STREAMRESULT,
-                    stats.summaryString(tag = "NativeDevicePerformanceTest") + "\n"
-                )
-            }
-        )
-    }
-
-    @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
-    }
-}

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

@@ -1,5 +0,0 @@
-package com.openeditor.editor
-
-import android.app.Activity
-
-class NativeEditorOutsideTapActivity : Activity()

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

@@ -1,315 +0,0 @@
-package com.openeditor.editor
-
-import android.content.Intent
-import android.content.Context
-import android.graphics.Color
-import android.net.Uri
-import android.view.MotionEvent
-import android.view.View
-import android.view.ViewGroup
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.viewevent.EventDispatcher
-import expo.modules.kotlin.views.ExpoView
-import kotlin.math.abs
-import org.json.JSONArray
-
-class NativeProseViewerExpoView(
-    context: Context,
-    appContext: AppContext
-) : ExpoView(context, appContext) {
-
-    private val proseView = EditorEditText(context)
-    private val onContentHeightChange by EventDispatcher<Map<String, Any>>()
-    @Suppress("unused")
-    private val onPressLink by EventDispatcher<Map<String, Any>>()
-    @Suppress("unused")
-    private val onPressMention by EventDispatcher<Map<String, Any>>()
-
-    private var lastRenderJson: String? = null
-    private var lastThemeJson: String? = null
-    private var lastEmittedContentHeight = 0
-    private var collapsesWhenEmpty = true
-    private var isCollapsedEmptyContent = false
-    private var enableLinkTaps = true
-    private var interceptLinkTaps = false
-    internal var suppressContentHeightEventsForTesting = false
-
-    init {
-        proseView.setBaseStyle(
-            proseView.textSize,
-            proseView.currentTextColor,
-            Color.TRANSPARENT
-        )
-        proseView.isEditable = false
-        proseView.inputType = android.text.InputType.TYPE_CLASS_TEXT or
-            android.text.InputType.TYPE_TEXT_FLAG_MULTI_LINE or
-            android.text.InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
-        proseView.setImageResizingEnabled(false)
-        proseView.setHeightBehavior(EditorHeightBehavior.AUTO_GROW)
-        proseView.isFocusable = false
-        proseView.isFocusableInTouchMode = false
-        proseView.isCursorVisible = false
-        proseView.isLongClickable = false
-        proseView.setTextIsSelectable(false)
-        proseView.showSoftInputOnFocus = false
-        proseView.setOnTouchListener { _, event ->
-            if (event.actionMasked != MotionEvent.ACTION_UP) {
-                return@setOnTouchListener false
-            }
-
-            proseView.mentionHitAt(event.x, event.y)?.let { mention ->
-                onPressMention(mapOf("docPos" to mention.docPos, "label" to mention.label))
-                return@setOnTouchListener true
-            }
-
-            if (!enableLinkTaps) {
-                return@setOnTouchListener false
-            }
-
-            val link = proseView.linkHitAt(event.x, event.y) ?: return@setOnTouchListener false
-            if (interceptLinkTaps) {
-                onPressLink(
-                    mapOf(
-                        "href" to link.href,
-                        "text" to link.text
-                    )
-                )
-                return@setOnTouchListener true
-            }
-
-            return@setOnTouchListener openLink(link.href)
-        }
-
-        addView(
-            proseView,
-            LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.WRAP_CONTENT
-            )
-        )
-    }
-
-    fun setRenderJson(renderJson: String?) {
-        if (lastRenderJson == renderJson) return
-        lastRenderJson = renderJson
-        applyRenderJson()
-        requestLayout()
-    }
-
-    fun setThemeJson(themeJson: String?) {
-        if (lastThemeJson == themeJson) return
-        lastThemeJson = themeJson
-        proseView.applyTheme(EditorTheme.fromJson(themeJson))
-        applyRenderJson()
-        requestLayout()
-    }
-
-    fun setCollapsesWhenEmpty(collapsesWhenEmpty: Boolean?) {
-        val nextValue = collapsesWhenEmpty ?: true
-        if (this.collapsesWhenEmpty == nextValue) return
-        this.collapsesWhenEmpty = nextValue
-        updateCollapsedEmptyState()
-        requestLayout()
-        emitContentHeightIfNeeded(force = true)
-    }
-
-    fun setEnableLinkTaps(enableLinkTaps: Boolean?) {
-        this.enableLinkTaps = enableLinkTaps ?: true
-    }
-
-    fun setInterceptLinkTaps(interceptLinkTaps: Boolean?) {
-        this.interceptLinkTaps = interceptLinkTaps ?: false
-    }
-
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        if (isCollapsedEmptyContent) {
-            setMeasuredDimension(resolveSize(0, widthMeasureSpec), 0)
-            emitContentHeightIfNeeded()
-            return
-        }
-
-        val childWidthSpec = getChildMeasureSpec(
-            widthMeasureSpec,
-            paddingLeft + paddingRight,
-            proseView.layoutParams.width
-        )
-        val childHeightSpec = android.view.View.MeasureSpec.makeMeasureSpec(
-            0,
-            android.view.View.MeasureSpec.UNSPECIFIED
-        )
-        proseView.measure(childWidthSpec, childHeightSpec)
-
-        val resolvedContentHeight = proseView.resolveAutoGrowHeight()
-        val desiredWidth = proseView.measuredWidth + paddingLeft + paddingRight
-        val desiredHeight = resolvedContentHeight + paddingTop + paddingBottom
-        val measuredHeight = when (View.MeasureSpec.getMode(heightMeasureSpec)) {
-            View.MeasureSpec.AT_MOST -> desiredHeight.coerceAtMost(
-                View.MeasureSpec.getSize(heightMeasureSpec)
-            )
-            else -> desiredHeight
-        }
-        setMeasuredDimension(
-            resolveSize(desiredWidth, widthMeasureSpec),
-            measuredHeight
-        )
-        emitContentHeightIfNeeded(measuredContentHeight = desiredHeight)
-    }
-
-    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-        if (isCollapsedEmptyContent) {
-            proseView.layout(paddingLeft, paddingTop, right - left - paddingRight, paddingTop)
-            emitContentHeightIfNeeded()
-            return
-        }
-
-        val childLeft = paddingLeft
-        val childTop = paddingTop
-        proseView.layout(
-            childLeft,
-            childTop,
-            right - left - paddingRight,
-            childTop + proseView.measuredHeight
-        )
-        emitContentHeightIfNeeded()
-    }
-
-    private fun applyRenderJson() {
-        updateCollapsedEmptyState()
-        proseView.applyRenderJSON(lastRenderJson ?: "[]")
-        proseView.visibility = if (isCollapsedEmptyContent) View.GONE else View.VISIBLE
-    }
-
-    private fun updateCollapsedEmptyState() {
-        isCollapsedEmptyContent = collapsesWhenEmpty &&
-            renderJsonContainsOnlyEmptyParagraphs(lastRenderJson ?: "[]")
-        proseView.visibility = if (isCollapsedEmptyContent) View.GONE else View.VISIBLE
-    }
-
-    private fun emitContentHeightIfNeeded(
-        force: Boolean = false,
-        measuredContentHeight: Int? = null
-    ) {
-        val contentHeight = if (isCollapsedEmptyContent) {
-            0
-        } else {
-            (
-                measuredContentHeight ?: (measureContentHeightPx() + paddingTop + paddingBottom)
-            ).coerceAtLeast(0)
-        }
-        if (contentHeight <= 0 && !isCollapsedEmptyContent) {
-            return
-        }
-        if (!force && contentHeight == lastEmittedContentHeight) {
-            return
-        }
-        lastEmittedContentHeight = contentHeight
-        if (suppressContentHeightEventsForTesting) {
-            return
-        }
-        onContentHeightChange(mapOf("contentHeight" to contentHeight))
-    }
-
-    private fun measureContentHeightPx(): Int {
-        if (isCollapsedEmptyContent) {
-            return 0
-        }
-
-        val availableWidthPx = resolveAvailableWidthPx()
-        if (
-            proseView.measuredWidth <= 0 ||
-            abs(proseView.measuredWidth - availableWidthPx) > 1
-        ) {
-            val childWidthSpec = View.MeasureSpec.makeMeasureSpec(
-                availableWidthPx,
-                View.MeasureSpec.EXACTLY
-            )
-            val childHeightSpec = View.MeasureSpec.makeMeasureSpec(
-                0,
-                View.MeasureSpec.UNSPECIFIED
-            )
-            proseView.measure(childWidthSpec, childHeightSpec)
-        }
-        return proseView.resolveAutoGrowHeight()
-    }
-
-    private fun resolveAvailableWidthPx(): Int {
-        val localWidth = width - paddingLeft - paddingRight
-        if (localWidth > 0) {
-            return localWidth
-        }
-
-        val parentWidth = ((parent as? View)?.width ?: 0) - paddingLeft - paddingRight
-        if (parentWidth > 0) {
-            return parentWidth
-        }
-
-        return (resources.displayMetrics.widthPixels - paddingLeft - paddingRight).coerceAtLeast(1)
-    }
-
-    private fun openLink(href: String): Boolean {
-        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(href)).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        }
-        return runCatching {
-            context.startActivity(intent)
-            true
-        }.getOrDefault(false)
-    }
-
-    companion object {
-        private const val EMPTY_TEXT_BLOCK_PLACEHOLDER = '\u200B'
-
-        internal fun renderJsonContainsOnlyEmptyParagraphs(renderJson: String): Boolean {
-            val elements = try {
-                JSONArray(renderJson)
-            } catch (_: Exception) {
-                return false
-            }
-
-            if (elements.length() == 0) {
-                return true
-            }
-
-            var hasParagraph = false
-            var paragraphIsOpen = false
-
-            for (index in 0 until elements.length()) {
-                val element = elements.optJSONObject(index) ?: return false
-                when (element.optString("type", "")) {
-                    "blockStart" -> {
-                        if (
-                            paragraphIsOpen ||
-                            element.optString("nodeType", "") != "paragraph" ||
-                            element.optInt("depth", 0) != 0
-                        ) {
-                            return false
-                        }
-                        paragraphIsOpen = true
-                        hasParagraph = true
-                    }
-
-                    "textRun" -> {
-                        val text = element.optString("text", "")
-                        if (
-                            !paragraphIsOpen ||
-                            !text.all { it == EMPTY_TEXT_BLOCK_PLACEHOLDER }
-                        ) {
-                            return false
-                        }
-                    }
-
-                    "blockEnd" -> {
-                        if (!paragraphIsOpen) {
-                            return false
-                        }
-                        paragraphIsOpen = false
-                    }
-
-                    else -> return false
-                }
-            }
-
-            return hasParagraph && !paragraphIsOpen
-        }
-    }
-}