@apollohg/react-native-prose-editor 0.1.1 → 0.3.0

package/README.md

@@ -1,12 +1,12 @@
-# React Native Prose Editor
+# React Native Prose Editor [![NPM version](https://img.shields.io/npm/v/@apollohg/react-native-prose-editor.svg?style=flat)](https://www.npmjs.com/package/@apollohg/react-native-prose-editor)
 
 `@apollohg/react-native-prose-editor` is a native rich text editor for React Native with a Rust document core, native iOS and Android rendering, configurable schemas, and a React-facing toolbar and theme API.
 
-This project is currently in alpha and the API, behavior, and packaging may still change.
+This project is currently in `alpha` and the API, behavior, and packaging may still change.
 
 <p align="center">
-  <img src="./docs/images/example-1.PNG" alt="Example editor screen" width="45%" />
-  <img src="./docs/images/example-2.PNG" alt="Example editor theme screen" width="45%" />
+  <img src="./docs/images/example-ios.png" alt="Example editor Android" width="45%" align="top" />
+  <img src="./docs/images/example-android.png" alt="Example editor iOS" width="45%" align="top" />
 </p>
 
 This repository contains three main pieces:
@@ -21,7 +21,8 @@ The editor already supports:
 
 - HTML and ProseMirror JSON content input/output
 - configurable schemas
-- marks such as bold, italic, underline, and strike
+- marks such as bold, italic, underline, strike, and links
+- blockquotes
 - bullet and ordered lists with indent/outdent behavior
 - hard breaks and horizontal rules
 - native @-mentions with themed suggestion UI in the toolbar area
@@ -99,14 +100,17 @@ export function EditorScreen() {
 The main extension points today are:
 
 - `schema`: provide a custom schema definition
-- `theme`: style text blocks, lists, horizontal rules, background, and toolbar chrome
+- `theme`: style text blocks, blockquotes, lists, horizontal rules, background, and toolbar chrome, including a native-looking keyboard toolbar mode
 - `toolbarItems`: define the visible toolbar controls and order
 - `onToolbarAction`: handle app-defined toolbar buttons
+- `onRequestLink`: collect or edit hyperlink URLs when a toolbar link item is pressed
 - `addons`: configure optional features like @-mentions
 - `heightBehavior`: switch between internal scrolling and auto-grow
 
 For setup and customization details, start with the [Documentation Index](./docs/README.md).
 
+For realtime collaboration, including the correct `useYjsCollaboration()` wiring, encoded-state persistence, remote cursors, and automatic reconnect behavior, see the [Collaboration Guide](./docs/modules/collaboration.md).
+
 ## Development
 
 Common commands:
@@ -132,8 +136,9 @@ npm run android:test                                  # Android Robolectric test
 - [Documentation Index](./docs/README.md): main documentation index
 - [Installation Guide](./docs/guides/installation.md): installation and local setup
 - [Getting Started](./docs/guides/getting-started.md): first setup and first editor
+- [Collaboration Guide](./docs/modules/collaboration.md): Yjs collaboration wiring, source-of-truth rules, and persistence
 - [Toolbar Setup](./docs/guides/toolbar-setup.md): toolbar setup patterns and examples
-- [Mentions Guide](./docs/guides/mentions.md): @-mentions addon setup and configuration
+- [Mentions Guide](./docs/modules/mentions.md): @-mentions addon setup and configuration
 - [Styling Guide](./docs/guides/styling.md): content, toolbar, and mention styling
 - [NativeRichTextEditor Reference](./docs/reference/native-rich-text-editor.md): component props and ref methods
 - [Design Decisions](./docs/explanations/design-decisions.md): rationale for key API and architecture decisions

package/android/build.gradle

@@ -1,10 +1,14 @@
+import groovy.json.JsonSlurper
+
 plugins {
     id 'com.android.library'
     id 'expo-module-gradle-plugin'
 }
 
+def packageJson = new JsonSlurper().parse(file('../package.json'))
+
 group = 'com.apollohg'
-version = '0.1.1'
+version = packageJson.version
 
 android {
     namespace "com.apollohg.editor"
@@ -13,7 +17,7 @@ android {
     }
     defaultConfig {
         versionCode 1
-        versionName '0.1.1'
+        versionName packageJson.version
     }
 
     // Include prebuilt Rust .so files from the package's rust/android/ directory
@@ -32,6 +36,7 @@ android {
 
 dependencies {
     implementation "androidx.appcompat:appcompat:1.7.0"
+    implementation "com.google.android.material:material:1.12.0"
     implementation "net.java.dev.jna:jna:5.14.0@aar"
 
     testImplementation "junit:junit:4.13.2"

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

@@ -4,8 +4,10 @@ import android.content.ClipboardManager
 import android.content.Context
 import android.graphics.Typeface
 import android.graphics.Rect
+import android.graphics.RectF
 import android.text.Editable
 import android.text.Layout
+import android.text.Spanned
 import android.text.StaticLayout
 import android.text.TextWatcher
 import android.util.AttributeSet
@@ -16,6 +18,7 @@ import android.view.MotionEvent
 import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import androidx.appcompat.widget.AppCompatEditText
+import kotlin.math.roundToInt
 import uniffi.editor_core.*  // UniFFI-generated bindings
 
 /**
@@ -48,6 +51,16 @@ class EditorEditText @JvmOverloads constructor(
     attrs: AttributeSet? = null,
     defStyleAttr: Int = android.R.attr.editTextStyle
 ) : AppCompatEditText(context, attrs, defStyleAttr) {
+    data class SelectedImageGeometry(
+        val docPos: Int,
+        val rect: RectF
+    )
+
+    private data class ImageSelectionRange(
+        val start: Int,
+        val end: Int
+    )
+
     /**
      * Listener interface for editor events, parallel to iOS's EditorTextViewDelegate.
      */
@@ -79,6 +92,7 @@ class EditorEditText @JvmOverloads constructor(
 
     /** Listener for editor events. */
     var editorListener: EditorListener? = null
+    var onSelectionOrContentMayChange: (() -> Unit)? = null
 
     /** The base font size in pixels used for unstyled text. */
     private var baseFontSize: Float = textSize
@@ -93,8 +107,15 @@ class EditorEditText @JvmOverloads constructor(
     var theme: EditorTheme? = null
         private set
 
+    var placeholderText: String = ""
+        set(value) {
+            field = value
+            invalidate()
+        }
+
     var heightBehavior: EditorHeightBehavior = EditorHeightBehavior.FIXED
         private set
+    private var imageResizingEnabled = true
 
     private var contentInsets: EditorContentInsets? = null
     private var viewportBottomInsetPx: Int = 0
@@ -114,6 +135,7 @@ class EditorEditText @JvmOverloads constructor(
 
     private var lastHandledHardwareKeyCode: Int? = null
     private var lastHandledHardwareKeyDownTime: Long? = null
+    private var explicitSelectedImageRange: ImageSelectionRange? = null
 
     init {
         // Configure for rich text editing.
@@ -139,6 +161,7 @@ class EditorEditText @JvmOverloads constructor(
         // Strip the default EditText theme drawable which carries implicit padding.
         // Background color is applied in setBaseStyle() / applyTheme().
         background = null
+        linksClickable = false
         updateEffectivePadding()
     }
 
@@ -160,7 +183,35 @@ class EditorEditText @JvmOverloads constructor(
         return super.dispatchKeyEvent(event)
     }
 
+    override fun onDraw(canvas: android.graphics.Canvas) {
+        super.onDraw(canvas)
+
+        if (!shouldDisplayPlaceholder()) return
+
+        val availableWidth = width - compoundPaddingLeft - compoundPaddingRight
+        if (availableWidth <= 0) return
+
+        val previousColor = paint.color
+        val saveCount = canvas.save()
+        paint.color = currentHintTextColor
+        canvas.translate(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat())
+        StaticLayout.Builder
+            .obtain(placeholderText, 0, placeholderText.length, paint, availableWidth)
+            .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+            .setIncludePad(includeFontPadding)
+            .build()
+            .draw(canvas)
+        canvas.restoreToCount(saveCount)
+        paint.color = previousColor
+    }
+
     override fun onTouchEvent(event: MotionEvent): Boolean {
+        if (event.actionMasked == MotionEvent.ACTION_DOWN && imageSpanHitAt(event.x, event.y) == null) {
+            clearExplicitSelectedImageRange()
+        }
+        if (handleImageTap(event)) {
+            return true
+        }
         if (heightBehavior == EditorHeightBehavior.FIXED) {
             val canScroll = canScrollVertically(-1) || canScrollVertically(1)
             if (canScroll) {
@@ -175,6 +226,30 @@ class EditorEditText @JvmOverloads constructor(
         return super.onTouchEvent(event)
     }
 
+    override fun performClick(): Boolean {
+        return super.performClick()
+    }
+
+    private fun isRenderedContentEmpty(content: CharSequence? = text): Boolean {
+        val renderedContent = content ?: return true
+        if (renderedContent.isEmpty()) return true
+
+        for (index in 0 until renderedContent.length) {
+            when (renderedContent[index]) {
+                EMPTY_BLOCK_PLACEHOLDER, '\n', '\r' -> continue
+                else -> return false
+            }
+        }
+
+        return true
+    }
+
+    private fun shouldDisplayPlaceholder(): Boolean {
+        return placeholderText.isNotEmpty() && isRenderedContentEmpty()
+    }
+
+    fun shouldDisplayPlaceholderForTesting(): Boolean = shouldDisplayPlaceholder()
+
     // ── Editor Binding ──────────────────────────────────────────────────
 
     /**
@@ -272,6 +347,16 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
+    fun setImageResizingEnabled(enabled: Boolean) {
+        if (imageResizingEnabled == enabled) return
+        imageResizingEnabled = enabled
+        if (!enabled) {
+            clearExplicitSelectedImageRange()
+        } else {
+            onSelectionOrContentMayChange?.invoke()
+        }
+    }
+
     fun resolveAutoGrowHeight(): Int {
         val laidOutTextHeight = if (isLaidOut) layout?.height else null
         if (laidOutTextHeight != null && laidOutTextHeight > 0) {
@@ -669,6 +754,17 @@ class EditorEditText @JvmOverloads constructor(
         applyUpdateJSON(updateJSON)
     }
 
+    fun performToolbarToggleBlockquote() {
+        if (!isEditable || isApplyingRustState || editorId == 0L) return
+        val selection = currentScalarSelection() ?: return
+        val updateJSON = editorToggleBlockquoteAtSelectionScalar(
+            editorId.toULong(),
+            selection.first.toUInt(),
+            selection.second.toUInt()
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     fun performToolbarIndentListItem() {
         if (!isEditable || isApplyingRustState || editorId == 0L) return
         val selection = currentScalarSelection() ?: return
@@ -780,7 +876,12 @@ class EditorEditText @JvmOverloads constructor(
      */
     override fun onSelectionChanged(selStart: Int, selEnd: Int) {
         super.onSelectionChanged(selStart, selEnd)
+        val spannable = text as? Spanned
+        if (spannable != null && isExactImageSpanRange(spannable, selStart, selEnd)) {
+            explicitSelectedImageRange = ImageSelectionRange(selStart, selEnd)
+        }
         ensureSelectionVisible()
+        onSelectionOrContentMayChange?.invoke()
 
         if (isApplyingRustState || editorId == 0L) return
 
@@ -840,6 +941,49 @@ class EditorEditText @JvmOverloads constructor(
         )
     }
 
+    fun selectedImageGeometry(): SelectedImageGeometry? {
+        if (!imageResizingEnabled) return null
+        val spannable = text as? Spanned ?: return null
+        val selection = resolvedSelectedImageRange(spannable) ?: return null
+        val start = selection.start
+        val end = selection.end
+        val imageSpan = spannable
+            .getSpans(start, end, BlockImageSpan::class.java)
+            .firstOrNull() ?: return null
+        val spanStart = spannable.getSpanStart(imageSpan)
+        val spanEnd = spannable.getSpanEnd(imageSpan)
+        if (spanStart != start || spanEnd != end) return null
+
+        val textLayout = layout ?: return null
+        val currentText = text?.toString() ?: return null
+        val scalarPos = PositionBridge.utf16ToScalar(spanStart, currentText)
+        val docPos = if (editorId != 0L) {
+            editorScalarToDoc(editorId.toULong(), scalarPos.toUInt()).toInt()
+        } else {
+            0
+        }
+        val line = textLayout.getLineForOffset(spanStart.coerceAtMost(maxOf(spannable.length - 1, 0)))
+        val rect = resolvedImageRect(textLayout, imageSpan, spanStart, spanEnd)
+        return SelectedImageGeometry(
+            docPos = docPos,
+            rect = rect
+        )
+    }
+
+    fun resizeImageAtDocPos(docPos: Int, widthPx: Float, heightPx: Float) {
+        if (editorId == 0L) return
+        val density = resources.displayMetrics.density
+        val widthDp = maxOf(48, (widthPx / density).roundToInt())
+        val heightDp = maxOf(48, (heightPx / density).roundToInt())
+        val updateJSON = editorResizeImageAtDocPos(
+            editorId.toULong(),
+            docPos.toUInt(),
+            widthDp.toUInt(),
+            heightDp.toUInt()
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     private fun isSelectionInsideList(): Boolean {
         if (editorId == 0L) return false
 
@@ -894,12 +1038,14 @@ class EditorEditText @JvmOverloads constructor(
             baseFontSize,
             baseTextColor,
             theme,
-            resources.displayMetrics.density
+            resources.displayMetrics.density,
+            this
         )
 
         val previousScrollX = scrollX
         val previousScrollY = scrollY
 
+        explicitSelectedImageRange = null
         isApplyingRustState = true
         setText(spannable)
         lastAuthorizedText = spannable.toString()
@@ -914,6 +1060,7 @@ class EditorEditText @JvmOverloads constructor(
         if (notifyListener) {
             editorListener?.onEditorUpdate(updateJSON)
         }
+        onSelectionOrContentMayChange?.invoke()
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
             requestLayout()
         } else {
@@ -935,16 +1082,19 @@ class EditorEditText @JvmOverloads constructor(
             baseFontSize,
             baseTextColor,
             theme,
-            resources.displayMetrics.density
+            resources.displayMetrics.density,
+            this
         )
 
         val previousScrollX = scrollX
         val previousScrollY = scrollY
 
+        explicitSelectedImageRange = null
         isApplyingRustState = true
         setText(spannable)
         lastAuthorizedText = spannable.toString()
         isApplyingRustState = false
+        onSelectionOrContentMayChange?.invoke()
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
             requestLayout()
         } else {
@@ -952,6 +1102,142 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
+    private fun handleImageTap(event: MotionEvent): Boolean {
+        if (!imageResizingEnabled) {
+            return false
+        }
+        if (event.actionMasked != MotionEvent.ACTION_DOWN && event.actionMasked != MotionEvent.ACTION_UP) {
+            return false
+        }
+        val hit = imageSpanHitAt(event.x, event.y) ?: return false
+        requestFocus()
+        selectExplicitImageRange(hit.first, hit.second)
+        if (event.actionMasked == MotionEvent.ACTION_UP) {
+            performClick()
+        }
+        return true
+    }
+
+    private fun imageSpanHitAt(x: Float, y: Float): Pair<Int, Int>? {
+        val spannable = text as? Spanned ?: return null
+        imageSpanRangeNearTouchOffset(spannable, x, y)?.let { return it }
+        val textLayout = layout ?: return null
+        return imageSpanRectHit(spannable, textLayout, x, y)
+    }
+
+    private fun imageSpanRectHit(
+        spannable: Spanned,
+        textLayout: Layout,
+        x: Float,
+        y: Float
+    ): Pair<Int, Int>? {
+        val candidateSpans = spannable.getSpans(0, spannable.length, BlockImageSpan::class.java)
+        for (span in candidateSpans) {
+            val spanStart = spannable.getSpanStart(span)
+            val spanEnd = spannable.getSpanEnd(span)
+            if (spanStart < 0 || spanEnd <= spanStart) continue
+            val rect = resolvedImageRect(textLayout, span, spanStart, spanEnd)
+            if (rect.contains(x, y)) {
+                return spanStart to spanEnd
+            }
+        }
+        return null
+    }
+
+    override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
+        super.onFocusChanged(focused, direction, previouslyFocusedRect)
+        if (!focused) {
+            clearExplicitSelectedImageRange()
+        }
+    }
+
+    private fun selectExplicitImageRange(start: Int, end: Int) {
+        explicitSelectedImageRange = ImageSelectionRange(start, end)
+        if (selectionStart == start && selectionEnd == end) {
+            onSelectionOrContentMayChange?.invoke()
+            return
+        }
+        setSelection(start, end)
+    }
+
+    private fun clearExplicitSelectedImageRange() {
+        if (explicitSelectedImageRange == null) return
+        explicitSelectedImageRange = null
+        onSelectionOrContentMayChange?.invoke()
+    }
+
+    private fun resolvedSelectedImageRange(spannable: Spanned): ImageSelectionRange? {
+        explicitSelectedImageRange?.let { explicit ->
+            if (isExactImageSpanRange(spannable, explicit.start, explicit.end)) {
+                return explicit
+            }
+            explicitSelectedImageRange = null
+        }
+
+        val start = selectionStart
+        val end = selectionEnd
+        if (!isExactImageSpanRange(spannable, start, end)) return null
+        return ImageSelectionRange(start, end)
+    }
+
+    private fun isExactImageSpanRange(spannable: Spanned, start: Int, end: Int): Boolean {
+        if (start < 0 || end != start + 1) return false
+        val imageSpan = spannable
+            .getSpans(start, end, BlockImageSpan::class.java)
+            .firstOrNull() ?: return false
+        return spannable.getSpanStart(imageSpan) == start && spannable.getSpanEnd(imageSpan) == end
+    }
+
+    private fun imageSpanRangeNearTouchOffset(
+        spannable: Spanned,
+        x: Float,
+        y: Float
+    ): Pair<Int, Int>? {
+        val safeOffset = runCatching { getOffsetForPosition(x, y) }.getOrNull() ?: return null
+        val nearbyOffsets = linkedSetOf(
+            safeOffset,
+            (safeOffset - 1).coerceAtLeast(0),
+            (safeOffset + 1).coerceAtMost(spannable.length)
+        )
+        for (offset in nearbyOffsets) {
+            val searchStart = (offset - 1).coerceAtLeast(0)
+            val searchEnd = (offset + 1).coerceAtMost(spannable.length)
+            val imageSpan = spannable
+                .getSpans(searchStart, searchEnd, BlockImageSpan::class.java)
+                .firstOrNull() ?: continue
+            val spanStart = spannable.getSpanStart(imageSpan)
+            val spanEnd = spannable.getSpanEnd(imageSpan)
+            if (spanStart >= 0 && spanEnd > spanStart) {
+                return spanStart to spanEnd
+            }
+        }
+        return null
+    }
+
+    private fun resolvedImageRect(
+        textLayout: Layout,
+        imageSpan: BlockImageSpan,
+        spanStart: Int,
+        spanEnd: Int
+    ): RectF {
+        imageSpan.currentDrawRect()?.let { drawnRect ->
+            return drawnRect
+        }
+
+        val safeOffset = spanStart.coerceAtMost(maxOf((text?.length ?: 0) - 1, 0))
+        val line = textLayout.getLineForOffset(safeOffset)
+        val startHorizontal = textLayout.getPrimaryHorizontal(spanStart)
+        val endHorizontal = textLayout.getPrimaryHorizontal(spanEnd)
+        val (widthPx, heightPx) = imageSpan.currentSizePx()
+        val left = compoundPaddingLeft + minOf(startHorizontal, endHorizontal)
+        val right = compoundPaddingLeft + maxOf(
+            maxOf(startHorizontal, endHorizontal),
+            minOf(startHorizontal, endHorizontal) + widthPx
+        )
+        val top = extendedPaddingTop + textLayout.getLineBottom(line) - heightPx
+        return RectF(left, top.toFloat(), right, top + heightPx.toFloat())
+    }
+
     /**
      * Apply a selection from a parsed JSON selection object.
      *
@@ -1052,6 +1338,7 @@ class EditorEditText @JvmOverloads constructor(
     }
 
     companion object {
+        private const val EMPTY_BLOCK_PLACEHOLDER = '\u200B'
         private const val LOG_TAG = "NativeEditor"
     }
 }

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

@@ -89,6 +89,27 @@ data class EditorHorizontalRuleTheme(
     }
 }
 
+data class EditorBlockquoteTheme(
+    val text: EditorTextStyle? = null,
+    val indent: Float? = null,
+    val borderColor: Int? = null,
+    val borderWidth: Float? = null,
+    val markerGap: Float? = null
+) {
+    companion object {
+        fun fromJson(json: JSONObject?): EditorBlockquoteTheme? {
+            json ?: return null
+            return EditorBlockquoteTheme(
+                text = EditorTextStyle.fromJson(json.optJSONObject("text")),
+                indent = json.optNullableFloat("indent"),
+                borderColor = parseColor(json.optNullableString("borderColor")),
+                borderWidth = json.optNullableFloat("borderWidth"),
+                markerGap = json.optNullableFloat("markerGap")
+            )
+        }
+    }
+}
+
 data class EditorMentionTheme(
     val textColor: Int? = null,
     val backgroundColor: Int? = null,
@@ -130,7 +151,22 @@ data class EditorMentionTheme(
     }
 }
 
+enum class EditorToolbarAppearance {
+    CUSTOM,
+    NATIVE;
+
+    companion object {
+        fun fromRaw(raw: String?): EditorToolbarAppearance? =
+            when (raw?.trim()?.lowercase()) {
+                "custom" -> CUSTOM
+                "native" -> NATIVE
+                else -> null
+            }
+    }
+}
+
 data class EditorToolbarTheme(
+    val appearance: EditorToolbarAppearance? = null,
     val backgroundColor: Int? = null,
     val borderColor: Int? = null,
     val borderWidth: Float? = null,
@@ -144,10 +180,21 @@ data class EditorToolbarTheme(
     val buttonActiveBackgroundColor: Int? = null,
     val buttonBorderRadius: Float? = null
 ) {
+    fun resolvedKeyboardOffset(): Float = keyboardOffset ?: if (appearance == EditorToolbarAppearance.NATIVE) 8f else 0f
+
+    fun resolvedHorizontalInset(): Float = horizontalInset ?: if (appearance == EditorToolbarAppearance.NATIVE) 0f else 0f
+
+    fun resolvedBorderRadius(): Float = if (appearance == EditorToolbarAppearance.NATIVE) 32f else (borderRadius ?: 0f)
+
+    fun resolvedBorderWidth(): Float = borderWidth ?: if (appearance == EditorToolbarAppearance.NATIVE) 0f else 1f
+
+    fun resolvedButtonBorderRadius(): Float = if (appearance == EditorToolbarAppearance.NATIVE) 20f else (buttonBorderRadius ?: 6f)
+
     companion object {
         fun fromJson(json: JSONObject?): EditorToolbarTheme? {
             json ?: return null
             return EditorToolbarTheme(
+                appearance = EditorToolbarAppearance.fromRaw(json.optNullableString("appearance")),
                 backgroundColor = parseColor(json.optNullableString("backgroundColor")),
                 borderColor = parseColor(json.optNullableString("borderColor")),
                 borderWidth = json.optNullableFloat("borderWidth"),
@@ -187,6 +234,7 @@ data class EditorContentInsets(
 data class EditorTheme(
     val text: EditorTextStyle? = null,
     val paragraph: EditorTextStyle? = null,
+    val blockquote: EditorBlockquoteTheme? = null,
     val headings: Map<String, EditorTextStyle> = emptyMap(),
     val list: EditorListTheme? = null,
     val horizontalRule: EditorHorizontalRuleTheme? = null,
@@ -216,6 +264,7 @@ data class EditorTheme(
             return EditorTheme(
                 text = EditorTextStyle.fromJson(root.optJSONObject("text")),
                 paragraph = EditorTextStyle.fromJson(root.optJSONObject("paragraph")),
+                blockquote = EditorBlockquoteTheme.fromJson(root.optJSONObject("blockquote")),
                 headings = headings,
                 list = EditorListTheme.fromJson(root.optJSONObject("list")),
                 horizontalRule = EditorHorizontalRuleTheme.fromJson(root.optJSONObject("horizontalRule")),
@@ -228,8 +277,9 @@ data class EditorTheme(
         }
     }
 
-    fun effectiveTextStyle(nodeType: String): EditorTextStyle {
+    fun effectiveTextStyle(nodeType: String, inBlockquote: Boolean = false): EditorTextStyle {
         var style = text ?: EditorTextStyle()
+        style = style.mergedWith(if (inBlockquote) blockquote?.text else null)
         if (nodeType == "paragraph") {
             style = style.mergedWith(paragraph)
             if (paragraph?.lineHeight == null) {