macOS: Windows, Menus, Commands, Settings and Menu Bar Extras

// FieldNotes/Mac/TagInspector.swift
#if os(macOS)
import SwiftUI
import FieldNotesModel
import FieldNotesServices
import FieldNotesUI

struct TagInspector: View {
    @Environment(NoteStore.self) private var store
    @FocusedValue(\.selectedNote) private var selectedNote   // declared in FieldNotesUI, set by NoteDetail

    /// Every tag in the library, with how many notes use it, most used first.
    private var tagCounts: [(tag: String, count: Int)] {
        Dictionary(grouping: store.notes.flatMap(\.tags), by: { $0 })
            .map { (tag: $0.key, count: $0.value.count) }
            .sorted { $0.count != $1.count ? $0.count > $1.count : $0.tag < $1.tag }
    }

    var body: some View {
        List(tagCounts, id: \.tag) { entry in
            HStack {
                TagChip(entry.tag, isSelected: selectedNote?.tags.contains(entry.tag) == true)
                Spacer()
                Text(entry.count, format: .number)
                    .foregroundStyle(.secondary)
                    .monospacedDigit()
            }
        }
        .navigationSubtitle(selectedNote?.title ?? String(localized: "No note selected"))
        .frame(minWidth: 240, minHeight: 300)
    }
}
#endif

// FieldNotes/Mac/MacOnlyCommands.swift
#if os(macOS)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct MacOnlyCommands: Commands {
    let store: NoteStore

    @Environment(\.openWindow) private var openWindow
    @FocusedValue(\.selectedNote) private var selectedNote

    /// The notebook of the frontmost note, if it has one.
    private var notebook: Notebook? {
        store.notebooks.first { $0.id == selectedNote?.notebookID }
    }

    var body: some Commands {
        CommandGroup(after: .importExport) {
            Button("Export Notebook…") {
                guard let notebook else { return }
                do {
                    try exportNotebook(notebook, from: store)   // shown under App Sandbox below
                } catch {
                    NSAlert(error: error).runModal()            // never fail silently
                }
            }
            .keyboardShortcut("e", modifiers: [.command, .shift])
            .disabled(notebook == nil)
        }

        CommandGroup(before: .windowList) {
            Button("Tag Browser") { openWindow(id: "tag-browser") }
                .keyboardShortcut("t", modifiers: [.command, .option])
            Button("Tag Inspector") { openWindow(id: "tag-inspector") }
                .keyboardShortcut("i", modifiers: [.command, .option])
            Divider()
        }

        CommandGroup(replacing: .help) {
            Link("FieldNotes Help", destination: URL(string: "https://example.com/fieldnotes/help")!)
        }
    }
}
#endif

// Packages/FieldNotesUI/Sources/FieldNotesUI/SettingsView.swift (updated: tabs on macOS)
import SwiftUI

public struct SettingsView: View {
    public init() {}

    public var body: some View {
        #if os(macOS)
        TabView {
            Tab("General", systemImage: "gearshape") {
                Form { GeneralSettings() }.formStyle(.grouped)
            }
            Tab("Sync", systemImage: "arrow.triangle.2.circlepath.icloud") {
                Form { SyncSettings() }.formStyle(.grouped)
            }
        }
        .frame(width: 520, height: 460)
        #else
        Form {
            SyncSettings()
            GeneralSettings()
        }
        .formStyle(.grouped)
        .navigationTitle("Settings")
        #endif
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/GeneralSettings.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices

/// Where the Mac app shows its menu bar extra, stored in the App Group suite.
public enum MenuBarExtraChoice: String, CaseIterable, Identifiable, Sendable {
    case hidden, menu, window
    public var id: Self { self }
}

public struct GeneralSettings: View {
    @Environment(NoteStore.self) private var store
    @AppStorage("pinnedFirst") private var pinnedFirst = true
    @AppStorage("noteSortOrder") private var sortOrder = NoteSortOrder.newestFirst
    #if os(macOS)
    @AppStorage("menuBarExtraChoice") private var menuBarExtraChoice = MenuBarExtraChoice.window
    #endif

    public init() {}

    public var body: some View {
        Section("Notes") {
            Picker("Sort By", selection: $sortOrder) {
                ForEach(NoteSortOrder.allCases) { Text($0.title).tag($0) }
            }
            Toggle("Show Pinned Notes First", isOn: $pinnedFirst)
            // Default Notebook picker as before
        }
        #if os(macOS)
        Section("Menu Bar") {
            Picker("Quick Capture", selection: $menuBarExtraChoice) {
                Text("Hidden").tag(MenuBarExtraChoice.hidden)
                Text("Menu").tag(MenuBarExtraChoice.menu)
                Text("Panel").tag(MenuBarExtraChoice.window)
            }
        }
        #endif
        // Capture and About sections as before
    }
}

// Packages/FieldNotesUI/Sources/FieldNotesUI/SyncSettings.swift
import SwiftUI

public struct SyncSettings: View {
    @AppStorage("syncWithICloud") private var syncWithICloud = true

    public init() {}

    public var body: some View {
        Section("Sync") {
            Toggle("Sync with iCloud", isOn: $syncWithICloud)
        }
        #if os(macOS)
        Section("Export") {
            ExportFolderRow()   // also in FieldNotesUI, shown under App Sandbox below
        }
        #endif
    }
}

// FieldNotes/Mac/SyncOffBanner.swift
#if os(macOS)
import SwiftUI

struct SyncOffBanner: View {
    @Environment(\.openSettings) private var openSettings

    var body: some View {
        HStack {
            Label("iCloud sync is off", systemImage: "icloud.slash")
            Spacer()
            SettingsLink {
                Text("Open Settings…")
            }
            Button("Turn On in Settings") {
                openSettings()   // the same as SettingsLink, for use inside another action
            }
        }
        .padding(8)
    }
}
#endif

// FieldNotes/Mac/QuickCaptureMenu.swift
#if os(macOS)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

/// The menu bar extra's content: menu items in .menu style, the lower part of the panel in .window style.
struct QuickCaptureMenu: View {
    @Environment(NoteStore.self) private var store
    @Environment(\.openWindow) private var openWindow

    private var pinned: [Note] {
        store.notes.filter(\.isPinned).sorted { $0.createdAt > $1.createdAt }
    }

    var body: some View {
        Button("New Note from Clipboard") {
            let text = NSPasteboard.general.string(forType: .string) ?? ""
            let note = Note(title: String(text.prefix(60)), body: text)
            store.add(note)
            openWindow(id: "note", value: note.id)
            NSApplication.shared.activate()
        }
        .disabled(NSPasteboard.general.string(forType: .string) == nil)

        Section("Pinned") {
            ForEach(pinned.prefix(5)) { note in
                Button(note.title) {
                    openWindow(id: "note", value: note.id)
                    NSApplication.shared.activate()
                }
            }
        }

        Divider()
        SettingsLink()
        Button("Quit FieldNotes") { NSApplication.shared.terminate(nil) }
            .keyboardShortcut("q")
    }
}
#endif

// Packages/FieldNotesKit/Sources/FieldNotesServices/Mac/ExportFolderBookmark.swift
#if os(macOS)
import Foundation

/// The export folder the person chose, remembered across launches as a security-scoped bookmark
/// in `UserDefaults.fieldNotesShared`.
public enum ExportFolderBookmark {
    public enum AccessError: Error {
        case noFolderChosen
        case accessDenied(URL)
    }

    private static let key = "exportFolderBookmark"

    /// Call with a URL from fileImporter or NSOpenPanel, while the panel's access is still active.
    public static func remember(_ folder: URL) throws {
        let data = try folder.bookmarkData(options: .withSecurityScope,
                                           includingResourceValuesForKeys: nil, relativeTo: nil)
        UserDefaults.fieldNotesShared.set(data, forKey: key)
    }

    public static var hasFolder: Bool {
        UserDefaults.fieldNotesShared.data(forKey: key) != nil
    }

    /// Resolves the bookmark, opens the sandbox for the folder, runs `body`, and closes it again.
    public static func withAccess<T>(_ body: (URL) throws -> T) throws -> T {
        guard let data = UserDefaults.fieldNotesShared.data(forKey: key) else {
            throw AccessError.noFolderChosen
        }
        var isStale = false
        let folder = try URL(resolvingBookmarkData: data, options: .withSecurityScope,
                             relativeTo: nil, bookmarkDataIsStale: &isStale)
        guard folder.startAccessingSecurityScopedResource() else {
            throw AccessError.accessDenied(folder)
        }
        defer { folder.stopAccessingSecurityScopedResource() }
        if isStale {
            try remember(folder)   // the folder moved or was renamed: refresh the stored bookmark
        }
        return try body(folder)
    }
}
#endif

// Packages/FieldNotesUI/Sources/FieldNotesUI/Mac/ExportFolderRow.swift
#if os(macOS)
import SwiftUI
import UniformTypeIdentifiers
import FieldNotesServices

public struct ExportFolderRow: View {
    @State private var isChoosing = false
    @State private var hasFolder = ExportFolderBookmark.hasFolder
    @State private var errorMessage: String?

    public init() {}

    public var body: some View {
        LabeledContent("Export Folder") {
            Button(hasFolder ? "Change…" : "Choose…") { isChoosing = true }
        }
        .fileImporter(isPresented: $isChoosing, allowedContentTypes: [.folder]) { result in
            do {
                try ExportFolderBookmark.remember(try result.get())
                hasFolder = true
            } catch {
                errorMessage = error.localizedDescription
            }
        }
        .alert("Couldn't Use That Folder", isPresented: Binding(
            get: { errorMessage != nil }, set: { if !$0 { errorMessage = nil } })) {
            Button("OK") {}
        } message: {
            Text(errorMessage ?? "")
        }
    }
}
#endif

// FieldNotes/Mac/ExportNotebook.swift (app target: the export itself, called from the Export Notebook command)
#if os(macOS)
import Foundation
import FieldNotesModel
import FieldNotesServices

@MainActor
func exportNotebook(_ notebook: Notebook, from store: NoteStore) throws {
    let notes = store.notes.filter { $0.notebookID == notebook.id }
    let envelope = NoteFileFormat.Envelope(notebookName: notebook.name, notes: notes)
    let data = try JSONEncoder().encode(envelope)
    try ExportFolderBookmark.withAccess { folder in
        try data.write(to: folder.appending(path: "\(notebook.name).fieldnotes"), options: .atomic)
    }
}
#endif

# Which architectures does the archived Mac app contain?
lipo -archs "FieldNotes.app/Contents/MacOS/FieldNotes"
# arm64 x86_64

# Any Intel-only framework left in the bundle would stop working on macOS 28.
find FieldNotes.app/Contents/Frameworks -type f -perm +111 -exec lipo -archs {} \; 2>/dev/null