snapshot test

main.rs

use anyhow::Result;
use deno_core::anyhow;
use deno_core::futures::FutureExt;
use deno_core::url::Url;
use deno_core::JsRuntime;
use deno_core::ModuleSource;
use deno_core::ModuleSourceFuture;
use deno_core::ModuleType;
use deno_core::RuntimeOptions;
use std::pin::Pin;
use std::rc::Rc;

struct ModuleLoader {}
impl deno_core::ModuleLoader for ModuleLoader {
    fn resolve(&self, url: &str, referrer: &str, _is_main: bool) -> Result<Url> {
        Ok(deno_core::resolve_import(url, referrer)?)
    }
    fn load(
        &self,
        url: &Url,
        _maybe_referrer: Option<Url>,
        _is_dyn_import: bool,
    ) -> Pin<Box<ModuleSourceFuture>> {
        let url = url.clone();
        let code = match url.as_str() {
            "file:///foo.js" => "import * as ts from \"./bar.js\";",
            "file:///bar.js" => {
                "globalThis.zed = function(){};
                export const baz = undefined;"
            }
            _ => panic!("unexpected url {}", url),
        };
        let code = code.to_string().into_bytes().into_boxed_slice();
        let url = url.to_string();
        async move {
            Ok(ModuleSource {
                code,
                module_type: ModuleType::JavaScript,
                module_url_specified: url.clone(),
                module_url_found: url,
            })
        }
        .boxed_local()
    }
}

#[tokio::main]
async fn main() {
    let mut runtime = JsRuntime::new(RuntimeOptions {
        will_snapshot: true,
        module_loader: Some(Rc::new(ModuleLoader {})),
        ..Default::default()
    });

    let url = Url::parse("file:///foo.js").unwrap();
    let module_id = runtime.load_main_module(&url, None).await.unwrap();
    let receiver = runtime.mod_evaluate(module_id);
    runtime.run_event_loop(false).await.unwrap();
    receiver.await.unwrap().unwrap();
    let _snapshot = runtime.snapshot();
}