appkit: revert to swift 6 compatible but lopsided support.

* This ensures scui works with swift 6 strict concurrency - however it is lopsided in that makeCoordinator() is not marked with a main actor.

Signed-off-by: furby™ <devs@wabi.foundation>

Author: furby-tm

Sources/AppKitBackend/BaseWidget.swift

@@ -0,0 +1,123 @@
+import AppKit
+
+public class BaseWidget: NSView {
+    private var leftConstraint: NSLayoutConstraint?
+    private var topConstraint: NSLayoutConstraint?
+    private var widthConstraint: NSLayoutConstraint?
+    private var heightConstraint: NSLayoutConstraint?
+
+    var x = 0 {
+        didSet {
+            if x != oldValue {
+                updateLeftConstraint()
+            }
+        }
+    }
+
+    var y = 0 {
+        didSet {
+            if y != oldValue {
+                updateTopConstraint()
+            }
+        }
+    }
+
+    var width = 0 {
+        didSet {
+            if width != oldValue {
+                updateWidthConstraint()
+            }
+        }
+    }
+
+    var height = 0 {
+        didSet {
+            if height != oldValue {
+                updateHeightConstraint()
+            }
+        }
+    }
+
+    init() {
+        super.init(frame: .zero)
+
+        self.translatesAutoresizingMaskIntoConstraints = false
+    }
+
+    @available(*, unavailable)
+    public required init?(coder: NSCoder) {
+        fatalError("init(coder:) is not used for this view")
+    }
+
+    private func updateLeftConstraint() {
+        leftConstraint?.isActive = false
+        guard let superview else { return }
+        if #available(macOS 11.0, *) {
+            leftConstraint = self.leftAnchor.constraint(
+                equalTo: superview.safeAreaLayoutGuide.leftAnchor, constant: CGFloat(x))
+        } else {
+            leftConstraint = self.leftAnchor.constraint(
+                equalTo: superview.leftAnchor, constant: CGFloat(x))
+        }
+        leftConstraint!.isActive = true
+    }
+
+    private func updateTopConstraint() {
+        topConstraint?.isActive = false
+        guard let superview else { return }
+        if #available(macOS 11.0, *) {
+            topConstraint = self.topAnchor.constraint(
+                equalTo: superview.safeAreaLayoutGuide.topAnchor, constant: CGFloat(x))
+        } else {
+            topConstraint = self.topAnchor.constraint(
+                equalTo: superview.topAnchor, constant: CGFloat(x))
+        }
+        topConstraint!.isActive = true
+    }
+
+    private func updateWidthConstraint() {
+        widthConstraint?.isActive = false
+        widthConstraint = self.widthAnchor.constraint(equalToConstant: CGFloat(width))
+        widthConstraint!.isActive = true
+    }
+
+    private func updateHeightConstraint() {
+        heightConstraint?.isActive = false
+        heightConstraint = self.heightAnchor.constraint(equalToConstant: CGFloat(height))
+        heightConstraint!.isActive = true
+    }
+
+    public override func viewDidMoveToSuperview() {
+        super.viewDidMoveToSuperview()
+
+        updateLeftConstraint()
+        updateTopConstraint()
+    }
+}
+
+class WrapperWidget<View: NSView>: BaseWidget {
+    init(child: View) {
+        super.init()
+
+        self.addSubview(child)
+        child.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            child.topAnchor.constraint(equalTo: self.topAnchor),
+            child.leadingAnchor.constraint(equalTo: self.leadingAnchor),
+            child.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+            child.trailingAnchor.constraint(equalTo: self.trailingAnchor),
+        ])
+    }
+
+    override convenience init() {
+        self.init(child: View(frame: .zero))
+    }
+
+    var child: View {
+        subviews[0] as! View
+    }
+
+    override var intrinsicContentSize: CGSize {
+        child.intrinsicContentSize
+    }
+}

Sources/AppKitBackend/NSViewRepresentable.swift

@@ -27,7 +27,6 @@ public protocol NSViewRepresentable: View where Content == Never {
     ///
     /// The coordinator is used when the view needs to communicate changes to the rest of
     /// the view hierarchy (i.e. through bindings), and is often the view's delegate.
-    @MainActor
     func makeCoordinator() -> Coordinator
 
     /// Compute the view's size.
@@ -151,6 +150,11 @@ extension View where Self: NSViewRepresentable {
                 context: representingWidget.context!
             )
 
+        if !dryRun {
+            representingWidget.width = size.size.x
+            representingWidget.height = size.size.y
+        }
+
         return ViewUpdateResult.leafView(size: size)
     }
 }
@@ -162,20 +166,26 @@ extension NSViewRepresentable where Coordinator == Void {
 }
 
 
-final class RepresentingWidget<Representable: NSViewRepresentable> {
+final class RepresentingWidget<Representable: NSViewRepresentable>: BaseWidget {
     var representable: Representable
     var context: NSViewRepresentableContext<Representable.Coordinator>?
 
-    @MainActor
     lazy var subview: Representable.NSViewType = {
         let view = representable.makeNSView(context: context!)
 
+        self.addSubview(view)
+
         view.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            view.topAnchor.constraint(equalTo: self.topAnchor),
+            view.leadingAnchor.constraint(equalTo: self.leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: self.trailingAnchor),
+            view.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+        ])
 
         return view
     }()
 
-    @MainActor
     func update(with environment: EnvironmentValues) {
         if context == nil {
             context = .init(coordinator: representable.makeCoordinator(), environment: environment)
@@ -187,5 +197,12 @@ final class RepresentingWidget<Representable: NSViewRepresentable> {
 
     init(representable: Representable) {
         self.representable = representable
+        super.init()
+    }
+
+    deinit {
+        if let context {
+            Representable.dismantleNSView(subview, coordinator: context.coordinator)
+        }
     }
 }