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

package/ios/EditorTextView+KeyboardInput.swift

@@ -0,0 +1,318 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    @objc func handleIndentKeyCommand() {
+        handleListDepthKeyCommand(outdent: false)
+    }
+
+    @objc func handleHardBreakKeyCommand() {
+        guard !isApplyingRustState, editorId != 0, isEditable else { return }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return }
+        guard flushPendingNativeTextMutationCommitIfNeeded() else { return }
+        guard !isCollapsedAtomBoundary(selectedUtf16Range()) else { return }
+        performInterceptedInput {
+            insertNodeInRust(preferredHardBreakNodeType())
+        }
+    }
+
+    @objc func handleOutdentKeyCommand() {
+        handleListDepthKeyCommand(outdent: true)
+    }
+
+    func adjacentVoidBlockDeleteRangeForBackwardDelete(
+        cursorUtf16Offset: Int,
+        cursorScalar: UInt32
+    ) -> (from: UInt32, to: UInt32)? {
+        guard cursorUtf16Offset >= 0, cursorUtf16Offset < textStorage.length else {
+            return nil
+        }
+        let attrs = textStorage.attributes(at: cursorUtf16Offset, effectiveRange: nil)
+        guard attrs[.attachment] is NSTextAttachment,
+              attrs[RenderBridgeAttributes.voidNodeType] is String,
+              cursorScalar < UInt32.max
+        else {
+            return nil
+        }
+        return (from: cursorScalar, to: cursorScalar + 1)
+    }
+
+    func trailingVoidBlockDeleteRangeForBackwardDelete(
+        cursorUtf16Offset: Int
+    ) -> (from: UInt32, to: UInt32)? {
+        let text = textStorage.string as NSString
+        guard text.length > 0 else { return nil }
+
+        let clampedCursor = min(max(cursorUtf16Offset, 0), text.length)
+        let paragraphProbe = min(max(clampedCursor - 1, 0), text.length - 1)
+        let paragraphRange = text.paragraphRange(for: NSRange(location: paragraphProbe, length: 0))
+
+        let placeholderRange = NSRange(location: paragraphRange.location, length: 1)
+        guard placeholderRange.location + placeholderRange.length <= text.length else {
+            return nil
+        }
+
+        let paragraphText = text.substring(with: placeholderRange)
+        guard paragraphText == "\u{200B}" else { return nil }
+        guard paragraphRange.location >= 2 else { return nil }
+        guard text.character(at: paragraphRange.location - 1) == 0x000A else { return nil }
+
+        let attachmentIndex = paragraphRange.location - 2
+        guard
+            let deleteRange = scalarDeleteRangeForVoidAttachment(at: attachmentIndex)
+        else {
+            return nil
+        }
+
+        return deleteRange
+    }
+
+    private func scalarDeleteRangeForVoidAttachment(
+        at utf16Offset: Int
+    ) -> (from: UInt32, to: UInt32)? {
+        guard utf16Offset >= 0, utf16Offset < textStorage.length else {
+            return nil
+        }
+        let attrs = textStorage.attributes(at: utf16Offset, effectiveRange: nil)
+        guard let attachment = attrs[.attachment] as? NSTextAttachment,
+              !(attachment is AtomBlockAttachment),
+              attrs[RenderBridgeAttributes.voidNodeType] is String
+        else {
+            return nil
+        }
+
+        let attachmentEndScalar = PositionBridge.utf16OffsetToScalar(
+            utf16Offset + 1,
+            in: self
+        )
+        guard attachmentEndScalar > 0 else { return nil }
+        return (from: attachmentEndScalar - 1, to: attachmentEndScalar)
+    }
+
+    private func handleListDepthKeyCommand(outdent: Bool) {
+        guard !isApplyingRustState else { return }
+        guard editorId != 0 else { return }
+        guard isEditable else { return }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return }
+        guard flushPendingNativeTextMutationCommitIfNeeded() else { return }
+        guard isCaretInsideList() else { return }
+        guard let selection = currentScalarSelection() else { return }
+
+        performInterceptedInput {
+            let updateJSON = outdent
+                ? EditorV2Shadow.outdentListItemAtSelectionScalar(
+                    id: editorId,
+                    scalarAnchor: selection.anchor,
+                    scalarHead: selection.head
+                )
+                : EditorV2Shadow.indentListItemAtSelectionScalar(
+                    id: editorId,
+                    scalarAnchor: selection.anchor,
+                    scalarHead: selection.head
+                )
+            applyUpdateJSON(updateJSON)
+        }
+    }
+
+    private func isCaretInsideList() -> Bool {
+        guard editorId != 0 else { return false }
+        guard
+            let data = EditorV2Shadow.getCurrentState(id: editorId).data(using: .utf8),
+            let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            let activeState = object["activeState"] as? [String: Any],
+            let nodes = activeState["nodes"] as? [String: Any]
+        else {
+            return false
+        }
+
+        return nodes.contains { nodeType, value in
+            EditorNodeTypes.isListContainer(nodeType) && value as? Bool == true
+        }
+    }
+
+    private func preferredHardBreakNodeType() -> String {
+        guard
+            let data = EditorV2Shadow.getCurrentState(id: editorId).data(using: .utf8),
+            let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            let activeState = object["activeState"] as? [String: Any],
+            let insertableNodes = activeState["insertableNodes"] as? [String]
+        else {
+            return "hardBreak"
+        }
+
+        return EditorNodeTypes.preferredHardBreak(in: Set(insertableNodes))
+    }
+
+    func ensureInternalTextViewDelegate() {
+        // Some keyboard integrations replace UITextView's private delegate ivar
+        // directly. The editor must own delegate callbacks so external observers
+        // cannot inspect transient TextKit state during Rust-driven edits.
+        // The delegate is a dedicated object rather than the text view itself;
+        // see EditorTextViewInternalDelegate for why (APOLLO-REACT-56).
+        guard (delegate as AnyObject?) !== internalTextViewDelegate else { return }
+        delegate = internalTextViewDelegate
+    }
+
+    func performInterceptedInput(
+        flushPendingNativeTextMutation: Bool = true,
+        _ action: () -> Void
+    ) {
+        if flushPendingNativeTextMutation, interceptedInputDepth == 0 {
+            guard flushPendingNativeTextMutationCommitIfNeeded() else { return }
+        }
+        interceptedInputDepth += 1
+        Self.inputLog.debug(
+            "[intercept.begin] depth=\(self.interceptedInputDepth) selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
+        )
+        action()
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.interceptedInputDepth = max(0, self.interceptedInputDepth - 1)
+            Self.inputLog.debug(
+                "[intercept.end] depth=\(self.interceptedInputDepth) selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
+            )
+            if self.interceptedInputDepth == 0 {
+                _ = self.drainPendingNativeTextMutation(
+                    allowAfterBlur: false,
+                    allowWhileIntercepting: false
+                )
+                self.drainDeferredInsertTextIfReady()
+            }
+        }
+    }
+
+    func enqueueDeferredInsertText(_ text: String) {
+        deferredInsertTexts.append(text)
+        scheduleDeferredInsertDrain()
+    }
+
+    private func scheduleDeferredInsertDrain() {
+        guard !deferredInsertDrainScheduled else { return }
+        deferredInsertDrainScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            self?.drainDeferredInsertTextIfReady()
+        }
+    }
+
+    private func drainDeferredInsertTextIfReady() {
+        deferredInsertDrainScheduled = false
+        guard !deferredInsertTexts.isEmpty else { return }
+        guard editorId != 0 else {
+            deferredInsertTexts.removeAll()
+            return
+        }
+        guard !isApplyingRustState,
+              interceptedInputDepth == 0,
+              pendingNativeTextMutation == nil,
+              !nativeTextMutationCommitScheduled
+        else {
+            scheduleDeferredInsertDrain()
+            return
+        }
+
+        let text = deferredInsertTexts.removeFirst()
+        isReplayingDeferredInsertText = true
+        defer { isReplayingDeferredInsertText = false }
+        insertText(text)
+        if !deferredInsertTexts.isEmpty {
+            scheduleDeferredInsertDrain()
+        }
+    }
+
+    /// Handle return key press as a block split operation.
+    private func handleReturnKey() {
+        if let selectedRange = selectedTextRange, !selectedRange.isEmpty {
+            let range = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+            let updateJSON = EditorV2Shadow.deleteAndSplitScalar(
+                id: editorId,
+                scalarFrom: range.from,
+                scalarTo: range.to
+            )
+            applyUpdateJSON(updateJSON)
+        } else {
+            let scalarPos = PositionBridge.cursorScalarOffset(in: self)
+            splitBlockInRust(at: scalarPos)
+        }
+    }
+
+    func interceptReturnInput(
+        _ text: String,
+        replacing replacementRange: UITextRange? = nil
+    ) -> Bool {
+        guard text == "\n" || text == "\r" else { return false }
+        let scalarRange = replacementRange.map {
+            PositionBridge.textRangeToScalarRange($0, in: self)
+        }
+        guard commitActiveMarkedTextBeforeReturn() else { return true }
+        performInterceptedInput {
+            if let scalarRange {
+                if scalarRange.from == scalarRange.to {
+                    splitBlockInRust(at: scalarRange.from)
+                } else {
+                    let updateJSON = EditorV2Shadow.deleteAndSplitScalar(
+                        id: editorId,
+                        scalarFrom: scalarRange.from,
+                        scalarTo: scalarRange.to
+                    )
+                    applyUpdateJSON(updateJSON)
+                }
+            } else {
+                handleReturnKey()
+            }
+        }
+        return true
+    }
+
+    /// Split a block at a scalar position via the Rust editor.
+    private func splitBlockInRust(at scalarPos: UInt32) {
+        Self.inputLog.debug(
+            "[rust.splitBlockScalar] scalarPos=\(scalarPos) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.splitBlockScalar(id: editorId, scalarPos: scalarPos)
+        applyUpdateJSON(updateJSON)
+    }
+
+    /// Paste HTML content through Rust.
+    @discardableResult
+    func pasteHTML(_ html: String, detectContentChange: Bool = false) -> Bool {
+        let previousHTML = detectContentChange ? EditorV2Shadow.getHtml(id: editorId) : nil
+        syncCurrentUIKitSelectionToRust()
+        Self.inputLog.debug(
+            "[rust.pasteHTML] html=\(self.preview(html), privacy: .public) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = EditorV2Shadow.insertContentHtml(id: editorId, html: html)
+        applyUpdateJSON(updateJSON)
+        guard let previousHTML else { return true }
+        return EditorV2Shadow.getHtml(id: editorId) != previousHTML
+    }
+
+    private func syncCurrentUIKitSelectionToRust() {
+        guard editorId != 0, let range = selectedTextRange else { return }
+        let anchor = PositionBridge.textViewToScalar(range.start, in: self)
+        let head = PositionBridge.textViewToScalar(range.end, in: self)
+        EditorV2Shadow.setSelectionScalar(id: editorId, scalarAnchor: anchor, scalarHead: head)
+    }
+
+    /// Paste plain text through Rust.
+    func pastePlainText(_ text: String) {
+        if let selectedRange = selectedTextRange, !selectedRange.isEmpty {
+            let range = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+            Self.inputLog.debug(
+                "[rust.pastePlainText.replace] text=\(self.preview(text), privacy: .public) scalar=\(range.from)-\(range.to) selection=\(self.selectionSummary(), privacy: .public)"
+            )
+            let updateJSON = EditorV2Shadow.replaceTextScalar(
+                id: editorId,
+                scalarFrom: range.from,
+                scalarTo: range.to,
+                text: text
+            )
+            applyUpdateJSON(updateJSON)
+        } else {
+            Self.inputLog.debug(
+                "[rust.pastePlainText.insert] text=\(self.preview(text), privacy: .public) selection=\(self.selectionSummary(), privacy: .public)"
+            )
+            insertTextInRust(text, at: PositionBridge.cursorScalarOffset(in: self))
+        }
+    }
+
+}

package/ios/EditorTextView+Layout.swift

@@ -0,0 +1,245 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    @objc func handleKeyboardFrameChange(_ notification: Notification) {
+        guard isFirstResponder || keyboardFrameInScreen != nil else { return }
+        if notification.name == UIResponder.keyboardWillHideNotification {
+            keyboardFrameInScreen = nil
+        } else {
+            keyboardFrameInScreen = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
+        }
+        let duration = (notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
+        let curve = (notification.userInfo?[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber)?.uintValue ?? 0
+        UIView.animate(
+            withDuration: duration,
+            delay: 0,
+            options: [UIView.AnimationOptions(rawValue: curve << 16), .beginFromCurrentState]
+        ) {
+            self.updateKeyboardInset()
+        }
+    }
+
+    func updateKeyboardInset() {
+        var overlap: CGFloat = 0
+        if isScrollEnabled, let window, let keyboardFrameInScreen {
+            let frameInWindow = window.convert(keyboardFrameInScreen, from: window.screen.coordinateSpace)
+            let keyboardFrame = convert(frameInWindow, from: window)
+            let intersection = bounds.intersection(keyboardFrame)
+            if !intersection.isNull, intersection.maxY >= bounds.maxY - 1 {
+                overlap = intersection.height
+            }
+        }
+        let baseBottomInset = contentInset.bottom - keyboardBottomInset
+        let automaticBottomInset = adjustedContentInset.bottom - contentInset.bottom
+        let nextInset = max(0, overlap - automaticBottomInset - baseBottomInset)
+        guard abs(nextInset - keyboardBottomInset) > 0.5 else { return }
+        let delta = nextInset - keyboardBottomInset
+        keyboardBottomInset = nextInset
+        contentInset.bottom += delta
+        verticalScrollIndicatorInsets.bottom += delta
+        if overlap > 0, isFirstResponder, let selection = selectedTextRange {
+            let caret = caretRect(for: selection.end)
+            if !caret.isEmpty {
+                scrollRectToVisible(caret.insetBy(dx: 0, dy: -8), animated: false)
+            }
+        }
+    }
+
+    /// Whether the document holds nothing the user authored.
+    ///
+    /// Taken verbatim from the core. Deriving it cannot work: an empty list
+    /// item contributes no characters, so scanning the storage reports empty
+    /// and leaves the placeholder over a visible bullet. The scan below is
+    /// only the fallback for renders with no editor update (the viewer).
+    private func isRenderedContentEmpty() -> Bool {
+        if let coreReportedDocumentIsEmpty {
+            return coreReportedDocumentIsEmpty
+        }
+
+        let renderedText = textStorage.string
+        guard !renderedText.isEmpty else { return true }
+
+        for scalar in renderedText.unicodeScalars {
+            switch scalar {
+            case Self.emptyBlockPlaceholderScalar, "\n", "\r":
+                continue
+            default:
+                return false
+            }
+        }
+
+        return true
+    }
+
+    @discardableResult
+    func normalizeSelectionForEmptyBlockAutocapitalizationIfNeeded() -> Bool {
+        guard textStorage.length == 1 else { return false }
+        guard textStorage.string.unicodeScalars.elementsEqual([Self.emptyBlockPlaceholderScalar]) else {
+            return false
+        }
+
+        let currentRange = selectedRange
+        guard currentRange.location != NSNotFound, currentRange.length == 0 else { return false }
+        guard currentRange.location == textStorage.length else { return false }
+
+        let adjustedRange = NSRange(location: 0, length: 0)
+        guard currentRange != adjustedRange else { return false }
+        selectedRange = adjustedRange
+        noteSelectionDidChange()
+        return true
+    }
+
+    func refreshPlaceholderVisibility() {
+        let hasProvisionalText = externalTextComposition?.latestText.isEmpty == false
+        placeholderLabel.isHidden = placeholder.isEmpty
+            || hasProvisionalText
+            || !isRenderedContentEmpty()
+    }
+
+    func preserveScrollOffset(_ previousOffset: CGPoint) {
+        let restore = { [weak self] in
+            guard let self else { return }
+            self.layoutIfNeeded()
+
+            let maxOffsetX = max(
+                -self.adjustedContentInset.left,
+                self.contentSize.width - self.bounds.width + self.adjustedContentInset.right
+            )
+            let maxOffsetY = max(
+                -self.adjustedContentInset.top,
+                self.contentSize.height - self.bounds.height + self.adjustedContentInset.bottom
+            )
+
+            let clampedOffset = CGPoint(
+                x: min(max(previousOffset.x, -self.adjustedContentInset.left), maxOffsetX),
+                y: min(max(previousOffset.y, -self.adjustedContentInset.top), maxOffsetY)
+            )
+            self.setContentOffset(clampedOffset, animated: false)
+        }
+
+        restore()
+        DispatchQueue.main.async(execute: restore)
+    }
+
+    func defaultTypingAttributes() -> [NSAttributedString.Key: Any] {
+        [
+            .font: resolvedDefaultFont(),
+            .foregroundColor: resolvedDefaultTextColor()
+        ]
+    }
+
+    func resolvedDefaultFont() -> UIFont {
+        theme?.effectiveTextStyle(for: "paragraph").resolvedFont(fallback: baseFont)
+            ?? baseFont
+    }
+
+    func resolvedDefaultTextColor() -> UIColor {
+        theme?.effectiveTextStyle(for: "paragraph").color ?? baseTextColor
+    }
+
+    func notifyHeightChangeIfNeeded(force: Bool = false) {
+        guard heightBehavior == .autoGrow else { return }
+        let width = bounds.width > 0 ? bounds.width : UIScreen.main.bounds.width
+        guard width > 0 else { return }
+        if !force {
+            let measuredWidth = ceil(width)
+            if !autoGrowHeightCheckIsDirty && abs(measuredWidth - lastAutoGrowMeasuredWidth) <= 0.5 {
+                return
+            }
+        }
+        lastHeightNotifyEnsureLayoutNanosForTesting = 0
+        lastHeightNotifyUsedRectNanosForTesting = 0
+        lastHeightNotifyContentSizeNanosForTesting = 0
+        lastHeightNotifySizeThatFitsNanosForTesting = 0
+        let measurementStartedAt = DispatchTime.now().uptimeNanoseconds
+        let measuredHeight = measuredAutoGrowHeight(forWidth: width)
+        lastHeightNotifyMeasureNanosForTesting =
+            DispatchTime.now().uptimeNanoseconds - measurementStartedAt
+        autoGrowHeightCheckIsDirty = false
+        lastAutoGrowMeasuredWidth = ceil(width)
+        guard force || abs(measuredHeight - lastAutoGrowMeasuredHeight) > 0.5 else { return }
+        lastAutoGrowMeasuredHeight = measuredHeight
+        let callbackStartedAt = DispatchTime.now().uptimeNanoseconds
+        onHeightMayChange?(measuredHeight)
+        lastHeightNotifyCallbackNanosForTesting =
+            DispatchTime.now().uptimeNanoseconds - callbackStartedAt
+    }
+
+    func measuredAutoGrowHeight(forWidth width: CGFloat) -> CGFloat {
+        guard width > 0 else { return 0 }
+
+        if abs(bounds.width - width) <= 0.5 {
+            let currentHeight = ceil(bounds.height)
+            let ensureLayoutStartedAt = DispatchTime.now().uptimeNanoseconds
+            editorLayoutManager.ensureLayout(for: textContainer)
+            lastHeightNotifyEnsureLayoutNanosForTesting =
+                DispatchTime.now().uptimeNanoseconds - ensureLayoutStartedAt
+
+            let usedRectStartedAt = DispatchTime.now().uptimeNanoseconds
+            var usedRect = editorLayoutManager.usedRect(for: textContainer)
+            let extraLineFragmentRect = editorLayoutManager.extraLineFragmentRect
+            if !extraLineFragmentRect.isEmpty {
+                usedRect = usedRect.union(extraLineFragmentRect)
+            }
+            lastHeightNotifyUsedRectNanosForTesting =
+                DispatchTime.now().uptimeNanoseconds - usedRectStartedAt
+            let layoutHeight = ceil(
+                usedRect.height
+                    + textContainerInset.top
+                    + textContainerInset.bottom
+            )
+
+            let contentSizeStartedAt = DispatchTime.now().uptimeNanoseconds
+            let contentHeight = ceil(contentSize.height)
+            lastHeightNotifyContentSizeNanosForTesting =
+                DispatchTime.now().uptimeNanoseconds - contentSizeStartedAt
+            if currentHeight > 0 {
+                if layoutHeight > currentHeight + 0.5 {
+                    return layoutHeight
+                }
+                let hostIsTrackingMeasuredHeight =
+                    autoGrowHostHeight > 0
+                        && abs(currentHeight - ceil(autoGrowHostHeight)) <= 1.0
+                guard hostIsTrackingMeasuredHeight else {
+                    return layoutHeight
+                }
+                let measuredFromLayout = max(layoutHeight, contentHeight)
+                if measuredFromLayout > currentHeight + 0.5 {
+                    return measuredFromLayout
+                }
+                let sizeThatFitsStartedAt = DispatchTime.now().uptimeNanoseconds
+                let fittedHeight = ceil(
+                    sizeThatFits(
+                        CGSize(width: width, height: CGFloat.greatestFiniteMagnitude)
+                    ).height
+                )
+                lastHeightNotifySizeThatFitsNanosForTesting =
+                    DispatchTime.now().uptimeNanoseconds - sizeThatFitsStartedAt
+                if fittedHeight > currentHeight + 0.5 {
+                    return max(measuredFromLayout, fittedHeight)
+                }
+                return layoutHeight
+            }
+            return max(layoutHeight, contentHeight)
+        }
+
+        let sizeThatFitsStartedAt = DispatchTime.now().uptimeNanoseconds
+        let fittedHeight = ceil(
+            sizeThatFits(CGSize(width: width, height: CGFloat.greatestFiniteMagnitude)).height
+        )
+        lastHeightNotifySizeThatFitsNanosForTesting =
+            DispatchTime.now().uptimeNanoseconds - sizeThatFitsStartedAt
+        return fittedHeight
+    }
+
+    func updateAutoGrowHostHeight(_ height: CGFloat) {
+        autoGrowHostHeight = max(0, ceil(height))
+    }
+
+    func invalidateAutoGrowHeightMeasurement() {
+        autoGrowHeightCheckIsDirty = true
+        lastAutoGrowMeasuredWidth = 0
+    }
+
+}