renderreport 0.2.0

Data-driven report generation with Typst as embedded render engine — no CLI dependency
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Render request and output types

use crate::pack::PackId;
use crate::theme::Theme;

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;

/// Request to render a report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenderRequest {
    /// Template identifier
    pub template_id: String,
    /// Optional pack identifier
    #[serde(default)]
    pub pack_id: Option<PackId>,
    /// Report title
    #[serde(default)]
    pub title: Option<String>,
    /// Report subtitle
    #[serde(default)]
    pub subtitle: Option<String>,
    /// Theme overrides
    #[serde(default)]
    pub theme: Option<Theme>,
    /// Report components
    #[serde(default)]
    pub components: Vec<serde_json::Value>,
    /// Asset references (name -> path)
    #[serde(default)]
    pub assets: HashMap<String, PathBuf>,
    /// Additional metadata
    #[serde(default)]
    pub metadata: HashMap<String, String>,
}

impl RenderRequest {
    /// Create a new render request
    pub fn new(template_id: impl Into<String>) -> Self {
        Self {
            template_id: template_id.into(),
            pack_id: None,
            title: None,
            subtitle: None,
            theme: None,
            components: Vec::new(),
            assets: HashMap::new(),
            metadata: HashMap::new(),
        }
    }
}

/// Output from rendering
#[derive(Debug)]
pub enum RenderOutput {
    /// PDF bytes
    Pdf(Vec<u8>),
    /// Future: HTML output
    #[allow(dead_code)]
    Html(String),
}

impl RenderOutput {
    /// Convert to bytes (for PDF)
    pub fn into_bytes(self) -> Vec<u8> {
        match self {
            RenderOutput::Pdf(bytes) => bytes,
            RenderOutput::Html(html) => html.into_bytes(),
        }
    }

    /// Check if output is PDF
    pub fn is_pdf(&self) -> bool {
        matches!(self, RenderOutput::Pdf(_))
    }
}