Imporove compiler

Author: ije

compiler/dist/compiler.js

@@ -112,17 +112,16 @@ function addHeapObject(obj) {
 /**
  * @param {string} specifier
  * @param {string} code
- * @param {any} options
  * @returns {any}
  */
-export function fastTransform(specifier, code, options) {
+export function parseExportNames(specifier, code) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
     const ptr0 = passStringToWasm0(specifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    wasm.fastTransform(retptr, ptr0, len0, ptr1, len1, addHeapObject(options));
+    wasm.parseExportNames(retptr, ptr0, len0, ptr1, len1);
     var r0 = getInt32Memory0()[retptr / 4 + 0];
     var r1 = getInt32Memory0()[retptr / 4 + 1];
     var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -138,16 +137,17 @@ export function fastTransform(specifier, code, options) {
 /**
  * @param {string} specifier
  * @param {string} code
+ * @param {any} options
  * @returns {any}
  */
-export function parseExportNames(specifier, code) {
+export function parseDeps(specifier, code, options) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
     const ptr0 = passStringToWasm0(specifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    wasm.parseExportNames(retptr, ptr0, len0, ptr1, len1);
+    wasm.parseDeps(retptr, ptr0, len0, ptr1, len1, addHeapObject(options));
     var r0 = getInt32Memory0()[retptr / 4 + 0];
     var r1 = getInt32Memory0()[retptr / 4 + 1];
     var r2 = getInt32Memory0()[retptr / 4 + 2];

compiler/dist/wasm.js

@@ -3,14 +3,14 @@ import { dirname, join } from "https://deno.land/[email protected]/path/mod.ts";
 import { existsFile } from "../lib/fs.ts";
 import { isCanary, VERSION } from "../version.ts";
 import init, {
-  fastTransform as fastSWC,
-  parseExportNames as parseExportNamesSWC,
-  transform as swc,
+  parseDeps as parseDepsWasmFn,
+  parseExportNames as parseExportNamesWasmFn,
+  transform as transformWasmFn,
   transformCSS as parcelCSS,
 } from "./dist/compiler.js";
 import decodeWasmData from "./dist/wasm.js";
 import {
-  FastTransformOptions,
+  DependencyDescriptor,
   TransformCSSOptions,
   TransformCSSResult,
   TransformOptions,
@@ -56,17 +56,17 @@ export async function parseExportNames(
   code: string,
 ): Promise<string[]> {
   await checkWasmReady();
-  return parseExportNamesSWC(specifier, code);
+  return parseExportNamesWasmFn(specifier, code);
 }
 
 /** fast transform without transpile code raw syntax */
-export async function fastTransform(
+export async function parseDeps(
   specifier: string,
   code: string,
-  options: FastTransformOptions = {},
-): Promise<TransformResult> {
+  options: Pick<TransformOptions, "importMap" | "lang"> = {},
+): Promise<DependencyDescriptor[]> {
   await checkWasmReady();
-  return fastSWC(specifier, code, options);
+  return parseDepsWasmFn(specifier, code, options);
 }
 
 /**
@@ -91,7 +91,7 @@ export async function transform(
   options: TransformOptions = {},
 ): Promise<TransformResult> {
   await checkWasmReady();
-  return swc(specifier, code, options);
+  return transformWasmFn(specifier, code, options);
 }
 
 /**

compiler/mod.ts

@@ -15,7 +15,6 @@ mod tests;
 
 use resolver::{DependencyDescriptor, Resolver};
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::str::FromStr;
 use std::{cell::RefCell, rc::Rc};
 use swc::{EmitOptions, SWC};
@@ -38,12 +37,6 @@ pub struct Options {
   #[serde(default)]
   pub import_map: Option<String>,
 
-  #[serde(default)]
-  pub graph_versions: HashMap<String, String>,
-
-  #[serde(default)]
-  pub initial_graph_version: Option<String>,
-
   #[serde(default = "default_target")]
   pub target: String,
 
@@ -78,8 +71,18 @@ pub struct TransformOutput {
   pub map: Option<String>,
 }
 
-#[wasm_bindgen(js_name = "fastTransform")]
-pub fn fast_transform(specifier: &str, code: &str, options: JsValue) -> Result<JsValue, JsValue> {
+#[wasm_bindgen(js_name = "parseExportNames")]
+pub fn parse_export_names(specifier: &str, code: &str) -> Result<JsValue, JsValue> {
+  console_error_panic_hook::set_once();
+
+  let module = SWC::parse(specifier, code, EsVersion::Es2022, None).expect("could not parse the module");
+  let names = module.parse_export_names().expect("could not parse the module");
+
+  Ok(JsValue::from_serde(&names).unwrap())
+}
+
+#[wasm_bindgen(js_name = "parseDeps")]
+pub fn parse_deps(specifier: &str, code: &str, options: JsValue) -> Result<JsValue, JsValue> {
   console_error_panic_hook::set_once();
 
   let options: Options = options
@@ -93,41 +96,12 @@ pub fn fast_transform(specifier: &str, code: &str, options: JsValue) -> Result<J
   .expect("could not pause the import map")
   .import_map;
   let resolver = Rc::new(RefCell::new(Resolver::new(
-    specifier,
-    "",
-    None,
-    None,
-    None,
-    importmap,
-    options.graph_versions,
-    options.initial_graph_version,
-    false,
-    false,
+    specifier, "", None, None, None, importmap, false, false,
   )));
   let module = SWC::parse(specifier, code, EsVersion::Es2022, options.lang).expect("could not parse the module");
-  let (code, map) = module
-    .fast_transform(resolver.clone())
-    .expect("could not transform the module");
-  let r = resolver.borrow();
+  let deps = module.parse_deps(resolver).expect("could not parse the module");
 
-  Ok(
-    JsValue::from_serde(&TransformOutput {
-      code,
-      deps: r.deps.clone(),
-      map,
-    })
-    .unwrap(),
-  )
-}
-
-#[wasm_bindgen(js_name = "parseExportNames")]
-pub fn parse_export_names(specifier: &str, code: &str) -> Result<JsValue, JsValue> {
-  console_error_panic_hook::set_once();
-
-  let module = SWC::parse(specifier, code, EsVersion::Es2022, None).expect("could not parse the module");
-  let names = module.parse_export_names().expect("could not parse the module");
-
-  Ok(JsValue::from_serde(&names).unwrap())
+  Ok(JsValue::from_serde(&deps).unwrap())
 }
 
 #[wasm_bindgen(js_name = "transform")]
@@ -151,8 +125,6 @@ pub fn transform(specifier: &str, code: &str, options: JsValue) -> Result<JsValu
     options.jsx_runtime_version,
     options.jsx_runtime_cdn_version,
     importmap,
-    options.graph_versions,
-    options.initial_graph_version,
     options.is_dev,
     true,
   )));

compiler/src/lib.rs

@@ -35,7 +35,7 @@ impl Fold for ResolveFold {
                 ModuleItem::ModuleDecl(ModuleDecl::Import(import_decl))
               } else {
                 let mut resolver = self.resolver.borrow_mut();
-                let resolved_url = resolver.resolve(import_decl.src.value.as_ref(), false);
+                let resolved_url = resolver.resolve(import_decl.src.value.as_ref(), &import_decl.src.span, false);
                 ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
                   src: new_str(&resolved_url),
                   ..import_decl
@@ -62,7 +62,7 @@ impl Fold for ResolveFold {
                 }))
               } else {
                 let mut resolver = self.resolver.borrow_mut();
-                let resolved_url = resolver.resolve(src.value.as_ref(), false);
+                let resolved_url = resolver.resolve(src.value.as_ref(), &src.span, false);
                 ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {
                   span,
                   specifiers,
@@ -75,7 +75,7 @@ impl Fold for ResolveFold {
             // match: export * from "https://esm.sh/react"
             ModuleDecl::ExportAll(ExportAll { src, span, asserts }) => {
               let mut resolver = self.resolver.borrow_mut();
-              let resolved_url = resolver.resolve(src.value.as_ref(), false);
+              let resolved_url = resolver.resolve(src.value.as_ref(), &src.span, false);
               ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ExportAll {
                 span,
                 src: new_str(&resolved_url),
@@ -154,23 +154,23 @@ impl Fold for ResolveFold {
     };
     if ok {
       if let Some(args) = &mut new_expr.args {
-        let url = match args.first() {
+        let src = match args.first() {
           Some(ExprOrSpread { expr, .. }) => match expr.as_ref() {
             Expr::Lit(lit) => match lit {
-              Lit::Str(s) => Some(s.value.as_ref()),
+              Lit::Str(s) => Some(s),
               _ => None,
             },
             _ => None,
           },
           _ => None,
         };
-        if let Some(url) = url {
+        if let Some(src) = src {
           let mut resolver = self.resolver.borrow_mut();
-          let new_url = resolver.resolve(url, true);
+          let new_src = resolver.resolve(src.value.as_ref(), &src.span, true);
 
           args[0] = ExprOrSpread {
             spread: None,
-            expr: Box::new(Expr::Lit(Lit::Str(new_str(&new_url)))),
+            expr: Box::new(Expr::Lit(Lit::Str(new_str(&new_src)))),
           }
         }
       }
@@ -182,23 +182,23 @@ impl Fold for ResolveFold {
   // fold&resolve dynamic import url
   fn fold_call_expr(&mut self, mut call: CallExpr) -> CallExpr {
     if is_call_expr_by_name(&call, "import") {
-      let url = match call.args.first() {
+      let src = match call.args.first() {
         Some(ExprOrSpread { expr, .. }) => match expr.as_ref() {
           Expr::Lit(lit) => match lit {
-            Lit::Str(s) => Some(s.value.as_ref()),
+            Lit::Str(s) => Some(s),
             _ => None,
           },
           _ => None,
         },
         _ => None,
       };
-      if let Some(url) = url {
+      if let Some(src) = src {
         let mut resolver = self.resolver.borrow_mut();
-        let new_url = resolver.resolve(url, true);
+        let new_src = resolver.resolve(src.value.as_ref(), &src.span, true);
 
         call.args[0] = ExprOrSpread {
           spread: None,
-          expr: Box::new(Expr::Lit(Lit::Str(new_str(&new_url)))),
+          expr: Box::new(Expr::Lit(Lit::Str(new_str(&new_src)))),
         }
       }
     }

compiler/src/resolve_fold.rs

@@ -4,9 +4,9 @@ use path_slash::PathBufExt;
 use pathdiff::diff_paths;
 use regex::Regex;
 use serde::Serialize;
-use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use swc_common::Span;
 use url::Url;
 
 lazy_static! {
@@ -19,8 +19,8 @@ lazy_static! {
 #[serde(rename_all = "camelCase")]
 pub struct DependencyDescriptor {
   pub specifier: String,
-  #[serde(skip)]
   pub import_url: String,
+  pub loc: Span,
   #[serde(skip_serializing_if = "is_false")]
   pub dynamic: bool,
 }
@@ -46,8 +46,6 @@ pub struct Resolver {
   resolve_remote_deps: bool,
   jsx_runtime_version: Option<String>,
   jsx_runtime_cdn_version: Option<String>,
-  graph_versions: HashMap<String, String>,
-  initial_graph_version: Option<String>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
@@ -66,8 +64,6 @@ impl Resolver {
     jsx_runtime_version: Option<String>,
     jsx_runtime_cdn_version: Option<String>,
     import_map: ImportMap,
-    graph_versions: HashMap<String, String>,
-    initial_graph_version: Option<String>,
     is_dev: bool,
     resolve_remote_deps: bool,
   ) -> Self {
@@ -81,8 +77,6 @@ impl Resolver {
       jsx_runtime_cdn_version,
       jsx_static_classes: IndexSet::new(),
       import_map,
-      graph_versions,
-      initial_graph_version,
       is_dev,
       resolve_remote_deps,
     }
@@ -126,7 +120,7 @@ impl Resolver {
   }
 
   /// Resolve import/export URLs.
-  pub fn resolve(&mut self, url: &str, dynamic: bool) -> String {
+  pub fn resolve(&mut self, url: &str, span: &Span, dynamic: bool) -> String {
     let referrer = if self.specifier_is_remote {
       Url::from_str(self.specifier.as_str()).unwrap()
     } else {
@@ -214,30 +208,15 @@ impl Resolver {
       }
     }
 
-    if is_remote {
-      // fix remote url to local path if allowed
-      if self.resolve_remote_deps {
-        import_url = self.to_local_path(&import_url);
-      }
-    } else {
-      // apply graph version if exists
-      let v = if self.graph_versions.contains_key(&fixed_url) {
-        self.graph_versions.get(&fixed_url)
-      } else {
-        self.initial_graph_version.as_ref()
-      };
-      if let Some(version) = v {
-        if import_url.contains("?") {
-          import_url = format!("{}&v={}", import_url, version);
-        } else {
-          import_url = format!("{}?v={}", import_url, version);
-        }
-      }
+    // fix remote url to local path if allowed
+    if is_remote && self.resolve_remote_deps {
+      import_url = self.to_local_path(&import_url);
     }
 
     // update dep graph
     self.deps.push(DependencyDescriptor {
       specifier: fixed_url.clone(),
+      loc: span.clone(),
       import_url: import_url.clone(),
       dynamic,
     });