Preserve inline formatting while typing

docmostly/Features/Editor/NativeEditorBlockRow.swift

@@ -4,6 +4,7 @@ struct NativeEditorBlockRow: View {
     @Binding var block: NativeEditorBlock
     let isActive: Bool
     let focusRequestID: UUID?
+    let retainsResponderDuringFocusHandoff: Bool
     let isSelected: Bool
     let isShowingControls: Bool
     let isReadOnly: Bool
@@ -20,8 +21,9 @@ struct NativeEditorBlockRow: View {
     let presenceProjection: NativeEditorRemotePresenceProjection
     let presenceScope: [NativeEditorRemotePresenceScope]
     let presenceBlockIndex: Int
-    let focusBlock: () -> Void
     let textInputFocusChanged: (Bool) -> Void
+    let typingInlineMarks: Set<NativeEditorInlineMark>
+    let invalidateInlineTypingContext: () -> Void
     let moveBefore: (UUID) -> Void
     let splitBlock: (Range<Int>) -> Bool
     let insertHardBreak: (Range<Int>) -> Bool
@@ -61,13 +63,17 @@ struct NativeEditorBlockRow: View {
                     .frame(width: 24, alignment: .center)
             }
 
-            if showsEditableTextEditor {
+            if usesTextInputSurface {
                 NativeEditorBlockTextSurface(kind: block.kind) {
                     NativeEditorTextInputView(
                         block: $block,
+                        isEditable: isReadOnly == false,
                         isFocused: isActive,
                         focusRequestID: focusRequestID,
+                        retainsResponderDuringFocusHandoff: retainsResponderDuringFocusHandoff,
                         focusChanged: textInputFocusChanged,
+                        typingInlineMarks: typingInlineMarks,
+                        invalidateTypingContext: invalidateInlineTypingContext,
                         accessibilityLabel: block.kind.accessibilityLabel,
                         actions: NativeEditorTextInputActions(
                             handleReturn: handleReturn,
@@ -82,24 +88,6 @@ struct NativeEditorBlockRow: View {
                             selectionChanged()
                         }
                 }
-            } else if block.isEditable && isReadOnly == false {
-                Button(action: focusBlock) {
-                    NativeEditorBlockTextSurface(kind: block.kind) {
-                        NativeEditorRichBlockPreviewView(
-                            block: block,
-                            pageID: pageID,
-                            spaceID: spaceID,
-                            serverURLString: serverURLString,
-                            presenceProjection: presenceProjection,
-                            presenceScope: presenceScope,
-                            presenceBlockIndex: presenceBlockIndex
-                        )
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                        .contentShape(.rect)
-                    }
-                }
-                .buttonStyle(.plain)
-                .accessibilityLabel(block.kind.accessibilityLabel)
             } else {
                 NativeEditorRichBlockPreviewView(
                     block: block,
@@ -196,8 +184,8 @@ struct NativeEditorBlockRow: View {
         }
     }
 
-    private var showsEditableTextEditor: Bool {
-        NativeEditorBlockRowPolicy.showsEditableTextEditor(block: block, isReadOnly: isReadOnly)
+    private var usesTextInputSurface: Bool {
+        NativeEditorBlockRowPolicy.usesTextInputSurface(block: block)
     }
 
     private var showsControls: Bool {

docmostly/Features/Editor/NativeEditorBlockRowPolicy.swift

@@ -1,8 +1,8 @@
 import Foundation
 
 nonisolated enum NativeEditorBlockRowPolicy {
-    static func showsEditableTextEditor(block: NativeEditorBlock, isReadOnly: Bool) -> Bool {
-        block.isEditable && isReadOnly == false
+    static func usesTextInputSurface(block: NativeEditorBlock) -> Bool {
+        block.isEditable
     }
 
     static func allowsTaskToggle(isReadOnly: Bool) -> Bool {

docmostly/Features/Editor/NativeEditorBodyView.swift

@@ -62,6 +62,8 @@ struct NativeEditorBodyView: View {
                         focusRequestID: textInputFocusRequest?.blockID == block.id
                             ? textInputFocusRequest?.id
                             : nil,
+                        retainsResponderDuringFocusHandoff: viewModel.activeBlockID != nil &&
+                            viewModel.activeBlockID != block.id,
                         isSelected: viewModel.selectedBlockID == block.id,
                         isShowingControls: viewModel.visibleBlockControlsID == block.id,
                         isReadOnly: authoringIsAvailable == false,
@@ -92,10 +94,6 @@ struct NativeEditorBodyView: View {
                         presenceProjection: activePresenceProjection,
                         presenceScope: presenceScope,
                         presenceBlockIndex: blockIndex(for: block.id),
-                        focusBlock: {
-                            guard authoringIsAvailable else { return }
-                            viewModel.focus(blockID: block.id)
-                        },
                         textInputFocusChanged: { isFocused in
                             if isFocused {
                                 guard authoringIsAvailable else { return }
@@ -104,6 +102,10 @@ struct NativeEditorBodyView: View {
                                 viewModel.textInputDidEndEditing(blockID: block.id)
                             }
                         },
+                        typingInlineMarks: viewModel.typingInlineMarks(for: block.id),
+                        invalidateInlineTypingContext: {
+                            viewModel.invalidateInlineTypingContext(for: block.id)
+                        },
                         moveBefore: { movedBlockID in
                             guard authoringIsAvailable else { return }
                             viewModel.moveBlock(movedBlockID, before: block.id)

docmostly/Features/Editor/NativeEditorInlineMark.swift

@@ -1,7 +1,7 @@
 import Foundation
 import SwiftUI
 
-enum NativeEditorInlineMark {
+nonisolated enum NativeEditorInlineMark: CaseIterable, Hashable, Sendable {
     case bold
     case italic
     case underline
@@ -11,49 +11,122 @@ enum NativeEditorInlineMark {
     case superscript
 
     func toggle(in attributes: inout AttributeContainer) {
+        set(isActive(in: attributes) == false, in: &attributes)
+    }
+
+    func toggle(in text: inout AttributedString) {
         if case .underline = self {
-            attributes.underlineStyle = attributes.underlineStyle == nil ? .single : nil
+            text.underlineStyle = text.underlineStyle == nil ? .single : nil
             return
         }
 
         if let baselineOffset {
-            attributes.baselineOffset = attributes.baselineOffset == baselineOffset ? nil : baselineOffset
+            text.baselineOffset = text.baselineOffset == baselineOffset ? nil : baselineOffset
             return
         }
 
         guard let intent else { return }
-        var currentIntent = attributes.inlinePresentationIntent ?? []
-
+        var currentIntent = text.inlinePresentationIntent ?? []
         if currentIntent.contains(intent) {
             currentIntent.remove(intent)
         } else {
             currentIntent.insert(intent)
         }
+        text.inlinePresentationIntent = currentIntent.isEmpty ? nil : currentIntent
+    }
 
-        attributes.inlinePresentationIntent = currentIntent.isEmpty ? nil : currentIntent
+    func isActive(in attributes: AttributeContainer) -> Bool {
+        if case .underline = self {
+            return attributes.underlineStyle != nil
+        }
+
+        if let baselineOffset {
+            return attributes.baselineOffset == baselineOffset
+        }
+
+        guard let intent else { return false }
+        return attributes.inlinePresentationIntent?.contains(intent) == true
     }
 
-    func toggle(in text: inout AttributedString) {
+    func set(_ isActive: Bool, in attributes: inout AttributeContainer) {
         if case .underline = self {
-            text.underlineStyle = text.underlineStyle == nil ? .single : nil
+            attributes.underlineStyle = isActive ? .single : nil
             return
         }
 
         if let baselineOffset {
-            text.baselineOffset = text.baselineOffset == baselineOffset ? nil : baselineOffset
+            attributes.baselineOffset = isActive ? baselineOffset : nil
             return
         }
 
         guard let intent else { return }
-        var currentIntent = text.inlinePresentationIntent ?? []
-
-        if currentIntent.contains(intent) {
+        var currentIntent = attributes.inlinePresentationIntent ?? []
+        if isActive {
+            currentIntent.insert(intent)
+        } else {
             currentIntent.remove(intent)
+        }
+        attributes.inlinePresentationIntent = currentIntent.isEmpty ? nil : currentIntent
+    }
+
+    static func setActiveMarks(_ marks: Set<Self>, in attributes: inout AttributeContainer) {
+        for mark in allCases where mark != .subscript && mark != .superscript {
+            mark.set(marks.contains(mark), in: &attributes)
+        }
+        if marks.contains(.subscript) {
+            attributes.baselineOffset = -4
+        } else if marks.contains(.superscript) {
+            attributes.baselineOffset = 4
         } else {
-            currentIntent.insert(intent)
+            attributes.baselineOffset = nil
         }
+    }
 
-        text.inlinePresentationIntent = currentIntent.isEmpty ? nil : currentIntent
+    static func activeMarks(
+        for selection: AttributedTextSelection,
+        in text: AttributedString
+    ) -> Set<Self> {
+        switch selection.indices(in: text) {
+        case .insertionPoint(let index):
+            return activeMarks(in: inheritedAttributes(at: index, in: text))
+        case .ranges(let ranges):
+            guard ranges.isEmpty == false else {
+                return activeMarks(in: inheritedAttributes(at: text.endIndex, in: text))
+            }
+            return Set(allCases.filter { mark in
+                ranges.ranges.allSatisfy { range in
+                    text[range].runs.allSatisfy { mark.isActive(in: $0.attributes) }
+                }
+            })
+        }
+    }
+
+    private static func activeMarks(in attributes: AttributeContainer?) -> Set<Self> {
+        guard let attributes else { return [] }
+        return Set(allCases.filter { $0.isActive(in: attributes) })
+    }
+
+    private static func inheritedAttributes(
+        at insertionIndex: AttributedString.Index,
+        in text: AttributedString
+    ) -> AttributeContainer? {
+        if insertionIndex > text.startIndex {
+            let previousIndex = text.characters.index(before: insertionIndex)
+            if let attributes = text[previousIndex..<insertionIndex].runs.first?.attributes,
+               attributes.hasNativeEditorAtomicInlineAttribute == false {
+                return attributes
+            }
+        }
+
+        if insertionIndex < text.endIndex {
+            let nextIndex = text.characters.index(after: insertionIndex)
+            let attributes = text[insertionIndex..<nextIndex].runs.first?.attributes
+            if attributes?.hasNativeEditorAtomicInlineAttribute == false {
+                return attributes
+            }
+        }
+
+        return nil
     }
 
     private var intent: InlinePresentationIntent? {

docmostly/Features/Editor/NativeEditorInlineTypingContext.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+nonisolated struct NativeEditorInlineTypingContext: Equatable, Sendable {
+    let blockID: UUID
+    var marks: Set<NativeEditorInlineMark>
+}

docmostly/Features/Editor/NativeEditorNSTextView.swift

@@ -0,0 +1,33 @@
+#if os(macOS)
+import AppKit
+
+@MainActor
+final class NativeEditorNSTextView: NSTextView {
+    var requestsFirstResponder = false
+    var renderedRemotePresenceSegments: [NativeEditorRemotePresenceSegment] = []
+    var remotePresenceHighlightRanges: [NSRange] = []
+    var remotePresenceOverlayViews: [NSView] = []
+    var remotePresenceRenderingIsInvalid = true
+
+    override func layout() {
+        super.layout()
+        layoutRemotePresenceOverlays()
+    }
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        requestFirstResponderIfPossible()
+    }
+
+    func requestFirstResponderIfPossible() {
+        guard
+            requestsFirstResponder,
+            let window,
+            window.firstResponder !== self
+        else {
+            return
+        }
+        window.makeFirstResponder(self)
+    }
+}
+#endif

docmostly/Features/Editor/NativeEditorPlatformTypingAttributes+iOS.swift

@@ -0,0 +1,65 @@
+#if os(iOS)
+import UIKit
+
+nonisolated enum NativeEditorPlatformTypingAttributes {
+    static func attributes(
+        baseFont: UIFont,
+        marks: Set<NativeEditorInlineMark>,
+        kind: NativeEditorBlockKind,
+        paragraphStyle: NSParagraphStyle
+    ) -> [NSAttributedString.Key: Any] {
+        var attributes: [NSAttributedString.Key: Any] = [
+            .font: font(baseFont: baseFont, marks: marks, kind: kind),
+            .foregroundColor: UIColor.label,
+            .paragraphStyle: paragraphStyle
+        ]
+        if marks.contains(.underline) {
+            attributes[.underlineStyle] = NSUnderlineStyle.single.rawValue
+        }
+        if marks.contains(.strikethrough) {
+            attributes[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+        }
+        if marks.contains(.subscript) {
+            attributes[.baselineOffset] = -4.0
+        } else if marks.contains(.superscript) {
+            attributes[.baselineOffset] = 4.0
+        }
+        return attributes
+    }
+
+    private static func font(
+        baseFont: UIFont,
+        marks: Set<NativeEditorInlineMark>,
+        kind: NativeEditorBlockKind
+    ) -> UIFont {
+        let hasStrongEmphasis = marks.contains(.bold)
+        let usesHeavyHeadingWeight = hasStrongEmphasis && kind.isTypingAttributesHeading
+        var descriptor = usesHeavyHeadingWeight
+            ? UIFont.systemFont(ofSize: baseFont.pointSize, weight: .heavy).fontDescriptor
+            : baseFont.fontDescriptor
+        if marks.contains(.code), let monospacedDescriptor = descriptor.withDesign(.monospaced) {
+            descriptor = monospacedDescriptor
+        }
+        var traits = descriptor.symbolicTraits
+        if hasStrongEmphasis && usesHeavyHeadingWeight == false {
+            traits.insert(.traitBold)
+        }
+        if marks.contains(.italic) {
+            traits.insert(.traitItalic)
+        }
+        guard let styledDescriptor = descriptor.withSymbolicTraits(traits) else {
+            return baseFont
+        }
+        return UIFont(descriptor: styledDescriptor, size: baseFont.pointSize)
+    }
+}
+
+private extension NativeEditorBlockKind {
+    nonisolated var isTypingAttributesHeading: Bool {
+        if case .heading = self {
+            return true
+        }
+        return false
+    }
+}
+#endif