1 files changed, 87 insertions, 9 deletions

diff --git a/cli/ops/compiler.rs b/cli/ops/compiler.rs
index bc85e5ca8..114a4e1f0 100644
--- a/cli/ops/compiler.rs
+++ b/cli/ops/compiler.rs
@@ -1,15 +1,22 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 use super::dispatch_json::{Deserialize, JsonOp, Value};
+use crate::compilers::runtime_compile_async;
+use crate::compilers::runtime_transpile_async;
 use crate::futures::future::try_join_all;
 use crate::msg;
 use crate::ops::json_op;
 use crate::state::ThreadSafeState;
 use deno_core::Loader;
 use deno_core::*;
+use std::collections::HashMap;
 
 pub fn init(i: &mut Isolate, s: &ThreadSafeState) {
   i.register_op("cache", s.core_op(json_op(s.stateful_op(op_cache))));
   i.register_op(
+    "resolve_modules",
+    s.core_op(json_op(s.stateful_op(op_resolve_modules))),
+  );
+  i.register_op(
     "fetch_source_files",
     s.core_op(json_op(s.stateful_op(op_fetch_source_files))),
   );
@@ -17,6 +24,8 @@ pub fn init(i: &mut Isolate, s: &ThreadSafeState) {
     "fetch_asset",
     s.core_op(json_op(s.stateful_op(op_fetch_asset))),
   );
+  i.register_op("compile", s.core_op(json_op(s.stateful_op(op_compile))));
+  i.register_op("transpile", s.core_op(json_op(s.stateful_op(op_transpile))));
 }
 
 #[derive(Deserialize)]
@@ -46,36 +55,62 @@ fn op_cache(
   Ok(JsonOp::Sync(json!({})))
 }
 
-#[derive(Deserialize)]
-struct FetchSourceFilesArgs {
+#[derive(Deserialize, Debug)]
+struct SpecifiersReferrerArgs {
   specifiers: Vec<String>,
   referrer: Option<String>,
 }
 
-fn op_fetch_source_files(
+fn op_resolve_modules(
   state: &ThreadSafeState,
   args: Value,
   _data: Option<PinnedBuf>,
 ) -> Result<JsonOp, ErrBox> {
-  let args: FetchSourceFilesArgs = serde_json::from_value(args)?;
+  let args: SpecifiersReferrerArgs = serde_json::from_value(args)?;
 
   // TODO(ry) Maybe a security hole. Only the compiler worker should have access
   // to this. Need a test to demonstrate the hole.
   let is_dyn_import = false;
 
-  let (referrer, ref_specifier) = if let Some(referrer) = args.referrer {
+  let (referrer, is_main) = if let Some(referrer) = args.referrer {
+    (referrer, false)
+  } else {
+    ("<unknown>".to_owned(), true)
+  };
+
+  let mut specifiers = vec![];
+
+  for specifier in &args.specifiers {
+    let resolved_specifier =
+      state.resolve(specifier, &referrer, is_main, is_dyn_import);
+    match resolved_specifier {
+      Ok(ms) => specifiers.push(ms.as_str().to_owned()),
+      Err(err) => return Err(err),
+    }
+  }
+
+  Ok(JsonOp::Sync(json!(specifiers)))
+}
+
+fn op_fetch_source_files(
+  state: &ThreadSafeState,
+  args: Value,
+  _data: Option<PinnedBuf>,
+) -> Result<JsonOp, ErrBox> {
+  let args: SpecifiersReferrerArgs = serde_json::from_value(args)?;
+
+  let ref_specifier = if let Some(referrer) = args.referrer {
     let specifier = ModuleSpecifier::resolve_url(&referrer)
       .expect("Referrer is not a valid specifier");
-    (referrer, Some(specifier))
+    Some(specifier)
   } else {
-    // main script import
-    (".".to_string(), None)
+    None
   };
 
   let mut futures = vec![];
   for specifier in &args.specifiers {
     let resolved_specifier =
-      state.resolve(specifier, &referrer, false, is_dyn_import)?;
+      ModuleSpecifier::resolve_url(&specifier).expect("Invalid specifier");
     let fut = state
       .global_state
       .file_fetcher
@@ -137,3 +172,46 @@ fn op_fetch_asset(
     panic!("op_fetch_asset bad asset {}", args.name)
   }
 }
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct CompileArgs {
+  root_name: String,
+  sources: Option<HashMap<String, String>>,
+  bundle: bool,
+  options: Option<String>,
+}
+
+fn op_compile(
+  state: &ThreadSafeState,
+  args: Value,
+  _zero_copy: Option<PinnedBuf>,
+) -> Result<JsonOp, ErrBox> {
+  let args: CompileArgs = serde_json::from_value(args)?;
+  Ok(JsonOp::Async(runtime_compile_async(
+    state.global_state.clone(),
+    &args.root_name,
+    &args.sources,
+    args.bundle,
+    &args.options,
+  )))
+}
+
+#[derive(Deserialize, Debug)]
+struct TranspileArgs {
+  sources: HashMap<String, String>,
+  options: Option<String>,
+}
+
+fn op_transpile(
+  state: &ThreadSafeState,
+  args: Value,
+  _zero_copy: Option<PinnedBuf>,
+) -> Result<JsonOp, ErrBox> {
+  let args: TranspileArgs = serde_json::from_value(args)?;
+  Ok(JsonOp::Async(runtime_transpile_async(
+    state.global_state.clone(),
+    &args.sources,
+    &args.options,
+  )))
+}