feat: add strict mode

arlyon · Nov 3, 2022 · e85d0d1 · e85d0d1
1 parent 27e71c9
commit e85d0d1
Show file tree

Hide file tree

Showing 4 changed files with 30 additions and 5 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,6 +24,7 @@ opt-level = "s"
 itertools = "0.10.3"
 nom = "7.1.1"
 nom_locate = "4.0.0"
+once_cell = "1.15.0"
 serde = "1"
 serde_json = "1.0.83"
 serde_path_to_error = "0.1.8"

diff --git a/src/config.rs b/src/config.rs
@@ -6,6 +6,10 @@ use serde::Deserialize;
 pub struct AppConfig<'a> {
     #[serde(borrow)]
     pub config: TailwindConfig<'a>,
+
+    /// Strict mode throws an error when an unknown class is used.
+    #[serde(default)]
+    pub strict: bool,
 }
 
 #[derive(Deserialize, Debug)]

diff --git a/src/lib.rs b/src/lib.rs
@@ -11,6 +11,7 @@ mod util;
 
 use config::TailwindConfig;
 use nom_locate::LocatedSpan;
+use once_cell::sync::OnceCell;
 use swc_core::{
     common::{util::take::Take, Span, DUMMY_SP},
     ecma::{
@@ -45,6 +46,8 @@ impl<'a> TransformVisitor<'a> {
     }
 }
 
+static STRICT: OnceCell<bool> = OnceCell::new();
+
 /**
  * Implement necessary visit_mut_* methods for actual custom transform.
  * A comprehensive list of possible visitor methods can be found here:
@@ -256,6 +259,10 @@ pub fn process_transform(program: Program, metadata: TransformPluginProgramMetad
     let deser = &mut serde_json::Deserializer::from_str(&config);
     let config: Result<AppConfig, _> = serde_path_to_error::deserialize(deser);
 
+    if let Ok(c) = &config {
+        STRICT.set(c.strict).expect("failed to set strict mode");
+    }
+
     match config {
         Ok(config) => program.fold_with(&mut as_folder(TransformVisitor::new(config.config))),
         Err(error) => {

diff --git a/src/parse/from.rs b/src/parse/from.rs
@@ -13,6 +13,7 @@ use swc_core::plugin::errors::HANDLER;
 use crate::config::Screens;
 use crate::config::TailwindConfig;
 use crate::util::merge_literals;
+use crate::STRICT;
 
 use super::literal::parse_literal;
 use super::nom::Directive;
@@ -38,13 +39,20 @@ pub fn literal_from_exp<'a>(span: Span, val: Expression<'a>, config: &TailwindCo
     let mut object: ObjectLit = match literal_from_subject(span, val.subject, config) {
         Ok(object) => object,
         Err(text) => {
-            HANDLER.with(|handler| {
-                handler
-                    .struct_span_err(
+            HANDLER.with(|h| {
+                if STRICT.get().copied().unwrap_or_default() {
+                    h.struct_span_err(
                         val.span.unwrap_or(span),
                         &format!("unknown subject `{}`", text),
                     )
                     .emit()
+                } else {
+                    h.struct_span_warn(
+                        val.span.unwrap_or(span),
+                        &format!("unknown subject `{}`", text),
+                    )
+                    .emit()
+                }
             });
             return ObjectLit {
                 span: DUMMY_SP,
@@ -147,8 +155,13 @@ pub fn literal_from_exp<'a>(span: Span, val: Expression<'a>, config: &TailwindCo
                 "group-hover" => ".group:hover &",
                 x => {
                     HANDLER.with(|h| {
-                        h.struct_span_err(span, &format!("unknown modifier `{}`", x))
-                            .emit()
+                        if STRICT.get().copied().unwrap_or_default() {
+                            h.struct_span_err(span, &format!("unknown modifier `{}`", x))
+                                .emit()
+                        } else {
+                            h.struct_span_warn(span, &format!("unknown modifier `{}`", x))
+                                .emit()
+                        }
                     });
                     continue;
                 }