@apollohg/react-native-rich-text-editor 2.0.1 → 2.0.3

package/ios/EditorTextView+KeyboardInput.swift

@@ -1,7 +1,306 @@
 import os
 import UIKit
 
+enum EditorPasteMode: String {
+    case rich
+    case plainText
+    case disabled
+}
+
+struct EditorClipboardPayload {
+    static let fragmentType = "com.apollohg.native-editor.fragment"
+
+    let fragment: String
+    let html: String
+    let text: String
+
+    init(fragment: String, html: String, text: String) {
+        self.fragment = fragment
+        self.html = html
+        self.text = text
+    }
+
+    init?(json: String) {
+        guard let data = json.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              object["empty"] as? Bool != true,
+              let fragment = object["fragment"] as? String,
+              let html = object["html"] as? String,
+              let text = object["text"] as? String
+        else { return nil }
+        self.init(fragment: fragment, html: html, text: text)
+    }
+
+    @discardableResult
+    func write(to pasteboard: UIPasteboard) -> Bool {
+        pasteboard.items = [[
+            Self.fragmentType: Data(fragment.utf8),
+            "public.html": Data(html.utf8),
+            "public.utf8-plain-text": text
+        ]]
+        return pasteboard.data(forPasteboardType: Self.fragmentType) != nil
+            && pasteboard.data(forPasteboardType: "public.html") != nil
+            && pasteboard.string != nil
+    }
+}
+
+enum EditorClipboardPaste {
+    static let maximumRTFBytes = 64 * 1_024 * 1_024
+
+    static let supportedTypes = [
+        EditorClipboardPayload.fragmentType,
+        "public.html",
+        "public.rtf",
+        "public.utf8-plain-text",
+        "public.plain-text",
+        "public.text"
+    ]
+
+    static func hasSupportedContent(in pasteboard: UIPasteboard) -> Bool {
+        pasteboard.contains(pasteboardTypes: supportedTypes)
+    }
+
+    static func command(
+        from pasteboard: UIPasteboard,
+        mode: EditorPasteMode,
+        maximumRTFBytes: Int = EditorClipboardPaste.maximumRTFBytes
+    ) -> [String: Any]? {
+        guard mode != .disabled else { return nil }
+        var command: [String: Any] = ["type": "paste"]
+        if let fragment = utf8String(pasteboard.data(forPasteboardType: EditorClipboardPayload.fragmentType)) {
+            command["fragment"] = fragment
+        }
+        var html = utf8String(pasteboard.data(forPasteboardType: "public.html"))
+        var text = pasteboard.string
+        if html == nil,
+           let rtf = pasteboard.data(forPasteboardType: "public.rtf"),
+           rtf.count <= maximumRTFBytes,
+           let attributed = try? NSAttributedString(
+               data: rtf,
+               options: [.documentType: NSAttributedString.DocumentType.rtf],
+               documentAttributes: nil
+           ) {
+            let convertedHTML = semanticHTML(from: attributed)
+            if !convertedHTML.isEmpty {
+                html = convertedHTML
+            }
+            if text == nil {
+                text = attributed.string
+            }
+        }
+        let hasStructuredContent = command["fragment"] != nil || html != nil
+        guard hasStructuredContent || !(text?.isEmpty ?? true) else { return nil }
+        if let html {
+            command["html"] = html
+        }
+        if let text {
+            command["text"] = text
+        }
+        if mode == .plainText {
+            command["plainText"] = true
+        }
+        return command.count > 1 ? command : nil
+    }
+
+    private static func utf8String(_ data: Data?) -> String? {
+        guard let data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    private static func semanticHTML(from attributed: NSAttributedString) -> String {
+        let range = NSRange(location: 0, length: attributed.length)
+        var hasList = false
+        attributed.enumerateAttribute(.paragraphStyle, in: range) { value, _, stop in
+            if let style = value as? NSParagraphStyle, !style.textLists.isEmpty {
+                hasList = true
+                stop.pointee = true
+            }
+        }
+        guard attributed.string.contains("\n") || attributed.string.contains("\r") || hasList else {
+            return semanticInlineHTML(from: attributed, range: range)
+        }
+
+        let string = attributed.string as NSString
+        var paragraphs: [(html: String, listTags: [String])] = []
+        var location = 0
+        while location < string.length {
+            let paragraphRange = string.paragraphRange(
+                for: NSRange(location: location, length: 0)
+            )
+            var contentLength = paragraphRange.length
+            while contentLength > 0 {
+                let scalar = string.character(at: paragraphRange.location + contentLength - 1)
+                guard scalar == 0x000A || scalar == 0x000D else { break }
+                contentLength -= 1
+            }
+            let contentRange = NSRange(location: paragraphRange.location, length: contentLength)
+            let styleLocation = min(paragraphRange.location, max(attributed.length - 1, 0))
+            let style = attributed.length > 0
+                ? attributed.attribute(.paragraphStyle, at: styleLocation, effectiveRange: nil)
+                    as? NSParagraphStyle
+                : nil
+            paragraphs.append((
+                html: semanticInlineHTML(from: attributed, range: contentRange),
+                listTags: style?.textLists.map(listTag) ?? []
+            ))
+            location = NSMaxRange(paragraphRange)
+        }
+        if let finalScalar = attributed.string.utf16.last,
+           finalScalar == 0x000A || finalScalar == 0x000D {
+            let style = attributed.attribute(
+                .paragraphStyle,
+                at: attributed.length - 1,
+                effectiveRange: nil
+            ) as? NSParagraphStyle
+            paragraphs.append((html: "", listTags: style?.textLists.map(listTag) ?? []))
+        }
+
+        var html = ""
+        var openListTags: [String] = []
+        for paragraph in paragraphs {
+            guard !paragraph.listTags.isEmpty else {
+                closeLists(&openListTags, into: &html)
+                html += "<p>\(paragraph.html)</p>"
+                continue
+            }
+
+            let sharedDepth = zip(openListTags, paragraph.listTags)
+                .prefix { $0.0 == $0.1 }
+                .count
+            while openListTags.count > sharedDepth {
+                let tag = openListTags.removeLast()
+                html += "</li></\(tag)>"
+            }
+            if !openListTags.isEmpty, openListTags.count == paragraph.listTags.count {
+                html += "</li><li>"
+            }
+            for tag in paragraph.listTags.dropFirst(sharedDepth) {
+                html += "<\(tag)><li>"
+                openListTags.append(tag)
+            }
+            html += paragraph.html
+        }
+        closeLists(&openListTags, into: &html)
+        return html
+    }
+
+    private static func semanticInlineHTML(
+        from attributed: NSAttributedString,
+        range: NSRange
+    ) -> String {
+        var html = ""
+        attributed.enumerateAttributes(in: range) { attributes, range, _ in
+            var run = escapeHTMLText(attributed.attributedSubstring(from: range).string)
+            if let font = attributes[.font] as? UIFont {
+                let traits = font.fontDescriptor.symbolicTraits
+                if traits.contains(.traitBold) {
+                    run = "<strong>\(run)</strong>"
+                }
+                if traits.contains(.traitItalic) {
+                    run = "<em>\(run)</em>"
+                }
+            }
+            if styleIsSet(attributes[.underlineStyle]) {
+                run = "<u>\(run)</u>"
+            }
+            if styleIsSet(attributes[.strikethroughStyle]) {
+                run = "<s>\(run)</s>"
+            }
+            if let href = linkString(attributes[.link]) {
+                run = "<a href=\"\(escapeHTMLAttribute(href))\">\(run)</a>"
+            }
+            html += run
+        }
+        guard !html.isEmpty else { return "" }
+        return "<span style=\"white-space:pre-wrap\">\(html)</span>"
+    }
+
+    private static func listTag(_ list: NSTextList) -> String {
+        let marker = String(describing: list.markerFormat).lowercased()
+        let orderedMarkers = ["decimal", "roman", "alpha", "latin"]
+        return orderedMarkers.contains { marker.contains($0) } ? "ol" : "ul"
+    }
+
+    private static func closeLists(_ tags: inout [String], into html: inout String) {
+        while let tag = tags.popLast() {
+            html += "</li></\(tag)>"
+        }
+    }
+
+    private static func escapeHTMLText(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "&", with: "&amp;")
+            .replacingOccurrences(of: "<", with: "&lt;")
+            .replacingOccurrences(of: ">", with: "&gt;")
+            .replacingOccurrences(of: "\r\n", with: "\n")
+            .replacingOccurrences(of: "\r", with: "\n")
+            .replacingOccurrences(of: "\n", with: "<br>")
+    }
+
+    private static func escapeHTMLAttribute(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "&", with: "&amp;")
+            .replacingOccurrences(of: "<", with: "&lt;")
+            .replacingOccurrences(of: ">", with: "&gt;")
+            .replacingOccurrences(of: "\"", with: "&quot;")
+            .replacingOccurrences(of: "'", with: "&#39;")
+    }
+
+    private static func styleIsSet(_ value: Any?) -> Bool {
+        guard let number = value as? NSNumber else { return false }
+        return number.intValue != 0
+    }
+
+    private static func linkString(_ value: Any?) -> String? {
+        if let url = value as? URL {
+            return url.absoluteString
+        }
+        return value as? String
+    }
+}
+
 extension EditorTextView {
+    @discardableResult
+    func exportSelectionToPasteboard(_ pasteboard: UIPasteboard = .general) -> Bool {
+        ensureInternalTextViewDelegate()
+        guard editorId != 0 else { return false }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return false }
+        guard prepareForExternalEditorUpdate() else { return false }
+        guard syncClipboardSelectionToRust(requiresRange: true) != nil else { return false }
+        guard let payload = EditorV2Shadow.clipboardPayload(id: editorId) else { return false }
+        return payload.write(to: pasteboard)
+    }
+
+    func syncClipboardSelectionToRust(
+        requiresRange: Bool = false
+    ) -> (anchor: UInt32, head: UInt32)? {
+        guard let selection = currentScalarSelection() else { return nil }
+        guard !requiresRange
+            || selection.anchor != selection.head
+            || selectedImageSelectionState() != nil
+        else { return nil }
+        let sync: EditorV2SelectionSync?
+        if let image = selectedImageSelectionState() {
+            sync = EditorV2Shadow.setNodeSelection(id: editorId, docPos: image.docPos)
+        } else {
+            sync = EditorV2Shadow.setSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head
+            )
+        }
+        guard let sync else { return nil }
+        if let refreshed = sync.refreshedUpdateJSON {
+            applyUpdateJSON(refreshed, notifyDelegate: false)
+        }
+        return selection
+    }
+
+    func applyClipboardCommand(_ command: [String: Any]) {
+        let updateJSON = EditorV2Shadow.applyClipboardCommand(id: editorId, command: command)
+        applyUpdateJSON(updateJSON)
+    }
+
     @objc func handleIndentKeyCommand() {
         handleListDepthKeyCommand(outdent: false)
     }

package/ios/EditorTextView.swift

@@ -35,6 +35,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
     var hidesNativeSelectionChrome = false
     var isPreviewingImageResize = false
     var allowImageResizing = true
+    var pasteMode: EditorPasteMode = .rich
 
     override var isEditable: Bool {
         didSet {
@@ -415,7 +416,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
                 height: min(maxPlaceholderHeight, ceil(fittedHeight))
             )
         }
-        if heightBehavior == .autoGrow, !isPreviewingImageResize {
+        if heightBehavior == .autoGrow {
             let currentWidth = ceil(bounds.width)
             if abs(currentWidth - lastAutoGrowMeasuredWidth) > 0.5 {
                 autoGrowHeightCheckIsDirty = true
@@ -622,6 +623,11 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
                 input: "\t",
                 modifierFlags: [.shift],
                 action: #selector(handleOutdentKeyCommand)
+            ),
+            UIKeyCommand(
+                input: "v",
+                modifierFlags: [.command, .shift],
+                action: #selector(pasteAndMatchStyle(_:))
             )
         ]
     }
@@ -875,61 +881,75 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
         }
     }
 
-    // MARK: - Paste Handling
+    // MARK: - Clipboard
+
+    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
+        guard editorId != 0 else {
+            return super.canPerformAction(action, withSender: sender)
+        }
+        switch action {
+        case #selector(copy(_:)):
+            return selectedTextRange?.isEmpty == false
+        case #selector(cut(_:)):
+            return isEditable && selectedTextRange?.isEmpty == false
+        case #selector(paste(_:)), #selector(pasteAndMatchStyle(_:)):
+            return isEditable
+                && pasteMode != .disabled
+                && EditorClipboardPaste.hasSupportedContent(in: .general)
+        default:
+            return super.canPerformAction(action, withSender: sender)
+        }
+    }
+
+    override func copy(_ sender: Any?) {
+        guard editorId != 0 else {
+            super.copy(sender)
+            return
+        }
+        _ = exportSelectionToPasteboard()
+    }
+
+    override func cut(_ sender: Any?) {
+        guard editorId != 0 else {
+            super.cut(sender)
+            return
+        }
+        guard isEditable, exportSelectionToPasteboard() else { return }
+        performInterceptedInput {
+            applyClipboardCommand(["type": "paste", "text": "", "plainText": true])
+        }
+    }
 
-    /// Intercept paste operations to route content through Rust.
-    ///
-    /// Attempts to extract HTML from the pasteboard first (for rich text paste),
-    /// falling back to plain text.
     override func paste(_ sender: Any?) {
+        pasteFromPasteboard(forcePlainText: false, sender: sender)
+    }
+
+    override func pasteAndMatchStyle(_ sender: Any?) {
+        pasteFromPasteboard(forcePlainText: true, sender: sender)
+    }
+
+    private func pasteFromPasteboard(forcePlainText: Bool, sender: Any?) {
         ensureInternalTextViewDelegate()
         guard editorId != 0 else {
-            super.paste(sender)
+            if forcePlainText {
+                super.pasteAndMatchStyle(sender)
+            } else {
+                super.paste(sender)
+            }
             return
         }
+        guard isEditable, pasteMode != .disabled else { return }
         guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return }
         guard prepareForExternalEditorUpdate() else { return }
+        guard syncClipboardSelectionToRust() != nil else { return }
+        let mode: EditorPasteMode = forcePlainText ? .plainText : pasteMode
+        guard let command = EditorClipboardPaste.command(from: .general, mode: mode) else { return }
 
         Self.inputLog.debug(
             "[paste] selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
         )
-
-        let pasteboard = UIPasteboard.general
-
-        if let htmlData = pasteboard.data(forPasteboardType: "public.html"),
-           let html = String(data: htmlData, encoding: .utf8) {
-            performInterceptedInput {
-                pasteHTML(html)
-            }
-            return
-        }
-
-        if let rtfData = pasteboard.data(forPasteboardType: "public.rtf") {
-            if let attrStr = try? NSAttributedString(
-                data: rtfData,
-                options: [.documentType: NSAttributedString.DocumentType.rtf],
-                documentAttributes: nil
-            ) {
-                if let htmlData = try? attrStr.data(
-                    from: NSRange(location: 0, length: attrStr.length),
-                    documentAttributes: [.documentType: NSAttributedString.DocumentType.html]
-                ), let html = String(data: htmlData, encoding: .utf8) {
-                    performInterceptedInput {
-                        if !pasteHTML(html, detectContentChange: true),
-                           !attrStr.string.isEmpty {
-                            pastePlainText(attrStr.string)
-                        }
-                    }
-                    return
-                }
-            }
-        }
-
-        if let text = pasteboard.string {
-            performInterceptedInput {
-                pastePlainText(text)
-            }
-            return
+        performInterceptedInput {
+            applyClipboardCommand(command)
         }
     }
 

package/ios/EditorV2Adapter+Commands.swift

@@ -1,6 +1,28 @@
 import Foundation
 
 extension EditorV2Adapter {
+    func clipboardPayloadJSON() -> String? {
+        guard beginRuntimeOperation() else { return nil }
+        defer { endRuntimeOperation() }
+        switch Self.normalizeJsonResult(editorV2GetClipboard(editorId: editorId)) {
+        case .failure(let error):
+            emit(error)
+            return nil
+        case .success(let json):
+            return json
+        }
+    }
+
+    func applyClipboardCommand(_ command: [String: Any]) -> String? {
+        guard beginRuntimeOperation() else { return nil }
+        defer { endRuntimeOperation() }
+        return performMutation(adoptEngineSelection: true) {
+            self.callWithEnvelope(["command": command]) { requestJson in
+                editorV2ApplyCommand(editorId: self.editorId, requestJson: requestJson)
+            }
+        }
+    }
+
     func toggleMark(_ markType: String, anchor: UInt32, head: UInt32) -> String? {
         guard beginRuntimeOperation() else { return nil }
         defer { endRuntimeOperation() }

package/ios/EditorV2Adapter+RenderValidation.swift

@@ -150,7 +150,7 @@ extension EditorV2Adapter {
     private static func isValidMentionStyle(_ value: Any) -> Bool {
         guard let style = value as? [String: Any] else { return false }
         let colors: Set<String> = ["color", "backgroundColor", "textDecorationColor", "borderColor", "borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"]
-        let dimensions: Set<String> = ["fontSize", "lineHeight", "letterSpacing", "borderWidth", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius"]
+        let dimensions: Set<String> = ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "fontSize", "lineHeight", "letterSpacing", "borderWidth", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius"]
         let strings: Set<String> = ["fontFamily", "fontWeight", "fontStyle", "textDecorationLine", "textDecorationStyle", "borderStyle"]
         guard hasOnlyKeys(style, colors.union(dimensions).union(strings)) else { return false }
         for key in colors where style[key] != nil {
@@ -159,7 +159,7 @@ extension EditorV2Adapter {
         for key in dimensions where style[key] != nil {
             guard let number = finiteNumber(style[key])?.doubleValue else { return false }
             if ["fontSize", "lineHeight"].contains(key), number <= 0 { return false }
-            if key.hasPrefix("border"), number < 0 { return false }
+            if key.hasPrefix("border") || key.hasPrefix("padding"), number < 0 { return false }
         }
         for key in strings where style[key] != nil {
             guard let value = style[key] as? String else { return false }

package/ios/EditorV2Shadow.swift

@@ -71,6 +71,11 @@ enum EditorV2Shadow {
         adapter(for: id)?.contentSnapshotJSON() ?? "{\"html\":\"\",\"json\":{}}"
     }
 
+    static func clipboardPayload(id: UInt64) -> EditorClipboardPayload? {
+        guard let json = adapter(for: id)?.clipboardPayloadJSON() else { return nil }
+        return EditorClipboardPayload(json: json)
+    }
+
     // MARK: - State / selection reads
 
     static func getCurrentState(id: UInt64) -> String {
@@ -295,6 +300,13 @@ enum EditorV2Shadow {
         adapter(for: id)?.insertContentHtmlAtEngineSelection(html) ?? "{}"
     }
 
+    static func applyClipboardCommand(
+        id: UInt64,
+        command: [String: Any]
+    ) -> String {
+        adapter(for: id)?.applyClipboardCommand(command) ?? "{}"
+    }
+
     static func insertContentJson(id: UInt64, json: String) -> String {
         adapter(for: id)?.insertContentJsonAtEngineSelection(json) ?? "{}"
     }

package/ios/Generated_editor_core.swift

@@ -2077,6 +2077,13 @@ public func editorV2DocToScalar(editorId: String, docPos: UInt32) -> FfiJsonResu
     )
 })
 }
+public func editorV2GetClipboard(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_clipboard(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
 public func editorV2GetContentSnapshot(editorId: String) -> FfiJsonResult  {
     return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
     uniffi_editor_core_fn_func_editor_v2_get_content_snapshot(
@@ -2289,6 +2296,9 @@ private let initializationResult: InitializationResult = {
     if (uniffi_editor_core_checksum_func_editor_v2_doc_to_scalar() != 62503) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_clipboard() != 3214) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_editor_core_checksum_func_editor_v2_get_content_snapshot() != 21323) {
         return InitializationResult.apiChecksumMismatch
     }

package/ios/NativeEditorExpoView+Properties.swift

@@ -104,6 +104,10 @@ extension NativeEditorExpoView {
         updateAccessoryToolbarVisibility()
     }
 
+    func setPasteMode(_ pasteMode: String) {
+        richTextView.textView.pasteMode = EditorPasteMode(rawValue: pasteMode) ?? .rich
+    }
+
     func setAccessibilityLabel(_ label: String?) {
         richTextView.textView.accessibilityLabel = label
     }

package/ios/NativeEditorModule.swift

@@ -753,6 +753,9 @@ public class NativeEditorModule: BaseModule, @preconcurrency AnyModule {
             Prop("editable") { (view: NativeEditorExpoView, editable: Bool) in
                 view.setEditable(editable)
             }
+            Prop("pasteMode") { (view: NativeEditorExpoView, pasteMode: String) in
+                view.setPasteMode(pasteMode)
+            }
             Prop("accessibilityLabel") { (view: NativeEditorExpoView, label: String?) in
                 view.setAccessibilityLabel(label)
             }

package/ios/NativeToolbar+ButtonStyle.swift

@@ -108,9 +108,7 @@ extension EditorAccessoryToolbarView {
                 ?? (resolvedAppearance == .native ? self.tintColor : .secondaryLabel)
         }
 
-        button.tintColor = tintColor
-        button.setTitleColor(tintColor, for: .normal)
-        button.setTitleColor(tintColor, for: .disabled)
+        applyButtonForeground(to: button, color: tintColor)
         button.tintAdjustmentMode = enabled ? .automatic : .normal
         button.alpha = enabled || resolvedAppearance == .native ? 1 : 0.7
         let inactiveBackgroundColor = buttonStyle?.backgroundColor
@@ -139,7 +137,20 @@ extension EditorAccessoryToolbarView {
             color: backgroundColor,
             cornerRadius: cornerRadius
         )
-        applyButtonIconStyle(to: button, item: item)
+        applyButtonIconStyle(to: button, item: item, color: tintColor)
+    }
+
+    /// A configured `UIButton` paints disabled content in its own system gray,
+    /// ignoring `tintColor`, so the colour must be forced through the
+    /// configuration's transformers as well.
+    private func applyButtonForeground(to button: UIButton, color: UIColor) {
+        button.tintColor = color
+        button.setTitleColor(color, for: .normal)
+        button.setTitleColor(color, for: .disabled)
+        guard #available(iOS 15.0, *), var configuration = button.configuration else { return }
+        configuration.baseForegroundColor = color
+        configuration.imageColorTransformer = UIConfigurationColorTransformer { _ in color }
+        button.configuration = configuration
     }
 
     /// Own the configured background to avoid stacking it with UIButton state fills.
@@ -175,13 +186,14 @@ extension EditorAccessoryToolbarView {
         return min(requestedSize, resolvedButtonSize)
     }
 
-    private func applyButtonIconStyle(to button: UIButton, item: NativeToolbarItem) {
+    private func applyButtonIconStyle(to button: UIButton, item: NativeToolbarItem, color: UIColor) {
         let iconSize = resolvedButtonIconSize(for: item)
         let font = UIFont.systemFont(ofSize: iconSize, weight: .semibold)
         if #available(iOS 15.0, *), var configuration = button.configuration {
             configuration.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { incoming in
                 var outgoing = incoming
                 outgoing.font = font
+                outgoing.foregroundColor = color
                 return outgoing
             }
             button.configuration = configuration

package/ios/NativeToolbar+Diagnostics.swift

@@ -25,6 +25,21 @@ extension EditorAccessoryToolbarView {
         buttonBindings.indices.contains(index) ? buttonBindings[index].button.tintColor : nil
     }
 
+    /// The foreground colour a configured button will actually paint for its
+    /// current state, resolved through the configuration transformers rather
+    /// than `tintColor`, which UIKit ignores for disabled configured buttons.
+    func buttonPaintedForegroundColorForTesting(_ index: Int) -> UIColor? {
+        guard buttonBindings.indices.contains(index) else { return nil }
+        let button = buttonBindings[index].button
+        guard #available(iOS 15.0, *), let configuration = button.configuration else {
+            return button.titleColor(for: button.state)
+        }
+        if button.image(for: .normal) != nil {
+            return configuration.imageColorTransformer?(.black)
+        }
+        return configuration.titleTextAttributesTransformer?(AttributeContainer()).foregroundColor
+    }
+
     func buttonFontSizeForTesting(_ index: Int) -> CGFloat? {
         buttonBindings.indices.contains(index) ? buttonBindings[index].button.titleLabel?.font.pointSize : nil
     }

package/ios/RenderBridge+Atoms.swift

@@ -192,7 +192,6 @@ extension RenderBridge {
             }
             let attachment = BlockImageAttachment(
                 source: source,
-                placeholderTint: textColor,
                 preferredWidth: jsonCGFloat(elementAttrs["width"]),
                 preferredHeight: jsonCGFloat(elementAttrs["height"])
             )