AppKitNavigation - Navigation

Package.swift

@@ -82,9 +82,13 @@ let package = Package(
     .target(
       name: "AppKitNavigation",
       dependencies: [
-        "SwiftNavigation"
+        "SwiftNavigation",
+        "AppKitNavigationShim",
       ]
     ),
+    .target(
+      name: "AppKitNavigationShim"
+    ),
     .testTarget(
       name: "UIKitNavigationTests",
       dependencies: [

Package@swift-6.0.swift

@@ -83,8 +83,12 @@ let package = Package(
       name: "AppKitNavigation",
       dependencies: [
         "SwiftNavigation",
+        "AppKitNavigationShim",
       ]
     ),
+    .target(
+      name: "AppKitNavigationShim"
+    ),
     .testTarget(
       name: "UIKitNavigationTests",
       dependencies: [

Sources/AppKitNavigation/AppKitAnimation.swift

@@ -43,8 +43,8 @@
         return try result!._rethrowGet()
 
       case let .swiftUI(animation):
-        var result: Swift.Result<Result, Error>?
         #if swift(>=6)
+          var result: Swift.Result<Result, Error>?
           if #available(macOS 15, *) {
             NSAnimationContext.animate(animation) {
               result = Swift.Result(catching: body)

Sources/AppKitNavigation/Internal/AssociatedKeys.swift

@@ -0,0 +1,36 @@
+#if canImport(AppKit) && !targetEnvironment(macCatalyst)
+
+import AppKit
+
+struct AssociatedKeys {
+    var keys: [AnyHashableMetatype: UnsafeMutableRawPointer] = [:]
+
+    mutating func key<T>(of type: T.Type) -> UnsafeMutableRawPointer {
+        let key = AnyHashableMetatype(type)
+        if let associatedKey = keys[key] {
+            return associatedKey
+        } else {
+            let associatedKey = malloc(1)!
+            keys[key] = associatedKey
+            return associatedKey
+        }
+    }
+}
+
+struct AnyHashableMetatype: Hashable {
+    static func == (lhs: AnyHashableMetatype, rhs: AnyHashableMetatype) -> Bool {
+        return lhs.base == rhs.base
+    }
+
+    let base: Any.Type
+
+    init(_ base: Any.Type) {
+        self.base = base
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(base))
+    }
+}
+
+#endif

Sources/AppKitNavigation/Navigation/Modal.swift

@@ -0,0 +1,200 @@
+#if canImport(AppKit) && !targetEnvironment(macCatalyst)
+
+import AppKit
+
+@MainActor
+private var modalObserverKeys = AssociatedKeys()
+
+private typealias ModalObserver<Content: ModalContent> = NavigationObserver<NSObject, Content>
+
+@MainActor
+extension NSObject {
+    @discardableResult
+    public func modal<Content: ModalContent>(
+        isModaled: UIBinding<Bool>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping () -> Content
+    ) -> ObserveToken {
+        modal(item: isModaled.toOptionalUnit, onDismiss: onDismiss) { _ in content() }
+    }
+
+    @discardableResult
+    public func modalSession<Content: ModalSessionContent>(
+        isModaled: UIBinding<Bool>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping () -> Content
+    ) -> ObserveToken {
+        modalSession(item: isModaled.toOptionalUnit, onDismiss: onDismiss) { _ in content() }
+    }
+
+    @discardableResult
+    public func modal<Item: Identifiable, Content: ModalContent>(
+        item: UIBinding<Item?>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (Item) -> Content
+    ) -> ObserveToken {
+        modal(item: item, id: \.id, onDismiss: onDismiss, content: content)
+    }
+
+    @discardableResult
+    public func modalSession<Item: Identifiable, Content: ModalSessionContent>(
+        item: UIBinding<Item?>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (Item) -> Content
+    ) -> ObserveToken {
+        modalSession(item: item, id: \.id, onDismiss: onDismiss, content: content)
+    }
+
+    @_disfavoredOverload
+    @discardableResult
+    public func modal<Item: Identifiable, Content: ModalContent>(
+        item: UIBinding<Item?>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (UIBinding<Item>) -> Content
+    ) -> ObserveToken {
+        modal(item: item, id: \.id, onDismiss: onDismiss, content: content)
+    }
+
+    @_disfavoredOverload
+    @discardableResult
+    public func modalSession<Item: Identifiable, Content: ModalSessionContent>(
+        item: UIBinding<Item?>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (UIBinding<Item>) -> Content
+    ) -> ObserveToken {
+        modalSession(item: item, id: \.id, onDismiss: onDismiss, content: content)
+    }
+
+    @discardableResult
+    public func modal<Item, ID: Hashable, Content: ModalContent>(
+        item: UIBinding<Item?>,
+        id: KeyPath<Item, ID>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (Item) -> Content
+    ) -> ObserveToken {
+        modal(item: item, id: id, onDismiss: onDismiss) {
+            content($0.wrappedValue)
+        }
+    }
+
+    @discardableResult
+    public func modalSession<Item, ID: Hashable, Content: ModalSessionContent>(
+        item: UIBinding<Item?>,
+        id: KeyPath<Item, ID>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (Item) -> Content
+    ) -> ObserveToken {
+        modalSession(item: item, id: id, onDismiss: onDismiss) {
+            content($0.wrappedValue)
+        }
+    }
+
+    @discardableResult
+    public func modal<Item, ID: Hashable, Content: ModalContent>(
+        item: UIBinding<Item?>,
+        id: KeyPath<Item, ID>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (UIBinding<Item>) -> Content
+    ) -> ObserveToken {
+        modal(item: item, id: id) { $item in
+            content($item)
+        } beginModal: { modalContent, _ in
+            if NSApplication.shared.modalWindow != nil {
+                NSApplication.shared.stopModal()
+                onDismiss?()
+                DispatchQueue.main.async {
+                    ModalWindowsObserver.shared.observeWindow(modalContent.window)
+                    modalContent.appKitNavigationRunModal()
+                    modalContent.onEndNavigation?()
+                    modalContent.onEndNavigation = nil
+                }
+
+            } else {
+                DispatchQueue.main.async {
+                    ModalWindowsObserver.shared.observeWindow(modalContent.window)
+                    modalContent.appKitNavigationRunModal()
+                    modalContent.onEndNavigation?()
+                    modalContent.onEndNavigation = nil
+                }
+            }
+        } endModal: { _, _ in
+            NSApplication.shared.stopModal()
+            onDismiss?()
+        }
+    }
+
+    @discardableResult
+    public func modalSession<Item, ID: Hashable, Content: ModalSessionContent>(
+        item: UIBinding<Item?>,
+        id: KeyPath<Item, ID>,
+        onDismiss: (() -> Void)? = nil,
+        content: @escaping (UIBinding<Item>) -> Content
+    ) -> ObserveToken {
+        modal(item: item, id: id) { $item in
+            content($item)
+        } beginModal: { modalContent, _ in
+            if let modaledWindow = NSApplication.shared.modalWindow, let modalSession = ModalWindowsObserver.shared.modalSessionByWindow[modaledWindow] {
+                NSApplication.shared.endModalSession(modalSession)
+                modaledWindow.window.close()
+                onDismiss?()
+                DispatchQueue.main.async {
+                    let modalSession = modalContent.appKitNavigationBeginModalSession()
+                    ModalWindowsObserver.shared.observeWindow(modalContent.window, modalSession: modalSession)
+                }
+
+            } else {
+                DispatchQueue.main.async {
+                    let modalSession = modalContent.appKitNavigationBeginModalSession()
+                    ModalWindowsObserver.shared.observeWindow(modalContent.window, modalSession: modalSession)
+                }
+            }
+        } endModal: { modalContent, _ in
+            if let modalSession = ModalWindowsObserver.shared.modalSessionByWindow[modalContent.window] {
+                NSApplication.shared.endModalSession(modalSession)
+                modalContent.window.close()
+                onDismiss?()
+            }
+        }
+    }
+
+    private func modal<Item, ID: Hashable, Content: ModalContent>(
+        item: UIBinding<Item?>,
+        id: KeyPath<Item, ID>,
+        content: @escaping (UIBinding<Item>) -> Content,
+        beginModal: @escaping (
+            _ child: Content,
+            _ transaction: UITransaction
+        ) -> Void,
+        endModal: @escaping (
+            _ child: Content,
+            _ transaction: UITransaction
+        ) -> Void
+    ) -> ObserveToken {
+        let modalObserver: ModalObserver<Content> = modalObserver()
+        return modalObserver.observe(
+            item: item,
+            id: { $0[keyPath: id] },
+            content: content,
+            begin: beginModal,
+            end: endModal
+        )
+    }
+
+    private func modalObserver<Content: ModalContent>() -> ModalObserver<Content> {
+        if let observer = objc_getAssociatedObject(self, modalObserverKeys.key(of: Content.self)) as? ModalObserver<Content> {
+            return observer
+        } else {
+            let observer = ModalObserver<Content>(owner: self)
+            objc_setAssociatedObject(self, modalObserverKeys.key(of: Content.self), observer, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            return observer
+        }
+    }
+}
+
+extension Navigated where Content: ModalContent {
+    func clearup() {
+        NSApplication.shared.stopModal()
+    }
+}
+
+#endif

Sources/AppKitNavigation/Navigation/ModalContent.swift

@@ -0,0 +1,35 @@
+#if canImport(AppKit) && !targetEnvironment(macCatalyst)
+
+import AppKit
+
+@MainActor
+public protocol ModalContent: NavigationContent {
+    @discardableResult func appKitNavigationRunModal() -> NSApplication.ModalResponse
+    var window: NSWindow { get }
+}
+
+extension NSWindow: ModalContent {
+    public var window: NSWindow { self }
+
+    public func appKitNavigationRunModal() -> NSApplication.ModalResponse {
+        __appKitNavigationRunModal()
+    }
+
+    @objc func __appKitNavigationRunModal() -> NSApplication.ModalResponse {
+        NSApplication.shared.runModal(for: self)
+    }
+}
+
+extension NSSavePanel {
+    override func __appKitNavigationRunModal() -> NSApplication.ModalResponse {
+        runModal()
+    }
+}
+
+extension NSAlert: ModalContent {
+    public func appKitNavigationRunModal() -> NSApplication.ModalResponse {
+        runModal()
+    }
+}
+
+#endif

Sources/AppKitNavigation/Navigation/ModalSessionContent.swift

@@ -0,0 +1,22 @@
+#if canImport(AppKit) && !targetEnvironment(macCatalyst)
+
+import AppKit
+
+@MainActor
+public protocol ModalSessionContent: ModalContent {
+    func appKitNavigationBeginModalSession() -> NSApplication.ModalSession
+}
+
+extension NSWindow: ModalSessionContent {
+
+    public func appKitNavigationBeginModalSession() -> NSApplication.ModalSession {
+        __appKitNavigationBeginModalSession()
+    }
+
+    @objc func __appKitNavigationBeginModalSession() -> NSApplication.ModalSession {
+        let modalSession = NSApplication.shared.beginModalSession(for: self)
+        return modalSession
+    }
+}
+
+#endif

Sources/AppKitNavigation/Navigation/ModalWindowsObserver.swift

@@ -0,0 +1,33 @@
+#if canImport(AppKit) && !targetEnvironment(macCatalyst)
+
+import AppKit
+import Combine
+
+@MainActor
+class ModalWindowsObserver: NSObject {
+    static let shared = ModalWindowsObserver()
+
+    var windowsCancellable: [NSWindow: AnyCancellable] = [:]
+
+    var modalSessionByWindow: [NSWindow: NSApplication.ModalSession] = [:]
+
+    func observeWindow(_ window: NSWindow, modalSession: NSApplication.ModalSession? = nil) {
+        if let modalSession {
+            modalSessionByWindow[window] = modalSession
+        }
+        windowsCancellable[window] = NotificationCenter.default.publisher(for: NSWindow.willCloseNotification, object: window)
+            .sink { [weak self] _ in
+                guard let self else { return }
+                if let modalSession = modalSessionByWindow[window] {
+                    NSApplication.shared.endModalSession(modalSession)
+                } else if NSApplication.shared.modalWindow === window {
+                    NSApplication.shared.stopModal()
+                }
+                modalSessionByWindow.removeValue(forKey: window)
+                windowsCancellable[window]?.cancel()
+                windowsCancellable.removeValue(forKey: window)
+            }
+    }
+}
+
+#endif