Keep minimized windows minimized when the global hotkey activates cmux

Sources/App/MainWindowVisibilityController.swift

@@ -293,8 +293,8 @@ final class MainWindowVisibilityController {
         consumeDismissedWindowRestoreTargets: Bool = true
     ) -> NSWindow? {
         let allWindows = uniqueWindows(allWindows)
-        let visibleOrMiniaturizedTargets = allWindows.filter { window in
-            dependencies.windowOperations.isVisible(window) || dependencies.windowOperations.isMiniaturized(window)
+        let visibleTargets = allWindows.filter { window in
+            dependencies.windowOperations.isVisible(window) && !dependencies.windowOperations.isMiniaturized(window)
         }
         let revealTargets: [NSWindow]
 
@@ -314,14 +314,16 @@ final class MainWindowVisibilityController {
             } else {
                 revealTargets = allWindows.filter { dependencies.windowOperations.isMiniaturized($0) }
             }
-        } else if !visibleOrMiniaturizedTargets.isEmpty {
-            revealTargets = visibleOrMiniaturizedTargets
+        } else if !visibleTargets.isEmpty {
+            revealTargets = visibleTargets
         } else {
             let dismissedTargets = dismissedWindowRestoreTargets.filter { dismissedWindow in
                 allWindows.contains { $0 === dismissedWindow }
             }
             dismissedWindowRestoreTargets.removeAll()
-            revealTargets = dismissedTargets
+            revealTargets = dismissedTargets.isEmpty
+                ? allWindows.filter { dependencies.windowOperations.isMiniaturized($0) }
+                : dismissedTargets
         }
 
         trace("show.begin", reason: reason, windows: revealTargets)

cmuxTests/MainWindowVisibilityControllerTests.swift

@@ -143,20 +143,20 @@ final class MainWindowVisibilityControllerTests: XCTestCase {
         XCTAssertFalse(deminiaturizedWindows.contains { $0 === miniaturizedWindow })
     }
 
-    func testShowApplicationWindowsStillRestoresMiniaturizedWindowsWhenNoHiddenTargetsWereCaptured() {
+    func testHiddenApplicationStillRestoresMiniaturizedWindowsWhenNoTargetsWereCaptured() {
         let miniaturizedWindow = makeWindow()
         defer { miniaturizedWindow.orderOut(nil) }
 
         var miniaturizedIds: Set<ObjectIdentifier> = [ObjectIdentifier(miniaturizedWindow)]
-        var deminiaturizedWindows: [NSWindow] = []
-        var madeKeyWindows: [NSWindow] = []
+        var deminiaturizedWindows: [NSWindow] = [], madeKeyWindows: [NSWindow] = []
         var activationCount = 0
 
         let controller = MainWindowVisibilityController(
             dependencies: .init(
                 isActivationSuppressed: { false },
                 setActiveMainWindow: { _ in },
-                isApplicationHidden: { false },
+                isApplicationHidden: { true },
+                unhideApplication: {},
                 activateRunningApplication: { _ in activationCount += 1 },
                 windowOperations: makeWindowOperations(
                     isMiniaturized: { miniaturizedIds.contains(ObjectIdentifier($0)) },

cmuxTests/MainWindowVisibilityLifecycleTests.swift

@@ -10,6 +10,89 @@ import Testing
 @MainActor
 @Suite
 struct MainWindowVisibilityLifecycleTests {
+    @Test
+    func backgroundHotkeyLeavesMiniaturizedWindowsInTheDock() {
+        let visibleWindow = makeWindow()
+        let miniaturizedWindow = makeWindow()
+        defer {
+            visibleWindow.orderOut(nil)
+            miniaturizedWindow.orderOut(nil)
+        }
+
+        let visibleId = ObjectIdentifier(visibleWindow)
+        var miniaturizedIds: Set<ObjectIdentifier> = [ObjectIdentifier(miniaturizedWindow)]
+        var deminiaturizedWindows: [NSWindow] = []
+        var madeKeyWindows: [NSWindow] = []
+        var activationCount = 0
+
+        let controller = MainWindowVisibilityController(
+            dependencies: .init(
+                isActivationSuppressed: { false },
+                setActiveMainWindow: { _ in },
+                isApplicationActive: { false },
+                isApplicationHidden: { false },
+                activateRunningApplication: { _ in activationCount += 1 },
+                windowOperations: makeWindowOperations(
+                    isVisible: { ObjectIdentifier($0) == visibleId },
+                    isMiniaturized: { miniaturizedIds.contains(ObjectIdentifier($0)) },
+                    deminiaturize: { window in
+                        miniaturizedIds.remove(ObjectIdentifier(window))
+                        deminiaturizedWindows.append(window)
+                    },
+                    makeKey: { madeKeyWindows.append($0) }
+                )
+            )
+        )
+
+        controller.toggleApplicationVisibility(
+            windows: [visibleWindow, miniaturizedWindow],
+            reason: .globalHotkey
+        )
+
+        #expect(activationCount == 1)
+        #expect(madeKeyWindows.contains { $0 === visibleWindow })
+        #expect(!deminiaturizedWindows.contains { $0 === miniaturizedWindow })
+    }
+
+    @Test
+    func backgroundHotkeyRestoresMiniaturizedWindowsWhenAllWindowsAreMinimized() {
+        let miniaturizedWindow = makeWindow()
+        defer { miniaturizedWindow.orderOut(nil) }
+
+        let miniaturizedId = ObjectIdentifier(miniaturizedWindow)
+        var miniaturizedIds: Set<ObjectIdentifier> = [miniaturizedId]
+        var deminiaturizedWindows: [NSWindow] = []
+        var madeKeyWindows: [NSWindow] = []
+        var activationCount = 0
+
+        let controller = MainWindowVisibilityController(
+            dependencies: .init(
+                isActivationSuppressed: { false },
+                setActiveMainWindow: { _ in },
+                isApplicationActive: { false },
+                isApplicationHidden: { false },
+                activateRunningApplication: { _ in activationCount += 1 },
+                windowOperations: makeWindowOperations(
+                    isMiniaturized: { miniaturizedIds.contains(ObjectIdentifier($0)) },
+                    deminiaturize: { window in
+                        miniaturizedIds.remove(ObjectIdentifier(window))
+                        deminiaturizedWindows.append(window)
+                    },
+                    makeKey: { madeKeyWindows.append($0) }
+                )
+            )
+        )
+
+        controller.toggleApplicationVisibility(
+            windows: [miniaturizedWindow],
+            reason: .globalHotkey
+        )
+
+        #expect(activationCount == 1)
+        #expect(deminiaturizedWindows.contains { $0 === miniaturizedWindow })
+        #expect(madeKeyWindows.contains { $0 === miniaturizedWindow })
+    }
+
     @Test
     func discardClosedWindowRemovesHiddenRestoreTarget() {
         let window = makeWindow()