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

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

@@ -959,7 +959,7 @@ class NativeEditorExpoView(
             cancelPendingToolbarRefocus()
             clearPendingNativeActionRetry()
         }
-        richTextView.editorEditText.isEditable = editable
+        richTextView.setEditable(editable)
         updateKeyboardToolbarVisibility()
     }
 

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

@@ -165,6 +165,26 @@ class NativeEditorModule : Module() {
             val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
             editorOutdentListItem(editorId)
         }
+        Function("editorInsertTableRow") { id: Int, after: Boolean ->
+            val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
+            editorInsertTableRow(editorId, after)
+        }
+        Function("editorDeleteTableRow") { id: Int ->
+            val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
+            editorDeleteTableRow(editorId)
+        }
+        Function("editorInsertTableColumn") { id: Int, after: Boolean ->
+            val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
+            editorInsertTableColumn(editorId, after)
+        }
+        Function("editorDeleteTableColumn") { id: Int ->
+            val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
+            editorDeleteTableColumn(editorId)
+        }
+        Function("editorMoveTableCell") { id: Int, forward: Boolean ->
+            val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
+            editorMoveTableCell(editorId, forward)
+        }
         Function("editorInsertNode") { id: Int, nodeType: String ->
             val editorId = nativeULong(id) ?: return@Function nativeArgumentError("editor id")
             editorInsertNode(editorId, nodeType)
@@ -359,6 +379,12 @@ class NativeEditorModule : Module() {
             val headPosition = nativeUInt(head) ?: return@Function
             editorSetSelection(editorId, anchorPosition, headPosition)
         }
+        Function("editorSetCellSelection") { id: Int, anchor: Int, head: Int ->
+            val editorId = nativeULong(id) ?: return@Function
+            val anchorPosition = nativeUInt(anchor) ?: return@Function
+            val headPosition = nativeUInt(head) ?: return@Function
+            editorSetCellSelection(editorId, anchorPosition, headPosition)
+        }
         Function("editorSetSelectionScalar") { id: Int, scalarAnchor: Int, scalarHead: Int ->
             val editorId = nativeULong(id) ?: return@Function
             val anchor = nativeUInt(scalarAnchor) ?: return@Function
@@ -405,33 +431,6 @@ class NativeEditorModule : Module() {
             val editorId = nativeULong(id) ?: return@Function false
             editorCanRedo(editorId)
         }
-        Function("renderDocumentJson") { configJson: String, json: String ->
-            val editorId = editorCreate(configJson)
-            try {
-                editorSetJson(editorId, json)
-            } finally {
-                editorDestroy(editorId)
-            }
-        }
-        Function("measureContentHeight") { renderJson: String, themeJson: String?, width: Double ->
-            val density = appContext.reactContext?.resources?.displayMetrics?.density ?: 1f
-            val height = RenderBridge.measureHeight(
-                json = renderJson,
-                themeJson = themeJson,
-                width = width.toFloat(),
-                density = density
-            )
-            height.toDouble()
-        }
-        Function("renderDocumentHtml") { configJson: String, html: String ->
-            val editorId = editorCreate(configJson)
-            try {
-                editorSetHtml(editorId, html)
-            } finally {
-                editorDestroy(editorId)
-            }
-        }
-
         View(NativeEditorExpoView::class) {
             Events(
                 "onEditorUpdate",
@@ -534,28 +533,5 @@ class NativeEditorModule : Module() {
             }
 
         }
-
-        View(NativeProseViewerExpoView::class) {
-            Name("NativeProseViewer")
-            Events("onContentHeightChange", "onPressLink", "onPressMention")
-
-            Prop("renderJson") { view: NativeProseViewerExpoView, renderJson: String? ->
-                view.setRenderJson(renderJson)
-            }
-            Prop("themeJson") { view: NativeProseViewerExpoView, themeJson: String? ->
-                view.setThemeJson(themeJson)
-            }
-            Prop("collapsesWhenEmpty") {
-                view: NativeProseViewerExpoView,
-                collapsesWhenEmpty: Boolean? ->
-                view.setCollapsesWhenEmpty(collapsesWhenEmpty)
-            }
-            Prop("enableLinkTaps") { view: NativeProseViewerExpoView, enableLinkTaps: Boolean? ->
-                view.setEnableLinkTaps(enableLinkTaps)
-            }
-            Prop("interceptLinkTaps") { view: NativeProseViewerExpoView, interceptLinkTaps: Boolean? ->
-                view.setInterceptLinkTaps(interceptLinkTaps)
-            }
-        }
     }
 }

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

@@ -0,0 +1,89 @@
+package com.openeditor.editor
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Base64
+import android.util.Log
+import android.util.LruCache
+import java.net.URL
+import java.util.concurrent.ArrayBlockingQueue
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+
+internal object NativeImageDecoder {
+    private const val MAX_DECODE_DIMENSION_PX = 2048
+    private const val LOG_TAG = "NativeEditorImage"
+
+    fun decodeSource(source: String): Bitmap? {
+        val bytes = decodeDataUrlBytes(source) ?: runCatching {
+            URL(source).openStream().use { it.readBytes() }
+        }.getOrNull() ?: return null
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
+        if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
+        val options = BitmapFactory.Options().apply {
+            inSampleSize = calculateInSampleSize(bounds.outWidth, bounds.outHeight)
+        }
+        return BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
+    }
+
+    fun decodeDataUrlBytes(source: String): ByteArray? {
+        val trimmed = source.trim()
+        if (!trimmed.startsWith("data:image/", ignoreCase = true)) return null
+        val comma = trimmed.indexOf(',')
+        if (comma <= 0 || !trimmed.substring(0, comma).contains(";base64", ignoreCase = true)) return null
+        val payload = trimmed.substring(comma + 1).filterNot(Char::isWhitespace)
+        for (flags in intArrayOf(Base64.DEFAULT, Base64.NO_WRAP, Base64.URL_SAFE or Base64.NO_WRAP)) {
+            runCatching { Base64.decode(payload, flags) }.getOrNull()?.let { return it }
+        }
+        Log.w(LOG_TAG, "Unsupported image data URL")
+        return null
+    }
+
+    fun calculateInSampleSize(width: Int, height: Int): Int {
+        var sample = 1
+        while (width / sample > MAX_DECODE_DIMENSION_PX || height / sample > MAX_DECODE_DIMENSION_PX) {
+            sample *= 2
+        }
+        return sample
+    }
+}
+
+internal object NativeImageLoader {
+    private val cache = object : LruCache<String, Bitmap>(32 * 1024 * 1024) {
+        override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
+    }
+    private val executor = ThreadPoolExecutor(
+        2,
+        2,
+        30,
+        TimeUnit.SECONDS,
+        ArrayBlockingQueue(64),
+        ThreadPoolExecutor.DiscardOldestPolicy()
+    )
+    private val lock = Any()
+    private val inFlight = mutableMapOf<String, MutableList<(Bitmap?) -> Unit>>()
+
+    @Volatile
+    internal var decodeSourceOverride: ((String) -> Bitmap?)? = null
+
+    internal fun resetForTesting() {
+        synchronized(cache) { cache.evictAll() }
+        synchronized(lock) { inFlight.clear() }
+        decodeSourceOverride = null
+    }
+
+    fun load(source: String, onLoaded: (Bitmap?) -> Unit) {
+        synchronized(cache) { cache.get(source) }?.let(onLoaded)?.also { return }
+        synchronized(lock) {
+            inFlight[source]?.let { it += onLoaded; return }
+            inFlight[source] = mutableListOf(onLoaded)
+        }
+        executor.execute {
+            val bitmap = decodeSourceOverride?.invoke(source) ?: NativeImageDecoder.decodeSource(source)
+            if (bitmap != null) synchronized(cache) { cache.put(source, bitmap) }
+            val callbacks = synchronized(lock) { inFlight.remove(source).orEmpty() }
+            callbacks.forEach { it(bitmap) }
+        }
+    }
+}

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

@@ -11,7 +11,6 @@ import android.util.TypedValue
 import android.view.View
 import androidx.appcompat.content.res.AppCompatResources
 import org.json.JSONArray
-import uniffi.editor_core.editorDocToScalar
 
 data class RemoteSelectionDecoration(
     val clientId: Int,
@@ -102,11 +101,9 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
 
     private data class GeometrySnapshot(
         val editorId: Long,
-        val text: String,
-        val layoutWidth: Int,
-        val layoutHeight: Int,
-        val baseX: Int,
-        val baseY: Int,
+        val surfaceRevision: Long,
+        val surfaceWidth: Int,
+        val surfaceHeight: Int,
         val width: Int,
         val height: Int,
         val selections: List<RemoteSelectionDecoration>,
@@ -114,8 +111,9 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
 
     private data class GeometryContext(
         val snapshot: GeometrySnapshot,
-        val layout: android.text.Layout,
-        val caretWidth: Float,
+        val surface: NativeBlockEditorSurface,
+        val baseX: Float,
+        val baseY: Float,
     )
 
     private var editorView: RichTextEditorView? = null
@@ -123,9 +121,6 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
     private var cachedSnapshot: GeometrySnapshot? = null
     private var cachedGeometry: List<CachedSelectionGeometry> = emptyList()
     internal var editorIdOverrideForTesting: Long? = null
-    internal var docToScalarResolver: (Long, Int) -> Int = { editorId, docPos ->
-        editorDocToScalar(editorId.toULong(), docPos.toUInt()).toInt()
-    }
     private val selectionPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
         style = Paint.Style.FILL
     }
@@ -208,20 +203,21 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
             return cachedGeometry
         }
 
-        val text = context.snapshot.text
-        val editorId = context.snapshot.editorId
         val geometry = remoteSelections.map { selection ->
             val startDoc = minOf(selection.anchor, selection.head)
             val endDoc = maxOf(selection.anchor, selection.head)
-            val startScalar = docToScalarResolver(editorId, startDoc)
-            val endScalar = docToScalarResolver(editorId, endDoc)
-            val startUtf16 = PositionBridge.scalarToUtf16(startScalar, text).coerceIn(0, text.length)
-            val endUtf16 = PositionBridge.scalarToUtf16(endScalar, text).coerceIn(0, text.length)
-
-            val selectionPath = if (startUtf16 != endUtf16) {
+            val selectionRects = context.surface.selectionRectsForDocRange(startDoc, endDoc)
+            val selectionPath = if (selectionRects.isNotEmpty()) {
                 Path().apply {
-                    context.layout.getSelectionPath(startUtf16, endUtf16, this)
-                    offset(context.snapshot.baseX.toFloat(), context.snapshot.baseY.toFloat())
+                    selectionRects.forEach { rect ->
+                        addRect(
+                            rect.left + context.baseX,
+                            rect.top + context.baseY,
+                            rect.right + context.baseX,
+                            rect.bottom + context.baseY,
+                            Path.Direction.CW
+                        )
+                    }
                 }
             } else {
                 null
@@ -231,15 +227,11 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
                 clientId = selection.clientId,
                 selectionPath = selectionPath,
                 selectionColor = withAlpha(selection.color, 0.18f),
-                caretRect = caretRectForOffset(
-                    endUtf16 = endUtf16,
-                    textLength = text.length,
-                    layout = context.layout,
-                    baseX = context.snapshot.baseX.toFloat(),
-                    baseY = context.snapshot.baseY.toFloat(),
-                    caretWidth = context.caretWidth,
-                    isFocused = selection.isFocused,
-                ),
+                caretRect = if (selection.isFocused) {
+                    context.surface.caretRectForDocPosition(selection.head)?.apply {
+                        offset(context.baseX, context.baseY)
+                    }
+                } else null,
                 caretColor = selection.color,
             )
         }
@@ -254,29 +246,23 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
         val editorId = resolvedEditorId(editorView)
         if (editorId == 0L || remoteSelections.isEmpty()) return null
 
-        val editText = editorView.editorEditText
-        val layout = editText.layout ?: return null
-        val text = editText.text?.toString() ?: return null
-        val baseX = editorView.editorViewport.left + editorView.editorScrollView.left + editText.left +
-            editText.compoundPaddingLeft
-        val baseY = editorView.editorViewport.top + editorView.editorScrollView.top + editText.top +
-            editText.compoundPaddingTop - editorView.editorScrollView.scrollY
-        val caretWidth = maxOf(2f, resources.displayMetrics.density)
+        val surface = editorView.blockSurface
+        val baseX = (editorView.editorViewport.left + surface.left).toFloat()
+        val baseY = (editorView.editorViewport.top + surface.top).toFloat()
 
         return GeometryContext(
             snapshot = GeometrySnapshot(
                 editorId = editorId,
-                text = text,
-                layoutWidth = layout.width,
-                layoutHeight = layout.height,
-                baseX = baseX,
-                baseY = baseY,
+                surfaceRevision = surface.geometryRevision,
+                surfaceWidth = surface.width,
+                surfaceHeight = surface.height,
                 width = width,
                 height = height,
                 selections = remoteSelections,
             ),
-            layout = layout,
-            caretWidth = caretWidth,
+            surface = surface,
+            baseX = baseX,
+            baseY = baseY,
         )
     }
 
@@ -284,27 +270,6 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
         cachedSnapshot = null
     }
 
-    private fun caretRectForOffset(
-        endUtf16: Int,
-        textLength: Int,
-        layout: android.text.Layout,
-        baseX: Float,
-        baseY: Float,
-        caretWidth: Float,
-        isFocused: Boolean,
-    ): RectF? {
-        if (!isFocused) return null
-
-        val clampedOffset = endUtf16.coerceIn(0, textLength)
-        val lineLookupOffset = clampedOffset.coerceAtMost(maxOf(textLength - 1, 0))
-        val line = layout.getLineForOffset(lineLookupOffset)
-        val horizontal = layout.getPrimaryHorizontal(clampedOffset)
-        val caretLeft = baseX + horizontal
-        val caretTop = baseY + layout.getLineTop(line)
-        val caretBottom = baseY + layout.getLineBottom(line)
-        return RectF(caretLeft, caretTop, caretLeft + caretWidth, caretBottom)
-    }
-
     private fun withAlpha(color: Int, alphaFraction: Float): Int {
         val alpha = (255f * alphaFraction).toInt().coerceIn(0, 255)
         return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color))

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

@@ -7,6 +7,7 @@ import android.graphics.drawable.GradientDrawable
 import android.util.AttributeSet
 import android.view.MotionEvent
 import android.view.ViewGroup
+import android.view.inputmethod.InputMethodManager
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.ScrollView
@@ -20,7 +21,7 @@ class RichTextEditorView @JvmOverloads constructor(
 ) : LinearLayout(context, attrs, defStyleAttr) {
     val editorViewport: FrameLayout
 
-    private class EditorScrollView(context: Context) : ScrollView(context) {
+    class EditorScrollView(context: Context) : ScrollView(context) {
         private fun updateParentIntercept(action: Int) {
             val canScroll = canScrollVertically(-1) || canScrollVertically(1)
             if (!canScroll) return
@@ -44,7 +45,8 @@ class RichTextEditorView @JvmOverloads constructor(
     }
 
     val editorEditText: EditorEditText
-    val editorScrollView: ScrollView
+    val editorScrollView: EditorScrollView
+    val blockSurface: NativeBlockEditorSurface
     private val remoteSelectionOverlayView: RemoteSelectionOverlayView
     private val imageResizeOverlayView: ImageResizeOverlayView
 
@@ -58,6 +60,7 @@ class RichTextEditorView @JvmOverloads constructor(
 
     private var currentEditorId: Long = 0
     private var deferEditorUnbindOnDetach = false
+    private var isSyncingBlockSurfaceUpdateToInputAdapter = false
     internal var onBeforeDetachedFromWindow: (() -> Unit)? = null
 
     /** Binds or unbinds the Rust editor instance. */
@@ -74,7 +77,9 @@ class RichTextEditorView @JvmOverloads constructor(
         editorScrollView = EditorScrollView(context).apply {
             clipToPadding = false
             isFillViewport = false
+            alpha = 0.01f
         }
+        blockSurface = NativeBlockEditorSurface(context)
         editorViewport = FrameLayout(context)
         remoteSelectionOverlayView = RemoteSelectionOverlayView(context)
         imageResizeOverlayView = ImageResizeOverlayView(context)
@@ -86,6 +91,13 @@ class RichTextEditorView @JvmOverloads constructor(
                 ViewGroup.LayoutParams.MATCH_PARENT
             )
         )
+        editorViewport.addView(
+            blockSurface,
+            FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        )
         editorViewport.addView(
             remoteSelectionOverlayView,
             FrameLayout.LayoutParams(
@@ -105,7 +117,43 @@ class RichTextEditorView @JvmOverloads constructor(
         editorScrollView.setOnScrollChangeListener { _, _, _, _, _ ->
             refreshOverlays()
         }
-        editorEditText.onSelectionOrContentMayChange = { refreshOverlays() }
+        editorEditText.onSelectionOrContentMayChange = {
+            if (editorId != 0L && !isSyncingBlockSurfaceUpdateToInputAdapter) {
+                blockSurface.applyUpdateJSON(
+                    editorGetSelectionState(editorId.toULong()),
+                    editorId
+                )
+            }
+            refreshOverlays()
+        }
+        editorEditText.onUpdateJSONApplied = appliedUpdate@ { updateJSON ->
+            if (isSyncingBlockSurfaceUpdateToInputAdapter) return@appliedUpdate
+            blockSurface.applyUpdateJSON(updateJSON, editorId)
+        }
+        blockSurface.onAppliedUpdate = { updateJSON ->
+            isSyncingBlockSurfaceUpdateToInputAdapter = true
+            try {
+                editorEditText.applyUpdateJSON(updateJSON, notifyListener = true)
+            } finally {
+                isSyncingBlockSurfaceUpdateToInputAdapter = false
+            }
+        }
+        blockSurface.onRequestTextInput = requestTextInput@ { docPos ->
+            if (editorId == 0L || !editorEditText.isEditable) return@requestTextInput
+            editorSetSelection(editorId.toULong(), docPos.toUInt(), docPos.toUInt())
+            isSyncingBlockSurfaceUpdateToInputAdapter = true
+            try {
+                editorEditText.applyUpdateJSON(
+                    editorGetSelectionState(editorId.toULong()),
+                    notifyListener = true
+                )
+            } finally {
+                isSyncingBlockSurfaceUpdateToInputAdapter = false
+            }
+            editorEditText.requestFocus()
+            context.getSystemService(InputMethodManager::class.java)
+                ?.showSoftInput(editorEditText, InputMethodManager.SHOW_IMPLICIT)
+        }
 
         addView(editorViewport, createContainerLayoutParams())
         updateScrollContainerAppearance()
@@ -119,6 +167,7 @@ class RichTextEditorView @JvmOverloads constructor(
     ) {
         baseBackgroundColor = backgroundColor
         editorEditText.setBaseStyle(textSizePx, textColor, backgroundColor)
+        blockSurface.configure(textSizePx, textColor, backgroundColor)
         updateScrollContainerAppearance()
         refreshOverlays()
     }
@@ -127,6 +176,7 @@ class RichTextEditorView @JvmOverloads constructor(
         this.theme = theme
         val previousScrollY = editorScrollView.scrollY
         editorEditText.applyTheme(theme)
+        blockSurface.applyTheme(theme)
         updateScrollContainerAppearance()
         updateScrollContainerInsets()
         if (heightBehavior == EditorHeightBehavior.FIXED) {
@@ -143,6 +193,12 @@ class RichTextEditorView @JvmOverloads constructor(
         refreshOverlays()
     }
 
+    fun setEditable(editable: Boolean) {
+        editorEditText.isEditable = editable
+        blockSurface.isEditable = editable
+        if (!editable) editorEditText.clearFocus()
+    }
+
     fun setHeightBehavior(heightBehavior: EditorHeightBehavior) {
         if (this.heightBehavior == heightBehavior) return
         this.heightBehavior = heightBehavior
@@ -155,6 +211,13 @@ class RichTextEditorView @JvmOverloads constructor(
         } else {
             OVER_SCROLL_NEVER
         }
+        blockSurface.isScrollingEnabled = heightBehavior == EditorHeightBehavior.FIXED
+        blockSurface.isVerticalScrollBarEnabled = heightBehavior == EditorHeightBehavior.FIXED
+        blockSurface.overScrollMode = if (heightBehavior == EditorHeightBehavior.FIXED) {
+            OVER_SCROLL_IF_CONTENT_SCROLLS
+        } else {
+            OVER_SCROLL_NEVER
+        }
         updateScrollContainerInsets()
         refreshOverlays()
         requestLayout()
@@ -198,10 +261,6 @@ class RichTextEditorView @JvmOverloads constructor(
     fun remoteSelectionDebugSnapshotsForTesting(): List<RemoteSelectionDebugSnapshot> =
         remoteSelectionOverlayView.debugSnapshotsForTesting()
 
-    fun setRemoteSelectionScalarResolverForTesting(resolver: (Long, Int) -> Int) {
-        remoteSelectionOverlayView.docToScalarResolver = resolver
-    }
-
     fun setRemoteSelectionEditorIdForTesting(editorId: Long) {
         remoteSelectionOverlayView.editorIdOverrideForTesting = editorId
     }
@@ -209,21 +268,27 @@ class RichTextEditorView @JvmOverloads constructor(
     fun setContent(html: String) {
         if (editorId == 0L) return
         editorSetHtml(editorId.toULong(), html)
-        editorEditText.applyUpdateJSON(
-            editorGetCurrentState(editorId.toULong()),
-            notifyListener = false,
-            refreshInputConnectionForExternalUpdate = true
-        )
+        applyFullStateToInputAndSurface(editorGetCurrentState(editorId.toULong()))
     }
 
     fun setContent(json: org.json.JSONObject) {
         if (editorId == 0L) return
         editorSetJson(editorId.toULong(), json.toString())
-        editorEditText.applyUpdateJSON(
-            editorGetCurrentState(editorId.toULong()),
-            notifyListener = false,
-            refreshInputConnectionForExternalUpdate = true
-        )
+        applyFullStateToInputAndSurface(editorGetCurrentState(editorId.toULong()))
+    }
+
+    private fun applyFullStateToInputAndSurface(stateJSON: String) {
+        isSyncingBlockSurfaceUpdateToInputAdapter = true
+        try {
+            editorEditText.applyUpdateJSON(
+                stateJSON,
+                notifyListener = false,
+                refreshInputConnectionForExternalUpdate = true
+            )
+        } finally {
+            isSyncingBlockSurfaceUpdateToInputAdapter = false
+        }
+        blockSurface.applyUpdateJSON(stateJSON, editorId)
     }
 
     internal fun rebindEditorIfNeeded(notifyListener: Boolean = true) {
@@ -259,6 +324,7 @@ class RichTextEditorView @JvmOverloads constructor(
             editorEditText.discardTransientNativeInputForEditorRebind()
         }
         currentEditorId = value
+        blockSurface.bind(value)
         if (bindEditor && value != 0L) {
             editorEditText.bindEditor(value, notifyListener = notifyListener)
         } else {
@@ -346,34 +412,32 @@ class RichTextEditorView @JvmOverloads constructor(
         )
 
     internal fun selectedImageGeometry(): EditorEditText.SelectedImageGeometry? {
-        val geometry = editorEditText.selectedImageGeometry() ?: return null
+        if (!imageResizingEnabled) return null
+        val geometry = blockSurface.selectedImageGeometry() ?: return null
         return EditorEditText.SelectedImageGeometry(
             docPos = geometry.docPos,
             rect = RectF(
-                editorViewport.left + editorScrollView.left + editorEditText.left + geometry.rect.left,
-                editorViewport.top + editorScrollView.top + editorEditText.top + geometry.rect.top - editorScrollView.scrollY,
-                editorViewport.left + editorScrollView.left + editorEditText.left + geometry.rect.right,
-                editorViewport.top + editorScrollView.top + editorEditText.top + geometry.rect.bottom - editorScrollView.scrollY
+                editorViewport.left + blockSurface.left + geometry.rect.left,
+                editorViewport.top + blockSurface.top + geometry.rect.top,
+                editorViewport.left + blockSurface.left + geometry.rect.right,
+                editorViewport.top + blockSurface.top + geometry.rect.bottom
             )
         )
     }
 
     internal fun caretRect(): RectF? {
-        val rect = editorEditText.caretRect() ?: return null
+        blockSurface.isInputFocused = editorEditText.hasFocus()
+        val rect = blockSurface.selectedCaretRect() ?: return null
         return RectF(
-            editorViewport.left + editorScrollView.left + editorEditText.left + rect.left,
-            editorViewport.top + editorScrollView.top + editorEditText.top + rect.top - editorScrollView.scrollY,
-            editorViewport.left + editorScrollView.left + editorEditText.left + rect.right,
-            editorViewport.top + editorScrollView.top + editorEditText.top + rect.bottom - editorScrollView.scrollY
+            editorViewport.left + blockSurface.left + rect.left,
+            editorViewport.top + blockSurface.top + rect.top,
+            editorViewport.left + blockSurface.left + rect.right,
+            editorViewport.top + blockSurface.top + rect.bottom
         )
     }
 
     internal fun maximumImageWidthPx(): Float {
-        val availableWidth =
-            maxOf(editorEditText.width, editorEditText.measuredWidth) -
-                editorEditText.compoundPaddingLeft -
-                editorEditText.compoundPaddingRight
-        return availableWidth.coerceAtLeast(48).toFloat()
+        return blockSurface.maximumImageWidthPx()
     }
 
     internal fun clampImageSize(
@@ -389,10 +453,11 @@ class RichTextEditorView @JvmOverloads constructor(
 
     internal fun resizeImage(docPos: Int, widthPx: Float, heightPx: Float) {
         val (clampedWidth, clampedHeight) = clampImageSize(widthPx, heightPx)
-        editorEditText.resizeImageAtDocPos(docPos, clampedWidth, clampedHeight)
+        blockSurface.resizeImage(docPos, clampedWidth, clampedHeight)
     }
 
     private fun refreshOverlays() {
+        blockSurface.isInputFocused = editorEditText.hasFocus()
         remoteSelectionOverlayView.refreshGeometry()
         imageResizeOverlayView.refresh()
     }

package/dist/EditorToolbar.d.ts

@@ -4,7 +4,7 @@ import type { EditorMentionTheme, EditorToolbarTheme } from './EditorTheme';
 import type { MentionSuggestion } from './addons';
 export type EditorToolbarListType = 'bulletList' | 'orderedList';
 export type EditorToolbarHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
-export type EditorToolbarCommand = 'indentList' | 'outdentList' | 'undo' | 'redo';
+export type EditorToolbarCommand = 'indentList' | 'outdentList' | 'insertTableRowBefore' | 'insertTableRowAfter' | 'deleteTableRow' | 'insertTableColumnBefore' | 'insertTableColumnAfter' | 'deleteTableColumn' | 'moveToNextTableCell' | 'moveToPreviousTableCell' | 'undo' | 'redo';
 export type EditorToolbarGroupPresentation = 'expand' | 'menu';
 export type EditorToolbarItemPlacement = 'start' | 'scroll' | 'end';
 export type EditorToolbarDefaultIconId = 'bold' | 'italic' | 'underline' | 'strike' | 'link' | 'image' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'blockquote' | 'bulletList' | 'orderedList' | 'indentList' | 'outdentList' | 'lineBreak' | 'horizontalRule' | 'undo' | 'redo';

package/dist/EditorToolbar.js

@@ -342,6 +342,15 @@ function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic
                         return onIndentList ?? null;
                     case 'outdentList':
                         return onOutdentList ?? null;
+                    case 'insertTableRowBefore':
+                    case 'insertTableRowAfter':
+                    case 'deleteTableRow':
+                    case 'insertTableColumnBefore':
+                    case 'insertTableColumnAfter':
+                    case 'deleteTableColumn':
+                    case 'moveToNextTableCell':
+                    case 'moveToPreviousTableCell':
+                        return null;
                     case 'undo':
                         return onUndo;
                     case 'redo':
@@ -434,6 +443,16 @@ function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic
                     case 'outdentList':
                         isDisabled = !canOutdentList;
                         break;
+                    case 'insertTableRowBefore':
+                    case 'insertTableRowAfter':
+                    case 'deleteTableRow':
+                    case 'insertTableColumnBefore':
+                    case 'insertTableColumnAfter':
+                    case 'deleteTableColumn':
+                    case 'moveToNextTableCell':
+                    case 'moveToPreviousTableCell':
+                        isDisabled = !commands[item.command];
+                        break;
                     case 'undo':
                         isDisabled = !historyState.canUndo;
                         break;