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

package/ios/RenderBridge+Atoms.swift

@@ -0,0 +1,288 @@
+import CryptoKit
+import ImageIO
+import UIKit
+
+extension RenderBridge {
+    /// Build NSAttributedString attributes for a set of render marks.
+    ///
+    /// Supported marks:
+    /// - `bold` -> adds `.traitBold` to the font descriptor
+    /// - `italic` -> adds `.traitItalic` to the font descriptor
+    /// - `underline` -> sets `.underlineStyle = .single`
+    /// - `strike` / `strikethrough` -> sets `.strikethroughStyle = .single`
+    /// - `code` -> uses a monospaced font variant
+    ///
+    /// Multiple marks are combined: "bold italic" produces a bold-italic font.
+    static func attributesForMarks(
+        _ marks: [Any],
+        baseFont: UIFont,
+        textColor: UIColor,
+        theme: EditorTheme? = nil
+    ) -> [NSAttributedString.Key: Any] {
+        if let sheet = theme?.styleSheet {
+            return sheet.inlineAttributes(marks, base: defaultAttributes(baseFont: baseFont, textColor: textColor))
+        }
+        var attrs = defaultAttributes(baseFont: baseFont, textColor: textColor)
+
+        if marks.isEmpty {
+            return attrs
+        }
+
+        var traits: UIFontDescriptor.SymbolicTraits = []
+        var useMonospace = false
+        var linkTheme: EditorLinkTheme?
+        var shouldUnderline = false
+        for mark in marks {
+            let markObject = mark as? [String: Any]
+            let markType: String
+            if let markName = mark as? String {
+                markType = markName
+            } else if let resolvedType = markObject?["type"] as? String {
+                markType = resolvedType
+            } else {
+                continue
+            }
+
+            switch markType {
+            case "bold", "strong":
+                traits.insert(.traitBold)
+            case "italic", "em":
+                traits.insert(.traitItalic)
+            case "underline":
+                shouldUnderline = true
+            case "strike", "strikethrough":
+                attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+            case "code":
+                useMonospace = true
+            case "link":
+                linkTheme = theme?.links
+                if theme?.links?.underline ?? true {
+                    shouldUnderline = true
+                }
+                attrs[.foregroundColor] = theme?.links?.color ?? UIColor.systemBlue
+                if let backgroundColor = theme?.links?.backgroundColor {
+                    attrs[.backgroundColor] = backgroundColor
+                }
+                if let href = markObject?["href"] as? String, !href.isEmpty {
+                    attrs[RenderBridgeAttributes.linkHref] = href
+                }
+            default:
+                break
+            }
+        }
+
+        var resolvedFont = linkTheme?.resolvedFont(fallback: baseFont) ?? baseFont
+
+        resolvedFont = ViewerFontEnvironment.shared.resolveFont(
+            family: useMonospace ? "monospace" : nil,
+            size: resolvedFont.pointSize,
+            fallback: resolvedFont,
+            additionalTraits: traits,
+            semanticGeneration: "legacy-editor-theme"
+        )
+
+        if shouldUnderline {
+            attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue
+        }
+        attrs[.font] = resolvedFont
+        return attrs
+    }
+
+    /// Create an attributed string for a void inline element (e.g. hardBreak).
+    ///
+    /// A hardBreak is rendered as a newline character with custom attributes
+    /// so the position bridge knows it represents a single doc position.
+    static func attributedStringForVoidInline(
+        nodeType: String,
+        docPos: UInt32,
+        attrs _: [String: Any],
+        baseFont: UIFont,
+        textColor: UIColor,
+        blockStack: [BlockContext],
+        topLevelChildIndex _: Int?,
+        theme: EditorTheme?
+    ) -> NSAttributedString {
+        let blockFont = resolvedFont(for: blockStack, baseFont: baseFont, theme: theme)
+        let blockColor = resolvedTextColor(for: blockStack, textColor: textColor, theme: theme)
+        var attrs = defaultAttributes(baseFont: blockFont, textColor: blockColor)
+        attrs[RenderBridgeAttributes.voidNodeType] = nodeType
+        attrs[RenderBridgeAttributes.docPos] = docPos
+        let styledAttrs = applyBlockStyle(
+            to: attrs,
+            blockStack: blockStack,
+            theme: theme,
+            blockBaseFont: blockFont
+        )
+
+        switch nodeType {
+        case "hardBreak", "hard_break":
+            var hardBreakAttrs = styledAttrs
+            if let paragraphStyle = (hardBreakAttrs[.paragraphStyle] as? NSParagraphStyle)?.mutableCopy()
+                as? NSMutableParagraphStyle {
+                paragraphStyle.paragraphSpacing = 0
+                hardBreakAttrs[.paragraphStyle] = paragraphStyle
+            }
+            return NSAttributedString(string: "\n", attributes: hardBreakAttrs)
+        default:
+            return NSAttributedString(
+                string: LayoutConstants.objectReplacementCharacter,
+                attributes: styledAttrs
+            )
+        }
+    }
+
+    /// Create an attributed string for a void block element (e.g. horizontalRule).
+    ///
+    /// Horizontal rules are rendered as U+FFFC (object replacement character)
+    /// with an NSTextAttachment that draws a separator line.
+    static func attributedStringForVoidBlock(
+        nodeType: String,
+        docPos: UInt32,
+        elementAttrs: [String: Any],
+        baseFont: UIFont,
+        textColor: UIColor,
+        topLevelChildIndex: Int?,
+        theme: EditorTheme?,
+        atomKey: String,
+        atomConfiguration: AtomRenderConfiguration?
+    ) -> NSAttributedString {
+        var attrs = defaultAttributes(baseFont: baseFont, textColor: textColor)
+        attrs[RenderBridgeAttributes.voidNodeType] = nodeType
+        attrs[RenderBridgeAttributes.docPos] = docPos
+        if let topLevelChildIndex {
+            attrs[RenderBridgeAttributes.topLevelChildIndex] = NSNumber(value: topLevelChildIndex)
+        }
+
+        if atomConfiguration?.registeredNodeTypes.contains(nodeType) == true {
+            let attachment = AtomBlockAttachment(
+                atomKey: atomKey,
+                nodeType: nodeType,
+                docPos: docPos,
+                reservedHeight: atomConfiguration?.reservedHeight(
+                    atomKey: atomKey,
+                    nodeType: nodeType
+                ) ?? 0
+            )
+            let attrStr = NSMutableAttributedString(attachment: attachment)
+            attrStr.addAttributes(attrs, range: NSRange(location: 0, length: attrStr.length))
+            return attrStr
+        }
+
+        switch nodeType {
+        case "horizontalRule", "horizontal_rule":
+            let attachment = HorizontalRuleAttachment()
+            attachment.styleBox = theme?.styleSheet?.box("horizontalRule")
+            attachment.lineColor = theme?.horizontalRule?.color ?? textColor.withAlphaComponent(0.3)
+            attachment.lineHeight = theme?.horizontalRule?.thickness ?? LayoutConstants.horizontalRuleHeight
+            attachment.verticalPadding = resolvedHorizontalRuleVerticalMargin(theme: theme)
+            let attrStr = NSMutableAttributedString(
+                attachment: attachment
+            )
+            let range = NSRange(location: 0, length: attrStr.length)
+            attrStr.addAttributes(attrs, range: range)
+            return attrStr
+        case "image":
+            guard let source = (elementAttrs["src"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !source.isEmpty
+            else {
+                return NSAttributedString(
+                    string: LayoutConstants.objectReplacementCharacter,
+                    attributes: attrs
+                )
+            }
+            let attachment = BlockImageAttachment(
+                source: source,
+                placeholderTint: textColor,
+                preferredWidth: jsonCGFloat(elementAttrs["width"]),
+                preferredHeight: jsonCGFloat(elementAttrs["height"])
+            )
+            attachment.styleBox = theme?.styleSheet?.box("image")
+            let attrStr = NSMutableAttributedString(attachment: attachment)
+            let range = NSRange(location: 0, length: attrStr.length)
+            attrStr.addAttributes(attrs, range: range)
+            return attrStr
+        default:
+            return NSAttributedString(
+                string: LayoutConstants.objectReplacementCharacter,
+                attributes: attrs
+            )
+        }
+    }
+
+    /// Create an attributed string for an opaque inline atom (unknown inline void).
+    static func attributedStringForOpaqueInlineAtom(
+        nodeType: String,
+        label: String,
+        docPos: UInt32,
+        baseFont: UIFont,
+        textColor: UIColor,
+        blockStack: [BlockContext],
+        topLevelChildIndex _: Int?,
+        theme: EditorTheme?,
+        mentionTheme: EditorMentionTheme?
+    ) -> NSAttributedString {
+        let blockFont = resolvedFont(for: blockStack, baseFont: baseFont, theme: theme)
+        let blockColor = resolvedTextColor(for: blockStack, textColor: textColor, theme: theme)
+        var attrs = defaultAttributes(baseFont: blockFont, textColor: blockColor)
+        attrs[RenderBridgeAttributes.voidNodeType] = nodeType
+        attrs[RenderBridgeAttributes.docPos] = docPos
+        if nodeType == "mention" {
+            let resolvedMentionTheme = theme?.mentions?.merged(with: mentionTheme) ?? mentionTheme
+            let node = resolvedMentionTheme?.node
+            attrs[.foregroundColor] = node?.textColor ?? blockColor
+            attrs[.backgroundColor] =
+                node?.backgroundColor ?? UIColor.systemBlue.withAlphaComponent(0.12)
+            if let mentionFont = mentionFont(from: blockFont, theme: node) {
+                attrs[.font] = mentionFont
+            }
+            if let values = node?.style, !values.isEmpty {
+                EditorStyleSheet.applyText(values, to: &attrs)
+                var boxValues = values
+                boxValues["backgroundColor"] = values["backgroundColor"] ?? "#007aff1f"
+                attrs.removeValue(forKey: .backgroundColor)
+                let chip = EditorMentionRenderedBox(box: EditorStyleBox(boxValues), label: NSAttributedString(string: label, attributes: attrs))
+                attrs[editorMentionBoxAttribute] = chip
+                attrs[editorInlineLineHeightAttribute] = chip.size.height
+            }
+        } else {
+            attrs[.backgroundColor] = UIColor.systemGray5
+        }
+        let styledAttrs = applyBlockStyle(
+            to: attrs,
+            blockStack: blockStack,
+            theme: theme,
+            blockBaseFont: blockFont
+        )
+
+        let visibleText = nodeType == "mention" ? label : "[\(label)]"
+        return NSAttributedString(string: visibleText, attributes: styledAttrs)
+    }
+
+    /// Create an attributed string for an opaque block atom (unknown block void).
+    static func attributedStringForOpaqueBlockAtom(
+        nodeType: String,
+        label: String,
+        docPos: UInt32,
+        baseFont: UIFont,
+        textColor: UIColor,
+        topLevelChildIndex: Int?,
+        theme: EditorTheme?
+    ) -> NSAttributedString {
+        var attrs = defaultAttributes(baseFont: baseFont, textColor: textColor)
+        attrs[RenderBridgeAttributes.voidNodeType] = nodeType
+        attrs[RenderBridgeAttributes.docPos] = docPos
+        attrs[.backgroundColor] = UIColor.systemGray5
+        if let topLevelChildIndex {
+            attrs[RenderBridgeAttributes.topLevelChildIndex] = NSNumber(value: topLevelChildIndex)
+        }
+
+        return NSAttributedString(string: "[\(label)]", attributes: attrs)
+    }
+
+    private static func mentionFont(from baseFont: UIFont, theme: EditorMentionNodeTheme?)
+        -> UIFont? {
+        guard let fontWeight = theme?.fontWeight else { return nil }
+        return EditorTextStyle(fontWeight: fontWeight).resolvedFont(fallback: baseFont)
+    }
+
+}

package/ios/RenderBridge+Attachments.swift

@@ -0,0 +1,246 @@
+import CryptoKit
+import ImageIO
+import UIKit
+
+struct BlockContext {
+    let nodeType: String
+    let depth: UInt8
+    var listContext: [String: Any]?
+    var topLevelChildIndex: Int?
+    var listMarkerContext: [String: Any]?
+    var markerPending: Bool = false
+    var styleStart: Int = 0
+    var language: String?
+}
+
+// MARK: - HorizontalRuleAttachment
+
+/// NSTextAttachment subclass that draws a horizontal separator line.
+///
+/// The attachment renders as a thin line across the available width with
+/// vertical padding. Used for `horizontalRule` void block elements.
+final class HorizontalRuleAttachment: NSTextAttachment {
+
+    var styleBox: EditorStyleBox?
+    var lineColor: UIColor = .separator
+    var lineHeight: CGFloat = LayoutConstants.horizontalRuleHeight
+    var verticalPadding: CGFloat = LayoutConstants.horizontalRuleVerticalPadding
+
+    override func attachmentBounds(
+        for textContainer: NSTextContainer?,
+        proposedLineFragment lineFrag: CGRect,
+        glyphPosition position: CGPoint,
+        characterIndex charIndex: Int
+    ) -> CGRect {
+        let totalHeight = lineHeight + (verticalPadding * 2) + (styleBox?.inset.top ?? 0) + (styleBox?.inset.bottom ?? 0)
+        return CGRect(
+            x: 0,
+            y: 0,
+            width: lineFrag.width,
+            height: totalHeight
+        )
+    }
+
+    override func image(
+        forBounds imageBounds: CGRect,
+        textContainer: NSTextContainer?,
+        characterIndex charIndex: Int
+    ) -> UIImage? {
+        let renderer = UIGraphicsImageRenderer(bounds: imageBounds)
+        return renderer.image { context in
+            if let styleBox { styleBox.draw(in: imageBounds, context: context.cgContext); return }
+            lineColor.setFill()
+            let lineY = imageBounds.midY - (lineHeight / 2)
+            let lineRect = CGRect(
+                x: imageBounds.origin.x,
+                y: lineY,
+                width: imageBounds.width,
+                height: lineHeight
+            )
+            context.fill(lineRect)
+        }
+    }
+}
+
+final class AtomBlockAttachment: NSTextAttachment {
+    let atomKey: String
+    let nodeType: String
+    let docPos: UInt32
+    var reservedHeight: CGFloat
+
+    init(atomKey: String, nodeType: String, docPos: UInt32, reservedHeight: CGFloat) {
+        self.atomKey = atomKey
+        self.nodeType = nodeType
+        self.docPos = docPos
+        self.reservedHeight = reservedHeight
+        super.init(data: nil, ofType: nil)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func attachmentBounds(
+        for textContainer: NSTextContainer?,
+        proposedLineFragment lineFrag: CGRect,
+        glyphPosition position: CGPoint,
+        characterIndex charIndex: Int
+    ) -> CGRect {
+        CGRect(x: 0, y: 0, width: lineFrag.width, height: reservedHeight)
+    }
+
+    override func image(
+        forBounds imageBounds: CGRect,
+        textContainer: NSTextContainer?,
+        characterIndex charIndex: Int
+    ) -> UIImage? {
+        nil
+    }
+}
+
+final class BlockImageAttachment: NSTextAttachment {
+    var styleBox: EditorStyleBox?
+    let source: String
+    let placeholderTint: UIColor
+    private weak var loadOwner: RenderImageLoadOwner?
+    private var loadReceipt: RenderImageLoadOwner.ImageLoadReceipt?
+    var preferredWidth: CGFloat?
+    var preferredHeight: CGFloat?
+    private var loadedImage: UIImage?
+
+    init(
+        source: String,
+        placeholderTint: UIColor,
+        preferredWidth: CGFloat?,
+        preferredHeight: CGFloat?
+    ) {
+        self.source = source
+        self.placeholderTint = placeholderTint
+        self.preferredWidth = preferredWidth
+        self.preferredHeight = preferredHeight
+        self.loadOwner = RenderImageLoadOwner.current
+        super.init(data: nil, ofType: nil)
+        loadImageIfNeeded()
+    }
+
+    required init?(coder: NSCoder) {
+        return nil
+    }
+
+    deinit {
+        loadReceipt?.cancel()
+    }
+
+    func setPreferredSize(width: CGFloat, height: CGFloat) {
+        preferredWidth = width
+        preferredHeight = height
+    }
+
+    func previewImage() -> UIImage? {
+        loadedImage ?? image
+    }
+
+    override func attachmentBounds(
+        for textContainer: NSTextContainer?,
+        proposedLineFragment lineFrag: CGRect,
+        glyphPosition position: CGPoint,
+        characterIndex charIndex: Int
+    ) -> CGRect {
+        let lineFragmentWidth = lineFrag.width.isFinite ? lineFrag.width : 0
+        let containerWidth = textContainer.map {
+            max(0, $0.size.width - ($0.lineFragmentPadding * 2))
+        } ?? 0
+        let widthCandidates = [lineFragmentWidth, containerWidth].filter { $0.isFinite && $0 > 0 }
+        let inset = styleBox?.inset ?? .zero
+        let maxWidth = styleBox == nil ? max(160, widthCandidates.min() ?? 160) : max(1, (widthCandidates.min() ?? 160) - inset.left - inset.right)
+        let fallbackAspectRatio = loadedImage.flatMap { image -> CGFloat? in
+            let imageSize = image.size
+            guard imageSize.width > 0, imageSize.height > 0 else { return nil }
+            return imageSize.height / imageSize.width
+        } ?? 0.56
+
+        var resolvedWidth = preferredWidth
+        var resolvedHeight = preferredHeight
+
+        if resolvedWidth == nil, resolvedHeight == nil, let loadedImage {
+            let imageSize = loadedImage.size
+            if imageSize.width > 0, imageSize.height > 0 {
+                resolvedWidth = imageSize.width
+                resolvedHeight = imageSize.height
+            }
+        } else if resolvedWidth == nil, let resolvedHeight {
+            resolvedWidth = resolvedHeight / fallbackAspectRatio
+        } else if resolvedHeight == nil, let resolvedWidth {
+            resolvedHeight = resolvedWidth * fallbackAspectRatio
+        }
+
+        let width = max(1, resolvedWidth ?? maxWidth)
+        let height = max(1, resolvedHeight ?? min(180, maxWidth * fallbackAspectRatio))
+        let scale = min(1, maxWidth / width)
+        return CGRect(x: 0, y: 0, width: width * scale + inset.left + inset.right, height: height * scale + inset.top + inset.bottom)
+    }
+
+    override func image(
+        forBounds imageBounds: CGRect,
+        textContainer: NSTextContainer?,
+        characterIndex charIndex: Int
+    ) -> UIImage? {
+        if let styleBox {
+            return UIGraphicsImageRenderer(bounds: imageBounds).image { renderer in
+                styleBox.draw(in: imageBounds, context: renderer.cgContext)
+                renderer.cgContext.addPath(styleBox.path(in: imageBounds, inner: true).cgPath)
+                renderer.cgContext.clip()
+                renderer.cgContext.clip(to: imageBounds.inset(by: styleBox.inset))
+                if let loadedImage {
+                    loadedImage.draw(in: styleBox.imageRect(loadedImage.size, in: imageBounds))
+                } else {
+                    let iconBounds = imageBounds.insetBy(dx: imageBounds.width * 0.35, dy: imageBounds.height * 0.35)
+                    UIImage(systemName: "photo")?.withTintColor(placeholderTint, renderingMode: .alwaysOriginal).draw(in: iconBounds)
+                }
+            }
+        }
+        if let loadedImage { return loadedImage }
+
+        let renderer = UIGraphicsImageRenderer(bounds: imageBounds)
+        return renderer.image { _ in
+            let path = UIBezierPath(roundedRect: imageBounds, cornerRadius: 12)
+            UIColor.secondarySystemFill.setFill()
+            path.fill()
+
+            let iconSize = min(imageBounds.width, imageBounds.height) * 0.28
+            let iconOrigin = CGPoint(
+                x: imageBounds.midX - (iconSize / 2),
+                y: imageBounds.midY - (iconSize / 2)
+            )
+            let iconRect = CGRect(origin: iconOrigin, size: CGSize(width: iconSize, height: iconSize))
+
+            if #available(iOS 13.0, *) {
+                let config = UIImage.SymbolConfiguration(pointSize: iconSize, weight: .medium)
+                let icon = UIImage(systemName: "photo", withConfiguration: config)?
+                    .withTintColor(placeholderTint.withAlphaComponent(0.7), renderingMode: .alwaysOriginal)
+                icon?.draw(in: iconRect)
+            }
+        }
+    }
+
+    private func loadImageIfNeeded() {
+        guard let loadOwner else { return }
+        let cacheKey = RenderImageCache.key(source: source, policy: loadOwner.policy)
+        if let cached = RenderImageCache.cache.image(forKey: cacheKey) {
+            loadedImage = cached
+            image = cached
+            return
+        }
+        loadReceipt = loadOwner.startImageLoad(source: source) { [weak self] image in
+            guard let self,
+                  let image
+            else {
+                return
+            }
+            self.loadedImage = image
+            self.image = image
+            self.loadReceipt = nil
+            NotificationCenter.default.post(name: .editorImageAttachmentDidLoad, object: self)
+        }
+    }
+}