Revert client transfomer

Author: ije

compiler/dist/wasm.js

@@ -15,6 +15,7 @@ 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};
@@ -37,6 +38,12 @@ 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,
 
@@ -96,7 +103,16 @@ pub fn parse_deps(specifier: &str, code: &str, options: JsValue) -> Result<JsVal
   .expect("could not pause the import map")
   .import_map;
   let resolver = Rc::new(RefCell::new(Resolver::new(
-    specifier, "", None, None, None, importmap, false, false,
+    specifier,
+    "",
+    None,
+    None,
+    None,
+    importmap,
+    HashMap::new(),
+    None,
+    false,
+    false,
   )));
   let module = SWC::parse(specifier, code, EsVersion::Es2022, options.lang).expect("could not parse the module");
   let deps = module.parse_deps(resolver).expect("could not parse the module");
@@ -125,6 +141,8 @@ 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

@@ -1,20 +1,26 @@
 use crate::resolver::Resolver;
 use crate::swc_helpers::{is_call_expr_by_name, new_str};
 use std::{cell::RefCell, rc::Rc};
-use swc_common::DUMMY_SP;
+use swc_common::{Span, DUMMY_SP};
 use swc_ecmascript::ast::*;
 use swc_ecmascript::visit::{noop_fold_type, Fold, FoldWith};
 
-pub fn resolve_fold(resolver: Rc<RefCell<Resolver>>, strip_data_export: bool) -> impl Fold {
+pub fn resolve_fold(
+  resolver: Rc<RefCell<Resolver>>,
+  strip_data_export: bool,
+  mark_import_src_location: bool,
+) -> impl Fold {
   ResolveFold {
     resolver,
     strip_data_export,
+    mark_import_src_location,
   }
 }
 
 pub struct ResolveFold {
   resolver: Rc<RefCell<Resolver>>,
   strip_data_export: bool,
+  mark_import_src_location: bool,
 }
 
 impl Fold for ResolveFold {
@@ -35,7 +41,11 @@ 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(), &import_decl.src.span, false);
+                let resolved_url = resolver.resolve(
+                  import_decl.src.value.as_ref(),
+                  false,
+                  mark_span(&import_decl.src.span, self.mark_import_src_location),
+                );
                 ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
                   src: new_str(&resolved_url),
                   ..import_decl
@@ -62,7 +72,11 @@ impl Fold for ResolveFold {
                 }))
               } else {
                 let mut resolver = self.resolver.borrow_mut();
-                let resolved_url = resolver.resolve(src.value.as_ref(), &src.span, false);
+                let resolved_url = resolver.resolve(
+                  src.value.as_ref(),
+                  false,
+                  mark_span(&src.span, self.mark_import_src_location),
+                );
                 ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {
                   span,
                   specifiers,
@@ -75,7 +89,11 @@ 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(), &src.span, false);
+              let resolved_url = resolver.resolve(
+                src.value.as_ref(),
+                false,
+                mark_span(&src.span, self.mark_import_src_location),
+              );
               ModuleItem::ModuleDecl(ModuleDecl::ExportAll(ExportAll {
                 span,
                 src: new_str(&resolved_url),
@@ -167,7 +185,11 @@ impl Fold for ResolveFold {
         };
         if let Some(src) = src {
           let mut resolver = self.resolver.borrow_mut();
-          let new_src = resolver.resolve(src.value.as_ref(), &src.span, true);
+          let new_src = resolver.resolve(
+            src.value.as_ref(),
+            true,
+            mark_span(&src.span, self.mark_import_src_location),
+          );
 
           args[0] = ExprOrSpread {
             spread: None,
@@ -195,7 +217,11 @@ impl Fold for ResolveFold {
       };
       if let Some(src) = src {
         let mut resolver = self.resolver.borrow_mut();
-        let new_src = resolver.resolve(src.value.as_ref(), &src.span, true);
+        let new_src = resolver.resolve(
+          src.value.as_ref(),
+          true,
+          mark_span(&src.span, self.mark_import_src_location),
+        );
 
         call.args[0] = ExprOrSpread {
           spread: None,
@@ -207,3 +233,11 @@ impl Fold for ResolveFold {
     call.fold_children_with(self)
   }
 }
+
+fn mark_span(span: &Span, ok: bool) -> Option<Span> {
+  if ok {
+    Some(span.clone())
+  } else {
+    None
+  }
+}

compiler/src/resolve_fold.rs

@@ -4,6 +4,7 @@ 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;
@@ -20,7 +21,8 @@ lazy_static! {
 pub struct DependencyDescriptor {
   pub specifier: String,
   pub import_url: String,
-  pub loc: Span,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub loc: Option<Span>,
   #[serde(skip_serializing_if = "is_false")]
   pub dynamic: bool,
 }
@@ -46,6 +48,8 @@ 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)]
@@ -64,6 +68,8 @@ 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 {
@@ -77,6 +83,8 @@ impl Resolver {
       jsx_runtime_cdn_version,
       jsx_static_classes: IndexSet::new(),
       import_map,
+      graph_versions,
+      initial_graph_version,
       is_dev,
       resolve_remote_deps,
     }
@@ -120,7 +128,7 @@ impl Resolver {
   }
 
   /// Resolve import/export URLs.
-  pub fn resolve(&mut self, url: &str, span: &Span, dynamic: bool) -> String {
+  pub fn resolve(&mut self, url: &str, dynamic: bool, loc: Option<Span>) -> String {
     let referrer = if self.specifier_is_remote {
       Url::from_str(self.specifier.as_str()).unwrap()
     } else {
@@ -208,16 +216,32 @@ impl Resolver {
       }
     }
 
-    // fix remote url to local path if allowed
-    if is_remote && self.resolve_remote_deps {
-      import_url = self.to_local_path(&import_url);
+    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);
+        }
+      }
     }
 
     // update dep graph
     self.deps.push(DependencyDescriptor {
       specifier: fixed_url.clone(),
-      loc: span.clone(),
       import_url: import_url.clone(),
+      loc,
       dynamic,
     });
 

compiler/src/resolver.rs

@@ -7,7 +7,7 @@ use crate::resolver::{DependencyDescriptor, Resolver};
 use std::{cell::RefCell, path::Path, rc::Rc};
 use swc_common::comments::SingleThreadedComments;
 use swc_common::errors::{Handler, HandlerFlags};
-use swc_common::{chain, FileName, Globals, Mark, SourceMap, DUMMY_SP};
+use swc_common::{chain, FileName, Globals, Mark, SourceMap};
 use swc_ecma_transforms::proposals::decorators;
 use swc_ecma_transforms::react;
 use swc_ecma_transforms::typescript::strip;
@@ -93,7 +93,7 @@ impl SWC {
   /// parse deps in the module.
   pub fn parse_deps(&self, resolver: Rc<RefCell<Resolver>>) -> Result<Vec<DependencyDescriptor>, anyhow::Error> {
     let program = Program::Module(self.module.clone());
-    let mut resolve_fold = resolve_fold(resolver.clone(), false);
+    let mut resolve_fold = resolve_fold(resolver.clone(), false, true);
     program.fold_with(&mut resolve_fold);
     let resolver = resolver.borrow();
     Ok(resolver.deps.clone())
@@ -114,7 +114,7 @@ impl SWC {
       let react_options = if let Some(jsx_import_source) = &options.jsx_import_source {
         let mut resolver = resolver.borrow_mut();
         let runtime = if is_dev { "/jsx-dev-runtime" } else { "/jsx-runtime" };
-        let import_source = resolver.resolve(&(jsx_import_source.to_owned() + runtime), &DUMMY_SP, false);
+        let import_source = resolver.resolve(&(jsx_import_source.to_owned() + runtime), false, None);
         let import_source = import_source
           .strip_suffix("?dev")
           .unwrap_or(&import_source)
@@ -148,7 +148,7 @@ impl SWC {
       let passes = chain!(
         resolver_with_mark(top_level_mark),
         Optional::new(react::jsx_src(is_dev, self.source_map.clone()), is_jsx),
-        resolve_fold(resolver.clone(), options.strip_data_export),
+        resolve_fold(resolver.clone(), options.strip_data_export, false),
         decorators::decorators(decorators::Config {
           legacy: true,
           emit_metadata: false

compiler/src/swc.rs

@@ -1,4 +1,5 @@
 use super::*;
+use std::collections::HashMap;
 
 fn transform(specifer: &str, source: &str, is_dev: bool, options: &EmitOptions) -> (String, Rc<RefCell<Resolver>>) {
   let importmap = import_map::parse_from_json(
@@ -12,6 +13,8 @@ fn transform(specifer: &str, source: &str, is_dev: bool, options: &EmitOptions)
   )
   .expect("could not pause the import map")
   .import_map;
+  let mut graph_versions: HashMap<String, String> = HashMap::new();
+  graph_versions.insert("./foo.ts".into(), "100".into());
   let module =
     SWC::parse(specifer, source, swc_ecmascript::ast::EsVersion::Es2022, None).expect("could not parse module");
   let resolver = Rc::new(RefCell::new(Resolver::new(
@@ -21,6 +24,8 @@ fn transform(specifer: &str, source: &str, is_dev: bool, options: &EmitOptions)
     Some("17.0.2".into()),
     Some("64".into()),
     importmap,
+    graph_versions,
+    None,
     is_dev,
     true,
   )));
@@ -86,7 +91,7 @@ fn import_resolving() {
   let (code, _) = transform("./pages/blog/$id.tsx", source, false, &EmitOptions::default());
   assert!(code.contains("\"/-/esm.sh/[email protected]\""));
   assert!(code.contains("\"/-/cdn.esm.sh/v64/[email protected]\""));
-  assert!(code.contains("\"../../foo.ts\""));
+  assert!(code.contains("\"../../foo.ts?v=100\""));
   assert!(code.contains("\"./Layout.tsx\""));
   assert!(code.contains("\"/-/esm.sh/@fullcalendar/daygrid?css&dev&module\""));
   assert!(code.contains("\"../../style/app.css?module\""));

compiler/src/tests.rs

@@ -1,6 +1,8 @@
 export type TransformOptions = {
   alephPkgUri?: string;
   importMap?: string;
+  graphVersions?: Record<string, string>;
+  initialGraphVersion?: string;
   isDev?: boolean;
   jsxImportSource?: string;
   jsxRuntime?: "react" | "preact";
@@ -20,7 +22,7 @@ export type TransformResult = {
 export type DependencyDescriptor = {
   readonly specifier: string;
   readonly importUrl: string;
-  readonly loc: { start: number; end: number; ctxt: number };
+  readonly loc?: { start: number; end: number; ctxt: number };
   readonly dynamic?: boolean;
 };
 

compiler/types.ts

@@ -67,14 +67,16 @@ const esModuleLoader = async (input: { pathname: string } & ModuleLoaderContent,
       const s = new MagicString(rawCode);
       locDeps.forEach((dep) => {
         const { specifier, importUrl, loc } = dep;
-        const versionStr = serverDependencyGraph.get(specifier)?.version || serverDependencyGraph.initialVersion;
-        let url = importUrl;
-        if (url.includes("?")) {
-          url = `"${url}&v=${versionStr}"`;
-        } else {
-          url = `"${url}?v=${versionStr}"`;
+        if (loc) {
+          const versionStr = serverDependencyGraph.get(specifier)?.version || serverDependencyGraph.initialVersion;
+          let url = importUrl;
+          if (url.includes("?")) {
+            url = `"${url}&v=${versionStr}"`;
+          } else {
+            url = `"${url}?v=${versionStr}"`;
+          }
+          s.overwrite(loc.start, loc.end, url);
         }
-        s.overwrite(loc.start, loc.end, url);
       });
       return { content: s.toString(), contentType };
     }