Emit new URL('...', import.meta.url) for Wasm

Lots of bundlers now support `new URL('...path...', import.meta.url)` as an explicit signal to specify assets that should be bundled alongside JS.

This is already supported by default in Webpack v5, Parcel v2,Vite, Snowpack and WMR, and available via a plugin - https://modern-web.dev/docs/building/rollup-plugin-import-meta-assets/ - in Rollup as well.

Emitting such pattern by default would allow all those bundlers to automatically include Wasm and generate a correct URL for `--target web` builds without any work from the user's side.

Author: RReverser

crates/cli-support/src/js/mod.rs

@@ -611,14 +611,13 @@ impl<'a> Context<'a> {
         }
 
         let default_module_path = match self.config.mode {
-            OutputMode::Web => {
-                "\
-                    if (typeof input === 'undefined') {
-                        input = import.meta.url.replace(/\\.js$/, '_bg.wasm');
-                    }"
-            }
-            OutputMode::NoModules { .. } => {
+            OutputMode::Web => format!(
                 "\
+                    if (typeof input === 'undefined') {{
+                        input = new URL('{stem}_bg.wasm', import.meta.url);
+                    }}"
+            , stem = self.config.stem()?),
+            OutputMode::NoModules { .. } => "\
                     if (typeof input === 'undefined') {
                         let src;
                         if (typeof document === 'undefined') {
@@ -627,9 +626,8 @@ impl<'a> Context<'a> {
                             src = document.currentScript.src;
                         }
                         input = src.replace(/\\.js$/, '_bg.wasm');
-                    }"
-            }
-            _ => "",
+                    }".to_string(),
+            _ => "".to_string(),
         };
 
         let ts = self.ts_for_init_fn(has_memory, !default_module_path.is_empty())?;

crates/cli-support/src/lib.rs

@@ -286,12 +286,23 @@ impl Bindgen {
         self.generate_output()?.emit(path.as_ref())
     }
 
+    pub fn stem(&self) -> Result<&str, Error> {
+        Ok(match &self.input {
+            Input::None => bail!("must have an input by now"),
+            Input::Module(_, name) => name,
+            Input::Path(path) => match &self.out_name {
+                Some(name) => name,
+                None => path.file_stem().unwrap().to_str().unwrap(),
+            },
+        })
+    }
+
     pub fn generate_output(&mut self) -> Result<Output, Error> {
-        let (mut module, stem) = match self.input {
+        let mut module = match self.input {
             Input::None => bail!("must have an input by now"),
-            Input::Module(ref mut m, ref name) => {
+            Input::Module(ref mut m, _) => {
                 let blank_module = Module::default();
-                (mem::replace(m, blank_module), &name[..])
+                mem::replace(m, blank_module)
             }
             Input::Path(ref path) => {
                 let wasm = wit_text::parse_file(&path)
@@ -312,11 +323,7 @@ impl Bindgen {
                     .on_parse(wit_walrus::on_parse)
                     .parse(&wasm)
                     .context("failed to parse input file as wasm")?;
-                let stem = match &self.out_name {
-                    Some(name) => &name,
-                    None => path.file_stem().unwrap().to_str().unwrap(),
-                };
-                (module, stem)
+                module
             }
         };
 
@@ -409,6 +416,8 @@ impl Bindgen {
         // unnecessary things here.
         gc_module_and_adapters(&mut module);
 
+        let stem = self.stem()?;
+
         // We're ready for the final emission passes now. If we're in wasm
         // interface types mode then we execute the various passes there and
         // generate a valid interface typess section into the wasm module.