` tags if there is a blank line above and below it. + +``` +
not wrapped
+
+not wrapped either
+
+
+
+
+this paragraph gets wrapped in a `
+```
+
+## Static Statements
Define module-level functions and variables.
diff --git a/lib/jsr.json b/lib/jsr.json
index f44015e16f4642edf95d1842c5d4be3f01aded83..ecc81a8e31589d4dfda41e468bbdf9e7c0a97548 100644
--- a/lib/jsr.json
+++ b/lib/jsr.json
@@ -1,4 +1,13 @@
{
"name": "@clo/markodown",
- "version": "1.0.0-rc.1"
+ "version": "1.0.0-rc.1",
+ "license": "MIT",
+ "exports": {
+ ".": "./mod.ts",
+ "./esbuild.ts": "./esbuild.ts",
+ "./rollup.ts": "./rollup.ts"
+ },
+ "imports": {
+ "@marko/compiler": "@marko/compiler@^5.39.55"
+ }
}
diff --git a/lib/mod.ts b/lib/mod.ts
index 2fec80a1b51f046ab61a3848e8242278968f8c8f..70f3d38761c23a96c3928e132b2df4488e0f7c81 100644
--- a/lib/mod.ts
+++ b/lib/mod.ts
@@ -5,6 +5,20 @@ wasm.initSync({ module: bytes });
type Transformed = Success | Failure;
+/** Configuration for replacing built-in elements with custom components. */
+export interface ComponentImports {
+ /** Replace heading elements (h1-h6) with a custom component. Receives `level=1-6`. */
+ heading?: string;
+ /** Replace code blocks with a custom component. Receives `language` and `meta`. */
+ codeBlock?: string;
+ /** Replace link elements with a custom component. */
+ link?: string;
+ /** Replace image elements with a custom component. */
+ image?: string;
+ /** Replace blockquote elements with a custom component. */
+ blockquote?: string;
+}
+
export interface TransformOptions {
source: string;
/**
@@ -16,6 +30,8 @@ export interface TransformOptions {
format?: Array<"marko" | "html">;
/** Wraps the component in another component. Enables Table of Contents generation */
layoutImport?: string;
+ /** Replace built-in elements with custom components */
+ componentImports?: ComponentImports;
}
export type OutputFormat = "marko" | "html";
@@ -69,5 +85,6 @@ export function transform(options: TransformOptions): Transformed {
options.source,
forceFormat,
options?.layoutImport,
+ options?.componentImports,
);
}
diff --git a/src/component_transforms.rs b/src/component_transforms.rs
new file mode 100644
index 0000000000000000000000000000000000000000..799638c52d978e7193e82ac442ae5b698d0171d3
--- /dev/null
+++ b/src/component_transforms.rs
@@ -0,0 +1,423 @@
+//! Component transformations for replacing built-in elements with custom components.
+//!
+//! This module walks the AST and replaces heading, code block, link, image, and
+//! blockquote elements with calls to custom components specified in ComponentImports.
+
+use markdown_it::{Node, NodeValue, Renderer};
+
+use crate::marko_ast::OpenOwned;
+use crate::plugin::tags::{MarkoBlockComplete, MarkoClose, MarkoOpen, MarkoOpenWithText};
+use crate::ComponentImports;
+
+/// Component name suffix to avoid collisions
+const SUFFIX: &str = "__markodown__";
+
+/// Heading component name
+fn heading_component() -> String {
+ format!("HeadingComponent{}", SUFFIX)
+}
+
+/// Code block component name
+fn code_block_component() -> String {
+ format!("CodeBlockComponent{}", SUFFIX)
+}
+
+/// Link component name
+fn link_component() -> String {
+ format!("LinkComponent{}", SUFFIX)
+}
+
+/// Image component name
+fn image_component() -> String {
+ format!("ImageComponent{}", SUFFIX)
+}
+
+/// Blockquote component name
+fn blockquote_component() -> String {
+ format!("BlockquoteComponent{}", SUFFIX)
+}
+
+/// Generate import statements for all configured component imports
+pub fn generate_imports(imports: &ComponentImports) -> String {
+ let mut result = String::new();
+
+ if let Some(path) = &imports.heading {
+ result.push_str(&format!(
+ "import {} from \"{}\";\n",
+ heading_component(),
+ path
+ ));
+ }
+
+ if let Some(path) = &imports.code_block {
+ result.push_str(&format!(
+ "import {} from \"{}\";\n",
+ code_block_component(),
+ path
+ ));
+ }
+
+ if let Some(path) = &imports.link {
+ result.push_str(&format!("import {} from \"{}\";\n", link_component(), path));
+ }
+
+ if let Some(path) = &imports.image {
+ result.push_str(&format!(
+ "import {} from \"{}\";\n",
+ image_component(),
+ path
+ ));
+ }
+
+ if let Some(path) = &imports.blockquote {
+ result.push_str(&format!(
+ "import {} from \"{}\";\n",
+ blockquote_component(),
+ path
+ ));
+ }
+
+ result
+}
+
+/// Transform all elements according to the component imports configuration.
+pub fn transform_components(node: &mut Node, imports: &ComponentImports) {
+ // Process children first (bottom-up traversal)
+ for child in &mut node.children {
+ transform_components(child, imports);
+ }
+
+ // Transform this node if applicable
+ if imports.heading.is_some() {
+ transform_heading(node);
+ }
+
+ if imports.code_block.is_some() {
+ transform_code_block(node);
+ }
+
+ if imports.link.is_some() {
+ transform_link(node);
+ }
+
+ if imports.image.is_some() {
+ transform_image(node);
+ }
+
+ if imports.blockquote.is_some() {
+ transform_blockquote(node);
+ }
+}
+
+/// A code block component node that renders as `` tag! + +
");
+ open.replace_tag_name("Heading");
+ assert_eq!(open.src, "");
+ assert_eq!(open.as_ref().tag_name(), "Heading");
+ }
+
+ #[test]
+ fn test_replace_tag_name_with_shorthand() {
+ let mut open = parse_open("").unwrap().to_owned();
+ assert_eq!(open.as_ref().tag_name(), "h3");
+ open.replace_tag_name("Heading");
+ assert_eq!(open.src, "");
+ assert_eq!(open.as_ref().tag_name(), "Heading");
+ // ID should still be accessible
+ assert_eq!(open.as_ref().id_attr(), Some(("foo", false)));
+ }
+
+ #[test]
+ fn test_replace_tag_name_with_attributes() {
+ let mut open = parse_open("").unwrap().to_owned();
+ open.replace_tag_name("HeadingComponent__markodown__");
+ assert_eq!(
+ open.src,
+ ""
+ );
+ }
+
+ #[test]
+ fn test_insert_attr_simple() {
+ let mut open = OpenOwned::from_tag_name("Heading");
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ }
+
+ #[test]
+ fn test_insert_attr_with_shorthand() {
+ let mut open = parse_open("").unwrap().to_owned();
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ // ID should still be accessible
+ assert_eq!(open.as_ref().id_attr(), Some(("foo", false)));
+ }
+
+ #[test]
+ fn test_insert_attr_with_existing_attrs() {
+ let mut open = parse_open("")
+ .unwrap()
+ .to_owned();
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ }
+
+ #[test]
+ fn test_combined_replace_and_insert() {
+ let mut open = parse_open("")
+ .unwrap()
+ .to_owned();
+ open.replace_tag_name("HeadingComponent__markodown__");
+ open.insert_attr("level=3");
+ assert_eq!(
+ open.src,
+ ""
+ );
+ assert_eq!(open.as_ref().id_attr(), Some(("about", false)));
+ }
+}
diff --git a/src/outline.rs b/src/outline.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe5bd14affc82eb5671489669157c09c91107380
--- /dev/null
+++ b/src/outline.rs
@@ -0,0 +1,574 @@
+//! Outline extraction for headings.
+//!
+//! Walks the AST to collect heading information, inject IDs, and extract content
+//! into hoisted `,
+ /// The `,
+}
+
+/// A node that renders as a component reference: `) -> String {
+ let mut slug: String = text
+ .chars()
+ .map(|c| match c {
+ 'a'..='z' | '0'..='9' => c,
+ 'A'..='Z' => c.to_ascii_lowercase(),
+ ' ' | '\t' => '-',
+ _ if c.is_alphanumeric() => c.to_ascii_lowercase(),
+ _ => '-',
+ })
+ .collect();
+
+ // Collapse multiple dashes and trim
+ slug = slug
+ .split('-')
+ .filter(|s| !s.is_empty())
+ .collect::>()
+ .join("-");
+
+ if slug.is_empty() {
+ slug = "heading".to_string();
+ }
+
+ // Ensure uniqueness
+ if !existing_ids.contains(&slug) {
+ existing_ids.insert(slug.clone());
+ return slug;
+ }
+
+ let mut counter = 1;
+ loop {
+ let new_slug = format!("{}-{}", slug, counter);
+ if !existing_ids.contains(&new_slug) {
+ existing_ids.insert(new_slug.clone());
+ return new_slug;
+ }
+ counter += 1;
+ }
+}
+
+/// Collect headings from the AST, inject IDs, and extract content into defines.
+pub fn collect_and_extract(node: &mut Node, preamble_offset: u32) -> OutlineResult {
+ let mut headings = Vec::new();
+ let mut errors = Vec::new();
+ let mut defines = String::new();
+ let mut existing_ids = HashSet::new();
+ let mut heading_counter = 0usize;
+
+ collect_recursive(
+ node,
+ &mut headings,
+ &mut errors,
+ &mut defines,
+ &mut existing_ids,
+ &mut heading_counter,
+ preamble_offset,
+ );
+
+ OutlineResult {
+ headings,
+ defines,
+ errors,
+ }
+}
+
+/// Render a node's children to a string.
+fn render_children(node: &Node) -> String {
+ // Create a temporary wrapper to render just the children
+ let mut output = String::new();
+ for child in &node.children {
+ output.push_str(&child.render());
+ }
+ output
+}
+
+fn collect_recursive(
+ node: &mut Node,
+ headings: &mut Vec,
+ errors: &mut Vec,
+ defines: &mut String,
+ existing_ids: &mut HashSet,
+ heading_counter: &mut usize,
+ preamble_offset: u32,
+) {
+ let (node_start, _) = node.srcmap.map(|s| s.get_byte_offsets()).unwrap_or((0, 0));
+ let node_start = node_start as u32 + preamble_offset;
+
+ // Check for markdown-it ATX headings (# ## ### etc)
+ if let Some(heading) = node.cast::() {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ // Generate component name
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ // Render children before replacing them
+ let rendered_content = render_children(node);
+
+ // Create the define block
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ // Replace children with reference node
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ // Inject id attribute
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for setext headings (underline style)
+ else if let Some(heading) =
+ node.cast::()
+ {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for setext headings (underline style)
+ else if let Some(heading) =
+ node.cast::()
+ {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for MarkoOpen tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let open = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = open.open.id;
+ let tag_span = open.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(open.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let open = node.cast_mut::().unwrap();
+ open.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+ // Check for MarkoOpenWithText tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let open = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = open.open.id;
+ let tag_span = open.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(open.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let open = node.cast_mut::().unwrap();
+ open.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+ // Check for MarkoBlockComplete tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let block = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(block.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = block.open.id;
+ let tag_span = block.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(block.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let block = node.cast_mut::().unwrap();
+ block.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+
+ // Recurse into children
+ for child in &mut node.children {
+ collect_recursive(
+ child,
+ headings,
+ errors,
+ defines,
+ existing_ids,
+ heading_counter,
+ preamble_offset,
+ );
+ }
+}
+
+fn parse_heading_level(tag_name: &str) -> Option {
+ match tag_name {
+ "h1" => Some(1),
+ "h2" => Some(2),
+ "h3" => Some(3),
+ "h4" => Some(4),
+ "h5" => Some(5),
+ "h6" => Some(6),
+ _ => None,
+ }
+}
+
+/// Format the outline array for Marko output.
+/// Uses JS object syntax with unquoted component references.
+pub fn format_outline_array(headings: &[HeadingEntry]) -> String {
+ if headings.is_empty() {
+ return "[]".to_string();
+ }
+
+ let entries: Vec = headings
+ .iter()
+ .map(|h| {
+ format!(
+ "{{ level: {}, id: '{}', content: {} }}",
+ h.level, h.id, h.component_name
+ )
+ })
+ .collect();
+
+ format!("[\n {},\n]", entries.join(",\n "))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_generate_slug_basic() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("Hello World", &mut existing), "hello-world");
+ assert!(existing.contains("hello-world"));
+ }
+
+ #[test]
+ fn test_generate_slug_special_chars() {
+ let mut existing = HashSet::new();
+ assert_eq!(
+ generate_slug("What's up? (2024)", &mut existing),
+ "what-s-up-2024"
+ );
+ }
+
+ #[test]
+ fn test_generate_slug_duplicates() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("test", &mut existing), "test");
+ assert_eq!(generate_slug("test", &mut existing), "test-1");
+ assert_eq!(generate_slug("test", &mut existing), "test-2");
+ }
+
+ #[test]
+ fn test_generate_slug_empty() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("!!!", &mut existing), "heading");
+ }
+
+ #[test]
+ fn test_format_outline_array() {
+ let headings = vec![
+ HeadingEntry {
+ level: 1,
+ id: "hello".to_string(),
+ text: "Hello".to_string(),
+ component_name: "Heading_1__markodown__".to_string(),
+ },
+ HeadingEntry {
+ level: 2,
+ id: "world".to_string(),
+ text: "World".to_string(),
+ component_name: "Heading_2__markodown__".to_string(),
+ },
+ ];
+
+ let result = format_outline_array(&headings);
+ assert!(result.contains("level: 1"));
+ assert!(result.contains("id: 'hello'"));
+ assert!(result.contains("content: Heading_1__markodown__"));
+ }
+}
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index 8dee0257d179f2e472908f4315eea094eff810b2..7494368208e4b2034fdcad1ea3326899ecff1c92 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -5,7 +5,6 @@ pub mod inline_tags;
pub mod statement;
pub mod tags;
pub mod template;
-pub mod toc;
pub use frontmatter::{extract_preamble_and_frontmatter, PreambleResult};
diff --git a/src/plugin/tags.rs b/src/plugin/tags.rs
index d9a3a97660d94876c14ce23cd7b955bcfcbbca00..8084d006892dba24977240d7ddb88fa581c5f5e3 100644
--- a/src/plugin/tags.rs
+++ b/src/plugin/tags.rs
@@ -118,15 +118,13 @@ impl NodeValue for MarkoInlineTag {
/// The content is parsed as inline markdown
#[derive(Debug)]
pub struct MarkoBlockComplete {
- pub open_tag: String,
+ pub open: marko_ast::OpenOwned,
pub close_tag: String,
- pub tag_name: String,
- pub tag_name_len: usize,
}
impl NodeValue for MarkoBlockComplete {
fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
- fmt.text_raw(&self.open_tag);
+ fmt.text_raw(&self.open.src);
fmt.contents(&node.children);
fmt.text_raw(&self.close_tag);
fmt.text_raw("\n");
@@ -235,10 +233,8 @@ impl BlockRule for Rule {
let mapping = vec![(0, text_start)];
let mut node = Node::new(MarkoBlockComplete {
- open_tag: open.src.to_string(),
+ open: open.to_owned(),
close_tag: close_tag.to_string(),
- tag_name: open.tag_name().to_string(),
- tag_name_len: open.tag_name().len(),
});
if !content.is_empty() {
diff --git a/src/plugin/toc.rs b/src/plugin/toc.rs
deleted file mode 100644
index 48445654752db889e1a1331f0df1fb3e9466897c..0000000000000000000000000000000000000000
--- a/src/plugin/toc.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-use markdown_it::Node;
-use serde::Serialize;
-
-#[derive(Debug, Clone, Serialize)]
-pub struct HeadingEntry {
- pub level: u8,
- pub id: String,
- pub text: String,
-}
-
-pub fn generate_slug(text: &str, existing_ids: &mut std::collections::HashSet) -> String {
- let mut slug = text
- .chars()
- .map(|c| match c {
- 'a'..='z' | '0'..='9' => c.to_ascii_lowercase(),
- 'A'..='Z' => c.to_ascii_lowercase(),
- ' ' | '\t' => '-',
- _ if c.is_alphanumeric() => c.to_ascii_lowercase(),
- _ => '-',
- })
- .collect::();
-
- slug = slug
- .split('-')
- .filter(|s| !s.is_empty())
- .collect::>()
- .join("-");
-
- if slug.is_empty() {
- slug = "heading".to_string();
- }
-
- if !existing_ids.contains(&slug) {
- existing_ids.insert(slug.clone());
- return slug;
- }
-
- let mut counter = 1;
- loop {
- let new_slug = format!("{}-{}", slug, counter);
- if !existing_ids.contains(&new_slug) {
- existing_ids.insert(new_slug.clone());
- return new_slug;
- }
- counter += 1;
- }
-}
-
-pub fn collect_headings(node: &Node) -> Vec {
- let mut headings = Vec::new();
- let mut existing_ids = std::collections::HashSet::new();
-
- collect_headings_recursive(node, &mut headings, &mut existing_ids);
-
- headings
-}
-
-fn collect_headings_recursive(
- node: &Node,
- headings: &mut Vec,
- existing_ids: &mut std::collections::HashSet,
-) {
- // Check for markdown-it ATX headings (# ## ### etc)
- if let Some(heading) = node.cast::() {
- let text = node.collect_text();
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry {
- level: heading.level,
- id,
- text,
- });
- }
- // Check for setext headings (underline style)
- else if let Some(heading) =
- node.cast::()
- {
- let text = node.collect_text();
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry {
- level: heading.level,
- id,
- text,
- });
- }
- // Check for MarkoOpen tags that are h1-h6
- else if let Some(open) = node.cast::() {
- if let Some(level) = parse_heading_level(&open.open.as_ref().tag_name()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = if let Some(existing) = open.open.src.strip_prefix('<').and_then(|s| {
- s.find("id=\"")
- .map(|pos| {
- let start = pos + 4;
- s[start..].split('"').next().map(|s| s.to_string())
- })
- .flatten()
- }) {
- if !existing_ids.contains(&existing) {
- existing_ids.insert(existing.clone());
- existing
- } else {
- generate_slug(&text, existing_ids)
- }
- } else {
- generate_slug(&text, existing_ids)
- };
- headings.push(HeadingEntry { level, id, text });
- }
- }
- // Check for MarkoOpenWithText tags that are h1-h6
- else if let Some(open) = node.cast::() {
- if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry { level, id, text });
- }
- }
- // Check for MarkoBlockComplete tags that are h1-h6
- else if let Some(block) = node.cast::() {
- if let Some(level) = parse_heading_level(block.tag_name.as_str()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry { level, id, text });
- }
- }
-
- for child in &node.children {
- collect_headings_recursive(child, headings, existing_ids);
- }
-}
-
-fn parse_heading_level(tag_name: &str) -> Option {
- match tag_name {
- "h1" => Some(1),
- "h2" => Some(2),
- "h3" => Some(3),
- "h4" => Some(4),
- "h5" => Some(5),
- "h6" => Some(6),
- _ => None,
- }
-}
-
-pub fn inject_heading_ids(text: &str, headings: &[HeadingEntry]) -> String {
- if headings.is_empty() {
- return text.to_string();
- }
-
- let mut result = String::new();
- let mut pos = 0;
- let mut heading_idx = 0;
- let bytes = text.as_bytes();
-
- while pos < bytes.len() {
- if bytes[pos] == b'<' {
- let remaining = &bytes[pos..];
- if remaining.starts_with(b" 1u8,
- b'2' => 2,
- b'3' => 3,
- b'4' => 4,
- b'5' => 5,
- b'6' => 6,
- _ => {
- result.push('<');
- pos += 1;
- continue;
- }
- };
-
- let close_pos = match remaining[2..].iter().position(|&b| b == b'>') {
- Some(p) => p + 2,
- None => {
- result.push('<');
- pos += 1;
- continue;
- }
- };
-
- let tag_end = pos + close_pos;
- let tag = std::str::from_utf8(&bytes[pos..=tag_end]).unwrap_or("");
-
- if tag.ends_with("/>") || tag.contains(" ") {
- result.push_str(tag);
- pos = tag_end + 1;
- continue;
- }
-
- if heading_idx < headings.len() && headings[heading_idx].level == level {
- let id = &headings[heading_idx].id;
- result.push_str(&format!("h{level} id=\"{}\">", id));
- heading_idx += 1;
- pos = tag_end + 1;
- continue;
- } else {
- result.push_str(tag);
- pos = tag_end + 1;
- continue;
- }
- }
- }
-
- result.push(bytes[pos] as char);
- pos += 1;
- }
-
- result
-}
diff --git a/src/wasm.rs b/src/wasm.rs
index 939ef888dad6bf95a1564df717067072fdd3fce3..66de423d8fb7f9d8db1e26b153ad0d2d1ffa241e 100644
--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -1,4 +1,4 @@
-use crate::OutputFormat;
+use crate::{ComponentImports, OutputFormat};
use oxc_diagnostics::OxcDiagnostic;
use serde::Serialize;
use wasm_bindgen::prelude::*;
@@ -100,9 +100,24 @@ pub fn transform(
src: &str,
force_format: Option,
layout_import: Option,
+ component_imports: JsValue,
self_path: Option,
) -> JsValue {
- match crate::transform(src, force_format, layout_import, self_path) {
+ // Deserialize component_imports from JsValue (can be undefined/null)
+ let component_imports: Option =
+ if component_imports.is_undefined() || component_imports.is_null() {
+ None
+ } else {
+ serde_wasm_bindgen::from_value(component_imports).ok()
+ };
+
+ match crate::transform(
+ src,
+ force_format,
+ layout_import,
+ component_imports,
+ self_path,
+ ) {
Ok(output) => serde_wasm_bindgen::to_value(&TransformResult {
text: Some(output.text),
success: true,
diff --git a/tests/fixtures.rs b/tests/fixtures.rs
index 50fcc6a432c55795f90ce0237786948f30f60849..b832e79f1bb94c3cd5b095934181ca984493719e 100644
--- a/tests/fixtures.rs
+++ b/tests/fixtures.rs
@@ -1,4 +1,4 @@
-use markodown::{transform, OutputFormat};
+use markodown::{transform, ComponentImports, OutputFormat};
use std::fs;
use std::path::Path;
@@ -7,6 +7,16 @@ use std::path::Path;
/// Each fixture has an `.mdo` input and either an `.html` expected output
/// (static mode) or a `.marko` expected output (marko mode), or both.
fn run_fixture(name: &str) {
+ run_fixture_with_options(name, None, None, None);
+}
+
+/// Run fixture with optional layout, component_imports, and self_path arguments.
+fn run_fixture_with_options(
+ name: &str,
+ layout: Option<&str>,
+ component_imports: Option,
+ self_path: Option<&str>,
+) {
let base = Path::new("tests/fixtures").join(name);
let input_path = base.with_extension("mdo");
let html_path = base.with_extension("html");
@@ -20,7 +30,14 @@ fn run_fixture(name: &str) {
let expected = fs::read_to_string(&html_path)
.unwrap_or_else(|e| panic!("failed to read {}: {e}", html_path.display()));
- let output = transform(&source, Some(OutputFormat::Html), None, None).unwrap();
+ let output = transform(
+ &source,
+ Some(OutputFormat::Html),
+ layout.map(|s| s.to_string()),
+ component_imports.clone(),
+ self_path.map(|s| s.to_string()),
+ )
+ .unwrap();
assert_eq!(
output.format,
@@ -40,7 +57,14 @@ fn run_fixture(name: &str) {
let expected = fs::read_to_string(&marko_path)
.unwrap_or_else(|e| panic!("failed to read {}: {e}", marko_path.display()));
- let output = transform(&source, Some(OutputFormat::Marko), None, None).unwrap();
+ let output = transform(
+ &source,
+ Some(OutputFormat::Marko),
+ layout.map(|s| s.to_string()),
+ component_imports.clone(),
+ self_path.map(|s| s.to_string()),
+ )
+ .unwrap();
assert_eq!(
output.format,
@@ -172,3 +196,21 @@ fn fixture_21_frontmatter_blank_lines() {
fn fixture_22_frontmatter_mixed_preamble() {
run_fixture("22-frontmatter-mixed-preamble");
}
+
+#[test]
+fn fixture_23_outline_extracting() {
+ run_fixture_with_options("23-outline-extracting", Some("./layout.marko"), None, None);
+}
+
+#[test]
+fn fixture_24_heading_import() {
+ run_fixture_with_options(
+ "24-heading-import",
+ None,
+ Some(ComponentImports {
+ heading: Some("./heading.marko".to_string()),
+ ..Default::default()
+ }),
+ None,
+ );
+}
diff --git a/tests/fixtures/23-outline-extracting.marko b/tests/fixtures/23-outline-extracting.marko
index 4defab92d3ca6daf4a0423bb6a06d4d07766727c..2736aa794e967adf1a9268c42d231ecfa4670c2d 100644
--- a/tests/fixtures/23-outline-extracting.marko
+++ b/tests/fixtures/23-outline-extracting.marko
@@ -1,27 +1,28 @@
-
+import Layout__markodown__ from "./layout.marko";
+
good morning
-
+
good night
-
+
snow time
+
rain time
-
-
-content 1
-
-content 2
-
-content 3
-
-content 4
+
+
+Hello World
+About Us
+Details here
+Simple heading
diff --git a/tests/fixtures/24-heading-import.mdo b/tests/fixtures/24-heading-import.mdo
new file mode 100644
index 0000000000000000000000000000000000000000..5173323abdc4cabc79b49a50c18839a8e384f4c5
--- /dev/null
+++ b/tests/fixtures/24-heading-import.mdo
@@ -0,0 +1,7 @@
+# Hello World
+
+About Us
+
+### Details here
+
+Simple heading
").unwrap().to_owned();
+ open.replace_tag_name("HeadingComponent__markodown__");
+ assert_eq!(
+ open.src,
+ ""
+ );
+ }
+
+ #[test]
+ fn test_insert_attr_simple() {
+ let mut open = OpenOwned::from_tag_name("Heading");
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ }
+
+ #[test]
+ fn test_insert_attr_with_shorthand() {
+ let mut open = parse_open("").unwrap().to_owned();
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ // ID should still be accessible
+ assert_eq!(open.as_ref().id_attr(), Some(("foo", false)));
+ }
+
+ #[test]
+ fn test_insert_attr_with_existing_attrs() {
+ let mut open = parse_open("")
+ .unwrap()
+ .to_owned();
+ open.insert_attr("level=3");
+ assert_eq!(open.src, "");
+ }
+
+ #[test]
+ fn test_combined_replace_and_insert() {
+ let mut open = parse_open("")
+ .unwrap()
+ .to_owned();
+ open.replace_tag_name("HeadingComponent__markodown__");
+ open.insert_attr("level=3");
+ assert_eq!(
+ open.src,
+ ""
+ );
+ assert_eq!(open.as_ref().id_attr(), Some(("about", false)));
+ }
+}
diff --git a/src/outline.rs b/src/outline.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe5bd14affc82eb5671489669157c09c91107380
--- /dev/null
+++ b/src/outline.rs
@@ -0,0 +1,574 @@
+//! Outline extraction for headings.
+//!
+//! Walks the AST to collect heading information, inject IDs, and extract content
+//! into hoisted `,
+ /// The `,
+}
+
+/// A node that renders as a component reference: `) -> String {
+ let mut slug: String = text
+ .chars()
+ .map(|c| match c {
+ 'a'..='z' | '0'..='9' => c,
+ 'A'..='Z' => c.to_ascii_lowercase(),
+ ' ' | '\t' => '-',
+ _ if c.is_alphanumeric() => c.to_ascii_lowercase(),
+ _ => '-',
+ })
+ .collect();
+
+ // Collapse multiple dashes and trim
+ slug = slug
+ .split('-')
+ .filter(|s| !s.is_empty())
+ .collect::>()
+ .join("-");
+
+ if slug.is_empty() {
+ slug = "heading".to_string();
+ }
+
+ // Ensure uniqueness
+ if !existing_ids.contains(&slug) {
+ existing_ids.insert(slug.clone());
+ return slug;
+ }
+
+ let mut counter = 1;
+ loop {
+ let new_slug = format!("{}-{}", slug, counter);
+ if !existing_ids.contains(&new_slug) {
+ existing_ids.insert(new_slug.clone());
+ return new_slug;
+ }
+ counter += 1;
+ }
+}
+
+/// Collect headings from the AST, inject IDs, and extract content into defines.
+pub fn collect_and_extract(node: &mut Node, preamble_offset: u32) -> OutlineResult {
+ let mut headings = Vec::new();
+ let mut errors = Vec::new();
+ let mut defines = String::new();
+ let mut existing_ids = HashSet::new();
+ let mut heading_counter = 0usize;
+
+ collect_recursive(
+ node,
+ &mut headings,
+ &mut errors,
+ &mut defines,
+ &mut existing_ids,
+ &mut heading_counter,
+ preamble_offset,
+ );
+
+ OutlineResult {
+ headings,
+ defines,
+ errors,
+ }
+}
+
+/// Render a node's children to a string.
+fn render_children(node: &Node) -> String {
+ // Create a temporary wrapper to render just the children
+ let mut output = String::new();
+ for child in &node.children {
+ output.push_str(&child.render());
+ }
+ output
+}
+
+fn collect_recursive(
+ node: &mut Node,
+ headings: &mut Vec,
+ errors: &mut Vec,
+ defines: &mut String,
+ existing_ids: &mut HashSet,
+ heading_counter: &mut usize,
+ preamble_offset: u32,
+) {
+ let (node_start, _) = node.srcmap.map(|s| s.get_byte_offsets()).unwrap_or((0, 0));
+ let node_start = node_start as u32 + preamble_offset;
+
+ // Check for markdown-it ATX headings (# ## ### etc)
+ if let Some(heading) = node.cast::() {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ // Generate component name
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ // Render children before replacing them
+ let rendered_content = render_children(node);
+
+ // Create the define block
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ // Replace children with reference node
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ // Inject id attribute
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for setext headings (underline style)
+ else if let Some(heading) =
+ node.cast::()
+ {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for setext headings (underline style)
+ else if let Some(heading) =
+ node.cast::()
+ {
+ let level = heading.level;
+ let text = node.collect_text();
+ let id = generate_slug(&text, existing_ids);
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ node.attrs.push(("id", id.clone()));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ // Check for MarkoOpen tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let open = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = open.open.id;
+ let tag_span = open.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(open.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let open = node.cast_mut::().unwrap();
+ open.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+ // Check for MarkoOpenWithText tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let open = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = open.open.id;
+ let tag_span = open.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(open.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let open = node.cast_mut::().unwrap();
+ open.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+ // Check for MarkoBlockComplete tags that are h1-h6
+ else if node.cast::().is_some() {
+ let heading_info = {
+ let block = node.cast::().unwrap();
+ if let Some(level) = parse_heading_level(block.open.as_ref().tag_name()) {
+ let text = node
+ .children
+ .iter()
+ .map(|c| c.collect_text())
+ .collect::>()
+ .join("");
+ let id_info = block.open.id;
+ let tag_span = block.open.as_ref().tag_name_span();
+ let existing_id = match id_info {
+ AttributeValue::Static { span, .. } => {
+ Some(block.open.src[span.start as usize..span.end as usize].to_string())
+ }
+ _ => None,
+ };
+ Some((level, text, id_info, tag_span, existing_id))
+ } else {
+ None
+ }
+ };
+
+ if let Some((level, text, id_info, tag_span, existing_id)) = heading_info {
+ let id = match id_info {
+ AttributeValue::Static { .. } => {
+ let id_str = existing_id.unwrap();
+ if !existing_ids.contains(&id_str) {
+ existing_ids.insert(id_str.clone());
+ id_str
+ } else {
+ generate_slug(&text, existing_ids)
+ }
+ }
+ AttributeValue::Dynamic => {
+ errors.push(
+ OxcDiagnostic::error(
+ "Dynamic id attribute not supported when outline is enabled",
+ )
+ .with_label(Span::new(
+ node_start + tag_span.start,
+ node_start + tag_span.end,
+ )),
+ );
+ generate_slug(&text, existing_ids)
+ }
+ AttributeValue::None => {
+ let id = generate_slug(&text, existing_ids);
+ let block = node.cast_mut::().unwrap();
+ block.open.insert_id_attr(&id);
+ id
+ }
+ };
+
+ *heading_counter += 1;
+ let component_name = format!("Heading_{}__markodown__", heading_counter);
+
+ let rendered_content = render_children(node);
+
+ let trimmed_content = rendered_content.trim();
+ defines.push_str(&format!(
+ "\n{trimmed_content}\n\n"
+ ));
+
+ node.children.clear();
+ node.children.push(Node::new(HeadingContentRef {
+ component_name: component_name.clone(),
+ }));
+
+ headings.push(HeadingEntry {
+ level,
+ id,
+ text,
+ component_name,
+ });
+ }
+ }
+
+ // Recurse into children
+ for child in &mut node.children {
+ collect_recursive(
+ child,
+ headings,
+ errors,
+ defines,
+ existing_ids,
+ heading_counter,
+ preamble_offset,
+ );
+ }
+}
+
+fn parse_heading_level(tag_name: &str) -> Option {
+ match tag_name {
+ "h1" => Some(1),
+ "h2" => Some(2),
+ "h3" => Some(3),
+ "h4" => Some(4),
+ "h5" => Some(5),
+ "h6" => Some(6),
+ _ => None,
+ }
+}
+
+/// Format the outline array for Marko output.
+/// Uses JS object syntax with unquoted component references.
+pub fn format_outline_array(headings: &[HeadingEntry]) -> String {
+ if headings.is_empty() {
+ return "[]".to_string();
+ }
+
+ let entries: Vec = headings
+ .iter()
+ .map(|h| {
+ format!(
+ "{{ level: {}, id: '{}', content: {} }}",
+ h.level, h.id, h.component_name
+ )
+ })
+ .collect();
+
+ format!("[\n {},\n]", entries.join(",\n "))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_generate_slug_basic() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("Hello World", &mut existing), "hello-world");
+ assert!(existing.contains("hello-world"));
+ }
+
+ #[test]
+ fn test_generate_slug_special_chars() {
+ let mut existing = HashSet::new();
+ assert_eq!(
+ generate_slug("What's up? (2024)", &mut existing),
+ "what-s-up-2024"
+ );
+ }
+
+ #[test]
+ fn test_generate_slug_duplicates() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("test", &mut existing), "test");
+ assert_eq!(generate_slug("test", &mut existing), "test-1");
+ assert_eq!(generate_slug("test", &mut existing), "test-2");
+ }
+
+ #[test]
+ fn test_generate_slug_empty() {
+ let mut existing = HashSet::new();
+ assert_eq!(generate_slug("!!!", &mut existing), "heading");
+ }
+
+ #[test]
+ fn test_format_outline_array() {
+ let headings = vec![
+ HeadingEntry {
+ level: 1,
+ id: "hello".to_string(),
+ text: "Hello".to_string(),
+ component_name: "Heading_1__markodown__".to_string(),
+ },
+ HeadingEntry {
+ level: 2,
+ id: "world".to_string(),
+ text: "World".to_string(),
+ component_name: "Heading_2__markodown__".to_string(),
+ },
+ ];
+
+ let result = format_outline_array(&headings);
+ assert!(result.contains("level: 1"));
+ assert!(result.contains("id: 'hello'"));
+ assert!(result.contains("content: Heading_1__markodown__"));
+ }
+}
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index 8dee0257d179f2e472908f4315eea094eff810b2..7494368208e4b2034fdcad1ea3326899ecff1c92 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -5,7 +5,6 @@ pub mod inline_tags;
pub mod statement;
pub mod tags;
pub mod template;
-pub mod toc;
pub use frontmatter::{extract_preamble_and_frontmatter, PreambleResult};
diff --git a/src/plugin/tags.rs b/src/plugin/tags.rs
index d9a3a97660d94876c14ce23cd7b955bcfcbbca00..8084d006892dba24977240d7ddb88fa581c5f5e3 100644
--- a/src/plugin/tags.rs
+++ b/src/plugin/tags.rs
@@ -118,15 +118,13 @@ impl NodeValue for MarkoInlineTag {
/// The content is parsed as inline markdown
#[derive(Debug)]
pub struct MarkoBlockComplete {
- pub open_tag: String,
+ pub open: marko_ast::OpenOwned,
pub close_tag: String,
- pub tag_name: String,
- pub tag_name_len: usize,
}
impl NodeValue for MarkoBlockComplete {
fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
- fmt.text_raw(&self.open_tag);
+ fmt.text_raw(&self.open.src);
fmt.contents(&node.children);
fmt.text_raw(&self.close_tag);
fmt.text_raw("\n");
@@ -235,10 +233,8 @@ impl BlockRule for Rule {
let mapping = vec![(0, text_start)];
let mut node = Node::new(MarkoBlockComplete {
- open_tag: open.src.to_string(),
+ open: open.to_owned(),
close_tag: close_tag.to_string(),
- tag_name: open.tag_name().to_string(),
- tag_name_len: open.tag_name().len(),
});
if !content.is_empty() {
diff --git a/src/plugin/toc.rs b/src/plugin/toc.rs
deleted file mode 100644
index 48445654752db889e1a1331f0df1fb3e9466897c..0000000000000000000000000000000000000000
--- a/src/plugin/toc.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-use markdown_it::Node;
-use serde::Serialize;
-
-#[derive(Debug, Clone, Serialize)]
-pub struct HeadingEntry {
- pub level: u8,
- pub id: String,
- pub text: String,
-}
-
-pub fn generate_slug(text: &str, existing_ids: &mut std::collections::HashSet) -> String {
- let mut slug = text
- .chars()
- .map(|c| match c {
- 'a'..='z' | '0'..='9' => c.to_ascii_lowercase(),
- 'A'..='Z' => c.to_ascii_lowercase(),
- ' ' | '\t' => '-',
- _ if c.is_alphanumeric() => c.to_ascii_lowercase(),
- _ => '-',
- })
- .collect::();
-
- slug = slug
- .split('-')
- .filter(|s| !s.is_empty())
- .collect::>()
- .join("-");
-
- if slug.is_empty() {
- slug = "heading".to_string();
- }
-
- if !existing_ids.contains(&slug) {
- existing_ids.insert(slug.clone());
- return slug;
- }
-
- let mut counter = 1;
- loop {
- let new_slug = format!("{}-{}", slug, counter);
- if !existing_ids.contains(&new_slug) {
- existing_ids.insert(new_slug.clone());
- return new_slug;
- }
- counter += 1;
- }
-}
-
-pub fn collect_headings(node: &Node) -> Vec {
- let mut headings = Vec::new();
- let mut existing_ids = std::collections::HashSet::new();
-
- collect_headings_recursive(node, &mut headings, &mut existing_ids);
-
- headings
-}
-
-fn collect_headings_recursive(
- node: &Node,
- headings: &mut Vec,
- existing_ids: &mut std::collections::HashSet,
-) {
- // Check for markdown-it ATX headings (# ## ### etc)
- if let Some(heading) = node.cast::() {
- let text = node.collect_text();
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry {
- level: heading.level,
- id,
- text,
- });
- }
- // Check for setext headings (underline style)
- else if let Some(heading) =
- node.cast::()
- {
- let text = node.collect_text();
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry {
- level: heading.level,
- id,
- text,
- });
- }
- // Check for MarkoOpen tags that are h1-h6
- else if let Some(open) = node.cast::() {
- if let Some(level) = parse_heading_level(&open.open.as_ref().tag_name()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = if let Some(existing) = open.open.src.strip_prefix('<').and_then(|s| {
- s.find("id=\"")
- .map(|pos| {
- let start = pos + 4;
- s[start..].split('"').next().map(|s| s.to_string())
- })
- .flatten()
- }) {
- if !existing_ids.contains(&existing) {
- existing_ids.insert(existing.clone());
- existing
- } else {
- generate_slug(&text, existing_ids)
- }
- } else {
- generate_slug(&text, existing_ids)
- };
- headings.push(HeadingEntry { level, id, text });
- }
- }
- // Check for MarkoOpenWithText tags that are h1-h6
- else if let Some(open) = node.cast::() {
- if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry { level, id, text });
- }
- }
- // Check for MarkoBlockComplete tags that are h1-h6
- else if let Some(block) = node.cast::() {
- if let Some(level) = parse_heading_level(block.tag_name.as_str()) {
- let text = node
- .children
- .iter()
- .map(|c| c.collect_text())
- .collect::>()
- .join("");
- let id = generate_slug(&text, existing_ids);
- headings.push(HeadingEntry { level, id, text });
- }
- }
-
- for child in &node.children {
- collect_headings_recursive(child, headings, existing_ids);
- }
-}
-
-fn parse_heading_level(tag_name: &str) -> Option {
- match tag_name {
- "h1" => Some(1),
- "h2" => Some(2),
- "h3" => Some(3),
- "h4" => Some(4),
- "h5" => Some(5),
- "h6" => Some(6),
- _ => None,
- }
-}
-
-pub fn inject_heading_ids(text: &str, headings: &[HeadingEntry]) -> String {
- if headings.is_empty() {
- return text.to_string();
- }
-
- let mut result = String::new();
- let mut pos = 0;
- let mut heading_idx = 0;
- let bytes = text.as_bytes();
-
- while pos < bytes.len() {
- if bytes[pos] == b'<' {
- let remaining = &bytes[pos..];
- if remaining.starts_with(b" 1u8,
- b'2' => 2,
- b'3' => 3,
- b'4' => 4,
- b'5' => 5,
- b'6' => 6,
- _ => {
- result.push('<');
- pos += 1;
- continue;
- }
- };
-
- let close_pos = match remaining[2..].iter().position(|&b| b == b'>') {
- Some(p) => p + 2,
- None => {
- result.push('<');
- pos += 1;
- continue;
- }
- };
-
- let tag_end = pos + close_pos;
- let tag = std::str::from_utf8(&bytes[pos..=tag_end]).unwrap_or("");
-
- if tag.ends_with("/>") || tag.contains(" ") {
- result.push_str(tag);
- pos = tag_end + 1;
- continue;
- }
-
- if heading_idx < headings.len() && headings[heading_idx].level == level {
- let id = &headings[heading_idx].id;
- result.push_str(&format!("h{level} id=\"{}\">", id));
- heading_idx += 1;
- pos = tag_end + 1;
- continue;
- } else {
- result.push_str(tag);
- pos = tag_end + 1;
- continue;
- }
- }
- }
-
- result.push(bytes[pos] as char);
- pos += 1;
- }
-
- result
-}
diff --git a/src/wasm.rs b/src/wasm.rs
index 939ef888dad6bf95a1564df717067072fdd3fce3..66de423d8fb7f9d8db1e26b153ad0d2d1ffa241e 100644
--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -1,4 +1,4 @@
-use crate::OutputFormat;
+use crate::{ComponentImports, OutputFormat};
use oxc_diagnostics::OxcDiagnostic;
use serde::Serialize;
use wasm_bindgen::prelude::*;
@@ -100,9 +100,24 @@ pub fn transform(
src: &str,
force_format: Option,
layout_import: Option,
+ component_imports: JsValue,
self_path: Option,
) -> JsValue {
- match crate::transform(src, force_format, layout_import, self_path) {
+ // Deserialize component_imports from JsValue (can be undefined/null)
+ let component_imports: Option =
+ if component_imports.is_undefined() || component_imports.is_null() {
+ None
+ } else {
+ serde_wasm_bindgen::from_value(component_imports).ok()
+ };
+
+ match crate::transform(
+ src,
+ force_format,
+ layout_import,
+ component_imports,
+ self_path,
+ ) {
Ok(output) => serde_wasm_bindgen::to_value(&TransformResult {
text: Some(output.text),
success: true,
diff --git a/tests/fixtures.rs b/tests/fixtures.rs
index 50fcc6a432c55795f90ce0237786948f30f60849..b832e79f1bb94c3cd5b095934181ca984493719e 100644
--- a/tests/fixtures.rs
+++ b/tests/fixtures.rs
@@ -1,4 +1,4 @@
-use markodown::{transform, OutputFormat};
+use markodown::{transform, ComponentImports, OutputFormat};
use std::fs;
use std::path::Path;
@@ -7,6 +7,16 @@ use std::path::Path;
/// Each fixture has an `.mdo` input and either an `.html` expected output
/// (static mode) or a `.marko` expected output (marko mode), or both.
fn run_fixture(name: &str) {
+ run_fixture_with_options(name, None, None, None);
+}
+
+/// Run fixture with optional layout, component_imports, and self_path arguments.
+fn run_fixture_with_options(
+ name: &str,
+ layout: Option<&str>,
+ component_imports: Option,
+ self_path: Option<&str>,
+) {
let base = Path::new("tests/fixtures").join(name);
let input_path = base.with_extension("mdo");
let html_path = base.with_extension("html");
@@ -20,7 +30,14 @@ fn run_fixture(name: &str) {
let expected = fs::read_to_string(&html_path)
.unwrap_or_else(|e| panic!("failed to read {}: {e}", html_path.display()));
- let output = transform(&source, Some(OutputFormat::Html), None, None).unwrap();
+ let output = transform(
+ &source,
+ Some(OutputFormat::Html),
+ layout.map(|s| s.to_string()),
+ component_imports.clone(),
+ self_path.map(|s| s.to_string()),
+ )
+ .unwrap();
assert_eq!(
output.format,
@@ -40,7 +57,14 @@ fn run_fixture(name: &str) {
let expected = fs::read_to_string(&marko_path)
.unwrap_or_else(|e| panic!("failed to read {}: {e}", marko_path.display()));
- let output = transform(&source, Some(OutputFormat::Marko), None, None).unwrap();
+ let output = transform(
+ &source,
+ Some(OutputFormat::Marko),
+ layout.map(|s| s.to_string()),
+ component_imports.clone(),
+ self_path.map(|s| s.to_string()),
+ )
+ .unwrap();
assert_eq!(
output.format,
@@ -172,3 +196,21 @@ fn fixture_21_frontmatter_blank_lines() {
fn fixture_22_frontmatter_mixed_preamble() {
run_fixture("22-frontmatter-mixed-preamble");
}
+
+#[test]
+fn fixture_23_outline_extracting() {
+ run_fixture_with_options("23-outline-extracting", Some("./layout.marko"), None, None);
+}
+
+#[test]
+fn fixture_24_heading_import() {
+ run_fixture_with_options(
+ "24-heading-import",
+ None,
+ Some(ComponentImports {
+ heading: Some("./heading.marko".to_string()),
+ ..Default::default()
+ }),
+ None,
+ );
+}
diff --git a/tests/fixtures/23-outline-extracting.marko b/tests/fixtures/23-outline-extracting.marko
index 4defab92d3ca6daf4a0423bb6a06d4d07766727c..2736aa794e967adf1a9268c42d231ecfa4670c2d 100644
--- a/tests/fixtures/23-outline-extracting.marko
+++ b/tests/fixtures/23-outline-extracting.marko
@@ -1,27 +1,28 @@
-
+import Layout__markodown__ from "./layout.marko";
+
good morning
-
+
good night
-
+
snow time
+
rain time
-
-
-content 1
-
-content 2
-
-content 1
-content 2
-content 3
-content 4
+