Bump cargo deps

src-tauri/src/runtime.rs

@@ -1,9 +1,16 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::pin::Pin;
 use std::rc::Rc;
 
 use deno_ast::{MediaType, ParseParams, SourceTextInfo};
+use deno_core::anyhow::{anyhow, bail, Error};
 use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
-use deno_core::{op, Extension, JsRuntime, ModuleCode, ModuleSource, ModuleType, RuntimeOptions};
+use deno_core::{
+    resolve_import, Extension, JsRuntime, ModuleLoader, ModuleSource, ModuleSourceFuture,
+    ModuleSpecifier, ModuleType, ResolutionKind, RuntimeOptions, SourceMapGetter,
+};
 use futures::executor;
 
 pub fn run_plugin_sync(file_path: &str) -> Result<(), AnyError> {
@@ -11,19 +18,24 @@ pub fn run_plugin_sync(file_path: &str) -> Result<(), AnyError> {
 }
 
 pub async fn run_plugin(file_path: &str) -> Result<(), AnyError> {
-    let extension = Extension::builder("runtime")
-        .ops(vec![op_hello::decl()])
-        .build();
+    let extension = Extension {
+        name: "runtime",
+        // ops: std::borrow::Cow::Borrowed(&[op_hello::DECL]),
+        ..Default::default()
+    };
+    let source_map_store = SourceMapStore(Rc::new(RefCell::new(HashMap::new())));
 
     // Initialize a runtime instance
     let mut runtime = JsRuntime::new(RuntimeOptions {
-        module_loader: Some(Rc::new(TsModuleLoader)),
+        module_loader: Some(Rc::new(TypescriptModuleLoader {
+            source_maps: source_map_store.clone(),
+        })),
         extensions: vec![extension],
         ..Default::default()
     });
 
     runtime
-        .execute_script("<runtime>", include_str!("runtime.js"))
+        .execute_script_static("<runtime>", include_str!("runtime.js"))
         .expect("Failed to execute runtime.js");
 
     let current_dir = &std::env::current_dir().expect("Unable to get CWD");
@@ -41,41 +53,50 @@ pub async fn run_plugin(file_path: &str) -> Result<(), AnyError> {
     result.await?
 }
 
-#[op]
-async fn op_hello(name: String) -> Result<String, AnyError> {
-    let contents = format!("Hello {} from Rust!", name);
-    println!("{}", contents);
-    Ok(contents)
+#[derive(Clone)]
+struct SourceMapStore(Rc<RefCell<HashMap<String, Vec<u8>>>>);
+
+impl SourceMapGetter for SourceMapStore {
+    fn get_source_map(&self, specifier: &str) -> Option<Vec<u8>> {
+        self.0.borrow().get(specifier).cloned()
+    }
+
+    fn get_source_line(&self, _file_name: &str, _line_number: usize) -> Option<String> {
+        None
+    }
 }
 
-struct TsModuleLoader;
+struct TypescriptModuleLoader {
+    source_maps: SourceMapStore,
+}
 
-impl deno_core::ModuleLoader for TsModuleLoader {
+impl ModuleLoader for TypescriptModuleLoader {
     fn resolve(
         &self,
         specifier: &str,
         referrer: &str,
-        _kind: deno_core::ResolutionKind,
-    ) -> Result<deno_core::ModuleSpecifier, AnyError> {
-        deno_core::resolve_import(specifier, referrer).map_err(|e| e.into())
+        _kind: ResolutionKind,
+    ) -> Result<ModuleSpecifier, Error> {
+        Ok(resolve_import(specifier, referrer)?)
     }
 
     fn load(
         &self,
-        module_specifier: &deno_core::ModuleSpecifier,
-        _maybe_referrer: Option<deno_core::ModuleSpecifier>,
+        module_specifier: &ModuleSpecifier,
+        _maybe_referrer: Option<&ModuleSpecifier>,
         _is_dyn_import: bool,
-    ) -> std::pin::Pin<Box<deno_core::ModuleSourceFuture>> {
-        let module_specifier = module_specifier.clone();
-        async move {
+    ) -> Pin<Box<ModuleSourceFuture>> {
+        let source_maps = self.source_maps.clone();
+        fn load(
+            source_maps: SourceMapStore,
+            module_specifier: &ModuleSpecifier,
+        ) -> Result<ModuleSource, AnyError> {
             let path = module_specifier
                 .to_file_path()
-                .expect("Failed to convert to file path");
+                .map_err(|_| anyhow!("Only file:// URLs are supported."))?;
 
-            // Determine what the MediaType is (this is done based on the file
-            // extension) and whether transpiling is required.
             let media_type = MediaType::from_path(&path);
-            let (module_type, should_transpile) = match media_type {
+            let (module_type, should_transpile) = match MediaType::from_path(&path) {
                 MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs => {
                     (ModuleType::JavaScript, false)
                 }
@@ -88,10 +109,9 @@ impl deno_core::ModuleLoader for TsModuleLoader {
                 | MediaType::Dcts
                 | MediaType::Tsx => (ModuleType::JavaScript, true),
                 MediaType::Json => (ModuleType::Json, false),
-                _ => panic!("Unknown extension {:?}", path.extension()),
+                _ => bail!("Unknown extension {:?}", path.extension()),
             };
 
-            // Read the file, transpile if necessary.
             let code = std::fs::read_to_string(&path)?;
             let code = if should_transpile {
                 let parsed = deno_ast::parse_module(ParseParams {
@@ -102,20 +122,28 @@ impl deno_core::ModuleLoader for TsModuleLoader {
                     scope_analysis: false,
                     maybe_syntax: None,
                 })?;
-                parsed.transpile(&Default::default())?.text
+                let res = parsed.transpile(&deno_ast::EmitOptions {
+                    inline_source_map: false,
+                    source_map: true,
+                    inline_sources: true,
+                    ..Default::default()
+                })?;
+                let source_map = res.source_map.unwrap();
+                source_maps
+                    .0
+                    .borrow_mut()
+                    .insert(module_specifier.to_string(), source_map.into_bytes());
+                res.text
             } else {
                 code
             };
-
-            // Load and return module.
-            let module = ModuleSource {
-                code: ModuleCode::from(code),
+            Ok(ModuleSource::new(
                 module_type,
-                module_url_specified: module_specifier.to_string(),
-                module_url_found: module_specifier.to_string(),
-            };
-            Ok(module)
+                code.into(),
+                module_specifier,
+            ))
         }
-        .boxed_local()
+
+        futures::future::ready(load(source_maps, module_specifier)).boxed_local()
     }
 }