feat: Allow support for Wasm modules

core/examples/fs_module_loader.rs

@@ -1,12 +1,88 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use anyhow::anyhow;
 use anyhow::Context;
 use deno_core::anyhow::Error;
+use deno_core::v8;
+use deno_core::FastString;
 use deno_core::FsModuleLoader;
 use deno_core::JsRuntime;
+use deno_core::ModuleSourceCode;
 use deno_core::RuntimeOptions;
+use std::borrow::Cow;
+use std::collections::HashMap;
 use std::rc::Rc;
 
+fn custom_module_evaluation_cb(
+  scope: &mut v8::HandleScope,
+  module_type: Cow<'_, str>,
+  module_name: &FastString,
+  code: ModuleSourceCode,
+) -> Result<v8::Global<v8::Value>, Error> {
+  match &*module_type {
+    "bytes" => Ok(bytes_module(scope, code)),
+    "text" => text_module(scope, module_name, code),
+    "url" => Ok(url_module(scope, module_name)),
+    _ => Err(anyhow!(
+      "Can't import {:?} because of unknown module type {}",
+      module_name,
+      module_type
+    )),
+  }
+}
+
+fn bytes_module(
+  scope: &mut v8::HandleScope,
+  code: ModuleSourceCode,
+) -> v8::Global<v8::Value> {
+  // FsModuleLoader always returns bytes.
+  let ModuleSourceCode::Bytes(buf) = code else {
+    unreachable!()
+  };
+  let owned_buf = buf.to_vec();
+  let buf_len: usize = owned_buf.len();
+  let backing_store = v8::ArrayBuffer::new_backing_store_from_vec(owned_buf);
+  let backing_store_shared = backing_store.make_shared();
+  let ab = v8::ArrayBuffer::with_backing_store(scope, &backing_store_shared);
+  let uint8_array = v8::Uint8Array::new(scope, ab, 0, buf_len).unwrap();
+  let value: v8::Local<v8::Value> = uint8_array.into();
+  v8::Global::new(scope, value)
+}
+
+fn text_module(
+  scope: &mut v8::HandleScope,
+  module_name: &FastString,
+  code: ModuleSourceCode,
+) -> Result<v8::Global<v8::Value>, Error> {
+  // FsModuleLoader always returns bytes.
+  let ModuleSourceCode::Bytes(buf) = code else {
+    unreachable!()
+  };
+
+  let code = std::str::from_utf8(buf.as_bytes()).with_context(|| {
+    format!("Can't convert {:?} source code to string", module_name)
+  })?;
+  let str_ = v8::String::new(scope, code).unwrap();
+  let value: v8::Local<v8::Value> = str_.into();
+  Ok(v8::Global::new(scope, value))
+}
+
+fn url_module(
+  scope: &mut v8::HandleScope,
+  module_name: &FastString,
+) -> v8::Global<v8::Value> {
+  let str_ = v8::String::new(scope, module_name.as_str()).unwrap();
+  let value: v8::Local<v8::Value> = str_.into();
+  v8::Global::new(scope, value)
+}
+
+fn validate_import_attributes(
+  _scope: &mut v8::HandleScope,
+  _assertions: &HashMap<String, String>,
+) {
+  // allow all
+}
+
 fn main() -> Result<(), Error> {
   let args: Vec<String> = std::env::args().collect();
   if args.len() < 2 {
@@ -18,6 +94,8 @@ fn main() -> Result<(), Error> {
 
   let mut js_runtime = JsRuntime::new(RuntimeOptions {
     module_loader: Some(Rc::new(FsModuleLoader)),
+    custom_module_evaluation_cb: Some(Box::new(custom_module_evaluation_cb)),
+    validate_import_attributes_cb: Some(Box::new(validate_import_attributes)),
     ..Default::default()
   });
 

core/modules/loaders.rs

@@ -7,6 +7,7 @@ use crate::modules::ModuleCodeString;
 use crate::modules::ModuleSource;
 use crate::modules::ModuleSourceFuture;
 use crate::modules::ModuleType;
+use crate::modules::RequestedModuleType;
 use crate::modules::ResolutionKind;
 use crate::resolve_import;
 use crate::Extension;
@@ -24,8 +25,6 @@ use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
 
-use super::RequestedModuleType;
-
 pub trait ModuleLoader {
   /// Returns an absolute URL.
   /// When implementing an spec-complaint VM, this should be exactly the
@@ -289,10 +288,11 @@ impl ModuleLoader for FsModuleLoader {
     module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleSpecifier>,
     _is_dynamic: bool,
-    _requested_module_type: RequestedModuleType,
+    requested_module_type: RequestedModuleType,
   ) -> Pin<Box<ModuleSourceFuture>> {
     fn load(
       module_specifier: &ModuleSpecifier,
+      requested_module_type: RequestedModuleType,
     ) -> Result<ModuleSource, AnyError> {
       let path = module_specifier.to_file_path().map_err(|_| {
         generic_error(format!(
@@ -301,10 +301,16 @@ impl ModuleLoader for FsModuleLoader {
       })?;
       let module_type = if let Some(extension) = path.extension() {
         let ext = extension.to_string_lossy().to_lowercase();
+        // We only return JSON modules if extension was actually `.json`.
+        // In other cases we defer to actual requested module type, so runtime
+        // can decide what to do with it.
         if ext == "json" {
           ModuleType::Json
         } else {
-          ModuleType::JavaScript
+          match requested_module_type {
+            RequestedModuleType::Other(ty) => ModuleType::Other(ty.clone()),
+            _ => ModuleType::JavaScript,
+          }
         }
       } else {
         ModuleType::JavaScript
@@ -321,7 +327,8 @@ impl ModuleLoader for FsModuleLoader {
       Ok(module)
     }
 
-    futures::future::ready(load(module_specifier)).boxed_local()
+    futures::future::ready(load(module_specifier, requested_module_type))
+      .boxed_local()
   }
 }
 

core/modules/map.rs

@@ -296,7 +296,7 @@ impl ModuleMap {
       return Ok(module_id);
     }
 
-    let module_id = match module_type.clone() {
+    let module_id = match module_type {
       ModuleType::JavaScript => {
         let code =
           ModuleSource::get_string_source(module_url_found.as_str(), code)
@@ -317,31 +317,69 @@ impl ModuleMap {
         self.new_json_module(scope, module_url_found, code)?
       }
       ModuleType::Other(module_type) => {
-        let state = JsRuntime::state_from(scope);
-        let custom_module_evaluation_cb =
-          state.custom_module_evaluation_cb.as_ref();
-
-        let Some(custom_evaluation_cb) = custom_module_evaluation_cb else {
-          return Err(ModuleError::Other(generic_error(format!(
-            "Importing '{}' modules is not supported",
-            module_type
-          ))));
-        };
-
-        let value_global = custom_evaluation_cb(
-          scope,
-          module_type.clone(),
-          &module_url_found,
-          code,
-        )
-        .map_err(ModuleError::Other)?;
-        let value = v8::Local::new(scope, value_global);
-        self.new_synthetic_module(
-          scope,
-          module_url_found,
-          ModuleType::Other(module_type.clone()),
-          value,
-        )?
+        // TODO(bartlomieju): this needs to be abstracted away and assumes
+        // "bytes" import support
+        if module_type == "wasm" {
+          let source = format!(
+            r#"
+import wasmBytes from "{}" with {{ type: "bytes" }};
+const wasmMod = await WebAssembly.compile(wasmBytes);
+const requestedImports = WebAssembly.Module.imports(wasmMod);
+const importedModules = await Promise.all(
+  requestedImports.map((i) => i.module).map((m) => import(m)),
+);
+const importsObject = {{}};
+for (let i = 0; i < requestedImports.length; i++) {{
+  const importedModule = importedModules[i];
+  const requestedImport = requestedImports[i];
+  if (typeof importsObject[requestedImport.module] === "undefined") {{
+    importsObject[requestedImport.module] = {{}};
+  }}
+  const import_ = importedModule[requestedImport.name];
+  importsObject[requestedImport.module][requestedImport.name] = import_;
+}}
+const result = await WebAssembly.instantiate(wasmMod, importsObject);
+export default result;
+          "#,
+            module_url_found.as_str()
+          );
+          // Ha! This is cool - we're saying this is a "WASM" module type, even
+          // though it's really a JS module that pulls WASM byte source.
+          self.new_module_from_js_source(
+            scope,
+            main,
+            ModuleType::Other("wasm".into()),
+            module_url_found,
+            source.into(),
+            dynamic,
+          )?
+        } else {
+          let state = JsRuntime::state_from(scope);
+          let custom_module_evaluation_cb =
+            state.custom_module_evaluation_cb.as_ref();
+
+          let Some(custom_evaluation_cb) = custom_module_evaluation_cb else {
+            return Err(ModuleError::Other(generic_error(format!(
+              "Importing '{}' modules is not supported",
+              module_type
+            ))));
+          };
+
+          let value_global = custom_evaluation_cb(
+            scope,
+            module_type.clone(),
+            &module_url_found,
+            code,
+          )
+          .map_err(ModuleError::Other)?;
+          let value = v8::Local::new(scope, value_global);
+          self.new_synthetic_module(
+            scope,
+            module_url_found,
+            ModuleType::Other(module_type.clone()),
+            value,
+          )?
+        }
       }
     };
     Ok(module_id)

import_bytes/main.js

@@ -0,0 +1,14 @@
+import img from "./img.jpg" with { type: "bytes" };
+import imgUrl from "./img.jpg" with { type: "url" };
+import textBytes from "./text.txt" with { type: "bytes" };
+import text from "./text.txt" with { type: "text" };
+import textUrl from "./text.txt" with { type: "url" };
+
+console.log("Img byte length", img.length);
+console.log("Img bytes", img.slice(0, 5));
+console.log("Text bytes length", textBytes.length);
+console.log("Text bytes", textBytes.slice(0, 5));
+console.log("Text length", text.length);
+console.log("Text", text.slice(0, 100));
+console.log("Img url", imgUrl);
+console.log("Text url", textUrl);

import_bytes/text.txt

@@ -0,0 +1 @@
+lorem ipsum dolor sit aemt

wasm_example/import.mjs

@@ -0,0 +1,6 @@
+import wasmBytes from "./import.wasm" with { type: "bytes" };
+import { wasmShim } from "./test.js";
+
+const wasmMod = await wasmShim(wasmBytes);
+console.log(`hey ${wasmMod.exports.exported_add}`);
+console.log(`${wasmMod.exports.exported_add()}`);

wasm_example/import.wat

@@ -0,0 +1,8 @@
+(module
+  (func $add (import "./import_inner.mjs" "add") (param i32) (param i32) (result i32))
+  (func (export "exported_add") (result i32)
+    i32.const 21
+    i32.const 21
+    call $add
+  )
+)

wasm_example/import2.mjs

@@ -0,0 +1,14 @@
+import wasmModule from "./import.wasm" with { type: "wasm" };
+import bytes from "./import.wasm" with { type: "bytes" };
+console.log(`hey ${exported_add}`);
+console.log(`${exported_add()}`);
+
+import {
+  get_plugin_schema_version,
+  get_wasm_memory_buffer_size,
+} from "./plugin.wasm" with { type: "wasm" };
+console.log("dprint plugin version", get_plugin_schema_version());
+console.log(
+  "dprint plugin get_wasm_memory_buffer_size",
+  get_wasm_memory_buffer_size(),
+);

wasm_example/import3.mjs

@@ -0,0 +1,14 @@
+import wasmMod from "./import.wasm" with { type: "wasm" };
+console.log(`hey ${wasmMod.exports.exported_add}`);
+console.log(`${wasmMod.exports.exported_add()}`);
+
+import dprintPlugin from "./plugin.wasm" with { type: "wasm" };
+console.log(`hey ${Object.keys(dprintPlugin.exports)}`);
+console.log(
+  "dprint plugin version",
+  dprintPlugin.exports.get_plugin_schema_version(),
+);
+console.log(
+  "dprint plugin get_wasm_memory_buffer_size",
+  dprintPlugin.exports.get_wasm_memory_buffer_size(),
+);

wasm_example/import_inner.mjs

@@ -0,0 +1,8 @@
+import { sleep } from "./import_inner_inner.mjs";
+export { add } from "./import_inner_inner.mjs";
+
+console.log("import_inner.js before");
+
+await sleep(100);
+
+console.log("import_inner.js after");

wasm_example/import_inner_inner.mjs

@@ -0,0 +1,21 @@
+console.log("import_inner_inner.js before");
+
+export async function sleep(timeout) {
+  return new Promise((resolve) => {
+    Deno.core.queueTimer(
+      Deno.core.getTimerDepth() + 1,
+      false,
+      timeout,
+      resolve,
+    );
+  });
+}
+await sleep(100);
+
+console.log("import_inner_inner.js after");
+
+const abc = 1 + 2;
+export function add(a, b) {
+  console.log(`abc: ${abc}`);
+  return a + b;
+}

wasm_example/test.js

@@ -0,0 +1,34 @@
+import wasmBytes from "./specifier.wasm" with { type: "bytes" };
+
+export async function wasmShim(wasmBytes) {
+  const wasmMod = await WebAssembly.compile(wasmBytes);
+  const requestedImports = WebAssembly.Module.imports(wasmMod);
+  const importedModules = await Promise.all(
+    requestedImports.map((i) => i.module).map((m) => import(m)),
+  );
+  const importsObject = {};
+  for (let i = 0; i < requestedImports.length; i++) {
+    const importedModule = importedModules[i];
+    const requestedImport = requestedImports[i];
+    if (typeof importsObject[requestedImport.module] === "undefined") {
+      importsObject[requestedImport.module] = {};
+    }
+    const import_ = importedModule[requestedImport.name];
+    importsObject[requestedImport.module][requestedImport.name] = import_;
+  }
+  const result = await WebAssembly.instantiate(wasmMod, importsObject);
+  result.exports
+  result.imports;
+  return result;
+}
+
+
+/// 
+const wasmMod = await WebAssembly.compile(wasmBytes);
+const requestedImports = WebAssembly.Module.imports(wasmMod);
+const exports = WebAssembly.Module.exports(wasmMod);
+
+/// 
+
+import import from "./"
+