Minimal’s Conversion Engine

/// Namespace for the Intermediate-Representation.
enum IR {
    // Intentionally has no cases. Exists purely to scope the types below.
}
 
 
// MARK: - Document
 
extension IR {
    
    /// A parsed note in dialect-neutral form.
    struct Document: Equatable {
        
        /// A sequence of `Block` (stacks vertically), each containing a sequence of `Inline` (stacks horizontally).
        var blocks: [Block]
        
        var resources: [String: Resource]
        
        init(blocks: [Block] = [],
             resources: [String: Resource] = [:]) {
            ...
        }
    }
}
 
 
// MARK: - Blocks
 
extension IR {
    
    /// A unit of textual content that stacks vertically.
    indirect enum Block: Equatable {
        case blankLine
        case paragraph([Inline])
        case codeBlock(language: String?, content: String)
        case heading(level: Int, inlines: [Inline])
        case bulletList([ListItem])
        case orderedList(items: [ListItem], start: Int)
        case todoList([TodoItem])
        case blockquote([Block])
        case pullquote([Inline])
        case horizontalRule
        case embed(resourceId: String)
    }
    
    struct ListItem: Equatable {
        var blocks: [Block]
        init(blocks: [Block]) { self.blocks = blocks }
    }
    
    struct TodoItem: Equatable {
        var checked: Bool
        var blocks: [Block]
        init(checked: Bool, blocks: [Block]) {
            ...
        }
    }
}
 
 
// MARK: - Inlines
 
extension IR {
    
    /// Content that flows horizontally inside a block.
    indirect enum Inline: Equatable {
        case text(String)
        case strong([Inline])
        case emphasis([Inline])
        case underline([Inline])
        case link(url: String, inlines: [Inline])
        case inlineCode(String)
        case folder(name: String)
        case embed(resourceId: String)
        case lineBreak
    }
}
 
 
// MARK: - Resources
 
extension IR {
    
    /// An embed payload. Held off the tree and referenced by id.
    struct Resource: Equatable {
        
        var kind: String
        
        var mimeType: String?
        
        var data: Data?
        
        var url: String?
        
        var attributes: [String: String]
        
        init(kind: String,
             mimeType: String? = nil,
             data: Data? = nil,
             url: String? = nil,
             attributes: [String: String] = [:]) {
            ...
        }
    }
}

/// A record of something the engine simplified, downgraded, or set aside during conversion.
struct Concession: Equatable {
    
    var category: Category
    
    var description: String
    
    var count: Int?
    
    init(category: Category,
         description: String,
         count: Int? = nil) {
        ...
    }
    
    enum Category: Equatable {
        case unsupportedFormatting
        case downgraded
        case dropped
        case truncated
    }
}

extension Array where Element == Concession {
    
    mutating func appendOrIncrement(_ concession: Concession) {
        ...
    }
}

/// Protocol for producing an `IR.Document` from source text of a specific `Format`.
/// Each parser handles exactly one input format — `DocumentParserMinimal` reads MNML, `DocumentParserHTML` reads HTML, and so on. The orchestrator picks the right one based on the caller's `Format`.
/// Parsers never render. Their only output is the Intermediate-Representation and any concessions.
protocol DocumentParser {
    
    /// The input format this parser handles.
    var format: Format { get }
    
    /// Parse `source` into an IR document.
    /// Any content the IR can't represent is recorded in the result's concessions.
    func parse(_ source: String) throws -> ParseResult
}

/// The outcome of a parse: the IR document, plus a record of what was simplified.
struct ParseResult: Equatable {
    var document: IR.Document
    var concessions: [Concession]
    
    init(document: IR.Document, concessions: [Concession] = []) {
        self.document = document
        self.concessions = concessions
    }
}

/// Protocol for producing output of a specific `Format` from an `IR.Document`.
/// Each renderer handles exactly one output format: `HTMLRenderer` emits HTML, `MNMLRenderer` emits MNML, and so on. The orchestrator picks the right one based on the caller's `Format`.
/// Renderers never parse. Their only input is the Intermediate-Representation; their only output is the rendered form and the concessions incurred producing it (see `RenderResult`).
protocol DocumentRenderer {
    
    /// The output format this renderer produces.
    var format: Format { get }
    
    /// Render `document` into this renderer's format.
    /// Any IR content the target format can't express is recorded in the result's concessions.
    func render(_ document: IR.Document) throws -> RenderResult
}

/// The outcome of a render: the output payload, plus a record of what was simplified.
/// Output is carried as `Data` so this struct can serve text and binary formats alike.
/// Text formats (HTML, Markdown, MNML, plain text, RTF) populate `data` with UTF-8 bytes; binary formats (PDF) populate it directly.
struct RenderResult: Equatable {
    var data: Data
    var concessions: [Concession]
    
    init(data: Data, concessions: [Concession] = []) {
        self.data = data
        self.concessions = concessions
    }
}

let content = try readFile(at: url)
let parseResult = try? DocumentParserHTML().parse(content)
let renderResult = try? DocumentRendererMarkdown().render(parseResult.document)
let renderedMarkdownText = String(decoding: renderResult.data, as: UTF8.self)

extension UTType {

	 // (Declared in Info.plist via `UTExportedTypeDeclarations`)
    
    /// Minimal's first-class file format. Preserves MNML conventions verbatim.
    /// Round-trips through Minimal with full fidelity.
    static let mnml: UTType = UTType("app.minimal.mnml") ?? .plainText
    
    /// The de facto Markdown UTI adopted broadly across Markdown tooling.
    static let markdown = UTType(importedAs: "net.daringfireball.markdown")
}

/// Provides various data types (plain text, RTF, HTML, native Minimal plain text) so writers can copy from Minimal and paste anywhere.
/// Includes a native Minimal-specific data type so that within-Minimal copy-paste's do not roundtrip through RTF.
enum MinimalPasteboard {
    
    /// Pasteboard types for which we enable Paste, richest first.
    static let pasteableTypeIdentifiers: [String] = [
        UTType.rtf.identifier,
        UTType.html.identifier,
        UTType.utf8PlainText.identifier,
        UTType.plainText.identifier,
        UTType.text.identifier,
    ]
    
    /// Builds the pasteboard item for copying `source` (text in the writer's dialect).
    /// The native and plain representations are always present; RTF/HTML are best-effort.
    static func pasteboardItem(for source: String) -> [String: Any] {
        var item = MinimalPasteboard.nativeItem(for: source)
        item[UTType.utf8PlainText.identifier] = source
        if let document = try? StyleSettings.preferredParser().parse(source).document {
            if let rtf  = try? DocumentRendererRTF().render(document).data  { item[UTType.rtf.identifier]  = rtf }
            if let html = try? DocumentRendererHTML().render(document).data { item[UTType.html.identifier] = html }
        }
        return item
    }
    
    
    // MARK: Native Source
    
    private static let nativeType = UTType.mnml.identifier
    
    /// The native entry to merge into a pasteboard item on copy.
    private static func nativeItem(for source: String) -> [String: Any] { [nativeType: Data(source.utf8)] }
    
    /// Minimal's own source carried on `pasteboard`, if present.
    static func nativeSource(from pasteboard: UIPasteboard) -> String? {
        guard let data = pasteboard.data(forPasteboardType: nativeType) else { return nil }
        return String(data: data, encoding: .utf8)
    }
}

let quickExport = UIKeyCommand(title: "Quick Export",
                                       action: #selector(quickExportNoteViaCommand),
                                       input: "E",
                                       modifierFlags: [.command, .alternate],
                                       discoverabilityTitle: "Quick Export")