@sigx/lynx-richtext 0.4.7 → 0.4.9

package/android/com/sigx/richtext/SigxRichTextUI.kt

@@ -31,7 +31,14 @@ import com.lynx.tasm.event.LynxDetailEvent
  */
 class SigxRichTextUI(context: LynxContext) : LynxUI<RichEditText>(context) {
 
-    private val theme = RichTextTheme()
+    // Lazy: LynxUI's super constructor calls createView() BEFORE this
+    // class's property initializers run, so `theme` must not be touched
+    // there. First access happens post-construction, when mView exists —
+    // seeding from the view's platform-default color so derived visuals
+    // match until the `text-color` prop overrides it.
+    private val theme by lazy {
+        RichTextTheme().apply { textColor = mView.currentTextColor }
+    }
     private var localVersion = 0
     private var userHasEdited = false
     private var minHeightPx = 0f
@@ -53,9 +60,6 @@ class SigxRichTextUI(context: LynxContext) : LynxUI<RichEditText>(context) {
 
     override fun createView(context: Context): RichEditText {
         val view = RichEditText(context)
-        // Seed the theme from the view's platform-default color so derived
-        // visuals (code runs, etc.) match until `text-color` overrides it.
-        theme.textColor = view.currentTextColor
         view.inputType = InputType.TYPE_CLASS_TEXT or
             InputType.TYPE_TEXT_FLAG_MULTI_LINE or
             InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
@@ -116,7 +120,11 @@ class SigxRichTextUI(context: LynxContext) : LynxUI<RichEditText>(context) {
         mView.hint = value ?: ""
     }
 
-    @LynxProp(name = "editable")
+    /** Editable unless explicitly disabled — `defaultBoolean = true` makes a
+     *  null/absent value mean editable, mirroring iOS (`value?.boolValue ?? true`).
+     *  Without it, `editable={undefined}` from JS coerces to false and the
+     *  EditText becomes permanently unfocusable (#182). */
+    @LynxProp(name = "editable", defaultBoolean = true)
     fun setEditable(value: Boolean) {
         mView.isEnabled = value
         mView.isFocusable = value
@@ -249,16 +257,44 @@ class SigxRichTextUI(context: LynxContext) : LynxUI<RichEditText>(context) {
                 // Collapsed: tri-state typing override (Android's typingAttributes).
                 val inherited = formatActiveAt(editable, start, type)
                 val current = typingOverrides[type] ?: inherited
+                if (!current) {
+                    // `code` is terminal (mirrors the markdown serializer):
+                    // turning it on clears the marks it excludes, and the
+                    // excluded marks can't turn on inside it.
+                    val codeActive = typingOverrides["code"] ?: formatActiveAt(editable, start, "code")
+                    if (type == "code") {
+                        typingOverrides["bold"] = false
+                        typingOverrides["italic"] = false
+                        typingOverrides["strike"] = false
+                    } else if (codeActive) {
+                        fireSelection(start, end)
+                        callback?.invoke(LynxUIMethodConstants.SUCCESS, resultMap("active" to false))
+                        return@post
+                    }
+                }
                 typingOverrides[type] = !current
                 fireSelection(start, end)
                 callback?.invoke(LynxUIMethodConstants.SUCCESS, resultMap("active" to !current))
                 return@post
             }
             val active = rangeFullyHas(editable, type, start, end)
+            // `code` is terminal (mirrors the markdown serializer): the marks
+            // it excludes can't turn on across an all-code selection.
+            if (!active && type != "code" && rangeFullyHas(editable, "code", start, end)) {
+                fireSelection(start, end)
+                callback?.invoke(LynxUIMethodConstants.SUCCESS, resultMap("active" to false))
+                return@post
+            }
             isProgrammaticEdit = true
             if (active) {
                 removeFormatRange(editable, type, start, end)
             } else {
+                if (type == "code") {
+                    // Turning code on strips the marks it excludes.
+                    removeFormatRange(editable, "bold", start, end)
+                    removeFormatRange(editable, "italic", start, end)
+                    removeFormatRange(editable, "strike", start, end)
+                }
                 editable.setSpan(newMarker(type), start, end, DocumentMapper.INLINE_FLAGS)
             }
             isProgrammaticEdit = false

package/dist/model/codec.js

@@ -6,6 +6,8 @@
  * `decodeDoc` is defensive: malformed input degrades to an empty document
  * rather than throwing (events from native should never crash the BG thread).
  */
+const INLINE_TYPES = new Set(['bold', 'italic', 'strike', 'code', 'link', 'mention']);
+const BLOCK_TYPES = new Set(['paragraph', 'heading', 'bullet', 'ordered', 'task', 'blockquote', 'codeBlock', 'raw']);
 export function emptyDoc(v = 0) {
     return { text: '', spans: [], blocks: [], v };
 }
@@ -34,13 +36,16 @@ function sanitizeSpans(spans, max) {
         return [];
     const out = [];
     for (const s of spans) {
-        if (!s || typeof s.start !== 'number' || typeof s.end !== 'number' || !s.type)
+        if (!s || typeof s.start !== 'number' || typeof s.end !== 'number')
+            continue;
+        if (typeof s.type !== 'string' || !INLINE_TYPES.has(s.type))
             continue;
         const start = clamp(s.start, 0, max);
         const end = clamp(s.end, 0, max);
         if (end <= start)
             continue;
-        out.push({ start, end, type: s.type, ...(s.attrs ? { attrs: s.attrs } : {}) });
+        const attrs = s.attrs && typeof s.attrs === 'object' && !Array.isArray(s.attrs) ? s.attrs : undefined;
+        out.push({ start, end, type: s.type, ...(attrs ? { attrs } : {}) });
     }
     return out;
 }
@@ -49,7 +54,9 @@ function sanitizeBlocks(blocks, max) {
         return [];
     const out = [];
     for (const b of blocks) {
-        if (!b || typeof b.start !== 'number' || typeof b.end !== 'number' || !b.type)
+        if (!b || typeof b.start !== 'number' || typeof b.end !== 'number')
+            continue;
+        if (typeof b.type !== 'string' || !BLOCK_TYPES.has(b.type))
             continue;
         const start = clamp(b.start, 0, max);
         const end = clamp(b.end, 0, max);
@@ -59,8 +66,8 @@ function sanitizeBlocks(blocks, max) {
             start,
             end,
             type: b.type,
-            ...(b.level !== undefined ? { level: b.level } : {}),
-            ...(b.checked !== undefined ? { checked: b.checked } : {}),
+            ...(typeof b.level === 'number' && Number.isFinite(b.level) ? { level: Math.floor(b.level) } : {}),
+            ...(typeof b.checked === 'boolean' ? { checked: b.checked } : {}),
         });
     }
     return out;

package/ios/DocumentMapper.swift

@@ -142,20 +142,25 @@ enum DocumentMapper {
                 font = theme.headingFont(level: block["level"] as? Int ?? 1)
             }
 
-            if attrs[SigxAttr.code] != nil {
+            // `code` is terminal (mirrors the markdown serializer, where
+            // computeRuns drops every mark but `link` inside a code span):
+            // bold/italic/strike never render inside a code run, so the
+            // field can't show styling that serialization would discard.
+            let isCode = attrs[SigxAttr.code] != nil
+            if isCode {
                 font = theme.codeFont
                 background = theme.codeBackground
             }
 
             var traits = font.fontDescriptor.symbolicTraits
-            if attrs[SigxAttr.bold] != nil { traits.insert(.traitBold) }
-            if attrs[SigxAttr.italic] != nil { traits.insert(.traitItalic) }
+            if !isCode, attrs[SigxAttr.bold] != nil { traits.insert(.traitBold) }
+            if !isCode, attrs[SigxAttr.italic] != nil { traits.insert(.traitItalic) }
             if traits != font.fontDescriptor.symbolicTraits,
                let descriptor = font.fontDescriptor.withSymbolicTraits(traits) {
                 font = UIFont(descriptor: descriptor, size: font.pointSize)
             }
 
-            if attrs[SigxAttr.strike] != nil { strike = true }
+            if !isCode, attrs[SigxAttr.strike] != nil { strike = true }
             if attrs[SigxAttr.link] != nil {
                 color = theme.accentColor
                 underline = true

package/ios/SigxRichTextUI.swift

@@ -263,7 +263,23 @@ public class SigxRichTextUI: LynxUI<RichTextView> {
                 // carries (or drops) the format.
                 var typing = view.typingAttributes
                 let active = typing[key] != nil
-                if active { typing.removeValue(forKey: key) } else { typing[key] = true }
+                if active {
+                    typing.removeValue(forKey: key)
+                } else {
+                    // `code` is terminal (mirrors the markdown serializer):
+                    // turning it on clears the marks it excludes, and the
+                    // excluded marks can't turn on inside it.
+                    if key == SigxAttr.code {
+                        typing.removeValue(forKey: SigxAttr.bold)
+                        typing.removeValue(forKey: SigxAttr.italic)
+                        typing.removeValue(forKey: SigxAttr.strike)
+                    } else if typing[SigxAttr.code] != nil, key != SigxAttr.link {
+                        self.fireSelection()
+                        callback(SigxRichTextUI.kUIMethodSuccess, ["active": false])
+                        return
+                    }
+                    typing[key] = true
+                }
                 typing[.font] = SigxRichTextUI.deriveTypingFont(from: typing, theme: self.theme)
                 view.typingAttributes = typing
                 self.fireSelection()
@@ -275,11 +291,25 @@ public class SigxRichTextUI: LynxUI<RichTextView> {
                 return
             }
             let active = SigxRichTextUI.rangeFullyHasAttribute(storage, key: key, range: selection)
+            // `code` is terminal (mirrors the markdown serializer): the marks
+            // it excludes can't turn on across an all-code selection.
+            if !active, key != SigxAttr.code, key != SigxAttr.link,
+               SigxRichTextUI.rangeFullyHasAttribute(storage, key: SigxAttr.code, range: selection) {
+                self.fireSelection()
+                callback(SigxRichTextUI.kUIMethodSuccess, ["active": false])
+                return
+            }
             self.isProgrammaticEdit = true
             storage.beginEditing()
             if active {
                 storage.removeAttribute(key, range: selection)
             } else {
+                if key == SigxAttr.code {
+                    // Turning code on strips the marks it excludes.
+                    storage.removeAttribute(SigxAttr.bold, range: selection)
+                    storage.removeAttribute(SigxAttr.italic, range: selection)
+                    storage.removeAttribute(SigxAttr.strike, range: selection)
+                }
                 storage.addAttribute(key, value: true, range: selection)
             }
             DocumentMapper.refreshVisuals(storage, range: selection, theme: self.theme)
@@ -503,7 +533,9 @@ public class SigxRichTextUI: LynxUI<RichTextView> {
            (block["type"] as? String) == "heading" {
             font = theme.headingFont(level: block["level"] as? Int ?? 1)
         }
-        if attrs[SigxAttr.code] != nil { font = theme.codeFont }
+        // `code` is terminal (matches the serializer + applyBaseVisuals):
+        // characters typed inside a code run never pick up bold/italic.
+        if attrs[SigxAttr.code] != nil { return theme.codeFont }
         var traits = font.fontDescriptor.symbolicTraits
         if attrs[SigxAttr.bold] != nil { traits.insert(.traitBold) }
         if attrs[SigxAttr.italic] != nil { traits.insert(.traitItalic) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigx/lynx-richtext",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Native rich-text input element for Lynx (<sigx-richtext>): attributed editing (UITextView / EditText) with a span-based document model, selection events, and formatting commands. Powers @sigx/lynx-markdown's MarkdownEditor.",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,13 +23,13 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "@sigx/lynx": "^0.4.7"
+    "@sigx/lynx": "^0.4.9"
   },
   "devDependencies": {
     "@typescript/native-preview": "7.0.0-dev.20260521.1",
     "typescript": "^6.0.3",
-    "@sigx/lynx-testing": "^0.4.7",
-    "@sigx/lynx": "^0.4.7"
+    "@sigx/lynx": "^0.4.9",
+    "@sigx/lynx-testing": "^0.4.9"
   },
   "author": "Andreas Ekdahl",
   "license": "MIT",