@openeditor/react-native-prose-editor 0.0.9 → 0.0.10

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

@@ -449,7 +449,7 @@ class NativeEditorModule : Module() {
                 view.setEditable(editable)
             }
             Prop("placeholder") { view: NativeEditorExpoView, placeholder: String ->
-                view.richTextView.editorEditText.placeholderText = placeholder
+                view.richTextView.blockSurface.placeholder = placeholder
             }
             Prop("autoFocus") { view: NativeEditorExpoView, autoFocus: Boolean ->
                 view.setAutoFocus(autoFocus)

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

@@ -5,159 +5,62 @@ import android.graphics.Color
 import android.graphics.RectF
 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
 import uniffi.editor_core.*
 
-/** Container view that owns the native editor text field. */
+/**
+ * The single Android editor host. Its only text inputs are the editable leaves
+ * owned by [NativeBlockEditorSurface]; no whole-document EditText exists.
+ */
 class RichTextEditorView @JvmOverloads constructor(
     context: Context,
     attrs: AttributeSet? = null,
     defStyleAttr: Int = 0
 ) : LinearLayout(context, attrs, defStyleAttr) {
-    val editorViewport: FrameLayout
+    val editorViewport = FrameLayout(context)
+    val blockSurface = NativeBlockEditorSurface(context)
+    private val remoteSelectionOverlayView = RemoteSelectionOverlayView(context)
+    private val imageResizeOverlayView = ImageResizeOverlayView(context)
 
-    class EditorScrollView(context: Context) : ScrollView(context) {
-        private fun updateParentIntercept(action: Int) {
-            val canScroll = canScrollVertically(-1) || canScrollVertically(1)
-            if (!canScroll) return
-            when (action) {
-                MotionEvent.ACTION_DOWN,
-                MotionEvent.ACTION_MOVE -> parent?.requestDisallowInterceptTouchEvent(true)
-                MotionEvent.ACTION_UP,
-                MotionEvent.ACTION_CANCEL -> parent?.requestDisallowInterceptTouchEvent(false)
-            }
-        }
-
-        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-            updateParentIntercept(ev.actionMasked)
-            return super.onInterceptTouchEvent(ev)
-        }
-
-        override fun onTouchEvent(ev: MotionEvent): Boolean {
-            updateParentIntercept(ev.actionMasked)
-            return super.onTouchEvent(ev)
-        }
-    }
-
-    val editorEditText: EditorEditText
-    val editorScrollView: EditorScrollView
-    val blockSurface: NativeBlockEditorSurface
-    private val remoteSelectionOverlayView: RemoteSelectionOverlayView
-    private val imageResizeOverlayView: ImageResizeOverlayView
-
-    private var heightBehavior: EditorHeightBehavior = EditorHeightBehavior.FIXED
+    private var currentEditorId = 0L
+    private var heightBehavior = EditorHeightBehavior.FIXED
     private var imageResizingEnabled = true
+    private var viewportBottomInsetPx = 0
+    private var deferEditorUnbindOnDetach = false
     private var theme: EditorTheme? = null
-    private var baseBackgroundColor: Int = Color.WHITE
-    private var viewportBottomInsetPx: Int = 0
-    internal var appliedCornerRadiusPx: Float = 0f
-    internal var appliedBackgroundColorForTesting: Int = Color.WHITE
+    private var baseBackgroundColor = Color.WHITE
 
-    private var currentEditorId: Long = 0
-    private var deferEditorUnbindOnDetach = false
-    private var isSyncingBlockSurfaceUpdateToInputAdapter = false
+    internal var appliedCornerRadiusPx = 0f
+    internal var appliedBackgroundColorForTesting = Color.WHITE
     internal var onBeforeDetachedFromWindow: (() -> Unit)? = null
+    var onSelectionChange: ((Int, Int) -> Unit)? = null
+    var onEditorUpdate: ((String) -> Unit)? = null
+    var onFocusChange: ((Boolean) -> Unit)? = null
 
-    /** Binds or unbinds the Rust editor instance. */
     var editorId: Long
         get() = currentEditorId
-        set(value) {
-            setEditorId(value, bindEditor = true)
-        }
+        set(value) = bindEditor(value)
+
+    val activeEditText get() = blockSurface.activeEditText
+    val isEditorFocused get() = blockSurface.isEditorFocused
+    val editorIsEditable get() = blockSurface.isEditable
+    val editorTheme get() = theme
 
     init {
         orientation = VERTICAL
+        editorViewport.addView(blockSurface, matchParentParams())
+        editorViewport.addView(remoteSelectionOverlayView, matchParentParams())
+        editorViewport.addView(imageResizeOverlayView, matchParentParams())
+        addView(editorViewport, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
 
-        editorEditText = EditorEditText(context)
-        editorScrollView = EditorScrollView(context).apply {
-            clipToPadding = false
-            isFillViewport = false
-            alpha = 0.01f
-        }
-        blockSurface = NativeBlockEditorSurface(context)
-        editorViewport = FrameLayout(context)
-        remoteSelectionOverlayView = RemoteSelectionOverlayView(context)
-        imageResizeOverlayView = ImageResizeOverlayView(context)
-        editorScrollView.addView(editorEditText, createEditorLayoutParams())
-        editorViewport.addView(
-            editorScrollView,
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-        )
-        editorViewport.addView(
-            blockSurface,
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-        )
-        editorViewport.addView(
-            remoteSelectionOverlayView,
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-        )
-        editorViewport.addView(
-            imageResizeOverlayView,
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-        )
         remoteSelectionOverlayView.bind(this)
         imageResizeOverlayView.bind(this)
-        editorScrollView.setOnScrollChangeListener { _, _, _, _, _ ->
-            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()
-        updateScrollContainerInsets()
+        blockSurface.onSelectionChange = { anchor, head -> onSelectionChange?.invoke(anchor, head) }
+        blockSurface.onEditorUpdate = { update -> onEditorUpdate?.invoke(update) }
+        blockSurface.onFocusChange = { focused -> onFocusChange?.invoke(focused) }
+        updateAppearance()
     }
 
     fun configure(
@@ -166,257 +69,134 @@ class RichTextEditorView @JvmOverloads constructor(
         backgroundColor: Int = Color.WHITE
     ) {
         baseBackgroundColor = backgroundColor
-        editorEditText.setBaseStyle(textSizePx, textColor, backgroundColor)
         blockSurface.configure(textSizePx, textColor, backgroundColor)
-        updateScrollContainerAppearance()
-        refreshOverlays()
+        updateAppearance()
     }
 
     fun applyTheme(theme: EditorTheme?) {
         this.theme = theme
-        val previousScrollY = editorScrollView.scrollY
-        editorEditText.applyTheme(theme)
         blockSurface.applyTheme(theme)
-        updateScrollContainerAppearance()
-        updateScrollContainerInsets()
-        if (heightBehavior == EditorHeightBehavior.FIXED) {
-            editorScrollView.post {
-                val childHeight = editorScrollView.getChildAt(0)?.height ?: 0
-                val maxScrollY = maxOf(
-                    0,
-                    childHeight + editorScrollView.paddingTop + editorScrollView.paddingBottom - editorScrollView.height
-                )
-                editorScrollView.scrollTo(0, previousScrollY.coerceIn(0, maxScrollY))
-                refreshOverlays()
-            }
-        }
-        refreshOverlays()
+        updateAppearance()
     }
 
     fun setEditable(editable: Boolean) {
-        editorEditText.isEditable = editable
         blockSurface.isEditable = editable
-        if (!editable) editorEditText.clearFocus()
+        if (!editable) blurEditor()
     }
 
-    fun setHeightBehavior(heightBehavior: EditorHeightBehavior) {
-        if (this.heightBehavior == heightBehavior) return
-        this.heightBehavior = heightBehavior
-        editorEditText.setHeightBehavior(heightBehavior)
-        editorEditText.layoutParams = createEditorLayoutParams()
-        editorViewport.layoutParams = createContainerLayoutParams()
-        editorScrollView.isVerticalScrollBarEnabled = heightBehavior == EditorHeightBehavior.FIXED
-        editorScrollView.overScrollMode = if (heightBehavior == EditorHeightBehavior.FIXED) {
-            OVER_SCROLL_IF_CONTENT_SCROLLS
-        } 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()
+    fun setHeightBehavior(value: EditorHeightBehavior) {
+        heightBehavior = value
+        blockSurface.isScrollingEnabled = value == EditorHeightBehavior.FIXED
+        blockSurface.isVerticalScrollBarEnabled = value == EditorHeightBehavior.FIXED
+        layoutParams = createContainerLayoutParams()
         requestLayout()
     }
 
     fun setImageResizingEnabled(enabled: Boolean) {
-        if (imageResizingEnabled == enabled) return
         imageResizingEnabled = enabled
-        editorEditText.setImageResizingEnabled(enabled)
-        refreshOverlays()
+        imageResizeOverlayView.refresh()
     }
 
-    fun setViewportBottomInsetPx(bottomInsetPx: Int) {
-        val clampedInset = bottomInsetPx.coerceAtLeast(0)
-        if (viewportBottomInsetPx == clampedInset) return
-        viewportBottomInsetPx = clampedInset
-        updateScrollContainerInsets()
-        editorEditText.setViewportBottomInsetPx(clampedInset)
-        refreshOverlays()
+    fun setViewportBottomInsetPx(value: Int) {
+        viewportBottomInsetPx = value.coerceAtLeast(0)
+        blockSurface.setPadding(
+            blockSurface.paddingLeft,
+            blockSurface.paddingTop,
+            blockSurface.paddingRight,
+            viewportBottomInsetPx
+        )
         requestLayout()
     }
 
-    internal fun viewportBottomInsetPxForTesting(): Int = viewportBottomInsetPx
-
-    fun setRemoteSelections(selections: List<RemoteSelectionDecoration>) {
+    internal fun viewportBottomInsetPxForTesting() = viewportBottomInsetPx
+    fun setRemoteSelections(selections: List<RemoteSelectionDecoration>) =
         remoteSelectionOverlayView.setRemoteSelections(selections)
-    }
-
-    fun refreshRemoteSelections() {
-        if (!remoteSelectionOverlayView.hasSelectionsOrCachedGeometry()) return
-        remoteSelectionOverlayView.refreshGeometry()
-    }
-
-    fun imageResizeOverlayRectForTesting(): android.graphics.RectF? =
-        imageResizeOverlayView.visibleRectForTesting()
-
-    fun resizeSelectedImageForTesting(widthPx: Float, heightPx: Float) {
-        imageResizeOverlayView.simulateResizeForTesting(widthPx, heightPx)
-    }
-
-    fun remoteSelectionDebugSnapshotsForTesting(): List<RemoteSelectionDebugSnapshot> =
-        remoteSelectionOverlayView.debugSnapshotsForTesting()
-
+    fun refreshRemoteSelections() = remoteSelectionOverlayView.refreshGeometry()
+    fun remoteSelectionDebugSnapshotsForTesting() = remoteSelectionOverlayView.debugSnapshotsForTesting()
     fun setRemoteSelectionEditorIdForTesting(editorId: Long) {
         remoteSelectionOverlayView.editorIdOverrideForTesting = editorId
     }
+    fun imageResizeOverlayRectForTesting() = imageResizeOverlayView.visibleRectForTesting()
+    fun resizeSelectedImageForTesting(widthPx: Float, heightPx: Float) =
+        imageResizeOverlayView.simulateResizeForTesting(widthPx, heightPx)
 
     fun setContent(html: String) {
         if (editorId == 0L) return
-        editorSetHtml(editorId.toULong(), html)
-        applyFullStateToInputAndSurface(editorGetCurrentState(editorId.toULong()))
+        applyEditorUpdate(editorSetHtml(editorId.toULong(), html))
     }
 
     fun setContent(json: org.json.JSONObject) {
         if (editorId == 0L) return
-        editorSetJson(editorId.toULong(), json.toString())
-        applyFullStateToInputAndSurface(editorGetCurrentState(editorId.toULong()))
+        applyEditorUpdate(editorSetJson(editorId.toULong(), json.toString()))
     }
 
-    private fun applyFullStateToInputAndSurface(stateJSON: String) {
-        isSyncingBlockSurfaceUpdateToInputAdapter = true
-        try {
-            editorEditText.applyUpdateJSON(
-                stateJSON,
-                notifyListener = false,
-                refreshInputConnectionForExternalUpdate = true
-            )
-        } finally {
-            isSyncingBlockSurfaceUpdateToInputAdapter = false
-        }
-        blockSurface.applyUpdateJSON(stateJSON, editorId)
-    }
+    fun focusEditor() = blockSurface.focus()
+    fun blurEditor() = blockSurface.blur()
+    fun hasActiveComposition() = blockSurface.hasActiveComposition()
+    fun currentScalarSelection() = blockSurface.currentScalarSelection()
+    fun activeDocPositionForUtf16Offset(offset: Int) = blockSurface.activeDocPositionForUtf16Offset(offset)
+    fun applyEditorUpdate(updateJSON: String) = blockSurface.applyUpdateJSON(updateJSON, editorId)
+    fun setAutoCapitalize(value: String?) = blockSurface.setAutoCapitalize(value)
+    fun setAutoCorrect(value: Boolean?) = blockSurface.setAutoCorrect(value)
+    fun setKeyboardType(value: String?) = blockSurface.setKeyboardType(value)
 
-    internal fun rebindEditorIfNeeded(notifyListener: Boolean = true) {
-        if (editorId != 0L && editorEditText.editorId != editorId) {
-            setEditorId(editorId, bindEditor = true, notifyListener = notifyListener)
-        }
-    }
-
-    internal fun setEditorIdWhileDetached(value: Long) {
-        setEditorId(value, bindEditor = false)
-    }
-
-    internal fun deferEditorUnbindOnNextDetach() {
-        deferEditorUnbindOnDetach = true
+    fun performEditorCommand(command: () -> String): String {
+        val update = command()
+        applyEditorUpdate(update)
+        onEditorUpdate?.invoke(update)
+        return update
     }
 
-    internal fun clearDeferredEditorUnbind() {
-        deferEditorUnbindOnDetach = false
+    internal fun rebindEditorIfNeeded(notifyListener: Boolean = true) {
+        if (editorId != 0L) applyEditorUpdate(editorGetCurrentState(editorId.toULong()))
     }
 
+    internal fun setEditorIdWhileDetached(value: Long) = bindEditor(value)
+    internal fun deferEditorUnbindOnNextDetach() { deferEditorUnbindOnDetach = true }
+    internal fun clearDeferredEditorUnbind() { deferEditorUnbindOnDetach = false }
     internal fun unbindEditorForDetachedViewIfNeeded() {
-        if (isAttachedToWindow) return
+        if (!deferEditorUnbindOnDetach) blockSurface.bind(0)
         deferEditorUnbindOnDetach = false
-        if (editorId != 0L) {
-            editorEditText.unbindEditor()
-        }
     }
 
-    private fun setEditorId(value: Long, bindEditor: Boolean, notifyListener: Boolean = true) {
-        val targetBoundEditorId = if (bindEditor) value else 0L
-        if (currentEditorId == value && editorEditText.editorId == targetBoundEditorId) return
-        if (currentEditorId != value || editorEditText.editorId != targetBoundEditorId) {
-            editorEditText.discardTransientNativeInputForEditorRebind()
-        }
+    private fun bindEditor(value: Long) {
+        if (currentEditorId == value) return
         currentEditorId = value
         blockSurface.bind(value)
-        if (bindEditor && value != 0L) {
-            editorEditText.bindEditor(value, notifyListener = notifyListener)
-        } else {
-            editorEditText.unbindEditor()
-        }
-        refreshOverlays()
+        if (value != 0L) applyEditorUpdate(editorGetCurrentState(value.toULong()))
     }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        clearDeferredEditorUnbind()
-        rebindEditorIfNeeded()
+        rebindEditorIfNeeded(false)
     }
 
     override fun onDetachedFromWindow() {
         onBeforeDetachedFromWindow?.invoke()
+        unbindEditorForDetachedViewIfNeeded()
         super.onDetachedFromWindow()
-        if (editorId != 0L && !deferEditorUnbindOnDetach) {
-            editorEditText.unbindEditor()
-        }
     }
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        if (heightBehavior != EditorHeightBehavior.AUTO_GROW) {
-            super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-            return
-        }
-
-        val childWidthSpec = getChildMeasureSpec(
-            widthMeasureSpec,
-            paddingLeft + paddingRight,
-            editorViewport.layoutParams.width
-        )
-        val childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
-        editorViewport.measure(childWidthSpec, childHeightSpec)
-
-        val measuredWidth = resolveSize(
-            editorViewport.measuredWidth + paddingLeft + paddingRight,
-            widthMeasureSpec
-        )
-        val desiredHeight = editorViewport.measuredHeight + paddingTop + paddingBottom
-        val measuredHeight = when (MeasureSpec.getMode(heightMeasureSpec)) {
-            MeasureSpec.AT_MOST -> desiredHeight.coerceAtMost(MeasureSpec.getSize(heightMeasureSpec))
-            else -> desiredHeight
-        }
-        setMeasuredDimension(measuredWidth, measuredHeight)
-    }
-
-    private fun updateScrollContainerAppearance() {
-        val cornerRadiusPx = (theme?.borderRadius ?: 0f) * resources.displayMetrics.density
-        val backgroundColor = theme?.backgroundColor ?: baseBackgroundColor
-        editorViewport.background = GradientDrawable().apply {
-            cornerRadius = cornerRadiusPx
-            setColor(backgroundColor)
-        }
-        editorViewport.clipToOutline = cornerRadiusPx > 0f
-        editorScrollView.setBackgroundColor(Color.TRANSPARENT)
-        appliedCornerRadiusPx = cornerRadiusPx
-        appliedBackgroundColorForTesting = backgroundColor
-    }
-
-    private fun updateScrollContainerInsets() {
-        if (heightBehavior != EditorHeightBehavior.FIXED) {
-            editorScrollView.setPadding(0, 0, 0, 0)
-            return
-        }
-
-        val density = resources.displayMetrics.density
-        val topInset = ((theme?.contentInsets?.top ?: 0f) * density).toInt()
-        val bottomInset = ((theme?.contentInsets?.bottom ?: 0f) * density).toInt()
-        editorScrollView.setPadding(0, topInset, 0, bottomInset + viewportBottomInsetPx)
-    }
-
-    private fun createContainerLayoutParams(): LayoutParams =
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
-            LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)
+            val childWidth = getChildMeasureSpec(widthMeasureSpec, paddingLeft + paddingRight, LayoutParams.MATCH_PARENT)
+            val childHeight = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
+            editorViewport.measure(childWidth, childHeight)
+            setMeasuredDimension(
+                resolveSize(editorViewport.measuredWidth + paddingLeft + paddingRight, widthMeasureSpec),
+                editorViewport.measuredHeight + paddingTop + paddingBottom
+            )
         } else {
-            LayoutParams(LayoutParams.MATCH_PARENT, 0, 1f)
+            super.onMeasure(widthMeasureSpec, heightMeasureSpec)
         }
+    }
 
-    private fun createEditorLayoutParams(): FrameLayout.LayoutParams =
-        FrameLayout.LayoutParams(
-            ViewGroup.LayoutParams.MATCH_PARENT,
-            ViewGroup.LayoutParams.WRAP_CONTENT
-        )
-
-    internal fun selectedImageGeometry(): EditorEditText.SelectedImageGeometry? {
+    internal fun selectedImageGeometry(): SelectedImageGeometry? {
         if (!imageResizingEnabled) return null
         val geometry = blockSurface.selectedImageGeometry() ?: return null
-        return EditorEditText.SelectedImageGeometry(
-            docPos = geometry.docPos,
-            rect = RectF(
+        return SelectedImageGeometry(
+            geometry.docPos,
+            RectF(
                 editorViewport.left + blockSurface.left + geometry.rect.left,
                 editorViewport.top + blockSurface.top + geometry.rect.top,
                 editorViewport.left + blockSurface.left + geometry.rect.right,
@@ -426,7 +206,6 @@ class RichTextEditorView @JvmOverloads constructor(
     }
 
     internal fun caretRect(): RectF? {
-        blockSurface.isInputFocused = editorEditText.hasFocus()
         val rect = blockSurface.selectedCaretRect() ?: return null
         return RectF(
             editorViewport.left + blockSurface.left + rect.left,
@@ -436,29 +215,37 @@ class RichTextEditorView @JvmOverloads constructor(
         )
     }
 
-    internal fun maximumImageWidthPx(): Float {
-        return blockSurface.maximumImageWidthPx()
-    }
-
-    internal fun clampImageSize(
-        widthPx: Float,
-        heightPx: Float,
-        maximumWidthPx: Float = maximumImageWidthPx()
-    ): Pair<Float, Float> {
-        val aspectRatio = maxOf(widthPx / maxOf(heightPx, 1f), 0.1f)
-        val clampedWidth = minOf(maxOf(48f, maximumWidthPx), maxOf(48f, widthPx))
-        val clampedHeight = maxOf(48f, clampedWidth / aspectRatio)
-        return clampedWidth to clampedHeight
+    internal fun maximumImageWidthPx() = blockSurface.maximumImageWidthPx()
+    internal fun clampImageSize(widthPx: Float, heightPx: Float, maximumWidthPx: Float = maximumImageWidthPx()): Pair<Float, Float> {
+        val ratio = maxOf(widthPx / maxOf(heightPx, 1f), 0.1f)
+        val width = minOf(maxOf(48f, maximumWidthPx), maxOf(48f, widthPx))
+        return width to maxOf(48f, width / ratio)
     }
-
     internal fun resizeImage(docPos: Int, widthPx: Float, heightPx: Float) {
-        val (clampedWidth, clampedHeight) = clampImageSize(widthPx, heightPx)
-        blockSurface.resizeImage(docPos, clampedWidth, clampedHeight)
+        val size = clampImageSize(widthPx, heightPx)
+        blockSurface.resizeImage(docPos, size.first, size.second)
     }
 
-    private fun refreshOverlays() {
-        blockSurface.isInputFocused = editorEditText.hasFocus()
-        remoteSelectionOverlayView.refreshGeometry()
-        imageResizeOverlayView.refresh()
+    private fun updateAppearance() {
+        val backgroundColor = theme?.backgroundColor ?: baseBackgroundColor
+        val radius = (theme?.borderRadius ?: 0f) * resources.displayMetrics.density
+        appliedCornerRadiusPx = radius
+        appliedBackgroundColorForTesting = backgroundColor
+        background = GradientDrawable().apply {
+            shape = GradientDrawable.RECTANGLE
+            setColor(backgroundColor)
+            cornerRadius = radius
+        }
+        clipToOutline = radius > 0f
     }
+
+    private fun createContainerLayoutParams() = LayoutParams(
+        LayoutParams.MATCH_PARENT,
+        if (heightBehavior == EditorHeightBehavior.AUTO_GROW) LayoutParams.WRAP_CONTENT else LayoutParams.MATCH_PARENT
+    )
+
+    private fun matchParentParams() = FrameLayout.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+    )
 }

package/dist/EditorTheme.d.ts

@@ -69,6 +69,13 @@ export interface EditorCodeBlockTheme {
     paddingHorizontal?: number;
     paddingVertical?: number;
 }
+export interface EditorTableTheme {
+    cellBackgroundColor?: string;
+    headerBackgroundColor?: string;
+    borderColor?: string;
+    selectionBackgroundColor?: string;
+    selectionBorderColor?: string;
+}
 export type EditorToolbarAppearance = 'custom' | 'native';
 export interface EditorToolbarTheme {
     appearance?: EditorToolbarAppearance;
@@ -99,6 +106,7 @@ export interface EditorTheme {
     paragraph?: EditorTextStyle;
     blockquote?: EditorBlockquoteTheme;
     codeBlock?: EditorCodeBlockTheme;
+    table?: EditorTableTheme;
     headings?: EditorHeadingTheme;
     list?: EditorListTheme;
     horizontalRule?: EditorHorizontalRuleTheme;