mmdflux 2.1.0

Render Mermaid diagrams as Unicode text, ASCII, SVG, and MMDS JSON.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Runtime rendering from diagram payloads.

use super::graph_family;
use crate::errors::RenderError;
use crate::format::OutputFormat;
use crate::graph::measure;
use crate::payload::Diagram;
use crate::render::text::CharSet;
use crate::render::timeline;
use crate::runtime::config::RenderConfig;
use crate::timeline::sequence::layout;

pub(in crate::runtime) fn render_payload(
    payload: Diagram,
    format: OutputFormat,
    config: &RenderConfig,
) -> Result<String, RenderError> {
    // Apply show_ids annotation to graph-family payloads before rendering.
    // This is a presentation concern owned by runtime, not diagrams.
    let payload = if config.show_ids {
        annotate_graph_payload_ids(payload)
    } else {
        payload
    };

    match payload {
        Diagram::Flowchart(graph) => {
            graph_family::render_graph_family("flowchart", &graph, format, config)
        }
        Diagram::Class(graph) => graph_family::render_graph_family("class", &graph, format, config),
        Diagram::State(graph) => graph_family::render_graph_family("state", &graph, format, config),
        Diagram::Sequence(model) => match format {
            OutputFormat::Svg => {
                let metrics = measure::default_proportional_text_metrics();
                let font_family = "\"trebuchet ms\", verdana, arial, sans-serif";
                let theme = super::resolve_configured_svg_theme(config)?;
                Ok(timeline::render_svg(
                    &model,
                    &metrics,
                    font_family,
                    theme.as_ref(),
                ))
            }
            OutputFormat::Mmds => {
                let metrics = measure::default_proportional_text_metrics();
                Ok(super::timeline_family::to_json(&model, &metrics))
            }
            _ => {
                let seq_layout = layout::layout(&model);
                let charset = match format {
                    OutputFormat::Ascii => CharSet::ascii(),
                    _ => CharSet::unicode(),
                };
                Ok(timeline::render(&seq_layout, &charset))
            }
        },
    }
}

/// Annotate node labels as "ID: Label" for graph-family payloads.
/// Skips bare nodes where label == id (no useful annotation).
fn annotate_graph_payload_ids(payload: Diagram) -> Diagram {
    match payload {
        Diagram::Flowchart(mut graph) => {
            annotate_node_ids(&mut graph);
            Diagram::Flowchart(graph)
        }
        Diagram::Class(mut graph) => {
            annotate_node_ids(&mut graph);
            Diagram::Class(graph)
        }
        Diagram::State(mut graph) => {
            annotate_node_ids(&mut graph);
            Diagram::State(graph)
        }
        other => other,
    }
}

fn annotate_node_ids(graph: &mut crate::graph::Graph) {
    for node in graph.nodes.values_mut() {
        if node.label != node.id {
            node.label = format!("{}: {}", node.id, node.label);
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::format::OutputFormat;
    use crate::runtime::config::RenderConfig;

    #[test]
    fn render_payload_annotates_node_ids_when_show_ids_is_set() {
        let config = RenderConfig {
            show_ids: true,
            ..RenderConfig::default()
        };
        let output = crate::runtime::render_diagram(
            "graph TD\nA[Start] --> B[End]",
            OutputFormat::Text,
            &config,
        )
        .unwrap();
        assert!(
            output.contains("A: Start"),
            "output should contain annotated ID: {output}"
        );
        assert!(
            output.contains("B: End"),
            "output should contain annotated ID: {output}"
        );
    }

    #[test]
    fn render_payload_skips_annotation_when_show_ids_is_false() {
        let config = RenderConfig::default();
        let output = crate::runtime::render_diagram(
            "graph TD\nA[Start] --> B[End]",
            OutputFormat::Text,
            &config,
        )
        .unwrap();
        assert!(
            !output.contains("A:"),
            "output should not have ID prefix: {output}"
        );
    }
}