@openeditor/react-native-prose-editor 0.0.2

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

@@ -0,0 +1,50 @@
+package com.openeditor.editor
+
+import android.graphics.Paint
+import android.text.Layout
+
+/**
+ * Vertical geometry for the text caret, clipped to the rendered glyph height.
+ *
+ * Android's [android.widget.Editor] draws the native caret from
+ * `Layout.getLineTop(line)` to `Layout.getLineBottom(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 {
+        val line = layout.getLineForOffset(offset.coerceIn(0, layout.text.length))
+        val top = layout.getLineTop(line).toFloat()
+        // Anchor the bottom at the glyph descent below the baseline. The baseline
+        // is independent of any ReplacementSpan descent inflation, so this clips
+        // the caret to the rendered text height instead of the inflated line bottom.
+        val bottom = layout.getLineBaseline(line) + paint.fontMetrics.descent
+        return VerticalBounds(top, bottom)
+    }
+}

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

@@ -0,0 +1,135 @@
+package com.openeditor.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?
+) {
+    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"))
+            )
+        }
+    }
+}
+
+data class MentionQueryState(
+    val query: String,
+    val trigger: String,
+    val anchor: Int,
+    val head: Int
+)
+
+internal fun isMentionIdentifierCodePoint(codePoint: Int): Boolean {
+    return 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
+    )
+}