229 lines
8.4 KiB
Swift
229 lines
8.4 KiB
Swift
import AppKit
|
|
import SwiftUI
|
|
|
|
@MainActor
|
|
final class MenuContextCardInjector: NSObject, NSMenuDelegate {
|
|
static let shared = MenuContextCardInjector()
|
|
|
|
private let tag = 9_415_227
|
|
private let fallbackCardWidth: CGFloat = 320
|
|
private var lastKnownMenuWidth: CGFloat?
|
|
private weak var originalDelegate: NSMenuDelegate?
|
|
private var loadTask: Task<Void, Never>?
|
|
private var warmTask: Task<Void, Never>?
|
|
private var cachedRows: [SessionRow] = []
|
|
private var cacheErrorText: String?
|
|
private var cacheUpdatedAt: Date?
|
|
private let activeWindowSeconds: TimeInterval = 24 * 60 * 60
|
|
private let refreshIntervalSeconds: TimeInterval = 15
|
|
private var isMenuOpen = false
|
|
|
|
func install(into statusItem: NSStatusItem) {
|
|
// SwiftUI owns the menu, but we can inject a custom NSMenuItem.view right before display.
|
|
guard let menu = statusItem.menu else { return }
|
|
// Preserve SwiftUI's internal NSMenuDelegate, otherwise it may stop populating menu items.
|
|
if menu.delegate !== self {
|
|
self.originalDelegate = menu.delegate
|
|
menu.delegate = self
|
|
}
|
|
|
|
if self.warmTask == nil {
|
|
self.warmTask = Task { await self.refreshCache(force: true) }
|
|
}
|
|
}
|
|
|
|
func menuWillOpen(_ menu: NSMenu) {
|
|
self.originalDelegate?.menuWillOpen?(menu)
|
|
self.isMenuOpen = true
|
|
|
|
// Remove any previous injected card items.
|
|
for item in menu.items where item.tag == self.tag {
|
|
menu.removeItem(item)
|
|
}
|
|
|
|
guard let insertIndex = self.findInsertIndex(in: menu) else { return }
|
|
|
|
self.loadTask?.cancel()
|
|
|
|
let initialRows = self.cachedRows
|
|
let initialIsLoading = initialRows.isEmpty
|
|
let initialStatusText = initialIsLoading ? self.cacheErrorText : nil
|
|
let initialWidth = self.initialCardWidth(for: menu)
|
|
|
|
let initial = AnyView(ContextMenuCardView(
|
|
rows: initialRows,
|
|
statusText: initialStatusText,
|
|
isLoading: initialIsLoading))
|
|
|
|
let hosting = NSHostingView(rootView: initial)
|
|
hosting.frame.size.width = max(1, initialWidth)
|
|
let size = hosting.fittingSize
|
|
hosting.frame = NSRect(
|
|
origin: .zero,
|
|
size: NSSize(width: initialWidth, height: size.height))
|
|
|
|
let item = NSMenuItem()
|
|
item.tag = self.tag
|
|
item.view = hosting
|
|
item.isEnabled = false
|
|
|
|
menu.insertItem(item, at: insertIndex)
|
|
|
|
// Capture the menu window width for next open, but do not mutate widths while the menu is visible.
|
|
DispatchQueue.main.async { [weak self, weak hosting] in
|
|
guard let self, let hosting else { return }
|
|
self.captureMenuWidthIfAvailable(for: menu, hosting: hosting)
|
|
}
|
|
|
|
if initialIsLoading {
|
|
self.loadTask = Task { [weak hosting] in
|
|
await self.refreshCache(force: true)
|
|
guard let hosting else { return }
|
|
let view = self.cachedView()
|
|
await MainActor.run {
|
|
hosting.rootView = view
|
|
hosting.invalidateIntrinsicContentSize()
|
|
self.captureMenuWidthIfAvailable(for: menu, hosting: hosting)
|
|
hosting.frame.size.width = max(1, initialWidth)
|
|
let size = hosting.fittingSize
|
|
hosting.frame.size.height = size.height
|
|
}
|
|
}
|
|
} else {
|
|
// Keep the menu stable while it's open; refresh in the background for next open.
|
|
self.loadTask = Task { await self.refreshCache(force: false) }
|
|
}
|
|
}
|
|
|
|
func menuDidClose(_ menu: NSMenu) {
|
|
self.originalDelegate?.menuDidClose?(menu)
|
|
self.isMenuOpen = false
|
|
self.loadTask?.cancel()
|
|
}
|
|
|
|
func menuNeedsUpdate(_ menu: NSMenu) {
|
|
self.originalDelegate?.menuNeedsUpdate?(menu)
|
|
}
|
|
|
|
func confinementRect(for menu: NSMenu, on screen: NSScreen?) -> NSRect {
|
|
if let rect = self.originalDelegate?.confinementRect?(for: menu, on: screen) {
|
|
return rect
|
|
}
|
|
return NSRect.zero
|
|
}
|
|
|
|
private func refreshCache(force: Bool) async {
|
|
if !force, let cacheUpdatedAt, Date().timeIntervalSince(cacheUpdatedAt) < self.refreshIntervalSeconds {
|
|
return
|
|
}
|
|
|
|
do {
|
|
let rows = try await self.loadCurrentRows()
|
|
self.cachedRows = rows
|
|
self.cacheErrorText = nil
|
|
self.cacheUpdatedAt = Date()
|
|
} catch {
|
|
if self.cachedRows.isEmpty {
|
|
let raw = (error as? LocalizedError)?.errorDescription ?? error.localizedDescription
|
|
let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if trimmed.isEmpty {
|
|
self.cacheErrorText = "Could not load sessions"
|
|
} else {
|
|
// Keep the menu readable: one line, short.
|
|
let firstLine = trimmed.split(whereSeparator: \.isNewline).first.map(String.init) ?? trimmed
|
|
self.cacheErrorText = firstLine.count > 90 ? "\(firstLine.prefix(87))…" : firstLine
|
|
}
|
|
}
|
|
self.cacheUpdatedAt = Date()
|
|
}
|
|
}
|
|
|
|
private func cachedView() -> AnyView {
|
|
let rows = self.cachedRows
|
|
let isLoading = rows.isEmpty && self.cacheErrorText == nil
|
|
return AnyView(ContextMenuCardView(rows: rows, statusText: self.cacheErrorText, isLoading: isLoading))
|
|
}
|
|
|
|
private func loadCurrentRows() async throws -> [SessionRow] {
|
|
let snapshot = try await SessionLoader.loadSnapshot()
|
|
let loaded = snapshot.rows
|
|
let now = Date()
|
|
let current = loaded.filter { row in
|
|
if row.key == "main" { return true }
|
|
guard let updatedAt = row.updatedAt else { return false }
|
|
return now.timeIntervalSince(updatedAt) <= self.activeWindowSeconds
|
|
}
|
|
|
|
return current.sorted { lhs, rhs in
|
|
if lhs.key == "main" { return true }
|
|
if rhs.key == "main" { return false }
|
|
return (lhs.updatedAt ?? .distantPast) > (rhs.updatedAt ?? .distantPast)
|
|
}
|
|
}
|
|
|
|
private func findInsertIndex(in menu: NSMenu) -> Int? {
|
|
// Prefer inserting before the first separator (so the card sits right below the Active toggle).
|
|
if let idx = menu.items.firstIndex(where: { $0.title == "Send Heartbeats" }) {
|
|
// SwiftUI menus typically include a separator right after the first toggle; insert before it so the
|
|
// separator appears below the context card.
|
|
if let sepIdx = menu.items[..<idx].lastIndex(where: { $0.isSeparatorItem }) {
|
|
return sepIdx
|
|
}
|
|
return idx
|
|
}
|
|
|
|
if let sepIdx = menu.items.firstIndex(where: { $0.isSeparatorItem }) {
|
|
return sepIdx
|
|
}
|
|
|
|
// Fallback: insert after the first item.
|
|
if menu.items.count >= 1 { return 1 }
|
|
return menu.items.count
|
|
}
|
|
|
|
private func initialCardWidth(for menu: NSMenu) -> CGFloat {
|
|
let widthCandidates: [CGFloat] = [
|
|
menu.minimumWidth,
|
|
self.lastKnownMenuWidth ?? 0,
|
|
self.fallbackCardWidth,
|
|
]
|
|
let resolved = widthCandidates.max() ?? self.fallbackCardWidth
|
|
return max(300, resolved)
|
|
}
|
|
|
|
private func captureMenuWidthIfAvailable(for menu: NSMenu, hosting: NSHostingView<AnyView>) {
|
|
let targetWidth: CGFloat? = {
|
|
if let contentWidth = hosting.window?.contentView?.bounds.width, contentWidth > 0 { return contentWidth }
|
|
if let superWidth = hosting.superview?.bounds.width, superWidth > 0 { return superWidth }
|
|
let minimumWidth = menu.minimumWidth
|
|
if minimumWidth > 0 { return minimumWidth }
|
|
return nil
|
|
}()
|
|
|
|
guard let targetWidth else { return }
|
|
self.lastKnownMenuWidth = max(300, targetWidth)
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
extension MenuContextCardInjector {
|
|
func _testSetCache(rows: [SessionRow], errorText: String?, updatedAt: Date?) {
|
|
self.cachedRows = rows
|
|
self.cacheErrorText = errorText
|
|
self.cacheUpdatedAt = updatedAt
|
|
}
|
|
|
|
func _testFindInsertIndex(in menu: NSMenu) -> Int? {
|
|
self.findInsertIndex(in: menu)
|
|
}
|
|
|
|
func _testInitialCardWidth(for menu: NSMenu) -> CGFloat {
|
|
self.initialCardWidth(for: menu)
|
|
}
|
|
|
|
func _testCachedView() -> AnyView {
|
|
self.cachedView()
|
|
}
|
|
}
|
|
#endif
|