Address initial PR comments

Author: bbrk24

Sources/UIKitBackend/UIKitBackend+Container.swift

@@ -18,9 +18,9 @@ final class ScrollWidget: ContainerWidget {
         scrollView.translatesAutoresizingMaskIntoConstraints = false
     }
 
-    override func viewWillLayoutSubviews() {
+    override func updateViewConstraints() {
         NSLayoutConstraint.activate(contentLayoutGuideConstraints)
-        super.viewWillLayoutSubviews()
+        super.updateViewConstraints()
     }
 
     func setScrollBars(

Sources/UIKitBackend/UIViewControllerRepresentable.swift

@@ -16,11 +16,11 @@ where Content == Never {
         -> UIViewControllerType
 
     /// Update the view with new values.
+    /// - Note: This may be called even when `context` has not changed.
     /// - Parameters:
     ///   - uiViewController: The controller to update.
     ///   - context: The context, including the coordinator and potentially new environment
     ///   values.
-    /// - Note: This may be called even when `context` has not changed.
     func updateUIViewController(
         _ uiViewController: UIViewControllerType,
         context: UIViewControllerRepresentableContext<Coordinator>)
@@ -32,31 +32,31 @@ where Content == Never {
     func makeCoordinator() -> Coordinator
 
     /// Compute the view's size.
+    ///
+    /// The default implementation uses `uiViewController.view.intrinsicContentSize` and
+    /// `uiViewController.view.systemLayoutSizeFitting(_:)` to determine the return value.
     /// - Parameters:
     ///   - proposal: The proposed frame for the view to render in.
     ///   - uiViewController: The controller being queried for its view's preferred size.
     ///   - context: The context, including the coordinator and environment values.
     /// - Returns: Information about the view's size. The ``SwiftCrossUI/ViewSize/size``
-    /// property is what frame the view will actually be rendered with if the current layout
-    /// pass is not a dry run, while the other properties are used to inform the layout engine
-    /// how big or small the view can be. The ``SwiftCrossUI/ViewSize/idealSize`` property
-    /// should not vary with the `proposal`, and should only depend on the view's contents.
-    /// Pass `nil` for the maximum width/height if the view has no maximum size (and therefore
-    /// may occupy the entire screen).
-    ///
-    /// The default implementation uses `uiViewController.view.intrinsicContentSize` and
-    /// `uiViewController.view.systemLayoutSizeFitting(_:)` to determine the return value.
+    ///   property is what frame the view will actually be rendered with if the current layout
+    ///   pass is not a dry run, while the other properties are used to inform the layout
+    ///   engine how big or small the view can be. The ``SwiftCrossUI/ViewSize/idealSize``
+    ///   property should not vary with the `proposal`, and should only depend on the view's
+    ///   contents. Pass `nil` for the maximum width/height if the view has no maximum size
+    ///   (and therefore may occupy the entire screen).
     func determineViewSize(
         for proposal: SIMD2<Int>, uiViewController: UIViewControllerType,
         context: UIViewControllerRepresentableContext<Coordinator>
     ) -> ViewSize
 
     /// Called to clean up the view when it's removed.
+    ///
+    /// The default implementation does nothing.
     /// - Parameters:
     ///   - uiViewController: The controller being dismantled.
     ///   - coordinator: The coordinator.
-    ///
-    /// The default implementation does nothing.
     static func dismantleUIViewController(
         _ uiViewController: UIViewControllerType, coordinator: Coordinator)
 }

Sources/UIKitBackend/Widget.swift

@@ -29,38 +29,70 @@ private protocol WidgetProtocolHelpers: WidgetProtocol {
 
 extension WidgetProtocolHelpers {
     func updateLeftConstraint() {
-        leftConstraint?.isActive = false
-        guard let superview = view.superview else { return }
-        leftConstraint = view.leftAnchor.constraint(
-            equalTo: superview.safeAreaLayoutGuide.leftAnchor, constant: CGFloat(x))
-        // Set the constraint priority for leftConstraint (and topConstraint) to just under
-        // "required" so that we don't get warnings about unsatisfiable constraints from
-        // scroll views, which position relative to their contentLayoutGuide instead.
-        // This *should* be high enough that it won't cause any problems unless there was
-        // a constraint conflict anyways.
-        leftConstraint!.priority = .init(UILayoutPriority.required.rawValue - 1.0)
-        leftConstraint!.isActive = true
+        guard let superview = view.superview else {
+            leftConstraint?.isActive = false
+            return
+        }
+
+        if let leftConstraint,
+            leftConstraint.secondAnchor === superview.safeAreaLayoutGuide.leftAnchor
+        {
+            leftConstraint.constant = CGFloat(x)
+            leftConstraint.isActive = true
+        } else {
+            self.leftConstraint?.isActive = false
+            let leftConstraint = view.leftAnchor.constraint(
+                equalTo: superview.safeAreaLayoutGuide.leftAnchor, constant: CGFloat(x))
+            self.leftConstraint = leftConstraint
+            // Set the constraint priority for leftConstraint (and topConstraint) to just
+            // under "required" so that we don't get warnings about unsatisfiable constraints
+            // from scroll views, which position relative to their contentLayoutGuide instead.
+            // This *should* be high enough that it won't cause any problems unless there was
+            // a constraint conflict anyways.
+            leftConstraint.priority = .init(UILayoutPriority.required.rawValue - 1.0)
+            leftConstraint.isActive = true
+        }
     }
 
     func updateTopConstraint() {
-        topConstraint?.isActive = false
-        guard let superview = view.superview else { return }
-        topConstraint = view.topAnchor.constraint(
-            equalTo: superview.safeAreaLayoutGuide.topAnchor, constant: CGFloat(y))
-        topConstraint!.priority = .init(UILayoutPriority.required.rawValue - 1.0)
-        topConstraint!.isActive = true
+        guard let superview = view.superview else {
+            topConstraint?.isActive = false
+            return
+        }
+
+        if let topConstraint,
+            topConstraint.secondAnchor === superview.safeAreaLayoutGuide.topAnchor
+        {
+            topConstraint.constant = CGFloat(y)
+            topConstraint.isActive = true
+        } else {
+            self.topConstraint?.isActive = false
+            let topConstraint = view.topAnchor.constraint(
+                equalTo: superview.safeAreaLayoutGuide.topAnchor, constant: CGFloat(y))
+            self.topConstraint = topConstraint
+            topConstraint.priority = .init(UILayoutPriority.required.rawValue - 1.0)
+            topConstraint.isActive = true
+        }
     }
 
     func updateWidthConstraint() {
-        widthConstraint?.isActive = false
-        widthConstraint = view.widthAnchor.constraint(equalToConstant: CGFloat(width))
-        widthConstraint!.isActive = true
+        if let widthConstraint {
+            widthConstraint.constant = CGFloat(width)
+        } else {
+            let widthConstraint = view.widthAnchor.constraint(equalToConstant: CGFloat(width))
+            self.widthConstraint = widthConstraint
+            widthConstraint.isActive = true
+        }
     }
 
     func updateHeightConstraint() {
-        heightConstraint?.isActive = false
-        heightConstraint = view.heightAnchor.constraint(equalToConstant: CGFloat(height))
-        heightConstraint!.isActive = true
+        if let heightConstraint {
+            heightConstraint.constant = CGFloat(height)
+        } else {
+            let heightConstraint = view.heightAnchor.constraint(equalToConstant: CGFloat(height))
+            self.heightConstraint = heightConstraint
+            heightConstraint.isActive = true
+        }
     }
 }