🥮 mooncakes.io

    bobzhang/beautiful_mermaid/model does not have a README file

    MermaidError

    source
    pub(all) suberror MermaidError {
      ParseFailure(String)
      UnknownTheme(String)
    } derive(
    Debug    )

    Error type returned by parsing and themed render helpers.

    MermaidError::output

    source
    fn MermaidError::output(self : MermaidError, logger : &Logger) -> Unit

    MermaidError::to_repr

    source

    MermaidError::to_string

    source
    fn MermaidError::to_string(self : MermaidError) -> String

    AsciiRenderOptions

    source
    pub(all) struct AsciiRenderOptions {
      use_ascii : Bool
      padding_x : Int
      padding_y : Int
      box_border_padding : Int
    }

    ASCII/Unicode render configuration for terminal output.

    AsciiRenderOptions::default

    source

    Default ASCII render options (Unicode mode, standard spacing).

    DiagramColors

    source
    pub(all) struct DiagramColors {
      bg : String
      fg : String
      line : String?
      accent : String?
      muted : String?
      surface : String?
      border : String?
    }

    SVG theme colors. bg and fg are required; the rest are optional enrichments.

    DiagramColors::default

    source
    fn DiagramColors::default() -> DiagramColors

    Default diagram colors used when options omit bg/fg.

    DiagramKind

    source
    pub(all) enum DiagramKind {
      Flowchart
      State
      Sequence
      Class
      Er
    }

    High-level Mermaid diagram category from the parsed header.

    Direction

    source
    pub(all) enum Direction {
      TD
      TB
      LR
      BT
      RL
    }

    Flow/state layout direction.

    EdgeStyle

    source
    pub(all) enum EdgeStyle {
      Solid
      Dotted
      Thick
    } derive(Eq)

    Edge stroke style.

    EdgeStyle::equal

    source
    fn EdgeStyle::equal(EdgeStyle, EdgeStyle) -> Bool

    EdgeStyle::not_equal

    source
    fn EdgeStyle::not_equal(x : EdgeStyle, y : EdgeStyle) -> Bool

    LayoutEngine

    source
    pub(all) enum LayoutEngine {
      Legacy
      DagreParity
      Elk
      ElkLayered
    }

    Layout engine selection for graph positioning.

    MermaidEdge

    source
    pub(all) struct MermaidEdge {
      source : String
      target : String
      label : String?
      style : EdgeStyle
      has_arrow_start : Bool
      has_arrow_end : Bool
      relation_operator : String?
    }

    Parsed logical edge before layout.

    MermaidGraph

    source
    pub(all) struct MermaidGraph {
      diagram_kind : DiagramKind
      direction : Direction
      nodes : Map[String, MermaidNode]
      node_definition_order : Array[String]
      edges : Array[MermaidEdge]
      subgraphs : Array[MermaidSubgraph]
      class_defs : Map[String, Map[String, String]]
      class_assignments : Map[String, String]
      node_styles : Map[String, Map[String, String]]
      sequence_actor_order : Array[String]
      sequence_actor_kinds : Map[String, SequenceParticipantKind]
      sequence_blocks : Array[SequenceBlock]
      sequence_notes : Array[SequenceNote]
      sequence_activation_commands : Array[SequenceActivationCommand]
    }

    Normalized parsed Mermaid model consumed by layout/render stages.

    MermaidNode

    source
    pub(all) struct MermaidNode {
      id : String
      label : String
      shape : NodeShape
    }

    Parsed logical node before layout.

    MermaidSubgraph

    source
    pub(all) struct MermaidSubgraph {
      id : String
      label : String
      node_ids : Array[String]
      children : Array[MermaidSubgraph]
      direction : Direction?
    }

    Parsed subgraph/composite block with optional direction override.

    NodeShape

    source
    pub(all) enum NodeShape {
      Rectangle
      Rounded
      Diamond
      Stadium
      Circle
      Subroutine
      DoubleCircle
      Hexagon
      Cylinder
      Asymmetric
      Trapezoid
      TrapezoidAlt
      StateStart
      StateEnd
      ClassEntity
      ErEntity
      SequenceParticipant
    } derive(Eq)

    Normalized node shapes used by parser and renderers.

    NodeShape::equal

    source
    fn NodeShape::equal(NodeShape, NodeShape) -> Bool

    NodeShape::not_equal

    source
    fn NodeShape::not_equal(x : NodeShape, y : NodeShape) -> Bool

    Point

    source
    pub(all) struct Point {
      x : Int
      y : Int
    }

    2D point used by positioned edge routes.

    PositionedEdge

    source
    pub(all) struct PositionedEdge {
      source : String
      target : String
      label : String?
      style : EdgeStyle
      has_arrow_start : Bool
      has_arrow_end : Bool
      relation_operator : String?
      points : Array[Point]
      label_position : Point?
    }

    Edge after layout with routed polyline points and optional label anchor.

    PositionedGraph

    source
    pub(all) struct PositionedGraph {
      width : Int
      height : Int
      nodes : Array[PositionedNode]
      edges : Array[PositionedEdge]
      groups : Array[PositionedGroup]
      sequence_lifelines : Array[PositionedSequenceLifeline]
      sequence_activations : Array[PositionedSequenceActivation]
      sequence_blocks : Array[PositionedSequenceBlock]
      sequence_notes : Array[PositionedSequenceNote]
    }

    Full positioned scene graph consumed by SVG and ASCII renderers.

    PositionedGroup

    source
    pub(all) struct PositionedGroup {
      id : String
      label : String
      x : Int
      y : Int
      width : Int
      height : Int
      children : Array[PositionedGroup]
    }

    Positioned subgraph/composite group bounds and nested children.

    PositionedNode

    source
    pub(all) struct PositionedNode {
      id : String
      label : String
      shape : NodeShape
      x : Int
      y : Int
      width : Int
      height : Int
      inline_style : Map[String, String]?
    }

    Node after layout with absolute coordinates and computed size.

    PositionedSequenceActivation

    source
    pub(all) struct PositionedSequenceActivation {
      actor_id : String
      x : Int
      top_y : Int
      bottom_y : Int
      width : Int
    }

    Sequence activation bar geometry.

    PositionedSequenceBlock

    source
    pub(all) struct PositionedSequenceBlock {
      block_type : SequenceBlockType
      label : String
      x : Int
      y : Int
      width : Int
      height : Int
      dividers : Array[PositionedSequenceBlockDivider]
    }

    Positioned sequence block container and divider rows.

    PositionedSequenceBlockDivider

    source
    pub(all) struct PositionedSequenceBlockDivider {
      y : Int
      label : String
    }

    Positioned divider label row inside a sequence block.

    PositionedSequenceLifeline

    source
    pub(all) struct PositionedSequenceLifeline {
      actor_id : String
      x : Int
      top_y : Int
      bottom_y : Int
    }

    Sequence lifeline geometry for SVG/ASCII sequence renderers.

    PositionedSequenceNote

    source
    pub(all) struct PositionedSequenceNote {
      text : String
      x : Int
      y : Int
      width : Int
      height : Int
    }

    Positioned sequence note box.

    RenderOptions

    source
    pub(all) struct RenderOptions {
      bg : String?
      fg : String?
      line : String?
      accent : String?
      muted : String?
      surface : String?
      border : String?
      font : String?
      padding : Int?
      node_spacing : Int?
      layer_spacing : Int?
      transparent : Bool?
      layout_engine : LayoutEngine?
    }

    SVG render configuration (theme colors, font, spacing, transparency).

    RenderOptions::default

    source
    fn RenderOptions::default() -> RenderOptions

    Default SVG render options (all optional fields unset).

    SequenceActivationCommand

    source
    pub(all) struct SequenceActivationCommand {
      actor_id : String
      activate : Bool
      after_index : Int
    }

    Sequence activation/deactivation command positioned relative to messages.

    SequenceBlock

    source
    pub(all) struct SequenceBlock {
      block_type : SequenceBlockType
      label : String
      start_index : Int
      end_index : Int
      dividers : Array[SequenceBlockDivider]
    }

    Parsed sequence control block (alt, opt, loop, ...).

    SequenceBlockDivider

    source
    pub(all) struct SequenceBlockDivider {
      index : Int
      label : String
    }

    Divider row metadata (else / and) inside a sequence block.

    SequenceBlockType

    source
    pub(all) enum SequenceBlockType {
      Loop
      Alt
      Opt
      Par
      Critical
      Break
      Rect
    } derive(Eq)

    Sequence block keyword kind (alt, loop, par, etc.).

    SequenceBlockType::equal

    source

    SequenceBlockType::not_equal

    source
    fn SequenceBlockType::not_equal(x : SequenceBlockType, y : SequenceBlockType) -> Bool

    SequenceNote

    source
    pub(all) struct SequenceNote {
      actor_ids : Array[String]
      text : String
      position : SequenceNotePosition
      after_index : Int
    }

    Sequence note attached after a message index.

    SequenceNotePosition

    source
    pub(all) enum SequenceNotePosition {
      Left
      Right
      Over
    }

    Placement mode for sequence notes.

    SequenceParticipantKind

    source
    pub(all) enum SequenceParticipantKind {
      Participant
      Actor
    }

    Sequence participant visual kind.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io