@apollohg/react-native-rich-text-editor 2.0.0

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

@@ -0,0 +1,117 @@
+package com.apollohg.editor
+
+import kotlin.math.roundToInt
+import org.json.JSONArray
+import org.json.JSONObject
+
+object LayoutConstants {
+    /** Base indentation per depth level (pixels at base scale). */
+    const val INDENT_PER_DEPTH: Float = 24f
+
+    /** Width reserved for the list bullet/number (pixels at base scale). */
+    const val LIST_MARKER_WIDTH: Float = 36f
+
+    /** Gap between the list marker and the text that follows (pixels at base scale). */
+    const val LIST_MARKER_TEXT_GAP: Float = 8f
+
+    /** Height of the horizontal rule separator line (pixels). */
+    const val HORIZONTAL_RULE_HEIGHT: Float = 1f
+
+    /** Vertical padding above and below the horizontal rule (pixels). */
+    const val HORIZONTAL_RULE_VERTICAL_PADDING: Float = 8f
+
+    /** Total leading inset reserved for each blockquote depth. */
+    const val BLOCKQUOTE_INDENT: Float = 18f
+
+    /** Width of the rendered blockquote border bar (pixels at base scale). */
+    const val BLOCKQUOTE_BORDER_WIDTH: Float = 3f
+
+    /** Gap between the blockquote border bar and the text that follows. */
+    const val BLOCKQUOTE_MARKER_GAP: Float = 8f
+
+    /** Bullet character for unordered list items. */
+    const val UNORDERED_LIST_BULLET: String = "\u2022 "
+
+    /** Scale factor applied only to unordered list marker glyphs. */
+    const val UNORDERED_LIST_MARKER_FONT_SCALE: Float = 2.0f
+
+    /** Rendered marker text for task list items. Must stay in sync with the
+     *  Rust core's task_list_marker_string (render/mod.rs) — the marker's
+     *  scalar length is part of the position-mapping contract. */
+    const val TASK_LIST_MARKER_CHECKED: String = "☑ "
+    const val TASK_LIST_MARKER_UNCHECKED: String = "☐ "
+
+    /** Scale factor applied to task checkbox marker glyphs. */
+    const val TASK_LIST_MARKER_FONT_SCALE: Float = 1.55f
+
+    /** Default visual treatment for link text when no explicit theme color exists. */
+    const val DEFAULT_LINK_COLOR: Int = 0xFF1B73E8.toInt()
+
+    /** Object replacement character used for void block elements. */
+    const val OBJECT_REPLACEMENT_CHARACTER: String = "\uFFFC"
+
+    /** Zero-width placeholder used to preserve trailing hard-break lines. */
+    const val SYNTHETIC_PLACEHOLDER_CHARACTER: String = "\u200B"
+
+    /** Background color for inline code spans (light gray). */
+    const val CODE_BACKGROUND_COLOR: Int = 0x1A000000 // 10% black
+}
+
+data class BlockContext(
+    val nodeType: String,
+    val depth: Int,
+    val listContext: JSONObject?,
+    val topLevelChildIndex: Int? = null,
+    var markerPending: Boolean = false,
+    var renderStart: Int = 0,
+    val language: String? = null
+)
+
+data class AtomRenderConfiguration(
+    val registeredNodeTypes: Set<String>,
+    val estimatedHeightsDp: Map<String, Float>,
+    val measuredHeightsPx: Map<String, Int>
+) {
+    fun reservedHeightPx(atomKey: String, nodeType: String, density: Float): Int =
+        measuredHeightsPx[atomKey]
+            ?: ((estimatedHeightsDp[nodeType] ?: 0f) * density).roundToInt()
+
+    companion object {
+        fun fromJson(json: String?): AtomRenderConfiguration? {
+            if (json == null) return null
+            val raw = try {
+                JSONObject(json)
+            } catch (_: Exception) {
+                return null
+            }
+            val nodeTypes = buildSet {
+                val values = raw.optJSONArray("nodeTypes") ?: JSONArray()
+                for (index in 0 until values.length()) {
+                    (values.opt(index) as? String)?.let(::add)
+                }
+            }
+            val estimatedHeights = buildMap {
+                val values = raw.optJSONObject("estimatedHeights") ?: JSONObject()
+                for (nodeType in values.keys()) {
+                    val height = (values.opt(nodeType) as? Number)?.toFloat() ?: continue
+                    if (height.isFinite() && height >= 0f) {
+                        put(nodeType, height)
+                    }
+                }
+            }
+            return AtomRenderConfiguration(nodeTypes, estimatedHeights, emptyMap())
+        }
+    }
+}
+
+internal data class PendingLeadingMargin(
+    val indentPx: Int,
+    val restIndentPx: Int?,
+    val blockquoteIndentPx: Int = 0,
+    val blockquoteStripeColor: Int? = null,
+    val blockquoteStripeWidthPx: Int = 0,
+    val blockquoteGapWidthPx: Int = 0,
+    val blockquoteBaseIndentPx: Int = 0
+)
+
+internal data class PendingCodeBlockSpan(val start: Int, val end: Int)

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

@@ -0,0 +1,337 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.text.style.ReplacementSpan
+import android.util.Log
+import android.view.View
+import java.lang.ref.WeakReference
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+
+internal class AtomBlockSpan(
+    val atomKey: String,
+    val nodeType: String,
+    val docPos: Int,
+    var reservedHeightPx: Int,
+    val hasStableAtomId: Boolean,
+    val isDirectRootChild: Boolean
+) : ReplacementSpan() {
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int {
+        fm?.apply {
+            ascent = -reservedHeightPx
+            top = ascent
+            descent = 0
+            bottom = 0
+        }
+        return 0
+    }
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) = Unit
+}
+
+internal class BlockImageSpan(
+    private val source: String,
+    hostView: View?,
+    private val density: Float,
+    private val preferredWidthDp: Float?,
+    private val preferredHeightDp: Float?,
+    internal var imageStyle: EditorElementStyle? = null
+) : ReplacementSpan() {
+    internal var ancestorWidthInset: Float = 0f
+    private val hostRef = WeakReference(hostView)
+    private val policy = (hostView as? EditorEditText)?.imageLoadingPolicy
+        ?: ImageLoadingPolicy.DEFAULT
+    private val generation = (hostView as? EditorEditText)?.currentImageLoadGeneration()
+    private val boundEditorId = (hostView as? EditorEditText)?.editorId
+    private val boundDriver = WeakReference((hostView as? EditorEditText)?.v2Driver)
+    private val hadBoundDriver = boundDriver.get() != null
+    private val ownerId = (hostView as? EditorEditText)?.decodedBitmapOwnerId
+        ?: DecodedBitmapBudget.nextOwnerId()
+    private val preparedSource = NativeImagePipeline.prepare(source, policy)
+
+    private val retired = AtomicBoolean(false)
+    private val bitmapLease = AtomicReference<DecodedBitmapLease?>()
+    private val loadHandle = AtomicReference<RenderImageLoader.LoadHandle?>()
+
+    @Volatile
+    private var lastDrawRect: RectF? = null
+
+    init {
+        if (preparedSource != null) {
+            val handle = NativeImagePipeline.load(
+                preparedSource,
+                ownerId,
+                DecodedBitmapPriority.VISIBLE
+            ) { loaded ->
+                val currentHost = hostRef.get()
+                if (
+                    retired.get() ||
+                    (
+                        currentHost is EditorEditText &&
+                            !canReuseFor(currentHost)
+                        )
+                ) {
+                    loaded?.close()
+                    return@load
+                }
+                if (loaded == null) {
+                    Log.w(
+                        RenderImageDecoder.LOG_TAG,
+                        "BlockImageSpan: loader returned null for image source"
+                    )
+                    return@load
+                }
+                val previous = bitmapLease.getAndSet(loaded)
+                if (retired.get()) {
+                    if (bitmapLease.compareAndSet(loaded, null)) loaded.close()
+                    previous?.close()
+                    return@load
+                }
+                previous?.close()
+                currentHost?.post {
+                    if (
+                        currentHost is EditorEditText &&
+                        !canReuseFor(currentHost)
+                    ) {
+                        close()
+                        return@post
+                    }
+                    if (currentHost is EditorEditText) {
+                        currentHost.onImageSpanSizeMayChange(this@BlockImageSpan)
+                    } else {
+                        currentHost.requestLayout()
+                        currentHost.invalidate()
+                    }
+                }
+            }
+            if (!loadHandle.compareAndSet(null, handle) || retired.get()) {
+                loadHandle.getAndSet(null)?.cancel()
+            }
+            handle.onFinished { loadHandle.compareAndSet(handle, null) }
+            (hostView as? EditorEditText)?.registerImageLoad(handle)
+        }
+    }
+
+    internal fun matches(source: String, width: Float?, height: Float?): Boolean =
+        !retired.get() && this.source == source && preferredWidthDp == width &&
+            preferredHeightDp == height
+
+    internal fun canReuseFor(host: EditorEditText): Boolean {
+        val sameDriver = if (hadBoundDriver) {
+            boundDriver.get()?.let { it === host.v2Driver } == true
+        } else {
+            host.v2Driver ==
+                null
+        }
+        return !retired.get() && hostRef.get() === host && sameDriver &&
+            boundEditorId == host.editorId &&
+            generation == host.currentImageLoadGeneration() && policy == host.imageLoadingPolicy
+    }
+
+    internal fun reloadedFor(hostView: View): BlockImageSpan = BlockImageSpan(
+        source = source,
+        hostView = hostView,
+        density = density,
+        preferredWidthDp = preferredWidthDp,
+        preferredHeightDp = preferredHeightDp,
+        imageStyle = imageStyle
+    ).also { it.ancestorWidthInset = ancestorWidthInset }
+
+    internal fun close() {
+        if (!retired.compareAndSet(false, true)) return
+        loadHandle.getAndSet(null)?.cancel()
+        bitmapLease.getAndSet(null)?.close()
+    }
+
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int {
+        val (widthPx, heightPx) = currentSizePx()
+        val inset = imageStyle?.box?.outerInset?.scaled(density) ?: EditorEdges()
+        if (fm != null) {
+            fm.ascent = -heightPx - (inset.top + inset.bottom).toInt()
+            fm.descent = 0
+            fm.top = fm.ascent
+            fm.bottom = 0
+        }
+        return widthPx + (inset.left + inset.right).toInt()
+    }
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) {
+        val rect = boxRect(x, y.toFloat())
+        val host = hostRef.get()
+        val documentRect =
+            ((host as? EditorTextSurface)?.layout as? EditorDocumentLayout)?.imageBounds(
+                this
+            )
+        lastDrawRect = RectF(documentRect ?: rect).apply {
+            if (host != null) {
+                offset(
+                    (host as? android.widget.TextView)?.compoundPaddingLeft?.toFloat()
+                        ?: host.paddingLeft.toFloat(),
+                    (host as? android.widget.TextView)?.extendedPaddingTop?.toFloat()
+                        ?: host.paddingTop.toFloat()
+                )
+            }
+        }
+        val loadedBitmap = bitmapLease.get()?.bitmap
+        imageStyle?.let {
+            val box = it.box.scaled(density)
+            EditorBoxDrawing.draw(canvas, rect, box)
+            if (loadedBitmap !=
+                null
+            ) {
+                EditorBoxDrawing.drawImage(canvas, loadedBitmap, rect, box, it.resizeMode)
+            }
+            return
+        }
+        if (loadedBitmap != null) {
+            canvas.drawBitmap(loadedBitmap, null, rect, null)
+            return
+        }
+
+        val previousColor = paint.color
+        val previousStyle = paint.style
+        paint.color = Color.argb(24, 0, 0, 0)
+        paint.style = Paint.Style.FILL
+        canvas.drawRoundRect(rect, 16f * density, 16f * density, paint)
+        paint.color = Color.argb(120, 0, 0, 0)
+        val iconRadius = minOf(rect.width(), rect.height()) * 0.12f
+        canvas.drawCircle(rect.centerX(), rect.centerY(), iconRadius, paint)
+        paint.color = previousColor
+        paint.style = previousStyle
+    }
+
+    internal fun boxRect(x: Float, baseline: Float): RectF {
+        val (widthPx, heightPx) = currentSizePx()
+        val box = imageStyle?.box?.scaled(density) ?: EditorBoxStyle()
+        return RectF(
+            x + box.margin.left,
+            baseline - heightPx - box.inset.top - box.inset.bottom - box.margin.bottom,
+            x + box.margin.left + widthPx + box.inset.left + box.inset.right,
+            baseline - box.margin.bottom
+        )
+    }
+
+    internal fun currentSizePx(): Pair<Int, Int> {
+        val maxWidth = resolvedMaxWidth()
+        val loadedBitmap = bitmapLease.get()?.bitmap
+        val fallbackAspectRatio = if (loadedBitmap != null && loadedBitmap.width > 0 &&
+            loadedBitmap.height > 0
+        ) {
+            loadedBitmap.height.toFloat() / loadedBitmap.width.toFloat()
+        } else {
+            0.56f
+        }
+
+        var widthPx = checkedPixels(preferredWidthDp)
+        var heightPx = checkedPixels(preferredHeightDp)
+
+        if (widthPx == null && heightPx == null && loadedBitmap != null && loadedBitmap.width > 0 &&
+            loadedBitmap.height > 0
+        ) {
+            widthPx = loadedBitmap.width.toFloat()
+            heightPx = loadedBitmap.height.toFloat()
+        } else if (widthPx == null && heightPx != null) {
+            widthPx = heightPx / fallbackAspectRatio
+        } else if (heightPx == null && widthPx != null) {
+            heightPx = widthPx * fallbackAspectRatio
+        }
+
+        if (widthPx == null || heightPx == null) {
+            val placeholderWidth = maxWidth.coerceAtLeast(160f * density)
+            val placeholderHeight = minOf(
+                180f * density,
+                placeholderWidth * fallbackAspectRatio
+            ).coerceAtLeast(96f * density)
+            widthPx = placeholderWidth
+            heightPx = placeholderHeight
+        }
+
+        if (!widthPx.isFinite() || widthPx <= 0f || !heightPx.isFinite() || heightPx <= 0f) {
+            widthPx = maxWidth
+            heightPx = minOf(maxWidth * 0.56f, policy.maxDecodeDimensionPx.toFloat())
+        }
+        val maximumDimension = policy.maxDecodeDimensionPx.toFloat()
+        val scale = minOf(
+            1f,
+            maxWidth / widthPx.coerceAtLeast(1f),
+            maximumDimension / heightPx.coerceAtLeast(1f)
+        )
+        return Pair(
+            checkedPositiveInt(widthPx * scale),
+            checkedPositiveInt(heightPx * scale)
+        )
+    }
+
+    internal fun currentDrawRect(): RectF? = lastDrawRect?.let(::RectF)
+
+    private fun resolvedMaxWidth(): Float {
+        val host = hostRef.get()
+        val hostWidth = host?.let {
+            maxOf(it.width, it.measuredWidth) -
+                ((it as? android.widget.TextView)?.totalPaddingLeft ?: it.paddingLeft) -
+                ((it as? android.widget.TextView)?.totalPaddingRight ?: it.paddingRight)
+        } ?: 0
+        val inset = imageStyle?.box?.outerInset?.scaled(density) ?: EditorEdges()
+        val candidate =
+            (if (hostWidth > 0) hostWidth.toDouble() else 240.0 * density.toDouble()) - inset.left -
+                inset.right -
+                ancestorWidthInset
+        return candidate
+            .takeIf { it.isFinite() && it > 0.0 }
+            ?.coerceAtMost(policy.maxDecodeDimensionPx.toDouble())
+            ?.toFloat()
+            ?: policy.maxDecodeDimensionPx.toFloat()
+    }
+
+    private fun checkedPixels(preferredDp: Float?): Float? {
+        val value = preferredDp ?: return null
+        if (!value.isFinite() || value <= 0f || !density.isFinite() || density <= 0f) return null
+        val pixels = value.toDouble() * density.toDouble()
+        return pixels.takeIf {
+            it.isFinite() && it > 0.0 && it <= Int.MAX_VALUE.toDouble()
+        }?.toFloat()
+    }
+
+    private fun checkedPositiveInt(value: Float): Int = value
+        .takeIf { it.isFinite() && it > 0f }
+        ?.toDouble()
+        ?.coerceAtMost(Int.MAX_VALUE.toDouble())
+        ?.toInt()
+        ?.coerceAtLeast(1)
+        ?: 1
+}

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

@@ -0,0 +1,182 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+import android.text.style.ReplacementSpan
+
+class FixedLineHeightSpan(private val lineHeightPx: Int) : LineHeightSpan {
+    override fun chooseHeight(
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        spanstartv: Int,
+        v: Int,
+        fm: android.graphics.Paint.FontMetricsInt
+    ) {
+        val paragraphSpacing = if (end > start && text[end - 1] == '\n' && text is Spanned) {
+            text.getSpans(end - 1, end, ParagraphSpacerSpan::class.java)
+                .maxOfOrNull { it.spacingPx }
+                ?: 0
+        } else {
+            0
+        }
+        val currentHeight = fm.descent - paragraphSpacing - fm.ascent
+        if (lineHeightPx <= 0 || currentHeight <= 0) return
+        if (lineHeightPx == currentHeight) return
+
+        val extra = lineHeightPx - currentHeight
+        fm.descent += extra
+        fm.bottom = fm.descent
+    }
+}
+
+/**
+ * Adds vertical spacing after a paragraph by increasing the descent of the
+ * inter-block newline character.
+ *
+ * Uses [ReplacementSpan] (not [LineHeightSpan]/[android.text.style.ParagraphStyle])
+ * because Android's StaticLayout normalizes ParagraphStyle metrics across all
+ * lines in a paragraph, making per-line spacing impossible.
+ *
+ * ReplacementSpan only affects the single character it covers, so the extra
+ * descent applies only to the newline's line — creating a gap below the
+ * preceding paragraph without inflating other lines.
+ */
+class ParagraphSpacerSpan(
+    internal val spacingPx: Int,
+    private val baseFontSize: Int,
+    private val textColor: Int
+) : ReplacementSpan() {
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int {
+        if (fm != null && spacingPx > 0) {
+            // Keep the natural ascent/top (from baseFontSize) so the newline
+            // line doesn't shrink above the baseline. Add spacing as descent.
+            val savedSize = paint.textSize
+            paint.textSize = baseFontSize.toFloat()
+            paint.getFontMetricsInt(fm)
+            paint.textSize = savedSize
+            fm.descent += spacingPx
+            fm.bottom = fm.descent
+        }
+        return 0
+    }
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) {
+        // Draw nothing — pure spacing.
+    }
+}
+
+class MarkerGapSpan(private val widthPx: Float) : ReplacementSpan() {
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int = kotlin.math.ceil(widthPx).toInt()
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) = Unit
+}
+
+internal class OrderedListMarkerSpan(internal val label: String) : ReplacementSpan() {
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int = kotlin.math.ceil(paint.measureText(label).toDouble()).toInt()
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) {
+        canvas.drawText(label, x, y.toFloat(), paint)
+    }
+}
+
+class CenteredBulletSpan(
+    private val textColor: Int,
+    private val markerWidthPx: Float,
+    private val bulletRadiusPx: Float,
+    private val bodyFontSizePx: Float,
+    private val markerGapToTextPx: Float
+) : ReplacementSpan() {
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int = kotlin.math.ceil(markerWidthPx).toInt()
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) {
+        val previousColor = paint.color
+        val previousStyle = paint.style
+        val previousSize = paint.textSize
+
+        paint.color = textColor
+        paint.style = Paint.Style.FILL
+
+        // Use body text metrics (not the marker's inflated font) for centering.
+        paint.textSize = bodyFontSizePx
+        val fm = paint.fontMetrics
+        val centerX = resolvedCenterX(x)
+        val centerY = y + (fm.ascent + fm.descent) / 2f
+        canvas.drawCircle(centerX, centerY, bulletRadiusPx, paint)
+
+        paint.color = previousColor
+        paint.style = previousStyle
+        paint.textSize = previousSize
+    }
+
+    fun textSideGapPx(x: Float): Float = (x + markerWidthPx) - (resolvedCenterX(x) + bulletRadiusPx)
+
+    private fun resolvedCenterX(x: Float): Float =
+        x + markerWidthPx - markerGapToTextPx - bulletRadiusPx
+}