Add option to preserve @import dependencies with analyzeDependencies

Author: devongovett

node/index.d.ts

@@ -23,7 +23,7 @@ export interface TransformOptions {
    * are replaced with hashed placeholders that can be replaced with the final
    * urls later (after bundling). Dependencies are returned as part of the result.
    */
-  analyzeDependencies?: boolean,
+  analyzeDependencies?: boolean | DependencyOptions,
   /** 
    * Replaces user action pseudo classes with class names that can be applied from JavaScript.
    * This is useful for polyfills, for example.
@@ -43,6 +43,11 @@ export interface TransformOptions {
   errorRecovery?: boolean
 }
 
+export interface DependencyOptions {
+  /** Whether to preserve `@import` rules rather than removing them. */
+  preserveImports?: boolean
+}
+
 export type BundleOptions = Omit<TransformOptions, 'code'>;
 
 export interface BundleAsyncOptions extends BundleOptions {

node/src/lib.rs

@@ -4,7 +4,7 @@ static GLOBAL: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
 use lightningcss::bundler::{BundleErrorKind, Bundler, FileProvider, SourceProvider};
 use lightningcss::css_modules::{CssModuleExports, CssModuleReferences, PatternParseError};
-use lightningcss::dependencies::Dependency;
+use lightningcss::dependencies::{Dependency, DependencyOptions};
 use lightningcss::error::{Error, ErrorLocation, MinifyErrorKind, ParserError, PrinterErrorKind};
 use lightningcss::stylesheet::{
   MinifyOptions, ParserOptions, PrinterOptions, PseudoClasses, StyleAttribute, StyleSheet,
@@ -466,12 +466,25 @@ struct Config {
   pub input_source_map: Option<String>,
   pub drafts: Option<Drafts>,
   pub css_modules: Option<CssModulesOption>,
-  pub analyze_dependencies: Option<bool>,
+  pub analyze_dependencies: Option<AnalyzeDependenciesOption>,
   pub pseudo_classes: Option<OwnedPseudoClasses>,
   pub unused_symbols: Option<HashSet<String>>,
   pub error_recovery: Option<bool>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum AnalyzeDependenciesOption {
+  Bool(bool),
+  Config(AnalyzeDependenciesConfig),
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AnalyzeDependenciesConfig {
+  preserve_imports: bool,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
 enum CssModulesOption {
@@ -495,7 +508,7 @@ struct BundleConfig {
   pub source_map: Option<bool>,
   pub drafts: Option<Drafts>,
   pub css_modules: Option<CssModulesOption>,
-  pub analyze_dependencies: Option<bool>,
+  pub analyze_dependencies: Option<AnalyzeDependenciesOption>,
   pub pseudo_classes: Option<OwnedPseudoClasses>,
   pub unused_symbols: Option<HashSet<String>>,
   pub error_recovery: Option<bool>,
@@ -586,7 +599,17 @@ fn compile<'i>(code: &'i str, config: &Config) -> Result<TransformResult<'i>, Co
       minify: config.minify.unwrap_or_default(),
       source_map: source_map.as_mut(),
       targets: config.targets,
-      analyze_dependencies: config.analyze_dependencies.unwrap_or_default(),
+      analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
+        match d {
+          AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
+          AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
+            remove_imports: !c.preserve_imports,
+          }),
+          _ => None,
+        }
+      } else {
+        None
+      },
       pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
     })?
   };
@@ -672,7 +695,17 @@ fn compile_bundle<'i, P: SourceProvider>(
       minify: config.minify.unwrap_or_default(),
       source_map: source_map.as_mut(),
       targets: config.targets,
-      analyze_dependencies: config.analyze_dependencies.unwrap_or_default(),
+      analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
+        match d {
+          AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
+          AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
+            remove_imports: !c.preserve_imports,
+          }),
+          _ => None,
+        }
+      } else {
+        None
+      },
       pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
     })?
   };
@@ -701,16 +734,15 @@ fn compile_bundle<'i, P: SourceProvider>(
   })
 }
 
-#[derive(Serialize, Debug, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct AttrConfig {
   #[serde(with = "serde_bytes")]
   pub code: Vec<u8>,
   pub targets: Option<Browsers>,
   #[serde(default)]
   pub minify: bool,
-  #[serde(default)]
-  pub analyze_dependencies: bool,
+  pub analyze_dependencies: Option<AnalyzeDependenciesOption>,
   #[serde(default)]
   pub error_recovery: bool,
 }
@@ -764,7 +796,17 @@ fn compile_attr<'i>(
       minify: config.minify,
       source_map: None,
       targets: config.targets,
-      analyze_dependencies: config.analyze_dependencies,
+      analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
+        match d {
+          AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
+          AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
+            remove_imports: !c.preserve_imports,
+          }),
+          _ => None,
+        }
+      } else {
+        None
+      },
       pseudo_classes: None,
     })?
   };

src/dependencies.rs

@@ -16,6 +16,13 @@ use crate::values::url::Url;
 use cssparser::SourceLocation;
 use serde::Serialize;
 
+/// Options for `analyze_dependencies` in `PrinterOptions`.
+#[derive(Default)]
+pub struct DependencyOptions {
+  /// Whether to remove `@import` rules.
+  pub remove_imports: bool,
+}
+
 /// A dependency.
 #[derive(Serialize, Debug)]
 #[serde(tag = "type", rename_all = "lowercase")]
@@ -31,6 +38,8 @@ pub enum Dependency {
 pub struct ImportDependency {
   /// The url to import.
   pub url: String,
+  /// The placeholder that the URL was replaced with.
+  pub placeholder: String,
   /// An optional `supports()` condition.
   pub supports: Option<String>,
   /// A media query.
@@ -56,8 +65,11 @@ impl ImportDependency {
       None
     };
 
+    let placeholder = hash(&format!("{}_{}", filename, rule.url), false);
+
     ImportDependency {
       url: rule.url.as_ref().to_owned(),
+      placeholder,
       supports,
       media,
       loc: SourceRange::new(

src/lib.rs

@@ -19253,7 +19253,7 @@ mod tests {
       stylesheet.minify(MinifyOptions::default()).unwrap();
       let res = stylesheet
         .to_css(PrinterOptions {
-          analyze_dependencies: true,
+          analyze_dependencies: Some(Default::default()),
           minify: true,
           ..PrinterOptions::default()
         })
@@ -19267,15 +19267,18 @@ mod tests {
             assert_eq!(dep.url, url);
             assert_eq!(dep.placeholder, placeholder);
           }
-          _ => unreachable!(),
+          Dependency::Import(dep) => {
+            assert_eq!(dep.url, url);
+            assert_eq!(dep.placeholder, placeholder);
+          }
         }
       }
     }
 
     fn dep_error_test(source: &str, error: PrinterErrorKind) {
       let stylesheet = StyleSheet::parse(&source, ParserOptions::default()).unwrap();
       let res = stylesheet.to_css(PrinterOptions {
-        analyze_dependencies: true,
+        analyze_dependencies: Some(Default::default()),
         ..PrinterOptions::default()
       });
       match res {
@@ -19354,6 +19357,12 @@ mod tests {
       ".foo{--foo:url(\"Zn9-2q\")}",
       vec![("#foo", "Zn9-2q")],
     );
+
+    dep_test(
+      "@import \"test.css\"; .foo { color: red }",
+      "@import \"hHsogW\";.foo{color:red}",
+      vec![("test.css", "hHsogW")],
+    );
   }
 
   #[test]

src/printer.rs

@@ -1,7 +1,7 @@
 //! CSS serialization and source map generation.
 
 use crate::css_modules::CssModule;
-use crate::dependencies::Dependency;
+use crate::dependencies::{Dependency, DependencyOptions};
 use crate::error::{Error, ErrorLocation, PrinterError, PrinterErrorKind};
 use crate::rules::Location;
 use crate::targets::Browsers;
@@ -22,10 +22,10 @@ pub struct PrinterOptions<'a> {
   /// If true, the dependencies are returned as part of the
   /// [ToCssResult](super::stylesheet::ToCssResult).
   ///
-  /// When enabled, `@import` rules are removed, and `url()` dependencies
+  /// When enabled, `@import` and `url()` dependencies
   /// are replaced with hashed placeholders that can be replaced with the final
   /// urls later (after bundling).
-  pub analyze_dependencies: bool,
+  pub analyze_dependencies: Option<DependencyOptions>,
   /// A mapping of pseudo classes to replace with class names that can be applied
   /// from JavaScript. Useful for polyfills, for example.
   pub pseudo_classes: Option<PseudoClasses<'a>>,
@@ -74,6 +74,7 @@ pub struct Printer<'a, 'b, 'c, W> {
   pub(crate) in_calc: bool,
   pub(crate) css_module: Option<CssModule<'a, 'b, 'c>>,
   pub(crate) dependencies: Option<Vec<Dependency>>,
+  pub(crate) remove_imports: bool,
   pub(crate) pseudo_classes: Option<PseudoClasses<'a>>,
 }
 
@@ -98,11 +99,12 @@ impl<'a, 'b, 'c, W: std::fmt::Write + Sized> Printer<'a, 'b, 'c, W> {
       vendor_prefix: VendorPrefix::empty(),
       in_calc: false,
       css_module: None,
-      dependencies: if options.analyze_dependencies {
+      dependencies: if options.analyze_dependencies.is_some() {
         Some(Vec::new())
       } else {
         None
       },
+      remove_imports: matches!(&options.analyze_dependencies, Some(d) if d.remove_imports),
       pseudo_classes: options.pseudo_classes,
     }
   }
@@ -209,11 +211,11 @@ impl<'a, 'b, 'c, W: std::fmt::Write + Sized> Printer<'a, 'b, 'c, W> {
     self.loc = loc;
 
     if let Some(map) = &mut self.source_map {
-    let mut original = OriginalLocation {
-          original_line: loc.line,
-          original_column: loc.column - 1,
-          source: loc.source_index,
-          name: None,
+      let mut original = OriginalLocation {
+        original_line: loc.line,
+        original_column: loc.column - 1,
+        source: loc.source_index,
+        name: None,
       };
 
       // Remap using input source map if possible.
@@ -235,7 +237,7 @@ impl<'a, 'b, 'c, W: std::fmt::Write + Sized> Printer<'a, 'b, 'c, W> {
 
             found_mapping = true;
           }
-          }
+        }
 
         if !found_mapping {
           return;

src/rules/import.rs

@@ -3,6 +3,7 @@
 use super::layer::LayerName;
 use super::supports::SupportsCondition;
 use super::Location;
+use crate::dependencies::{Dependency, ImportDependency};
 use crate::error::PrinterError;
 use crate::media_query::MediaList;
 use crate::printer::Printer;
@@ -32,9 +33,23 @@ impl<'i> ToCss for ImportRule<'i> {
   where
     W: std::fmt::Write,
   {
+    let dep = if dest.dependencies.is_some() {
+      Some(ImportDependency::new(self, dest.filename()))
+    } else {
+      None
+    };
+
     dest.add_mapping(self.loc);
     dest.write_str("@import ")?;
-    serialize_string(&self.url, dest)?;
+    if let Some(dep) = dep {
+      serialize_string(&dep.placeholder, dest)?;
+
+      if let Some(dependencies) = &mut dest.dependencies {
+        dependencies.push(Dependency::Import(dep))
+      }
+    } else {
+      serialize_string(&self.url, dest)?;
+    }
 
     if let Some(layer) = &self.layer {
       dest.write_str(" layer")?;

src/rules/mod.rs

@@ -532,15 +532,17 @@ impl<'a, 'i> ToCssWithContext<'a, 'i> for CssRuleList<'i> {
 
       // Skip @import rules if collecting dependencies.
       if let CssRule::Import(rule) = &rule {
-        let dep = if dest.dependencies.is_some() {
-          Some(Dependency::Import(ImportDependency::new(&rule, dest.filename())))
-        } else {
-          None
-        };
-
-        if let Some(dependencies) = &mut dest.dependencies {
-          dependencies.push(dep.unwrap());
-          continue;
+        if dest.remove_imports {
+          let dep = if dest.dependencies.is_some() {
+            Some(Dependency::Import(ImportDependency::new(&rule, dest.filename())))
+          } else {
+            None
+          };
+
+          if let Some(dependencies) = &mut dest.dependencies {
+            dependencies.push(dep.unwrap());
+            continue;
+          }
         }
       }