Struct Engine 

pub struct Engine { /* private fields */ }

Headless Mermaid parser engine.

An engine owns detector/parser registries and a site-level Mermaid configuration. It is cheap to clone when callers need per-request option variants.

Implementations

impl Engine

pub fn new() -> Self

Creates an engine using the pinned Mermaid baseline registries and default site config.

pub fn with_fixed_today(self, today: Option<NaiveDate>) -> Self

Overrides the “today” value used by diagrams that depend on local time (e.g. Gantt).

This exists primarily to make fixture snapshots deterministic. By default, Mermaid uses the current local date.

pub fn with_fixed_local_offset_minutes( self, offset_minutes: Option<i32>, ) -> Self

Overrides the local timezone offset (in minutes) used by diagrams that depend on local time semantics (notably Gantt).

This exists primarily to make fixture snapshots deterministic across CI runners. When None, the system local timezone is used.

pub fn with_site_config(self, site_config: MermaidConfig) -> Self

Applies site-level Mermaid config defaults.

pub fn registry(&self) -> &DetectorRegistry

Returns the detector registry used for automatic diagram type detection.

pub fn registry_mut(&mut self) -> &mut DetectorRegistry

Returns a mutable detector registry for custom diagram detection.

pub fn diagram_registry(&self) -> &DiagramRegistry

Returns the semantic JSON parser registry.

pub fn diagram_registry_mut(&mut self) -> &mut DiagramRegistry

Returns a mutable semantic JSON parser registry for custom diagram adapters.

pub fn render_diagram_registry(&self) -> &RenderDiagramRegistry

Returns the typed render-model parser registry.

pub fn render_diagram_registry_mut(&mut self) -> &mut RenderDiagramRegistry

Returns a mutable typed render-model parser registry.

pub fn parse_metadata_sync( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParseMetadata>>

Synchronous variant of Engine::parse_metadata.

This is useful for UI render pipelines that are synchronous (e.g. immediate-mode UI), where introducing an async executor would be awkward. The parsing work is CPU-bound and does not perform I/O.

pub fn parse_metadata_with_type_sync( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParseMetadata>>

Parses metadata for an already-known diagram type (skips type detection).

This is intended for integrations that already know the diagram type, e.g. Markdown fences like ````mermaid/ flowchart` / ` sequenceDiagram`.

Example (Markdown fence)

use merman_core::{Engine, ParseOptions};

let engine = Engine::new();

// Your markdown parser provides the fence info string (e.g. "flowchart", "sequenceDiagram").
let fence = "sequenceDiagram";
let diagram = r#"sequenceDiagram
  Alice->>Bob: Hello
"#;

// Map fence info strings to merman's internal diagram ids.
let diagram_type = match fence {
    "sequenceDiagram" => "sequence",
    "flowchart" | "graph" => "flowchart-v2",
    "stateDiagram" | "stateDiagram-v2" => "stateDiagram",
    other => other,
};

let meta = engine
    .parse_metadata_with_type_sync(diagram_type, diagram, ParseOptions::strict())?
    .expect("diagram detected");

pub async fn parse_metadata( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParseMetadata>>

Async facade for Engine::parse_metadata_sync.

The work is CPU-bound and executes synchronously; this method exists for callers that prefer an async-shaped API.

pub async fn parse_metadata_with_type( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParseMetadata>>

Async facade for Engine::parse_metadata_with_type_sync.

The work is CPU-bound and executes synchronously.

pub fn parse_diagram_sync( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagram>>

Synchronous variant of Engine::parse_diagram.

Note: callers that want “always returns a diagram” behavior can set ParseOptions::suppress_errors to true to get an error diagram on parse failures.

pub async fn parse_diagram( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagram>>

Async facade for Engine::parse_diagram_sync.

The work is CPU-bound and executes synchronously.

pub fn parse_diagram_for_render_model_sync( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagramRender>>

Parses a diagram into a typed semantic model optimized for headless layout + SVG rendering.

Unlike Engine::parse_diagram_sync, this avoids constructing large serde_json::Value object trees for high-impact typed-first diagrams and instead returns typed semantic structs that the renderer can consume directly.

Callers that need the semantic JSON model should continue using Engine::parse_diagram_sync.

pub async fn parse_diagram_for_render_model( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagramRender>>

Async facade for Engine::parse_diagram_for_render_model_sync.

The work is CPU-bound and executes synchronously.

pub fn parse_diagram_for_render_model_with_type_sync( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagramRender>>

Parses a diagram into a typed semantic render model when the diagram type is already known (skips type detection).

This is the preferred entrypoint for Markdown renderers and editors that already know the diagram type from the code fence info string. It avoids the detection pass and can reduce a small fixed overhead in tight render loops.

pub async fn parse_diagram_for_render_model_with_type( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagramRender>>

Async facade for Engine::parse_diagram_for_render_model_with_type_sync.

The work is CPU-bound and executes synchronously.

pub fn parse_diagram_with_type_sync( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagram>>

Parses a diagram when the diagram type is already known (skips type detection).

This is the preferred entrypoint for Markdown renderers and editors that already know the diagram type from the code fence info string. It avoids the detection pass and can reduce a small fixed overhead in tight render loops.

Example

use merman_core::{Engine, ParseOptions};

let engine = Engine::new();
let input = "flowchart TD; A-->B;";

let parsed = engine
    .parse_diagram_with_type_sync("flowchart-v2", input, ParseOptions::strict())?
    .expect("diagram detected");

assert_eq!(parsed.meta.diagram_type, "flowchart-v2");

pub async fn parse_diagram_with_type( &self, diagram_type: &str, text: &str, options: ParseOptions, ) -> Result<Option<ParsedDiagram>>

Async facade for Engine::parse_diagram_with_type_sync.

The work is CPU-bound and executes synchronously.

pub async fn parse( &self, text: &str, options: ParseOptions, ) -> Result<Option<ParseMetadata>>

Backward-compatible shorthand for Engine::parse_metadata.

Trait Implementations

impl Clone for Engine

fn clone(&self) -> Engine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Engine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.