feat: deno compile

cli/main.rs

@@ -39,6 +39,7 @@ mod resolve_addr;
 mod signal;
 mod source_maps;
 mod specifier_handler;
+mod standalone;
 mod text_encoding;
 mod tokio_util;
 mod tools;
@@ -967,8 +968,9 @@ pub fn main() {
   colors::enable_ansi(); // For Windows 10
 
   let args: Vec<String> = env::args().collect();
-  let flags = flags::flags_from_vec(args);
+  standalone::standalone();
 
+  let flags = flags::flags_from_vec(args);
   if let Some(ref v8_flags) = flags.v8_flags {
     init_v8_flags(v8_flags);
   }

cli/standalone.rs

@@ -0,0 +1,123 @@
+use std::cell::RefCell;
+use std::convert::TryInto;
+use std::env::current_exe;
+use std::fs::File;
+use std::io::Read;
+use std::io::Seek;
+use std::io::SeekFrom;
+use std::pin::Pin;
+use std::rc::Rc;
+
+use deno_core::error::AnyError;
+use deno_core::futures::FutureExt;
+use deno_core::ModuleLoader;
+use deno_core::ModuleSpecifier;
+use deno_core::OpState;
+
+use crate::colors;
+use crate::flags::Flags;
+use crate::permissions::Permissions;
+use crate::program_state::ProgramState;
+use crate::tokio_util;
+use crate::worker::MainWorker;
+
+pub fn standalone() {
+  let current_exe_path =
+    current_exe().expect("expect current exe path to be known");
+
+  let mut current_exe = File::open(current_exe_path)
+    .expect("expected to be able to open current exe");
+  let magic_trailer_pos = current_exe
+    .seek(SeekFrom::End(-12))
+    .expect("expected to be able to seek to magic trailer in current exe");
+  let mut magic_trailer = [0; 12];
+  current_exe
+    .read_exact(&mut magic_trailer)
+    .expect("expected to be able to read magic trailer from current exe");
+  let (magic_trailer, bundle_pos) = magic_trailer.split_at(4);
+  if magic_trailer == b"DENO" {
+    let bundle_pos_arr: &[u8; 8] =
+      bundle_pos.try_into().expect("slice with incorrect length");
+    let bundle_pos = u64::from_be_bytes(*bundle_pos_arr);
+    println!(
+      "standalone bin! bundle starting at {} and ending at {}.",
+      bundle_pos,
+      magic_trailer_pos - 1
+    );
+    current_exe
+      .seek(SeekFrom::Start(bundle_pos))
+      .expect("expected to be able to seek to bundle pos in current exe");
+
+    let bundle_len = magic_trailer_pos - bundle_pos;
+    let mut bundle = String::new();
+    current_exe
+      .take(bundle_len)
+      .read_to_string(&mut bundle)
+      .expect("expected to be able to read bundle from current exe");
+    // TODO: check amount of bytes read
+
+    // println!("standalone bin bundle:\n{}", bundle);
+
+    let result = tokio_util::run_basic(run(bundle));
+    if let Err(err) = result {
+      eprintln!("{}: {}", colors::red_bold("error"), err.to_string());
+      std::process::exit(1);
+    }
+    std::process::exit(0);
+  }
+}
+
+const SPECIFIER: &str = "file://$deno$/bundle.js";
+
+struct EmbeddedModuleLoader(String);
+
+impl ModuleLoader for EmbeddedModuleLoader {
+  fn resolve(
+    &self,
+    _op_state: Rc<RefCell<OpState>>,
+    specifier: &str,
+    _referrer: &str,
+    _is_main: bool,
+  ) -> Result<ModuleSpecifier, AnyError> {
+    assert_eq!(specifier, SPECIFIER);
+    Ok(ModuleSpecifier::resolve_url(specifier)?)
+  }
+
+  fn load(
+    &self,
+    _op_state: Rc<RefCell<OpState>>,
+    module_specifier: &ModuleSpecifier,
+    _maybe_referrer: Option<ModuleSpecifier>,
+    _is_dynamic: bool,
+  ) -> Pin<Box<deno_core::ModuleSourceFuture>> {
+    let module_specifier = module_specifier.clone();
+    let code = self.0.to_string();
+    async move {
+      Ok(deno_core::ModuleSource {
+        code,
+        module_url_specified: module_specifier.to_string(),
+        module_url_found: module_specifier.to_string(),
+      })
+    }
+    .boxed_local()
+  }
+}
+
+async fn run(source_code: String) -> Result<(), AnyError> {
+  let flags = Flags::default();
+  let main_module = ModuleSpecifier::resolve_url(SPECIFIER)?;
+  let program_state = ProgramState::new(flags.clone())?;
+  let permissions = Permissions::allow_all();
+  let module_loader = Rc::new(EmbeddedModuleLoader(source_code));
+  let mut worker = MainWorker::from_options(
+    &program_state,
+    main_module.clone(),
+    permissions,
+    module_loader,
+  );
+  worker.execute_module(&main_module).await?;
+  worker.execute("window.dispatchEvent(new Event('load'))")?;
+  worker.run_event_loop().await?;
+  worker.execute("window.dispatchEvent(new Event('unload'))")?;
+  Ok(())
+}

cli/worker.rs

@@ -17,9 +17,11 @@ use deno_core::futures::future::FutureExt;
 use deno_core::url::Url;
 use deno_core::JsRuntime;
 use deno_core::ModuleId;
+use deno_core::ModuleLoader;
 use deno_core::ModuleSpecifier;
 use deno_core::RuntimeOptions;
 use std::env;
+use std::rc::Rc;
 use std::sync::Arc;
 use std::task::Context;
 use std::task::Poll;
@@ -45,6 +47,16 @@ impl MainWorker {
   ) -> Self {
     let module_loader =
       CliModuleLoader::new(program_state.maybe_import_map.clone());
+
+    Self::from_options(program_state, main_module, permissions, module_loader)
+  }
+
+  pub fn from_options(
+    program_state: &Arc<ProgramState>,
+    main_module: ModuleSpecifier,
+    permissions: Permissions,
+    module_loader: Rc<dyn ModuleLoader>,
+  ) -> Self {
     let global_state_ = program_state.clone();
 
     let js_error_create_fn = Box::new(move |core_js_error| {

compile.ts

@@ -0,0 +1,26 @@
+const specifier = Deno.args[0];
+const out = Deno.args[1];
+const [_, bundle] = await Deno.bundle(specifier);
+
+const originalBinaryPath = Deno.execPath();
+const originalBin = await Deno.readFile(originalBinaryPath);
+
+const encoder = new TextEncoder();
+const bundleData = encoder.encode(bundle);
+const magicTrailer = new Uint8Array(12);
+magicTrailer.set(encoder.encode("DENO"), 0);
+new DataView(magicTrailer.buffer).setBigUint64(
+  4,
+  BigInt(originalBin.byteLength),
+  false,
+);
+
+var newBin = new Uint8Array(
+  originalBin.byteLength + bundleData.byteLength + magicTrailer.byteLength,
+);
+newBin.set(originalBin, 0);
+newBin.set(bundleData, originalBin.byteLength);
+newBin.set(magicTrailer, originalBin.byteLength + bundleData.byteLength);
+
+await Deno.writeFile(out, newBin);
+console.log(`Created binary at ${out}`);