Use AsRef<str> instead of String for parameters/arguments (#233)

.changeset/beige-phones-end.md

@@ -0,0 +1,2 @@
+---
+---

packages/yak-swc/yak_swc/src/lib.rs

@@ -110,7 +110,7 @@ where
 {
   pub fn new(
     comments: Option<GenericComments>,
-    filename: String,
+    filename: impl AsRef<str>,
     dev_mode: bool,
     prefix: Option<String>,
   ) -> Self {
@@ -122,12 +122,12 @@ where
       current_exported: false,
       variables: VariableVisitor::new(),
       yak_library_imports: None,
-      naming_convention: NamingConvention::new(filename.clone(), dev_mode, prefix),
+      naming_convention: NamingConvention::new(filename.as_ref(), dev_mode, prefix),
       variable_name_selector_mapping: FxHashMap::default(),
       expression_replacement: None,
       css_module_identifier: None,
       inside_element_with_css_attribute: false,
-      filename,
+      filename: filename.as_ref().into(),
       comments,
     }
   }
@@ -452,8 +452,8 @@ ${{() => {var}}};\n",
                   .yak_library_imports
                   .as_mut()
                   .unwrap()
-                  .get_yak_utility_ident("unitPostFix".to_string()),
-                unit.to_string(),
+                  .get_yak_utility_ident("unitPostFix"),
+                unit,
               )
             } else {
               *expr.clone()
@@ -662,7 +662,7 @@ where
           .yak_library_imports
           .as_mut()
           .unwrap()
-          .get_yak_utility_ident("mergeCssProp".into()),
+          .get_yak_utility_ident("mergeCssProp"),
       );
     }
   }
@@ -1022,7 +1022,7 @@ mod tests {
       &|tester| {
         visit_mut_pass(TransformVisitor::new(
           Some(tester.comments.clone()),
-          "path/input.tsx".to_string(),
+          "path/input.tsx",
           true,
           None,
         ))
@@ -1047,7 +1047,7 @@ mod tests {
       &|tester| {
         visit_mut_pass(TransformVisitor::new(
           Some(tester.comments.clone()),
-          "path/input.tsx".to_string(),
+          "path/input.tsx",
           false,
           None,
         ))

packages/yak-swc/yak_swc/src/naming_convention.rs

@@ -13,18 +13,18 @@ pub struct NamingConvention {
 /// Use the `generate_unique_name` method to generate a unique name based on a base name.
 /// e.g. `generate_unique_name("foo bar")` might return `"foo_bar-01"`, `"foo_bar-02"`, etc.
 impl NamingConvention {
-  pub fn new(file_name: String, dev_mode: bool, prefix: Option<String>) -> Self {
+  pub fn new(file_name: impl AsRef<str>, dev_mode: bool, prefix: Option<String>) -> Self {
     Self {
       postfix_counters: FxHashMap::default(),
-      file_name,
+      file_name: file_name.as_ref().into(),
       file_name_hash: None,
       dev_mode,
       prefix: prefix.unwrap_or_else(|| {
         if dev_mode {
           // In dev mode we don't prefix by default as it already uses long unique names
-          String::from("")
+          "".into()
         } else {
-          String::from("y")
+          "y".into()
         }
       }),
     }
@@ -156,23 +156,23 @@ mod tests {
 
   #[test]
   fn css_naming_convention() {
-    let mut convention = NamingConvention::new("file.css".into(), true, None);
+    let mut convention = NamingConvention::new("file.css", true, None);
     assert_eq!(convention.generate_unique_name("foo"), "foo");
     assert_eq!(convention.generate_unique_name("foo"), "foo-01");
     assert_eq!(convention.generate_unique_name("foo"), "foo-02");
   }
 
   #[test]
   fn css_variable_name() {
-    let mut convention = NamingConvention::new("file.css".into(), false, None);
+    let mut convention = NamingConvention::new("file.css", false, None);
     assert_eq!(convention.get_css_variable_name("foo"), "yoPBkbU");
     assert_eq!(convention.get_css_variable_name("foo"), "yoPBkbU1");
     assert_eq!(convention.get_css_variable_name(""), "yoPBkbU2");
   }
 
   #[test]
   fn css_variable_name_dev_mode() {
-    let mut convention = NamingConvention::new("file.css".into(), true, None);
+    let mut convention = NamingConvention::new("file.css", true, None);
     assert_eq!(convention.get_css_variable_name("foo"), "foo_oPBkbU");
     assert_eq!(convention.get_css_variable_name("foo"), "foo_oPBkbU-01");
     assert_eq!(convention.get_css_variable_name(""), "var_oPBkbU");

packages/yak-swc/yak_swc/src/utils/add_suffix_to_expr.rs

@@ -5,7 +5,7 @@ use swc_core::{
 
 /// Adds a suffix to an expression
 /// e.g: `({$foo}) => $foo` -> __yak_add_suffix_to_expr(({$foo}) => $foo, "-suffix")
-pub fn add_suffix_to_expr(expr: Expr, helper: Ident, suffix: String) -> Expr {
+pub fn add_suffix_to_expr(expr: Expr, helper: Ident, suffix: impl AsRef<str>) -> Expr {
   // Otherwise, replace the expression with a call to the utility function
   Expr::Call(CallExpr {
     span: DUMMY_SP,
@@ -15,7 +15,7 @@ pub fn add_suffix_to_expr(expr: Expr, helper: Ident, suffix: String) -> Expr {
       expr.into(),
       Expr::Lit(Lit::Str(Str {
         span: DUMMY_SP,
-        value: suffix.into(),
+        value: suffix.as_ref().into(),
         raw: None,
       }))
       .into(),

packages/yak-swc/yak_swc/src/utils/ast_helper.rs

@@ -64,24 +64,26 @@ pub fn member_expr_to_strings(member_expr: &MemberExpr) -> Option<(Ident, Vec<At
 }
 
 /// String to MemberProp
-pub fn create_member_prop_from_string(s: String) -> MemberProp {
+pub fn create_member_prop_from_string(s: impl AsRef<str>) -> MemberProp {
   // if the string contains characters that are not allowed in an identifier
   // "with space" -> foo["with space"]
-  if s.contains(|c: char| !c.is_alphanumeric() && c != '_' && c != '$')
-    || s.starts_with(|c: char| c.is_ascii_digit())
+  if s
+    .as_ref()
+    .contains(|c: char| !c.is_alphanumeric() && c != '_' && c != '$')
+    || s.as_ref().starts_with(|c: char| c.is_ascii_digit())
   {
     MemberProp::Computed(ComputedPropName {
       span: DUMMY_SP,
       expr: Box::new(Expr::Lit(Lit::Str(Str {
         span: DUMMY_SP,
-        value: s.into(),
+        value: s.as_ref().into(),
         raw: None,
       }))),
     })
   }
   // otherwise "bar" -> foo.bar
   else {
-    MemberProp::Ident(IdentName::new(s.into(), DUMMY_SP))
+    MemberProp::Ident(IdentName::new(s.as_ref().into(), DUMMY_SP))
   }
 }
 

packages/yak-swc/yak_swc/src/yak_imports.rs

@@ -124,14 +124,14 @@ impl YakImports {
   }
 
   /// Returns the utility function identifier
-  pub fn get_yak_utility_ident(&mut self, name: String) -> Ident {
-    if !UTILITIES.contains(&name.as_str()) {
-      panic!("Utility function not found: {}", name);
+  pub fn get_yak_utility_ident(&mut self, name: impl AsRef<str>) -> Ident {
+    if !UTILITIES.contains(&name.as_ref()) {
+      panic!("Utility function not found: {}", name.as_ref());
     }
-    if let Some(ident) = self.yak_utilities.get(&name) {
+    if let Some(ident) = self.yak_utilities.get(name.as_ref()) {
       ident.clone()
     } else {
-      let prefixed_name = format!("__yak_{}", name);
+      let prefixed_name = format!("__yak_{}", name.as_ref());
       let ident = Ident::from(prefixed_name.clone());
       self.yak_utilities.insert(prefixed_name, ident.clone());
       ident
@@ -361,9 +361,9 @@ mod tests {
   fn test_yak_import_visitor_utility_ident() {
     let visitor = YakImportVisitor::new();
     let mut imports: YakImports = visitor.into();
-    let ident = imports.get_yak_utility_ident("unitPostFix".to_string());
+    let ident = imports.get_yak_utility_ident("unitPostFix");
     assert_eq!(ident.sym, "__yak_unitPostFix");
-    let ident = imports.get_yak_utility_ident("mergeCssProp".to_string());
+    let ident = imports.get_yak_utility_ident("mergeCssProp");
     assert_eq!(ident.sym, "__yak_mergeCssProp");
   }
 }