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

package/ios/EditorTextView+MarkedText.swift

@@ -0,0 +1,267 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    func captureMarkedTextReplacementRangeIfNeeded() {
+        guard markedTextReplacementScalarRange == nil else { return }
+
+        guard let selectedRange = selectedTextRange else {
+            let scalarPos = PositionBridge.cursorScalarOffset(in: self)
+            let utf16Pos = PositionBridge.scalarToUtf16Offset(scalarPos, in: lastAuthorizedText)
+            markedTextReplacementScalarRange = (from: scalarPos, to: scalarPos)
+            markedTextReplacementUtf16Range = NSRange(
+                location: utf16Pos,
+                length: 0
+            )
+            return
+        }
+
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        let startUtf16 = offset(from: beginningOfDocument, to: selectedRange.start)
+        let endUtf16 = offset(from: beginningOfDocument, to: selectedRange.end)
+
+        markedTextReplacementScalarRange = (from: scalarRange.from, to: scalarRange.to)
+        markedTextReplacementUtf16Range = NSRange(
+            location: min(startUtf16, endUtf16),
+            length: abs(endUtf16 - startUtf16)
+        )
+    }
+
+    func trackedMarkedTextReplacementRange() -> (from: UInt32, to: UInt32)? {
+        if let markedTextReplacementScalarRange {
+            return markedTextReplacementScalarRange
+        }
+        guard let selectedRange = selectedTextRange else { return nil }
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        return (from: scalarRange.from, to: scalarRange.to)
+    }
+
+    func clearMarkedTextTracking() {
+        markedTextReplacementScalarRange = nil
+        markedTextReplacementUtf16Range = nil
+        markedTextCompositionText = nil
+        markedTextCompositionIsExplicitlyEmpty = false
+        isComposing = false
+    }
+
+    func finishTransientMarkedTextMutation() {
+        performTransientTextMutation {
+            super.unmarkText()
+        }
+        clearMarkedTextTracking()
+        onExternalUpdateReadinessMayChange?()
+    }
+
+    func performTransientTextMutation(_ action: () -> Void) {
+        let wasApplyingRustState = isApplyingRustState
+        isApplyingRustState = true
+        action()
+        isApplyingRustState = wasApplyingRustState
+    }
+
+    func currentMarkedTextForCommit() -> String? {
+        if markedTextCompositionIsExplicitlyEmpty { return "" }
+        return transientMarkedTextFromAuthorizedDiff()
+            ?? markedTextRange.flatMap { text(in: $0) }
+            ?? markedTextCompositionText
+    }
+
+    func validatedTrackedMarkedTextForCommit() -> String? {
+        guard markedTextReplacementScalarRange != nil || markedTextReplacementUtf16Range != nil else {
+            return nil
+        }
+        if markedTextCompositionIsExplicitlyEmpty { return "" }
+        return transientMarkedTextFromAuthorizedDiff()
+            ?? markedTextRange.flatMap { text(in: $0) }
+    }
+
+    func refreshMarkedTextCompositionText(fallback: String? = nil) {
+        if fallback?.isEmpty == true {
+            markedTextCompositionText = ""
+            markedTextCompositionIsExplicitlyEmpty = true
+            return
+        }
+        markedTextCompositionIsExplicitlyEmpty = false
+        markedTextCompositionText = transientMarkedTextFromAuthorizedDiff()
+            ?? markedTextRange.flatMap { text(in: $0) }
+            ?? fallback
+    }
+
+    private func transientMarkedTextFromAuthorizedDiff() -> String? {
+        guard let replacementRange = markedTextReplacementUtf16Range else { return nil }
+
+        let currentText = textStorage.string as NSString
+        let authorizedText = lastAuthorizedText as NSString
+        let replacementEnd = replacementRange.location + replacementRange.length
+        guard replacementRange.location >= 0,
+              replacementEnd <= authorizedText.length
+        else {
+            return nil
+        }
+
+        let insertedLength = currentText.length - (authorizedText.length - replacementRange.length)
+        guard insertedLength >= 0,
+              replacementRange.location + insertedLength <= currentText.length
+        else {
+            return nil
+        }
+
+        if replacementRange.location > 0 {
+            let prefixRange = NSRange(location: 0, length: replacementRange.location)
+            guard currentText.substring(with: prefixRange) == authorizedText.substring(with: prefixRange) else {
+                return nil
+            }
+        }
+
+        let insertedEnd = replacementRange.location + insertedLength
+        let authorizedSuffixLength = authorizedText.length - replacementEnd
+        let currentSuffixLength = currentText.length - insertedEnd
+        guard authorizedSuffixLength == currentSuffixLength else { return nil }
+        if authorizedSuffixLength > 0 {
+            let authorizedSuffixRange = NSRange(location: replacementEnd, length: authorizedSuffixLength)
+            let currentSuffixRange = NSRange(location: insertedEnd, length: currentSuffixLength)
+            guard currentText.substring(with: currentSuffixRange)
+                == authorizedText.substring(with: authorizedSuffixRange)
+            else {
+                return nil
+            }
+        }
+
+        return currentText.substring(
+            with: NSRange(location: replacementRange.location, length: insertedLength)
+        )
+    }
+
+    func commitMarkedText(
+        _ text: String,
+        replacementRange: (from: UInt32, to: UInt32)?
+    ) -> String? {
+        guard editorId != 0,
+              let adapter = EditorV2Registry.adapter(forLegacyId: editorId)
+        else {
+            return nil
+        }
+        var adoptedUpdateJSON: String?
+        performInterceptedInput(flushPendingNativeTextMutation: false) {
+            if let replacementRange {
+                if replacementRange.from == replacementRange.to {
+                    adoptedUpdateJSON = adapter.insertText(text, atScalar: replacementRange.from)
+                } else {
+                    adoptedUpdateJSON = adapter.replaceTextRange(
+                        from: replacementRange.from,
+                        to: replacementRange.to,
+                        with: text
+                    )
+                }
+            } else {
+                adoptedUpdateJSON = adapter.insertText(
+                    text,
+                    atScalar: PositionBridge.cursorScalarOffset(in: self)
+                )
+            }
+            guard let adoptedUpdateJSON else { return }
+            applyUpdateJSON(adoptedUpdateJSON)
+        }
+        return adoptedUpdateJSON
+    }
+
+    func commitMarkedTextWithNativeOutcome(
+        _ text: String,
+        replacementRange: (from: UInt32, to: UInt32)?
+    ) -> EditorV2Adapter.NativeMutationRender? {
+        guard editorId != 0,
+              let adapter = EditorV2Registry.adapter(forLegacyId: editorId)
+        else {
+            return nil
+        }
+        var commit: EditorV2Adapter.NativeMutationRender?
+        performInterceptedInput(flushPendingNativeTextMutation: false) {
+            if let replacementRange {
+                if replacementRange.from == replacementRange.to {
+                    commit = adapter.insertTextWithNativeOutcome(
+                        text,
+                        atScalar: replacementRange.from
+                    )
+                } else {
+                    commit = adapter.replaceTextRangeWithNativeOutcome(
+                        from: replacementRange.from,
+                        to: replacementRange.to,
+                        with: text
+                    )
+                }
+            } else {
+                let position = PositionBridge.cursorScalarOffset(in: self)
+                commit = adapter.insertTextWithNativeOutcome(text, atScalar: position)
+            }
+            guard let commit else { return }
+            applyUpdateJSON(commit.updateJSON, notifyDelegate: commit.documentChanged)
+        }
+        return commit
+    }
+
+    func commitActiveMarkedTextBeforeReturn() -> Bool {
+        guard markedTextReplacementScalarRange != nil || markedTextRange != nil else {
+            return true
+        }
+
+        if markedTextReplacementScalarRange != nil || markedTextReplacementUtf16Range != nil {
+            let composedText = currentMarkedTextForCommit()
+            let replacementRange = trackedMarkedTextReplacementRange()
+            finishTransientMarkedTextMutation()
+
+            guard shouldCommitMarkedText(composedText, replacementRange: replacementRange) else {
+                restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+                return true
+            }
+            return commitMarkedText(composedText ?? "", replacementRange: replacementRange) != nil
+        }
+
+        let mutation = nativeTextMutationFromAuthorizedDiff(currentText: textStorage.string)
+        finishTransientMarkedTextMutation()
+        guard let mutation else {
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+            return true
+        }
+
+        switch commitNativeTextMutationIfPossible(
+            mutation,
+            allowAfterBlur: false,
+            allowWhileIntercepting: true
+        ) {
+        case .committed:
+            return true
+        case .deferred, .rejected:
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+            return false
+        }
+    }
+
+    func shouldCommitMarkedText(
+        _ text: String?,
+        replacementRange: (from: UInt32, to: UInt32)?
+    ) -> Bool {
+        guard let text else { return false }
+        if !text.isEmpty { return true }
+        guard let replacementRange else { return false }
+        return replacementRange.from != replacementRange.to
+    }
+
+    func restoreAuthorizedTextAfterCancelledCompositionIfNeeded() {
+        guard editorId != 0 else { return }
+        guard textStorage.string != lastAuthorizedText else { return }
+
+        let stateJSON = EditorV2Shadow.getCurrentState(id: editorId)
+        applyUpdateJSON(stateJSON)
+    }
+
+    func previewMarkedTextReplacementRange(
+        _ range: (from: UInt32, to: UInt32)?
+    ) -> String {
+        guard let range else { return "none" }
+        let utf16 = markedTextReplacementUtf16Range
+            .map { "\($0.location)..<\($0.location + $0.length)" }
+            ?? "none"
+        return "scalar=\(range.from)..<\(range.to) utf16=\(utf16)"
+    }
+
+}

package/ios/EditorTextView+NativeInputLifecycle.swift

@@ -0,0 +1,372 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    enum NativeTextMutationCommitResult {
+        case committed(adoptedUpdateJSON: String)
+        case deferred
+        case rejected
+    }
+
+    struct NativeTextMutationDrainResult {
+        let ready: Bool
+        let adoptedUpdateJSON: String?
+    }
+
+    func shouldAdoptNativeTextStorageMutation(
+        _ mutation: NativeTextMutation,
+        allowAfterBlur: Bool = false
+    ) -> Bool {
+        if isFirstResponder && isEditable {
+            return true
+        }
+        return allowAfterBlur
+            && mutation.capturedAfterBlur
+            && mutation.inputGeneration == nativeTextMutationGeneration
+            && canAdoptNativeTextMutationAfterBlur()
+            && mutation.capturedWhileFirstResponder
+            && mutation.capturedWhileEditable
+    }
+
+    func canAdoptNativeTextMutationAfterBlur() -> Bool {
+        guard let deadline = nativeTextMutationAfterBlurDeadline else {
+            return false
+        }
+        guard nativeTextMutationAfterBlurGeneration == nativeTextMutationGeneration else {
+            clearNativeTextMutationAfterBlurWindow()
+            return false
+        }
+        guard ProcessInfo.processInfo.systemUptime <= deadline else {
+            clearNativeTextMutationAfterBlurWindow()
+            return false
+        }
+        return true
+    }
+
+    func clearNativeTextMutationAfterBlurWindow() {
+        nativeTextMutationAfterBlurDeadline = nil
+        nativeTextMutationAfterBlurGeneration = nil
+    }
+
+    private func advanceNativeTextMutationGeneration() {
+        nativeTextMutationGeneration &+= 1
+        clearNativeTextMutationAfterBlurWindow()
+    }
+
+    func resetPendingNativeTextMutationState() {
+        pendingNativeTextMutation = nil
+        nativeTextMutationCommitScheduled = false
+        advanceNativeTextMutationGeneration()
+    }
+
+    @discardableResult
+    func cancelExternalTextCompositionForLifecycleIfNeeded() -> String? {
+        finishExternalTextComposition(
+            cause: "lifecycle",
+            finalText: nil,
+            cancel: true
+        )?.resultJSON
+    }
+
+    func discardTransientNativeInputForEditorReset() {
+        _ = finishExternalTextComposition(cause: "documentChange", finalText: nil, cancel: true)
+        deferredInsertTexts.removeAll()
+        deferredInsertDrainScheduled = false
+        isReplayingDeferredInsertText = false
+        resetPendingNativeTextMutationState()
+        clearPendingInputTraitRetry()
+        performTransientTextMutation {
+            super.unmarkText()
+        }
+        clearMarkedTextTracking()
+    }
+
+    @discardableResult
+    func discardTransientNativeInputForEditorRebind() -> String? {
+        localTextDragState = .idle
+        let externalCompositionResultJSON =
+            cancelExternalTextCompositionForLifecycleIfNeeded()
+        deferredInsertTexts.removeAll()
+        deferredInsertDrainScheduled = false
+        isReplayingDeferredInsertText = false
+        resetPendingNativeTextMutationState()
+        lastAuthorizedSelectedUtf16Range = nil
+        lastAuthorizedSelectionIsBackward = false
+        logicalSelectionScalarRange = nil
+        logicalSelectionUtf16Range = nil
+        clearPendingInputTraitRetry()
+        markedTextReplacementScalarRange = nil
+        markedTextReplacementUtf16Range = nil
+        markedTextCompositionText = nil
+        markedTextCompositionIsExplicitlyEmpty = false
+        isComposing = false
+        return externalCompositionResultJSON
+    }
+
+    @discardableResult
+    func flushPendingNativeTextMutationCommitIfNeeded() -> Bool {
+        drainPendingNativeTextMutation(
+            allowAfterBlur: false,
+            allowWhileIntercepting: true
+        ).ready
+    }
+
+    struct ExternalEditorUpdatePreparation {
+        let ready: Bool
+        /// When preflight committed local UIKit state, the adapter already
+        /// rendered and adopted this current atomic update. Reuse it instead
+        /// of reading Rust again for the same external update operation.
+        let adoptedUpdateJSON: String?
+    }
+
+    private struct ActiveCompositionPreparation {
+        let ready: Bool
+        let adoptedUpdateJSON: String?
+    }
+
+    @discardableResult
+    func prepareForExternalEditorUpdate() -> Bool {
+        prepareForExternalEditorUpdateResult().ready
+    }
+
+    func prepareForExternalEditorUpdateResult() -> ExternalEditorUpdatePreparation {
+        let composition = prepareActiveCompositionForExternalMutation()
+        guard composition.ready else {
+            return ExternalEditorUpdatePreparation(ready: false, adoptedUpdateJSON: nil)
+        }
+        let nativeMutation = drainPendingNativeTextMutation(
+            allowAfterBlur: true,
+            allowWhileIntercepting: true
+        )
+        return ExternalEditorUpdatePreparation(
+            ready: nativeMutation.ready,
+            adoptedUpdateJSON: composition.adoptedUpdateJSON ?? nativeMutation.adoptedUpdateJSON
+        )
+    }
+
+    struct ExternalEditorCommandPreparation {
+        let ready: Bool
+        let updateJSON: String?
+        let blockedReason: String?
+    }
+
+    @discardableResult
+    func prepareForExternalEditorCommand() -> ExternalEditorCommandPreparation {
+        let previousEditorId = editorId
+        let previousAuthorizedText = lastAuthorizedText
+        let previousStateJSON = previousEditorId != 0 ? EditorV2Shadow.getCurrentState(id: previousEditorId) : nil
+        let preparation = prepareForExternalEditorUpdateResult()
+        guard preparation.ready else {
+            return ExternalEditorCommandPreparation(ready: false, updateJSON: nil, blockedReason: "composition")
+        }
+        guard editorId != 0 else {
+            return ExternalEditorCommandPreparation(ready: true, updateJSON: nil, blockedReason: nil)
+        }
+        if let adoptedUpdateJSON = preparation.adoptedUpdateJSON {
+            return ExternalEditorCommandPreparation(ready: true, updateJSON: adoptedUpdateJSON, blockedReason: nil)
+        }
+        let currentStateJSON = EditorV2Shadow.getCurrentState(id: editorId)
+        guard lastAuthorizedText != previousAuthorizedText
+            || previousEditorId != editorId
+            || previousStateJSON != currentStateJSON
+        else {
+            return ExternalEditorCommandPreparation(ready: true, updateJSON: nil, blockedReason: nil)
+        }
+        return ExternalEditorCommandPreparation(ready: true, updateJSON: currentStateJSON, blockedReason: nil)
+    }
+
+    private func prepareActiveCompositionForExternalMutation() -> ActiveCompositionPreparation {
+        if externalTextComposition != nil {
+            guard let finished = finishExternalTextComposition(
+                cause: "documentChange",
+                finalText: nil,
+                cancel: false
+            ) else {
+                return ActiveCompositionPreparation(ready: false, adoptedUpdateJSON: nil)
+            }
+            return ActiveCompositionPreparation(
+                ready: finished.succeeded,
+                adoptedUpdateJSON: finished.adoptedUpdateJSON
+            )
+        }
+        guard isComposing else {
+            return ActiveCompositionPreparation(ready: true, adoptedUpdateJSON: nil)
+        }
+
+        let composedText = validatedTrackedMarkedTextForCommit()
+        let replacementRange = trackedMarkedTextReplacementRange()
+        finishTransientMarkedTextMutation()
+
+        guard shouldCommitMarkedText(composedText, replacementRange: replacementRange) else {
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+            return ActiveCompositionPreparation(ready: false, adoptedUpdateJSON: nil)
+        }
+
+        return ActiveCompositionPreparation(
+            ready: true,
+            adoptedUpdateJSON: commitMarkedText(composedText ?? "", replacementRange: replacementRange)
+        )
+    }
+
+    @discardableResult
+    func drainPendingNativeTextMutation(
+        allowAfterBlur: Bool,
+        allowWhileIntercepting: Bool
+    ) -> NativeTextMutationDrainResult {
+        if reconciliationWorkScheduled, textStorage.string != lastAuthorizedText {
+            let adoptedUpdateJSON = restoreRejectedNativeTextMutation()
+            return NativeTextMutationDrainResult(
+                ready: textStorage.string == lastAuthorizedText,
+                adoptedUpdateJSON: adoptedUpdateJSON
+            )
+        }
+        guard nativeTextMutationCommitScheduled
+            || pendingNativeTextMutation != nil
+            || (!isComposing && markedTextRange == nil && textStorage.string != lastAuthorizedText)
+        else {
+            return NativeTextMutationDrainResult(ready: true, adoptedUpdateJSON: nil)
+        }
+
+        nativeTextMutationCommitScheduled = false
+        let currentText = textStorage.string
+        let mutation: NativeTextMutation?
+        if let pendingNativeTextMutation,
+           pendingNativeTextMutation.resultingText == currentText,
+           pendingNativeTextMutation.authorizedText == lastAuthorizedText {
+            mutation = nativeTextMutationWithCurrentSelection(pendingNativeTextMutation)
+        } else {
+            mutation = nativeTextMutationFromAuthorizedDiff(currentText: currentText)
+        }
+
+        guard let mutation else {
+            pendingNativeTextMutation = nil
+            return NativeTextMutationDrainResult(ready: true, adoptedUpdateJSON: nil)
+        }
+
+        switch commitNativeTextMutationIfPossible(
+            mutation,
+            allowAfterBlur: allowAfterBlur,
+            allowWhileIntercepting: allowWhileIntercepting
+        ) {
+        case .committed(let adoptedUpdateJSON):
+            pendingNativeTextMutation = nil
+            return NativeTextMutationDrainResult(ready: true, adoptedUpdateJSON: adoptedUpdateJSON)
+        case .rejected:
+            pendingNativeTextMutation = nil
+            let adoptedUpdateJSON = restoreRejectedNativeTextMutation()
+            return NativeTextMutationDrainResult(
+                ready: textStorage.string == lastAuthorizedText,
+                adoptedUpdateJSON: adoptedUpdateJSON
+            )
+        case .deferred:
+            pendingNativeTextMutation = mutation
+            return NativeTextMutationDrainResult(ready: false, adoptedUpdateJSON: nil)
+        }
+    }
+
+    private func restoreRejectedNativeTextMutation() -> String? {
+        guard editorId != 0, textStorage.string != lastAuthorizedText else { return nil }
+        reconciliationWorkScheduled = false
+        let updateJSON = EditorV2Shadow.getCurrentState(id: editorId)
+        return applyUpdateJSON(updateJSON) ? updateJSON : nil
+    }
+
+    func scheduleNativeTextMutationCommit(_ mutation: NativeTextMutation) {
+        pendingNativeTextMutation = mutation
+        guard !nativeTextMutationCommitScheduled else { return }
+
+        nativeTextMutationCommitScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            _ = self.drainPendingNativeTextMutation(
+                allowAfterBlur: true,
+                allowWhileIntercepting: true
+            )
+        }
+    }
+
+    @discardableResult
+    func commitNativeTextMutationIfPossible(
+        _ mutation: NativeTextMutation,
+        allowAfterBlur: Bool,
+        allowWhileIntercepting: Bool
+    ) -> NativeTextMutationCommitResult {
+        guard editorId != 0 else {
+            return .rejected
+        }
+
+        guard !isApplyingRustState,
+              !isInterceptingInput || allowWhileIntercepting,
+              !isComposing
+        else {
+            return .deferred
+        }
+
+        guard shouldAdoptNativeTextStorageMutation(mutation, allowAfterBlur: allowAfterBlur) else {
+            if textStorage.string != lastAuthorizedText {
+                scheduleReconciliationFromRust()
+            }
+            return .rejected
+        }
+
+        guard textStorage.string == mutation.resultingText else {
+            if let refreshedMutation = nativeTextMutationFromAuthorizedDiff(currentText: textStorage.string) {
+                return commitNativeTextMutationIfPossible(
+                    refreshedMutation,
+                    allowAfterBlur: allowAfterBlur,
+                    allowWhileIntercepting: allowWhileIntercepting
+                )
+            }
+            return .rejected
+        }
+
+        guard mutation.authorizedText == lastAuthorizedText else {
+            if let refreshedMutation = nativeTextMutationFromAuthorizedDiff(currentText: textStorage.string) {
+                return commitNativeTextMutationIfPossible(
+                    refreshedMutation,
+                    allowAfterBlur: allowAfterBlur,
+                    allowWhileIntercepting: allowWhileIntercepting
+                )
+            }
+            return .rejected
+        }
+
+        var adoptedUpdateJSON: String?
+        performInterceptedInput(flushPendingNativeTextMutation: false) {
+            guard let adapter = EditorV2Registry.adapter(forLegacyId: editorId) else { return }
+            let postSelection: (anchor: UInt32, head: UInt32)?
+            if let anchor = mutation.selectionAnchor,
+               let head = mutation.selectionHead {
+                postSelection = (anchor: anchor, head: head)
+            } else {
+                postSelection = nil
+            }
+            adoptedUpdateJSON = adapter.commitNativeTextMutation(
+                from: mutation.from,
+                to: mutation.to,
+                with: mutation.replacementText,
+                postSelection: postSelection
+            )
+            guard let adoptedUpdateJSON else { return }
+            applyUpdateJSON(adoptedUpdateJSON)
+            notifyDelegateOfAuthoritativeTextSelection()
+        }
+        guard let adoptedUpdateJSON else { return .rejected }
+        if mutation.capturedAfterBlur {
+            clearNativeTextMutationAfterBlurWindow()
+        }
+        return .committed(adoptedUpdateJSON: adoptedUpdateJSON)
+    }
+
+    private func notifyDelegateOfAuthoritativeTextSelection() {
+        guard editorId != 0,
+              let selection = logicalSelectionScalarRange
+        else {
+            return
+        }
+        let docAnchor = EditorV2Shadow.scalarToDoc(id: editorId, scalar: selection.anchor)
+        let docHead = EditorV2Shadow.scalarToDoc(id: editorId, scalar: selection.head)
+        editorDelegate?.editorTextView(self, selectionDidChange: docAnchor, head: docHead)
+    }
+
+}