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

package/ios/EditorTextView+Commands.swift

@@ -0,0 +1,203 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    func performToolbarToggleMark(_ markName: String) {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.toggleMarkAtSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head,
+                markName: markName
+            )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarToggleList(_ listType: String, isActive: Bool) {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        performInterceptedInput {
+            let updateJSON = isActive
+                ? EditorV2Shadow.unwrapFromListAtSelectionScalar(
+                    id: editorId,
+                    scalarAnchor: selection.anchor,
+                    scalarHead: selection.head
+                )
+                : EditorV2Shadow.wrapInListAtSelectionScalar(
+                    id: editorId,
+                    scalarAnchor: selection.anchor,
+                    scalarHead: selection.head,
+                    listType: listType
+                )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarToggleBlockquote() {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.toggleBlockquoteAtSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head
+            )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarToggleHeading(_ level: Int) {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        guard let level = UInt8(exactly: level), (1...6).contains(level) else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.toggleHeadingAtSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head,
+                level: level
+            )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarIndentListItem() {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.indentListItemAtSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head
+            )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarOutdentListItem() {
+        guard prepareForToolbarCommand() else { return }
+        guard let selection = currentScalarSelection() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.outdentListItemAtSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head
+            )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarInsertNode(_ nodeType: String) {
+        guard prepareForToolbarCommand() else { return }
+        performInterceptedInput {
+            insertNodeInRust(nodeType)
+        }
+    }
+
+    func performToolbarUndo() {
+        guard prepareForToolbarCommand() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.undo(id: editorId)
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    func performToolbarRedo() {
+        guard prepareForToolbarCommand() else { return }
+        performInterceptedInput {
+            let updateJSON = EditorV2Shadow.redo(id: editorId)
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    private func prepareForToolbarCommand() -> Bool {
+        guard editorId != 0 else { return false }
+        guard isEditable else { return false }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return false }
+        return prepareForExternalEditorUpdate()
+    }
+
+    /// Insert text at a scalar position via the Rust editor.
+    func insertTextInRust(_ text: String, at scalarPos: UInt32) {
+        Self.inputLog.debug(
+            "[rust.insertTextScalar] text=\(self.preview(text), privacy: .public) scalarPos=\(scalarPos) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.insertTextScalar(id: editorId, scalarPos: scalarPos, text: text)
+        applyUpdateJSON(updateJSON)
+    }
+
+    private func replaceTextRangeInRust(from: UInt32, to: UInt32, with text: String) {
+        Self.inputLog.debug(
+            "[rust.replaceTextScalar] text=\(self.preview(text), privacy: .public) scalar=\(from)-\(to) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.replaceTextScalar(
+            id: editorId,
+            scalarFrom: from,
+            scalarTo: to,
+            text: text
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
+    func insertNodeInRust(_ nodeType: String) {
+        guard let selection = currentScalarSelection() else { return }
+        Self.inputLog.debug(
+            "[rust.insertNode] nodeType=\(nodeType, privacy: .public) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.insertNodeAtSelectionScalar(
+            id: editorId,
+            scalarAnchor: selection.anchor,
+            scalarHead: selection.head,
+            nodeType: nodeType
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
+    /// Delete a scalar range via the Rust editor.
+    func deleteScalarRangeInRust(from: UInt32, to: UInt32) {
+        guard from < to else { return }
+        Self.inputLog.debug(
+            "[rust.deleteScalarRange] scalar=\(from)-\(to) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.deleteScalarRange(id: editorId, scalarFrom: from, scalarTo: to)
+        applyUpdateJSON(updateJSON)
+    }
+
+    func deleteBackwardAtSelectionScalarInRust(anchor: UInt32, head: UInt32) {
+        Self.inputLog.debug(
+            "[rust.deleteBackwardAtSelectionScalar] scalar=\(anchor)-\(head) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.deleteBackwardAtSelectionScalar(
+            id: editorId,
+            scalarAnchor: anchor,
+            scalarHead: head
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
+    func toggleTaskItemCheckedAtSelectionScalarInRust(anchor: UInt32, head: UInt32) {
+        Self.inputLog.debug(
+            "[rust.toggleTaskItemCheckedAtSelectionScalar] scalar=\(anchor)-\(head) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.toggleTaskItemCheckedAtSelectionScalar(
+            id: editorId,
+            scalarAnchor: anchor,
+            scalarHead: head
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
+    /// Delete a document-position range via the Rust editor.
+    private func deleteRangeInRust(from: UInt32, to: UInt32) {
+        guard from < to else { return }
+        Self.inputLog.debug(
+            "[rust.deleteRange] doc=\(from)-\(to) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.deleteRange(id: editorId, from: from, to: to)
+        applyUpdateJSON(updateJSON)
+    }
+
+}

package/ios/EditorTextView+Delegate.swift

@@ -0,0 +1,65 @@
+import UIKit
+
+// MARK: - EditorTextViewDelegate
+
+/// Delegate protocol for EditorTextView to communicate state changes
+/// back to the hosting view (Fabric component or UIKit container).
+protocol EditorTextViewDelegate: AnyObject {
+    /// Called when the editor's selection changes.
+    /// - Parameters:
+    ///   - textView: The editor text view.
+    ///   - anchor: Scalar offset of the selection anchor.
+    ///   - head: Scalar offset of the selection head.
+    func editorTextView(_ textView: EditorTextView, selectionDidChange anchor: UInt32, head: UInt32)
+
+    /// Called when the editor content is updated after a Rust operation.
+    /// - Parameters:
+    ///   - textView: The editor text view.
+    ///   - updateJSON: The full EditorUpdate JSON string from Rust.
+    func editorTextView(_ textView: EditorTextView, didReceiveUpdate updateJSON: String)
+
+    func editorTextView(_ textView: EditorTextView, didEndExternalTextComposition resultJSON: String)
+}
+
+extension EditorTextViewDelegate {
+    func editorTextView(_ textView: EditorTextView, didEndExternalTextComposition resultJSON: String) {}
+}
+
+// MARK: - EditorTextView
+
+/// Dedicated `UITextViewDelegate`, because the editor must not be its own.
+///
+/// Proxy keyboard integrations forward unimplemented selectors via
+/// `forwardingTarget(for:)`, so UIKit's private `keyboardInputChangedSelection:`
+/// bounces view -> proxy -> view until the stack overflows (APOLLO-REACT-56).
+/// A plain NSObject does not respond to those private selectors.
+final class EditorTextViewInternalDelegate: NSObject, UITextViewDelegate {
+    private weak var editor: EditorTextView?
+
+    init(editor: EditorTextView) {
+        self.editor = editor
+    }
+
+    func textViewDidChangeSelection(_ textView: UITextView) {
+        editor?.textViewDidChangeSelection(textView)
+    }
+
+    func textView(
+        _ textView: UITextView,
+        shouldInteractWith URL: URL,
+        in characterRange: NSRange,
+        interaction: UITextItemInteraction
+    ) -> Bool {
+        editor?.textView(textView, shouldInteractWith: URL, in: characterRange, interaction: interaction) ?? false
+    }
+
+    func textView(
+        _ textView: UITextView,
+        shouldInteractWith textAttachment: NSTextAttachment,
+        in characterRange: NSRange,
+        interaction: UITextItemInteraction
+    ) -> Bool {
+        editor?.textView(textView, shouldInteractWith: textAttachment, in: characterRange, interaction: interaction)
+            ?? false
+    }
+}

package/ios/EditorTextView+Diagnostics.swift

@@ -0,0 +1,225 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    struct ApplyUpdateTrace {
+        let attemptedPatch: Bool
+        let patchStartIndex: Int?
+        let patchDeleteCount: Int?
+        let patchRenderBlockCount: Int?
+        let usedPatch: Bool
+        let usedSmallPatchTextMutation: Bool
+        let applyRenderReplaceUtf16Length: Int
+        let applyRenderReplacementUtf16Length: Int
+        let parseNanos: UInt64
+        let resolveRenderBlocksNanos: UInt64
+        let patchEligibilityNanos: UInt64
+        let patchTrimNanos: UInt64
+        let patchMetadataNanos: UInt64
+        let buildRenderNanos: UInt64
+        let applyRenderNanos: UInt64
+        let selectionNanos: UInt64
+        let postApplyNanos: UInt64
+        let totalNanos: UInt64
+        let applyRenderTextMutationNanos: UInt64
+        let applyRenderBeginEditingNanos: UInt64
+        let applyRenderEndEditingNanos: UInt64
+        let applyRenderStringMutationNanos: UInt64
+        let applyRenderAttributeMutationNanos: UInt64
+        let applyRenderAuthorizedTextNanos: UInt64
+        let applyRenderCacheInvalidationNanos: UInt64
+        let selectionResolveNanos: UInt64
+        let selectionAssignmentNanos: UInt64
+        let selectionChromeNanos: UInt64
+        let postApplyTypingAttributesNanos: UInt64
+        let postApplyHeightNotifyNanos: UInt64
+        let postApplyHeightNotifyMeasureNanos: UInt64
+        let postApplyHeightNotifyCallbackNanos: UInt64
+        let postApplyHeightNotifyEnsureLayoutNanos: UInt64
+        let postApplyHeightNotifyUsedRectNanos: UInt64
+        let postApplyHeightNotifyContentSizeNanos: UInt64
+        let postApplyHeightNotifySizeThatFitsNanos: UInt64
+        let postApplySelectionOrContentCallbackNanos: UInt64
+    }
+
+    struct PatchApplyTrace {
+        let applied: Bool
+        let eligibilityNanos: UInt64
+        let trimNanos: UInt64
+        let metadataNanos: UInt64
+        let buildRenderNanos: UInt64
+        let applyRenderNanos: UInt64
+        let applyRenderReplaceUtf16Length: Int
+        let applyRenderReplacementUtf16Length: Int
+        let applyRenderTextMutationNanos: UInt64
+        let applyRenderBeginEditingNanos: UInt64
+        let applyRenderEndEditingNanos: UInt64
+        let applyRenderStringMutationNanos: UInt64
+        let applyRenderAttributeMutationNanos: UInt64
+        let applyRenderAuthorizedTextNanos: UInt64
+        let applyRenderCacheInvalidationNanos: UInt64
+        let usedSmallPatchTextMutation: Bool
+    }
+
+    struct ApplyRenderTrace {
+        let totalNanos: UInt64
+        let replaceUtf16Length: Int
+        let replacementUtf16Length: Int
+        let textMutationNanos: UInt64
+        let beginEditingNanos: UInt64
+        let endEditingNanos: UInt64
+        let stringMutationNanos: UInt64
+        let attributeMutationNanos: UInt64
+        let authorizedTextNanos: UInt64
+        let cacheInvalidationNanos: UInt64
+        let usedSmallPatchTextMutation: Bool
+    }
+
+    struct SelectionApplyTrace {
+        let totalNanos: UInt64
+        let resolveNanos: UInt64
+        let assignmentNanos: UInt64
+        let chromeNanos: UInt64
+    }
+
+    struct PostApplyTrace {
+        let totalNanos: UInt64
+        let typingAttributesNanos: UInt64
+        let heightNotifyNanos: UInt64
+        let heightNotifyMeasureNanos: UInt64
+        let heightNotifyCallbackNanos: UInt64
+        let heightNotifyEnsureLayoutNanos: UInt64
+        let heightNotifyUsedRectNanos: UInt64
+        let heightNotifyContentSizeNanos: UInt64
+        let heightNotifySizeThatFitsNanos: UInt64
+        let selectionOrContentCallbackNanos: UInt64
+    }
+
+    func isPlaceholderVisibleForTesting() -> Bool {
+        !placeholderLabel.isHidden
+    }
+
+    func placeholderFrameForTesting() -> CGRect {
+        placeholderLabel.frame
+    }
+
+    func lastRenderAppliedPatch() -> Bool {
+        lastRenderAppliedPatchForTesting
+    }
+
+    func authorizedTextForTesting() -> String {
+        lastAuthorizedText
+    }
+
+    func lastApplyUpdateTrace() -> ApplyUpdateTrace? {
+        lastApplyUpdateTraceForTesting
+    }
+
+    func isUsingInternalTextViewDelegateForTesting() -> Bool {
+        (delegate as AnyObject?) === internalTextViewDelegate
+    }
+
+    func blockquoteStripeRectsForTesting() -> [CGRect] {
+        editorLayoutManager.blockquoteStripeRectsForTesting(in: textStorage)
+    }
+
+    func resetBlockquoteStripeDrawPassesForTesting() {
+        editorLayoutManager.resetBlockquoteStripeDrawPassesForTesting()
+    }
+
+    func blockquoteStripeDrawPassesForTesting() -> [[CGRect]] {
+        editorLayoutManager.blockquoteStripeDrawPassesForTesting
+    }
+
+    func resetCodeBlockDrawPassesForTesting() {
+        editorLayoutManager.resetCodeBlockDrawPassesForTesting()
+    }
+
+    func codeBlockDrawPassesForTesting() -> [[CGRect]] {
+        editorLayoutManager.codeBlockDrawPassesForTesting
+    }
+
+    @discardableResult
+    func selectImageAttachmentForTesting(at location: CGPoint) -> Bool {
+        selectImageAttachmentIfNeeded(at: location)
+    }
+
+    func imageSelectionTapWouldHandleForTesting(at location: CGPoint) -> Bool {
+        imageAttachmentRange(at: location) != nil
+    }
+
+    func taskListMarkerParagraphStartForTesting(at location: CGPoint) -> Int? {
+        taskListMarkerParagraphStart(at: location)
+    }
+
+    func imageSelectionTapCancelsTouchesForTesting() -> Bool {
+        imageSelectionTapRecognizer.cancelsTouchesInView
+    }
+
+    func imageSelectionTapYieldsToDefaultTapForTesting() -> Bool {
+        gestureRecognizer(
+            imageSelectionTapRecognizer,
+            shouldBeRequiredToFailBy: UITapGestureRecognizer()
+        ) || gestureRecognizer(
+            imageSelectionTapRecognizer,
+            shouldRequireFailureOf: UITapGestureRecognizer()
+        )
+    }
+
+    func measuredAutoGrowHeightForTesting(width: CGFloat) -> CGFloat {
+        measuredAutoGrowHeight(forWidth: width)
+    }
+
+    func preview(_ text: String, limit: Int = 32) -> String {
+        let normalized = text.replacingOccurrences(of: "\n", with: "\\n")
+        if normalized.count <= limit {
+            return normalized
+        }
+        return "\(normalized.prefix(limit))…"
+    }
+
+    func textSnapshotSummary() -> String {
+        let text = textStorage.string
+        return "len=\(text.count) preview=\"\(preview(text))\""
+    }
+
+    func selectionSummary() -> String {
+        guard let range = selectedTextRange else { return "none" }
+        // The UTF-16 offsets are what UIKit actually holds; every scalar below
+        // is derived through the conversion table. Logging both is what tells
+        // a caret that moved apart from a table that changed under a caret
+        // that did not.
+        let anchorUtf16 = offset(from: beginningOfDocument, to: range.start)
+        let headUtf16 = offset(from: beginningOfDocument, to: range.end)
+        let anchorScalar = PositionBridge.textViewToScalar(range.start, in: self)
+        let headScalar = PositionBridge.textViewToScalar(range.end, in: self)
+        guard editorId != 0 else {
+            return "utf16=\(anchorUtf16)-\(headUtf16) scalar=\(anchorScalar)-\(headScalar)"
+        }
+        let docAnchor = EditorV2Shadow.scalarToDoc(id: editorId, scalar: anchorScalar)
+        let docHead = EditorV2Shadow.scalarToDoc(id: editorId, scalar: headScalar)
+        return "utf16=\(anchorUtf16)-\(headUtf16) scalar=\(anchorScalar)-\(headScalar) doc=\(docAnchor)-\(docHead)"
+    }
+
+    func selectionSummary(from selection: [String: Any]) -> String {
+        guard let type = selection["type"] as? String else { return "unknown" }
+        switch type {
+        case "text":
+            let anchor = v2ExactUInt32(selection["anchor"] as? NSNumber) ?? 0
+            let head = v2ExactUInt32(selection["head"] as? NSNumber) ?? 0
+            return "text doc=\(anchor)-\(head)"
+        case "node":
+            let pos = v2ExactUInt32(selection["pos"] as? NSNumber) ?? 0
+            return "node doc=\(pos)"
+        case "all":
+            return "all"
+        default:
+            return type
+        }
+    }
+
+    func expireNativeTextMutationAfterBlurDeadlineForTesting() {
+        nativeTextMutationAfterBlurDeadline = ProcessInfo.processInfo.systemUptime - 0.001
+    }
+
+}