struct ContentView: View {
    @ObservedObject var intent: ContentIntent
    var body: some View {
        Text("Hello, world!")
    }
}

// MARK: - Screen ContentView
struct ContentView: View {
    @State var isNextScreenVisible = false
    @State var seconds = "0"
    var body: some View {
        NavigationView {
            VStack(spacing: 16) {
                Text("Seconds: \(seconds)")
                NavigationLink("Next screen", destination: NextView(), isActive: $isNextScreenVisible)
            }
        }.onAppear {
            Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
                self.seconds = String(Int(Date().timeIntervalSince1970) % 60)
            }
        }
    }
}
// MARK: - Scren NextView
struct NextView: View {
    @ObservedObject var intent: NextIntent
    init() {
        intent = ContentIntent()
        print("init NextView")
    }
    var body: some View {
        Text("Hello Weold!")
    }

init NextView
init NextView
init NextView
init NextView
init NextView
init NextView
init NextView
init NextView
init NextView

struct ContentView: View {
    @ObservedObject var intent: ContentInten
    init() {
        self.intent = ContentInten.shared
        let model = ContentModel()
        self.intent.update(model: model)
    }
    var body: some View {
        Text("Hello, world!")
    }

struct ContentView: View {
    @StateObject var intent: ContentInten
    var body: some View {
        Text("Hello, world!")
    }
    static func build() -> some View {
        let model = ContentModel()
        let intent = ContentInten(model: model)
        return ContentView(intent: intent)
    }

struct ContentView: View {
    @State var isVisibleHomeScreen = false
    var body: some View {
        NavigationView {
            VStack {
                Text("Hello, world!")
                NavigationLink(destination: Text("Screen Home"),
                               isActive: $isVisibleHomeScreen,
                               label: { Text("Open screen") })
            }.onAppear {
                print("onAppear was called")
            }.onDisappear {
                print("onDisappear was called")
            }
        }
    }

onDisappear was called
onAppear was called

//  ContentRouter.swift
//
//  Copyright © 2020 Vyacheslav Ansimov. All rights reserved.
//
import SwiftUI
import Combine
// MARK: - Realization
struct ContentRouter: View {
    enum ScreenType {
        case sheetScreen(value: String)
        case navigationScreen(value: String)
        case exit
    }
    private class ScreenTypeHolder: ObservableObject {
        @Published var type: ScreenType?
    }
    // API
    let screen: PassthroughSubject<ScreenType, Never>
    // private
    @Environment(\.presentationMode) private var presentationMode
    @StateObject private var screenType = ScreenTypeHolder()
    // Life cycle
    var body: some View {
        displayView().onReceive(screen) { self.screenType.type = $0 }
    }
    private func displayView() -> some View {
        let isVisible = Binding<Bool>(get: { screenType.type != nil },
                                      set: { if !$0 { screenType.type = nil } })
        // Screens
        switch screenType.type {
        case .sheetScreen(let value):
            return AnyView(
                Spacer().sheet(isPresented: isVisible) {
                    Text(value)
                }
            )
        case .navigationScreen(let value):
            return AnyView (
                NavigationLink("", destination: Text(value), isActive: isVisible)
            )
        case .exit:
            presentationMode.wrappedValue.dismiss()
            return AnyView(EmptyView())
        case .none:
            return AnyView(EmptyView())
        }
    }
}
// MARK: - Example
struct ContentRouter_Previews: PreviewProvider {
    static let routeSubject = PassthroughSubject<ContentRouter.ScreenType, Never>()
    static var previews: some View {
        NavigationView {
            VStack {
                Button(action: {
                    self.routeSubject.send(.sheetScreen(value: "Hello World!"))
                }, label: { Text("Display Sheet Screen") })
                Button(action: {
                    self.routeSubject.send(.navigationScreen(value: "Hello World!"))
                }, label: { Text("Display NavigationLink Screen") })
            }
            .overlay(ContentRouter(screen: routeSubject))
        }
    }
}

// MARK: Model
class ContentModel: ObservableObject {
    @Publised var title = "Hello World!"
}
// MARK: View
struct ContentView: View {
    @ObservedObject var model:  ContentModel
    var body: some View {
        Text(model.title)
    }
}

// MARK: View
struct ContentView: View {
  @StateObject var intent:  ContentIntent
  var body: some View {
      Text(intent.model .title).onAppear {
          self.intent.onAppear()
      }
  }
}
// MARK: Intent
class ContentIntent {
  let model:  ContentModel
  ...
  func onAppear() {
    model.title = "Hello World!"
  }
}
// MARK: Model
class ContentModel: ObservableObject {
  @Published var title = "Loaded"
}

let model: ContentModel

@Published var model: ContentModel

import Combine
class ContentIntent: ObservableObject {
    let model: ContentModel
    private var cancellable: Set<AnyCancellable> = []
    init(model: ContentModel) {
        self.model = model
        cancellable.insert(model.objectWillChange.sink { [weak self] in
           self?.objectWillChange.send()
        })
    }
    ...
}