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

package/ios/NativeEditorExpoView+Focus.swift

@@ -0,0 +1,169 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func focus() {
+        _ = richTextView.textView.becomeFirstResponder()
+    }
+
+    func blur() {
+        clearRecentToolbarTouch()
+        _ = richTextView.textView.resignFirstResponder()
+    }
+
+    func getCaretRectJson() -> String? {
+        layoutIfNeeded()
+        richTextView.layoutIfNeeded()
+
+        guard let caretRect = richTextView.currentCaretRect() else {
+            return nil
+        }
+        let editorRect = richTextView.convert(caretRect, to: self)
+        let payload: [String: Any] = [
+            "x": editorRect.minX,
+            "y": editorRect.minY,
+            "width": editorRect.width,
+            "height": editorRect.height,
+            "editorWidth": bounds.width,
+            "editorHeight": bounds.height
+        ]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return nil
+        }
+        return json
+    }
+
+    @objc func textViewDidBeginEditing(_ notification: Notification) {
+        let originatingEditorId = richTextView.textView.editorId
+        installOutsideTapRecognizerIfNeeded()
+        richTextView.textView.refreshSelectionVisualState()
+        refreshMentionQuery()
+        guard let event = Self.editorScopedEventPayload(
+            ["isFocused": true],
+            originatingEditorId: originatingEditorId
+        ) else { return }
+        onFocusChange(event)
+    }
+
+    @objc func textViewDidEndEditing(_ notification: Notification) {
+        let originatingEditorId = richTextView.textView.editorId
+        if consumeToolbarFocusPreservationForBlur() {
+            DispatchQueue.main.async { [weak self] in
+                _ = self?.richTextView.textView.becomeFirstResponder()
+            }
+            return
+        }
+
+        uninstallOutsideTapRecognizer()
+        richTextView.textView.refreshSelectionVisualState()
+        clearMentionQueryStateAndHidePopover()
+        guard let event = Self.editorScopedEventPayload(
+            ["isFocused": false],
+            originatingEditorId: originatingEditorId
+        ) else { return }
+        onFocusChange(event)
+    }
+
+    @objc func handleOutsideTap(_ recognizer: UITapGestureRecognizer) {
+        guard recognizer.state == .ended else { return }
+        guard richTextView.textView.isFirstResponder else { return }
+        guard let tapWindow = gestureWindow ?? window else { return }
+        let locationInWindow = recognizer.location(in: tapWindow)
+        guard shouldHandleOutsideTap(locationInWindow: locationInWindow, touchedView: nil) else {
+            return
+        }
+        clearRecentToolbarTouch()
+        blur()
+    }
+
+    func installOutsideTapRecognizerIfNeeded() {
+        guard let window else { return }
+        if gestureWindow === window, window.gestureRecognizers?.contains(outsideTapGestureRecognizer) == true {
+            return
+        }
+        uninstallOutsideTapRecognizer()
+        window.addGestureRecognizer(outsideTapGestureRecognizer)
+        gestureWindow = window
+    }
+
+    func uninstallOutsideTapRecognizer() {
+        if let window = gestureWindow {
+            window.removeGestureRecognizer(outsideTapGestureRecognizer)
+        }
+        gestureWindow = nil
+    }
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        guard gestureRecognizer === outsideTapGestureRecognizer else { return true }
+        guard let tapWindow = gestureWindow ?? window else { return true }
+        let locationInWindow = touch.location(in: tapWindow)
+        return prepareOutsideTapForFocusHandling(
+            locationInWindow: locationInWindow,
+            touchedView: touch.view
+        )
+    }
+
+    func prepareOutsideTapForFocusHandling(
+        locationInWindow: CGPoint,
+        touchedView: UIView?
+    ) -> Bool {
+        if isLocationInStandaloneToolbarFrame(locationInWindow) {
+            markRecentToolbarTouch()
+        }
+        let result = shouldHandleOutsideTap(
+            locationInWindow: locationInWindow,
+            touchedView: touchedView
+        )
+        if result {
+            clearRecentToolbarTouch()
+        }
+        return result
+    }
+
+    func markRecentToolbarTouch() {
+        lastToolbarTouchUptime = ProcessInfo.processInfo.systemUptime
+    }
+
+    private func clearRecentToolbarTouch() {
+        lastToolbarTouchUptime = -Double.infinity
+    }
+
+    func shouldPreserveFocusAfterToolbarTouch() -> Bool {
+        ProcessInfo.processInfo.systemUptime - lastToolbarTouchUptime <= 0.75
+    }
+
+    func consumeToolbarFocusPreservationForBlur() -> Bool {
+        guard shouldPreserveFocusAfterToolbarTouch() else { return false }
+        clearRecentToolbarTouch()
+        return true
+    }
+
+    private func isLocationInStandaloneToolbarFrame(_ locationInWindow: CGPoint) -> Bool {
+        toolbarFramesInWindow.contains(where: { $0.contains(locationInWindow) })
+    }
+
+    private func shouldHandleOutsideTap(
+        locationInWindow: CGPoint,
+        touchedView: UIView?
+    ) -> Bool {
+        if let touchedView, touchedView.isDescendant(of: self) {
+            return false
+        }
+        if let tapWindow = gestureWindow ?? window {
+            let editorFrameInWindow = convert(bounds, to: tapWindow)
+            if editorFrameInWindow.contains(locationInWindow) {
+                return false
+            }
+        }
+        if let touchedView, touchedView.isDescendant(of: accessoryToolbar) {
+            return false
+        }
+        if isLocationInStandaloneToolbarFrame(locationInWindow) {
+            return false
+        }
+        return true
+    }
+
+}

package/ios/NativeEditorExpoView+MentionRetry.swift

@@ -0,0 +1,288 @@
+import ExpoModulesCore
+import UIKit
+
+extension NativeEditorExpoView {
+    func insertMentionSuggestion(
+        _ suggestion: NativeMentionSuggestion
+    ) {
+        insertMentionSuggestion(suggestionKey: suggestion.key)
+    }
+
+    func insertMentionSuggestion(
+        retryScope: PendingMentionSuggestionRetry
+    ) {
+        insertMentionSuggestion(
+            suggestionKey: retryScope.suggestionKey,
+            retryScope: retryScope
+        )
+    }
+
+    func insertMentionSuggestion(
+        suggestionKey: String,
+        retryScope: PendingMentionSuggestionRetry? = nil
+    ) {
+        guard let mentions = addons.mentions,
+              mentionQueryState != nil
+        else {
+            return
+        }
+        if let retryScope,
+           !isMentionSuggestionRetryScopeCurrent(retryScope) {
+            return
+        }
+
+        let scopedQueryState = currentMentionQueryState(trigger: mentions.trigger) ?? mentionQueryState
+        guard let scopedQueryState else {
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+        let preparation = richTextView.textView.prepareForExternalEditorCommand()
+        guard preparation.ready else {
+            scheduleMentionSuggestionRetry(
+                PendingMentionSuggestionRetry(
+                    suggestionKey: suggestionKey,
+                    editorId: richTextView.editorId,
+                    trigger: mentions.trigger,
+                    query: scopedQueryState.query,
+                    anchor: scopedQueryState.anchor,
+                    head: scopedQueryState.head,
+                    documentVersion: currentDocumentVersion(),
+                    textSnapshot: richTextView.textView.text ?? ""
+                )
+            )
+            return
+        }
+        let queryState = currentMentionQueryState(trigger: mentions.trigger)
+            ?? (richTextView.textView.isFirstResponder ? nil : mentionQueryState)
+        guard let queryState else {
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+        if let retryScope,
+           !doesMentionQueryState(
+               queryState,
+               match: retryScope,
+               acceptingPreflightDocumentVersion: documentVersion(fromUpdateJSON: preparation.updateJSON),
+               currentText: richTextView.textView.text ?? ""
+           ) {
+            return
+        }
+        guard let currentSuggestion = filteredMentionSuggestions(
+            for: queryState,
+            config: mentions
+        ).first(where: { $0.key == suggestionKey }) else {
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+        mentionQueryState = queryState
+
+        let attrs = resolvedMentionAttrs(trigger: mentions.trigger, suggestion: currentSuggestion)
+        if mentions.resolveSelectionAttrs || mentions.resolveTheme {
+            emitMentionSelectRequest(
+                trigger: mentions.trigger,
+                suggestion: currentSuggestion,
+                attrs: attrs,
+                range: queryState,
+                preflightUpdateJSON: preparation.updateJSON
+            )
+            lastMentionEventJSON = nil
+            clearMentionQueryStateAndHidePopover()
+            return
+        }
+        let payload: [String: Any] = [
+            "type": "doc",
+            "content": [[
+                "type": "mention",
+                "attrs": attrs
+            ]]
+        ]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return
+        }
+
+        let updateJSON = EditorV2Shadow.insertContentJsonAtSelectionScalar(
+            id: richTextView.editorId,
+            scalarAnchor: queryState.anchor,
+            scalarHead: queryState.head,
+            json: json
+        )
+        imageLoadOwner.withCurrent {
+            _ = richTextView.textView.applyUpdateJSON(updateJSON)
+        }
+        emitMentionSelect(trigger: mentions.trigger, suggestion: currentSuggestion, attrs: attrs)
+        lastMentionEventJSON = nil
+        clearMentionQueryStateAndHidePopover()
+    }
+
+    private func scheduleMentionSuggestionRetry(_ retry: PendingMentionSuggestionRetry) {
+        pendingMentionSuggestionRetry = retry
+        guard !pendingMentionSuggestionRetryScheduled else { return }
+        pendingMentionSuggestionRetryScheduled = true
+        pendingMentionSuggestionRetryGeneration &+= 1
+        let retryGeneration = pendingMentionSuggestionRetryGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard retryGeneration == self.pendingMentionSuggestionRetryGeneration else { return }
+            guard let retry = self.pendingMentionSuggestionRetry else {
+                self.pendingMentionSuggestionRetryScheduled = false
+                return
+            }
+            guard retry.editorId == self.richTextView.editorId else {
+                self.clearPendingMentionSuggestionRetry()
+                return
+            }
+            self.pendingMentionSuggestionRetry = nil
+            self.pendingMentionSuggestionRetryScheduled = false
+            self.insertMentionSuggestion(retryScope: retry)
+        }
+    }
+
+    private func isMentionSuggestionRetryScopeCurrent(
+        _ retry: PendingMentionSuggestionRetry
+    ) -> Bool {
+        guard retry.editorId == richTextView.editorId,
+              addons.mentions?.trigger == retry.trigger
+        else {
+            return false
+        }
+        let queryState = currentMentionQueryState(trigger: retry.trigger) ?? mentionQueryState
+        guard let queryState else { return false }
+        guard doesMentionQueryStateMatchRetryIdentity(queryState, match: retry) else {
+            return false
+        }
+        return isMentionSuggestionRetryDocumentVersionCurrent(retry)
+    }
+
+    private func doesMentionQueryState(
+        _ queryState: MentionQueryState,
+        match retry: PendingMentionSuggestionRetry,
+        acceptingPreflightDocumentVersion preflightDocumentVersion: String? = nil,
+        currentText: String? = nil
+    ) -> Bool {
+        guard doesMentionQueryStateMatchRetryIdentity(queryState, match: retry) else {
+            return false
+        }
+
+        let currentVersion = currentDocumentVersion()
+        var acceptedPreflightVersionChange = false
+        if let retryVersion = retry.documentVersion,
+           let currentVersion,
+           currentVersion != retryVersion {
+            guard let preflightDocumentVersion,
+                  currentVersion == preflightDocumentVersion
+            else {
+                return false
+            }
+            acceptedPreflightVersionChange = true
+        }
+
+        if queryState.anchor == retry.anchor && queryState.head == retry.head {
+            return true
+        }
+
+        guard acceptedPreflightVersionChange else {
+            return false
+        }
+
+        guard let currentText,
+              let diff = mentionRetryTextDiff(
+                  from: retry.textSnapshot,
+                  to: currentText
+              ),
+              let mappedRange = mappedMentionRetryRange(retry, through: diff)
+        else {
+            return false
+        }
+
+        return queryState.anchor == mappedRange.anchor && queryState.head == mappedRange.head
+    }
+
+    private func doesMentionQueryStateMatchRetryIdentity(
+        _ queryState: MentionQueryState,
+        match retry: PendingMentionSuggestionRetry
+    ) -> Bool {
+        queryState.trigger == retry.trigger && queryState.query == retry.query
+    }
+
+    private func isMentionSuggestionRetryDocumentVersionCurrent(
+        _ retry: PendingMentionSuggestionRetry
+    ) -> Bool {
+        let currentVersion = currentDocumentVersion()
+        if let retryVersion = retry.documentVersion,
+           let currentVersion,
+           currentVersion != retryVersion {
+            return false
+        }
+        return true
+    }
+
+    private func mentionRetryTextDiff(
+        from oldText: String,
+        to newText: String
+    ) -> MentionRetryTextDiff? {
+        let oldScalars = Array(oldText.unicodeScalars)
+        let newScalars = Array(newText.unicodeScalars)
+        let sharedLength = min(oldScalars.count, newScalars.count)
+
+        var prefix = 0
+        while prefix < sharedLength,
+              oldScalars[prefix] == newScalars[prefix] {
+            prefix += 1
+        }
+
+        var oldEnd = oldScalars.count
+        var newEnd = newScalars.count
+        while oldEnd > prefix,
+              newEnd > prefix,
+              oldScalars[oldEnd - 1] == newScalars[newEnd - 1] {
+            oldEnd -= 1
+            newEnd -= 1
+        }
+
+        guard prefix != oldEnd || prefix != newEnd else {
+            return nil
+        }
+
+        return MentionRetryTextDiff(
+            start: prefix,
+            oldEnd: oldEnd,
+            newEnd: newEnd
+        )
+    }
+
+    private func mappedMentionRetryRange(
+        _ retry: PendingMentionSuggestionRetry,
+        through diff: MentionRetryTextDiff
+    ) -> (anchor: UInt32, head: UInt32)? {
+        let anchor = Int(retry.anchor)
+        let head = Int(retry.head)
+        guard anchor <= head else { return nil }
+
+        if head <= diff.start {
+            return (retry.anchor, retry.head)
+        }
+
+        if anchor >= diff.oldEnd {
+            let delta = diff.newEnd - diff.oldEnd
+            let mappedAnchor = anchor + delta
+            let mappedHead = head + delta
+            guard mappedAnchor >= 0,
+                  mappedHead >= mappedAnchor,
+                  mappedHead <= Int(UInt32.max)
+            else {
+                return nil
+            }
+            return (UInt32(mappedAnchor), UInt32(mappedHead))
+        }
+
+        return nil
+    }
+
+    private func currentDocumentVersion() -> String? {
+        guard richTextView.editorId != 0 else { return nil }
+        return documentVersion(fromUpdateJSON: EditorV2Shadow.getCurrentState(id: richTextView.editorId))
+    }
+
+}