typst-as-lib 0.16.0

Small wrapper for typst that makes it easier to use it as a templating engine
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

use std::fs;
use typst::foundations::{Bytes, Dict, IntoValue, Value};
use typst_as_lib::TypstEngine;

static TEMPLATE_FILE: &str = include_str!("./templates/html.typ");
static OUTPUT: &str = "./examples/output.html";
static IMAGE: &[u8] = include_bytes!("./templates/images/typst.png");

fn main() {
    // Read in fonts and the main source file.
    // We can use this template more than once, if needed (Possibly
    // with different input each time).
    let template = TypstEngine::builder().main_file(TEMPLATE_FILE).build();

    // Run it
    let doc = template
        .compile_with_input(dummy_data())
        .output
        .expect("typst::compile() returned an error!");

    // Create html
    let options = Default::default();
    let html = typst_html::html(&doc, &options).expect("Could not generate HTML.");
    fs::write(OUTPUT, html).expect("Could not write HTML.");
}

fn dummy_data() -> Content {
    Content {
        v: vec![
            ContentElement {
                heading: "Foo".to_owned(),
                text: Some("Hello World!".to_owned()),
                num1: 1,
                num2: Some(42),
                image: Some(Bytes::new(IMAGE.to_vec())),
            },
            ContentElement {
                heading: "Bar".to_owned(),
                num1: 2,
                ..Default::default()
            },
        ],
    }
}

#[derive(Debug, Clone)]
struct Content {
    v: Vec<ContentElement>,
}

impl From<Content> for Dict {
    fn from(value: Content) -> Self {
        let mut dict = Dict::new();
        dict.insert("v".into(), value.v.into_value());
        dict
    }
}

impl IntoValue for Content {
    fn into_value(self) -> Value {
        Value::Dict(self.into())
    }
}

#[derive(Debug, Clone, Default)]
struct ContentElement {
    heading: String,
    text: Option<String>,
    num1: i32,
    num2: Option<i32>,
    image: Option<Bytes>,
}

impl IntoValue for ContentElement {
    fn into_value(self) -> Value {
        let mut dict = Dict::new();
        dict.insert("heading".into(), self.heading.into_value());
        dict.insert("text".into(), self.text.into_value());
        dict.insert("num1".into(), self.num1.into_value());
        dict.insert("num2".into(), self.num2.into_value());
        dict.insert("image".into(), self.image.into_value());
        Value::Dict(dict)
    }
}