refactor: snapshotting (#3753)

1 files changed, 45 insertions, 83 deletions

diff --git a/deno_typescript/lib.rs b/deno_typescript/lib.rs
index ccad69a3d..2d908cf8b 100644
--- a/deno_typescript/lib.rs
+++ b/deno_typescript/lib.rs
@@ -16,7 +16,6 @@ use deno_core::PinnedBuf;
 use deno_core::StartupData;
 pub use ops::EmitResult;
 use ops::WrittenFile;
-use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
@@ -38,19 +37,11 @@ pub struct TSState {
   bundle: bool,
   exit_code: i32,
   emit_result: Option<EmitResult>,
-  custom_assets: HashMap<String, PathBuf>,
   /// A list of files emitted by typescript. WrittenFile is tuple of the form
   /// (url, corresponding_module, source_code)
   written_files: Vec<WrittenFile>,
 }
 
-impl TSState {
-  fn main_module_name(&self) -> String {
-    // Assuming that TypeScript has emitted the main file last.
-    self.written_files.last().unwrap().module_name.clone()
-  }
-}
-
 fn compiler_op<D>(
   ts_state: Arc<Mutex<TSState>>,
   dispatcher: D,
@@ -78,7 +69,6 @@ impl TSIsolate {
 
     let state = Arc::new(Mutex::new(TSState {
       bundle,
-      custom_assets: HashMap::new(),
       exit_code: 0,
       emit_result: None,
       written_files: Vec::new(),
@@ -122,24 +112,21 @@ impl TSIsolate {
     self.isolate.execute("<anon>", source)?;
     Ok(self.state)
   }
-
-  pub fn add_custom_assets(&mut self, custom_assets: Vec<(String, PathBuf)>) {
-    let mut state = self.state.lock().unwrap();
-    for (name, path) in custom_assets {
-      state.custom_assets.insert(name, path);
-    }
-  }
 }
 
+/// Compile provided roots into a single JS bundle.
+///
+/// This function writes compiled bundle to disk at provided path.
+///
+/// Source map file and type declaration file are emmited
+/// alongside the bundle.
+///
+/// To instantiate bundle use returned `module_name`.
 pub fn compile_bundle(
-  bundle: &Path,
+  bundle_filename: &Path,
   root_names: Vec<PathBuf>,
-  custom_assets: Option<Vec<(String, PathBuf)>>,
-) -> Result<Arc<Mutex<TSState>>, ErrBox> {
-  let mut ts_isolate = TSIsolate::new(true);
-  if let Some(assets) = custom_assets {
-    ts_isolate.add_custom_assets(assets);
-  }
+) -> Result<String, ErrBox> {
+  let ts_isolate = TSIsolate::new(true);
 
   let config_json = serde_json::json!({
     "compilerOptions": {
@@ -156,7 +143,7 @@ pub fn compile_bundle(
       // requires --inlineSourceMap or --sourceMap to be set.
       // "inlineSources": true,
       "sourceMap": true,
-      "outFile": bundle,
+      "outFile": bundle_filename,
     },
   });
 
@@ -174,9 +161,12 @@ pub fn compile_bundle(
     .collect();
 
   // TODO lift js_check to caller?
-  let state = js_check(ts_isolate.compile(&config_json, root_names_str));
-
-  Ok(state)
+  let locked_state = js_check(ts_isolate.compile(&config_json, root_names_str));
+  let state = locked_state.lock().unwrap();
+  // Assuming that TypeScript has emitted the main file last.
+  let main = state.written_files.last().unwrap();
+  let module_name = main.module_name.clone();
+  Ok(module_name)
 }
 
 #[allow(dead_code)]
@@ -190,81 +180,53 @@ fn print_source_code(code: &str) {
 
 /// Create a V8 snapshot.
 pub fn mksnapshot_bundle(
-  bundle: &Path,
-  state: Arc<Mutex<TSState>>,
+  isolate: &mut Isolate,
+  snapshot_filename: &Path,
+  bundle_filename: &Path,
+  main_module_name: &str,
 ) -> Result<(), ErrBox> {
-  let runtime_isolate = &mut Isolate::new(StartupData::None, true);
-  let source_code_vec = std::fs::read(bundle)?;
-  let source_code = std::str::from_utf8(&source_code_vec)?;
-
-  js_check(runtime_isolate.execute("bundle_loader.js", BUNDLE_LOADER));
-  js_check(runtime_isolate.execute(&bundle.to_string_lossy(), &source_code));
-
-  let main = state.lock().unwrap().main_module_name();
+  js_check(isolate.execute("bundle_loader.js", BUNDLE_LOADER));
+  let source_code_vec = std::fs::read(bundle_filename).unwrap();
+  let bundle_source_code = std::str::from_utf8(&source_code_vec).unwrap();
   js_check(
-    runtime_isolate.execute("anon", &format!("instantiate('{}')", main)),
+    isolate.execute(&bundle_filename.to_string_lossy(), bundle_source_code),
   );
-
-  write_snapshot(runtime_isolate, bundle)?;
-
+  let script = &format!("instantiate('{}')", main_module_name);
+  js_check(isolate.execute("anon", script));
+  write_snapshot(isolate, snapshot_filename)?;
   Ok(())
 }
 
 /// Create a V8 snapshot. This differs from mksnapshot_bundle in that is also
 /// runs typescript.js
 pub fn mksnapshot_bundle_ts(
-  bundle: &Path,
-  state: Arc<Mutex<TSState>>,
+  isolate: &mut Isolate,
+  snapshot_filename: &Path,
+  bundle_filename: &Path,
+  main_module_name: &str,
 ) -> Result<(), ErrBox> {
-  let runtime_isolate = &mut Isolate::new(StartupData::None, true);
-  runtime_isolate.register_op(
-    "fetch_asset",
-    compiler_op(state.clone(), ops::json_op(ops::fetch_asset)),
-  );
-  let source_code_vec = std::fs::read(bundle)?;
-  let source_code = std::str::from_utf8(&source_code_vec)?;
-
-  js_check(runtime_isolate.execute("bundle_loader.js", BUNDLE_LOADER));
-  js_check(runtime_isolate.execute("typescript.js", TYPESCRIPT_CODE));
-  js_check(runtime_isolate.execute(&bundle.to_string_lossy(), &source_code));
-
-  let main = state.lock().unwrap().main_module_name();
-  js_check(
-    runtime_isolate.execute("anon", &format!("instantiate('{}')", main)),
-  );
-
-  write_snapshot(runtime_isolate, bundle)?;
-
-  Ok(())
+  js_check(isolate.execute("typescript.js", TYPESCRIPT_CODE));
+  mksnapshot_bundle(
+    isolate,
+    snapshot_filename,
+    bundle_filename,
+    main_module_name,
+  )
 }
 
 fn write_snapshot(
   runtime_isolate: &mut Isolate,
-  bundle: &Path,
+  snapshot_filename: &Path,
 ) -> Result<(), ErrBox> {
-  println!("creating snapshot...");
+  println!("Creating snapshot...");
   let snapshot = runtime_isolate.snapshot()?;
   let snapshot_slice: &[u8] = &*snapshot;
-  println!("snapshot bytes {}", snapshot_slice.len());
-
-  let snapshot_path = bundle.with_extension("bin");
-
-  fs::write(&snapshot_path, snapshot_slice)?;
-  println!("snapshot path {} ", snapshot_path.display());
+  println!("Snapshot size: {}", snapshot_slice.len());
+  fs::write(&snapshot_filename, snapshot_slice)?;
+  println!("Snapshot written to: {} ", snapshot_filename.display());
   Ok(())
 }
 
-/// Same as get_asset() but returns NotFound intead of None.
-pub fn get_asset2(name: &str) -> Result<&'static str, ErrBox> {
-  match get_asset(name) {
-    Some(a) => Ok(a),
-    None => Err(
-      std::io::Error::new(std::io::ErrorKind::NotFound, "Asset not found")
-        .into(),
-    ),
-  }
-}
-
 pub fn get_asset(name: &str) -> Option<&'static str> {
   macro_rules! inc {
     ($e:expr) => {