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

package/ios/EditorTextView+AttributedPatch.swift

@@ -0,0 +1,305 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    func shouldUseSmallPatchTextMutation(
+        for attributedString: NSAttributedString,
+        replaceRange: NSRange?
+    ) -> Bool {
+        attributedString.length > 0
+            && attributedString.length <= 512
+            && (replaceRange?.length ?? 0) <= 512
+            && !attributedStringContainsAttachment(attributedString)
+    }
+
+    private func attributesEqualForPatchTrimming(
+        _ lhs: [NSAttributedString.Key: Any],
+        _ rhs: [NSAttributedString.Key: Any]
+    ) -> Bool {
+        // `docPos` and `topLevelChildIndex` are positional metadata consumed
+        // by atom actions and future patch-range resolution. Trimming across
+        // either change would preserve stale attributed metadata.
+        NSDictionary(dictionary: lhs).isEqual(to: rhs)
+    }
+
+    func applyAttributes(from attributedString: NSAttributedString, to destinationRange: NSRange) {
+        guard attributedString.length == destinationRange.length else { return }
+        if let uniformAttributes = uniformAttributes(in: attributedString) {
+            textStorage.setAttributes(uniformAttributes, range: destinationRange)
+            return
+        }
+        let sourceRange = NSRange(location: 0, length: attributedString.length)
+        attributedString.enumerateAttributes(
+            in: sourceRange,
+            options: [.longestEffectiveRangeNotRequired]
+        ) { attrs, range, _ in
+            let targetRange = NSRange(location: destinationRange.location + range.location, length: range.length)
+            textStorage.setAttributes(attrs, range: targetRange)
+        }
+    }
+
+    private func uniformAttributes(in attributedString: NSAttributedString) -> [NSAttributedString.Key: Any]? {
+        guard attributedString.length > 0 else { return [:] }
+        let firstAttributes = attributedString.attributes(at: 0, effectiveRange: nil)
+        var isUniform = true
+        attributedString.enumerateAttributes(
+            in: NSRange(location: 0, length: attributedString.length),
+            options: [.longestEffectiveRangeNotRequired]
+        ) { attrs, _, stop in
+            guard (attrs as NSDictionary).isEqual(firstAttributes) else {
+                isUniform = false
+                stop.pointee = true
+                return
+            }
+        }
+        return isUniform ? firstAttributes : nil
+    }
+
+    func attributedStringContainsAttachment(_ attributedString: NSAttributedString) -> Bool {
+        guard attributedString.length > 0 else { return false }
+        var hasAttachment = false
+        attributedString.enumerateAttribute(
+            .attachment,
+            in: NSRange(location: 0, length: attributedString.length),
+            options: [.longestEffectiveRangeNotRequired]
+        ) { value, _, stop in
+            if value != nil {
+                hasAttachment = true
+                stop.pointee = true
+            }
+        }
+        return hasAttachment
+    }
+
+    func attributedStringContainsPositionAdjustments(_ attributedString: NSAttributedString) -> Bool {
+        guard attributedString.length > 0 else { return false }
+        var hasAdjustments = false
+        attributedString.enumerateAttributes(
+            in: NSRange(location: 0, length: attributedString.length),
+            options: [.longestEffectiveRangeNotRequired]
+        ) { attrs, _, stop in
+            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true
+                || attrs[RenderBridgeAttributes.listMarkerContext] != nil {
+                hasAdjustments = true
+                stop.pointee = true
+            }
+        }
+        return hasAdjustments
+    }
+
+    func attributedStringContainsListMarkerContext(_ attributedString: NSAttributedString) -> Bool {
+        guard attributedString.length > 0 else { return false }
+        var hasListMarkerContext = false
+        attributedString.enumerateAttribute(
+            RenderBridgeAttributes.listMarkerContext,
+            in: NSRange(location: 0, length: attributedString.length),
+            options: [.longestEffectiveRangeNotRequired]
+        ) { value, _, stop in
+            if value != nil {
+                hasListMarkerContext = true
+                stop.pointee = true
+            }
+        }
+        return hasListMarkerContext
+    }
+
+    func textStorageRangeContainsPositionAdjustments(_ range: NSRange) -> Bool {
+        guard range.length > 0,
+              range.location >= 0,
+              range.location + range.length <= textStorage.length
+        else {
+            return false
+        }
+
+        var hasAdjustments = false
+        textStorage.enumerateAttributes(
+            in: range,
+            options: [.longestEffectiveRangeNotRequired]
+        ) { attrs, _, stop in
+            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true
+                || attrs[RenderBridgeAttributes.listMarkerContext] != nil {
+                hasAdjustments = true
+                stop.pointee = true
+            }
+        }
+        return hasAdjustments
+    }
+
+    func textStorageRangeContainsListMarkerContext(_ range: NSRange) -> Bool {
+        guard range.length > 0,
+              range.location >= 0,
+              range.location + range.length <= textStorage.length
+        else {
+            return false
+        }
+
+        var hasListMarkerContext = false
+        textStorage.enumerateAttribute(
+            RenderBridgeAttributes.listMarkerContext,
+            in: range,
+            options: [.longestEffectiveRangeNotRequired]
+        ) { value, _, stop in
+            if value != nil {
+                hasListMarkerContext = true
+                stop.pointee = true
+            }
+        }
+        return hasListMarkerContext
+    }
+
+    func textStorageRangeContainsAttachment(_ range: NSRange) -> Bool {
+        guard range.length > 0,
+              range.location >= 0,
+              range.location + range.length <= textStorage.length
+        else {
+            return false
+        }
+
+        var hasAttachment = false
+        textStorage.enumerateAttribute(
+            .attachment,
+            in: range,
+            options: [.longestEffectiveRangeNotRequired]
+        ) { value, _, stop in
+            if value != nil {
+                hasAttachment = true
+                stop.pointee = true
+            }
+        }
+        return hasAttachment
+    }
+
+    func topLevelChildrenContainAttachment(
+        startIndex: Int,
+        deleteCount: Int
+    ) -> Bool {
+        guard deleteCount > 0,
+              let currentTopLevelChildMetadata,
+              startIndex >= 0,
+              startIndex + deleteCount <= currentTopLevelChildMetadata.count
+        else {
+            return false
+        }
+        return currentTopLevelChildMetadata[startIndex..<(startIndex + deleteCount)]
+            .contains(where: \.containsAttachment)
+    }
+
+    func topLevelChildrenContainPositionAdjustments(
+        startIndex: Int,
+        deleteCount: Int
+    ) -> Bool {
+        guard deleteCount > 0,
+              let currentTopLevelChildMetadata,
+              startIndex >= 0,
+              startIndex + deleteCount <= currentTopLevelChildMetadata.count
+        else {
+            return false
+        }
+        return currentTopLevelChildMetadata[startIndex..<(startIndex + deleteCount)]
+            .contains(where: \.containsPositionAdjustments)
+    }
+
+    func trimmedAttributedPatch(
+        replacing fullReplaceRange: NSRange,
+        with replacement: NSAttributedString
+    ) -> (replaceRange: NSRange, replacement: NSAttributedString) {
+        guard fullReplaceRange.length > 0 else {
+            return (fullReplaceRange, replacement)
+        }
+
+        let existing = textStorage.attributedSubstring(from: fullReplaceRange)
+        let existingRawString = existing.string
+        let replacementRawString = replacement.string
+        let existingString = existingRawString as NSString
+        let replacementString = replacementRawString as NSString
+        let sharedLength = min(existing.length, replacement.length)
+
+        var prefix = 0
+        while prefix < sharedLength {
+            var existingRange = NSRange()
+            let existingAttrs = existing.attributes(
+                at: prefix,
+                longestEffectiveRange: &existingRange,
+                in: NSRange(location: prefix, length: sharedLength - prefix)
+            )
+            var replacementRange = NSRange()
+            let replacementAttrs = replacement.attributes(
+                at: prefix,
+                longestEffectiveRange: &replacementRange,
+                in: NSRange(location: prefix, length: sharedLength - prefix)
+            )
+            guard attributesEqualForPatchTrimming(existingAttrs, replacementAttrs) else { break }
+            let runEnd = min(NSMaxRange(existingRange), NSMaxRange(replacementRange), sharedLength)
+            while prefix < runEnd,
+                  existingString.character(at: prefix) == replacementString.character(at: prefix) {
+                prefix += 1
+            }
+            if prefix < runEnd {
+                break
+            }
+        }
+
+        var suffix = 0
+        while suffix < (sharedLength - prefix) {
+            let existingIndex = existing.length - suffix - 1
+            let replacementIndex = replacement.length - suffix - 1
+            var existingRange = NSRange()
+            let existingAttrs = existing.attributes(
+                at: existingIndex,
+                longestEffectiveRange: &existingRange,
+                in: NSRange(location: prefix, length: existingIndex - prefix + 1)
+            )
+            var replacementRange = NSRange()
+            let replacementAttrs = replacement.attributes(
+                at: replacementIndex,
+                longestEffectiveRange: &replacementRange,
+                in: NSRange(location: prefix, length: replacementIndex - prefix + 1)
+            )
+            guard attributesEqualForPatchTrimming(existingAttrs, replacementAttrs) else { break }
+            let maxComparableLength = min(
+                existingIndex - max(existingRange.location, prefix) + 1,
+                replacementIndex - max(replacementRange.location, prefix) + 1,
+                sharedLength - prefix - suffix
+            )
+            var matchedLength = 0
+            while matchedLength < maxComparableLength,
+                  existingString.character(at: existingIndex - matchedLength)
+                  == replacementString.character(at: replacementIndex - matchedLength) {
+                matchedLength += 1
+            }
+            suffix += matchedLength
+            if matchedLength < maxComparableLength {
+                break
+            }
+        }
+        prefix = sharedUtf16ScalarBoundary(atOrBefore: prefix, in: existingRawString, and: replacementRawString)
+        while suffix > 0 {
+            let existingSuffixStart = existing.length - suffix
+            let replacementSuffixStart = replacement.length - suffix
+            if suffix <= sharedLength - prefix,
+               isUtf16ScalarBoundary(existingSuffixStart, in: existingRawString),
+               isUtf16ScalarBoundary(replacementSuffixStart, in: replacementRawString) {
+                break
+            }
+            suffix -= 1
+        }
+
+        guard prefix > 0 || suffix > 0 else {
+            return (fullReplaceRange, replacement)
+        }
+
+        let trimmedReplaceRange = NSRange(
+            location: fullReplaceRange.location + prefix,
+            length: fullReplaceRange.length - prefix - suffix
+        )
+        let trimmedReplacementRange = NSRange(
+            location: prefix,
+            length: replacement.length - prefix - suffix
+        )
+        return (
+            trimmedReplaceRange,
+            replacement.attributedSubstring(from: trimmedReplacementRange)
+        )
+    }
+
+}

package/ios/EditorTextView+Binding.swift

@@ -0,0 +1,61 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    func ownsNativeBinding(_ adapter: EditorV2Adapter) -> Bool {
+        adapter.isNativeBindingOwner(token: nativeBindingToken)
+    }
+
+    /// Bind this text view to a Rust editor instance and apply initial content.
+    ///
+    /// - Parameters:
+    ///   - id: The editor ID from `editor_create()`.
+    ///   - initialHTML: Optional HTML to set as initial content.
+    func bindEditor(
+        id: UInt64,
+        initialHTML: String? = nil,
+        initialUpdateJSON: String? = nil
+    ) {
+        ensureInternalTextViewDelegate()
+        if editorId == id, initialHTML == nil {
+            return
+        }
+        localTextDragState = .idle
+        if editorId != id {
+            EditorV2Registry.adapter(forLegacyId: editorId)?
+                .releaseNativeBindingOwner(token: nativeBindingToken)
+            discardTransientNativeInputForEditorRebind()
+            invalidateCurrentRenderBlocks()
+        }
+        editorId = id
+        EditorV2Registry.adapter(forLegacyId: id)?
+            .claimNativeBindingIfUnowned(token: nativeBindingToken)
+
+        if let initialUpdateJSON {
+            applyUpdateJSON(initialUpdateJSON, notifyDelegate: false)
+        } else if let html = initialHTML, !html.isEmpty {
+            let updateJSON = EditorV2Shadow.setHtml(id: editorId, html: html)
+            if !applyUpdateJSON(updateJSON, notifyDelegate: false) {
+                let stateJSON = EditorV2Shadow.getCurrentState(id: editorId)
+                applyUpdateJSON(stateJSON, notifyDelegate: false)
+            }
+        } else {
+            // Pull current state from Rust (content may already be loaded via bridge).
+            let stateJSON = EditorV2Shadow.getCurrentState(id: editorId)
+            applyUpdateJSON(stateJSON, notifyDelegate: false)
+        }
+        replayDesiredInputTraitsIfNeeded()
+    }
+
+    /// Unbind from the current editor instance.
+    func unbindEditor() {
+        codeHighlightingSession.cancel()
+        restoreCodeHighlighting()
+        discardTransientNativeInputForEditorRebind()
+        EditorV2Registry.adapter(forLegacyId: editorId)?
+            .releaseNativeBindingOwner(token: nativeBindingToken)
+        invalidateCurrentRenderBlocks()
+        editorId = 0
+    }
+
+}

package/ios/EditorTextView+Caret.swift

@@ -0,0 +1,333 @@
+import os
+import UIKit
+
+extension EditorTextView {
+    func resolvedCaretReferenceRect(for position: UITextPosition) -> CGRect {
+        let directRect = super.caretRect(for: position)
+        if let horizontalRuleRect = resolvedHorizontalRuleAdjacentCaretRect(
+            for: position,
+            directRect: directRect
+        ) {
+            return horizontalRuleRect
+        }
+        guard directRect.height <= 0 || directRect.isEmpty else {
+            return directRect
+        }
+
+        let caretWidth = max(directRect.width, 2)
+
+        if let nextPosition = self.position(from: position, offset: 1),
+           let nextRange = textRange(from: position, to: nextPosition),
+           let nextRect = selectionRects(for: nextRange)
+           .map(\.rect)
+           .first(where: { !$0.isEmpty && $0.width > 0 && $0.height > 0 }) {
+            return CGRect(
+                x: nextRect.minX,
+                y: nextRect.minY,
+                width: caretWidth,
+                height: max(directRect.height, nextRect.height)
+            )
+        }
+
+        if let previousPosition = self.position(from: position, offset: -1),
+           let previousRange = textRange(from: previousPosition, to: position),
+           let previousRect = selectionRects(for: previousRange)
+           .map(\.rect)
+           .last(where: { !$0.isEmpty && $0.width > 0 && $0.height > 0 }) {
+            return CGRect(
+                x: previousRect.maxX,
+                y: previousRect.minY,
+                width: caretWidth,
+                height: max(directRect.height, previousRect.height)
+            )
+        }
+
+        return directRect
+    }
+
+    private func resolvedHorizontalRuleAdjacentCaretRect(
+        for position: UITextPosition,
+        directRect: CGRect
+    ) -> CGRect? {
+        guard textStorage.length > 0 else { return nil }
+
+        let utf16Offset = offset(from: beginningOfDocument, to: position)
+        let caretWidth = max(directRect.width, 2)
+
+        if isHorizontalRuleAttachment(at: utf16Offset),
+           let previousCharacterIndex = nearestVisibleCharacterIndex(
+               from: utf16Offset - 1,
+               direction: -1
+           ),
+           let previousRect = visibleSelectionRect(forCharacterAt: previousCharacterIndex) {
+            return CGRect(
+                x: previousRect.maxX,
+                y: previousRect.minY,
+                width: caretWidth,
+                height: max(directRect.height, previousRect.height)
+            )
+        }
+
+        if isHorizontalRuleAttachment(at: utf16Offset - 1),
+           let nextCharacterIndex = nearestVisibleCharacterIndex(
+               from: utf16Offset,
+               direction: 1
+           ),
+           let nextRect = visibleSelectionRect(forCharacterAt: nextCharacterIndex) {
+            return CGRect(
+                x: nextRect.minX,
+                y: nextRect.minY,
+                width: caretWidth,
+                height: max(directRect.height, nextRect.height)
+            )
+        }
+
+        return nil
+    }
+
+    static func adjustedCaretRect(
+        from rect: CGRect,
+        targetHeight: CGFloat,
+        screenScale: CGFloat
+    ) -> CGRect {
+        guard rect.height > 0, targetHeight > 0, targetHeight < rect.height else {
+            return rect
+        }
+
+        let scale = max(screenScale, 1)
+        let alignedHeight = ceil(targetHeight * scale) / scale
+        let centeredY = rect.minY + ((rect.height - alignedHeight) / 2.0)
+        let alignedY = (centeredY * scale).rounded() / scale
+
+        var adjusted = rect
+        adjusted.origin.y = alignedY
+        adjusted.size.height = alignedHeight
+        return adjusted
+    }
+
+    static func adjustedCaretRect(
+        from rect: CGRect,
+        font: UIFont,
+        screenScale: CGFloat
+    ) -> CGRect {
+        let scale = max(screenScale, 1)
+        let lineHeight = max(font.lineHeight, 0)
+        let alignedHeight = ceil(lineHeight * scale) / scale
+        let alignedY = ((rect.maxY - alignedHeight) * scale).rounded() / scale
+
+        var adjusted = rect
+        adjusted.origin.y = alignedY
+        adjusted.size.height = alignedHeight
+        return adjusted
+    }
+
+    static func adjustedCaretRect(
+        from rect: CGRect,
+        baselineY: CGFloat,
+        font: UIFont,
+        screenScale: CGFloat
+    ) -> CGRect {
+        let scale = max(screenScale, 1)
+        let lineHeight = max(font.lineHeight, 0)
+        let alignedHeight = ceil(lineHeight * scale) / scale
+        let typographicHeight = font.ascender - font.descender
+        let leading = max(lineHeight - typographicHeight, 0)
+        let topY = baselineY - font.ascender - (leading / 2.0)
+        let alignedY = (topY * scale).rounded() / scale
+
+        var adjusted = rect
+        adjusted.origin.y = alignedY
+        adjusted.size.height = alignedHeight
+        return adjusted
+    }
+
+    func caretBaselineY(for position: UITextPosition, referenceRect: CGRect) -> CGFloat? {
+        guard textStorage.length > 0 else { return nil }
+
+        let rawOffset = offset(from: beginningOfDocument, to: position)
+        let clampedOffset = min(max(rawOffset, 0), textStorage.length)
+
+        if let horizontalRuleBaselineY = horizontalRuleAdjacentBaselineY(at: clampedOffset) {
+            return horizontalRuleBaselineY
+        }
+
+        if let hardBreakBaselineY = hardBreakBaselineY(after: clampedOffset) {
+            return hardBreakBaselineY
+        }
+
+        var candidateCharacters = Set<Int>()
+
+        if clampedOffset < textStorage.length {
+            candidateCharacters.insert(clampedOffset)
+        }
+        if clampedOffset > 0 {
+            candidateCharacters.insert(clampedOffset - 1)
+        }
+        if clampedOffset + 1 < textStorage.length {
+            candidateCharacters.insert(clampedOffset + 1)
+        }
+
+        guard !candidateCharacters.isEmpty else { return nil }
+
+        let referenceMidY = referenceRect.midY
+        let referenceMinY = referenceRect.minY
+        var bestMatch: (score: CGFloat, baselineY: CGFloat)?
+
+        for characterIndex in candidateCharacters.sorted() {
+            let glyphIndex = layoutManager.glyphIndexForCharacter(at: characterIndex)
+            guard glyphIndex < layoutManager.numberOfGlyphs else { continue }
+
+            let lineFragmentRect = layoutManager.lineFragmentRect(
+                forGlyphAt: glyphIndex,
+                effectiveRange: nil
+            )
+            let lineRectInView = lineFragmentRect.offsetBy(dx: 0, dy: textContainerInset.top)
+            let score = abs(lineRectInView.midY - referenceMidY) * 10
+                + abs(lineRectInView.minY - referenceMinY)
+            let glyphLocation = layoutManager.location(forGlyphAt: glyphIndex)
+            let baselineY = textContainerInset.top + lineFragmentRect.minY + glyphLocation.y
+
+            if let currentBest = bestMatch, currentBest.score <= score {
+                continue
+            }
+            bestMatch = (score, baselineY)
+        }
+
+        return bestMatch?.baselineY
+    }
+
+    private func horizontalRuleAdjacentBaselineY(at utf16Offset: Int) -> CGFloat? {
+        guard textStorage.length > 0 else { return nil }
+
+        if isHorizontalRuleAttachment(at: utf16Offset),
+           let previousCharacterIndex = nearestVisibleCharacterIndex(
+               from: utf16Offset - 1,
+               direction: -1
+           ) {
+            return baselineY(forCharacterAt: previousCharacterIndex)
+        }
+
+        if isHorizontalRuleAttachment(at: utf16Offset - 1),
+           let nextCharacterIndex = nearestVisibleCharacterIndex(
+               from: utf16Offset,
+               direction: 1
+           ) {
+            return baselineY(forCharacterAt: nextCharacterIndex)
+        }
+
+        return nil
+    }
+
+    func baselineY(forCharacterAt characterIndex: Int) -> CGFloat? {
+        guard characterIndex >= 0, characterIndex < textStorage.length else { return nil }
+
+        let glyphIndex = layoutManager.glyphIndexForCharacter(at: characterIndex)
+        guard glyphIndex < layoutManager.numberOfGlyphs else { return nil }
+
+        let lineFragmentRect = layoutManager.lineFragmentRect(
+            forGlyphAt: glyphIndex,
+            effectiveRange: nil
+        )
+        let glyphLocation = layoutManager.location(forGlyphAt: glyphIndex)
+        return textContainerInset.top + lineFragmentRect.minY + glyphLocation.y
+    }
+
+    private func visibleSelectionRect(forCharacterAt characterIndex: Int) -> CGRect? {
+        guard characterIndex >= 0, characterIndex < textStorage.length else { return nil }
+        guard let start = position(from: beginningOfDocument, offset: characterIndex),
+              let end = position(from: start, offset: 1),
+              let range = textRange(from: start, to: end)
+        else {
+            return nil
+        }
+
+        return selectionRects(for: range)
+            .map(\.rect)
+            .first(where: { !$0.isEmpty && $0.width > 0 && $0.height > 0 })
+    }
+
+    private func nearestVisibleCharacterIndex(from startIndex: Int, direction: Int) -> Int? {
+        guard direction == -1 || direction == 1 else { return nil }
+        guard textStorage.length > 0 else { return nil }
+
+        let text = textStorage.string as NSString
+        var index = startIndex
+
+        while index >= 0, index < text.length {
+            let attrs = textStorage.attributes(at: index, effectiveRange: nil)
+            let character = text.substring(with: NSRange(location: index, length: 1))
+
+            if attrs[.attachment] == nil,
+               character != "\n",
+               character != "\r",
+               visibleSelectionRect(forCharacterAt: index) != nil {
+                return index
+            }
+
+            index += direction
+        }
+
+        return nil
+    }
+
+    private func isHorizontalRuleAttachment(at utf16Offset: Int) -> Bool {
+        guard utf16Offset >= 0, utf16Offset < textStorage.length else { return false }
+
+        let attrs = textStorage.attributes(at: utf16Offset, effectiveRange: nil)
+        return attrs[.attachment] is NSTextAttachment
+            && EditorNodeTypes.isHorizontalRule(attrs[RenderBridgeAttributes.voidNodeType] as? String)
+    }
+
+    private func hardBreakBaselineY(after utf16Offset: Int) -> CGFloat? {
+        guard utf16Offset > 0, utf16Offset <= textStorage.length else { return nil }
+        let previousVoidType = textStorage.attribute(
+            RenderBridgeAttributes.voidNodeType,
+            at: utf16Offset - 1,
+            effectiveRange: nil
+        ) as? String
+        guard EditorNodeTypes.isHardBreak(previousVoidType) else { return nil }
+
+        let previousGlyphIndex = layoutManager.glyphIndexForCharacter(at: utf16Offset - 1)
+        guard previousGlyphIndex < layoutManager.numberOfGlyphs else { return nil }
+
+        let lineFragmentRect = layoutManager.lineFragmentRect(
+            forGlyphAt: previousGlyphIndex,
+            effectiveRange: nil
+        )
+        let glyphLocation = layoutManager.location(forGlyphAt: previousGlyphIndex)
+        let previousBaselineY = textContainerInset.top + lineFragmentRect.minY + glyphLocation.y
+
+        let paragraphStyle = textStorage.attribute(
+            .paragraphStyle,
+            at: utf16Offset - 1,
+            effectiveRange: nil
+        ) as? NSParagraphStyle
+        let configuredLineHeight = max(
+            paragraphStyle?.minimumLineHeight ?? 0,
+            paragraphStyle?.maximumLineHeight ?? 0
+        )
+        let lineAdvance = configuredLineHeight > 0
+            ? configuredLineHeight
+            : lineFragmentRect.height
+
+        return previousBaselineY + lineAdvance
+    }
+
+    func resolvedCaretFont(for position: UITextPosition) -> UIFont {
+        guard textStorage.length > 0 else { return resolvedDefaultFont() }
+
+        let offset = offset(from: beginningOfDocument, to: position)
+        let attributeIndex: Int
+        if offset <= 0 {
+            attributeIndex = 0
+        } else if offset < textStorage.length {
+            attributeIndex = offset
+        } else {
+            attributeIndex = textStorage.length - 1
+        }
+
+        return (textStorage.attribute(.font, at: attributeIndex, effectiveRange: nil) as? UIFont)
+            ?? resolvedDefaultFont()
+    }
+
+}