teasr-core 0.15.4

Core orchestration and capture for teasr
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use anyhow::{Context, Result};
use comrak::{markdown_to_html, Options};
use std::path::Path;
use tempfile::NamedTempFile;

use crate::types::{MarkdownFlavor, MarkdownTheme};

const TEMPLATE: &str = include_str!("../markdown_template.html");

struct Palette {
    fg: &'static str,
    bg: &'static str,
    heading: &'static str,
    link: &'static str,
    muted: &'static str,
    border: &'static str,
    code_bg: &'static str,
    stripe: &'static str,
}

const LIGHT: Palette = Palette {
    fg: "#1f2328",
    bg: "#ffffff",
    heading: "#1f2328",
    link: "#0969da",
    muted: "#656d76",
    border: "#d0d7de",
    code_bg: "#f6f8fa",
    stripe: "#f6f8fa",
};

const DARK: Palette = Palette {
    fg: "#e6edf3",
    bg: "#0d1117",
    heading: "#e6edf3",
    link: "#58a6ff",
    muted: "#8b949e",
    border: "#30363d",
    code_bg: "#161b22",
    stripe: "#161b22",
};

fn palette_for(theme: &MarkdownTheme) -> &'static Palette {
    match theme {
        MarkdownTheme::Light => &LIGHT,
        MarkdownTheme::Dark => &DARK,
    }
}

fn comrak_options(flavor: &MarkdownFlavor) -> Options<'_> {
    let mut opts = Options::default();
    match flavor {
        MarkdownFlavor::Commonmark => {
            // Strict CommonMark — no extensions.
        }
        MarkdownFlavor::Github | MarkdownFlavor::Custom => {
            opts.extension.strikethrough = true;
            opts.extension.table = true;
            opts.extension.autolink = true;
            opts.extension.tasklist = true;
            opts.extension.footnotes = true;
            opts.extension.header_ids = Some(String::new());
        }
    }
    opts.render.unsafe_ = true; // Allow raw HTML in markdown
    opts
}

/// Render a markdown file to a temporary HTML file ready for Chrome capture.
///
/// Returns the `NamedTempFile` — the caller must keep it alive until capture is done.
pub fn render_to_html(
    md_path: &Path,
    flavor: &MarkdownFlavor,
    theme: &MarkdownTheme,
    stylesheet: Option<&Path>,
    template: Option<&Path>,
    viewport_width: u32,
) -> Result<NamedTempFile> {
    let md_source = std::fs::read_to_string(md_path)
        .with_context(|| format!("failed to read markdown file: {}", md_path.display()))?;

    let opts = comrak_options(flavor);
    let html_body = markdown_to_html(&md_source, &opts);

    let full_html = if let Some(tpl_path) = template {
        // User-provided template — just substitute {{content}}.
        let tpl = std::fs::read_to_string(tpl_path)
            .with_context(|| format!("failed to read template: {}", tpl_path.display()))?;
        tpl.replace("{{content}}", &html_body)
    } else {
        // Use the bundled template with palette substitution.
        let palette = palette_for(theme);
        let mut html = TEMPLATE.to_string();
        html = html.replace("__VP_W__", &viewport_width.to_string());
        html = html.replace("__FG__", palette.fg);
        html = html.replace("__BG__", palette.bg);
        html = html.replace("__HEADING__", palette.heading);
        html = html.replace("__LINK__", palette.link);
        html = html.replace("__MUTED__", palette.muted);
        html = html.replace("__BORDER__", palette.border);
        html = html.replace("__CODE_BG__", palette.code_bg);
        html = html.replace("__STRIPE__", palette.stripe);

        // Syntax highlighting CSS from comrak/syntect (already inline in code spans).
        html = html.replace("__SYNTAX_CSS__", "");

        // Custom stylesheet injection.
        let custom_css = if let Some(css_path) = stylesheet {
            let css = std::fs::read_to_string(css_path)
                .with_context(|| format!("failed to read stylesheet: {}", css_path.display()))?;
            format!("<style>\n{css}\n</style>")
        } else {
            String::new()
        };
        html = html.replace("__CUSTOM_CSS__", &custom_css);

        html = html.replace("__CONTENT__", &html_body);
        html
    };

    let mut tmp = NamedTempFile::with_suffix(".html")
        .context("failed to create temp file for markdown render")?;
    std::io::Write::write_all(&mut tmp, full_html.as_bytes())
        .context("failed to write rendered markdown HTML")?;
    Ok(tmp)
}