feat: add support for rendering mermaid diagrams

config-file-schema.json

@@ -14,16 +14,14 @@
         }
       ]
     },
+    "mermaid": {
+      "$ref": "#/definitions/MermaidConfig"
+    },
     "options": {
       "$ref": "#/definitions/OptionsConfig"
     },
     "typst": {
-      "allOf": [
-        {
-          "$ref": "#/definitions/TypstConfig"
-        }
-      ],
-      "minimum": 1.0
+      "$ref": "#/definitions/TypstConfig"
     }
   },
   "additionalProperties": false,
@@ -210,6 +208,19 @@
       },
       "additionalProperties": false
     },
+    "MermaidConfig": {
+      "type": "object",
+      "properties": {
+        "scale": {
+          "description": "The scaling parameter to be used in the mermaid CLI.",
+          "default": 2,
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        }
+      },
+      "additionalProperties": false
+    },
     "OptionsConfig": {
       "type": "object",
       "properties": {

src/custom.rs

@@ -16,9 +16,11 @@ pub struct Config {
     pub defaults: DefaultsConfig,
 
     #[serde(default)]
-    #[validate(range(min = 1))]
     pub typst: TypstConfig,
 
+    #[serde(default)]
+    pub mermaid: MermaidConfig,
+
     #[serde(default)]
     pub options: OptionsConfig,
 
@@ -126,10 +128,28 @@ impl Default for TypstConfig {
     }
 }
 
-fn default_typst_ppi() -> u32 {
+pub(crate) fn default_typst_ppi() -> u32 {
     300
 }
 
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct MermaidConfig {
+    /// The scaling parameter to be used in the mermaid CLI.
+    #[serde(default = "default_mermaid_scale")]
+    pub scale: u32,
+}
+
+impl Default for MermaidConfig {
+    fn default() -> Self {
+        Self { scale: default_mermaid_scale() }
+    }
+}
+
+pub(crate) fn default_mermaid_scale() -> u32 {
+    2
+}
+
 #[derive(Clone, Debug, Default, Deserialize, ValueEnum, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 pub enum ImageProtocol {

src/demo.rs

@@ -8,7 +8,7 @@ use crate::{
     presentation::Presentation,
     processing::builder::{BuildError, PresentationBuilder},
     render::{draw::TerminalDrawer, terminal::TerminalWrite},
-    ImageRegistry, MarkdownParser, PresentationBuilderOptions, PresentationTheme, Resources, Themes, TypstRender,
+    ImageRegistry, MarkdownParser, PresentationBuilderOptions, PresentationTheme, Resources, Themes, ThirdPartyRender,
 };
 use std::{io, rc::Rc};
 
@@ -100,14 +100,14 @@ impl<W: TerminalWrite> ThemesDemo<W> {
     ) -> Result<Presentation, BuildError> {
         let image_registry = ImageRegistry::default();
         let mut resources = Resources::new("non_existent", image_registry.clone());
-        let mut typst = TypstRender::default();
+        let mut third_party = ThirdPartyRender::default();
         let options = PresentationBuilderOptions::default();
         let executer = Rc::new(CodeExecutor::default());
         let bindings_config = Default::default();
         let builder = PresentationBuilder::new(
             theme,
             &mut resources,
-            &mut typst,
+            &mut third_party,
             executer,
             &self.themes,
             image_registry,

src/export.rs

@@ -8,8 +8,8 @@ use crate::{
     },
     presentation::{Presentation, RenderOperation},
     processing::builder::{BuildError, PresentationBuilder, PresentationBuilderOptions, Themes},
+    third_party::ThirdPartyRender,
     tools::{ExecutionError, ThirdPartyTools},
-    typst::TypstRender,
     MarkdownParser, PresentationTheme, Resources,
 };
 use base64::{engine::general_purpose::STANDARD, Engine};
@@ -29,7 +29,7 @@ pub struct Exporter<'a> {
     parser: MarkdownParser<'a>,
     default_theme: &'a PresentationTheme,
     resources: Resources,
-    typst: TypstRender,
+    third_party: ThirdPartyRender,
     code_executor: Rc<CodeExecutor>,
     themes: Themes,
     options: PresentationBuilderOptions,
@@ -41,12 +41,12 @@ impl<'a> Exporter<'a> {
         parser: MarkdownParser<'a>,
         default_theme: &'a PresentationTheme,
         resources: Resources,
-        typst: TypstRender,
+        third_party: ThirdPartyRender,
         code_executor: Rc<CodeExecutor>,
         themes: Themes,
         options: PresentationBuilderOptions,
     ) -> Self {
-        Self { parser, default_theme, resources, typst, code_executor, themes, options }
+        Self { parser, default_theme, resources, third_party, code_executor, themes, options }
     }
 
     /// Export the given presentation into PDF.
@@ -85,7 +85,7 @@ impl<'a> Exporter<'a> {
         let mut presentation = PresentationBuilder::new(
             self.default_theme,
             &mut self.resources,
-            &mut self.typst,
+            &mut self.third_party,
             self.code_executor.clone(),
             &self.themes,
             Default::default(),
@@ -302,11 +302,11 @@ mod test {
         let parser = MarkdownParser::new(&arena);
         let theme = PresentationThemeSet::default().load_by_name("dark").unwrap();
         let resources = Resources::new("examples", Default::default());
-        let typst = TypstRender::default();
+        let third_party = ThirdPartyRender::default();
         let code_executor = Default::default();
         let themes = Themes::default();
         let options = PresentationBuilderOptions { allow_mutations: false, ..Default::default() };
-        let mut exporter = Exporter::new(parser, &theme, resources, typst, code_executor, themes, options);
+        let mut exporter = Exporter::new(parser, &theme, resources, third_party, code_executor, themes, options);
         exporter.extract_metadata(content, Path::new(path)).expect("metadata extraction failed")
     }
 

src/lib.rs

@@ -17,8 +17,8 @@ pub(crate) mod render;
 pub(crate) mod resource;
 pub(crate) mod style;
 pub(crate) mod theme;
+pub(crate) mod third_party;
 pub(crate) mod tools;
-pub(crate) mod typst;
 
 pub use crate::{
     custom::{Config, ImageProtocol, ValidateOverflows},
@@ -33,5 +33,5 @@ pub use crate::{
     render::highlighting::{CodeHighlighter, HighlightThemeSet},
     resource::Resources,
     theme::{LoadThemeError, PresentationTheme, PresentationThemeSet},
-    typst::TypstRender,
+    third_party::{ThirdPartyConfigs, ThirdPartyRender},
 };

src/main.rs

@@ -4,7 +4,7 @@ use directories::ProjectDirs;
 use presenterm::{
     CodeExecutor, CommandSource, Config, Exporter, GraphicsMode, HighlightThemeSet, ImagePrinter, ImageProtocol,
     ImageRegistry, MarkdownParser, PresentMode, PresentationBuilderOptions, PresentationTheme, PresentationThemeSet,
-    Presenter, PresenterOptions, Resources, Themes, ThemesDemo, TypstRender, ValidateOverflows,
+    Presenter, PresenterOptions, Resources, Themes, ThemesDemo, ThirdPartyConfigs, ThirdPartyRender, ValidateOverflows,
 };
 use std::{
     env, io,
@@ -211,10 +211,13 @@ fn run(mut cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
     let printer = Rc::new(ImagePrinter::new(graphics_mode.clone())?);
     let registry = ImageRegistry(printer.clone());
     let resources = Resources::new(resources_path, registry.clone());
-    let typst = TypstRender::new(config.typst.ppi, registry, resources_path);
+    let third_party_config =
+        ThirdPartyConfigs { typst_ppi: config.typst.ppi.to_string(), mermaid_scale: config.mermaid.scale.to_string() };
+    let third_party = ThirdPartyRender::new(third_party_config, registry, resources_path);
     let code_executor = Rc::new(code_executor);
     if cli.export_pdf || cli.generate_pdf_metadata {
-        let mut exporter = Exporter::new(parser, &default_theme, resources, typst, code_executor, themes, options);
+        let mut exporter =
+            Exporter::new(parser, &default_theme, resources, third_party, code_executor, themes, options);
         let mut args = Vec::new();
         if let Some(theme) = cli.theme.as_ref() {
             args.extend(["--theme", theme]);
@@ -239,8 +242,17 @@ fn run(mut cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
             bindings: config.bindings,
             validate_overflows,
         };
-        let presenter =
-            Presenter::new(&default_theme, commands, parser, resources, typst, code_executor, themes, printer, options);
+        let presenter = Presenter::new(
+            &default_theme,
+            commands,
+            parser,
+            resources,
+            third_party,
+            code_executor,
+            themes,
+            printer,
+            options,
+        );
         presenter.present(&path)?;
     }
     Ok(())

src/markdown/elements.rs

@@ -217,6 +217,7 @@ pub enum CodeLanguage {
     Latex,
     Lua,
     Makefile,
+    Mermaid,
     Markdown,
     Nix,
     OCaml,
@@ -245,7 +246,7 @@ pub enum CodeLanguage {
 
 impl CodeLanguage {
     pub(crate) fn supports_auto_render(&self) -> bool {
-        matches!(self, Self::Latex | Self::Typst)
+        matches!(self, Self::Latex | Self::Typst | Self::Mermaid)
     }
 }
 
@@ -283,6 +284,7 @@ impl FromStr for CodeLanguage {
             "lua" => Lua,
             "make" => Makefile,
             "markdown" => Markdown,
+            "mermaid" => Mermaid,
             "nix" => Nix,
             "ocaml" => OCaml,
             "perl" => Perl,

src/presenter.rs

@@ -15,7 +15,7 @@ use crate::{
     },
     resource::Resources,
     theme::PresentationTheme,
-    typst::TypstRender,
+    third_party::ThirdPartyRender,
 };
 use std::{
     collections::HashSet,
@@ -43,7 +43,7 @@ pub struct Presenter<'a> {
     commands: CommandSource,
     parser: MarkdownParser<'a>,
     resources: Resources,
-    typst: TypstRender,
+    third_party: ThirdPartyRender,
     code_executor: Rc<CodeExecutor>,
     state: PresenterState,
     slides_with_pending_widgets: HashSet<usize>,
@@ -60,7 +60,7 @@ impl<'a> Presenter<'a> {
         commands: CommandSource,
         parser: MarkdownParser<'a>,
         resources: Resources,
-        typst: TypstRender,
+        third_party: ThirdPartyRender,
         code_executor: Rc<CodeExecutor>,
         themes: Themes,
         image_printer: Rc<ImagePrinter>,
@@ -71,7 +71,7 @@ impl<'a> Presenter<'a> {
             commands,
             parser,
             resources,
-            typst,
+            third_party,
             code_executor,
             state: PresenterState::Empty,
             slides_with_pending_widgets: HashSet::new(),
@@ -260,7 +260,7 @@ impl<'a> Presenter<'a> {
         let mut presentation = PresentationBuilder::new(
             self.default_theme,
             &mut self.resources,
-            &mut self.typst,
+            &mut self.third_party,
             self.code_executor.clone(),
             &self.themes,
             ImageRegistry(self.image_printer.clone()),

src/processing/builder.rs

@@ -26,7 +26,7 @@ use crate::{
     theme::{
         Alignment, AuthorPositioning, ElementType, LoadThemeError, Margin, PresentationTheme, PresentationThemeSet,
     },
-    typst::{TypstRender, TypstRenderError},
+    third_party::{ThirdPartyRender, TypstRenderError},
 };
 use image::DynamicImage;
 use serde::Deserialize;
@@ -98,7 +98,7 @@ pub(crate) struct PresentationBuilder<'a> {
     code_executor: Rc<CodeExecutor>,
     theme: Cow<'a, PresentationTheme>,
     resources: &'a mut Resources,
-    typst: &'a mut TypstRender,
+    third_party: &'a mut ThirdPartyRender,
     slide_state: SlideState,
     footer_context: Rc<RefCell<FooterContext>>,
     themes: &'a Themes,
@@ -114,7 +114,7 @@ impl<'a> PresentationBuilder<'a> {
     pub(crate) fn new(
         default_theme: &'a PresentationTheme,
         resources: &'a mut Resources,
-        typst: &'a mut TypstRender,
+        third_party: &'a mut ThirdPartyRender,
         code_executor: Rc<CodeExecutor>,
         themes: &'a Themes,
         image_registry: ImageRegistry,
@@ -130,7 +130,7 @@ impl<'a> PresentationBuilder<'a> {
             code_executor,
             theme: Cow::Borrowed(default_theme),
             resources,
-            typst,
+            third_party,
             slide_state: Default::default(),
             footer_context: Default::default(),
             themes,
@@ -694,8 +694,9 @@ impl<'a> PresentationBuilder<'a> {
 
     fn push_rendered_code(&mut self, code: Code) -> Result<(), BuildError> {
         let image = match code.language {
-            CodeLanguage::Typst => self.typst.render_typst(&code.contents, &self.theme.typst)?,
-            CodeLanguage::Latex => self.typst.render_latex(&code.contents, &self.theme.typst)?,
+            CodeLanguage::Typst => self.third_party.render_typst(&code.contents, &self.theme.typst)?,
+            CodeLanguage::Latex => self.third_party.render_latex(&code.contents, &self.theme.typst)?,
+            CodeLanguage::Mermaid => self.third_party.render_mermaid(&code.contents, &self.theme.mermaid)?,
             _ => panic!("language {:?} should not be renderable", code.language),
         };
         self.push_image(image);
@@ -1065,14 +1066,14 @@ mod test {
     ) -> Result<Presentation, BuildError> {
         let theme = PresentationTheme::default();
         let mut resources = Resources::new("/tmp", Default::default());
-        let mut typst = TypstRender::default();
+        let mut third_party = ThirdPartyRender::default();
         let code_executor = Rc::new(CodeExecutor::default());
         let themes = Themes::default();
         let bindings = KeyBindingsConfig::default();
         let builder = PresentationBuilder::new(
             &theme,
             &mut resources,
-            &mut typst,
+            &mut third_party,
             code_executor,
             &themes,
             Default::default(),

src/render/highlighting.rs

@@ -137,6 +137,7 @@ impl CodeHighlighter {
             Lua => "lua",
             Makefile => "make",
             Markdown => "md",
+            Mermaid => "txt",
             Nix => "nix",
             OCaml => "ml",
             Perl => "pl",