Add dedicated create-PR window, load branch tip history on demand, and relayout diff on resize

macgit/App/CreatePullRequestWindowController.swift

@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import AppKit
+import Combine
+import SwiftUI
+
+@MainActor
+final class CreatePullRequestWindowController: NSWindowController, NSWindowDelegate, ObservableObject {
+    private var onClose: (() -> Void)?
+    @Published private(set) var cancelRequestID = UUID()
+
+    init() {
+        super.init(window: nil)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func show<Content: View>(repositoryName: String, content: Content, onClose: @escaping () -> Void) {
+        close()
+        self.onClose = onClose
+
+        let screen = NSApp.keyWindow?.screen ?? NSScreen.main
+        let visibleFrame = screen?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1200, height: 800)
+        let size = NSSize(
+            width: min(1080, visibleFrame.width - 40),
+            height: min(720, visibleFrame.height - 80)
+        )
+        let window = NSWindow(
+            contentRect: NSRect(origin: .zero, size: size),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = "Create Pull Request — \(repositoryName)"
+        window.isReleasedWhenClosed = false
+        window.tabbingMode = .disallowed
+        window.contentMinSize = NSSize(width: min(820, size.width), height: min(520, size.height))
+        window.delegate = self
+
+        let hostingView = NSHostingView(rootView: content)
+        hostingView.sizingOptions = []
+        window.contentView = hostingView
+        window.setContentSize(size)
+        window.setFrameOrigin(NSPoint(
+            x: visibleFrame.midX - window.frame.width / 2,
+            y: visibleFrame.midY - window.frame.height / 2
+        ))
+        self.window = window
+        showWindow(nil)
+        window.makeKeyAndOrderFront(nil)
+    }
+
+    override func close() {
+        window?.close()
+    }
+
+    func activateIfPresented() -> Bool {
+        guard let window else { return false }
+        if window.isMiniaturized {
+            window.deminiaturize(nil)
+        }
+        window.makeKeyAndOrderFront(nil)
+        return true
+    }
+
+    func windowShouldClose(_ sender: NSWindow) -> Bool {
+        cancelRequestID = UUID()
+        return false
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        let callback = onClose
+        onClose = nil
+        window = nil
+        callback?()
+    }
+}
+
+struct CreatePullRequestWindowContent: View {
+    @ObservedObject var controller: PullRequestController
+    @ObservedObject var windowController: CreatePullRequestWindowController
+    let seed: PullRequestDraftSeed
+    let repositoryURL: URL
+    let authorizeAction: () async -> Bool
+    let onGenerateText: PullRequestAIGenerationAction
+    let onCancel: () -> Void
+    let onCreate: (PullRequestDraft) async -> Void
+    @State private var isSubmitting = false
+
+    var body: some View {
+        CreatePullRequestView(
+            seed: seed,
+            repositoryURL: repositoryURL,
+            isSubmitting: isSubmitting || controller.isPerformingAction,
+            changedFileCount: controller.createDraftChangedFileCount,
+            isLoadingChanges: controller.isLoadingCreateDraftChanges,
+            changesErrorMessage: controller.createDraftChangesErrorMessage,
+            participants: controller.createDraftParticipants,
+            isLoadingParticipants: controller.isLoadingCreateDraftParticipants,
+            participantsErrorMessage: controller.createDraftParticipantsErrorMessage,
+            loadSourceBranches: { query in
+                await controller.loadCreateDraftSourceBranches(query: query)
+            },
+            loadTargetBranches: { query in
+                await controller.loadCreateDraftTargetBranches(query: query)
+            },
+            onGenerateText: onGenerateText,
+            onCancel: onCancel,
+            onBranchesChanged: { sourceBranch, targetBranch in
+                Task {
+                    guard await authorizeAction() else { return }
+                    if let targetBranch {
+                        await controller.loadCreateDraftChanges(
+                            sourceBranch: sourceBranch,
+                            targetBranch: targetBranch
+                        )
+                    } else {
+                        controller.resetCreateDraftChanges()
+                    }
+                }
+            },
+            onCreate: { draft in
+                guard !isSubmitting else { return }
+                isSubmitting = true
+                Task {
+                    await onCreate(draft)
+                    isSubmitting = false
+                }
+            },
+            isPresentedInWindow: true,
+            cancelRequestID: windowController.cancelRequestID
+        )
+        .overlay {
+            if isSubmitting || controller.isPerformingAction {
+                ZStack {
+                    Color(nsColor: .windowBackgroundColor)
+                        .opacity(0.72)
+                    ProgressView("Creating pull request…")
+                        .controlSize(.large)
+                }
+                .ignoresSafeArea()
+            }
+        }
+        .alert("Pull Request", isPresented: detailErrorPresented) {
+            Button("OK", role: .cancel) {
+                controller.detailErrorMessage = nil
+            }
+        } message: {
+            Text(controller.detailErrorMessage ?? "Could not create pull request.")
+        }
+    }
+
+    private var detailErrorPresented: Binding<Bool> {
+        Binding(
+            get: { controller.detailErrorMessage != nil },
+            set: { isPresented in
+                if !isPresented {
+                    controller.detailErrorMessage = nil
+                }
+            }
+        )
+    }
+}

macgit/App/PullRequestController.swift

@@ -274,6 +274,74 @@ final class PullRequestController: ObservableObject {
         await loadPullRequests(remoteURLString: remoteURLString, page: page, forceRefresh: forceRefresh)
     }
 
+    func prepareCreatePullRequest(
+        repositoryURL: URL,
+        remoteName requestedRemoteName: String? = nil,
+        sourceBranch: String? = nil
+    ) async {
+        activeRepositoryURL = repositoryURL
+        detailErrorMessage = nil
+
+        let remoteName = if let requestedRemoteName {
+            requestedRemoteName
+        } else {
+            await remoteNameProvider(repositoryURL)
+        }
+        guard let remoteName,
+              let remoteURLString = await remoteURLProvider(repositoryURL, remoteName) else {
+            detailErrorMessage = "No remotes configured."
+            return
+        }
+        guard let remoteIdentity = GitRemoteIdentityResolver.identity(
+            from: remoteURLString,
+            knownGitLabHosts: connectedGitLabHosts,
+            knownHosts: providerAccountController.accounts.map {
+                GitProviderHost(kind: $0.provider, baseURL: $0.hostURL)
+            }
+        ) else {
+            detailErrorMessage = PullRequestProviderError.unsupportedProvider.localizedDescription
+            return
+        }
+
+        let repository = GitRepositoryIdentity(
+            provider: remoteIdentity.provider,
+            hostURL: remoteIdentity.hostURL,
+            owner: remoteIdentity.ownerPath,
+            name: remoteIdentity.repositoryName
+        )
+        let matchingAccounts = matchingAccounts(for: repository)
+        guard !matchingAccounts.isEmpty else {
+            accountConnectionHost = GitProviderHost(
+                kind: repository.provider,
+                baseURL: repository.hostURL
+            ).normalized
+            detailErrorMessage = "Connect Account..."
+            return
+        }
+        guard let apiCredential = apiCredential(for: matchingAccounts) else {
+            accountConnectionHost = GitProviderHost(
+                kind: repository.provider,
+                baseURL: repository.hostURL
+            ).normalized
+            detailErrorMessage = matchingAccounts.contains(where: supportsProviderAPI)
+                ? "Reconnect..."
+                : "Connect Account..."
+            return
+        }
+        guard services[repository.provider] != nil else {
+            detailErrorMessage = PullRequestProviderError.unsupportedProvider.localizedDescription
+            return
+        }
+
+        activeRemoteName = remoteName
+        activeRemoteURLString = remoteURLString
+        activeRepository = repository
+        activeToken = apiCredential.token
+        selectedProviderAccountID = apiCredential.account.id
+        accountConnectionHost = nil
+        await presentCreatePullRequest(sourceBranch: sourceBranch)
+    }
+
     func loadPullRequests(
         repositoryURL: URL,
         remoteName: String,

macgit/ViewModels/HistoryListModel.swift

@@ -256,11 +256,21 @@ final class HistoryListModel {
         storeSnapshot()
     }
 
-    func selectBranchTipIfPossible() {
-        guard branchFilter == .all, activeSearchQuery.isEmpty, publishedKey == loadKey,
-              let selectedBranch, let hash = branchTips[selectedBranch], let tip = commit(hash) else { return }
+    func selectReferenceTipIfLoaded(_ reference: String) async -> Bool {
+        guard branchFilter == .all, activeSearchQuery.isEmpty, publishedKey == loadKey else { return false }
+        let requestedGeneration = generation
+        let requestedKey = loadKey
+        let hash: String?
+        if let loadedHash = branchTips[reference] {
+            hash = loadedHash
+        } else {
+            hash = await GitStatusService.shared.tipHash(for: reference, in: repositoryURL)
+        }
+        guard generation == requestedGeneration, loadKey == requestedKey,
+              selectedBranch == reference, let hash, let tip = commit(hash) else { return false }
         select(tip, focus: true)
         storeSnapshot()
+        return true
     }
 
     func clearCache() { cache.removeAll() }

macgit/Views/Common/DiffNativeTable.swift

@@ -58,8 +58,9 @@ struct DiffNativeTable<Content: View>: NSViewRepresentable {
         private var panels: [Int: DiffNativeHunkView] = [:]
         private var recycledPanels: [DiffNativeHunkView] = []
         private var widthTask: Task<Void, Never>?
-        private var observer: NSObjectProtocol?
+        private var observers: [NSObjectProtocol] = []
         private var updating = false
+        private var needsRelayout = false
 
         /// Keep one viewport of fully configured content on either side of the
         /// clip. This moves hosting-view reuse away from the hunk boundary the
@@ -149,21 +150,52 @@ struct DiffNativeTable<Content: View>: NSViewRepresentable {
 
         func observe(_ scroll: NSScrollView) {
             scroll.contentView.postsBoundsChangedNotifications = true
-            observer = NotificationCenter.default.addObserver(
+            scroll.contentView.postsFrameChangedNotifications = true
+            document.postsFrameChangedNotifications = true
+            let center = NotificationCenter.default
+            observers.append(center.addObserver(
                 forName: NSView.boundsDidChangeNotification, object: scroll.contentView,
                 queue: .main
             ) { [weak self, weak scroll] _ in
                 MainActor.assumeIsolated {
                     guard let self, let scroll else { return }
                     self.layout(scroll)
                 }
-            }
+            })
+            observers.append(center.addObserver(
+                forName: NSView.frameDidChangeNotification, object: scroll.contentView,
+                queue: .main
+            ) { [weak self, weak scroll] _ in
+                MainActor.assumeIsolated {
+                    guard let self, let scroll else { return }
+                    self.layout(scroll)
+                }
+            })
+            observers.append(center.addObserver(
+                forName: NSView.frameDidChangeNotification, object: document,
+                queue: .main
+            ) { [weak self, weak scroll] _ in
+                MainActor.assumeIsolated {
+                    guard let self, let scroll else { return }
+                    self.layout(scroll)
+                }
+            })
         }
 
         private func layout(_ scroll: NSScrollView, refresh: Bool = false) {
-            guard let model, !updating else { return }
+            guard let model else { return }
+            guard !updating else {
+                needsRelayout = true
+                return
+            }
             updating = true
-            defer { updating = false }
+            defer {
+                updating = false
+                if needsRelayout {
+                    needsRelayout = false
+                    layout(scroll)
+                }
+            }
             let bounds = scroll.contentView.bounds
             let size = CGSize(
                 width: max(1, bounds.width), height: max(bounds.height, geometry.height))
@@ -263,8 +295,8 @@ struct DiffNativeTable<Content: View>: NSViewRepresentable {
             widthTask = nil
             for panel in panels.values { panel.canvas.cancelPendingWork() }
             textStore.cancel()
-            if let observer { NotificationCenter.default.removeObserver(observer) }
-            observer = nil
+            for observer in observers { NotificationCenter.default.removeObserver(observer) }
+            observers.removeAll()
         }
     }
 }

macgit/Views/History/HistoryScreen.swift

@@ -106,7 +106,13 @@ struct HistoryScreen: View {
         .onChange(of: baseBranch) { _, value in listModel.baseBranch = value }
         .onChange(of: selectedBranch) { _, value in
             listModel.selectedBranch = value
-            listModel.selectBranchTipIfPossible()
+            guard let value else { return }
+            Task {
+                let selectedLoadedTip = await listModel.selectReferenceTipIfLoaded(value)
+                guard !Task.isCancelled, !selectedLoadedTip,
+                      selectedBranch == value, branchFilter == .all else { return }
+                branchFilter = .branch(value)
+            }
         }
         .onChange(of: searchText) { _, value in listModel.setSearchText(value) }
         .onChange(of: historyLoadSizeRaw) { _, value in