Unexpected sharing of overrides in SwiftUI Preview traits

[cabeca]

Hello there!
In this short example:

import Dependencies
import IssueReporting
import Foundation
import SwiftUI

struct SampleClient {
    var func1: @Sendable () throws -> String
    var func2: @Sendable () throws -> String
}

extension SampleClient: DependencyKey {
    static let liveValue = SampleClient(
        func1: { "LiveFunc1" },
        func2: { "LiveFunc2" }
    )
    static let previewValue: SampleClient = SampleClient(
        func1: { "MockFunc1" },
        func2: { "MockFunc2" }
    )
    static let testValue: SampleClient = SampleClient(
        func1: IssueReporting.unimplemented("UnimplementedFunc1"),
        func2: IssueReporting.unimplemented("UnimplementedFunc2")
    )
}

extension DependencyValues {
    var sampleClient: SampleClient {
        get { self[SampleClient.self] }
        set { self[SampleClient.self] = newValue }
    }
}

struct ContentView: View {
    @Dependency(\.sampleClient) var sampleClient
    var body: some View {
        VStack {
            Text(try! self.sampleClient.func1())
                .font(.system(size: 50))
            Text(try! self.sampleClient.func2())
                .font(.system(size: 50))
        }
    }
}

@available(iOS 18, *)
#Preview(
    "Preview1",
    traits: .dependencies {
        $0.sampleClient.func1 = { @Sendable in "Preview1" }
    }
) {
    ContentView()
}

@available(iOS 18, *)
#Preview(
    "Preview2",
    traits: .dependencies {
        $0.sampleClient.func2 = { @Sendable in "Preview2" }
    }
) {
    ContentView()
}

I always get this result for both previews:

Is this expected behavior?

I would expect the previews to show this instead:

// Preview1
Preview1
MockFunc2

// Preview2
MockFunc1
Preview2

@mbrandonw @stephencelis Why are the dependency overrides being shared between Previews?

[stephencelis]

@cabeca This is a quirk/bug of Xcode previews. If you have multiple defined in a single file, they will all execute even though you're only viewing a single one. You should be able to reproduce this in a vanilla project, so we think it's worth filing feedback if you find the behavior surprising.

Preview traits only provide a "modifier" extension to apply to a view after it's been computed, which we can't leverage, so instead our trait is simply a shorthand for prepareDependencies, which globally overrides dependencies for the process. This global is going to bleed over to other previews defined in the same file as a result. We're open to ideas on how to improve this, but we're not sure it's possible to address.

So for now, we recommend one of the following workarounds:

• Use withDependencies instead of the preview trait to scope dependencies when defining multiple in the same file.
• Only define a single preview per file

[cabeca]

Thank you for the response. I'll revert back to using withDependencies which was what I had before. Reading the Preview traits documentation, it is somehow explicit that these traits are shared between all the previews. Quite surprising to be honest.

[mbrandonw]

FWIW it does seem that using prepareDependencies works around this problem:

@available(iOS 18, *)
#Preview("Preview1") {
  let _ = prepareDependencies {
    $0.sampleClient.func1 = { @Sendable in "Preview1" }
  }
  ContentView()
}

@available(iOS 18, *)
#Preview("Preview2") {
  let _ = prepareDependencies {
    $0.sampleClient.func2 = { @Sendable in "Preview2" }
  }
  ContentView()
}

It seems that traits for all previews are executed when any particular preview runs, but we can still prepare the dependencies for just one particular preview in isolation. We may want to even consider deprecating the dependency preview trait and recommend that people just use prepareDependencies.

[cabeca]

What is the advantage of using

#Preview("Preview1") {
  let _ = prepareDependencies {
    $0.sampleClient.func1 = { @Sendable in "Preview1" }
  }
  ContentView(
    model: ContentModel(...)
  )
}

versus doing what I was already doing before trying to change to Preview traits?

#Preview("Preview1") {
  ContentView(
    model: withDependencies {
     $0.sampleClient.func1 = { @Sendable in "Preview1" }
    } operation: {
      ContentModel(...)
    }
  )
}

Is it "just" the removal of indentation?

[mbrandonw]

There is a difference between these. The first will globally override sampleClient.func1 for the entire duration of the preview. But, you can only override sampleClient a single time using prepareDependencies.

The second overrides sampleClient.func1 just for the duration of the operation closure being executed. If any @Dependencys happen to be executed in that operation scope then they will capture the dependencies and keep them around for later use. But if later some code is executed that creates a new @Dependency (like say presenting a feature with dependencies), then those dependencies will go back to their defaults and not be overridden.

[cabeca]

Thank you for the explanation of the different approaches. I have now converted my code to use prepareDependencies, as it is closer to what I wanted to achieve with the Preview traits, before discovering its limitations.

Regarding deprecating the preview trait, I'm not sure it warrants a deprecation, but definitely a callout about its limitations.