renderreport 0.2.5

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Template pack system
//!
//! Packs contain templates, components, themes, and assets.
//! They can be loaded from the filesystem, embedded, or (later) from remote sources.

mod loader;
mod manifest;

pub use loader::PackLoader;
pub use manifest::PackManifest;

use crate::theme::Theme;

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

/// Unique identifier for a pack
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct PackId(pub String);

impl PackId {
    pub fn new(id: impl Into<String>) -> Self {
        Self(id.into())
    }
}

impl std::fmt::Display for PackId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl From<&str> for PackId {
    fn from(s: &str) -> Self {
        Self(s.to_string())
    }
}

/// A template pack containing templates, components, themes, and assets
#[derive(Debug, Clone)]
pub struct Pack {
    /// Pack identifier
    pub id: PackId,
    /// Pack manifest
    pub manifest: PackManifest,
    /// Root path (if loaded from filesystem)
    pub root_path: Option<PathBuf>,
    /// Default theme from pack
    pub default_theme: Option<Theme>,
    /// Available themes
    pub themes: HashMap<String, Theme>,
    /// Template files (name -> content)
    pub templates: HashMap<String, String>,
    /// Component overrides (name -> content)
    pub components: HashMap<String, String>,
    /// Asset files (name -> bytes)
    pub assets: HashMap<String, Vec<u8>>,
}

impl Pack {
    /// Create a new empty pack
    pub fn new(id: impl Into<String>, manifest: PackManifest) -> Self {
        Self {
            id: PackId::new(id),
            manifest,
            root_path: None,
            default_theme: None,
            themes: HashMap::new(),
            templates: HashMap::new(),
            components: HashMap::new(),
            assets: HashMap::new(),
        }
    }

    /// Get a template by name
    pub fn get_template(&self, name: &str) -> Option<&String> {
        self.templates.get(name)
    }

    /// Get a component by name
    pub fn get_component(&self, name: &str) -> Option<&String> {
        self.components.get(name)
    }

    /// Get a theme by name
    pub fn get_theme(&self, name: &str) -> Option<&Theme> {
        self.themes.get(name)
    }

    /// Get an asset by name
    pub fn get_asset(&self, name: &str) -> Option<&Vec<u8>> {
        self.assets.get(name)
    }

    /// List available templates
    pub fn list_templates(&self) -> Vec<&String> {
        self.templates.keys().collect()
    }

    /// List available themes
    pub fn list_themes(&self) -> Vec<&String> {
        self.themes.keys().collect()
    }
}