2020-01-02 20:13:47 +00:00
|
|
|
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
2020-09-06 00:34:02 +00:00
|
|
|
|
2019-06-09 13:08:20 +00:00
|
|
|
use crate::import_map::ImportMap;
|
2020-05-04 18:10:59 +00:00
|
|
|
use crate::permissions::Permissions;
|
2020-10-13 11:35:35 +00:00
|
|
|
use crate::program_state::ProgramState;
|
2020-05-08 14:18:00 +00:00
|
|
|
use crate::tsc::TargetLib;
|
2020-09-14 16:48:57 +00:00
|
|
|
use deno_core::error::AnyError;
|
2020-09-21 16:36:37 +00:00
|
|
|
use deno_core::futures::future::FutureExt;
|
|
|
|
use deno_core::futures::Future;
|
2020-04-30 12:37:06 +00:00
|
|
|
use deno_core::ModuleLoadId;
|
2020-03-02 18:12:49 +00:00
|
|
|
use deno_core::ModuleLoader;
|
2020-01-05 16:56:18 +00:00
|
|
|
use deno_core::ModuleSpecifier;
|
2020-09-19 23:17:35 +00:00
|
|
|
use deno_core::OpState;
|
2020-02-08 19:34:31 +00:00
|
|
|
use std::cell::RefCell;
|
2019-11-17 00:17:47 +00:00
|
|
|
use std::pin::Pin;
|
2020-02-08 19:34:31 +00:00
|
|
|
use std::rc::Rc;
|
2019-07-31 17:16:03 +00:00
|
|
|
use std::str;
|
2020-08-18 16:30:13 +00:00
|
|
|
use std::sync::Arc;
|
2020-04-03 17:40:11 +00:00
|
|
|
|
2020-09-19 23:17:35 +00:00
|
|
|
pub struct CliModuleLoader {
|
2019-06-09 13:08:20 +00:00
|
|
|
/// When flags contains a `.import_map_path` option, the content of the
|
|
|
|
/// import map file will be resolved and set.
|
|
|
|
pub import_map: Option<ImportMap>,
|
2020-01-29 17:54:23 +00:00
|
|
|
pub target_lib: TargetLib,
|
2020-05-11 11:13:27 +00:00
|
|
|
pub is_main: bool,
|
2019-03-14 23:17:52 +00:00
|
|
|
}
|
|
|
|
|
2020-09-19 23:17:35 +00:00
|
|
|
impl CliModuleLoader {
|
|
|
|
pub fn new(maybe_import_map: Option<ImportMap>) -> Rc<Self> {
|
|
|
|
Rc::new(CliModuleLoader {
|
|
|
|
import_map: maybe_import_map,
|
|
|
|
target_lib: TargetLib::Main,
|
|
|
|
is_main: true,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new_for_worker() -> Rc<Self> {
|
|
|
|
Rc::new(CliModuleLoader {
|
|
|
|
import_map: None,
|
|
|
|
target_lib: TargetLib::Worker,
|
|
|
|
is_main: false,
|
|
|
|
})
|
|
|
|
}
|
2020-04-27 23:12:38 +00:00
|
|
|
}
|
|
|
|
|
2020-09-19 23:17:35 +00:00
|
|
|
impl ModuleLoader for CliModuleLoader {
|
2019-06-09 13:08:20 +00:00
|
|
|
fn resolve(
|
|
|
|
&self,
|
2020-10-02 11:13:23 +00:00
|
|
|
op_state: Rc<RefCell<OpState>>,
|
2019-06-09 13:08:20 +00:00
|
|
|
specifier: &str,
|
|
|
|
referrer: &str,
|
2019-08-07 16:55:39 +00:00
|
|
|
is_main: bool,
|
2020-09-14 16:48:57 +00:00
|
|
|
) -> Result<ModuleSpecifier, AnyError> {
|
2020-10-13 11:35:35 +00:00
|
|
|
let program_state = {
|
2020-10-02 11:13:23 +00:00
|
|
|
let state = op_state.borrow();
|
2020-10-13 11:35:35 +00:00
|
|
|
state.borrow::<Arc<ProgramState>>().clone()
|
2020-10-02 11:13:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// FIXME(bartlomieju): hacky way to provide compatibility with repl
|
2020-10-13 11:35:35 +00:00
|
|
|
let referrer = if referrer.is_empty() && program_state.flags.repl {
|
2020-10-02 11:13:23 +00:00
|
|
|
"<unknown>"
|
|
|
|
} else {
|
|
|
|
referrer
|
|
|
|
};
|
|
|
|
|
2019-08-07 16:55:39 +00:00
|
|
|
if !is_main {
|
2020-08-18 16:30:13 +00:00
|
|
|
if let Some(import_map) = &self.import_map {
|
2019-06-12 19:00:08 +00:00
|
|
|
let result = import_map.resolve(specifier, referrer)?;
|
2019-10-03 13:16:06 +00:00
|
|
|
if let Some(r) = result {
|
|
|
|
return Ok(r);
|
2019-06-09 13:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-10-02 11:13:23 +00:00
|
|
|
|
2019-08-13 18:51:15 +00:00
|
|
|
let module_specifier =
|
|
|
|
ModuleSpecifier::resolve_import(specifier, referrer)?;
|
2019-06-09 13:08:20 +00:00
|
|
|
|
2019-08-13 18:51:15 +00:00
|
|
|
Ok(module_specifier)
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|
|
|
|
|
2019-06-12 23:55:59 +00:00
|
|
|
fn load(
|
|
|
|
&self,
|
2020-09-19 23:17:35 +00:00
|
|
|
op_state: Rc<RefCell<OpState>>,
|
2019-06-12 23:55:59 +00:00
|
|
|
module_specifier: &ModuleSpecifier,
|
2019-11-25 14:33:23 +00:00
|
|
|
maybe_referrer: Option<ModuleSpecifier>,
|
2020-05-29 14:32:15 +00:00
|
|
|
_is_dyn_import: bool,
|
2020-03-02 18:12:49 +00:00
|
|
|
) -> Pin<Box<deno_core::ModuleSourceFuture>> {
|
2020-05-29 14:32:15 +00:00
|
|
|
let module_specifier = module_specifier.to_owned();
|
2019-08-07 16:55:39 +00:00
|
|
|
let module_url_specified = module_specifier.to_string();
|
2020-10-13 11:35:35 +00:00
|
|
|
let program_state = {
|
2020-09-19 23:17:35 +00:00
|
|
|
let state = op_state.borrow();
|
2020-10-13 11:35:35 +00:00
|
|
|
state.borrow::<Arc<ProgramState>>().clone()
|
2020-09-19 23:17:35 +00:00
|
|
|
};
|
2020-05-11 11:13:27 +00:00
|
|
|
|
2020-05-29 14:32:15 +00:00
|
|
|
// TODO(bartlomieju): `fetch_compiled_module` should take `load_id` param
|
2020-02-03 23:08:44 +00:00
|
|
|
let fut = async move {
|
2020-10-13 11:35:35 +00:00
|
|
|
let compiled_module = program_state
|
2020-05-29 14:32:15 +00:00
|
|
|
.fetch_compiled_module(module_specifier, maybe_referrer)
|
2020-02-03 23:08:44 +00:00
|
|
|
.await?;
|
2020-03-02 18:12:49 +00:00
|
|
|
Ok(deno_core::ModuleSource {
|
2019-07-31 17:16:03 +00:00
|
|
|
// Real module name, might be different from initial specifier
|
|
|
|
// due to redirections.
|
|
|
|
code: compiled_module.code,
|
2019-08-07 16:55:39 +00:00
|
|
|
module_url_specified,
|
|
|
|
module_url_found: compiled_module.name,
|
2020-02-03 23:08:44 +00:00
|
|
|
})
|
|
|
|
};
|
2019-11-04 15:38:52 +00:00
|
|
|
|
2020-02-03 23:08:44 +00:00
|
|
|
fut.boxed_local()
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|
2020-04-30 12:37:06 +00:00
|
|
|
|
|
|
|
fn prepare_load(
|
|
|
|
&self,
|
2020-09-19 23:17:35 +00:00
|
|
|
op_state: Rc<RefCell<OpState>>,
|
2020-04-30 12:37:06 +00:00
|
|
|
_load_id: ModuleLoadId,
|
2020-05-29 14:32:15 +00:00
|
|
|
module_specifier: &ModuleSpecifier,
|
|
|
|
maybe_referrer: Option<String>,
|
|
|
|
is_dyn_import: bool,
|
2020-09-14 16:48:57 +00:00
|
|
|
) -> Pin<Box<dyn Future<Output = Result<(), AnyError>>>> {
|
2020-05-29 14:32:15 +00:00
|
|
|
let module_specifier = module_specifier.clone();
|
2020-08-18 16:30:13 +00:00
|
|
|
let target_lib = self.target_lib.clone();
|
|
|
|
let maybe_import_map = self.import_map.clone();
|
2020-09-19 23:17:35 +00:00
|
|
|
let state = op_state.borrow();
|
|
|
|
|
2020-05-29 14:32:15 +00:00
|
|
|
// Only "main" module is loaded without permission check,
|
|
|
|
// ie. module that is associated with "is_main" state
|
|
|
|
// and is not a dynamic import.
|
2020-08-18 16:30:13 +00:00
|
|
|
let permissions = if self.is_main && !is_dyn_import {
|
2020-05-29 14:32:15 +00:00
|
|
|
Permissions::allow_all()
|
|
|
|
} else {
|
2020-09-19 23:17:35 +00:00
|
|
|
state.borrow::<Permissions>().clone()
|
2020-05-29 14:32:15 +00:00
|
|
|
};
|
2020-10-13 11:35:35 +00:00
|
|
|
let program_state = state.borrow::<Arc<ProgramState>>().clone();
|
2020-09-19 23:17:35 +00:00
|
|
|
drop(state);
|
|
|
|
|
2020-05-29 14:32:15 +00:00
|
|
|
// TODO(bartlomieju): I'm not sure if it's correct to ignore
|
|
|
|
// bad referrer - this is the case for `Deno.core.evalContext()` where
|
|
|
|
// `ref_str` is `<unknown>`.
|
|
|
|
let maybe_referrer = if let Some(ref_str) = maybe_referrer {
|
|
|
|
ModuleSpecifier::resolve_url(&ref_str).ok()
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
|
|
|
// TODO(bartlomieju): `prepare_module_load` should take `load_id` param
|
|
|
|
async move {
|
2020-10-13 11:35:35 +00:00
|
|
|
program_state
|
2020-05-29 14:32:15 +00:00
|
|
|
.prepare_module_load(
|
|
|
|
module_specifier,
|
|
|
|
maybe_referrer,
|
|
|
|
target_lib,
|
|
|
|
permissions,
|
|
|
|
is_dyn_import,
|
|
|
|
maybe_import_map,
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
.boxed_local()
|
2020-04-30 12:37:06 +00:00
|
|
|
}
|
2019-06-05 20:35:38 +00:00
|
|
|
}
|