PDF Generation & Document Export

Generate professional PDFs, export data to multiple formats, and implement sharing/printing for iOS applications.

When to Use This Skill

Use this skill when:

• Generating PDFs from SwiftUI views (reports, schedules, documents)
• Creating professional document templates with headers/footers/branding
• Exporting financial data (amortization schedules, payment histories)
• Implementing share sheets for document distribution
• Adding print support to iOS apps
• Exporting data to CSV, JSON, or other formats
• Creating multi-page documents with proper pagination

Quick Start

Generate PDF from SwiftUI View

Use generate_pdf_from_view.py to create PDF export functionality:

python scripts/generate_pdf_from_view.py AmortizationTableView --page-size letter

This generates Swift code that adds a generatePDF() method to your view.

Create Professional Report Template

Use create_report_template.py to scaffold a complete report:

python scripts/create_report_template.py MortgageReport --logo --sections Summary Details Analysis

This creates a SwiftUI view with headers, footers, sections, and branding.

Export Data to CSV

Use export_to_csv.py to generate CSV export code:

python scripts/export_to_csv.py Payment date amount principal interest balance --share-sheet

This generates CSV export functionality with share sheet integration.

Core Workflows

Workflow 1: Export Amortization Schedule to PDF

For a mortgage calculator app with a 30-year amortization schedule:

1. Generate PDF renderer for your table view:

   python scripts/generate_pdf_from_view.py AmortizationTableView --page-size letter --multi-page
   

2. Review references/pdf-generation-patterns.md for multi-page table patterns

3. Implement pagination using the multi-page pattern:

   • Group payments into pages (30-36 rows per page)
   • Add headers/footers to each page
   • Include page numbers

4. Test the PDF generation with full 360-payment schedule

Workflow 2: Create Complete Financial Report

For a professional mortgage summary report with charts and tables:

1. Create report template:

   python scripts/create_report_template.py MortgageSummaryReport --logo --sections Summary LoanDetails PaymentBreakdown AmortizationSchedule
   

2. Review references/report-templates-guide.md for:

   • Professional styling patterns
   • Chart integration examples
   • Multi-page report structure

3. Customize each section with:

   • Loan summary with key metrics
   • Detailed loan parameters
   • Payment breakdown chart
   • First year amortization table

4. Generate PDF using the report template

Workflow 3: Multi-Format Export with Sharing

Export data in multiple formats and share via iOS share sheet:

1. Generate CSV export:

   python scripts/export_to_csv.py Payment month payment principal interest balance --share-sheet
   

2. Generate PDF export using generate_pdf_from_view.py

3. Review references/export-formats-reference.md for:

   • Format selection guidance
   • Share sheet integration
   • Multiple format sharing

4. Implement share button that offers both PDF and CSV

Workflow 4: Print Support

Add native iOS print functionality:

1. Generate print renderer:

   python scripts/setup_print_renderer.py ReportView --page-size letter
   

2. Add print button to your UI that calls the generated print() method

3. Test print preview and actual printing

Script Reference

generate_pdf_from_view.py

Generate PDF rendering code for SwiftUI views.

Arguments:

• view_name - Name of the SwiftUI view (required)
• --page-size - PDF page size: letter, a4, legal, tabloid (default: letter)
• --no-margins - Disable default margins
• --multi-page - Generate multi-page document support

Example:

python scripts/generate_pdf_from_view.py MortgageReport --page-size a4 --multi-page

create_report_template.py

Generate professional report templates with branding.

Arguments:

• report_name - Name of the report view (required)
• --no-header - Disable header section
• --no-footer - Disable footer section
• --logo - Include company logo in header
• --sections - Custom section names (default: Summary Details Analysis)

Example:

python scripts/create_report_template.py QuarterlyReport --logo --sections Executive Operations Financial

export_to_csv.py

Generate CSV export functionality for data models.

Arguments:

• model_name - Name of the data model (required)
• properties - Model properties to export (required, multiple)
• --no-headers - Don't include column headers
• --share-sheet - Generate share sheet integration code

Example:

python scripts/export_to_csv.py Transaction date description amount category --share-sheet

setup_print_renderer.py

Generate print support code for SwiftUI views.

Arguments:

• view_name - Name of the SwiftUI view (required)
• --page-size - Print page size: letter, a4, legal, tabloid (default: letter)
• --no-preview - Don't generate print preview functionality

Example:

python scripts/setup_print_renderer.py InvoiceView --page-size letter

Reference Documentation

pdf-generation-patterns.md

Comprehensive patterns for PDF generation. Read this when:

• Implementing multi-page documents
• Creating tables and grids (amortization schedules)
• Adding headers and footers
• Handling page breaks intelligently
• Rendering complex views or charts

Key sections:

• Basic PDF generation pattern
• Multi-page document pagination
• Table layouts for financial data
• Header/footer consistency
• Page break algorithms

report-templates-guide.md

Professional report template patterns. Read this when:

• Creating financial reports
• Adding company branding
• Integrating charts and visualizations
• Implementing multi-page reports
• Establishing professional styling

Key sections:

• Financial report template (mortgage example)
• Multi-page report structure
• Chart integration patterns
• Professional styling (colors, typography)
• Branding integration
• Layout and content guidelines

export-formats-reference.md

Complete export format guide. Read this when:

• Choosing export format for use case
• Implementing CSV export
• Adding JSON export
• Creating plain text summaries
• Integrating share sheets
• Handling large datasets

Key sections:

• Format comparison (PDF, CSV, JSON, Text, Excel)
• Share sheet integration
• File naming conventions
• Format selection guide
• Performance considerations
• Error handling

Common Patterns

Pattern: Generate PDF with Error Handling

func exportReport() {
    do {
        let pdfData = reportView.generatePDF()
        let url = try savePDF(pdfData, fileName: "MortgageReport_\(Date().ISO8601Format()).pdf")
        
        // Share the PDF
        presentShareSheet(with: [url])
    } catch {
        showError("Failed to generate PDF: \(error.localizedDescription)")
    }
}

Pattern: Multi-Format Export

struct ExportView: View {
    @State private var showShareSheet = false
    @State private var exportItems: [Any] = []
    
    var body: some View {
        Button("Export & Share") {
            exportItems = generateExports()
            showShareSheet = true
        }
        .sheet(isPresented: $showShareSheet) {
            ShareSheet(items: exportItems)
        }
    }
    
    func generateExports() -> [Any] {
        var items: [Any] = []
        
        // PDF
        let pdfData = reportView.generatePDF()
        items.append(pdfData)
        
        // CSV
        if let csvURL = try? payments.saveAsCSV() {
            items.append(csvURL)
        }
        
        return items
    }
}

Pattern: Paginated Report

struct PaginatedReport: View {
    let allPayments: [Payment]
    let paymentsPerPage = 36
    
    var pages: [[Payment]] {
        stride(from: 0, to: allPayments.count, by: paymentsPerPage).map {
            Array(allPayments[$0..<min($0 + paymentsPerPage, allPayments.count)])
        }
    }
    
    @MainActor
    func generatePDF() -> Data {
        let pageRect = CGRect(origin: .zero, size: CGSize(width: 612, height: 792))
        let renderer = UIGraphicsPDFRenderer(bounds: pageRect)
        
        return renderer.pdfData { context in
            for (index, pagePayments) in pages.enumerated() {
                context.beginPage()
                
                let pageView = ReportPage(
                    payments: pagePayments,
                    pageNumber: index + 1,
                    totalPages: pages.count
                )
                
                let controller = UIHostingController(rootView: pageView)
                controller.view.frame = pageRect
                controller.view.backgroundColor = .white
                controller.view.layer.render(in: context.cgContext)
            }
        }
    }
}

Best Practices

PDF Generation

1. Use standard page sizes: Letter (612x792) or A4 (595x842) points
2. Include margins: 40-50 points minimum (0.5-0.7 inches)
3. Test pagination: Verify multi-page documents render all content
4. Optimize for print: Use high-contrast colors, readable fonts
5. Add metadata: Include generation date, page numbers
6. Handle large datasets: Paginate intelligently for 100+ rows

Report Design

1. Be consistent: Use same fonts, colors, spacing throughout
2. Prioritize readability: 10-12pt body text, adequate line spacing
3. Visual hierarchy: Use font sizes to show information importance
4. White space: Don't cram too much content on one page
5. Professional branding: Include company logo and colors
6. Executive summary: Lead with key findings/numbers

Export Formats

1. PDF: Professional reports, documents, printing
2. CSV: Data analysis, spreadsheet import, large datasets
3. JSON: API integration, structured data, backups
4. Text: Email content, simple summaries

Performance

1. Large datasets: Use incremental file writing for 1000+ rows
2. Memory management: Generate PDFs on background thread when possible
3. File size: Compress large PDFs, optimize images
4. Testing: Verify exports work with maximum expected data size

Troubleshooting

PDFs Render Incorrectly

• Ensure SwiftUI view has explicit frame dimensions
• Call layoutIfNeeded() before rendering
• Check that page size matches view dimensions
• Verify margins don't exceed page boundaries

Multi-Page Documents Cut Off

• Calculate page breaks based on content height
• Test with maximum dataset size (e.g., 360 payments)
• Ensure headers/footers account for their own height
• Leave buffer space at page bottom

Share Sheet Not Showing

• Verify items array is not empty
• Check file URLs are accessible
• Ensure @State binding is properly connected
• Test on actual device (not just simulator)

CSV Special Characters

• Escape commas in values with quotes
• Handle newlines in text fields
• Use UTF-8 encoding for international characters
• Test with edge cases (quotes, commas in data)

Real-World Example: Mortgage Calculator

Complete implementation for exporting 30-year amortization schedule:

# 1. Generate PDF renderer with multi-page support
python scripts/generate_pdf_from_view.py AmortizationScheduleView --multi-page

# 2. Generate CSV export with share sheet
python scripts/export_to_csv.py Payment month payment principal interest balance --share-sheet

# 3. Create summary report template
python scripts/create_report_template.py MortgageSummaryReport --logo --sections Summary Details Schedule

# 4. Generate print support
python scripts/setup_print_renderer.py MortgageSummaryReport

Then implement the full export feature:

1. Paginate 360 payments into 10 pages (36 per page)
2. Add professional headers with loan details
3. Include footer with page numbers and date
4. Generate both PDF and CSV formats
5. Present share sheet with both formats
6. Add print button for direct printing

Integration with Other Skills

This skill works well with:

• iOS Code Quality Auditor: Audit export code for memory leaks
• iOS Testing Suite Generator: Generate tests for export functions
• SwiftUI Architecture Review: Review export feature architecture
• App Store Submission: Validate export file permissions