Preferences, Files and Document-Based Apps

// FieldNotes/FieldNotesApp.swift (excerpt)
import SwiftUI
import FieldNotesServices

extension FieldNotesApp {
    static func registerDefaultPreferences() {
        UserDefaults.fieldNotesShared.register(defaults: [
            "syncWithICloud": true,
            "pinnedFirst": true,
            "noteSortOrder": "newestFirst",
            "locationRadius": 50.0,
            "summarySentences": 3,
        ])
    }
}

// Packages/FieldNotesKit/Sources/FieldNotesServices/Preferences/UserDefaults+FieldNotes.swift
import Foundation

extension UserDefaults {
    /// Preferences shared by the app, its widgets and its extensions, through the App Group
    /// `group.com.example.fieldnotes`. UserDefaults is thread-safe, but the SDK doesn't declare it
    /// `Sendable`, so the global is marked `nonisolated(unsafe)` for the Swift 6 language mode.
    nonisolated(unsafe) public static let fieldNotesShared =
        UserDefaults(suiteName: "group.com.example.fieldnotes")!
}

// FieldNotes/FieldNotesApp.swift (excerpt: persistence wiring unchanged from Persisting Models with SwiftData)
import SwiftUI
import SwiftData
import FieldNotesServices
import FieldNotesUI

@main
struct FieldNotesApp: App {
    private let container: ModelContainer
    @State private var store: NoteStore

    init() {
        do {
            container = try ModelContainer.fieldNotes()
        } catch {
            fatalError("FieldNotes could not open its store: \(error)")
        }
        _store = State(initialValue: NoteStore(
            syncer: CloudNoteSyncer(),
            persistence: SwiftDataNotePersistence(modelContainer: container)))
        Self.registerDefaultPreferences()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
                .task { await store.load() }
        }
        .modelContainer(container)
        .defaultAppStorage(.fieldNotesShared)   // every @AppStorage in this scene uses the App Group suite

        #if os(macOS)
        Settings {
            SettingsView()
                .environment(store)
        }
        .defaultAppStorage(.fieldNotesShared)
        #endif
    }
}

// FieldNotesWidgets/PinnedNotesWidgetView.swift (excerpt)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

struct PinnedNotesSortLabel: View {
    @AppStorage("noteSortOrder", store: .fieldNotesShared)
    private var sortOrder = NoteSortOrder.newestFirst

    var body: some View {
        Text(sortOrder.title)
            .font(.caption2)
    }
}

// FieldNotes/Views/ContentView.swift (excerpt; the selection restoration is on the life-cycle page)
import SwiftUI
import FieldNotesModel
import FieldNotesServices
import FieldNotesUI

struct ContentView: View {
    @Environment(NoteStore.self) private var store
    @SceneStorage("ContentView.isInspectorPresented") private var isInspectorPresented = false
    @State private var notebookID: Notebook.ID?
    @State private var noteID: Note.ID?

    var body: some View {
        NavigationSplitView {
            NotebookList(selection: $notebookID)
        } content: {
            NoteList(notebookID: notebookID, selection: $noteID)
        } detail: {
            if let note = store.notes.first(where: { $0.id == noteID }) {
                NoteDetail(note: note)
            } else {
                ContentUnavailableView("Select a Note", systemImage: "note.text")
            }
        }
        .inspector(isPresented: $isInspectorPresented) {
            Text("Tags, location and attachments of the selected note")
        }
    }
}

#Preview {
    ContentView()
        .environment(NoteStore(notes: [Note(title: "Heron at the lake")]))
}

// Packages/FieldNotesKit/Sources/FieldNotesServices/Files/FieldNotesPaths.swift
import Foundation

public enum FieldNotesPaths {
    /// Notebooks the person exported to "On My iPhone" (visible in the Files app).
    public static var exports: URL { .documentsDirectory.appending(path: "Exports", directoryHint: .isDirectory) }

    /// Original attachments downloaded by AttachmentDownloader; re-downloadable, so excluded from backup below.
    public static var attachments: URL {
        .applicationSupportDirectory.appending(path: "Attachments", directoryHint: .isDirectory)
    }

    /// Thumbnails, recreated on demand.
    public static var thumbnails: URL { .cachesDirectory.appending(path: "Thumbnails", directoryHint: .isDirectory) }

    /// A fresh scratch file for an export in progress.
    public static func scratchFile(named name: String) -> URL {
        .temporaryDirectory.appending(path: "\(UUID().uuidString)-\(name)")
    }

    public static func createIfNeeded(_ directory: URL) throws {
        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
    }
}

// Packages/FieldNotesKit/Sources/FieldNotesServices/Files/FieldNotesPaths.swift (continued)
import Foundation

extension FieldNotesPaths {
    public static let appGroupIdentifier = "group.com.example.fieldnotes"

    /// The shared container, or nil when the App Groups entitlement is missing.
    public static var sharedContainer: URL? {
        FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupIdentifier)
    }

    /// Library/Application Support inside the shared container, where SwiftData keeps its store.
    public static var sharedStoreDirectory: URL? {
        sharedContainer?.appending(path: "Library/Application Support", directoryHint: .isDirectory)
    }
}

// Packages/FieldNotesKit/Sources/FieldNotesServices/Files/FieldNotesPaths.swift (continued)
import Foundation

extension FieldNotesPaths {
    /// Creates the attachments folder and asks backups to skip it; the files are on the server.
    public static func prepareAttachmentsDirectory() throws {
        var directory = attachments
        try createIfNeeded(directory)
        var values = URLResourceValues()
        values.isExcludedFromBackup = true
        try directory.setResourceValues(values)
    }
}

// FieldNotes/Documents/NotebookExportDocument.swift
import SwiftUI
import UniformTypeIdentifiers
import FieldNotesModel
import FieldNotesServices

@available(iOS 27, macOS 27, visionOS 27, *)
@Observable
final class NotebookExportDocument: Document {
    static let readableContentTypes: [UTType] = [.fieldNotesNotebook]

    var notebookName: String
    var notes: [Note]

    init(notebookName: String = String(localized: "Untitled Notebook"), notes: [Note] = []) {
        self.notebookName = notebookName
        self.notes = notes
    }

    // Reading: runs in the background, then apply(snapshot:previous:) runs on the main actor.
    func reader(configuration: sending ReadConfiguration)
        -> sending FileWrapperDocumentReader<NoteFileFormat.Envelope> {
        FileWrapperDocumentReader(configuration) { fileWrapper in
            guard let data = fileWrapper.regularFileContents else {
                throw CocoaError(.fileReadCorruptFile)
            }
            return try NoteFileFormat.decodeEnvelope(data)
        }
    }

    @MainActor
    func apply(snapshot: sending NoteFileFormat.Envelope,
               previous: sending NoteFileFormat.Envelope?) async throws {
        notebookName = snapshot.notebookName
        notes = snapshot.notes.map { $0.note(in: nil) }
    }

    // Writing: snapshot on the main actor, then the writer serializes it in the background.
    @MainActor
    func snapshot(contentType: UTType) async throws -> sending NoteFileFormat.Envelope {
        NoteFileFormat.Envelope(notebookName: notebookName, notes: notes)
    }

    func writer(configuration: sending WriteConfiguration)
        -> sending FileWrapperDocumentWriter<NoteFileFormat.Envelope> {
        FileWrapperDocumentWriter(configuration) { snapshot, _ in
            FileWrapper(regularFileWithContents: try NoteFileFormat.encode(snapshot))
        }
    }
}

// FieldNotes/FieldNotesApp.swift (excerpt: init() with the persistence wiring and default preferences unchanged)
import SwiftUI
import SwiftData
import FieldNotesServices

@main
struct FieldNotesApp: App {
    private let container: ModelContainer
    @State private var store: NoteStore

    // init() as above: opens ModelContainer.fieldNotes() and creates
    // NoteStore(syncer:persistence:) with a SwiftDataNotePersistence.

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
                .task { await store.load() }
        }
        .modelContainer(container)
        .defaultAppStorage(.fieldNotesShared)

        #if !os(watchOS)
        if #available(iOS 27, macOS 27, visionOS 27, *) {
            DocumentGroup { (document: NotebookExportDocument) in
                NotebookDocumentView(document: document)
                    .environment(store)   // lets the document view copy notes into the library
            } makeDocument: { _, _ in
                NotebookExportDocument()
            }
        }
        #endif
    }
}

// FieldNotes/Documents/NotebookDocumentView.swift
import SwiftUI
import FieldNotesModel
import FieldNotesServices
import FieldNotesUI

@available(iOS 27, macOS 27, visionOS 27, *)
struct NotebookDocumentView: View {
    @Bindable var document: NotebookExportDocument
    @Environment(NoteStore.self) private var store
    @Environment(\.undoManager) private var undoManager

    var body: some View {
        List {
            TextField("Notebook Name", text: $document.notebookName)
            ForEach(document.notes) { note in   // identity: Note.id
                NoteRow(note: note)
            }
            .onDelete(perform: deleteNotes)
        }
        .toolbar {
            Button("Add to Library", systemImage: "tray.and.arrow.down") {
                for note in document.notes where !store.notes.contains(where: { $0.id == note.id }) {
                    store.add(note)
                }
            }
        }
        .onChange(of: document.notebookName) { oldValue, _ in
            undoManager?.registerUndo(withTarget: document) { $0.notebookName = oldValue }
        }
    }

    private func deleteNotes(at offsets: IndexSet) {
        let removed = document.notes
        document.notes.remove(atOffsets: offsets)
        undoManager?.registerUndo(withTarget: document) { $0.notes = removed }
    }
}

// FieldNotes/Documents/LegacyNotebookFile.swift (for deployment targets below 27)
import SwiftUI
import UniformTypeIdentifiers
import FieldNotesServices

struct LegacyNotebookFile: FileDocument {
    static let readableContentTypes: [UTType] = [.fieldNotesNotebook]

    var envelope: NoteFileFormat.Envelope

    init(envelope: NoteFileFormat.Envelope = .init(notebookName: "Untitled Notebook", notes: [])) {
        self.envelope = envelope
    }

    init(configuration: ReadConfiguration) throws {
        guard let data = configuration.file.regularFileContents else {
            throw CocoaError(.fileReadCorruptFile)
        }
        envelope = try NoteFileFormat.decodeEnvelope(data)
    }

    func fileWrapper(configuration: WriteConfiguration) throws -> FileWrapper {
        FileWrapper(regularFileWithContents: try NoteFileFormat.encode(envelope))
    }
}

// The pre-27 scene: DocumentGroup(newDocument:editor:) with a binding to the value.
// DocumentGroup(newDocument: LegacyNotebookFile()) { file in
//     LegacyNotebookEditor(envelope: file.$document.envelope)
// }

// FieldNotes 1.x/NotebookUIDocument.swift
#if canImport(UIKit)
import UIKit
import FieldNotesServices

final class NotebookUIDocument: UIDocument {
    var envelope = NoteFileFormat.Envelope(notebookName: "Untitled Notebook", notes: [])

    override func contents(forType typeName: String) throws -> Any {
        try NoteFileFormat.encode(envelope)
    }

    override func load(fromContents contents: Any, ofType typeName: String?) throws {
        guard let data = contents as? Data else { throw CocoaError(.fileReadCorruptFile) }
        envelope = try NoteFileFormat.decodeEnvelope(data)
    }
}

// Opening: NotebookUIDocument(fileURL: url).open { success in ... }
// Editing: change `envelope`, then call updateChangeCount(.done) so autosave picks it up.
#endif