refactor(compiler): rewrite useDeno/inline-style signature

Author: ije

compiler/src/jsx.rs

@@ -6,7 +6,7 @@ use crate::resolve::{
 };
 
 use path_slash::PathBufExt;
-use rand::{distributions::Alphanumeric, Rng};
+use sha1::{Digest, Sha1};
 use std::{cell::RefCell, path::PathBuf, rc::Rc};
 use swc_common::{SourceMap, Spanned, DUMMY_SP};
 use swc_ecma_ast::*;
@@ -22,6 +22,7 @@ pub fn aleph_jsx_fold(
         AlephJsxFold {
             resolver: resolver.clone(),
             source,
+            inline_style_idx: 0,
             is_dev,
         },
         AlephJsxBuiltinModuleResolveFold {
@@ -42,27 +43,41 @@ pub fn aleph_jsx_fold(
 struct AlephJsxFold {
     resolver: Rc<RefCell<Resolver>>,
     source: Rc<SourceMap>,
+    inline_style_idx: i32,
     is_dev: bool,
 }
 
 impl AlephJsxFold {
+    fn new_inline_style_ident(&mut self) -> String {
+        let resolver = self.resolver.borrow_mut();
+        self.inline_style_idx = self.inline_style_idx + 1;
+        let path = format!("{}-{}", resolver.specifier, self.inline_style_idx);
+        let mut ident: String = "inline-style-".to_owned();
+        let mut hasher = Sha1::new();
+        hasher.update(path.as_bytes());
+        let hash = hasher.finalize();
+        ident.push_str(format!("{:x}", hash).as_str());
+        ident
+    }
+
     fn fold_jsx_opening_element(
         &mut self,
         mut el: JSXOpeningElement,
     ) -> (JSXOpeningElement, Option<(String, String)>) {
-        let mut resolver = self.resolver.borrow_mut();
         let mut inline_style: Option<(String, String)> = None;
 
         match &el.name {
             JSXElementName::Ident(id) => {
                 let name = id.sym.as_ref();
                 match name {
                     "head" | "script" => {
+                        let mut resolver = self.resolver.borrow_mut();
                         resolver.builtin_jsx_tags.insert(name.into());
                         el.name = JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                     }
 
                     "a" => {
+                        let mut resolver = self.resolver.borrow_mut();
                         let mut should_replace = true;
 
                         for attr in &el.attrs {
@@ -143,6 +158,7 @@ impl AlephJsxFold {
                                 };
                             }
 
+                            let mut resolver = self.resolver.borrow_mut();
                             let (resolved_path, fixed_url) =
                                 resolver.resolve(href_prop_value, true);
 
@@ -229,7 +245,7 @@ impl AlephJsxFold {
                             };
                         }
 
-                        let id = new_inline_style_ident();
+                        let id = self.new_inline_style_ident();
                         let id_attr = JSXAttrOrSpread::JSXAttr(JSXAttr {
                             span: DUMMY_SP,
                             name: JSXAttrName::Ident(quote_ident!("__styleId")),
@@ -246,11 +262,11 @@ impl AlephJsxFold {
                             el.attrs.push(id_attr);
                         }
 
+                        let mut resolver = self.resolver.borrow_mut();
                         resolver.dep_graph.push(DependencyDescriptor {
                             specifier: "#".to_owned() + id.as_str(),
                             is_dynamic: false,
                         });
-
                         resolver.builtin_jsx_tags.insert(name.into());
                         el.name = JSXElementName::Ident(quote_ident!(rename_builtin_tag(name)));
                         inline_style = Some((type_prop_value, id.into()));
@@ -268,6 +284,7 @@ impl AlephJsxFold {
 
         // copy from https://github.com/swc-project/swc/blob/master/ecmascript/transforms/src/react/jsx_src.rs
         if self.is_dev {
+            let resolver = self.resolver.borrow_mut();
             match self.source.span_to_lines(el.span) {
                 Ok(file_lines) => {
                     el.attrs.push(JSXAttrOrSpread::JSXAttr(JSXAttr {
@@ -463,14 +480,3 @@ fn rename_builtin_tag(name: &str) -> String {
     }
     "__ALEPH_".to_owned() + name.as_str()
 }
-
-fn new_inline_style_ident() -> String {
-    let mut ident: String = "inline-style-".to_owned();
-    let rand_id = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(9)
-        .map(char::from)
-        .collect::<String>();
-    ident.push_str(rand_id.as_str());
-    return ident;
-}

compiler/src/resolve.rs

@@ -6,10 +6,10 @@ use crate::import_map::{ImportHashMap, ImportMap};
 use indexmap::IndexSet;
 use path_slash::PathBufExt;
 use pathdiff::diff_paths;
-use rand::{distributions::Alphanumeric, Rng};
 use regex::Regex;
 use relative_path::RelativePath;
 use serde::Serialize;
+use sha1::{Digest, Sha1};
 use std::{
   cell::RefCell,
   collections::HashMap,
@@ -359,13 +359,31 @@ impl Resolver {
 }
 
 pub fn aleph_resolve_fold(resolver: Rc<RefCell<Resolver>>) -> impl Fold {
-  AlephResolveFold { resolver }
+  AlephResolveFold {
+    deno_hooks_idx: 0,
+    resolver,
+  }
 }
 
 pub struct AlephResolveFold {
+  deno_hooks_idx: i32,
   resolver: Rc<RefCell<Resolver>>,
 }
 
+impl AlephResolveFold {
+  fn new_use_deno_hook_ident(&mut self) -> String {
+    let resolver = self.resolver.borrow_mut();
+    self.deno_hooks_idx = self.deno_hooks_idx + 1;
+    let path = format!("{}-{}", resolver.specifier, self.deno_hooks_idx);
+    let mut ident: String = "useDeno-".to_owned();
+    let mut hasher = Sha1::new();
+    hasher.update(path.as_bytes());
+    let hash = hasher.finalize();
+    ident.push_str(format!("{:x}", hash).as_str());
+    ident
+  }
+}
+
 impl Fold for AlephResolveFold {
   noop_fold_type!();
 
@@ -623,7 +641,6 @@ impl Fold for AlephResolveFold {
   // - `import("https://esm.sh/rect")` -> `import("/-/esm.sh/react.js")`
   // - `useDeno(() => {})` -> `useDeno(() => {}, false, "useDeno.RANDOM_KEY")`
   fn fold_call_expr(&mut self, mut call: CallExpr) -> CallExpr {
-    let mut resolver = self.resolver.borrow_mut();
     if is_call_expr_by_name(&call, "import") {
       let url = match call.args.first() {
         Some(ExprOrSpread { expr, .. }) => match expr.as_ref() {
@@ -635,6 +652,7 @@ impl Fold for AlephResolveFold {
         },
         _ => return call,
       };
+      let mut resolver = self.resolver.borrow_mut();
       call.args = vec![ExprOrSpread {
         spread: None,
         expr: Box::new(Expr::Lit(Lit::Str(new_js_str(
@@ -651,7 +669,7 @@ impl Fold for AlephResolveFold {
         _ => false,
       };
       if has_callback {
-        let id = new_use_deno_hook_ident();
+        let id = self.new_use_deno_hook_ident();
         if call.args.len() == 1 {
           call.args.push(ExprOrSpread {
             spread: None,
@@ -672,6 +690,7 @@ impl Fold for AlephResolveFold {
             expr: Box::new(Expr::Lit(Lit::Str(new_js_str(id.clone())))),
           });
         }
+        let mut resolver = self.resolver.borrow_mut();
         resolver.dep_graph.push(DependencyDescriptor {
           specifier: "#".to_owned() + id.clone().as_str(),
           is_dynamic: false,
@@ -698,17 +717,6 @@ pub fn is_call_expr_by_name(call: &CallExpr, name: &str) -> bool {
   }
 }
 
-fn new_use_deno_hook_ident() -> String {
-  let mut ident: String = "useDeno-".to_owned();
-  let rand_id = rand::thread_rng()
-    .sample_iter(&Alphanumeric)
-    .take(9)
-    .map(char::from)
-    .collect::<String>();
-  ident.push_str(rand_id.as_str());
-  ident
-}
-
 pub fn create_aleph_pack_var_decl(ident: Ident, url: &str, prop: Option<&str>) -> VarDeclarator {
   let m = Expr::Member(MemberExpr {
     span: DUMMY_SP,