iOSアプリのアーキテクチャーを本読みながら実装してく

class UserModel: ObservableObject {
    private let urlString = "https://api.github.com/search/users?q="
    @Published var users = [User]()
    @Published var isNotFound = false
    @Published var error: ModelError?

    public func fetch(query: String) {
        users = [User]()
        error = nil
        isNotFound = false

        guard let encodedQuery = query.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) else {
            publishError(type: .encodingError)
            return
        }

        guard let url = URL(string: urlString + encodedQuery) else {
            publishError(type: .urlError)
            return
        }

        URLSession.shared.dataTask(with: url) {[weak self](data, _, error) in
            if let error = error {
                self?.publishError(type: .responseError(error))
                return
            }

            guard let data = data else {
                self?.publishError(type: .responseDataEmpty)
                return
            }

            guard let users = try? JSONDecoder().decode(Users.self, from: data) else {
                self?.publishError(type: .jsonParseError(String(data: data, encoding: .utf8) ?? ""))
                return
            }

            DispatchQueue.main.async {
                if users.totalCount == 0 {
                    self?.isNotFound = true
                    self?.users = [User]()
                    return
                }
                self?.users = users.items
            }
        }.resume()
    }

    private func publishError(type: ModelError) {
        DispatchQueue.main.async {[weak self] in
            self?.error = type
        }
    }
}

class UserModel: ObservableObject {
    private let urlString = "https://api.github.com/search/users?q="
    @Published var users = [User]()
    @Published var isNotFound = false
    @Published var error: ModelError?

    @MainActor
    public func fetch(query: String) async {
        users = [User]()
        error = nil
        isNotFound = false

        guard let encodedQuery = query.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) else {
            error =  .encodingError
            return
        }

        guard let url = URL(string: urlString + encodedQuery) else {
            error = .urlError
            return
        }

        do {
            let (data, _) = try await URLSession.shared.data(for: URLRequest(url: url))

            guard let users = try? JSONDecoder().decode(Users.self, from: data) else {
                error = .jsonParseError(String(data: data, encoding: .utf8) ?? "")
                return
            }

            if users.totalCount == 0 {
                isNotFound = true
                self.users = [User]()
                return
            }

            self.users = users.items
        } catch {
            self.error = .responseError(error)
        }
    }
}

@State public var isNotFound = true

    override func viewDidLoad() {
    // … //
        Timer.scheduledTimer(timeInterval: 3.0, target: self, selector: #selector(temp), userInfo: nil, repeats: true)
    }

    @objc private func temp() {
        userSearchView.isNotFound = false
    }

    mutating func temp() {
        self.isNotFound = true
    }

/// Presenterの入力になるクラスが準拠する
protocol PresenterInput: View {
    
}

class Presenter: UIViewController {
    private var userSearchView: PresenterInput! // Protocol 'PresenterInput' can only be used as a generic constraint because it has Self or associated type requirements
    private var hostingController: UIHostingController<PresenterInput>!
    private var model: SearchUserModelInput!
    
    public func inject(view: PresenterInput, model: SearchUserModelInput) {
        self.userSearchView = view
        self.model = model
    }

                    List(users) { user in
                        NavigationLink(destination: delegate?.transitionToRepository(repositoryUrlString: user.reposUrl)) {
                            UserRow(user: user)
                        }
                    }

    /// FIXME: 結果を受け取っても、Viewは更新されないので、画面遷移をまるごと書く必要があった
    func transitionToRepository(repositoryUrlString: String) -> RepositoryView {
        repositoryView = RepositoryView(type: .loading)

        model.fetchRepository(urlString: repositoryUrlString) { [weak self] result in
            switch result {
            case .success(let repositories):
                self?.repositoryView = RepositoryView(type: .display(repositories))
            case .failure(let error):
                self?.repositoryView =  RepositoryView(type: .error(error))
            }
        }
        return repositoryView
    }

struct UserSearchView: View {
    @StateObject var viewModel: UserSearchViewModel

    init(viewModel: UserSearchViewModel = UserSearchViewModel()) {
        _viewModel = StateObject(wrappedValue: viewModel)
    }
}

    var body: some View {
        let temp = "rendering"
        let some = print(temp)

NoBuildableEntriesError: active scheme does not build this file

ForEachStore(
    self.store.scope(state: \.filteredTodos, action: AppAction.todo(id:action:)),
    content: TodoView.init(store:)
  )

import Foundation
import ComposableArchitecture

struct GithubApi {
    var users: (String) -> Effect<[User], ModelError>
}

extension GithubApi {
    static let live = GithubApi(
        users: { query in
            var components = URLComponents()
            components.scheme = "https"
            components.host = "api.github.com"
            components.path = "/search/users"
            components.queryItems = [URLQueryItem(name: "q", value: query)]

            return URLSession.shared.dataTaskPublisher(for: components.url!)
                .map { data, _ in data }
                .decode(type: Users.self, decoder: JSONDecoder())
                .mapError { error in ModelError.jsonParseError(error.localizedDescription) }
                .map { return $0.items }
                .eraseToEffect()
        }
    )
}