sizeThatFits

[pnewell]

Have you had any luck getting this to work with sizeThatFits with NSViewRepresentable? I've been trying for a few days now and have been going in circles. The main issue is I am getting a lot of flickering whenever adding a new line.

Current iteration:

#Preview {
    @Previewable @State var text: AttributedString = "ssss"
    VStack {
        HStack(alignment: .top) {
            ResizingTextView(text: $text)                .background(Color.pink)
        }
    }
    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
    
}

#if canImport(UIKit)
public typealias ViewRepresentable = UIViewRepresentable
#elseif canImport(AppKit)
public typealias ViewRepresentable = NSViewRepresentable
#endif

private struct TextViewRepresentable: NSViewRepresentable {
    @Environment(\.isEnabled) private var isEnabled
    @Environment(\.font) private var font
    @Environment(\.lineSpacing) private var lineSpacing
    
    @Binding private var text: AttributedString
    @Binding private var selection: NSRange?
    private let options: STTextViewSwiftUIAppKit.TextView.Options
    private var plugins: [any STPlugin]
    
    init(text: Binding<AttributedString>, selection: Binding<NSRange?>, options: STTextViewSwiftUIAppKit.TextView.Options, plugins: [any STPlugin] = []) {
        self._text = text
        self._selection = selection
        self.options = options
        self.plugins = plugins
    }
    
    func makeNSView(context: Context) -> NSScrollView {
        let scrollView = STTextView.scrollableTextView()
        // Enable layer backing to help reduce flicker
        scrollView.wantsLayer = true
        let textView = scrollView.documentView as! STTextView
        textView.wantsLayer = true
        
        textView.textDelegate = context.coordinator
        textView.highlightSelectedLine = options.contains(.highlightSelectedLine)
        textView.isHorizontallyResizable = !options.contains(.wrapLines)
        textView.showsLineNumbers = options.contains(.showLineNumbers)
        textView.textSelection = NSRange()
        
        context.coordinator.isUpdating = true
        // Disable implicit animations while setting text
        CATransaction.begin()
        CATransaction.setDisableActions(true)
        textView.attributedText = NSAttributedString(styledAttributedString(textView.typingAttributes))
        CATransaction.commit()
        context.coordinator.isUpdating = false
        
        for plugin in plugins {
            textView.addPlugin(plugin)
        }
        
        return scrollView
    }
    
    func updateNSView(_ scrollView: NSScrollView, context: Context) {
        context.coordinator.parent = self
        let textView = scrollView.documentView as! STTextView
        
        // Disable implicit animations during update
        CATransaction.begin()
        CATransaction.setDisableActions(true)
        context.coordinator.isUpdating = true
        if context.coordinator.isDidChangeText == false {
            textView.attributedText = NSAttributedString(styledAttributedString(textView.typingAttributes))
        }
        context.coordinator.isUpdating = false
        context.coordinator.isDidChangeText = false
        CATransaction.commit()
        
        if textView.textSelection != selection, let selection {
            textView.textSelection = selection
        }
        
        textView.isEditable = isEnabled
        textView.isSelectable = isEnabled
        
        if options.contains(.wrapLines) != textView.isHorizontallyResizable {
            textView.isHorizontallyResizable = !options.contains(.wrapLines)
        }
    }
    
    func makeCoordinator() -> TextCoordinator {
        TextCoordinator(parent: self)
    }
    
    private func styledAttributedString(_ typingAttributes: [NSAttributedString.Key: Any]) -> AttributedString {
        let paragraph = (typingAttributes[.paragraphStyle] as! NSParagraphStyle).mutableCopy() as! NSMutableParagraphStyle
        if paragraph.lineSpacing != lineSpacing {
            paragraph.lineSpacing = lineSpacing
            var typingAttributes = typingAttributes
            typingAttributes[.paragraphStyle] = paragraph
            
            let attributeContainer = AttributeContainer(typingAttributes)
            var styledText = text
            styledText.mergeAttributes(attributeContainer, mergePolicy: .keepNew)
            return styledText
        }
        return text
    }
    
    @MainActor
    class TextCoordinator: @preconcurrency STTextViewDelegate {
        var parent: TextViewRepresentable
        var isUpdating: Bool = false
        var isDidChangeText: Bool = false
        var lastSize: CGSize = .zero

        init(parent: TextViewRepresentable) {
            self.parent = parent
        }
        
        func textViewDidChangeText(_ notification: Notification) {
            guard let textView = notification.object as? STTextView else { return }
            if !isUpdating {
                let newTextValue = AttributedString(textView.attributedText ?? NSAttributedString())
                // Delay the update by a few milliseconds so that TextKit 2's asynchronous layout can settle
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.02) {
                    self.isDidChangeText = true
                    self.parent.text = newTextValue
                }
            }
        }
        
        func textViewDidChangeSelection(_ notification: Notification) {
            guard let textView = notification.object as? STTextView else { return }
            Task { @MainActor in
                self.isDidChangeText = true
                self.parent.selection = textView.selectedRange()
            }
        }
    }
    
    @MainActor
    func sizeThatFits(_ proposal: ProposedViewSize, nsView: NSScrollView, context: Context) -> CGSize? {
        guard let textView = nsView.documentView as? STTextView else { return nil }

        var maxFragmentY: CGFloat = 0
        textView.textLayoutManager.enumerateTextLayoutFragments(from: nil, options: [NSTextLayoutFragment.EnumerationOptions.ensuresLayout, .ensuresExtraLineFragment], using: { fragment in
                        maxFragmentY = max(maxFragmentY, fragment.layoutFragmentFrame.maxY)
                        return true
        })

        return CGSize(
            width: proposal.width ?? textView.intrinsicContentSize.width,
            height: nsView.contentInsets.top + maxFragmentY + nsView.contentInsets.bottom
        )
    }
}

struct ResizingTextView: View {
    @Binding var text: AttributedString
    @State private var measuredHeight: CGFloat = 20

    var body: some View {
        // Wrap in a ZStack so that the background GeometryReader sees the intrinsic content
        ZStack {
            TextViewRepresentable(text: $text, selection: .constant(nil), options: [])
                .fixedSize(horizontal: false, vertical: true)
                // Measure its natural size without imposing an external frame
                .background(
                    GeometryReader { proxy in
                        Color.clear
                            .onAppear {
                                measuredHeight = proxy.size.height
                            }
                            .onChange(of: proxy.size.height) { newHeight in
                                if abs(newHeight - measuredHeight) > 1 {
                                    measuredHeight = newHeight
                                }
                            }
                    }
                )
        }
        // Force the outer container to match the measured height
        .frame(height: measuredHeight)
        .background(Color.pink)
    }
}

[krzyzanowskim]

func updateNSView(_ scrollView: NSScrollView, context: Context) {
…
    textView.attributedText = NSAttributedString(styledAttributedString(textView.typingAttributes))
… 
}

this assignment is a cuplprit, as it reset the content, and relayout everything. There's no good SwiftUI API for making incremental updates from the State variable. If you come up with somethng that is easy to use from SwiftUI, I'm all ears.