[feat]: add support for sizingOptions to SwiftUIScreen

Development.podspec

@@ -109,6 +109,12 @@ Pod::Spec.new do |s|
     test_spec.framework = 'XCTest'
   end
 
+  s.test_spec 'WorkflowSwiftUIExperimentalTests' do |test_spec|
+    test_spec.requires_app_host = true
+    test_spec.source_files = 'WorkflowSwiftUIExperimental/Tests/**/*.swift'
+    test_spec.framework = 'XCTest'
+  end
+
   s.test_spec 'WorkflowTests' do |test_spec|
     test_spec.requires_app_host = true
     test_spec.source_files = 'Workflow/Tests/**/*.swift'

WorkflowSwiftUIExperimental.podspec

@@ -22,4 +22,16 @@ Pod::Spec.new do |s|
     s.dependency 'WorkflowUI', "~> #{WORKFLOW_MAJOR_VERSION}.0"
 
     s.pod_target_xcconfig = { 'APPLICATION_EXTENSION_API_ONLY' => 'YES' }
+
+    s.test_spec 'Tests' do |test_spec|
+      test_spec.source_files = 'WorkflowSwiftUIExperimental/Tests/**/*.swift'
+      test_spec.framework = 'XCTest'
+      test_spec.library = 'swiftos'
+
+      # Create an app host so that we can host
+      # view or view controller based tests in a real environment.
+      test_spec.requires_app_host = true
+
+      test_spec.pod_target_xcconfig = { 'APPLICATION_EXTENSION_API_ONLY' => 'NO' }
+    end
   end

WorkflowSwiftUIExperimental/Sources/SwiftUIScreen.swift

@@ -23,14 +23,20 @@ import WorkflowUI
 public protocol SwiftUIScreen: Screen {
     associatedtype Content: View
 
+    var sizingOptions: SwiftUIScreenSizingOptions { get }
+
     @ViewBuilder
     static func makeView(model: ObservableValue<Self>) -> Content
 
     static var isEquivalent: ((Self, Self) -> Bool)? { get }
 }
 
 public extension SwiftUIScreen {
-    static var isEquivalent: ((Self, Self) -> Bool)? { return nil }
+    var sizingOptions: SwiftUIScreenSizingOptions { [] }
+}
+
+public extension SwiftUIScreen {
+    static var isEquivalent: ((Self, Self) -> Bool)? { nil }
 }
 
 public extension SwiftUIScreen where Self: Equatable {
@@ -53,17 +59,29 @@ public extension SwiftUIScreen {
                             viewEnvironment: viewEnvironment,
                             content: Self.makeView(model: model)
                         )
-                    })
+                    }),
+                    swiftUIScreenSizingOptions: sizingOptions
                 )
             },
             update: {
                 $0.modelSink.send(self)
                 $0.viewEnvironmentSink.send(environment)
+                $0.swiftUIScreenSizingOptions = sizingOptions
             }
         )
     }
 }
 
+public struct SwiftUIScreenSizingOptions: OptionSet {
+    public let rawValue: Int
+
+    public init(rawValue: Int) {
+        self.rawValue = rawValue
+    }
+
+    public static let preferredContentSize: SwiftUIScreenSizingOptions = .init(rawValue: 1 << 0)
+}
+
 private struct EnvironmentInjectingView<Content: View>: View {
     @ObservedObject var viewEnvironment: ObservableValue<ViewEnvironment>
     let content: Content
@@ -77,17 +95,104 @@ private struct EnvironmentInjectingView<Content: View>: View {
 private final class ModeledHostingController<Model, Content: View>: UIHostingController<Content> {
     let modelSink: Sink<Model>
     let viewEnvironmentSink: Sink<ViewEnvironment>
+    var swiftUIScreenSizingOptions: SwiftUIScreenSizingOptions {
+        didSet {
+            updateSizingOptionsIfNeeded()
 
-    init(modelSink: Sink<Model>, viewEnvironmentSink: Sink<ViewEnvironment>, rootView: Content) {
+            if !hasLaidOutOnce {
+                setNeedsLayoutBeforeFirstLayoutIfNeeded()
+            }
+        }
+    }
+
+    private var hasLaidOutOnce = false
+
+    init(
+        modelSink: Sink<Model>,
+        viewEnvironmentSink: Sink<ViewEnvironment>,
+        rootView: Content,
+        swiftUIScreenSizingOptions: SwiftUIScreenSizingOptions
+    ) {
         self.modelSink = modelSink
         self.viewEnvironmentSink = viewEnvironmentSink
+        self.swiftUIScreenSizingOptions = swiftUIScreenSizingOptions
 
         super.init(rootView: rootView)
+
+        updateSizingOptionsIfNeeded()
     }
 
     required init?(coder aDecoder: NSCoder) {
         fatalError("not implemented")
     }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        view.backgroundColor = .clear
+
+        setNeedsLayoutBeforeFirstLayoutIfNeeded()
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+
+        defer { hasLaidOutOnce = true }
+
+        if #available(iOS 16.0, *) {
+            // Handled in initializer, but set it on first layout to resolve a bug where the PCS is
+            // not updated appropriately after the first layout.
+            // UI-5797
+            if !hasLaidOutOnce,
+                swiftUIScreenSizingOptions.contains(.preferredContentSize) {
+                let size = view.sizeThatFits(view.frame.size)
+
+                if preferredContentSize != size {
+                    preferredContentSize = size
+                }
+            }
+        } else if swiftUIScreenSizingOptions.contains(.preferredContentSize) {
+            let size = view.sizeThatFits(view.frame.size)
+
+            if preferredContentSize != size {
+                preferredContentSize = size
+            }
+        }
+    }
+
+    private func updateSizingOptionsIfNeeded() {
+        if #available(iOS 16.0, *) {
+            self.sizingOptions = swiftUIScreenSizingOptions.uiHostingControllerSizingOptions
+        }
+
+        if !swiftUIScreenSizingOptions.contains(.preferredContentSize),
+            preferredContentSize != .zero {
+            preferredContentSize = .zero
+        }
+    }
+
+    private func setNeedsLayoutBeforeFirstLayoutIfNeeded() {
+        if swiftUIScreenSizingOptions.contains(.preferredContentSize) {
+            // Without manually calling setNeedsLayout here it was observed that a call to
+            // layoutIfNeeded() immediately after loading the view would not perform a layout, and
+            // therefore would not update the preferredContentSize in viewDidLayoutSubviews().
+            // UI-5797
+            view.setNeedsLayout()
+        }
+    }
+}
+
+extension SwiftUIScreenSizingOptions {
+    @available(iOS 16.0, *)
+    fileprivate var uiHostingControllerSizingOptions: UIHostingControllerSizingOptions {
+        var options = UIHostingControllerSizingOptions()
+
+        if contains(.preferredContentSize) {
+            options.insert(.preferredContentSize)
+        }
+
+        return options
+    }
 }
 
 #endif

WorkflowSwiftUIExperimental/Tests/SwiftUIScreenTests.swift

@@ -0,0 +1,64 @@
+import SwiftUI
+import UIKit
+import WorkflowSwiftUIExperimental
+import XCTest
+
+final class SwiftUIScreenTests: XCTestCase {
+    func test_noSizingOptions() {
+        let viewController = ContentScreen(sizingOptions: [])
+            .buildViewController(in: .empty)
+
+        viewController.view.layoutIfNeeded()
+
+        XCTAssertEqual(viewController.preferredContentSize, .zero)
+    }
+
+    func test_preferredContentSize() {
+        let viewController = ContentScreen(sizingOptions: .preferredContentSize)
+            .buildViewController(in: .empty)
+
+        viewController.view.layoutIfNeeded()
+
+        XCTAssertEqual(
+            viewController.preferredContentSize,
+            .init(width: 42, height: 42)
+        )
+    }
+
+    func test_preferredContentSize_sizingOptionsChanges() {
+        let viewController = ContentScreen(sizingOptions: [])
+            .buildViewController(in: .empty)
+
+        viewController.view.layoutIfNeeded()
+
+        XCTAssertEqual(viewController.preferredContentSize, .zero)
+
+        ContentScreen(sizingOptions: .preferredContentSize)
+            .viewControllerDescription(environment: .empty)
+            .update(viewController: viewController)
+
+        viewController.view.layoutIfNeeded()
+
+        XCTAssertEqual(
+            viewController.preferredContentSize,
+            .init(width: 42, height: 42)
+        )
+
+        ContentScreen(sizingOptions: [])
+            .viewControllerDescription(environment: .empty)
+            .update(viewController: viewController)
+
+        viewController.view.layoutIfNeeded()
+
+        XCTAssertEqual(viewController.preferredContentSize, .zero)
+    }
+}
+
+private struct ContentScreen: SwiftUIScreen {
+    let sizingOptions: SwiftUIScreenSizingOptions
+
+    static func makeView(model: ObservableValue<ContentScreen>) -> some View {
+        Color.clear
+            .frame(width: 42, height: 42)
+    }
+}