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

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

@@ -0,0 +1,177 @@
+package com.apollohg.editor
+
+import android.content.Context
+import android.graphics.Typeface
+import org.json.JSONObject
+
+internal data class NativeToolbarIcon(
+    val defaultId: ToolbarDefaultIconId? = null,
+    val glyphText: String? = null,
+    val fallbackText: String? = null,
+    val materialIconName: String? = null
+) {
+    companion object {
+        private val defaultGlyphs = mapOf(
+            ToolbarDefaultIconId.BOLD to "B",
+            ToolbarDefaultIconId.ITALIC to "I",
+            ToolbarDefaultIconId.UNDERLINE to "U",
+            ToolbarDefaultIconId.STRIKE to "S",
+            ToolbarDefaultIconId.LINK to "🔗",
+            ToolbarDefaultIconId.IMAGE to "🖼",
+            ToolbarDefaultIconId.H1 to "H1",
+            ToolbarDefaultIconId.H2 to "H2",
+            ToolbarDefaultIconId.H3 to "H3",
+            ToolbarDefaultIconId.H4 to "H4",
+            ToolbarDefaultIconId.H5 to "H5",
+            ToolbarDefaultIconId.H6 to "H6",
+            ToolbarDefaultIconId.BLOCKQUOTE to "❝",
+            ToolbarDefaultIconId.BULLET_LIST to "•≡",
+            ToolbarDefaultIconId.ORDERED_LIST to "1.",
+            ToolbarDefaultIconId.INDENT_LIST to "→",
+            ToolbarDefaultIconId.OUTDENT_LIST to "←",
+            ToolbarDefaultIconId.LINE_BREAK to "↵",
+            ToolbarDefaultIconId.HORIZONTAL_RULE to "—",
+            ToolbarDefaultIconId.UNDO to "↩",
+            ToolbarDefaultIconId.REDO to "↪"
+        )
+        private val defaultMaterialIcons = mapOf(
+            ToolbarDefaultIconId.BOLD to "format-bold",
+            ToolbarDefaultIconId.ITALIC to "format-italic",
+            ToolbarDefaultIconId.UNDERLINE to "format-underlined",
+            ToolbarDefaultIconId.STRIKE to "strikethrough-s",
+            ToolbarDefaultIconId.LINK to "link",
+            ToolbarDefaultIconId.IMAGE to "image",
+            ToolbarDefaultIconId.BLOCKQUOTE to "format-quote",
+            ToolbarDefaultIconId.BULLET_LIST to "format-list-bulleted",
+            ToolbarDefaultIconId.ORDERED_LIST to "format-list-numbered",
+            ToolbarDefaultIconId.INDENT_LIST to "format-indent-increase",
+            ToolbarDefaultIconId.OUTDENT_LIST to "format-indent-decrease",
+            ToolbarDefaultIconId.LINE_BREAK to "keyboard-return",
+            ToolbarDefaultIconId.HORIZONTAL_RULE to "horizontal-rule",
+            ToolbarDefaultIconId.H1 to "title",
+            ToolbarDefaultIconId.H2 to "title",
+            ToolbarDefaultIconId.H3 to "title",
+            ToolbarDefaultIconId.H4 to "title",
+            ToolbarDefaultIconId.H5 to "title",
+            ToolbarDefaultIconId.H6 to "title",
+            ToolbarDefaultIconId.UNDO to "undo",
+            ToolbarDefaultIconId.REDO to "redo"
+        )
+
+        fun fromJson(raw: JSONObject?): NativeToolbarIcon? {
+            raw ?: return null
+            return when (raw.optString("type")) {
+                "default" -> {
+                    val id = runCatching {
+                        ToolbarDefaultIconId.fromWireValue(raw.getString("id"))
+                    }.getOrNull() ?: return null
+                    NativeToolbarIcon(defaultId = id)
+                }
+
+                "glyph" -> {
+                    val text = raw.optString("text")
+                    if (text.isBlank()) null else NativeToolbarIcon(glyphText = text)
+                }
+
+                "platform" -> {
+                    val materialName = raw.optJSONObject("android")
+                        ?.takeIf { it.optString("type") == "material" }
+                        ?.toolbarNullableString("name")
+                    val fallback = raw.toolbarNullableString("fallbackText")
+                    if (materialName.isNullOrBlank() && fallback.isNullOrBlank()) {
+                        null
+                    } else {
+                        NativeToolbarIcon(
+                            fallbackText = fallback,
+                            materialIconName = materialName
+                        )
+                    }
+                }
+
+                else -> null
+            }
+        }
+
+        fun defaultMaterialIconName(defaultId: ToolbarDefaultIconId?): String? =
+            defaultId?.let { defaultMaterialIcons[it] }
+    }
+
+    fun resolvedGlyphText(): String = glyphText?.takeIf { it.isNotBlank() }
+        ?: fallbackText?.takeIf { it.isNotBlank() }
+        ?: defaultId?.let { defaultGlyphs[it] }
+        ?: "?"
+
+    fun resolvedMaterialIconName(): String? = materialIconName?.takeIf { it.isNotBlank() }
+        ?: Companion.defaultMaterialIconName(defaultId)
+}
+
+internal object MaterialIconRegistry {
+    private const val FONT_ASSET_PATH = "editor-icons/MaterialIcons.ttf"
+    private const val GLYPHMAP_ASSET_PATH = "editor-icons/MaterialIcons.json"
+
+    @Volatile
+    private var typeface: Typeface? = null
+
+    @Volatile
+    private var glyphMap: Map<String, String>? = null
+
+    fun typeface(context: Context): Typeface? {
+        val cached = typeface
+        if (cached != null) return cached
+        return runCatching {
+            Typeface.createFromAsset(context.assets, FONT_ASSET_PATH)
+        }.getOrNull()?.also { loaded ->
+            typeface = loaded
+        }
+    }
+
+    fun glyphForName(context: Context, name: String?): String? {
+        if (name.isNullOrBlank()) return null
+        val map = glyphMap ?: loadGlyphMap(context).also { loaded ->
+            glyphMap = loaded
+        }
+        return map[name]
+    }
+
+    private fun loadGlyphMap(context: Context): Map<String, String> {
+        val assetText = runCatching {
+            context.assets.open(GLYPHMAP_ASSET_PATH).bufferedReader().use { it.readText() }
+        }.getOrNull() ?: return emptyMap()
+
+        val json = runCatching { JSONObject(assetText) }.getOrNull() ?: return emptyMap()
+        val result = linkedMapOf<String, String>()
+        val keys = json.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val codePoint = json.optInt(key, -1)
+            if (codePoint > 0) {
+                result[key] = String(Character.toChars(codePoint))
+            }
+        }
+        return result
+    }
+}
+
+internal data class NativeToolbarResolvedIcon(val text: String, val typeface: Typeface? = null)
+
+internal fun NativeToolbarIcon.resolveForAndroid(context: Context): NativeToolbarResolvedIcon {
+    val materialName = resolvedMaterialIconName()
+    val materialGlyph = MaterialIconRegistry.glyphForName(context, materialName)
+    val materialTypeface = MaterialIconRegistry.typeface(context)
+    if (materialGlyph != null && materialTypeface != null) {
+        return NativeToolbarResolvedIcon(
+            text = materialGlyph,
+            typeface = materialTypeface
+        )
+    }
+
+    return NativeToolbarResolvedIcon(
+        text = resolvedGlyphText(),
+        typeface = null
+    )
+}
+
+internal fun JSONObject.toolbarNullableString(key: String): String? {
+    if (!has(key) || isNull(key)) return null
+    return optString(key).takeUnless { it == "null" }
+}

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

@@ -0,0 +1,274 @@
+package com.apollohg.editor
+
+import org.json.JSONObject
+
+internal data class NativeToolbarItem(
+    val type: ToolbarItemKind,
+    val key: String? = null,
+    val label: String? = null,
+    val icon: NativeToolbarIcon? = null,
+    val mark: String? = null,
+    val headingLevel: Int? = null,
+    val listType: ToolbarListType? = null,
+    val command: ToolbarCommand? = null,
+    val nodeType: String? = null,
+    val isActive: Boolean = false,
+    val isDisabled: Boolean = false,
+    val placement: ToolbarItemPlacement? = null,
+    val presentation: ToolbarGroupPresentation? = null,
+    val items: List<NativeToolbarItem> = emptyList(),
+    val buttonStyle: EditorToolbarButtonStyle? = null,
+    val parentGroupKey: String? = null
+) {
+    companion object {
+        val defaults = listOf(
+            NativeToolbarItem(
+                ToolbarItemKind.MARK,
+                label = "Bold",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.BOLD),
+                mark = "bold"
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.MARK,
+                label = "Italic",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.ITALIC),
+                mark = "italic"
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.MARK,
+                label = "Underline",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.UNDERLINE),
+                mark = "underline"
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.MARK,
+                label = "Strikethrough",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.STRIKE),
+                mark = "strike"
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.BLOCKQUOTE,
+                label = "Blockquote",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.BLOCKQUOTE)
+            ),
+            NativeToolbarItem(ToolbarItemKind.SEPARATOR),
+            NativeToolbarItem(
+                ToolbarItemKind.LIST,
+                label = "Bullet List",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.BULLET_LIST),
+                listType = ToolbarListType.BULLET_LIST
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.LIST,
+                label = "Ordered List",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.ORDERED_LIST),
+                listType = ToolbarListType.ORDERED_LIST
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.COMMAND,
+                label = "Indent List",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.INDENT_LIST),
+                command = ToolbarCommand.INDENT_LIST
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.COMMAND,
+                label = "Outdent List",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.OUTDENT_LIST),
+                command = ToolbarCommand.OUTDENT_LIST
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.NODE,
+                label = "Line Break",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.LINE_BREAK),
+                nodeType = "hard_break"
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.NODE,
+                label = "Horizontal Rule",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.HORIZONTAL_RULE),
+                nodeType = "horizontal_rule"
+            ),
+            NativeToolbarItem(ToolbarItemKind.SEPARATOR),
+            NativeToolbarItem(
+                ToolbarItemKind.COMMAND,
+                label = "Undo",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.UNDO),
+                command = ToolbarCommand.UNDO
+            ),
+            NativeToolbarItem(
+                ToolbarItemKind.COMMAND,
+                label = "Redo",
+                icon = NativeToolbarIcon(defaultId = ToolbarDefaultIconId.REDO),
+                command = ToolbarCommand.REDO
+            )
+        )
+
+        private fun parseItem(
+            rawItem: JSONObject,
+            allowGroup: Boolean = true,
+            allowSeparator: Boolean = true
+        ): NativeToolbarItem? {
+            val type = runCatching {
+                ToolbarItemKind.fromWireValue(rawItem.getString("type"))
+            }.getOrNull() ?: return null
+            val key = rawItem.toolbarNullableString("key")
+            val placement = rawItem.toolbarNullableString("placement")?.let {
+                runCatching { ToolbarItemPlacement.fromWireValue(it) }.getOrNull()
+            }
+            val parsed = when (type) {
+                ToolbarItemKind.SEPARATOR -> {
+                    if (!allowSeparator) {
+                        null
+                    } else {
+                        NativeToolbarItem(type = type, key = key, placement = placement)
+                    }
+                }
+
+                ToolbarItemKind.MARK -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val mark = rawItem.toolbarNullableString("mark") ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(type, key, label, icon, mark = mark, placement = placement)
+                }
+
+                ToolbarItemKind.HEADING -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val level = rawItem.optInt("level", -1)
+                    if (level !in 1..6) return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(
+                        type,
+                        key,
+                        label,
+                        icon,
+                        headingLevel = level,
+                        placement = placement
+                    )
+                }
+
+                ToolbarItemKind.BLOCKQUOTE -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(type, key, label, icon, placement = placement)
+                }
+
+                ToolbarItemKind.LIST -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val listType = runCatching {
+                        ToolbarListType.fromWireValue(rawItem.getString("listType"))
+                    }.getOrNull() ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(
+                        type,
+                        key,
+                        label,
+                        icon,
+                        listType = listType,
+                        placement = placement
+                    )
+                }
+
+                ToolbarItemKind.COMMAND -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val command = runCatching {
+                        ToolbarCommand.fromWireValue(rawItem.getString("command"))
+                    }.getOrNull() ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(
+                        type,
+                        key,
+                        label,
+                        icon,
+                        command = command,
+                        placement = placement
+                    )
+                }
+
+                ToolbarItemKind.NODE -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val nodeType = rawItem.toolbarNullableString("nodeType") ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(
+                        type,
+                        key,
+                        label,
+                        icon,
+                        nodeType = nodeType,
+                        placement = placement
+                    )
+                }
+
+                ToolbarItemKind.ACTION -> {
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val keyValue = rawItem.toolbarNullableString("key") ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    NativeToolbarItem(
+                        type = type,
+                        key = keyValue,
+                        label = label,
+                        icon = icon,
+                        placement = placement,
+                        isActive = rawItem.optBoolean("isActive", false),
+                        isDisabled = rawItem.optBoolean("isDisabled", false)
+                    )
+                }
+
+                ToolbarItemKind.GROUP -> {
+                    if (!allowGroup) return null
+                    val keyValue = rawItem.toolbarNullableString("key") ?: return null
+                    val icon =
+                        NativeToolbarIcon.fromJson(rawItem.optJSONObject("icon")) ?: return null
+                    val label = rawItem.toolbarNullableString("label") ?: return null
+                    val presentation = rawItem.toolbarNullableString("presentation")?.let {
+                        runCatching { ToolbarGroupPresentation.fromWireValue(it) }.getOrNull()
+                    } ?: ToolbarGroupPresentation.EXPAND
+                    val rawChildren = rawItem.optJSONArray("items") ?: return null
+                    val children = mutableListOf<NativeToolbarItem>()
+                    for (childIndex in 0 until rawChildren.length()) {
+                        val rawChild = rawChildren.optJSONObject(childIndex) ?: continue
+                        parseItem(rawChild, allowGroup = false, allowSeparator = false)?.let {
+                            children += it
+                        }
+                    }
+                    if (children.isEmpty()) return null
+                    NativeToolbarItem(
+                        type = type,
+                        key = keyValue,
+                        label = label,
+                        icon = icon,
+                        placement = placement,
+                        presentation = presentation,
+                        items = children
+                    )
+                }
+            }
+            return parsed?.copy(
+                buttonStyle = EditorToolbarButtonStyle.fromJson(
+                    rawItem.optJSONObject("buttonStyle")
+                )
+            )
+        }
+
+        fun fromJson(json: String?): List<NativeToolbarItem> {
+            if (json.isNullOrBlank()) return defaults
+            val rawArray = try {
+                org.json.JSONArray(json)
+            } catch (_: Exception) {
+                return defaults
+            }
+            val parsed = mutableListOf<NativeToolbarItem>()
+            for (index in 0 until rawArray.length()) {
+                val rawItem = rawArray.optJSONObject(index) ?: continue
+                parseItem(rawItem)?.let { parsed += it }
+            }
+            return parsed.ifEmpty { defaults }
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+package com.apollohg.editor
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.ByteString
+
+internal data class CollaborationSocketCallbacks(
+    val onOpen: (negotiatedProtocol: String?) -> Unit,
+    val onBinaryMessage: (ByteArray) -> Unit,
+    val onTextMessage: (String) -> Unit,
+    val onClosing: (Int) -> Unit,
+    val onClosed: (Int) -> Unit,
+    val onFailure: () -> Unit
+)
+
+internal interface CollaborationSocket {
+    fun connect()
+    fun send(data: ByteString): Boolean
+    fun send(text: String): Boolean
+    fun close(code: Int, reason: String?): Boolean
+    fun cancel()
+}
+
+internal interface CollaborationSocketFactory {
+    fun makeSocket(
+        url: String,
+        protocols: List<String>,
+        callbacks: CollaborationSocketCallbacks
+    ): CollaborationSocket
+}
+
+internal class OkHttpCollaborationSocketFactory(private val client: OkHttpClient = OkHttpClient()) :
+    CollaborationSocketFactory {
+    override fun makeSocket(
+        url: String,
+        protocols: List<String>,
+        callbacks: CollaborationSocketCallbacks
+    ): CollaborationSocket = OkHttpCollaborationSocket(client, url, protocols, callbacks)
+}
+
+private class OkHttpCollaborationSocket(
+    private val client: OkHttpClient,
+    private val url: String,
+    private val protocols: List<String>,
+    private val callbacks: CollaborationSocketCallbacks
+) : CollaborationSocket {
+    private var webSocket: WebSocket? = null
+
+    override fun connect() {
+        check(webSocket == null)
+        val request = Request.Builder().url(url).apply {
+            if (protocols.isNotEmpty()) {
+                header("Sec-WebSocket-Protocol", protocols.joinToString(", "))
+            }
+        }.build()
+        webSocket = client.newWebSocket(
+            request,
+            object : WebSocketListener() {
+                override fun onOpen(webSocket: WebSocket, response: Response) {
+                    callbacks.onOpen(response.header("Sec-WebSocket-Protocol"))
+                }
+
+                override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+                    callbacks.onBinaryMessage(bytes.toByteArray())
+                }
+
+                override fun onMessage(webSocket: WebSocket, text: String) {
+                    callbacks.onTextMessage(text)
+                }
+
+                override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+                    webSocket.close(code, reason)
+                    callbacks.onClosing(code)
+                }
+
+                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                    callbacks.onClosed(code)
+                }
+
+                override fun onFailure(
+                    webSocket: WebSocket,
+                    error: Throwable,
+                    response: Response?
+                ) {
+                    callbacks.onFailure()
+                }
+            }
+        )
+    }
+
+    override fun send(data: ByteString): Boolean = webSocket?.send(data) == true
+    override fun send(text: String): Boolean = webSocket?.send(text) == true
+
+    override fun close(code: Int, reason: String?): Boolean = webSocket?.close(code, reason) == true
+
+    override fun cancel() {
+        webSocket?.cancel()
+    }
+}

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

@@ -0,0 +1,130 @@
+package com.apollohg.editor
+
+import org.json.JSONObject
+
+enum class EditorOrderedListNumberingScheme {
+    DECIMAL,
+    LOWER_ALPHA,
+    UPPER_ALPHA,
+    LOWER_ROMAN,
+    UPPER_ROMAN;
+
+    companion object {
+        fun fromJson(value: String): EditorOrderedListNumberingScheme? = when (value) {
+            "decimal" -> DECIMAL
+            "lowerAlpha" -> LOWER_ALPHA
+            "upperAlpha" -> UPPER_ALPHA
+            "lowerRoman" -> LOWER_ROMAN
+            "upperRoman" -> UPPER_ROMAN
+            else -> null
+        }
+    }
+}
+
+private val DEFAULT_ORDERED_LIST_SCHEMES = listOf(
+    EditorOrderedListNumberingScheme.DECIMAL,
+    EditorOrderedListNumberingScheme.LOWER_ALPHA,
+    EditorOrderedListNumberingScheme.LOWER_ROMAN
+)
+
+data class EditorOrderedListMarkerTheme(
+    val schemes: List<EditorOrderedListNumberingScheme> = DEFAULT_ORDERED_LIST_SCHEMES,
+    val suffix: String = "."
+) {
+    companion object {
+        fun fromJson(json: JSONObject?): EditorOrderedListMarkerTheme? {
+            json ?: return null
+            val parsedSchemes = json.optJSONArray("schemes")?.let { values ->
+                buildList {
+                    for (index in 0 until values.length()) {
+                        val rawValue = values.opt(index) as? String ?: continue
+                        EditorOrderedListNumberingScheme.fromJson(rawValue)?.let(::add)
+                    }
+                }
+            }.orEmpty()
+
+            return EditorOrderedListMarkerTheme(
+                schemes = parsedSchemes.ifEmpty {
+                    DEFAULT_ORDERED_LIST_SCHEMES
+                },
+                suffix = if (json.optString("suffix") == ")") ")" else "."
+            )
+        }
+    }
+}
+
+internal object OrderedListMarkerFormatter {
+    private const val MAX_INDEX = 4_294_967_295L
+
+    private val romanTable = listOf(
+        1_000L to "m",
+        900L to "cm",
+        500L to "d",
+        400L to "cd",
+        100L to "c",
+        90L to "xc",
+        50L to "l",
+        40L to "xl",
+        10L to "x",
+        9L to "ix",
+        5L to "v",
+        4L to "iv",
+        1L to "i"
+    )
+
+    fun label(index: Long, nestingDepth: Int, theme: EditorOrderedListMarkerTheme?): String {
+        val resolvedTheme = theme ?: EditorOrderedListMarkerTheme()
+        val schemes = resolvedTheme.schemes.ifEmpty {
+            DEFAULT_ORDERED_LIST_SCHEMES
+        }
+        val scheme = schemes[nestingDepth.coerceAtLeast(0) % schemes.size]
+        val suffix = if (resolvedTheme.suffix == ")") ")" else "."
+        return formattedIndex(index, scheme) + suffix
+    }
+
+    private fun formattedIndex(index: Long, scheme: EditorOrderedListNumberingScheme): String {
+        if (index !in 0..MAX_INDEX) return index.toString()
+
+        return when (scheme) {
+            EditorOrderedListNumberingScheme.DECIMAL -> index.toString()
+
+            EditorOrderedListNumberingScheme.LOWER_ALPHA -> alphabeticIndex(index)
+                ?: index.toString()
+
+            EditorOrderedListNumberingScheme.UPPER_ALPHA ->
+                alphabeticIndex(index)?.uppercase() ?: index.toString()
+
+            EditorOrderedListNumberingScheme.LOWER_ROMAN -> romanIndex(index) ?: index.toString()
+
+            EditorOrderedListNumberingScheme.UPPER_ROMAN ->
+                romanIndex(index)?.uppercase() ?: index.toString()
+        }
+    }
+
+    private fun alphabeticIndex(index: Long): String? {
+        if (index == 0L) return null
+
+        var value = index
+        val result = StringBuilder()
+        while (value > 0) {
+            val offset = ((value - 1) % 26).toInt()
+            result.append(('a'.code + offset).toChar())
+            value = (value - 1) / 26
+        }
+        return result.reverse().toString()
+    }
+
+    private fun romanIndex(index: Long): String? {
+        if (index !in 1..3_999) return null
+
+        var value = index
+        return buildString {
+            for ((unit, symbol) in romanTable) {
+                while (value >= unit) {
+                    append(symbol)
+                    value -= unit
+                }
+            }
+        }
+    }
+}