Detect when a user stopped typing on a TextEditor in SwiftUI (macOS)

Question

I'm saving the text of a TextEditor to a text file. I start by creating the file with the first line of the TextEditor as the filename, and then subsequent updates are saved on that file. The code lives on a .onChange action. This presents a challenge since I'm creating a file for each character the use type on the first line of the TextEditor.

Is there a way to detect when the user stopped typing, or the component is idle, and then create the file and save the text? This is on macOS Big Sur.

I haven't been able to find any action I can use. Code follows for the view:

    @EnvironmentObject private var data: DataModel
    var note: NoteItem        
    @State var text: String
    
    var body: some View {
        HStack {
            VStack(alignment: .leading) {
                TextEditor(text: $text)
                    //.onTapGesture {
                    // tried with this....
                    //    print("stopped typing")
                    //}
                    .onChange(of: text, perform: { value in
                        guard let index = data.notes.firstIndex(of: note) else { return }
                        data.notes[index].text = value
                        data.notes[index].date = Date()
                        data.notes[index].filename = value.components(separatedBy: NSCharacterSet.newlines).first!
                        saveFile(filename: data.notes[index].filename, contents: data.notes[index].text)
                    })                    
            }
        }

Answer 1

Combine has debounce for such cases. It applies to Publisher, and passes the value down the chain only if no new value is received within the debounceFor specified time.

This is exactly what you need: if the user has not typed anything within say one second, you should save the text.

Just consider the fact that, if the user closes the view or minimizes the application, you may not save the text state. For these cases you have to duplicate the saving logic in onDisappear and listen for a willEnterForegroundNotification notification.

I created a modifier based on debounce which is easy to use in SwiftUI:

import Combine

extension View {
    func onDebouncedChange<V>(
        of binding: Binding<V>,
        debounceFor dueTime: TimeInterval,
        perform action: @escaping (V) -> Void
    ) -> some View where V: Equatable {
        modifier(ListenDebounce(binding: binding, dueTime: dueTime, action: action))
    }
}

private struct ListenDebounce<Value: Equatable>: ViewModifier {
    @Binding
    var binding: Value
    @StateObject
    var debounceSubject: ObservableDebounceSubject<Value, Never>
    let action: (Value) -> Void

    init(binding: Binding<Value>, dueTime: TimeInterval, action: @escaping (Value) -> Void) {
        _binding = binding
        _debounceSubject = .init(wrappedValue: .init(dueTime: dueTime))
        self.action = action
    }

    func body(content: Content) -> some View {
        content
            .onChange(of: binding) { value in
                debounceSubject.send(value)
            }
            .onReceive(debounceSubject) { value in
                action(value)
            }
    }
}

private final class ObservableDebounceSubject<Output: Equatable, Failure>: Subject, ObservableObject where Failure: Error {
    private let passthroughSubject = PassthroughSubject<Output, Failure>()

    let dueTime: TimeInterval

    init(dueTime: TimeInterval) {
        self.dueTime = dueTime
    }

    func send(_ value: Output) {
        passthroughSubject.send(value)
    }

    func send(completion: Subscribers.Completion<Failure>) {
        passthroughSubject.send(completion: completion)
    }

    func send(subscription: Subscription) {
        passthroughSubject.send(subscription: subscription)
    }

    func receive<S>(subscriber: S) where S: Subscriber, Failure == S.Failure, Output == S.Input {
        passthroughSubject
            .removeDuplicates()
            .debounce(for: .init(dueTime), scheduler: RunLoop.main)
            .receive(subscriber: subscriber)
    }
}

Usage:

@EnvironmentObject private var data: DataModel
var note: NoteItem
@State var text: String

var body: some View {
    HStack {
        VStack(alignment: .leading) {
            TextEditor(text: $text)
                //.onTapGesture {
                // tried with this....
                //    print("stopped typing")
                //}
                .onDebouncedChange(
                    of: $text,
                    debounceFor: 1 // TimeInterval, i.e. sec
                ) { value in
                    guard let index = data.notes.firstIndex(of: note) else {
                        return
                    }
                    data.notes[index].text = value
                    data.notes[index].date = Date()
                    data.notes[index].filename = value.components(separatedBy: NSCharacterSet.newlines).first!
                    saveFile(filename: data.notes[index].filename, contents: data.notes[index].text)
                }
        }
    }
}