feat(compiler): add resolveStarExports option

Author: ije

compiler/mod.ts

@@ -34,6 +34,7 @@ export type TransformOptions = {
   sourceMap?: boolean
   isDev?: boolean
   transpileOnly?: boolean
+  resolveStarExports?: boolean
   bundleMode?: boolean
   bundleExternal?: string[]
   // loaders for inline styles transform
@@ -43,8 +44,8 @@ export type TransformOptions = {
 export type TransformResult = {
   code: string
   deps: DependencyDescriptor[]
-  bundleStarExports?: string[]
-  map?: string
+  starExports: string[] | null
+  map: string | null
 }
 
 type InlineStyles = Record<string, { type: string, quasis: string[], exprs: string[] }>
@@ -121,7 +122,13 @@ export async function transform(url: string, code: string, options: TransformOpt
   }
 
   const { loaders, ...transformOptions } = options
-  let { code: jsContent, deps, map, inlineStyles, bundleStarExports } = transformSync(url, code, transformOptions)
+  let {
+    code: jsContent,
+    deps,
+    map,
+    inlineStyles,
+    starExports
+  } = transformSync(url, code, transformOptions)
 
   // resolve inline-style
   await Promise.all(Object.entries(inlineStyles as InlineStyles).map(async ([key, style]) => {
@@ -166,7 +173,7 @@ export async function transform(url: string, code: string, options: TransformOpt
     jsContent = jsContent.replace(`"%%${key}-placeholder%%"`, '`' + tpl + '`')
   }))
 
-  return { code: jsContent, deps, map, bundleStarExports }
+  return { code: jsContent, deps, map, starExports }
 }
 
 /* parse export names of the module */

compiler/src/fixer.rs

@@ -60,45 +60,20 @@ impl Fold for CompatFixer {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::swc::SWC;
-  use std::cmp::min;
-  use swc_common::Globals;
-
-  fn t(specifier: &str, source: &str, expect: &str) -> bool {
-    let module = SWC::parse(specifier, source, None).expect("could not parse module");
-    let (code, _) = swc_common::GLOBALS.set(&Globals::new(), || {
-      module
-        .apply_transform(compat_fixer_fold(), false)
-        .expect("could not transpile module")
-    });
-
-    if code != expect {
-      let mut p: usize = 0;
-      for i in 0..min(code.len(), expect.len()) {
-        if code.get(i..i + 1) != expect.get(i..i + 1) {
-          p = i;
-          break;
-        }
-      }
-      println!(
-        "{}\x1b[0;31m{}\x1b[0m",
-        code.get(0..p).unwrap(),
-        code.get(p..).unwrap()
-      );
-    }
-    code == expect
-  }
+  use crate::swc::t;
 
   #[test]
-  fn fast_refresh() {
-    let source = r#"require("regenerator-runtime")
-const { mark } = require("regenerator-runtime")
+  fn compat_fix() {
+    let source = r#"
+      require("regenerator-runtime")
+      const { mark } = require("regenerator-runtime")
     "#;
-    let expect = r#"(()=>window.regeneratorRuntime
+    let expect = r#"
+(()=>window.regeneratorRuntime
 )();
 const { mark  } = (()=>window.regeneratorRuntime
 )();
 "#;
-    assert!(t("/app.js", source, expect));
+    assert!(t("/app.js", source, compat_fixer_fold(), expect));
   }
 }

compiler/src/lib.rs

@@ -45,6 +45,9 @@ pub struct Options {
   #[serde(default)]
   pub transpile_only: bool,
 
+  #[serde(default)]
+  pub resolve_star_exports: bool,
+
   #[serde(default)]
   pub bundle_mode: bool,
 
@@ -99,7 +102,7 @@ pub struct TransformOutput {
   pub map: Option<String>,
   pub deps: Vec<DependencyDescriptor>,
   pub inline_styles: HashMap<String, InlineStyle>,
-  pub bundle_star_exports: Option<Vec<String>>,
+  pub star_exports: Option<Vec<String>>,
 }
 
 #[wasm_bindgen(js_name = "parseExportNamesSync")]
@@ -153,6 +156,7 @@ pub fn transform_sync(url: &str, code: &str, options: JsValue) -> Result<JsValue
         source_map: options.source_map,
         is_dev: options.is_dev,
         transpile_only: options.transpile_only,
+        resolve_star_exports: options.resolve_star_exports,
       },
     )
     .expect("could not transform module");
@@ -163,8 +167,8 @@ pub fn transform_sync(url: &str, code: &str, options: JsValue) -> Result<JsValue
       map,
       deps: r.dep_graph.clone(),
       inline_styles: r.inline_styles.clone(),
-      bundle_star_exports: if r.bundle_star_exports.len() > 0 {
-        Some(r.bundle_star_exports.clone())
+      star_exports: if r.star_exports.len() > 0 {
+        Some(r.star_exports.clone())
       } else {
         None
       },

compiler/src/resolve.rs

@@ -53,8 +53,8 @@ pub struct Resolver {
   pub bundle_mode: bool,
   /// bundled modules
   pub bundle_external: IndexSet<String>,
-  /// bundle star exports
-  pub bundle_star_exports: Vec<String>,
+  /// star exports
+  pub star_exports: Vec<String>,
   /// extra imports
   pub extra_imports: IndexSet<String>,
   /// builtin jsx tags like `a`, `link`, `head`, etc
@@ -84,7 +84,7 @@ impl Resolver {
       specifier_is_remote: is_remote_url(specifier),
       used_builtin_jsx_tags: IndexSet::new(),
       dep_graph: Vec::new(),
-      bundle_star_exports: Vec::new(),
+      star_exports: Vec::new(),
       inline_styles: HashMap::new(),
       import_map: ImportMap::from_hashmap(import_map),
       aleph_pkg_uri,

compiler/src/resolve_fold.rs

@@ -7,18 +7,24 @@ use swc_ecma_ast::*;
 use swc_ecma_utils::quote_ident;
 use swc_ecma_visit::{noop_fold_type, Fold, FoldWith};
 
-pub fn resolve_fold(resolver: Rc<RefCell<Resolver>>, source: Rc<SourceMap>) -> impl Fold {
+pub fn resolve_fold(
+  resolver: Rc<RefCell<Resolver>>,
+  source: Rc<SourceMap>,
+  resolve_star_exports: bool,
+) -> impl Fold {
   ResolveFold {
     deno_hooks_idx: 0,
     resolver,
     source,
+    resolve_star_exports,
   }
 }
 
 pub struct ResolveFold {
   deno_hooks_idx: i32,
   resolver: Rc<RefCell<Resolver>>,
   source: Rc<SourceMap>,
+  resolve_star_exports: bool,
 }
 
 impl ResolveFold {
@@ -208,7 +214,7 @@ impl Fold for ResolveFold {
               let mut resolver = self.resolver.borrow_mut();
               let (resolved_path, fixed_url) = resolver.resolve(src.value.as_ref(), false);
               if resolver.bundle_mode && resolver.bundle_external.contains(fixed_url.as_str()) {
-                resolver.bundle_star_exports.push(fixed_url.clone());
+                resolver.star_exports.push(fixed_url.clone());
                 ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                   span: DUMMY_SP,
                   decl: Decl::Var(VarDecl {
@@ -217,16 +223,25 @@ impl Fold for ResolveFold {
                     declare: false,
                     decls: vec![create_aleph_pack_var_decl(
                       fixed_url.as_ref(),
-                      quote_ident!(format!("$$star_{}", resolver.bundle_star_exports.len() - 1)),
+                      quote_ident!(format!("$$star_{}", resolver.star_exports.len() - 1)),
                     )],
                   }),
                 }))
               } else {
-                ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ExportAll {
-                  span: DUMMY_SP,
-                  src: new_str(resolved_path.into()),
-                  asserts: None,
-                }))
+                if self.resolve_star_exports {
+                  resolver.star_exports.push(fixed_url.clone());
+                  ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ExportAll {
+                    span: DUMMY_SP,
+                    src: new_str(fixed_url.into()),
+                    asserts: None,
+                  }))
+                } else {
+                  ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ExportAll {
+                    span: DUMMY_SP,
+                    src: new_str(resolved_path.into()),
+                    asserts: None,
+                  }))
+                }
               }
             }
             _ => ModuleItem::ModuleDecl(decl),

compiler/src/swc.rs

@@ -7,7 +7,7 @@ use crate::resolve::Resolver;
 use crate::resolve_fold::{resolve_fold, ExportsParser};
 use crate::source_type::SourceType;
 
-use std::{cell::RefCell, path::Path, rc::Rc};
+use std::{cell::RefCell, cmp::min, path::Path, rc::Rc};
 use swc_common::{
   chain,
   comments::SingleThreadedComments,
@@ -33,6 +33,7 @@ pub struct EmitOptions {
   pub jsx_fragment_factory: String,
   pub is_dev: bool,
   pub transpile_only: bool,
+  pub resolve_star_exports: bool,
   pub source_map: bool,
 }
 
@@ -44,6 +45,7 @@ impl Default for EmitOptions {
       jsx_fragment_factory: "React.Fragment".into(),
       is_dev: false,
       transpile_only: false,
+      resolve_star_exports: false,
       source_map: false,
     }
   }
@@ -147,7 +149,11 @@ impl SWC {
       let root_mark = Mark::fresh(Mark::root());
       let mut passes = chain!(
         Optional::new(
-          resolve_fold(resolver.clone(), self.source_map.clone()),
+          resolve_fold(
+            resolver.clone(),
+            self.source_map.clone(),
+            options.resolve_star_exports,
+          ),
           !transpile_only
         ),
         Optional::new(aleph_jsx_fold, is_jsx && !transpile_only),
@@ -298,6 +304,33 @@ fn get_syntax(source_type: &SourceType) -> Syntax {
   }
 }
 
+#[allow(dead_code)]
+pub fn t<T: Fold>(specifier: &str, source: &str, tr: T, expect: &str) -> bool {
+  let module = SWC::parse(specifier, source, None).expect("could not parse module");
+  let (code, _) = swc_common::GLOBALS.set(&Globals::new(), || {
+    module
+      .apply_transform(tr, false)
+      .expect("could not transpile module")
+  });
+  let matched = code.as_str().trim().eq(expect.trim());
+
+  if !matched {
+    let mut p: usize = 0;
+    for i in 0..min(code.len(), expect.len()) {
+      if code.get(i..i + 1) != expect.get(i..i + 1) {
+        p = i;
+        break;
+      }
+    }
+    println!(
+      "{}\x1b[0;31m{}\x1b[0m",
+      code.get(0..p).unwrap(),
+      code.get(p..).unwrap()
+    );
+  }
+  matched
+}
+
 #[allow(dead_code)]
 pub fn st(specifer: &str, source: &str, bundling: bool) -> (String, Rc<RefCell<Resolver>>) {
   let module = SWC::parse(specifer, source, None).expect("could not parse module");