Intent Sample

Intent.swift

//
//  EditDraftAppIntent.swift
//  Drafts
//
//  Created by Greg Pierce on 2026-01-06.
//  Copyright © 2026 Agile Tortoise. All rights reserved.
//
import Foundation
#if canImport(AppIntents)
import AppIntents
#endif
import DraftStore
import SwiftUI

@available(macOS 14.0, iOS 17.0, *)
struct EditDraftAppIntent: AppIntent {
    static var title: LocalizedStringResource = "Edit Draft"
    
    @Parameter(title: "Draft", description: "A draft to update.", requestValueDialog: "Which draft?")
    var draft: DraftEntity
    
    @Parameter(title: "Property", optionsProvider: DraftPropertyTypeOptionsProvider())
    var propertyType: DraftPropertyType
    
    @Parameter(title: "Content")
    var content: String?
        
    @Parameter(title: "Tags")
    var tags: [String]?
    
    @Parameter(title: "Folder")
    var folder: DraftUpdateFolder?
    
    @Parameter(title: "Flagged")
    var isFlagged: Bool?
    
    @Parameter(title: "Syntax")
    var grammarType: GrammarTypeEntity?
    
    static var parameterSummary: some ParameterSummary {
        Switch(\.$propertyType) {
            Case(.content) {
                Summary("Set \(\.$propertyType) of \(\.$draft) to \(\.$content)")
            }
            Case(.folder) {
                Summary("Set \(\.$propertyType) of \(\.$draft) to \(\.$folder)")
            }
            Case(.isFlagged) {
                Summary("Set \(\.$propertyType) of \(\.$draft) to \(\.$isFlagged)")
            }
            Case(.tags) {
                Summary("Set \(\.$propertyType) of \(\.$draft) to \(\.$tags)")
            }
            Case(.grammarType) {
                Summary("Set \(\.$propertyType) of \(\.$draft) to \(\.$grammarType)")
            }
            DefaultCase {
                Summary("Set \(\.$propertyType) of \(\.$draft)")
            }
        }
    }
    
    func perform() async throws -> some IntentResult & ReturnsValue<DraftEntity> {
        guard ENV.shared.isPro() else {
            throw AppIntentError.proRequired
        }

        guard let d = draft.draft else {
            throw AppIntentError.draftNotFound
        }
        
        switch propertyType {
            case .content:
            if let content = content, d.content != content {
                d.content = content
                d.update(source: self)
            }
            break
        case .folder:
            if let folder = folder {
                switch folder {
                case .inbox:
                    d.folder = .inbox
                case .archive:
                    d.folder = .archive
                case .trash:
                    d.folder = .trash
                case .unknown, .noChange:
                    break
                }
                d.update(source: self)
            }
            break
        case .isFlagged:
            if let isFlagged = isFlagged {
                if d.flagged != isFlagged {
                    d.flagged = isFlagged
                    d.update(source: self)
                }
            }
            break
        case .tags:
            if let tags = tags {
                d.tags.removeAll()
                for tag in tags {
                    d.addTag(tag)
                }
                d.update(source: self)
            }
            break
        case .grammarType:
            if let entity = grammarType, let type = entity.grammarType {
                d.languageGrammarName = type.rawValue
                d.update(source: self)
            }
        }
        
        DependencyManager.intentUpdateProcessed()
        return .result(value: DraftEntity.construct(for: d),
                       dialog: "Updated Draft") {
            DraftIntentView(draft: d)
        }
    }
}

@available(macOS 14.0, iOS 17.0, *)
extension EditDraftAppIntent {
    struct DraftPropertyTypeOptionsProvider: DynamicOptionsProvider {

        @IntentParameterDependency<EditDraftAppIntent>(
            \.$draft
        )

        var intent

        func results() async throws -> [DraftPropertyType] {
            return DraftPropertyType.allCases
        }

        func defaultResult() async -> DraftPropertyType? {
            nil
        }
    }
}