Struct Markdown 

pub struct Markdown {
    pub source: String,
}

Renders a subset of Markdown as styled terminal text.

Supports headings (#, ##, ###), bold, italic, inline code, fenced code blocks, and unordered lists. Designed for rendering LLM/AI chat output in the terminal.

The markdown source is a prop; style configuration lives in MarkdownState (internal state with sensible defaults).

Examples

// Constructor
Markdown::new("# Hello\n\nThis is **bold** and `code`.")

// In the element! macro
element! {
    Markdown(key: "response", source: response_text.clone())
}

Fields

source: String

The markdown source text to render.

Implementations

impl Markdown

pub fn builder() -> MarkdownBuilder<((),)>

Create a builder for building Markdown. On the builder, call .source(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of Markdown.

impl Markdown

pub fn new(source: impl Into<String>) -> Self

Create a new markdown component with the given source text.

Examples found in repository

examples/markdown_demo.rs (line 36)

fn main() -> io::Result<()> {
    let (width, _) = crossterm::terminal::size()?;
    let mut r = InlineRenderer::new(width);
    let mut stdout = io::stdout();

    // User prompt
    let _prompt = r.push(Text::styled(
        "› Explain how async/await works in Rust with an example",
        Style::default()
            .fg(Color::White)
            .add_modifier(Modifier::BOLD),
    ));
    flush(&mut r, &mut stdout)?;

    // Spacer
    let _sp = r.push(Text::unstyled(""));

    // Response container
    let response = r.push(VStack);

    // Thinking spinner
    let think = r.append_child(response, Spinner::new("Thinking..."));
    animate_spinner(&mut r, &mut stdout, think, Duration::from_millis(1200))?;
    r.swap_component(think, Spinner::new("Thinking...").done("Thought for 1.2s"));
    flush(&mut r, &mut stdout)?;
    r.freeze(think);

    // Stream the markdown response by rebuilding with progressively more content
    let md_id = r.append_child(response, Markdown::new(""));

    let response_text = r#"## Async/Await in Rust

Rust's async/await is built on the **Future** trait. When you write an `async fn`, the compiler transforms it into a state machine that implements `Future`.

### Key Concepts

- **Futures are lazy** — they don't run until polled by an *executor*
- The `await` keyword yields control back to the executor
- An executor like `tokio` manages scheduling futures onto threads

### Example

```rust
async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

#[tokio::main]
async fn main() {
    let data = fetch_data("https://example.com").await;
    println!("Got: {:?}", data);
}
```

The `.await` points are where the runtime can **suspend** this task and run others. This is *cooperative* multitasking — tasks must explicitly yield via `await`."#;

    // Stream token by token
    let tokens: Vec<&str> = response_text
        .split_inclusive(|c: char| c.is_whitespace() || c == '\n')
        .collect();
    let mut accumulated = String::new();
    for token in &tokens {
        accumulated.push_str(token);
        r.swap_component(md_id, Markdown::new(accumulated.clone()));
        flush(&mut r, &mut stdout)?;
        thread::sleep(Duration::from_millis(20));
    }

    println!();
    Ok(())
}

Trait Implementations

impl Component for Markdown

type State = MarkdownState

State type for this component. The framework wraps it in Tracked<S> for automatic dirty detection.

fn update( &self, __hooks: &mut Hooks<Self, Self::State>, __state: &Self::State, __children: Elements, ) -> Elements

Combined lifecycle and view in a single call.

impl Default for Markdown

fn default() -> Markdown

Returns the “default value” for a type.