@swc/plugin-styled-jsx 1.5.76 → 1.5.78

package/Cargo.toml

@@ -11,22 +11,23 @@ version = "0.14.3"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-custom_transform = ["swc_core/common_concurrent"]
+custom_transform = ["swc_common/concurrent"]
 
 [dependencies]
 easy-error = "1.0.0"
 styled_jsx = { path = "./transform" }
-swc_core = { version = "0.83.0", features = [
-  "common",
-  "ecma_ast",
-  "ecma_plugin_transform",
-  "ecma_parser",
-  "ecma_minifier",
-  "ecma_utils",
-  "ecma_visit",
-] }
 tracing = { version = "0.1.37", features = ["release_max_level_off"] }
+serde_json = "1"
+swc_common = "0.32.1"
+swc_ecma_ast = "0.109.1"
+swc_ecma_parser = "0.140.0"
+swc_ecma_minifier = "0.187.4"
+swc_ecma_utils = "0.123.0"
+swc_ecma_visit = "0.95.1"
+swc_plugin_macro = "0.9.15"
+swc_atoms = "0.5.9"
+swc_core = { version = "0.83.5", features = ["ecma_plugin_transform"] }
 
 [dev-dependencies]
-swc_core = { features = ["testing_transform"], version = "0.83.0" }
+swc_ecma_transforms_testing = "0.136.2"
 testing = "0.34.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swc/plugin-styled-jsx",
-  "version": "1.5.76",
+  "version": "1.5.78",
   "description": "SWC plugin for styled-jsx",
   "main": "swc_plugin_styled_jsx.wasm",
   "scripts": {

package/src/lib.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
 #![feature(box_patterns)]
 
-use styled_jsx::visitor;
+use styled_jsx::{visitor, visitor::Config};
 use swc_core::{
     common::{sync::Lrc, FileName, SourceMap},
     ecma::{ast::Program, visit::FoldWith},
@@ -9,9 +9,16 @@ use swc_core::{
 };
 
 #[plugin_transform]
-fn styled_jsx_plugin(program: Program, _: TransformPluginProgramMetadata) -> Program {
+fn styled_jsx_plugin(program: Program, data: TransformPluginProgramMetadata) -> Program {
+    let config = serde_json::from_str::<Config>(
+        &data
+            .get_transform_plugin_config()
+            .expect("failed to get plugin config for styled-jsx"),
+    )
+    .expect("invalid config for styled-jsx");
+
     // TODO(kdy1): This is wrong, but it does not use cm
     let cm = Lrc::new(SourceMap::default());
 
-    program.fold_with(&mut visitor::styled_jsx(cm, FileName::Anon))
+    program.fold_with(&mut visitor::styled_jsx(cm, FileName::Anon, config))
 }

package/transform/Cargo.toml

@@ -4,29 +4,36 @@ description = "AST transforms visitor for styled-jsx"
 edition = "2021"
 license = "Apache-2.0"
 name = "styled_jsx"
-version = "0.43.0"
+version = "0.45.0"
 
 [features]
-custom_transform = ["swc_core/common_concurrent"]
+custom_transform = ["swc_common/concurrent"]
 
 [dependencies]
 easy-error = "1.0.0"
 tracing = "0.1.37"
-lightningcss = { version = "1.0.0-alpha.44", features = [
+lightningcss = { version = "1.0.0-alpha.46", features = [
   "visitor",
   "into_owned",
 ] }
 parcel_selectors = "0.26.0"
+serde = { version = "1", features = ["derive"] }
 
-swc_core = { version = "0.83.0", features = [
-  "common",
-  "ecma_ast",
-  "ecma_parser",
-  "ecma_minifier",
-  "ecma_utils",
-  "ecma_visit",
-] }
+swc_common = "0.32.1"
+swc_ecma_ast = "0.109.1"
+swc_ecma_utils = "0.123.0"
+swc_ecma_visit = "0.95.1"
+swc_plugin_macro = "0.9.15"
+swc_ecma_parser = "0.140.0"
+swc_ecma_minifier = "0.187.4"
+swc_css_ast = "0.139.1"
+swc_css_codegen = "0.149.1"
+swc_css_parser = "0.148.1"
+swc_css_prefixer = "0.151.1"
+swc_css_minifier = "0.114.1"
+swc_css_visit = "0.138.1"
 
 [dev-dependencies]
 testing = "0.34.1"
-swc_core = { features = ["testing_transform"], version = "0.83.0" }
+swc_ecma_transforms_testing = "0.136.1"
+swc_ecma_transforms = "0.224.4"

package/transform/src/lib.rs

@@ -1,6 +1,7 @@
 #![feature(box_patterns)]
 mod lifetime;
 pub mod style;
-mod transform_css;
+mod transform_css_lightningcss;
+mod transform_css_swc;
 mod utils;
 pub mod visitor;

package/transform/src/style.rs

@@ -1,4 +1,5 @@
-use swc_core::{common::Span, ecma::ast::*};
+use swc_common::Span;
+use swc_ecma_ast::*;
 
 pub struct ExternalStyle {
     pub expr: Expr,

package/transform/src/{transform_css.rs → transform_css_lightningcss.rs}

@@ -18,10 +18,8 @@ use lightningcss::{
     visitor::{Visit, VisitTypes, Visitor},
 };
 use parcel_selectors::{parser::SelectorIter, SelectorImpl};
-use swc_core::{
-    common::{errors::HANDLER, SourceMap, DUMMY_SP},
-    ecma::ast::{Expr, Tpl, TplElement},
-};
+use swc_common::{errors::HANDLER, SourceMap, DUMMY_SP};
+use swc_ecma_ast::*;
 use tracing::{debug, error, trace};
 
 use crate::{
@@ -182,7 +180,9 @@ struct CssNamespace {
 impl<'i> Visitor<'i> for CssNamespace {
     type Error = Infallible;
 
-    const TYPES: VisitTypes = visit_types!(SELECTORS);
+    fn visit_types(&self) -> VisitTypes {
+        visit_types!(SELECTORS)
+    }
 
     fn visit_selector(&mut self, selector: &mut Selector<'i>) -> Result<(), Self::Error> {
         let mut new_selectors = vec![];

package/transform/src/transform_css_swc.rs

@@ -0,0 +1,392 @@
+use std::{panic, sync::Arc};
+
+use easy_error::{bail, Error};
+use swc_common::{
+    errors::HANDLER, source_map::Pos, util::take::Take, BytePos, SourceMap, Span, Spanned,
+    SyntaxContext, DUMMY_SP,
+};
+use swc_css_ast::{
+    ClassSelector, Combinator, CombinatorValue, ComplexSelector, ComplexSelectorChildren,
+    CompoundSelector, Ident, PseudoClassSelector, PseudoClassSelectorChildren, Stylesheet,
+    SubclassSelector, Token, TokenAndSpan,
+};
+use swc_css_codegen::{
+    writer::basic::{BasicCssWriter, BasicCssWriterConfig},
+    CodeGenerator, CodegenConfig, Emit,
+};
+use swc_css_parser::{
+    lexer::Lexer,
+    parse_input,
+    parser::{
+        input::{InputType, Tokens},
+        Parser, ParserConfig,
+    },
+};
+use swc_css_prefixer::prefixer;
+use swc_css_visit::{VisitMut, VisitMutWith};
+use swc_ecma_ast::*;
+use swc_ecma_parser::StringInput;
+use tracing::{debug, trace};
+
+use crate::{
+    style::LocalStyle,
+    utils::{hash_string, string_literal_expr},
+};
+
+pub fn transform_css(
+    _cm: Arc<SourceMap>,
+    style_info: &LocalStyle,
+    is_global: bool,
+    class_name: &Option<String>,
+) -> Result<Expr, Error> {
+    debug!("CSS: \n{}", style_info.css);
+
+    // TODO use `parse_string_input` in future
+    let config = ParserConfig {
+        allow_wrong_line_comments: true,
+        css_modules: false,
+        ..Default::default()
+    };
+    let lexer = Lexer::new(
+        StringInput::new(
+            &style_info.css,
+            style_info.css_span.lo,
+            style_info.css_span.hi,
+        ),
+        config,
+    );
+    let mut parser = Parser::new(lexer, config);
+
+    let result: Result<Stylesheet, _> = parser.parse_all();
+    let mut ss = match result {
+        Ok(ss) => ss,
+        Err(err) => {
+            HANDLER.with(|handler| {
+                // Print css parsing errors
+                err.to_diagnostics(handler).emit();
+
+                // TODO(kdy1): We may print css so the user can see the error, and report it.
+
+                handler
+                    .struct_span_err(
+                        style_info.css_span,
+                        "Failed to parse css in styled jsx component",
+                    )
+                    .note(&format!("Input to the css parser is {}", style_info.css))
+                    .emit()
+            });
+            bail!("Failed to parse css");
+        }
+    };
+    // ? Do we need to support optionally prefixing?
+    ss.visit_mut_with(&mut prefixer(Default::default()));
+    ss.visit_mut_with(&mut Namespacer {
+        class_name: match class_name {
+            Some(s) => s.clone(),
+            None => format!("jsx-{}", &hash_string(&style_info.hash)),
+        },
+        is_global,
+        is_dynamic: style_info.is_dynamic,
+    });
+
+    let mut s = String::new();
+    {
+        let mut wr = BasicCssWriter::new(&mut s, None, BasicCssWriterConfig::default());
+        let mut gen = CodeGenerator::new(&mut wr, CodegenConfig { minify: true });
+
+        gen.emit(&ss).unwrap();
+    }
+
+    if style_info.expressions.is_empty() {
+        return Ok(string_literal_expr(&s));
+    }
+
+    let mut parts: Vec<&str> = s.split("__styled-jsx-placeholder-").collect();
+    let mut final_expressions = vec![];
+    for i in parts.iter_mut().skip(1) {
+        let (num_len, expression_index) = read_number(i);
+        final_expressions.push(style_info.expressions[expression_index].clone());
+        let substr = &i[(num_len + 2)..];
+        *i = substr;
+    }
+
+    Ok(Expr::Tpl(Tpl {
+        quasis: parts
+            .iter()
+            .map(|quasi| {
+                TplElement {
+                    cooked: None, // ? Do we need cooked as well
+                    raw: quasi.replace('`', "\\`").into(),
+                    span: DUMMY_SP,
+                    tail: false,
+                }
+            })
+            .collect(),
+        exprs: final_expressions,
+        span: DUMMY_SP,
+    }))
+}
+
+/// Returns `(length, value)`
+fn read_number(s: &str) -> (usize, usize) {
+    for (idx, c) in s.char_indices() {
+        if c.is_ascii_digit() {
+            continue;
+        }
+
+        // For 10, we reach here after `0`.
+        let value = s[0..idx].parse().expect("failed to parse");
+
+        return (idx, value);
+    }
+
+    unreachable!("read_number(`{}`) is invalid because it is empty", s)
+}
+
+struct Namespacer {
+    class_name: String,
+    is_global: bool,
+    is_dynamic: bool,
+}
+
+impl VisitMut for Namespacer {
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+        #[cfg(debug_assertions)]
+        let _tracing = {
+            // This will add information to the log messages, only for debug build.
+            // Note that we use cargo feature to remove all logging on production builds.
+
+            let mut code = String::new();
+            {
+                let mut wr = BasicCssWriter::new(&mut code, None, BasicCssWriterConfig::default());
+                let mut gen = CodeGenerator::new(&mut wr, CodegenConfig { minify: true });
+
+                gen.emit(&*node).unwrap();
+            }
+
+            tracing::span!(
+                tracing::Level::TRACE,
+                "Namespacer::visit_mut_complex_selector",
+                class_name = &*self.class_name,
+                is_global = self.is_global,
+                is_dynamic = self.is_dynamic,
+                input = &*code
+            )
+            .entered()
+        };
+
+        let mut new_selectors = vec![];
+        let mut combinator = None;
+
+        for sel in node.children.take() {
+            match &sel {
+                ComplexSelectorChildren::CompoundSelector(selector) => {
+                    match self.get_transformed_selectors(combinator, selector.clone()) {
+                        Ok(transformed_selectors) => new_selectors.extend(transformed_selectors),
+                        Err(_) => {
+                            HANDLER.with(|handler| {
+                                handler
+                                    .struct_span_err(
+                                        selector.span,
+                                        "Failed to transform one off global selector",
+                                    )
+                                    .emit()
+                            });
+                            new_selectors.push(sel);
+                        }
+                    }
+
+                    combinator = None;
+                }
+                ComplexSelectorChildren::Combinator(v) => {
+                    combinator = Some(v.clone());
+                }
+            };
+        }
+
+        node.children = new_selectors;
+    }
+}
+
+impl Namespacer {
+    fn get_transformed_selectors(
+        &mut self,
+        combinator: Option<Combinator>,
+        mut node: CompoundSelector,
+    ) -> Result<Vec<ComplexSelectorChildren>, Error> {
+        let mut pseudo_index = None;
+
+        for (i, selector) in node.subclass_selectors.iter().enumerate() {
+            let (name, children) = match &selector {
+                SubclassSelector::PseudoClass(PseudoClassSelector {
+                    name,
+                    children: Some(children),
+                    ..
+                }) if &name.value == "global" => (name, children),
+                SubclassSelector::PseudoClass(_) | SubclassSelector::PseudoElement(_) => {
+                    if pseudo_index.is_none() {
+                        pseudo_index = Some(i);
+                    }
+
+                    continue;
+                }
+                _ => continue,
+            };
+
+            // One off global selector
+            if &name.value == "global" {
+                // TODO(alexander-akait): in future we should use list of component values
+                let tokens = children
+                    .iter()
+                    .map(|v| match v {
+                        PseudoClassSelectorChildren::PreservedToken(v) => v.clone(),
+                        _ => {
+                            unreachable!();
+                        }
+                    })
+                    .collect::<Vec<TokenAndSpan>>();
+                let mut tokens = {
+                    let lo = tokens.first().map(|v| v.span_lo()).unwrap_or(BytePos(0));
+                    let hi = tokens.last().map(|v| v.span_hi()).unwrap_or(BytePos(0));
+
+                    Tokens {
+                        span: Span::new(lo, hi, Default::default()),
+                        tokens,
+                    }
+                };
+
+                // Because it is allowed to write `.bar :global(> .foo) {}` or .bar
+                // :global(.foo) {}`, so selector can be complex or relative (it violates the
+                // specification), but it is popular usage, so we just add `a >` at top and then
+                // remove it
+                let mut front_tokens = get_front_selector_tokens(&tokens);
+
+                front_tokens.extend(tokens.tokens);
+
+                tokens.tokens = front_tokens;
+
+                let complex_selectors = panic::catch_unwind(|| {
+                    let x: ComplexSelector = parse_input(
+                        InputType::Tokens(&tokens),
+                        ParserConfig {
+                            allow_wrong_line_comments: true,
+                            css_modules: true,
+                            ..Default::default()
+                        },
+                        // TODO(kdy1): We might be able to report syntax errors.
+                        &mut vec![],
+                    )
+                    .unwrap();
+                    x
+                });
+
+                return match complex_selectors {
+                    Ok(complex_selectors) => {
+                        let mut v = complex_selectors.children[1..].to_vec();
+
+                        if let ComplexSelectorChildren::Combinator(Combinator {
+                            value: CombinatorValue::Descendant,
+                            ..
+                        }) = v[0]
+                        {
+                            v.remove(0);
+                        }
+
+                        if v.is_empty() {
+                            bail!("Failed to transform one off global selector");
+                        }
+
+                        trace!("Combinator: {:?}", combinator);
+                        trace!("v[0]: {:?}", v[0]);
+
+                        let mut result = vec![];
+
+                        if let Some(combinator) = combinator {
+                            match v.get(0) {
+                                // `Descendant` combinator can't be the first because we removed it
+                                // above
+                                Some(ComplexSelectorChildren::Combinator(..))
+                                    if combinator.value == CombinatorValue::Descendant => {}
+                                _ => {
+                                    result.push(ComplexSelectorChildren::Combinator(combinator));
+                                }
+                            }
+                        }
+
+                        v.iter_mut().for_each(|sel| {
+                            if i < node.subclass_selectors.len() {
+                                if let ComplexSelectorChildren::CompoundSelector(sel) = sel {
+                                    sel.subclass_selectors
+                                        .extend(node.subclass_selectors[i + 1..].iter().cloned());
+                                }
+                            }
+                        });
+
+                        result.extend(v);
+
+                        Ok(result)
+                    }
+                    Err(_) => bail!("Failed to transform one off global selector"),
+                };
+            }
+        }
+
+        let subclass_selector = match self.is_dynamic {
+            true => "__jsx-style-dynamic-selector",
+            false => &self.class_name,
+        };
+        let insert_index = match pseudo_index {
+            None => node.subclass_selectors.len(),
+            Some(i) => i,
+        };
+
+        if !self.is_global {
+            node.subclass_selectors.insert(
+                insert_index,
+                SubclassSelector::Class(ClassSelector {
+                    span: DUMMY_SP,
+                    text: Ident {
+                        raw: Some(subclass_selector.into()),
+                        value: subclass_selector.into(),
+                        span: DUMMY_SP,
+                    },
+                }),
+            );
+        }
+
+        let mut result = vec![];
+
+        if let Some(combinator) = combinator {
+            result.push(ComplexSelectorChildren::Combinator(combinator));
+        }
+
+        result.push(ComplexSelectorChildren::CompoundSelector(node));
+
+        Ok(result)
+    }
+}
+
+fn get_front_selector_tokens(selector_tokens: &Tokens) -> Vec<TokenAndSpan> {
+    let start_pos = selector_tokens.span.lo.to_u32() - 2;
+    vec![
+        TokenAndSpan {
+            span: Span {
+                lo: BytePos(start_pos),
+                hi: BytePos(start_pos + 1),
+                ctxt: SyntaxContext::empty(),
+            },
+            token: Token::Ident {
+                raw: "a".into(),
+                value: "a".into(),
+            },
+        },
+        TokenAndSpan {
+            span: Span {
+                lo: BytePos(start_pos + 1),
+                hi: BytePos(start_pos + 2),
+                ctxt: SyntaxContext::empty(),
+            },
+            token: Token::WhiteSpace { value: " ".into() },
+        },
+    ]
+}

package/transform/src/utils.rs

@@ -1,6 +1,7 @@
 use std::{collections::hash_map::DefaultHasher, hash::Hasher};
 
-use swc_core::{common::DUMMY_SP, ecma::ast::*};
+use swc_common::DUMMY_SP;
+use swc_ecma_ast::*;
 
 use crate::style::{ExternalStyle, JSXStyle, LocalStyle};
 

package/transform/src/visitor.rs

@@ -6,31 +6,33 @@ use std::{
 };
 
 use easy_error::{bail, Error};
-use swc_core::{
-    common::{collections::AHashSet, errors::HANDLER, FileName, SourceMap, Span, DUMMY_SP},
-    ecma::{
-        ast::*,
-        minifier::{
-            eval::{EvalResult, Evaluator},
-            marks::Marks,
-        },
-        utils::{collect_decls, drop_span, prepend_stmt, private_ident},
-        visit::{Fold, FoldWith},
-    },
+use serde::Deserialize;
+use swc_common::{collections::AHashSet, errors::HANDLER, FileName, SourceMap, Span, DUMMY_SP};
+use swc_ecma_ast::*;
+use swc_ecma_minifier::{
+    eval::{EvalResult, Evaluator},
+    marks::Marks,
 };
+use swc_ecma_utils::{collect_decls, drop_span, prepend_stmt, private_ident};
+use swc_ecma_visit::{Fold, FoldWith};
 
 use crate::{
     style::{ExternalStyle, JSXStyle, LocalStyle},
-    transform_css::transform_css,
     utils::{
         add, and, compute_class_names, get_usable_import_specifier, hash_string, ident,
         is_capitalized, make_external_styled_jsx_el, make_local_styled_jsx_el, not_eq, or,
         string_literal_expr, styled_jsx_import_decl,
     },
 };
-//use external::external_styles;
 
-pub fn styled_jsx(cm: Arc<SourceMap>, file_name: FileName) -> impl Fold {
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Config {
+    #[serde(default)]
+    pub use_lightningcss: bool,
+}
+
+pub fn styled_jsx(cm: Arc<SourceMap>, file_name: FileName, config: Config) -> impl Fold {
     let file_name = match file_name {
         FileName::Real(real_file_name) => real_file_name
             .to_str()
@@ -40,6 +42,7 @@ pub fn styled_jsx(cm: Arc<SourceMap>, file_name: FileName) -> impl Fold {
 
     StyledJSXTransformer {
         cm,
+        config,
         file_name,
         styles: Default::default(),
         static_class_name: Default::default(),
@@ -63,6 +66,8 @@ pub fn styled_jsx(cm: Arc<SourceMap>, file_name: FileName) -> impl Fold {
 
 struct StyledJSXTransformer {
     cm: Arc<SourceMap>,
+    config: Config,
+
     file_name: Option<String>,
     styles: Vec<JSXStyle>,
     static_class_name: Option<String>,
@@ -564,12 +569,22 @@ impl StyledJSXTransformer {
 
         match &style_info {
             JSXStyle::Local(style_info) => {
-                let css = transform_css(
-                    self.cm.clone(),
-                    style_info,
-                    is_global,
-                    &self.static_class_name,
-                )?;
+                let css = if self.config.use_lightningcss {
+                    crate::transform_css_lightningcss::transform_css(
+                        self.cm.clone(),
+                        style_info,
+                        is_global,
+                        &self.static_class_name,
+                    )?
+                } else {
+                    crate::transform_css_swc::transform_css(
+                        self.cm.clone(),
+                        style_info,
+                        is_global,
+                        &self.static_class_name,
+                    )?
+                };
+
                 Ok(make_local_styled_jsx_el(
                     style_info,
                     css,
@@ -618,7 +633,21 @@ impl StyledJSXTransformer {
         } else {
             bail!("This shouldn't happen, we already know that this is a template literal");
         };
-        let css = transform_css(self.cm.clone(), style, tag == "global", &static_class_name)?;
+        let css = if self.config.use_lightningcss {
+            crate::transform_css_lightningcss::transform_css(
+                self.cm.clone(),
+                style,
+                tag == "global",
+                &static_class_name,
+            )?
+        } else {
+            crate::transform_css_swc::transform_css(
+                self.cm.clone(),
+                style,
+                tag == "global",
+                &static_class_name,
+            )?
+        };
         if tag == "resolve" {
             self.file_has_css_resolve = true;
             return Ok(Expr::Object(ObjectLit {