Add option for unused symbols and refactor css modules

Author: devongovett

node/index.d.ts

@@ -55,25 +55,38 @@ export interface TransformResult {
 
 export type CSSModuleExports = {
   /** Maps exported (i.e. original) names to local names. */
-  [name: string]: CSSModuleExport[]
+  [name: string]: CSSModuleExport
 };
 
-export type CSSModuleExport = LocalCSSModuleExport | DependencyCSSModuleExport;
+export interface CSSModuleExport {
+  /** The local (compiled) name for this export. */
+  name: string,
+  /** Whether the export is referenced in this file. */
+  isReferenced: boolean,
+  /** Other names that are composed by this export. */
+  composes: CSSModuleReference[]
+}
+
+export type CSSModuleReference = LocalCSSModuleReference | GlobalCSSModuleReference | DependencyCSSModuleReference;
 
-export interface LocalCSSModuleExport {
+export interface LocalCSSModuleReference {
   type: 'local',
-  /** The local (compiled) name for this export. */
-  value: string
+  /** The local (compiled) name for the reference. */
+  name: string,
+}
+
+export interface GlobalCSSModuleReference {
+  type: 'global',
+  /** The referenced global name. */
+  name: string,
 }
 
-export interface DependencyCSSModuleExport {
+export interface DependencyCSSModuleReference {
   type: 'dependency',
-  value: {
-    /** The name to reference within the dependency. */
-    name: string,
-    /** The dependency specifier for the referenced file. */
-    specifier: string
-  }
+  /** The name to reference within the dependency. */
+  name: string,
+  /** The dependency specifier for the referenced file. */
+  specifier: string
 }
 
 export type Dependency = ImportDependency | UrlDependency;

node/src/lib.rs

@@ -2,8 +2,9 @@
 #[global_allocator]
 static GLOBAL: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
+use std::collections::HashSet;
 use serde::{Serialize, Deserialize};
-use parcel_css::stylesheet::{StyleSheet, StyleAttribute, ParserOptions, PrinterOptions, PseudoClasses};
+use parcel_css::stylesheet::{StyleSheet, StyleAttribute, ParserOptions, PrinterOptions, MinifyOptions, PseudoClasses};
 use parcel_css::targets::Browsers;
 use parcel_css::css_modules::CssModuleExports;
 use parcel_css::dependencies::Dependency;
@@ -115,7 +116,8 @@ struct Config {
   pub drafts: Option<Drafts>,
   pub css_modules: Option<bool>,
   pub analyze_dependencies: Option<bool>,
-  pub pseudo_classes: Option<OwnedPseudoClasses>
+  pub pseudo_classes: Option<OwnedPseudoClasses>,
+  pub unused_symbols: Option<HashSet<String>>
 }
 
 #[derive(Debug, Deserialize)]
@@ -154,7 +156,10 @@ fn compile<'i>(code: &'i str, config: &Config) -> Result<TransformResult, Compil
     },
     css_modules: config.css_modules.unwrap_or(false)
   })?;
-  stylesheet.minify(config.targets); // TODO: should this be conditional?
+  stylesheet.minify(MinifyOptions {
+    targets: config.targets,
+    unused_symbols: config.unused_symbols.clone().unwrap_or_default()
+  });
   let res = stylesheet.to_css(PrinterOptions {
     minify: config.minify.unwrap_or(false),
     source_map: config.source_map.unwrap_or(false),
@@ -209,7 +214,10 @@ struct AttrResult {
 
 fn compile_attr<'i>(code: &'i str, config: &AttrConfig) -> Result<AttrResult, CompileError<'i>> {
   let mut attr = StyleAttribute::parse(&code)?;
-  attr.minify(config.targets); // TODO: should this be conditional?
+  attr.minify(MinifyOptions {
+    targets: config.targets,
+    ..MinifyOptions::default()
+  });
   let res = attr.to_css(PrinterOptions {
     minify: config.minify.unwrap_or(false),
     source_map: false,

src/css_modules.rs

@@ -9,17 +9,30 @@ use crate::selector::Selectors;
 use serde::Serialize;
 use crate::error::PrinterError;
 
-#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize)]
-#[serde(tag = "type", content = "value", rename_all = "lowercase")]
-pub enum CssModuleExport {
-  Local(String),
+#[derive(PartialEq, Debug, Clone, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum CssModuleReference {
+  Local {
+    name: String,
+  },
+  Global {
+    name: String
+  },
   Dependency {
     name: String,
     specifier: String
   }
 }
 
-pub type CssModuleExports = HashMap<String, Vec<CssModuleExport>>;
+#[derive(PartialEq, Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CssModuleExport {
+  pub name: String,
+  pub composes: Vec<CssModuleReference>,
+  pub is_referenced: bool
+}
+
+pub type CssModuleExports = HashMap<String, CssModuleExport>;
 
 lazy_static! {
   static ref ENCODER: Encoding = {
@@ -35,50 +48,49 @@ pub(crate) struct CssModule<'a> {
 }
 
 impl<'a> CssModule<'a> {
-  pub fn add_export(&mut self, name: String, export: CssModuleExport) {
-    match self.exports.entry(name) {
+  pub fn add_local(&mut self, exported: &str, local: &str) {
+    let hash = &self.hash;
+    self.exports.entry(exported.into())
+      .or_insert_with(|| CssModuleExport {
+        name: format!("{}_{}", local, hash),
+        composes: vec![],
+        is_referenced: false
+      });
+  }
+
+  pub fn reference(&mut self, name: &str) {
+    match self.exports.entry(name.into()) {
       std::collections::hash_map::Entry::Occupied(mut entry) => {
-        if !entry.get().contains(&export) {
-          entry.get_mut().push(export);
-        }
+        entry.get_mut().is_referenced = true;
       }
       std::collections::hash_map::Entry::Vacant(entry) => {
-        let mut items = Vec::new();
-        if !items.contains(&export) {
-          items.push(export);
-        }
-        entry.insert(items);
+        entry.insert(CssModuleExport {
+          name: format!("{}_{}", name, self.hash),
+          composes: vec![],
+          is_referenced: true
+        });
       }
     }
   }
 
-  pub fn add_local(&mut self, exported: &str, local: &str) {
-    let local = CssModuleExport::Local(format!("{}_{}", local, self.hash));
-    self.add_export(exported.into(), local);
-  }
-
-  pub fn add_global(&mut self, exported: &str, global: &str) {
-    self.add_export(exported.into(), CssModuleExport::Local(global.into()))
-  }
-
-  pub fn add_dependency(&mut self, exported: &str, name: &str, specifier: &str) {
-    let dependency = CssModuleExport::Dependency {
-      name: name.into(),
-      specifier: specifier.into()
-    };
-    self.add_export(exported.into(), dependency)
-  }
-
   pub fn handle_composes(&mut self, selectors: &SelectorList<Selectors>, composes: &Composes) -> Result<(), PrinterError> {
     for sel in &selectors.0 {
       if sel.len() == 1 {
         match sel.iter_raw_match_order().next().unwrap() {
           parcel_selectors::parser::Component::Class(ref id) => {
             for name in &composes.names {
-              match &composes.from {
-                None => self.add_local(&id.0, &name.0),
-                Some(ComposesFrom::Global) => self.add_global(&id.0, &name.0),
-                Some(ComposesFrom::File(file)) => self.add_dependency(&id.0, &name.0, &file)
+              let reference = match &composes.from {
+                None => CssModuleReference::Local { name: format!("{}_{}", name.0, self.hash) },
+                Some(ComposesFrom::Global) => CssModuleReference::Global { name: name.0.clone() },
+                Some(ComposesFrom::File(file)) => CssModuleReference::Dependency {
+                  name: name.0.clone(),
+                  specifier: file.clone()
+                }
+              };
+
+              let export = self.exports.get_mut(&id.0).unwrap();
+              if !export.composes.contains(&reference) {
+                export.composes.push(reference);
               }
             }
             continue;