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

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

@@ -0,0 +1,91 @@
+package com.apollohg.editor
+
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+
+/**
+ * Vertical geometry for the text caret, clipped to the rendered glyph height.
+ *
+ * Android's [android.widget.Editor] draws the native caret from
+ * `Layout.editorTextLineTop(line)` to `Layout.editorTextLineBottom(line)`. When a
+ * [ParagraphSpacerSpan] inflates a line's descent to create inter-block
+ * spacing, `getLineBottom` includes that gap and the caret stretches into it.
+ * `getLineBottomWithoutSpacing` cannot help: the inflation lives in the line's
+ * DESCENT column, not the line-spacing EXTRA column it subtracts.
+ *
+ * The baseline is provably independent of descent inflation
+ * (`getLineBaseline(line) == getLineTop(line) - ascent`), so anchoring the
+ * caret bottom at `baseline + raw font descent` clips it to the glyph height.
+ * This mirrors the trim already used for blockquote stripes
+ * ([BlockquoteSpan.resolvedStripeBottom]).
+ */
+object CaretGeometry {
+    data class VerticalBounds(val top: Float, val bottom: Float)
+
+    /**
+     * Whether the manually-drawn caret should be visible. The native caret is
+     * suppressed, so this gates our replacement: only when the field is focused,
+     * its window is focused, and the selection is a collapsed insertion point
+     * (a range selection shows the selection highlight instead).
+     */
+    fun shouldRender(
+        focused: Boolean,
+        windowFocused: Boolean,
+        selectionStart: Int,
+        selectionEnd: Int
+    ): Boolean = focused &&
+        windowFocused &&
+        selectionStart >= 0 &&
+        selectionStart == selectionEnd
+
+    fun verticalBounds(layout: Layout, offset: Int, paint: Paint): VerticalBounds =
+        verticalBounds(layout, offset, paint, layout.text)
+
+    fun verticalBounds(
+        layout: Layout,
+        offset: Int,
+        fallbackPaint: Paint,
+        text: CharSequence
+    ): VerticalBounds {
+        val line = layout.getLineForOffset(offset.coerceIn(0, layout.text.length))
+        val top = layout.editorTextLineTop(line).toFloat()
+        val resolvedPaint =
+            (layout as? EditorDocumentLayout)?.emptyLinePaint(offset) ?: resolvedPaintAtOffset(
+                fallbackPaint,
+                text,
+                offset,
+                layout.getLineStart(line)
+            )
+        val bottom = layout.getLineBaseline(line) + resolvedPaint.fontMetrics.descent
+        return VerticalBounds(top, bottom)
+    }
+
+    private fun resolvedPaintAtOffset(
+        fallbackPaint: Paint,
+        text: CharSequence,
+        offset: Int,
+        lineStart: Int
+    ): TextPaint {
+        val resolved = TextPaint(fallbackPaint)
+        val spanned = text as? Spanned ?: return resolved
+        if (spanned.isEmpty()) {
+            spanned.getSpans(0, 0, MetricAffectingSpan::class.java).forEach {
+                it.updateMeasureState(resolved)
+            }
+            return resolved
+        }
+        val clampedOffset = offset.coerceIn(0, spanned.length)
+        val probe = if (clampedOffset > lineStart) {
+            clampedOffset - 1
+        } else {
+            clampedOffset.coerceAtMost(spanned.length - 1)
+        }
+        spanned.getSpans(probe, probe + 1, MetricAffectingSpan::class.java)
+            .filterNot { it is ParagraphSpacerSpan }
+            .forEach { it.updateMeasureState(resolved) }
+        return resolved
+    }
+}

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

@@ -0,0 +1,141 @@
+package com.apollohg.editor
+
+data class CodeHighlightRange(val start: Int, val length: Int, val color: Long, val fontStyle: Int)
+
+interface CodeHighlightingProvider {
+    val id: String
+    val version: Int
+    fun highlight(text: String, language: String?, theme: String): List<CodeHighlightRange>
+}
+
+object CodeHighlightingRegistry {
+    private val providers = mutableMapOf<String, CodeHighlightingProvider>()
+
+    @Synchronized
+    fun register(provider: CodeHighlightingProvider) {
+        require(provider.id.isNotEmpty() && provider.version == 1) {
+            "Code highlighting provider must have an ID and support version 1"
+        }
+        providers[provider.id] = provider
+    }
+
+    @Synchronized
+    fun provider(id: String): CodeHighlightingProvider = requireNotNull(providers[id]) {
+        "Code highlighting provider '$id' is unavailable. Install and import its native package, then rebuild the app."
+    }
+
+    internal fun validRanges(text: String, ranges: List<CodeHighlightRange>): Boolean {
+        fun isBoundary(offset: Int): Boolean = offset == 0 || offset == text.length ||
+            !Character.isHighSurrogate(text[offset - 1]) || !Character.isLowSurrogate(text[offset])
+        var end = 0
+        for (range in ranges) {
+            if (range.start < end || range.length <= 0 || range.start > text.length ||
+                range.length > text.length - range.start || range.color !in 0L..0xffffffffL ||
+                range.fontStyle !in 0..7 || !isBoundary(range.start) ||
+                !isBoundary(range.start + range.length)
+            ) {
+                return false
+            }
+            end = range.start + range.length
+        }
+        return true
+    }
+}
+
+internal data class CodeHighlightBlock(val start: Int, val text: String, val language: String?)
+internal data class HighlightedCodeBlock(
+    val block: CodeHighlightBlock,
+    val ranges: List<CodeHighlightRange>
+)
+
+internal class CodeHighlightingSession {
+    private data class Request(
+        val generation: Long,
+        val provider: CodeHighlightingProvider,
+        val theme: String,
+        val blocks: List<CodeHighlightBlock>,
+        val completion: (Result<List<HighlightedCodeBlock>>) -> Unit
+    )
+
+    companion object {
+        private val executor = java.util.concurrent.Executors.newSingleThreadExecutor { task ->
+            Thread(task, "editor.code-highlighting").apply { isDaemon = true }
+        }
+    }
+
+    private val lock = Any()
+    private val main = android.os.Handler(android.os.Looper.getMainLooper())
+    private var generation = 0L
+    private var pending: Request? = null
+    private var running = false
+
+    fun cancel() {
+        check(android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) {
+            "Highlighting sessions must be updated on the main thread"
+        }
+        synchronized(lock) {
+            generation++
+            pending = null
+        }
+    }
+
+    fun update(
+        provider: String,
+        theme: String,
+        blocks: List<CodeHighlightBlock>,
+        completion: (Result<List<HighlightedCodeBlock>>) -> Unit
+    ) {
+        cancel()
+        val resolved = CodeHighlightingRegistry.provider(provider)
+        val schedule = synchronized(lock) {
+            pending = Request(generation, resolved, theme, blocks.toList(), completion)
+            (!running).also { running = true }
+        }
+        if (schedule) executor.execute { drain() }
+    }
+
+    private fun current(value: Long) = synchronized(lock) { generation == value }
+
+    private fun takeRequest(): Request? = synchronized(lock) {
+        pending.also {
+            pending = null
+            if (it == null) running = false
+        }
+    }
+
+    private fun scheduleNext() {
+        val schedule = synchronized(lock) {
+            (pending != null).also { running = it }
+        }
+        if (schedule) executor.execute { drain() }
+    }
+
+    private fun drain() {
+        val request = takeRequest() ?: return
+        try {
+            val result = runCatching {
+                val output = mutableListOf<HighlightedCodeBlock>()
+                for (block in request.blocks) {
+                    if (!current(request.generation)) break
+                    val ranges = request.provider.highlight(
+                        block.text,
+                        block.language,
+                        request.theme
+                    ).toList()
+                    require(CodeHighlightingRegistry.validRanges(block.text, ranges)) {
+                        "Code highlighting provider returned invalid UTF-16 ranges"
+                    }
+                    output.add(HighlightedCodeBlock(block, ranges))
+                }
+                output.toList()
+            }
+            if (current(request.generation)) {
+                main.post {
+                    if (current(request.generation)) request.completion(result)
+                }
+            }
+        } finally {
+            scheduleNext()
+        }
+    }
+}

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

@@ -0,0 +1,250 @@
+package com.apollohg.editor
+
+import android.app.ActivityManager
+import android.content.Context
+import android.graphics.Bitmap
+import java.io.Closeable
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+internal enum class DecodedBitmapPriority { VISIBLE, PREFETCH }
+
+internal class DecodedBitmapBudget(private val processLimitBytes: Long) {
+    internal class Allocation(
+        var bytes: Long,
+        var bitmap: Bitmap? = null,
+        var references: Int = 1,
+        val ownerReferences: MutableMap<Long, Int> = mutableMapOf(),
+        val ownerPriorityReferences: MutableMap<Pair<Long, DecodedBitmapPriority>, Int> =
+            mutableMapOf()
+    )
+
+    private val lock = Any()
+    private var retainedProcessBytes = 0L
+    private val retainedOwnerBytes = mutableMapOf<Long, Long>()
+    private val ownerPressureHandlers = mutableMapOf<Long, () -> Unit>()
+
+    @Volatile private var pressureHandler: (() -> Unit)? = null
+
+    fun reserve(bytes: Long, priority: DecodedBitmapPriority): DecodedBitmapReservation? {
+        if (bytes <= 0L || bytes > processLimitBytes) return null
+        fun attempt(): Allocation? = synchronized(lock) {
+            val next = checkedAdd(retainedProcessBytes, bytes) ?: return@synchronized null
+            if (next > processLimitBytes) return@synchronized null
+            retainedProcessBytes = next
+            Allocation(bytes)
+        }
+        var allocation = attempt()
+        if (allocation == null && priority == DecodedBitmapPriority.VISIBLE) {
+            pressureHandler?.invoke()
+            allocation = attempt()
+            if (allocation == null) {
+                synchronized(lock) { ownerPressureHandlers.values.toList() }.forEach { it() }
+                pressureHandler?.invoke()
+                allocation = attempt()
+            }
+        }
+        allocation ?: return null
+        return DecodedBitmapReservation(this, allocation)
+    }
+
+    fun setPressureHandler(handler: (() -> Unit)?) {
+        pressureHandler = handler
+    }
+
+    fun setOwnerPressureHandler(ownerId: Long, handler: (() -> Unit)?) = synchronized(lock) {
+        if (handler == null) {
+            ownerPressureHandlers.remove(ownerId)
+        } else {
+            ownerPressureHandlers[ownerId] = handler
+        }
+    }
+
+    private fun reconcile(allocation: Allocation, actualBytes: Long): Boolean = synchronized(lock) {
+        if (actualBytes <= 0L || allocation.references <= 0) return@synchronized false
+        val withoutAllocation = retainedProcessBytes - allocation.bytes
+        val next = checkedAdd(withoutAllocation, actualBytes) ?: return@synchronized false
+        if (next > processLimitBytes) return@synchronized false
+        retainedProcessBytes = next
+        allocation.bytes = actualBytes
+        true
+    }
+
+    private fun fork(
+        allocation: Allocation,
+        ownerId: Long,
+        ownerLimitBytes: Long,
+        priority: DecodedBitmapPriority
+    ): DecodedBitmapLease? {
+        if (ownerLimitBytes <= 0L || allocation.bytes > ownerLimitBytes) return null
+        fun attempt(): DecodedBitmapLease? = synchronized(lock) {
+            if (allocation.references <= 0 || allocation.bitmap == null) {
+                return@synchronized null
+            }
+            val ownerReferences = allocation.ownerReferences[ownerId] ?: 0
+            if (ownerReferences == 0) {
+                val retained = retainedOwnerBytes[ownerId] ?: 0L
+                val next = checkedAdd(retained, allocation.bytes) ?: return@synchronized null
+                if (next > ownerLimitBytes) return@synchronized null
+                retainedOwnerBytes[ownerId] = next
+            }
+            val priorityKey = ownerId to priority
+            val priorityReferences = allocation.ownerPriorityReferences[priorityKey] ?: 0
+            if (
+                allocation.references == Int.MAX_VALUE ||
+                ownerReferences == Int.MAX_VALUE ||
+                priorityReferences == Int.MAX_VALUE
+            ) {
+                return@synchronized null
+            }
+            allocation.references += 1
+            allocation.ownerReferences[ownerId] = ownerReferences + 1
+            allocation.ownerPriorityReferences[priorityKey] = priorityReferences + 1
+            DecodedBitmapLease(this, allocation, ownerId, priority)
+        }
+        var lease = attempt()
+        if (lease == null && priority == DecodedBitmapPriority.VISIBLE) {
+            synchronized(lock) { ownerPressureHandlers[ownerId] }?.invoke()
+            lease = attempt()
+        }
+        return lease
+    }
+
+    private fun forkUnowned(allocation: Allocation): DecodedBitmapLease? = synchronized(lock) {
+        if (allocation.references <= 0 || allocation.bitmap == null ||
+            allocation.references == Int.MAX_VALUE
+        ) {
+            return@synchronized null
+        }
+        allocation.references += 1
+        DecodedBitmapLease(this, allocation, null, null)
+    }
+
+    private fun release(allocation: Allocation, ownerId: Long?, priority: DecodedBitmapPriority?) =
+        synchronized(lock) {
+            if (allocation.references <= 0) return@synchronized
+            if (ownerId != null) {
+                val references = allocation.ownerReferences[ownerId] ?: return@synchronized
+                val priorityKey = ownerId to checkNotNull(priority)
+                val priorityReferences = allocation.ownerPriorityReferences[priorityKey]
+                    ?: return@synchronized
+                if (priorityReferences == 1) {
+                    allocation.ownerPriorityReferences.remove(priorityKey)
+                } else {
+                    allocation.ownerPriorityReferences[priorityKey] = priorityReferences - 1
+                }
+                if (references == 1) {
+                    allocation.ownerReferences.remove(ownerId)
+                    val remaining = (retainedOwnerBytes[ownerId] ?: 0L) - allocation.bytes
+                    if (remaining <= 0L) {
+                        retainedOwnerBytes.remove(ownerId)
+                    } else {
+                        retainedOwnerBytes[ownerId] = remaining
+                    }
+                } else {
+                    allocation.ownerReferences[ownerId] = references - 1
+                }
+            }
+            allocation.references -= 1
+            if (allocation.references == 0) {
+                retainedProcessBytes = (retainedProcessBytes - allocation.bytes).coerceAtLeast(0L)
+                allocation.bitmap = null
+                allocation.ownerReferences.clear()
+                allocation.ownerPriorityReferences.clear()
+            }
+        }
+
+    internal fun retainedProcessBytesForTesting(): Long = synchronized(lock) {
+        retainedProcessBytes
+    }
+
+    internal fun retainedOwnerBytesForTesting(ownerId: Long): Long =
+        synchronized(lock) { retainedOwnerBytes[ownerId] ?: 0L }
+
+    internal companion object {
+        private const val MIB = 1024L * 1024L
+        private val ownerIds = AtomicLong()
+        private val sharedLock = Any()
+
+        @Volatile private var sharedBudget: DecodedBitmapBudget? = null
+
+        fun processLimitBytes(memoryClassMib: Int): Long =
+            (memoryClassMib.coerceAtLeast(0).toLong() * MIB / 8L)
+                .coerceIn(16L * MIB, 128L * MIB)
+
+        fun shared(context: Context? = null): DecodedBitmapBudget {
+            sharedBudget?.let { return it }
+            return synchronized(sharedLock) {
+                sharedBudget ?: DecodedBitmapBudget(
+                    processLimitBytes(
+                        context?.applicationContext
+                            ?.getSystemService(Context.ACTIVITY_SERVICE)
+                            ?.let { it as? ActivityManager }
+                            ?.memoryClass
+                            ?: (Runtime.getRuntime().maxMemory() / MIB)
+                                .coerceAtMost(Int.MAX_VALUE.toLong())
+                                .toInt()
+                    )
+                ).also { sharedBudget = it }
+            }
+        }
+
+        fun nextOwnerId(): Long = ownerIds.incrementAndGet()
+
+        private fun checkedAdd(left: Long, right: Long): Long? =
+            if (left < 0L || right < 0L || left > Long.MAX_VALUE - right) null else left + right
+    }
+
+    internal class DecodedBitmapReservation internal constructor(
+        private val budget: DecodedBitmapBudget,
+        private val allocation: Allocation
+    ) : Closeable {
+        private val finished = AtomicBoolean(false)
+
+        fun commit(bitmap: Bitmap, actualBytes: Long): DecodedBitmapLease? {
+            if (!finished.compareAndSet(false, true)) return null
+            if (!budget.reconcile(allocation, actualBytes)) {
+                budget.release(allocation, null, null)
+                return null
+            }
+            allocation.bitmap = bitmap
+            return DecodedBitmapLease(budget, allocation, null, null)
+        }
+
+        override fun close() {
+            if (finished.compareAndSet(false, true)) budget.release(allocation, null, null)
+        }
+    }
+
+    internal class DecodedBitmapLease internal constructor(
+        private val budget: DecodedBitmapBudget,
+        private val allocation: Allocation,
+        private val ownerId: Long?,
+        private val priority: DecodedBitmapPriority?
+    ) : Closeable {
+        private val closed = AtomicBoolean(false)
+        val bitmap: Bitmap get() = checkNotNull(allocation.bitmap)
+        val byteCount: Long get() = allocation.bytes
+
+        fun fork(
+            ownerId: Long,
+            ownerLimitBytes: Long,
+            priority: DecodedBitmapPriority
+        ): DecodedBitmapLease? {
+            if (closed.get()) return null
+            return budget.fork(allocation, ownerId, ownerLimitBytes, priority)
+        }
+
+        internal fun forkUnowned(): DecodedBitmapLease? {
+            if (closed.get()) return null
+            return budget.forkUnowned(allocation)
+        }
+
+        override fun close() {
+            if (closed.compareAndSet(false, true)) budget.release(allocation, ownerId, priority)
+        }
+    }
+}
+
+internal typealias DecodedBitmapReservation = DecodedBitmapBudget.DecodedBitmapReservation
+internal typealias DecodedBitmapLease = DecodedBitmapBudget.DecodedBitmapLease

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

@@ -0,0 +1,133 @@
+package com.apollohg.editor
+
+import org.json.JSONObject
+
+data class NativeMentionSuggestion(
+    val key: String,
+    val title: String,
+    val subtitle: String?,
+    val label: String,
+    val attrs: JSONObject
+) {
+    companion object {
+        fun fromJson(json: JSONObject?): NativeMentionSuggestion? {
+            json ?: return null
+            val key = json.optString("key", "")
+            val title = json.optString("title", "")
+            val label = json.optString("label", "")
+            if (key.isBlank() || title.isBlank() || label.isBlank()) return null
+            return NativeMentionSuggestion(
+                key = key,
+                title = title,
+                subtitle = json.takeUnless { it.isNull("subtitle") }?.optString("subtitle"),
+                label = label,
+                attrs = json.optJSONObject("attrs") ?: JSONObject()
+            )
+        }
+    }
+}
+
+data class NativeMentionsAddonConfig(
+    val trigger: String,
+    val suggestions: List<NativeMentionSuggestion>,
+    val theme: EditorMentionTheme?,
+    val resolveSelectionAttrs: Boolean,
+    val resolveTheme: Boolean
+) {
+    companion object {
+        fun fromJson(json: JSONObject?): NativeMentionsAddonConfig? {
+            json ?: return null
+            val trigger = json.optString("trigger", "@").ifBlank { "@" }
+            val rawSuggestions = json.optJSONArray("suggestions")
+            val suggestions = mutableListOf<NativeMentionSuggestion>()
+            if (rawSuggestions != null) {
+                for (index in 0 until rawSuggestions.length()) {
+                    val suggestion = NativeMentionSuggestion.fromJson(
+                        rawSuggestions.optJSONObject(index)
+                    )
+                    if (suggestion != null) {
+                        suggestions.add(suggestion)
+                    }
+                }
+            }
+            return NativeMentionsAddonConfig(
+                trigger = trigger,
+                suggestions = suggestions,
+                theme = EditorMentionTheme.fromJson(json.optJSONObject("theme")),
+                resolveSelectionAttrs = json.optBoolean("resolveSelectionAttrs", false),
+                resolveTheme = json.optBoolean("resolveTheme", false)
+            )
+        }
+    }
+}
+
+data class NativeEditorAddons(
+    val mentions: NativeMentionsAddonConfig?,
+    val codeHighlighting: NativeCodeHighlightingConfig? = null
+) {
+    companion object {
+        fun fromJson(json: String?): NativeEditorAddons {
+            if (json.isNullOrBlank()) return NativeEditorAddons(null)
+            val root = try {
+                JSONObject(json)
+            } catch (_: Exception) {
+                return NativeEditorAddons(null)
+            }
+            return NativeEditorAddons(
+                mentions = NativeMentionsAddonConfig.fromJson(root.optJSONObject("mentions")),
+                codeHighlighting = NativeCodeHighlightingConfig.fromJson(
+                    root.optJSONObject("codeHighlighting")
+                )
+            )
+        }
+    }
+}
+
+data class MentionQueryState(val query: String, val trigger: String, val anchor: Int, val head: Int)
+
+internal fun isMentionIdentifierCodePoint(codePoint: Int): Boolean =
+    Character.isLetterOrDigit(codePoint) || codePoint == '_'.code || codePoint == '-'.code
+
+internal fun resolveMentionQueryState(
+    text: String,
+    cursorScalar: Int,
+    trigger: String,
+    isCaretInsideMention: Boolean
+): MentionQueryState? {
+    if (isCaretInsideMention) return null
+
+    val scalars = text.codePoints().toArray()
+    if (cursorScalar > scalars.size) return null
+    val triggerCodePoint = trigger.codePointAt(0)
+
+    var start = cursorScalar
+    while (start > 0) {
+        val previous = scalars[start - 1]
+        if (Character.isWhitespace(previous) ||
+            previous == '\n'.code ||
+            previous == 0xFFFC ||
+            (!isMentionIdentifierCodePoint(previous) && previous != triggerCodePoint)
+        ) {
+            break
+        }
+        start -= 1
+    }
+
+    if (start >= scalars.size || scalars[start] != triggerCodePoint) return null
+    if (start > 0) {
+        val previous = scalars[start - 1]
+        if (isMentionIdentifierCodePoint(previous)) {
+            return null
+        }
+    }
+
+    val query = String(scalars, start + 1, cursorScalar - (start + 1))
+    if (query.any { it.isWhitespace() }) return null
+
+    return MentionQueryState(
+        query = query,
+        trigger = trigger,
+        anchor = start,
+        head = cursorScalar
+    )
+}

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

@@ -0,0 +1,51 @@
+package com.apollohg.editor
+
+import android.text.Spanned
+
+internal fun Spanned.resolvedBlockSpacing(): Map<EditorBlockBoxSpan, EditorBoxStyle> {
+    data class Box(val span: EditorBlockBoxSpan, val start: Int, val end: Int)
+    val spans = getSpans(0, length, EditorBlockBoxSpan::class.java)
+        .map { Box(it, getSpanStart(it), getSpanEnd(it)) }
+        .sortedWith(compareBy({ it.start }, { it.span.depth }, { -it.end }))
+    val styles = spans.associate { it.span to it.span.box }.toMutableMap()
+    val stack = mutableListOf<Box>()
+    val children = mutableMapOf<Box?, MutableList<Box>>()
+    for (span in spans) {
+        while (stack.isNotEmpty() &&
+            (stack.last().span.depth >= span.span.depth || stack.last().end < span.end)
+        ) {
+            stack.removeAt(stack.lastIndex)
+        }
+        children.getOrPut(stack.lastOrNull()) { mutableListOf() }.add(span)
+        stack.add(span)
+    }
+    for ((parent, siblings) in children) {
+        val last = siblings.last()
+        if (parent?.span?.nodeType == "blockquote" && last.span.nodeType == "paragraph" &&
+            last.end == parent.end
+        ) {
+            styles[last.span] = last.span.box.copy(margin = last.span.box.margin.copy(bottom = 0f))
+        }
+        for ((previous, current) in siblings.zipWithNext()) {
+            val start = previous.end
+            val end = current.start
+            if (start > end ||
+                (start until end).any { this[it] != '\n' && this[it] != '\u200B' }
+            ) {
+                continue
+            }
+            val bottom = previous.span.marginForCollapsing.bottom
+            val top = current.span.marginForCollapsing.top
+            val collapsed = maxOf(0f, bottom, top) + minOf(0f, bottom, top)
+            val style = styles.getValue(current.span)
+            styles[current.span] =
+                style.copy(
+                    margin = style.margin.copy(
+                        top =
+                            style.margin.top + collapsed - bottom - top
+                    )
+                )
+        }
+    }
+    return styles
+}

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

@@ -0,0 +1,16 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.PixelFormat
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+
+internal class EditorBoxDrawable(private val box: EditorBoxStyle) : Drawable() {
+    override fun draw(canvas: Canvas) = EditorBoxDrawing.draw(canvas, RectF(bounds), box)
+    override fun setAlpha(alpha: Int) = Unit
+    override fun setColorFilter(colorFilter: ColorFilter?) = Unit
+
+    @Deprecated("Drawable opacity is no longer used")
+    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+}