merman-core 0.4.1

Mermaid parser + semantic model (headless; parity-focused).
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

use crate::{Error, ParseMetadata, Result};
use serde_json::Value;

pub type DiagramSemanticParser = fn(code: &str, meta: &ParseMetadata) -> Result<Value>;

#[derive(Debug, Clone, Default)]
pub struct DiagramRegistry {
    parsers: std::collections::HashMap<&'static str, DiagramSemanticParser>,
}

impl DiagramRegistry {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn insert(&mut self, diagram_type: &'static str, parser: DiagramSemanticParser) {
        self.parsers.insert(diagram_type, parser);
    }

    pub fn get(&self, diagram_type: &str) -> Option<DiagramSemanticParser> {
        self.parsers.get(diagram_type).copied()
    }

    pub fn default_mermaid_11_12_2() -> Self {
        let mut reg = Self::new();

        reg.insert("error", crate::diagrams::error_diagram::parse_error);

        reg.insert("flowchart-v2", crate::diagrams::flowchart::parse_flowchart);
        reg.insert("flowchart", crate::diagrams::flowchart::parse_flowchart);
        reg.insert("flowchart-elk", crate::diagrams::flowchart::parse_flowchart);

        reg.insert("info", crate::diagrams::info::parse_info);
        reg.insert("pie", crate::diagrams::pie::parse_pie);
        reg.insert("c4", crate::diagrams::c4::parse_c4);
        reg.insert(
            "requirement",
            crate::diagrams::requirement::parse_requirement,
        );
        reg.insert("sequence", crate::diagrams::sequence::parse_sequence);
        reg.insert("zenuml", crate::diagrams::zenuml::parse_zenuml);

        reg.insert("classDiagram", crate::diagrams::class::parse_class);
        reg.insert("class", crate::diagrams::class::parse_class);

        reg.insert("er", crate::diagrams::er::parse_er);
        reg.insert("erDiagram", crate::diagrams::er::parse_er);

        reg.insert("stateDiagram", crate::diagrams::state::parse_state);
        reg.insert("state", crate::diagrams::state::parse_state);

        reg.insert("mindmap", crate::diagrams::mindmap::parse_mindmap);
        reg.insert("gantt", crate::diagrams::gantt::parse_gantt);
        reg.insert("timeline", crate::diagrams::timeline::parse_timeline);
        reg.insert("journey", crate::diagrams::journey::parse_journey);
        reg.insert("kanban", crate::diagrams::kanban::parse_kanban);
        reg.insert(
            "architecture",
            crate::diagrams::architecture::parse_architecture,
        );
        reg.insert("block", crate::diagrams::block::parse_block);
        reg.insert("gitGraph", crate::diagrams::git_graph::parse_git_graph);
        reg.insert(
            "quadrantChart",
            crate::diagrams::quadrant_chart::parse_quadrant_chart,
        );
        reg.insert("packet", crate::diagrams::packet::parse_packet);
        reg.insert("radar", crate::diagrams::radar::parse_radar);
        reg.insert("treemap", crate::diagrams::treemap::parse_treemap);
        reg.insert("sankey", crate::diagrams::sankey::parse_sankey);
        reg.insert("xychart", crate::diagrams::xychart::parse_xychart);

        reg
    }
}

#[derive(Debug, Clone)]
pub struct ParsedDiagram {
    pub meta: ParseMetadata,
    pub model: Value,
}

#[derive(Debug, Clone)]
pub enum RenderSemanticModel {
    Json(Value),
    Mindmap(crate::diagrams::mindmap::MindmapDiagramRenderModel),
    State(crate::diagrams::state::StateDiagramRenderModel),
    Flowchart(crate::diagrams::flowchart::FlowchartV2Model),
    Architecture(crate::diagrams::architecture::ArchitectureDiagramRenderModel),
    Class(crate::models::class_diagram::ClassDiagram),
}

#[derive(Debug, Clone)]
pub struct ParsedDiagramRender {
    pub meta: ParseMetadata,
    pub model: RenderSemanticModel,
}

pub fn parse_or_unsupported(
    registry: &DiagramRegistry,
    diagram_type: &str,
    code: &str,
    meta: &ParseMetadata,
) -> Result<Value> {
    let Some(parser) = registry.get(diagram_type) else {
        return Err(Error::UnsupportedDiagram {
            diagram_type: diagram_type.to_string(),
        });
    };
    parser(code, meta)
}