Best way to use Resolver in SwiftUI previews about resolver HOT 13 CLOSED

import SwiftUI

extension Resolver.Name {
    static let api = Self("api")
    static let mock0 = Self("mock0")
    static let mock1 = Self("mock1")
    static let mockN = Self("mockN")
    static var mode: Resolver.Name = .api
}

extension Resolver: ResolverRegistering {
    public static func registerAllServices() {
        register { resolve(name: .mode) as DataProviding }
        register(name: .api) { APIDataProvider() as DataProviding }
        register(name: .mock0) { Mock0DataProvider() as DataProviding }
        register(name: .mock1) { Mock1DataProvider() as DataProviding }
        register(name: .mockN) { MockNDataProvider() as DataProviding }
    }
}

protocol DataProviding {
    var text: String { get }
}

struct APIDataProvider: DataProviding {
    var text: String = "API"
}

struct Mock0DataProvider: DataProviding {
    var text: String = "MOCK0"
}

struct Mock1DataProvider: DataProviding {
    var text: String = "MOCK1"
}

struct MockNDataProvider: DataProviding {
    var text: String = "MOCKN"
}

class ContentViewModel: ObservableObject {
    @Injected var data: DataProviding
    var text: String { "Hello, \(data.text) world!" }
}

struct ContentView: View {
    @StateObject var viewModel = ContentViewModel()
    var body: some View {
        Text(viewModel.text)
            .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        Resolver.Name.mode = .mock1
        return ContentView()
    }
}

extension Resolver {
    static var mock: Resolver!
    static func setupMockMode() {
        Resolver.mock = Resolver(parent: .main)
        Resolver.root = .mock
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        Resolver.setupMockMode()
        Resolver.mock.register { MockNDataProvider() as DataProviding }
        return ContentView()
    }
}

import XCTest

@testable import ResolverSwiftUI

class ResolverSwiftUITests: XCTestCase {
    
    override func setUp() {
        Resolver.setupMockMode()
    }

    func testExample0() throws {
        Resolver.mock.register { Mock0DataProvider() as DataProviding }
        let viewModel = ContentViewModel()
        XCTAssert(viewModel.text == "Hello, MOCK0 world!")
    }

    func testExample1() throws {
        Resolver.mock.register { Mock1DataProvider() as DataProviding }
        let viewModel = ContentViewModel()
        XCTAssert(viewModel.text == "Hello, MOCK1 world!")
    }

    func testExampleN() throws {
        Resolver.mock.register { MockNDataProvider() as DataProviding }
        let viewModel = ContentViewModel()
        XCTAssert(viewModel.text == "Hello, MOCKN world!")
    }

}

import SwiftUI
import Resolver
import Combine

final class GoalPickerViewModel: ObservableObject {
    @LazyInjected private var goalService: GoalService
    @LazyInjected private var alertService: AlertService

    @Published private(set) var untrackedGoals: [Goal] = []

    private var subscribers = Set<AnyCancellable>()

    init() {
        Resolver.root = .mock
        goalService.goalsPublisher
            .combineLatest(goalService.goalTrackersPublisher)
            .map { goals, goalTrackers in
                goals.filter { goalTrackers[$0.id] == nil }
            }
            .receive(on: DispatchQueue.main)
            .sink { [weak self] in self?.untrackedGoals = $0 }
            .store(in: &subscribers)
    }

    func trackGoal(_ goal: Goal) {
        goalService.trackGoal(goal)
            .errorHandled(by: alertService)
    }
}

struct GoalPicker: View {
    @StateObject private var viewModel = GoalPickerViewModel()

    var body: some View {
        ScrollView {
            LazyVStack(alignment: .leading) {
                ForEach(viewModel.untrackedGoals) { goal in
                    GoalCard(goal: goal)
                        .onTap { viewModel.trackGoal(goal) }
                        .cardButtonStyle(.modalCard)
                        .disabled(!goal.isTrackable)
                }
            }
        }
    }
}

struct GoalPicker_Previews: PreviewProvider {
    static var previews: some View {
        GoalPicker()
            .preferredColorScheme(.dark)
    }
}

protocol PersonFormatterType {
    func string(from person: Person) -> String
}

struct PersonFormatter: PersonFormatterType {
    func string(from person: Person) -> String {
        "\(person.name) is a great person"
    }
}

struct Person {
    let name: String
}

struct PersonView: View {
    
    @ObservedObject var viewModel: PersonViewModel
    
    init(person: Person) {
        viewModel = .init(person: person)
    }
    
    var body: some View {
        Text(viewModel.text)
            .padding()
    }
}

class PersonViewModel: ObservableObject {
    
    // THIS WON'T WORK: 'self' used in property access 'formatter' before all stored properties are initialized
    @Injected private var formatter: PersonFormatterType
    
    // THIS WILL WORK
    private let formatter: PersonFormatterType = Resolver.main.resolve()

    let text: String

    init(person: Person) {
        text = formatter.string(from: person)
    }
}