Substitute variables (parcel-bundler#388)

Author: devongovett

Cargo.toml

@@ -38,6 +38,7 @@ serde = ["dep:serde", "smallvec/serde", "cssparser/serde", "parcel_selectors/ser
 sourcemap = ["parcel_sourcemap"]
 visitor = ["lightningcss-derive"]
 into_owned = ["lightningcss-derive"]
+substitute_variables = ["visitor", "into_owned"]
 
 [dependencies]
 serde = { version = "1.0.123", features = ["derive"], optional = true }

src/lib.rs

@@ -22436,6 +22436,66 @@ mod tests {
     }
   }
 
+  #[cfg(feature = "substitute_variables")]
+  #[test]
+  fn test_substitute_vars() {
+    use crate::properties::custom::TokenList;
+    use crate::traits::ParseWithOptions;
+
+    fn test(property: Property, vars: HashMap<&str, &str>, expected: &str) {
+      if let Property::Unparsed(unparsed) = property {
+        let vars = vars
+          .into_iter()
+          .map(|(k, v)| {
+            (
+              k,
+              TokenList::parse_string_with_options(v, ParserOptions::default()).unwrap(),
+            )
+          })
+          .collect();
+        let substituted = unparsed.substitute_variables(&vars).unwrap();
+        assert_eq!(
+          substituted.to_css_string(false, PrinterOptions::default()).unwrap(),
+          expected
+        );
+      } else {
+        panic!("Not an unparsed property");
+      }
+    }
+
+    let property = Property::parse_string("color".into(), "var(--test)", ParserOptions::default()).unwrap();
+    test(property, HashMap::from([("--test", "yellow")]), "color: #ff0");
+
+    let property =
+      Property::parse_string("color".into(), "var(--test, var(--foo))", ParserOptions::default()).unwrap();
+    test(property, HashMap::from([("--foo", "yellow")]), "color: #ff0");
+    let property = Property::parse_string(
+      "color".into(),
+      "var(--test, var(--foo, yellow))",
+      ParserOptions::default(),
+    )
+    .unwrap();
+    test(property, HashMap::new(), "color: #ff0");
+
+    let property =
+      Property::parse_string("width".into(), "calc(var(--a) + var(--b))", ParserOptions::default()).unwrap();
+    test(property, HashMap::from([("--a", "2px"), ("--b", "4px")]), "width: 6px");
+
+    let property = Property::parse_string("color".into(), "var(--a)", ParserOptions::default()).unwrap();
+    test(
+      property,
+      HashMap::from([("--a", "var(--b)"), ("--b", "yellow")]),
+      "color: #ff0",
+    );
+
+    let property = Property::parse_string("color".into(), "var(--a)", ParserOptions::default()).unwrap();
+    test(
+      property,
+      HashMap::from([("--a", "var(--b)"), ("--b", "var(--c)"), ("--c", "var(--a)")]),
+      "color: var(--a)",
+    );
+  }
+
   #[test]
   fn test_layer() {
     minify_test("@layer foo;", "@layer foo;");

src/properties/custom.rs

@@ -174,6 +174,28 @@ impl<'i> UnparsedProperty<'i> {
       value: self.value.clone(),
     }
   }
+
+  /// Substitutes variables and re-parses the property.
+  #[cfg(feature = "substitute_variables")]
+  pub fn substitute_variables<'x>(
+    mut self,
+    vars: &std::collections::HashMap<&str, TokenList<'i>>,
+  ) -> Result<super::Property<'x>, ()> {
+    use super::Property;
+    use crate::stylesheet::PrinterOptions;
+
+    // Substitute variables in the token list.
+    self.value.substitute_variables(vars);
+
+    // Now stringify and re-parse the property to its fully parsed form.
+    // Ideally we'd be able to reuse the tokens rather than printing, but cssparser doesn't provide a way to do that.
+    let mut css = String::new();
+    let mut dest = Printer::new(&mut css, PrinterOptions::default());
+    self.value.to_css(&mut dest, false).unwrap();
+    let property =
+      Property::parse_string(self.property_id.clone(), &css, ParserOptions::default()).map_err(|_| ())?;
+    Ok(property.into_owned())
+  }
 }
 
 /// A raw list of CSS tokens, with embedded parsed values.
@@ -235,6 +257,15 @@ impl<'i> TokenOrValue<'i> {
   }
 }
 
+impl<'i, T> ParseWithOptions<'i, T> for TokenList<'i> {
+  fn parse_with_options<'t>(
+    input: &mut Parser<'i, 't>,
+    options: &ParserOptions<T>,
+  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
+    TokenList::parse(input, options, 0)
+  }
+}
+
 impl<'i> TokenList<'i> {
   pub(crate) fn parse<'t, T>(
     input: &mut Parser<'i, 't>,
@@ -960,6 +991,49 @@ impl<'i> TokenList<'i> {
 
     res
   }
+
+  /// Substitutes variables with the provided values.
+  #[cfg(feature = "substitute_variables")]
+  pub fn substitute_variables(&mut self, vars: &std::collections::HashMap<&str, TokenList<'i>>) {
+    self.visit(&mut VarInliner { vars })
+  }
+}
+
+#[cfg(feature = "substitute_variables")]
+struct VarInliner<'a, 'i> {
+  vars: &'a std::collections::HashMap<&'a str, TokenList<'i>>,
+}
+
+#[cfg(feature = "substitute_variables")]
+impl<'a, 'i> crate::visitor::Visitor<'i> for VarInliner<'a, 'i> {
+  const TYPES: crate::visitor::VisitTypes = crate::visit_types!(TOKENS | VARIABLES);
+
+  fn visit_token_list(&mut self, tokens: &mut TokenList<'i>) {
+    let mut i = 0;
+    let mut seen = std::collections::HashSet::new();
+    while i < tokens.0.len() {
+      let token = &mut tokens.0[i];
+      token.visit(self);
+      if let TokenOrValue::Var(var) = token {
+        if let Some(value) = self.vars.get(var.name.ident.0.as_ref()) {
+          // Ignore circular references.
+          if seen.insert(var.name.ident.0.clone()) {
+            tokens.0.splice(i..i + 1, value.0.iter().cloned());
+            // Don't advance. We need to replace any variables in the value.
+            continue;
+          }
+        } else if let Some(fallback) = &var.fallback {
+          let fallback = fallback.0.clone();
+          if seen.insert(var.name.ident.0.clone()) {
+            tokens.0.splice(i..i + 1, fallback.into_iter());
+            continue;
+          }
+        }
+      }
+      seen.clear();
+      i += 1;
+    }
+  }
 }
 
 /// A CSS variable reference.

src/rules/style.rs

@@ -43,6 +43,7 @@ pub struct StyleRule<'i, R = DefaultAtRule> {
   pub loc: Location,
 }
 
+#[cfg(feature = "serde")]
 fn default_rule_list<'i, R>() -> CssRuleList<'i, R> {
   CssRuleList(Vec::new())
 }

src/traits.rs

@@ -27,11 +27,23 @@ pub trait Parse<'i>: Sized {
   }
 }
 
-pub(crate) trait ParseWithOptions<'i, T>: Sized {
+/// Trait for things that can be parsed from CSS syntax and require ParserOptions.
+pub trait ParseWithOptions<'i, T>: Sized {
+  /// Parse a value of this type with the given options.
   fn parse_with_options<'t>(
     input: &mut Parser<'i, 't>,
     options: &ParserOptions<T>,
   ) -> Result<Self, ParseError<'i, ParserError<'i>>>;
+
+  /// Parse a value from a string with the given options.
+  fn parse_string_with_options(
+    input: &'i str,
+    options: ParserOptions<T>,
+  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
+    let mut input = ParserInput::new(input);
+    let mut parser = Parser::new(&mut input);
+    Self::parse_with_options(&mut parser, &options)
+  }
 }
 
 impl<'i, T: Parse<'i>, U> ParseWithOptions<'i, U> for T {