@openeditor/react-native-prose-editor 0.0.7 → 0.0.8

package/ios/NativeEditorExpoView.swift

@@ -1,4 +1,4 @@
-import ExpoModulesCore
+public import ExpoModulesCore
 import UIKit
 
 private final class WeakNativeEditorExpoView {
@@ -2468,7 +2468,7 @@ class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognize
         pendingEditableRetryValue = nil
         pendingEditableRetryEditorId = nil
         pendingEditableRetryScheduled = false
-        richTextView.textView.isEditable = editable
+        richTextView.setEditable(editable)
         updateAccessoryToolbarVisibility()
     }
 
@@ -3157,7 +3157,7 @@ class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognize
         ]
 
         for offset in candidateOffsets where offset >= 0 && offset < textStorage.length {
-            if let nodeType = textStorage.attribute(RenderBridgeAttributes.voidNodeType, at: offset, effectiveRange: nil) as? String,
+            if let nodeType = textStorage.attribute(InputCoordinatorAttributes.voidNodeType, at: offset, effectiveRange: nil) as? String,
                nodeType == "mention" {
                 return true
             }

package/ios/NativeEditorModule.swift

@@ -1,4 +1,4 @@
-import ExpoModulesCore
+public import ExpoModulesCore
 
 private func nativeUInt64(_ value: Int) -> UInt64? {
     guard value >= 0 else { return nil }
@@ -224,6 +224,15 @@ public class NativeEditorModule: Module {
             }
             editorSetSelection(id: editorId, anchor: anchor, head: head)
         }
+        Function("editorSetCellSelection") { (id: Int, anchor: Int, head: Int) in
+            guard let editorId = nativeUInt64(id),
+                  let anchor = nativeUInt32(anchor),
+                  let head = nativeUInt32(head)
+            else {
+                return
+            }
+            editorSetCellSelection(id: editorId, anchor: anchor, head: head)
+        }
         Function("editorSetSelectionScalar") { (id: Int, scalarAnchor: Int, scalarHead: Int) in
             guard let editorId = nativeUInt64(id),
                   let scalarAnchor = nativeUInt32(scalarAnchor),
@@ -443,28 +452,6 @@ public class NativeEditorModule: Module {
             guard let editorId = nativeUInt64(id) else { return false }
             return editorCanRedo(id: editorId)
         }
-        Function("renderDocumentJson") { (configJson: String, json: String) -> String in
-            let editorId = editorCreate(configJson: configJson)
-            defer {
-                editorDestroy(id: editorId)
-            }
-            return editorSetJson(id: editorId, json: json)
-        }
-        Function("measureContentHeight") { (renderJson: String, themeJson: String?, width: Double) -> Double in
-            let height = RenderBridge.measureHeight(
-                forRenderJSON: renderJson,
-                themeJSON: themeJson,
-                width: CGFloat(width)
-            )
-            return Double(height)
-        }
-        Function("renderDocumentHtml") { (configJson: String, html: String) -> String in
-            let editorId = editorCreate(configJson: configJson)
-            defer {
-                editorDestroy(id: editorId)
-            }
-            return editorSetHtml(id: editorId, html: html)
-        }
         Function("editorReplaceHtml") { (id: Int, html: String) -> String in
             guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
             return editorReplaceHtml(id: editorId, html: html)
@@ -509,6 +496,26 @@ public class NativeEditorModule: Module {
             guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
             return editorOutdentListItem(id: editorId)
         }
+        Function("editorInsertTableRow") { (id: Int, after: Bool) -> String in
+            guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
+            return editorInsertTableRow(id: editorId, after: after)
+        }
+        Function("editorDeleteTableRow") { (id: Int) -> String in
+            guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
+            return editorDeleteTableRow(id: editorId)
+        }
+        Function("editorInsertTableColumn") { (id: Int, after: Bool) -> String in
+            guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
+            return editorInsertTableColumn(id: editorId, after: after)
+        }
+        Function("editorDeleteTableColumn") { (id: Int) -> String in
+            guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
+            return editorDeleteTableColumn(id: editorId)
+        }
+        Function("editorMoveTableCell") { (id: Int, forward: Bool) -> String in
+            guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
+            return editorMoveTableCell(id: editorId, forward: forward)
+        }
         Function("editorInsertNode") { (id: Int, nodeType: String) -> String in
             guard let editorId = nativeUInt64(id) else { return nativeArgumentError("editor id") }
             return editorInsertNode(id: editorId, nodeType: nodeType)
@@ -598,27 +605,5 @@ public class NativeEditorModule: Module {
                 view.getCaretRectJson()
             }
         }
-
-        View(NativeProseViewerExpoView.self) {
-            ViewName("NativeProseViewer")
-            Events("onContentHeightChange", "onPressLink", "onPressMention")
-
-            Prop("renderJson") { (view: NativeProseViewerExpoView, renderJson: String?) in
-                view.setRenderJson(renderJson)
-            }
-            Prop("themeJson") { (view: NativeProseViewerExpoView, themeJson: String?) in
-                view.setThemeJson(themeJson)
-            }
-            Prop("collapsesWhenEmpty") {
-                (view: NativeProseViewerExpoView, collapsesWhenEmpty: Bool?) in
-                view.setCollapsesWhenEmpty(collapsesWhenEmpty)
-            }
-            Prop("enableLinkTaps") { (view: NativeProseViewerExpoView, enableLinkTaps: Bool?) in
-                view.setEnableLinkTaps(enableLinkTaps)
-            }
-            Prop("interceptLinkTaps") { (view: NativeProseViewerExpoView, interceptLinkTaps: Bool?) in
-                view.setInterceptLinkTaps(interceptLinkTaps)
-            }
-        }
     }
 }

package/ios/NativeInputSupport.swift

@@ -0,0 +1,396 @@
+import UIKit
+
+extension Notification.Name {
+    static let editorImageAttachmentDidLoad = Notification.Name(
+        "com.openeditor.editor.imageAttachmentDidLoad"
+    )
+}
+
+enum NativeImageLoader {
+    static let cache = NSCache<NSString, UIImage>()
+    static let stateQueue = DispatchQueue(label: "com.openeditor.editor.image-loader-state")
+    static let session: URLSession = {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.timeoutIntervalForRequest = 10
+        configuration.timeoutIntervalForResource = 15
+        configuration.requestCachePolicy = .returnCacheDataElseLoad
+        return URLSession(configuration: configuration)
+    }()
+    private static var inFlight: [String: [(UIImage?) -> Void]] = [:]
+
+    static func load(source: String, completion: @escaping (UIImage?) -> Void) {
+        if let cached = cache.object(forKey: source as NSString) {
+            completion(cached)
+            return
+        }
+        if let inlineData = decodeDataURL(source), let image = UIImage(data: inlineData) {
+            cache.setObject(image, forKey: source as NSString)
+            completion(image)
+            return
+        }
+        guard let url = URL(string: source) else {
+            completion(nil)
+            return
+        }
+        load(source: source, url: url, completion: completion)
+    }
+
+    private static func load(
+        source: String,
+        url: URL,
+        completion: @escaping (UIImage?) -> Void
+    ) {
+        if let cached = cache.object(forKey: source as NSString) {
+            completion(cached)
+            return
+        }
+
+        var shouldStartLoad = false
+        stateQueue.sync {
+            if inFlight[source] != nil {
+                inFlight[source]?.append(completion)
+            } else {
+                inFlight[source] = [completion]
+                shouldStartLoad = true
+            }
+        }
+        guard shouldStartLoad else { return }
+
+        let finish: (Data?) -> Void = { data in
+            let image = data.flatMap(UIImage.init(data:))
+            if let image {
+                cache.setObject(image, forKey: source as NSString)
+            }
+
+            let callbacks: [(UIImage?) -> Void] = stateQueue.sync {
+                let callbacks = inFlight.removeValue(forKey: source) ?? []
+                return callbacks
+            }
+            DispatchQueue.main.async {
+                callbacks.forEach { $0(image) }
+            }
+        }
+
+        if url.isFileURL {
+            DispatchQueue.global(qos: .userInitiated).async {
+                finish(try? Data(contentsOf: url))
+            }
+            return
+        }
+        guard url.scheme == "https" || url.scheme == "http" else {
+            finish(nil)
+            return
+        }
+        session.dataTask(with: url) { data, _, _ in
+            finish(data)
+        }.resume()
+    }
+
+    private static func decodeDataURL(_ source: String) -> Data? {
+        let trimmed = source.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.lowercased().hasPrefix("data:image/"),
+              let commaIndex = trimmed.firstIndex(of: ",")
+        else {
+            return nil
+        }
+        let metadata = String(trimmed[..<commaIndex]).lowercased()
+        let payload = String(trimmed[trimmed.index(after: commaIndex)...])
+        guard metadata.contains(";base64") else { return nil }
+        return Data(base64Encoded: payload, options: [.ignoreUnknownCharacters])
+    }
+}
+
+// MARK: - Constants
+
+/// Custom NSAttributedString attribute keys for editor metadata.
+enum InputCoordinatorAttributes {
+    /// Marks a character as a void element placeholder (hardBreak, horizontalRule).
+    /// The value is the node type string (e.g. "hardBreak", "horizontalRule").
+    static let voidNodeType = NSAttributedString.Key("com.openeditor.editor.voidNodeType")
+
+    /// Stores the Rust document position (UInt32) for void elements.
+    static let docPos = NSAttributedString.Key("com.openeditor.editor.docPos")
+
+    /// Marks a character as a block boundary (for block start/end tracking).
+    static let blockBoundary = NSAttributedString.Key("com.openeditor.editor.blockBoundary")
+
+    /// Stores the block node type (e.g. "paragraph", "listItem").
+    static let blockNodeType = NSAttributedString.Key("com.openeditor.editor.blockNodeType")
+
+    /// Stores the block depth (UInt8).
+    static let blockDepth = NSAttributedString.Key("com.openeditor.editor.blockDepth")
+
+    /// Stores list context info as a dictionary for list items.
+    static let listContext = NSAttributedString.Key("com.openeditor.editor.listContext")
+
+    /// Marks blocks that should render a visible list marker.
+    static let listMarkerContext = NSAttributedString.Key("com.openeditor.editor.listMarkerContext")
+
+    /// Stores the rendered list marker color for the paragraph marker.
+    static let listMarkerColor = NSAttributedString.Key("com.openeditor.editor.listMarkerColor")
+
+    /// Stores the rendered list marker scale for unordered bullets.
+    static let listMarkerScale = NSAttributedString.Key("com.openeditor.editor.listMarkerScale")
+
+    /// Stores the paragraph base font used to render the list marker.
+    static let listMarkerBaseFont = NSAttributedString.Key("com.openeditor.editor.listMarkerBaseFont")
+
+    /// Stores the reserved list marker gutter width.
+    static let listMarkerWidth = NSAttributedString.Key("com.openeditor.editor.listMarkerWidth")
+
+    /// Stores the rendered blockquote border color.
+    static let blockquoteBorderColor = NSAttributedString.Key("com.openeditor.editor.blockquoteBorderColor")
+
+    /// Stores the rendered blockquote border width.
+    static let blockquoteBorderWidth = NSAttributedString.Key("com.openeditor.editor.blockquoteBorderWidth")
+
+    /// Stores the rendered blockquote gap between border and text.
+    static let blockquoteMarkerGap = NSAttributedString.Key("com.openeditor.editor.blockquoteMarkerGap")
+
+    /// Marks code-block paragraphs for custom background drawing.
+    static let codeBlockBackgroundColor = NSAttributedString.Key("com.openeditor.editor.codeBlockBackgroundColor")
+    static let codeBlockBorderRadius = NSAttributedString.Key("com.openeditor.editor.codeBlockBorderRadius")
+    static let codeBlockPaddingHorizontal = NSAttributedString.Key("com.openeditor.editor.codeBlockPaddingHorizontal")
+    static let codeBlockPaddingVertical = NSAttributedString.Key("com.openeditor.editor.codeBlockPaddingVertical")
+
+    /// Marks synthetic zero-width placeholders used only for UIKit layout.
+    static let syntheticPlaceholder = NSAttributedString.Key("com.openeditor.editor.syntheticPlaceholder")
+
+    /// Stores the link href for visually styled link text without enabling UITextView's default link interaction.
+    static let linkHref = NSAttributedString.Key("com.openeditor.editor.linkHref")
+
+    /// Stores the owning top-level document child index for partial native patching.
+    static let topLevelChildIndex = NSAttributedString.Key("com.openeditor.editor.topLevelChildIndex")
+}
+
+/// Layout constants for paragraph styles.
+enum LayoutConstants {
+    /// Spacing between paragraphs (points).
+    static let paragraphSpacing: CGFloat = 8.0
+
+    /// Base indentation per depth level (points).
+    static let indentPerDepth: CGFloat = 24.0
+
+    /// Width reserved for the list bullet/number (points).
+    static let listMarkerWidth: CGFloat = 36.0
+
+    /// Gap between the list marker and the text that follows (points).
+    static let listMarkerTextGap: CGFloat = 8.0
+
+    /// Height of the horizontal rule separator line (points).
+    static let horizontalRuleHeight: CGFloat = 1.0
+
+    /// Vertical padding above and below the horizontal rule (points).
+    static let horizontalRuleVerticalPadding: CGFloat = 8.0
+
+    /// Total leading inset reserved for each blockquote depth.
+    static let blockquoteIndent: CGFloat = 18.0
+
+    /// Width of the rendered blockquote border bar.
+    static let blockquoteBorderWidth: CGFloat = 3.0
+
+    /// Gap between the blockquote border bar and the text that follows.
+    static let blockquoteMarkerGap: CGFloat = 8.0
+
+    /// Bullet character for unordered list items.
+    static let unorderedListBullet = "\u{2022} "
+
+    /// Scale factor applied only to unordered list marker glyphs.
+    static let unorderedListMarkerFontScale: CGFloat = 2.0
+
+    /// Object replacement character used for void block elements.
+    static let objectReplacementCharacter = "\u{FFFC}"
+}
+
+enum NativeListMarker {
+    static func text(for context: [String: Any]) -> String {
+        if context["task"] as? Bool == true {
+            return (context["checked"] as? Bool == true) ? "☑︎ " : "☐ "
+        }
+        if context["ordered"] as? Bool == true {
+            let index = context["index"] as? Int ?? 1
+            return "\(index). "
+        }
+        return LayoutConstants.unorderedListBullet
+    }
+}
+
+
+// MARK: - BlockContext
+
+/// Transient context while rendering block elements. Pushed onto a stack
+/// when a `blockStart` element is encountered and popped on `blockEnd`.
+struct BlockContext {
+    let nodeType: String
+    let depth: UInt8
+    var listContext: [String: Any]?
+    var topLevelChildIndex: Int? = nil
+    var listMarkerContext: [String: Any]? = nil
+    var markerPending: Bool = false
+}
+
+// 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 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)
+        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
+            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 BlockImageAttachment: NSTextAttachment {
+    private let source: String
+    private let placeholderTint: UIColor
+    private var preferredWidth: CGFloat?
+    private 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
+        super.init(data: nil, ofType: nil)
+        loadImageIfNeeded()
+    }
+
+    required init?(coder: NSCoder) {
+        return nil
+    }
+
+    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 maxWidth = max(160, widthCandidates.min() ?? 160)
+        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, height: height * scale)
+    }
+
+    override func image(
+        forBounds imageBounds: CGRect,
+        textContainer: NSTextContainer?,
+        characterIndex charIndex: Int
+    ) -> UIImage? {
+        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() {
+        NativeImageLoader.load(source: source) { [weak self] image in
+            guard let self,
+                  let image
+            else {
+                return
+            }
+            self.loadedImage = image
+            self.image = image
+            NotificationCenter.default.post(name: .editorImageAttachmentDidLoad, object: self)
+        }
+    }
+
+}

package/ios/PositionBridge.swift

@@ -495,11 +495,11 @@ final class PositionBridge {
         ) { attrs, range, _ in
             guard range.length > 0 else { return }
 
-            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true {
+            if attrs[InputCoordinatorAttributes.syntheticPlaceholder] as? Bool == true {
                 placeholders.append(range.location)
             }
 
-            guard let listContext = attrs[RenderBridgeAttributes.listMarkerContext] as? [String: Any] else {
+            guard let listContext = attrs[InputCoordinatorAttributes.listMarkerContext] as? [String: Any] else {
                 return
             }
 
@@ -515,7 +515,7 @@ final class PositionBridge {
             guard seenStarts.insert(paragraphStart).inserted else { return }
 
             let markerLength = UInt32(
-                RenderBridge.listMarkerString(listContext: listContext).unicodeScalars.count
+                NativeListMarker.text(for: listContext).unicodeScalars.count
             )
             markers.append(
                 VirtualListMarker(
@@ -549,7 +549,7 @@ final class PositionBridge {
     ) -> Bool {
         guard paragraphStart > 0, paragraphStart <= attributedString.length else { return false }
         let previousVoidType = attributedString.attribute(
-            RenderBridgeAttributes.voidNodeType,
+            InputCoordinatorAttributes.voidNodeType,
             at: paragraphStart - 1,
             effectiveRange: nil
         ) as? String