@openeditor/react-native-prose-editor 0.0.9 → 0.0.10

package/ios/NativeBlockEditorSurface.swift

@@ -1,6 +1,6 @@
 import UIKit
 
-final class NativeBlockEditorSurface: UIScrollView {
+final class NativeBlockEditorSurface: UIScrollView, UITextViewDelegate, UIGestureRecognizerDelegate {
     private final class TextLeafView: UITextView {
         struct PositionSegment {
             let range: NSRange
@@ -8,49 +8,34 @@ final class NativeBlockEditorSurface: UIScrollView {
             let docPos: UInt32
             let docSize: UInt32
             let isAtom: Bool
+            let nodeType: String?
         }
 
         var positionSegments: [PositionSegment] = []
-        var onActivate: ((UInt32) -> Void)?
+        var compositionBaselineText: String?
         var geometryContainerWidth: CGFloat?
         private let geometryStorage = NSTextStorage()
         private let geometryLayoutManager = NSLayoutManager()
         private let geometryTextContainer = NSTextContainer()
         private var geometryInitialized = false
 
-        // Leaves expose TextKit geometry but never own keyboard focus. The
-        // shared EditorTextView input coordinator is the sole first responder.
-        override var canBecomeFirstResponder: Bool { false }
-
         override var intrinsicContentSize: CGSize {
             let size = sizeThatFits(CGSize(width: bounds.width > 0 ? bounds.width : 320, height: .greatestFiniteMagnitude))
             return CGSize(width: UIView.noIntrinsicMetric, height: max(36, ceil(size.height)))
         }
 
-        @objc func activate(_ gesture: UITapGestureRecognizer) {
-            let point = gesture.location(in: self)
-            var fraction: CGFloat = 0
-            let glyphIndex = layoutManager.glyphIndex(
-                for: point,
-                in: textContainer,
-                fractionOfDistanceThroughGlyph: &fraction
-            )
-            let utf16Offset = min(
-                layoutManager.characterIndexForGlyph(at: glyphIndex) + (fraction >= 0.5 ? 1 : 0),
-                textStorage.length
-            )
+        func docPosition(forNativeOffset utf16Offset: Int) -> UInt32? {
             guard let segment = positionSegments.first(where: {
                 utf16Offset >= $0.range.location && utf16Offset <= NSMaxRange($0.range)
-            }) ?? positionSegments.last else { return }
+            }) ?? positionSegments.last else { return nil }
             if segment.isAtom {
                 let after = utf16Offset > segment.range.location + segment.range.length / 2
-                onActivate?(segment.docPos + (after ? segment.docSize : 0))
-                return
+                return segment.docPos + (after ? segment.docSize : 0)
             }
             let localUtf16 = max(0, min(utf16Offset - segment.range.location, segment.text.utf16.count))
             let index = String.Index(utf16Offset: localUtf16, in: segment.text)
             let scalarOffset = segment.text[..<index].unicodeScalars.count
-            onActivate?(segment.docPos + UInt32(scalarOffset))
+            return segment.docPos + UInt32(scalarOffset)
         }
 
         func nativeOffset(forDocPosition docPosition: UInt32) -> Int? {
@@ -231,7 +216,7 @@ final class NativeBlockEditorSurface: UIScrollView {
     private var textLeafViews: [TextLeafView] = []
     private var selectedNodePos: UInt32?
     private var selectedTextPos: UInt32?
-    private let caretView = UIView()
+    private var isApplyingEditorUpdate = false
 
     var placeholder: String = "" {
         didSet {
@@ -248,18 +233,94 @@ final class NativeBlockEditorSurface: UIScrollView {
         }
     }
     var onAppliedUpdate: ((String) -> Void)?
-    var onRequestTextInput: ((UInt32) -> Void)?
+    var onFocusChange: ((Bool) -> Void)?
+    private var configuredInputAccessoryView: UIView?
+    private var configuredAutocapitalizationType: UITextAutocapitalizationType = .sentences
+    private var configuredAutocorrectionType: UITextAutocorrectionType = .default
+    private var configuredKeyboardType: UIKeyboardType = .default
+    private var configuredKeyboardAppearance: UIKeyboardAppearance = .default
     var isEditable = true {
         didSet {
+            textLeafViews.forEach {
+                $0.isEditable = isEditable
+                $0.isSelectable = isEditable
+            }
             refreshImageSelection()
-            refreshCaret()
         }
     }
-    var isInputFocused = false {
-        didSet { refreshCaret() }
-    }
     var onContentHeightMayChange: ((CGFloat) -> Void)?
 
+    var activeTextView: UITextView? {
+        textLeafViews.first(where: { $0.isFirstResponder })
+            ?? textLeafViews.first(where: { leaf in
+                guard let selectedTextPos else { return false }
+                return leaf.nativeOffset(forDocPosition: selectedTextPos) != nil
+            })
+            ?? textLeafViews.first
+    }
+
+    func activeDocPosition(forUTF16Offset offset: Int) -> UInt32? {
+        guard let leaf = activeTextView as? TextLeafView else { return nil }
+        return leaf.docPosition(forNativeOffset: offset)
+    }
+
+    func activeInlineAtomType(atUTF16Offset offset: Int) -> String? {
+        guard let leaf = activeTextView as? TextLeafView else { return nil }
+        return leaf.positionSegments.first(where: {
+            $0.isAtom && offset >= $0.range.location && offset <= NSMaxRange($0.range)
+        })?.nodeType
+    }
+
+    var activeDocSelection: (anchor: UInt32, head: UInt32)? {
+        guard let leaf = activeTextView as? TextLeafView,
+              let range = leaf.selectedTextRange
+        else { return nil }
+        let start = leaf.offset(from: leaf.beginningOfDocument, to: range.start)
+        let end = leaf.offset(from: leaf.beginningOfDocument, to: range.end)
+        guard let anchor = leaf.docPosition(forNativeOffset: start),
+              let head = leaf.docPosition(forNativeOffset: end)
+        else { return nil }
+        return (anchor, head)
+    }
+
+    @discardableResult
+    func focus() -> Bool {
+        activeTextView?.becomeFirstResponder() ?? false
+    }
+
+    func blur() {
+        activeTextView?.resignFirstResponder()
+    }
+
+    func setInputAccessoryView(_ view: UIView?) {
+        configuredInputAccessoryView = view
+        textLeafViews.forEach { $0.inputAccessoryView = view }
+        activeTextView?.reloadInputViews()
+    }
+
+    func configureInputTraits(
+        autocapitalizationType: UITextAutocapitalizationType? = nil,
+        autocorrectionType: UITextAutocorrectionType? = nil,
+        keyboardType: UIKeyboardType? = nil,
+        keyboardAppearance: UIKeyboardAppearance? = nil
+    ) {
+        if let autocapitalizationType { configuredAutocapitalizationType = autocapitalizationType }
+        if let autocorrectionType { configuredAutocorrectionType = autocorrectionType }
+        if let keyboardType { configuredKeyboardType = keyboardType }
+        if let keyboardAppearance { configuredKeyboardAppearance = keyboardAppearance }
+        textLeafViews.forEach(applyInputConfiguration)
+        activeTextView?.reloadInputViews()
+    }
+
+    private func applyInputConfiguration(to leaf: TextLeafView) {
+        leaf.inputAccessoryView = configuredInputAccessoryView
+        leaf.autocapitalizationType = configuredAutocapitalizationType
+        leaf.autocorrectionType = configuredAutocorrectionType
+        leaf.spellCheckingType = configuredAutocorrectionType == .no ? .no : .default
+        leaf.keyboardType = configuredKeyboardType
+        leaf.keyboardAppearance = configuredKeyboardAppearance
+    }
+
     override init(frame: CGRect) {
         super.init(frame: frame)
         setup()
@@ -283,11 +344,6 @@ final class NativeBlockEditorSurface: UIScrollView {
         placeholderLabel.isHidden = true
         placeholderLabel.layer.zPosition = 1
         addSubview(placeholderLabel)
-        caretView.backgroundColor = .systemBlue
-        caretView.isUserInteractionEnabled = false
-        caretView.layer.cornerRadius = 1
-        caretView.isHidden = true
-        addSubview(caretView)
     }
 
     override func layoutSubviews() {
@@ -321,7 +377,6 @@ final class NativeBlockEditorSurface: UIScrollView {
             ).height
         )
         contentSize = CGSize(width: bounds.width, height: stack.frame.maxY + bottomInset)
-        refreshCaret()
         onContentHeightMayChange?(contentSize.height)
     }
 
@@ -351,19 +406,30 @@ final class NativeBlockEditorSurface: UIScrollView {
         guard let data = updateJSON.data(using: .utf8),
               let update = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
         else { return }
+        let shouldPreserveTextFocus = textLeafViews.contains(where: \.isFirstResponder)
+        isApplyingEditorUpdate = true
+        defer { isApplyingEditorUpdate = false }
 
+        var textSelection: (UInt32, UInt32)?
         if let selection = update["selection"] as? [String: Any] {
             let type = selection["type"] as? String
             selectedNodePos = type == "node" ? (selection["pos"] as? NSNumber)?.uint32Value : nil
             let anchor = (selection["anchor"] as? NSNumber)?.uint32Value
             let head = (selection["head"] as? NSNumber)?.uint32Value
             selectedTextPos = type == "text" && anchor == head ? anchor : nil
+            if type == "text", let anchor, let head {
+                textSelection = (anchor, head)
+            }
             refreshImageSelection()
-            refreshCaret()
         }
         guard let renderTree = update["renderTree"] as? [String: Any],
               let root = renderTree["root"] as? [String: Any]
-        else { return }
+        else {
+            if let textSelection {
+                applyNativeSelection(anchor: textSelection.0, head: textSelection.1, preservingFocus: shouldPreserveTextFocus)
+            }
+            return
+        }
 
         currentEditorId = editorId
         isApplyingRemoteUpdate = true
@@ -375,10 +441,12 @@ final class NativeBlockEditorSurface: UIScrollView {
         }
         refreshTableCellRegistry()
         refreshImageSelection()
-        refreshCaret()
         currentRoot = root
         refreshPlaceholder()
         isApplyingRemoteUpdate = false
+        if let textSelection {
+            applyNativeSelection(anchor: textSelection.0, head: textSelection.1, preservingFocus: shouldPreserveTextFocus)
+        }
         setNeedsLayout()
         layoutIfNeeded()
     }
@@ -486,6 +554,10 @@ final class NativeBlockEditorSurface: UIScrollView {
             rebuildAll(from: root)
             return
         }
+        if let leaf = oldView as? TextLeafView {
+            configureTextLeaf(leaf, for: node)
+            return
+        }
         guard let parent = oldView.superview else {
             rebuildAll(from: root)
             return
@@ -521,7 +593,7 @@ final class NativeBlockEditorSurface: UIScrollView {
                 let blockPos = (node["docPos"] as? NSNumber)?.uint32Value ?? 0
                 let blockSize = (node["docSize"] as? NSNumber)?.uint32Value ?? 0
                 leaf.positionSegments = [
-                    .init(range: NSRange(location: 0, length: 0), text: "", docPos: blockPos, docSize: blockSize, isAtom: false),
+                    .init(range: NSRange(location: 0, length: 0), text: "", docPos: blockPos, docSize: blockSize, isAtom: false, nodeType: nil),
                 ]
             } else {
                 leaf.positionSegments = segments
@@ -849,6 +921,7 @@ final class NativeBlockEditorSurface: UIScrollView {
         cell.backgroundColor = cell.baseFillColor
         cell.isUserInteractionEnabled = true
         let tap = UITapGestureRecognizer(target: self, action: #selector(handleCellTap(_:)))
+        tap.delegate = self
         cell.addGestureRecognizer(tap)
         tableCells.append(cell)
         for (index, child) in (node["children"] as? [[String: Any]] ?? []).enumerated() {
@@ -860,8 +933,25 @@ final class NativeBlockEditorSurface: UIScrollView {
         return cell
     }
 
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        guard gestureRecognizer.view is CellView else { return true }
+        var touchedView: UIView? = touch.view
+        while let view = touchedView, view !== gestureRecognizer.view {
+            if view is UITextView || view is UIControl { return false }
+            touchedView = view.superview
+        }
+        return true
+    }
+
     private func textBlockView(for node: [String: Any], depth: Int) -> UIView {
         let leaf = TextLeafView()
+        configureTextLeaf(leaf, for: node)
+        return leaf
+    }
+
+    private func configureTextLeaf(_ leaf: TextLeafView, for node: [String: Any]) {
+        let wasFirstResponder = leaf.isFirstResponder
+        let previousSelection = leaf.selectedRange
         leaf.font = font(for: node)
         let nodeType = node["nodeType"] as? String ?? "paragraph"
         let textStyle = currentTheme?.effectiveTextStyle(for: nodeType)
@@ -896,9 +986,10 @@ final class NativeBlockEditorSurface: UIScrollView {
                 .init(
                     range: NSRange(location: 0, length: 0),
                     text: "",
-                    docPos: blockPos,
-                    docSize: blockSize,
-                    isAtom: false
+                    docPos: blockPos + (blockSize >= 2 ? 1 : 0),
+                    docSize: 0,
+                    isAtom: false,
+                    nodeType: nil
                 ),
             ]
         }
@@ -917,16 +1008,17 @@ final class NativeBlockEditorSurface: UIScrollView {
             leaf.textContainerInset = .zero
         }
         leaf.isScrollEnabled = false
-        leaf.isEditable = false
-        leaf.isSelectable = false
-        leaf.textContainer.widthTracksTextView = false
+        leaf.isEditable = isEditable
+        leaf.isSelectable = isEditable
+        leaf.textContainer.widthTracksTextView = true
         leaf.textContainer.lineFragmentPadding = 0
-        leaf.onActivate = { [weak self] docPos in
-            guard let self, self.isEditable else { return }
-            self.onRequestTextInput?(docPos)
+        leaf.delegate = self
+        applyInputConfiguration(to: leaf)
+        if wasFirstResponder {
+            let location = min(previousSelection.location, leaf.textStorage.length)
+            let length = min(previousSelection.length, leaf.textStorage.length - location)
+            leaf.selectedRange = NSRange(location: location, length: length)
         }
-        leaf.addGestureRecognizer(UITapGestureRecognizer(target: leaf, action: #selector(TextLeafView.activate(_:))))
-        return leaf
     }
 
     private func attributedInlineContent(
@@ -953,7 +1045,8 @@ final class NativeBlockEditorSurface: UIScrollView {
                     text: value,
                     docPos: docPos,
                     docSize: docSize,
-                    isAtom: false
+                    isAtom: false,
+                    nodeType: nil
                 ))
                 return
             }
@@ -977,7 +1070,8 @@ final class NativeBlockEditorSurface: UIScrollView {
                     text: value,
                     docPos: docPos,
                     docSize: max(docSize, 1),
-                    isAtom: true
+                    isAtom: true,
+                    nodeType: nodeType
                 ))
                 return
             }
@@ -1187,16 +1281,132 @@ final class NativeBlockEditorSurface: UIScrollView {
         }
     }
 
-    private func refreshCaret() {
-        guard isEditable, isInputFocused, selectedNodePos == nil,
-              let rect = selectedCaretRect()
+    private func applyNativeSelection(anchor: UInt32, head: UInt32, preservingFocus: Bool) {
+        let candidates = textLeafViews.filter {
+            $0.nativeOffset(forDocPosition: anchor) != nil &&
+                $0.nativeOffset(forDocPosition: head) != nil
+        }
+        guard let leaf = candidates.first(where: \.isFirstResponder)
+            ?? (anchor == head ? candidates.last : candidates.first),
+        let anchorOffset = leaf.nativeOffset(forDocPosition: anchor),
+        let headOffset = leaf.nativeOffset(forDocPosition: head),
+        let start = leaf.position(
+            from: leaf.beginningOfDocument,
+            offset: min(anchorOffset, headOffset)
+        ),
+        let end = leaf.position(
+            from: leaf.beginningOfDocument,
+            offset: max(anchorOffset, headOffset)
+        ),
+        let range = leaf.textRange(from: start, to: end)
+        else { return }
+        leaf.selectedTextRange = range
+        if preservingFocus, !leaf.isFirstResponder {
+            leaf.becomeFirstResponder()
+        }
+    }
+
+    func textViewDidChangeSelection(_ textView: UITextView) {
+        guard !isApplyingEditorUpdate, isEditable, currentEditorId != 0,
+              let leaf = textView as? TextLeafView,
+              let range = leaf.selectedTextRange
+        else { return }
+        let anchorOffset = leaf.offset(from: leaf.beginningOfDocument, to: range.start)
+        let headOffset = leaf.offset(from: leaf.beginningOfDocument, to: range.end)
+        guard let anchor = leaf.docPosition(forNativeOffset: anchorOffset),
+              let head = leaf.docPosition(forNativeOffset: headOffset)
+        else { return }
+        editorSetSelection(id: currentEditorId, anchor: anchor, head: head)
+        onAppliedUpdate?(editorGetSelectionState(id: currentEditorId))
+    }
+
+    func textViewDidChange(_ textView: UITextView) {
+        guard !isApplyingEditorUpdate, isEditable, currentEditorId != 0,
+              let leaf = textView as? TextLeafView,
+              textView.markedTextRange == nil,
+              let baseline = leaf.compositionBaselineText
+        else { return }
+        leaf.compositionBaselineText = nil
+        commitNativeText(in: leaf, baseline: baseline, current: leaf.text ?? "")
+    }
+
+    func textViewDidBeginEditing(_ textView: UITextView) {
+        onFocusChange?(true)
+    }
+
+    func textViewDidEndEditing(_ textView: UITextView) {
+        if !textLeafViews.contains(where: { $0.isFirstResponder }) {
+            onFocusChange?(false)
+        }
+    }
+
+    func textView(
+        _ textView: UITextView,
+        shouldChangeTextIn range: NSRange,
+        replacementText text: String
+    ) -> Bool {
+        guard !isApplyingEditorUpdate, isEditable, currentEditorId != 0,
+              let leaf = textView as? TextLeafView
+        else { return false }
+
+        if text.isEmpty, range.length == 0, range.location == 0,
+           let docPosition = leaf.docPosition(forNativeOffset: 0) {
+            let scalar = editorDocToScalar(id: currentEditorId, docPos: docPosition)
+            let update = editorDeleteBackwardAtSelectionScalar(
+                id: currentEditorId,
+                scalarAnchor: scalar,
+                scalarHead: scalar
+            )
+            applyUpdateJSON(update, editorId: currentEditorId)
+            onAppliedUpdate?(update)
+            return false
+        }
+
+        if text == "\n" {
+            guard let anchor = leaf.docPosition(forNativeOffset: range.location),
+                  let head = leaf.docPosition(forNativeOffset: NSMaxRange(range))
+            else { return false }
+            editorSetSelection(id: currentEditorId, anchor: anchor, head: head)
+            if anchor != head {
+                _ = editorReplaceSelectionText(id: currentEditorId, text: "")
+            }
+            let update = editorSplitBlock(id: currentEditorId, pos: anchor)
+            applyUpdateJSON(update, editorId: currentEditorId)
+            onAppliedUpdate?(update)
+            return false
+        }
+
+        if leaf.compositionBaselineText == nil {
+            leaf.compositionBaselineText = leaf.text ?? ""
+        }
+        return true
+    }
+
+    private func commitNativeText(in leaf: TextLeafView, baseline: String, current: String) {
+        guard baseline != current else { return }
+        let old = baseline as NSString
+        let new = current as NSString
+        var prefix = 0
+        while prefix < old.length, prefix < new.length,
+              old.character(at: prefix) == new.character(at: prefix) { prefix += 1 }
+        var oldSuffix = old.length
+        var newSuffix = new.length
+        while oldSuffix > prefix, newSuffix > prefix,
+              old.character(at: oldSuffix - 1) == new.character(at: newSuffix - 1) {
+            oldSuffix -= 1
+            newSuffix -= 1
+        }
+        guard let anchor = leaf.docPosition(forNativeOffset: prefix),
+              let head = leaf.docPosition(forNativeOffset: oldSuffix)
         else {
-            caretView.isHidden = true
+            applyUpdateJSON(editorGetCurrentState(id: currentEditorId), editorId: currentEditorId)
             return
         }
-        caretView.frame = CGRect(x: rect.minX, y: rect.minY, width: 2, height: rect.height)
-        caretView.isHidden = false
-        bringSubviewToFront(caretView)
+        let replacement = new.substring(with: NSRange(location: prefix, length: newSuffix - prefix))
+        editorSetSelection(id: currentEditorId, anchor: anchor, head: head)
+        let update = editorReplaceSelectionText(id: currentEditorId, text: replacement)
+        applyUpdateJSON(update, editorId: currentEditorId)
+        onAppliedUpdate?(update)
     }
 
     func firstImageGeometryForTesting() -> (docPos: UInt32, rect: CGRect)? {