@apollohg/react-native-prose-editor 0.1.0

package/ios/NativeEditorModule.swift

@@ -0,0 +1,263 @@
+import ExpoModulesCore
+
+public class NativeEditorModule: Module {
+    public func definition() -> ModuleDefinition {
+        Name("NativeEditor")
+
+        Function("editorCreate") { (configJson: String) -> Int in
+            Int(editorCreate(configJson: configJson))
+        }
+        Function("editorDestroy") { (id: Int) in
+            editorDestroy(id: UInt64(id))
+        }
+        Function("editorSetHtml") { (id: Int, html: String) -> String in
+            editorSetHtml(id: UInt64(id), html: html)
+        }
+        Function("editorGetHtml") { (id: Int) -> String in
+            editorGetHtml(id: UInt64(id))
+        }
+        Function("editorSetJson") { (id: Int, json: String) -> String in
+            editorSetJson(id: UInt64(id), json: json)
+        }
+        Function("editorGetJson") { (id: Int) -> String in
+            editorGetJson(id: UInt64(id))
+        }
+        Function("editorInsertText") { (id: Int, pos: Int, text: String) -> String in
+            editorInsertText(id: UInt64(id), pos: UInt32(pos), text: text)
+        }
+        Function("editorInsertTextScalar") { (id: Int, scalarPos: Int, text: String) -> String in
+            editorInsertTextScalar(id: UInt64(id), scalarPos: UInt32(scalarPos), text: text)
+        }
+        Function("editorReplaceSelectionText") { (id: Int, text: String) -> String in
+            editorReplaceSelectionText(id: UInt64(id), text: text)
+        }
+        Function("editorDeleteRange") { (id: Int, from: Int, to: Int) -> String in
+            editorDeleteRange(id: UInt64(id), from: UInt32(from), to: UInt32(to))
+        }
+        Function("editorDeleteScalarRange") { (id: Int, scalarFrom: Int, scalarTo: Int) -> String in
+            editorDeleteScalarRange(
+                id: UInt64(id),
+                scalarFrom: UInt32(scalarFrom),
+                scalarTo: UInt32(scalarTo)
+            )
+        }
+        Function(
+            "editorReplaceTextScalar"
+        ) { (id: Int, scalarFrom: Int, scalarTo: Int, text: String) -> String in
+            editorReplaceTextScalar(
+                id: UInt64(id),
+                scalarFrom: UInt32(scalarFrom),
+                scalarTo: UInt32(scalarTo),
+                text: text
+            )
+        }
+        Function("editorSplitBlock") { (id: Int, pos: Int) -> String in
+            editorSplitBlock(id: UInt64(id), pos: UInt32(pos))
+        }
+        Function("editorSplitBlockScalar") { (id: Int, scalarPos: Int) -> String in
+            editorSplitBlockScalar(id: UInt64(id), scalarPos: UInt32(scalarPos))
+        }
+        Function("editorDeleteAndSplitScalar") { (id: Int, scalarFrom: Int, scalarTo: Int) -> String in
+            editorDeleteAndSplitScalar(
+                id: UInt64(id),
+                scalarFrom: UInt32(scalarFrom),
+                scalarTo: UInt32(scalarTo)
+            )
+        }
+        Function("editorInsertContentHtml") { (id: Int, html: String) -> String in
+            editorInsertContentHtml(id: UInt64(id), html: html)
+        }
+        Function("editorToggleMark") { (id: Int, markName: String) -> String in
+            editorToggleMark(id: UInt64(id), markName: markName)
+        }
+        Function("editorSetSelection") { (id: Int, anchor: Int, head: Int) in
+            editorSetSelection(id: UInt64(id), anchor: UInt32(anchor), head: UInt32(head))
+        }
+        Function("editorSetSelectionScalar") { (id: Int, scalarAnchor: Int, scalarHead: Int) in
+            editorSetSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead)
+            )
+        }
+        Function(
+            "editorToggleMarkAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int, markName: String) -> String in
+            editorToggleMarkAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead),
+                markName: markName
+            )
+        }
+        Function(
+            "editorWrapInListAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int, listType: String) -> String in
+            editorWrapInListAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead),
+                listType: listType
+            )
+        }
+        Function(
+            "editorUnwrapFromListAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int) -> String in
+            editorUnwrapFromListAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead)
+            )
+        }
+        Function(
+            "editorIndentListItemAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int) -> String in
+            editorIndentListItemAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead)
+            )
+        }
+        Function(
+            "editorOutdentListItemAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int) -> String in
+            editorOutdentListItemAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead)
+            )
+        }
+        Function(
+            "editorInsertNodeAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int, nodeType: String) -> String in
+            editorInsertNodeAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead),
+                nodeType: nodeType
+            )
+        }
+        Function("editorGetSelection") { (id: Int) -> String in
+            editorGetSelection(id: UInt64(id))
+        }
+        Function("editorDocToScalar") { (id: Int, docPos: Int) -> Int in
+            Int(editorDocToScalar(id: UInt64(id), docPos: UInt32(docPos)))
+        }
+        Function("editorScalarToDoc") { (id: Int, scalar: Int) -> Int in
+            Int(editorScalarToDoc(id: UInt64(id), scalar: UInt32(scalar)))
+        }
+        Function("editorGetCurrentState") { (id: Int) -> String in
+            editorGetCurrentState(id: UInt64(id))
+        }
+        Function("editorUndo") { (id: Int) -> String in
+            editorUndo(id: UInt64(id))
+        }
+        Function("editorRedo") { (id: Int) -> String in
+            editorRedo(id: UInt64(id))
+        }
+        Function("editorCanUndo") { (id: Int) -> Bool in
+            editorCanUndo(id: UInt64(id))
+        }
+        Function("editorCanRedo") { (id: Int) -> Bool in
+            editorCanRedo(id: UInt64(id))
+        }
+        Function("editorReplaceHtml") { (id: Int, html: String) -> String in
+            editorReplaceHtml(id: UInt64(id), html: html)
+        }
+        Function("editorReplaceJson") { (id: Int, json: String) -> String in
+            editorReplaceJson(id: UInt64(id), json: json)
+        }
+        Function("editorInsertContentJson") { (id: Int, json: String) -> String in
+            editorInsertContentJson(id: UInt64(id), json: json)
+        }
+        Function(
+            "editorInsertContentJsonAtSelectionScalar"
+        ) { (id: Int, scalarAnchor: Int, scalarHead: Int, json: String) -> String in
+            editorInsertContentJsonAtSelectionScalar(
+                id: UInt64(id),
+                scalarAnchor: UInt32(scalarAnchor),
+                scalarHead: UInt32(scalarHead),
+                json: json
+            )
+        }
+        Function("editorWrapInList") { (id: Int, listType: String) -> String in
+            editorWrapInList(id: UInt64(id), listType: listType)
+        }
+        Function("editorUnwrapFromList") { (id: Int) -> String in
+            editorUnwrapFromList(id: UInt64(id))
+        }
+        Function("editorIndentListItem") { (id: Int) -> String in
+            editorIndentListItem(id: UInt64(id))
+        }
+        Function("editorOutdentListItem") { (id: Int) -> String in
+            editorOutdentListItem(id: UInt64(id))
+        }
+        Function("editorInsertNode") { (id: Int, nodeType: String) -> String in
+            editorInsertNode(id: UInt64(id), nodeType: nodeType)
+        }
+
+        View(NativeEditorExpoView.self) {
+            Events(
+                "onEditorUpdate",
+                "onSelectionChange",
+                "onFocusChange",
+                "onContentHeightChange",
+                "onToolbarAction",
+                "onAddonEvent"
+            )
+
+            Prop("editorId") { (view: NativeEditorExpoView, id: Int) in
+                view.setEditorId(UInt64(id))
+            }
+            Prop("editable") { (view: NativeEditorExpoView, editable: Bool) in
+                view.setEditable(editable)
+            }
+            Prop("placeholder") { (view: NativeEditorExpoView, placeholder: String) in
+                view.richTextView.textView.placeholder = placeholder
+            }
+            Prop("autoFocus") { (view: NativeEditorExpoView, autoFocus: Bool) in
+                view.setAutoFocus(autoFocus)
+            }
+            Prop("showToolbar") { (view: NativeEditorExpoView, showToolbar: Bool) in
+                view.setShowToolbar(showToolbar)
+            }
+            Prop("toolbarPlacement") { (view: NativeEditorExpoView, toolbarPlacement: String?) in
+                view.setToolbarPlacement(toolbarPlacement)
+            }
+            Prop("heightBehavior") { (view: NativeEditorExpoView, heightBehavior: String) in
+                view.setHeightBehavior(heightBehavior)
+            }
+            Prop("themeJson") { (view: NativeEditorExpoView, themeJson: String?) in
+                view.setThemeJson(themeJson)
+            }
+            Prop("addonsJson") { (view: NativeEditorExpoView, addonsJson: String?) in
+                view.setAddonsJson(addonsJson)
+            }
+            Prop("toolbarItemsJson") { (view: NativeEditorExpoView, toolbarItemsJson: String?) in
+                view.setToolbarButtonsJson(toolbarItemsJson)
+            }
+            Prop("toolbarFrameJson") { (view: NativeEditorExpoView, toolbarFrameJson: String?) in
+                view.setToolbarFrameJson(toolbarFrameJson)
+            }
+            Prop("editorUpdateJson") { (view: NativeEditorExpoView, editorUpdateJson: String?) in
+                view.setPendingEditorUpdateJson(editorUpdateJson)
+            }
+            Prop("editorUpdateRevision") { (view: NativeEditorExpoView, editorUpdateRevision: Int) in
+                view.setPendingEditorUpdateRevision(editorUpdateRevision)
+            }
+            OnViewDidUpdateProps { (view: NativeEditorExpoView) in
+                view.applyPendingEditorUpdateIfNeeded()
+            }
+
+            AsyncFunction("applyEditorUpdate") { (view: NativeEditorExpoView, updateJson: String) in
+                view.applyEditorUpdate(updateJson)
+            }
+            AsyncFunction("focus") { (view: NativeEditorExpoView) in
+                view.focus()
+            }
+            AsyncFunction("blur") { (view: NativeEditorExpoView) in
+                view.blur()
+            }
+        }
+    }
+}

package/ios/PositionBridge.swift

@@ -0,0 +1,278 @@
+import UIKit
+
+// MARK: - PositionBridge
+
+/// Converts between UITextView cursor positions (UTF-16 code unit offsets, snapped
+/// to grapheme cluster boundaries) and Rust editor-core scalar offsets (Unicode
+/// scalar values = Unicode code points).
+///
+/// UIKit's text system uses UTF-16 internally (NSString). Emoji like U+1F468
+/// (man) occupy 2 UTF-16 code units (a surrogate pair) but 1 Unicode scalar.
+/// Composed emoji sequences like 👨‍👩‍👧‍👦 are multiple scalars joined by
+/// ZWJ but render as a single grapheme cluster.
+///
+/// Rust's editor-core counts positions in Unicode scalars (what Rust calls `char`).
+/// The PositionMap in Rust converts between doc positions and scalar offsets.
+/// This bridge converts between those scalar offsets and UITextView UTF-16 offsets.
+final class PositionBridge {
+
+    struct VirtualListMarker {
+        let paragraphStartUtf16: Int
+        let scalarLength: UInt32
+    }
+
+    // MARK: - UTF-16 <-> Scalar Conversion
+
+    /// Convert a UITextView cursor position (UTF-16 offset) to a Rust scalar offset.
+    ///
+    /// Walks the string from the beginning, counting Unicode scalars consumed as
+    /// we advance through UTF-16 code units. Surrogate pairs (code units > U+FFFF)
+    /// contribute 2 UTF-16 code units but only 1 scalar.
+    ///
+    /// - Parameters:
+    ///   - position: A `UITextPosition` obtained from the text view.
+    ///   - textView: The text view containing the text.
+    /// - Returns: The equivalent Unicode scalar offset.
+    static func textViewToScalar(_ position: UITextPosition, in textView: UITextView) -> UInt32 {
+        let utf16Offset = textView.offset(from: textView.beginningOfDocument, to: position)
+        return utf16OffsetToScalar(utf16Offset, in: textView)
+    }
+
+    /// Convert a Rust scalar offset to a UITextView position.
+    ///
+    /// Walks the string counting scalars until we reach the target, then returns
+    /// the corresponding UTF-16 offset as a UITextPosition.
+    ///
+    /// - Parameters:
+    ///   - scalar: The Unicode scalar offset from Rust.
+    ///   - textView: The text view containing the text.
+    /// - Returns: The equivalent `UITextPosition`, or the end of document if the
+    ///   scalar offset exceeds the text length.
+    static func scalarToTextView(_ scalar: UInt32, in textView: UITextView) -> UITextPosition {
+        let utf16Offset = scalarToUtf16Offset(scalar, in: textView)
+        return textView.position(
+            from: textView.beginningOfDocument,
+            offset: utf16Offset
+        ) ?? textView.endOfDocument
+    }
+
+    static func utf16OffsetToScalar(_ utf16Offset: Int, in textView: UITextView) -> UInt32 {
+        let text = textView.text ?? ""
+        let nsString = text as NSString
+        let clampedOffset = min(max(utf16Offset, 0), nsString.length)
+        var scalarOffset = utf16OffsetToScalar(clampedOffset, in: text)
+
+        for marker in virtualListMarkers(in: textView) where clampedOffset >= marker.paragraphStartUtf16 {
+            scalarOffset += marker.scalarLength
+        }
+
+        return scalarOffset
+    }
+
+    static func scalarToUtf16Offset(_ scalar: UInt32, in textView: UITextView) -> Int {
+        let text = textView.text ?? ""
+        let maxUtf16 = (text as NSString).length
+
+        if scalar == 0 || maxUtf16 == 0 {
+            return 0
+        }
+
+        var low = 0
+        var high = maxUtf16
+        while low < high {
+            let mid = (low + high) / 2
+            if utf16OffsetToScalar(mid, in: textView) < scalar {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+
+        return low
+    }
+
+    /// Convert a UTF-16 offset to a Unicode scalar offset within a string.
+    ///
+    /// This is the core conversion used by `textViewToScalar`. Exposed as a
+    /// static method for direct use and testing.
+    ///
+    /// - Parameters:
+    ///   - utf16Offset: The UTF-16 code unit offset.
+    ///   - text: The string to walk.
+    /// - Returns: The number of Unicode scalars from the start to the given UTF-16 offset.
+    static func utf16OffsetToScalar(_ utf16Offset: Int, in text: String) -> UInt32 {
+        guard utf16Offset > 0 else { return 0 }
+
+        let utf16View = text.utf16
+        let endIndex = min(utf16Offset, utf16View.count)
+        var scalarCount: UInt32 = 0
+        var utf16Pos = 0
+
+        for scalar in text.unicodeScalars {
+            if utf16Pos >= endIndex { break }
+            let scalarUtf16Len = scalar.utf16.count
+            utf16Pos += scalarUtf16Len
+            scalarCount += 1
+        }
+
+        return scalarCount
+    }
+
+    /// Convert a Unicode scalar offset to a UTF-16 offset within a string.
+    ///
+    /// This is the core conversion used by `scalarToTextView`. Exposed as a
+    /// static method for direct use and testing.
+    ///
+    /// - Parameters:
+    ///   - scalar: The Unicode scalar offset.
+    ///   - text: The string to walk.
+    /// - Returns: The number of UTF-16 code units from the start to the given scalar offset.
+    static func scalarToUtf16Offset(_ scalar: UInt32, in text: String) -> Int {
+        guard scalar > 0 else { return 0 }
+
+        var utf16Len = 0
+        var scalarsSeen: UInt32 = 0
+
+        for s in text.unicodeScalars {
+            if scalarsSeen >= scalar { break }
+            utf16Len += s.utf16.count
+            scalarsSeen += 1
+        }
+
+        return utf16Len
+    }
+
+    // MARK: - Grapheme Boundary Snapping
+
+    /// Snap a UTF-16 offset to the nearest grapheme cluster boundary.
+    ///
+    /// UITextView may report offsets in the middle of a grapheme cluster (e.g.
+    /// between the scalars of a flag emoji or a composed character sequence).
+    /// This method snaps the offset forward to the end of the current grapheme
+    /// cluster, since that is the position the user would perceive.
+    ///
+    /// - Parameters:
+    ///   - utf16Offset: A UTF-16 code unit offset that may be mid-grapheme.
+    ///   - text: The string to inspect.
+    /// - Returns: The nearest grapheme-aligned UTF-16 offset. If the input is
+    ///   already on a boundary, it is returned unchanged.
+    static func snapToGraphemeBoundary(_ utf16Offset: Int, in text: String) -> Int {
+        guard !text.isEmpty else { return 0 }
+
+        let nsString = text as NSString
+        let clampedOffset = min(max(utf16Offset, 0), nsString.length)
+
+        // If we're at the very start or end, already on a boundary.
+        if clampedOffset == 0 || clampedOffset == nsString.length {
+            return clampedOffset
+        }
+
+        // composedCharacterSequence(at:) returns the full grapheme cluster range
+        // containing the given UTF-16 index. We snap to the end of that range
+        // (forward bias) since that's what a user moving the cursor expects.
+        let range = nsString.rangeOfComposedCharacterSequence(at: clampedOffset)
+
+        // If the offset is already at the start of a grapheme cluster, it's on a boundary.
+        if range.location == clampedOffset {
+            return clampedOffset
+        }
+
+        // Otherwise, snap to the end of this cluster.
+        return NSMaxRange(range)
+    }
+
+    // MARK: - UITextRange <-> Scalar Range
+
+    /// Convert a UITextRange to a (from, to) pair of Rust scalar offsets.
+    ///
+    /// - Parameters:
+    ///   - range: A `UITextRange` from the text view.
+    ///   - textView: The text view containing the text.
+    /// - Returns: A tuple of (from, to) scalar offsets where from <= to.
+    static func textRangeToScalarRange(
+        _ range: UITextRange,
+        in textView: UITextView
+    ) -> (from: UInt32, to: UInt32) {
+        let from = textViewToScalar(range.start, in: textView)
+        let to = textViewToScalar(range.end, in: textView)
+        return (from: min(from, to), to: max(from, to))
+    }
+
+    /// Convert a pair of Rust scalar offsets to a UITextRange.
+    ///
+    /// - Parameters:
+    ///   - from: The start scalar offset.
+    ///   - to: The end scalar offset.
+    ///   - textView: The text view.
+    /// - Returns: The corresponding `UITextRange`, or nil if the positions are invalid.
+    static func scalarRangeToTextRange(
+        from: UInt32,
+        to: UInt32,
+        in textView: UITextView
+    ) -> UITextRange? {
+        let startPos = scalarToTextView(from, in: textView)
+        let endPos = scalarToTextView(to, in: textView)
+        return textView.textRange(from: startPos, to: endPos)
+    }
+
+    // MARK: - Cursor Scalar Offset (Convenience)
+
+    /// Get the current cursor position as a Rust scalar offset.
+    ///
+    /// If there is a range selection, returns the head (moving end) position.
+    ///
+    /// - Parameter textView: The text view.
+    /// - Returns: The scalar offset of the cursor, or 0 if no selection exists.
+    static func cursorScalarOffset(in textView: UITextView) -> UInt32 {
+        guard let selectedRange = textView.selectedTextRange else { return 0 }
+        return textViewToScalar(selectedRange.end, in: textView)
+    }
+
+    static func virtualListMarker(
+        atUtf16Offset utf16Offset: Int,
+        in textView: UITextView
+    ) -> VirtualListMarker? {
+        virtualListMarkers(in: textView).first { $0.paragraphStartUtf16 == utf16Offset }
+    }
+
+    private static func virtualListMarkers(in textView: UITextView) -> [VirtualListMarker] {
+        let textStorage = textView.textStorage
+        guard textStorage.length > 0 else { return [] }
+
+        let nsString = textStorage.string as NSString
+        var markers: [VirtualListMarker] = []
+        var seenStarts = Set<Int>()
+        let fullRange = NSRange(location: 0, length: textStorage.length)
+
+        textStorage.enumerateAttribute(
+            RenderBridgeAttributes.listMarkerContext,
+            in: fullRange,
+            options: []
+        ) { value, range, _ in
+            guard range.length > 0, let listContext = value as? [String: Any] else { return }
+
+            let paragraphStart = nsString.paragraphRange(
+                for: NSRange(location: range.location, length: 0)
+            ).location
+            guard !EditorLayoutManager.isParagraphStartCreatedByHardBreak(
+                paragraphStart,
+                in: textStorage
+            ) else {
+                return
+            }
+            guard seenStarts.insert(paragraphStart).inserted else { return }
+
+            let markerLength = UInt32(
+                RenderBridge.listMarkerString(listContext: listContext).unicodeScalars.count
+            )
+            markers.append(
+                VirtualListMarker(
+                    paragraphStartUtf16: paragraphStart,
+                    scalarLength: markerLength
+                )
+            )
+        }
+
+        return markers.sorted { $0.paragraphStartUtf16 < $1.paragraphStartUtf16 }
+    }
+}

package/ios/ReactNativeProseEditor.podspec

@@ -0,0 +1,49 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ReactNativeProseEditor'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = { :type => 'MIT' }
+  s.author         = 'Apollo HG'
+  s.homepage       = 'https://github.com/apollohg/react-native-prose-editor'
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/apollohg/react-native-prose-editor.git' }
+  # UniFFI's generated Swift bindings import a companion Clang module
+  # (`editor_coreFFI`) via a custom modulemap. CocoaPods does not support
+  # custom module maps on Swift static libraries, so this pod must build as
+  # a framework.
+  s.static_framework = false
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift source files (including generated UniFFI bindings)
+  s.source_files = '**/*.{h,m,swift}'
+  s.exclude_files = 'Tests/**/*'
+
+  # Prebuilt Rust static library as XCFramework. CocoaPods only reliably
+  # picks up vendored binaries that live under the pod root, so build-ios.sh
+  # syncs the generated XCFramework into this ios/ directory.
+  xcframework_path = File.join(__dir__, 'EditorCore.xcframework')
+
+  if File.exist?(xcframework_path)
+    s.vendored_frameworks = 'EditorCore.xcframework'
+  end
+
+  # The UniFFI C header and modulemap for the Rust FFI layer
+  s.preserve_paths = [
+    'editor_coreFFI/**/*',
+    'EditorCore.xcframework/**/*',
+  ]
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+    'SWIFT_INCLUDE_PATHS' => '$(PODS_TARGET_SRCROOT)/editor_coreFFI',
+    'HEADER_SEARCH_PATHS' => '$(PODS_TARGET_SRCROOT)/editor_coreFFI',
+  }
+end