ios – separate presentation logic from the view in SwiftUI

I have been making an attempt to separate presentation logic from the view itself and I discovered this sample that initially look appeared to work.

struct MyView: View {
   @StateObject var viewModel = ViewModel()

   ...
}

extension MyView {
   class ViewModel: ObservableObject {
      ...
   }
}

This works properly besides when the view is determined by a dependency owned by the mother or father view. StateObject documentation provides the next instance:

struct MyInitializableView: View {
    @StateObject non-public var mannequin: DataModel


    init(title: String) {
        // SwiftUI ensures that the next initialization makes use of the
        // closure solely as soon as in the course of the lifetime of the view, so
        // later adjustments to the view's title enter don't have any impact.
        _model = StateObject(wrappedValue: DataModel(title: title))
    }


    var physique: some View {
        VStack {
            Textual content("Title: (mannequin.title)")
        }
    }
}

Nevertheless, they instantly warn that this strategy solely works if the exterior knowledge would not change. In any other case the information mannequin will not have entry to up to date values in any of the properties.

Within the above instance, if the title enter to MyInitializableView
adjustments, SwiftUI reruns the view’s initializer with the brand new worth.
Nevertheless, SwiftUI runs the autoclosure that you simply present to the state
object’s initializer solely the primary time you name the state object’s
initializer, so the mannequin’s saved title worth doesn’t change. What
could be one of the simplest ways to separate presentation logic from the view
itself? Subscribing to publishers in a use case, calculating body
sizes, logic to find out whether or not a toddler view is seen or not, and so forth
could be higher off in a unique file that the view makes use of to attract
itself.

To keep away from having an excessive amount of logic within the view like this:

NOTE: This has nice efficiency advantages since any updates to particular person will trigger a re-render WITHOUT inflicting your entire view to be reinitialised. Its lifecycle isn’t affected

struct PersonView: View {
    let particular person: Particular person
    
    non-public let dateFormatter = DateFormatter()
    
    var physique: some View {
        VStack(alignment: .main) {
            Textual content(fullName)
            Textual content(birthday)
        }
    }
    
    var fullName: String {
        "(particular person.firstName) (particular person.lastName)"
    }
    
    var birthday: String {
        dateFormatter.dateFormat = "MMM d"
        
        return dateFormatter.string(from: particular person.dateOfBirth)
    }
}

We may separate the presentation logic for the view’s rendering like this:

struct PersonView: View {
    @StateObject non-public var viewModel: ViewModel
    
    init(particular person: Particular person) {
        self._viewModel = .init(wrappedValue: ViewModel(particular person: particular person))
    }
    
    var physique: some View {
        VStack(alignment: .main) {
            Textual content(viewModel.fullName)
            Textual content(viewModel.birthday)
        }
    }
}

extension PersonView {
    class ViewModel: ObservableObject {
        let particular person: Particular person
        
        non-public let dateFormatter: DateFormatter
        
        init(particular person: Particular person) {
            self.particular person = particular person
            
            let dateFormatter = DateFormatter()
            dateFormatter.dateFormat = "MMM d"
            
            self.dateFormatter = dateFormatter
        }
        
        var fullName: String {
            "(particular person.firstName) (particular person.lastName)"
        }
        
        var birthday: String {
            dateFormatter.string(from: particular person.dateOfBirth)
        }
    }
}

Nevertheless, as talked about within the documentation any updates to any of Particular person’s properties will not be mirrored within the view.

There are a number of methods to drive reinitialisation by altering the view’s id, however all of them include efficiency points and different unwanted effects.

Be aware of the efficiency price of reinitializing the state object
each time the enter adjustments. Additionally, altering view id can have
unwanted effects. For instance, SwiftUI doesn’t routinely animate
adjustments contained in the view if the view’s id adjustments on the similar
time. Additionally, altering the id resets all state held by the view,
together with values that you simply handle as State, FocusState, GestureState,
and so forth.

Is there a approach to obtain a extra clear separation of issues whereas nonetheless leveraging SwftUI’s optimisations when re-rendering views?