From 7602200c070d668a3119c431fac3167cf363b6ba Mon Sep 17 00:00:00 2001 From: n1xx1 Date: Thu, 1 Dec 2022 11:41:40 +0100 Subject: [PATCH 1/4] added experimental plugins --- examples/plugins.rs | 81 +++++++++++++++++++++++++++++++++++++++++ src/configuration.rs | 22 +++++++++++ src/hast_util_to_swc.rs | 2 +- src/lib.rs | 38 +++++++++++++++---- 4 files changed, 135 insertions(+), 8 deletions(-) create mode 100644 examples/plugins.rs diff --git a/examples/plugins.rs b/examples/plugins.rs new file mode 100644 index 0000000..fa27224 --- /dev/null +++ b/examples/plugins.rs @@ -0,0 +1,81 @@ +extern crate mdxjs; + +use std::rc::Rc; +use mdxjs::{RecmaProgram, MdastNode, HastNode, Options, PluginOptions}; +use markdown::mdast; + +/// Example that compiles the example MDX document from +/// to JavaScript. +fn main() -> Result<(), String> { + println!( + "{}", + mdxjs::compile_with_plugins("# test", &Options { + ..Default::default() + }, &PluginOptions { + experimental_mdast_transforms: Some(vec![Rc::new(|root: &MdastNode| { + let mut root1 = root.clone(); + visit_mut(&mut root1, |n| { + match n { + mdast::Node::Text(text) => { + text.value = "Hello World!".into() + }, + _ => {} + }; + }); + root1 + })]), + experimental_hast_transforms: Some(vec![Rc::new(|root: &HastNode| { + root.clone() + })]), + experimental_recma_transforms: Some(vec![Rc::new(|program: &RecmaProgram| { + program.clone() + })]), + ..Default::default() + })? + ); + + Ok(()) +} + + +/// Visit. +fn visit(node: &mdast::Node, visitor: Visitor) where Visitor: FnMut(&mdast::Node) { + visit_impl(node, visitor); +} + +/// Internal implementation to visit. +fn visit_impl(node: &mdast::Node, mut visitor: Visitor) -> Visitor where Visitor: FnMut(&mdast::Node) { + visitor(node); + + if let Some(children) = node.children() { + let mut index = 0; + while index < children.len() { + let child = &children[index]; + visitor = visit_impl(child, visitor); + index += 1; + } + } + + visitor +} + +/// Visit. +fn visit_mut(node: &mut mdast::Node, visitor: Visitor) where Visitor: FnMut(&mut mdast::Node) { + visit_mut_impl(node, visitor); +} + +/// Internal implementation to visit. +fn visit_mut_impl(node: &mut mdast::Node, mut visitor: Visitor) -> Visitor where Visitor: FnMut(&mut mdast::Node) { + visitor(node); + + if let Some(children) = node.children_mut() { + let mut index = 0; + while index < children.len() { + let child = &mut children[index]; + visitor = visit_mut_impl(child, visitor); + index += 1; + } + } + + visitor +} diff --git a/src/configuration.rs b/src/configuration.rs index 862713e..0f0b5de 100644 --- a/src/configuration.rs +++ b/src/configuration.rs @@ -1,7 +1,12 @@ //! Configuration. +use std::rc::Rc; use crate::mdx_plugin_recma_document::JsxRuntime; +pub use markdown::mdast::Node as MdastNode; +pub use crate::hast::Node as HastNode; +pub use crate::hast_util_to_swc::Program as RecmaProgram; + /// Like `Constructs` from `markdown-rs`. /// /// You can’t use: @@ -156,6 +161,23 @@ impl MdxParseOptions { } } +pub struct PluginOptions { + pub experimental_mdast_transforms: Option MdastNode + 'static>>>, + pub experimental_hast_transforms: Option HastNode + 'static>>>, + pub experimental_recma_transforms: Option RecmaProgram + 'static>>>, +} + +impl Default for PluginOptions { + /// MDX with `CommonMark` defaults. + fn default() -> Self { + Self { + experimental_mdast_transforms: None, + experimental_hast_transforms: None, + experimental_recma_transforms: None, + } + } +} + /// Configuration (optional). #[derive(Clone, Debug)] #[cfg_attr(feature = "serializable", derive(serde::Serialize, serde::Deserialize))] diff --git a/src/hast_util_to_swc.rs b/src/hast_util_to_swc.rs index 4bebd66..af899e6 100644 --- a/src/hast_util_to_swc.rs +++ b/src/hast_util_to_swc.rs @@ -43,7 +43,7 @@ use swc_core::ecma::ast::{ pub const MAGIC_EXPLICIT_MARKER: u32 = 1337; /// Result. -#[derive(Debug, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct Program { /// File path. pub path: Option, diff --git a/src/lib.rs b/src/lib.rs index 7160a58..67cfb4c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,7 @@ #![allow(clippy::cast_precision_loss)] extern crate markdown; + mod configuration; mod hast; mod hast_util_to_swc; @@ -32,7 +33,7 @@ use crate::{ }; use markdown::{to_mdast, Constructs, Location, ParseOptions}; -pub use crate::configuration::{MdxConstructs, MdxParseOptions, Options}; +pub use crate::configuration::{MdxConstructs, MdxParseOptions, Options, PluginOptions, MdastNode, HastNode, RecmaProgram}; pub use crate::mdx_plugin_recma_document::JsxRuntime; /// Turn MDX into JavaScript. @@ -53,6 +54,11 @@ pub use crate::mdx_plugin_recma_document::JsxRuntime; /// This project errors for many different reasons, such as syntax errors in /// the MDX format or misconfiguration. pub fn compile(value: &str, options: &Options) -> Result { + compile_with_plugins(&value, &options, &PluginOptions::default()) +} + +/// Turn MDX into JavaScript using the specified Plugins +pub fn compile_with_plugins(value: &str, options: &Options, plugins: &PluginOptions) -> Result { let parse_options = ParseOptions { constructs: Constructs { attention: options.parse.constructs.attention, @@ -112,14 +118,32 @@ pub fn compile(value: &str, options: &Options) -> Result { let location = Location::new(value.as_bytes()); let mdast = to_mdast(value, &parse_options)?; - let hast = mdast_util_to_hast(&mdast); - let mut program = hast_util_to_swc(&hast, options.filepath.clone(), Some(&location))?; - mdx_plugin_recma_document(&mut program, &document_options, Some(&location))?; - mdx_plugin_recma_jsx_rewrite(&mut program, &rewrite_options, Some(&location)); + let mdast_transformed = plugins.experimental_mdast_transforms.as_ref() + .map(|plugins| plugins + .iter() + .fold(mdast.clone(), |old, plugin| plugin(&old))); + let mdast_ref = mdast_transformed.as_ref().unwrap_or(&mdast); + + let hast = mdast_util_to_hast(mdast_ref); + let hast_transformed = plugins.experimental_hast_transforms.as_ref() + .map(|plugins| plugins + .iter() + .fold(hast.clone(), |old, plugin| plugin(&old))); + let hast_ref = hast_transformed.as_ref().unwrap_or(&hast); + + let mut program = hast_util_to_swc(hast_ref, options.filepath.clone(), Some(&location))?; + let mut module_transformed = plugins.experimental_recma_transforms.as_ref() + .map(|plugins| plugins + .iter() + .fold(program.clone(), |old, plugin| plugin(&old))); + let program_ref = module_transformed.as_mut().unwrap_or(&mut program); + + mdx_plugin_recma_document(program_ref, &document_options, Some(&location))?; + mdx_plugin_recma_jsx_rewrite(program_ref, &rewrite_options, Some(&location)); if !options.jsx { - swc_util_build_jsx(&mut program, &build_options, Some(&location))?; + swc_util_build_jsx(program_ref, &build_options, Some(&location))?; } - Ok(serialize(&mut program.module, Some(&program.comments))) + Ok(serialize(&mut program_ref.module, Some(&program_ref.comments))) } From 58c7f2c1960400310b7e45e81b3fb84074e2f874 Mon Sep 17 00:00:00 2001 From: n1xx1 Date: Thu, 1 Dec 2022 14:43:29 +0100 Subject: [PATCH 2/4] formatting --- examples/plugins.rs | 73 ++++++++++++++++++++++++++------------------ src/configuration.rs | 14 ++++++--- src/lib.rs | 58 +++++++++++++++++++++++++---------- 3 files changed, 94 insertions(+), 51 deletions(-) diff --git a/examples/plugins.rs b/examples/plugins.rs index fa27224..2f8db1a 100644 --- a/examples/plugins.rs +++ b/examples/plugins.rs @@ -1,50 +1,57 @@ extern crate mdxjs; -use std::rc::Rc; -use mdxjs::{RecmaProgram, MdastNode, HastNode, Options, PluginOptions}; use markdown::mdast; +use mdxjs::{HastNode, MdastNode, Options, PluginOptions, RecmaProgram}; +use std::rc::Rc; /// Example that compiles the example MDX document from /// to JavaScript. fn main() -> Result<(), String> { println!( "{}", - mdxjs::compile_with_plugins("# test", &Options { - ..Default::default() - }, &PluginOptions { - experimental_mdast_transforms: Some(vec![Rc::new(|root: &MdastNode| { - let mut root1 = root.clone(); - visit_mut(&mut root1, |n| { - match n { - mdast::Node::Text(text) => { - text.value = "Hello World!".into() - }, - _ => {} - }; - }); - root1 - })]), - experimental_hast_transforms: Some(vec![Rc::new(|root: &HastNode| { - root.clone() - })]), - experimental_recma_transforms: Some(vec![Rc::new(|program: &RecmaProgram| { - program.clone() - })]), - ..Default::default() - })? + mdxjs::compile_with_plugins( + "# test", + &Options { + ..Default::default() + }, + &PluginOptions { + experimental_mdast_transforms: Some(vec![Rc::new(|root: &MdastNode| { + let mut root1 = root.clone(); + visit_mut(&mut root1, |n| { + match n { + mdast::Node::Text(text) => text.value = "Hello World!".into(), + _ => {} + }; + }); + root1 + })]), + experimental_hast_transforms: Some(vec![Rc::new(|root: &HastNode| { + root.clone() + })]), + experimental_recma_transforms: Some(vec![Rc::new(|program: &RecmaProgram| { + program.clone() + })]), + ..Default::default() + } + )? ); Ok(()) } - /// Visit. -fn visit(node: &mdast::Node, visitor: Visitor) where Visitor: FnMut(&mdast::Node) { +fn visit(node: &mdast::Node, visitor: Visitor) +where + Visitor: FnMut(&mdast::Node), +{ visit_impl(node, visitor); } /// Internal implementation to visit. -fn visit_impl(node: &mdast::Node, mut visitor: Visitor) -> Visitor where Visitor: FnMut(&mdast::Node) { +fn visit_impl(node: &mdast::Node, mut visitor: Visitor) -> Visitor +where + Visitor: FnMut(&mdast::Node), +{ visitor(node); if let Some(children) = node.children() { @@ -60,12 +67,18 @@ fn visit_impl(node: &mdast::Node, mut visitor: Visitor) -> Visitor wher } /// Visit. -fn visit_mut(node: &mut mdast::Node, visitor: Visitor) where Visitor: FnMut(&mut mdast::Node) { +fn visit_mut(node: &mut mdast::Node, visitor: Visitor) +where + Visitor: FnMut(&mut mdast::Node), +{ visit_mut_impl(node, visitor); } /// Internal implementation to visit. -fn visit_mut_impl(node: &mut mdast::Node, mut visitor: Visitor) -> Visitor where Visitor: FnMut(&mut mdast::Node) { +fn visit_mut_impl(node: &mut mdast::Node, mut visitor: Visitor) -> Visitor +where + Visitor: FnMut(&mut mdast::Node), +{ visitor(node); if let Some(children) = node.children_mut() { diff --git a/src/configuration.rs b/src/configuration.rs index 0f0b5de..884ac2b 100644 --- a/src/configuration.rs +++ b/src/configuration.rs @@ -1,11 +1,11 @@ //! Configuration. -use std::rc::Rc; use crate::mdx_plugin_recma_document::JsxRuntime; +use std::rc::Rc; -pub use markdown::mdast::Node as MdastNode; pub use crate::hast::Node as HastNode; pub use crate::hast_util_to_swc::Program as RecmaProgram; +pub use markdown::mdast::Node as MdastNode; /// Like `Constructs` from `markdown-rs`. /// @@ -161,10 +161,14 @@ impl MdxParseOptions { } } +type MdastPlugin = Rc MdastNode + 'static>; +type HastPlugin = Rc HastNode + 'static>; +type RecmaPlugin = Rc RecmaProgram + 'static>; + pub struct PluginOptions { - pub experimental_mdast_transforms: Option MdastNode + 'static>>>, - pub experimental_hast_transforms: Option HastNode + 'static>>>, - pub experimental_recma_transforms: Option RecmaProgram + 'static>>>, + pub experimental_mdast_transforms: Option>, + pub experimental_hast_transforms: Option>, + pub experimental_recma_transforms: Option>, } impl Default for PluginOptions { diff --git a/src/lib.rs b/src/lib.rs index 67cfb4c..0770ecf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -33,7 +33,9 @@ use crate::{ }; use markdown::{to_mdast, Constructs, Location, ParseOptions}; -pub use crate::configuration::{MdxConstructs, MdxParseOptions, Options, PluginOptions, MdastNode, HastNode, RecmaProgram}; +pub use crate::configuration::{ + HastNode, MdastNode, MdxConstructs, MdxParseOptions, Options, PluginOptions, RecmaProgram, +}; pub use crate::mdx_plugin_recma_document::JsxRuntime; /// Turn MDX into JavaScript. @@ -54,11 +56,20 @@ pub use crate::mdx_plugin_recma_document::JsxRuntime; /// This project errors for many different reasons, such as syntax errors in /// the MDX format or misconfiguration. pub fn compile(value: &str, options: &Options) -> Result { - compile_with_plugins(&value, &options, &PluginOptions::default()) + compile_with_plugins(value, options, &PluginOptions::default()) } /// Turn MDX into JavaScript using the specified Plugins -pub fn compile_with_plugins(value: &str, options: &Options, plugins: &PluginOptions) -> Result { +/// +/// ## Errors +/// +/// This project errors for many different reasons, such as syntax errors in +/// the MDX format or misconfiguration. +pub fn compile_with_plugins( + value: &str, + options: &Options, + plugins: &PluginOptions, +) -> Result { let parse_options = ParseOptions { constructs: Constructs { attention: options.parse.constructs.attention, @@ -118,24 +129,36 @@ pub fn compile_with_plugins(value: &str, options: &Options, plugins: &PluginOpti let location = Location::new(value.as_bytes()); let mdast = to_mdast(value, &parse_options)?; - let mdast_transformed = plugins.experimental_mdast_transforms.as_ref() - .map(|plugins| plugins - .iter() - .fold(mdast.clone(), |old, plugin| plugin(&old))); + let mdast_transformed = plugins + .experimental_mdast_transforms + .as_ref() + .map(|plugins| { + plugins + .iter() + .fold(mdast.clone(), |old, plugin| plugin(&old)) + }); let mdast_ref = mdast_transformed.as_ref().unwrap_or(&mdast); let hast = mdast_util_to_hast(mdast_ref); - let hast_transformed = plugins.experimental_hast_transforms.as_ref() - .map(|plugins| plugins - .iter() - .fold(hast.clone(), |old, plugin| plugin(&old))); + let hast_transformed = plugins + .experimental_hast_transforms + .as_ref() + .map(|plugins| { + plugins + .iter() + .fold(hast.clone(), |old, plugin| plugin(&old)) + }); let hast_ref = hast_transformed.as_ref().unwrap_or(&hast); let mut program = hast_util_to_swc(hast_ref, options.filepath.clone(), Some(&location))?; - let mut module_transformed = plugins.experimental_recma_transforms.as_ref() - .map(|plugins| plugins - .iter() - .fold(program.clone(), |old, plugin| plugin(&old))); + let mut module_transformed = plugins + .experimental_recma_transforms + .as_ref() + .map(|plugins| { + plugins + .iter() + .fold(program.clone(), |old, plugin| plugin(&old)) + }); let program_ref = module_transformed.as_mut().unwrap_or(&mut program); mdx_plugin_recma_document(program_ref, &document_options, Some(&location))?; @@ -145,5 +168,8 @@ pub fn compile_with_plugins(value: &str, options: &Options, plugins: &PluginOpti swc_util_build_jsx(program_ref, &build_options, Some(&location))?; } - Ok(serialize(&mut program_ref.module, Some(&program_ref.comments))) + Ok(serialize( + &mut program_ref.module, + Some(&program_ref.comments), + )) } From 0767cbde7a6c6cad6273b71b230af45f2e5e552f Mon Sep 17 00:00:00 2001 From: n1xx1 Date: Thu, 1 Dec 2022 15:22:05 +0100 Subject: [PATCH 3/4] switched from immutable references for plugins to mutable references, added error returning, added example hast and recma plugins, fixed clippy warnings --- examples/plugins.rs | 78 ++++++++++++++++++++++++++------------------ src/configuration.rs | 8 +++-- src/lib.rs | 64 +++++++++++++++--------------------- 3 files changed, 77 insertions(+), 73 deletions(-) diff --git a/examples/plugins.rs b/examples/plugins.rs index 2f8db1a..7bae341 100644 --- a/examples/plugins.rs +++ b/examples/plugins.rs @@ -1,8 +1,12 @@ extern crate mdxjs; use markdown::mdast; +use mdxjs::hast; use mdxjs::{HastNode, MdastNode, Options, PluginOptions, RecmaProgram}; use std::rc::Rc; +use swc_core::common::{Span, SyntaxContext}; +use swc_core::ecma::ast as estree; +use swc_core::ecma::atoms::JsWord; /// Example that compiles the example MDX document from /// to JavaScript. @@ -15,23 +19,37 @@ fn main() -> Result<(), String> { ..Default::default() }, &PluginOptions { - experimental_mdast_transforms: Some(vec![Rc::new(|root: &MdastNode| { - let mut root1 = root.clone(); - visit_mut(&mut root1, |n| { - match n { - mdast::Node::Text(text) => text.value = "Hello World!".into(), - _ => {} - }; + experimental_mdast_transforms: Some(vec![Rc::new(|root: &mut MdastNode| { + mdast_visit_mut(root, |n| { + if let mdast::Node::Text(text) = n { + text.value = "Hello World!".into(); + } }); - root1 - })]), - experimental_hast_transforms: Some(vec![Rc::new(|root: &HastNode| { - root.clone() + Ok(()) })]), - experimental_recma_transforms: Some(vec![Rc::new(|program: &RecmaProgram| { - program.clone() + experimental_hast_transforms: Some(vec![Rc::new(|root: &mut HastNode| { + hast_visit_mut(root, |n| { + if let hast::Node::Element(e) = n { + if e.tag_name == "h1" { + e.tag_name = "h2".into(); + } + }; + }); + Ok(()) })]), - ..Default::default() + experimental_recma_transforms: Some(vec![Rc::new(|program: &mut RecmaProgram| { + let body = &mut program.module.body; + body.push(estree::ModuleItem::Stmt(estree::Stmt::Expr( + estree::ExprStmt { + expr: Box::new(estree::Expr::Ident(estree::Ident::from(( + JsWord::from("hello"), + SyntaxContext::empty(), + )))), + span: Span::default(), + }, + ))); + Ok(()) + })]) } )? ); @@ -39,26 +57,24 @@ fn main() -> Result<(), String> { Ok(()) } -/// Visit. -fn visit(node: &mdast::Node, visitor: Visitor) +fn mdast_visit_mut(node: &mut mdast::Node, visitor: Visitor) where - Visitor: FnMut(&mdast::Node), + Visitor: FnMut(&mut mdast::Node), { - visit_impl(node, visitor); + mdast_visit_mut_impl(node, visitor); } -/// Internal implementation to visit. -fn visit_impl(node: &mdast::Node, mut visitor: Visitor) -> Visitor +fn mdast_visit_mut_impl(node: &mut mdast::Node, mut visitor: Visitor) -> Visitor where - Visitor: FnMut(&mdast::Node), + Visitor: FnMut(&mut mdast::Node), { visitor(node); - if let Some(children) = node.children() { + if let Some(children) = node.children_mut() { let mut index = 0; while index < children.len() { - let child = &children[index]; - visitor = visit_impl(child, visitor); + let child = &mut children[index]; + visitor = mdast_visit_mut_impl(child, visitor); index += 1; } } @@ -66,18 +82,16 @@ where visitor } -/// Visit. -fn visit_mut(node: &mut mdast::Node, visitor: Visitor) +fn hast_visit_mut(node: &mut hast::Node, visitor: Visitor) where - Visitor: FnMut(&mut mdast::Node), + Visitor: FnMut(&mut hast::Node), { - visit_mut_impl(node, visitor); + hast_visit_mut_impl(node, visitor); } -/// Internal implementation to visit. -fn visit_mut_impl(node: &mut mdast::Node, mut visitor: Visitor) -> Visitor +fn hast_visit_mut_impl(node: &mut hast::Node, mut visitor: Visitor) -> Visitor where - Visitor: FnMut(&mut mdast::Node), + Visitor: FnMut(&mut hast::Node), { visitor(node); @@ -85,7 +99,7 @@ where let mut index = 0; while index < children.len() { let child = &mut children[index]; - visitor = visit_mut_impl(child, visitor); + visitor = hast_visit_mut_impl(child, visitor); index += 1; } } diff --git a/src/configuration.rs b/src/configuration.rs index 884ac2b..d08304a 100644 --- a/src/configuration.rs +++ b/src/configuration.rs @@ -161,9 +161,11 @@ impl MdxParseOptions { } } -type MdastPlugin = Rc MdastNode + 'static>; -type HastPlugin = Rc HastNode + 'static>; -type RecmaPlugin = Rc RecmaProgram + 'static>; +type MdastPlugin = Rc Result<(), String> + 'static>; + +type HastPlugin = Rc Result<(), String> + 'static>; + +type RecmaPlugin = Rc Result<(), String> + 'static>; pub struct PluginOptions { pub experimental_mdast_transforms: Option>, diff --git a/src/lib.rs b/src/lib.rs index 0770ecf..fe34624 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -14,7 +14,7 @@ extern crate markdown; mod configuration; -mod hast; +pub mod hast; mod hast_util_to_swc; mod mdast_util_to_hast; mod mdx_plugin_recma_document; @@ -128,48 +128,36 @@ pub fn compile_with_plugins( }; let location = Location::new(value.as_bytes()); - let mdast = to_mdast(value, &parse_options)?; - let mdast_transformed = plugins - .experimental_mdast_transforms - .as_ref() - .map(|plugins| { - plugins - .iter() - .fold(mdast.clone(), |old, plugin| plugin(&old)) - }); - let mdast_ref = mdast_transformed.as_ref().unwrap_or(&mdast); + let mut mdast = to_mdast(value, &parse_options)?; - let hast = mdast_util_to_hast(mdast_ref); - let hast_transformed = plugins - .experimental_hast_transforms - .as_ref() - .map(|plugins| { - plugins - .iter() - .fold(hast.clone(), |old, plugin| plugin(&old)) - }); - let hast_ref = hast_transformed.as_ref().unwrap_or(&hast); + if let Some(mdast_plugins) = &plugins.experimental_mdast_transforms { + for plugin in mdast_plugins { + plugin(&mut mdast)?; + } + } + + let mut hast = mdast_util_to_hast(&mdast); + + if let Some(hast_plugins) = &plugins.experimental_hast_transforms { + for plugin in hast_plugins { + plugin(&mut hast)?; + } + } + + let mut program = hast_util_to_swc(&hast, options.filepath.clone(), Some(&location))?; - let mut program = hast_util_to_swc(hast_ref, options.filepath.clone(), Some(&location))?; - let mut module_transformed = plugins - .experimental_recma_transforms - .as_ref() - .map(|plugins| { - plugins - .iter() - .fold(program.clone(), |old, plugin| plugin(&old)) - }); - let program_ref = module_transformed.as_mut().unwrap_or(&mut program); + mdx_plugin_recma_document(&mut program, &document_options, Some(&location))?; + mdx_plugin_recma_jsx_rewrite(&mut program, &rewrite_options, Some(&location)); - mdx_plugin_recma_document(program_ref, &document_options, Some(&location))?; - mdx_plugin_recma_jsx_rewrite(program_ref, &rewrite_options, Some(&location)); + if let Some(recma_plugins) = &plugins.experimental_recma_transforms { + for plugin in recma_plugins { + plugin(&mut program)?; + } + } if !options.jsx { - swc_util_build_jsx(program_ref, &build_options, Some(&location))?; + swc_util_build_jsx(&mut program, &build_options, Some(&location))?; } - Ok(serialize( - &mut program_ref.module, - Some(&program_ref.comments), - )) + Ok(serialize(&mut program.module, Some(&program.comments))) } From f76968cae5dcb1aa5219bc3ee700bf8238de7930 Mon Sep 17 00:00:00 2001 From: n1xx1 Date: Thu, 1 Dec 2022 15:27:46 +0100 Subject: [PATCH 4/4] removed wrong comment --- src/configuration.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/configuration.rs b/src/configuration.rs index d08304a..777fbf7 100644 --- a/src/configuration.rs +++ b/src/configuration.rs @@ -174,7 +174,6 @@ pub struct PluginOptions { } impl Default for PluginOptions { - /// MDX with `CommonMark` defaults. fn default() -> Self { Self { experimental_mdast_transforms: None,