1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-22 15:06:54 -05:00
denoland-deno/cli/module_graph.rs
2021-04-11 07:56:40 +10:00

2606 lines
86 KiB
Rust

// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
use crate::ast;
use crate::ast::parse;
use crate::ast::transpile_module;
use crate::ast::BundleHook;
use crate::ast::Location;
use crate::ast::ParsedModule;
use crate::checksum;
use crate::colors;
use crate::diagnostics::Diagnostics;
use crate::import_map::ImportMap;
use crate::info;
use crate::lockfile::Lockfile;
use crate::media_type::MediaType;
use crate::specifier_handler::CachedModule;
use crate::specifier_handler::Dependency;
use crate::specifier_handler::DependencyMap;
use crate::specifier_handler::Emit;
use crate::specifier_handler::FetchFuture;
use crate::specifier_handler::SpecifierHandler;
use crate::tsc;
use crate::tsc_config::IgnoredCompilerOptions;
use crate::tsc_config::TsConfig;
use crate::version;
use deno_core::error::anyhow;
use deno_core::error::custom_error;
use deno_core::error::get_custom_error_class;
use deno_core::error::AnyError;
use deno_core::error::Context;
use deno_core::futures::stream::FuturesUnordered;
use deno_core::futures::stream::StreamExt;
use deno_core::resolve_url_or_path;
use deno_core::serde::Deserialize;
use deno_core::serde::Deserializer;
use deno_core::serde::Serialize;
use deno_core::serde::Serializer;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::ModuleResolutionError;
use deno_core::ModuleSource;
use deno_core::ModuleSpecifier;
use log::debug;
use regex::Regex;
use std::collections::HashMap;
use std::collections::HashSet;
use std::error::Error;
use std::fmt;
use std::path::PathBuf;
use std::rc::Rc;
use std::result;
use std::sync::Arc;
use std::sync::Mutex;
use std::time::Instant;
lazy_static::lazy_static! {
/// Matched the `@deno-types` pragma.
static ref DENO_TYPES_RE: Regex =
Regex::new(r#"(?i)^\s*@deno-types\s*=\s*(?:["']([^"']+)["']|(\S+))"#)
.unwrap();
/// Matches a `/// <reference ... />` comment reference.
static ref TRIPLE_SLASH_REFERENCE_RE: Regex =
Regex::new(r"(?i)^/\s*<reference\s.*?/>").unwrap();
/// Matches a path reference, which adds a dependency to a module
static ref PATH_REFERENCE_RE: Regex =
Regex::new(r#"(?i)\spath\s*=\s*["']([^"']*)["']"#).unwrap();
/// Matches a types reference, which for JavaScript files indicates the
/// location of types to use when type checking a program that includes it as
/// a dependency.
static ref TYPES_REFERENCE_RE: Regex =
Regex::new(r#"(?i)\stypes\s*=\s*["']([^"']*)["']"#).unwrap();
}
/// A group of errors that represent errors that can occur when interacting with
/// a module graph.
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum GraphError {
/// A module using the HTTPS protocol is trying to import a module with an
/// HTTP schema.
InvalidDowngrade(ModuleSpecifier, Location),
/// A remote module is trying to import a local module.
InvalidLocalImport(ModuleSpecifier, Location),
/// The source code is invalid, as it does not match the expected hash in the
/// lockfile.
InvalidSource(ModuleSpecifier, PathBuf),
/// An unexpected dependency was requested for a module.
MissingDependency(ModuleSpecifier, String),
/// An unexpected specifier was requested.
MissingSpecifier(ModuleSpecifier),
/// The current feature is not supported.
NotSupported(String),
/// A unsupported media type was attempted to be imported as a module.
UnsupportedImportType(ModuleSpecifier, MediaType),
}
impl fmt::Display for GraphError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
GraphError::InvalidDowngrade(ref specifier, ref location) => write!(f, "Modules imported via https are not allowed to import http modules.\n Importing: {}\n at {}", specifier, location),
GraphError::InvalidLocalImport(ref specifier, ref location) => write!(f, "Remote modules are not allowed to import local modules. Consider using a dynamic import instead.\n Importing: {}\n at {}", specifier, location),
GraphError::InvalidSource(ref specifier, ref lockfile) => write!(f, "The source code is invalid, as it does not match the expected hash in the lock file.\n Specifier: {}\n Lock file: {}", specifier, lockfile.to_str().unwrap()),
GraphError::MissingDependency(ref referrer, specifier) => write!(
f,
"The graph is missing a dependency.\n Specifier: {} from {}",
specifier, referrer
),
GraphError::MissingSpecifier(ref specifier) => write!(
f,
"The graph is missing a specifier.\n Specifier: {}",
specifier
),
GraphError::NotSupported(ref msg) => write!(f, "{}", msg),
GraphError::UnsupportedImportType(ref specifier, ref media_type) => write!(f, "An unsupported media type was attempted to be imported as a module.\n Specifier: {}\n MediaType: {}", specifier, media_type),
}
}
}
impl Error for GraphError {}
/// A structure for handling bundle loading, which is implemented here, to
/// avoid a circular dependency with `ast`.
struct BundleLoader<'a> {
cm: Rc<swc_common::SourceMap>,
emit_options: &'a ast::EmitOptions,
globals: &'a swc_common::Globals,
graph: &'a Graph,
}
impl<'a> BundleLoader<'a> {
pub fn new(
graph: &'a Graph,
emit_options: &'a ast::EmitOptions,
globals: &'a swc_common::Globals,
cm: Rc<swc_common::SourceMap>,
) -> Self {
BundleLoader {
cm,
emit_options,
globals,
graph,
}
}
}
impl swc_bundler::Load for BundleLoader<'_> {
fn load(
&self,
file: &swc_common::FileName,
) -> Result<swc_bundler::ModuleData, AnyError> {
match file {
swc_common::FileName::Custom(filename) => {
let specifier = resolve_url_or_path(filename)
.context("Failed to convert swc FileName to ModuleSpecifier.")?;
if let Some(src) = self.graph.get_source(&specifier) {
let media_type = self
.graph
.get_media_type(&specifier)
.context("Looking up media type during bundling.")?;
let (source_file, module) = transpile_module(
filename,
&src,
&media_type,
self.emit_options,
self.globals,
self.cm.clone(),
)?;
Ok(swc_bundler::ModuleData {
fm: source_file,
module,
helpers: Default::default(),
})
} else {
Err(
GraphError::MissingDependency(specifier, "<bundle>".to_string())
.into(),
)
}
}
_ => unreachable!("Received request for unsupported filename {:?}", file),
}
}
}
/// An enum which represents the parsed out values of references in source code.
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TypeScriptReference {
Path(String),
Types(String),
}
/// Determine if a comment contains a triple slash reference and optionally
/// return its kind and value.
pub fn parse_ts_reference(comment: &str) -> Option<TypeScriptReference> {
if !TRIPLE_SLASH_REFERENCE_RE.is_match(comment) {
None
} else if let Some(captures) = PATH_REFERENCE_RE.captures(comment) {
Some(TypeScriptReference::Path(
captures.get(1).unwrap().as_str().to_string(),
))
} else {
TYPES_REFERENCE_RE.captures(comment).map(|captures| {
TypeScriptReference::Types(captures.get(1).unwrap().as_str().to_string())
})
}
}
/// Determine if a comment contains a `@deno-types` pragma and optionally return
/// its value.
pub fn parse_deno_types(comment: &str) -> Option<String> {
if let Some(captures) = DENO_TYPES_RE.captures(comment) {
if let Some(m) = captures.get(1) {
Some(m.as_str().to_string())
} else if let Some(m) = captures.get(2) {
Some(m.as_str().to_string())
} else {
panic!("unreachable");
}
} else {
None
}
}
/// A hashing function that takes the source code, version and optionally a
/// user provided config and generates a string hash which can be stored to
/// determine if the cached emit is valid or not.
fn get_version(source: &str, version: &str, config: &[u8]) -> String {
crate::checksum::gen(&[source.as_bytes(), version.as_bytes(), config])
}
/// A logical representation of a module within a graph.
#[derive(Debug, Clone)]
pub struct Module {
pub dependencies: DependencyMap,
is_dirty: bool,
is_parsed: bool,
maybe_emit: Option<Emit>,
maybe_emit_path: Option<(PathBuf, Option<PathBuf>)>,
maybe_import_map: Option<Arc<Mutex<ImportMap>>>,
maybe_types: Option<(String, ModuleSpecifier)>,
maybe_version: Option<String>,
media_type: MediaType,
specifier: ModuleSpecifier,
source: String,
source_path: PathBuf,
}
impl Default for Module {
fn default() -> Self {
Module {
dependencies: HashMap::new(),
is_dirty: false,
is_parsed: false,
maybe_emit: None,
maybe_emit_path: None,
maybe_import_map: None,
maybe_types: None,
maybe_version: None,
media_type: MediaType::Unknown,
specifier: deno_core::resolve_url("file:///example.js").unwrap(),
source: "".to_string(),
source_path: PathBuf::new(),
}
}
}
impl Module {
pub fn new(
cached_module: CachedModule,
is_root: bool,
maybe_import_map: Option<Arc<Mutex<ImportMap>>>,
) -> Self {
// If this is a local root file, and its media type is unknown, set the
// media type to JavaScript. This allows easier ability to create "shell"
// scripts with Deno.
let media_type = if is_root
&& !cached_module.is_remote
&& cached_module.media_type == MediaType::Unknown
{
MediaType::JavaScript
} else {
cached_module.media_type
};
let mut module = Module {
specifier: cached_module.specifier,
maybe_import_map,
media_type,
source: cached_module.source,
source_path: cached_module.source_path,
maybe_emit: cached_module.maybe_emit,
maybe_emit_path: cached_module.maybe_emit_path,
maybe_version: cached_module.maybe_version,
is_dirty: false,
..Self::default()
};
if module.maybe_import_map.is_none() {
if let Some(dependencies) = cached_module.maybe_dependencies {
module.dependencies = dependencies;
module.is_parsed = true;
}
}
module.maybe_types = cached_module.maybe_types.map(|specifier| {
(
specifier.clone(),
module
.resolve_import(&specifier, None)
.expect("could not resolve module"),
)
});
module
}
/// Return `true` if the current hash of the module matches the stored
/// version.
pub fn is_emit_valid(&self, config: &[u8]) -> bool {
if let Some(version) = self.maybe_version.clone() {
version == get_version(&self.source, &version::deno(), config)
} else {
false
}
}
/// Parse a module, populating the structure with data retrieved from the
/// source of the module.
pub fn parse(&mut self) -> Result<ParsedModule, AnyError> {
let parsed_module =
parse(self.specifier.as_str(), &self.source, &self.media_type)?;
// parse out any triple slash references
for comment in parsed_module.get_leading_comments().iter() {
if let Some(ts_reference) = parse_ts_reference(&comment.text) {
let location = parsed_module.get_location(&comment.span);
match ts_reference {
TypeScriptReference::Path(import) => {
let specifier =
self.resolve_import(&import, Some(location.clone()))?;
let dep = self
.dependencies
.entry(import)
.or_insert_with(|| Dependency::new(location));
dep.maybe_code = Some(specifier);
}
TypeScriptReference::Types(import) => {
let specifier =
self.resolve_import(&import, Some(location.clone()))?;
if self.media_type == MediaType::JavaScript
|| self.media_type == MediaType::Jsx
{
// TODO(kitsonk) we need to specifically update the cache when
// this value changes
self.maybe_types = Some((import.clone(), specifier));
} else {
let dep = self
.dependencies
.entry(import)
.or_insert_with(|| Dependency::new(location));
dep.maybe_type = Some(specifier);
}
}
}
}
}
// Parse out all the syntactical dependencies for a module
let dependencies = parsed_module.analyze_dependencies();
for desc in dependencies.iter().filter(|desc| {
desc.kind != swc_ecmascript::dep_graph::DependencyKind::Require
}) {
let location = Location {
filename: self.specifier.to_string(),
col: desc.col,
line: desc.line,
};
// In situations where there is a potential issue with resolving the
// import specifier, that ends up being a module resolution error for a
// code dependency, we should not throw in the `ModuleGraph` but instead
// wait until runtime and throw there, as with dynamic imports they need
// to be catchable, which means they need to be resolved at runtime.
let maybe_specifier =
match self.resolve_import(&desc.specifier, Some(location.clone())) {
Ok(specifier) => Some(specifier),
Err(any_error) => {
match any_error.downcast_ref::<ModuleResolutionError>() {
Some(ModuleResolutionError::ImportPrefixMissing(_, _)) => None,
_ => {
return Err(any_error);
}
}
}
};
// Parse out any `@deno-types` pragmas and modify dependency
let maybe_type = if !desc.leading_comments.is_empty() {
let comment = desc.leading_comments.last().unwrap();
if let Some(deno_types) = parse_deno_types(&comment.text).as_ref() {
Some(self.resolve_import(deno_types, Some(location.clone()))?)
} else {
None
}
} else {
None
};
let dep = self
.dependencies
.entry(desc.specifier.to_string())
.or_insert_with(|| Dependency::new(location));
dep.is_dynamic = desc.is_dynamic;
if let Some(specifier) = maybe_specifier {
if desc.kind == swc_ecmascript::dep_graph::DependencyKind::ExportType
|| desc.kind == swc_ecmascript::dep_graph::DependencyKind::ImportType
{
dep.maybe_type = Some(specifier);
} else {
dep.maybe_code = Some(specifier);
}
}
// If the dependency wasn't a type only dependency already, and there is
// a `@deno-types` comment, then we will set the `maybe_type` dependency.
if maybe_type.is_some() && dep.maybe_type.is_none() {
dep.maybe_type = maybe_type;
}
}
Ok(parsed_module)
}
fn resolve_import(
&self,
specifier: &str,
maybe_location: Option<Location>,
) -> Result<ModuleSpecifier, AnyError> {
let maybe_resolve = if let Some(import_map) = self.maybe_import_map.clone()
{
import_map
.lock()
.unwrap()
.resolve(specifier, self.specifier.as_str())?
} else {
None
};
let mut remapped_import = false;
let specifier = if let Some(module_specifier) = maybe_resolve {
remapped_import = true;
module_specifier
} else {
deno_core::resolve_import(specifier, self.specifier.as_str())?
};
let referrer_scheme = self.specifier.scheme();
let specifier_scheme = specifier.scheme();
let location = maybe_location.unwrap_or(Location {
filename: self.specifier.to_string(),
line: 0,
col: 0,
});
// Disallow downgrades from HTTPS to HTTP
if referrer_scheme == "https" && specifier_scheme == "http" {
return Err(
GraphError::InvalidDowngrade(specifier.clone(), location).into(),
);
}
// Disallow a remote URL from trying to import a local URL, unless it is a
// remapped import via the import map
if (referrer_scheme == "https" || referrer_scheme == "http")
&& !(specifier_scheme == "https" || specifier_scheme == "http")
&& !remapped_import
{
return Err(
GraphError::InvalidLocalImport(specifier.clone(), location).into(),
);
}
Ok(specifier)
}
pub fn set_emit(&mut self, code: String, maybe_map: Option<String>) {
self.maybe_emit = Some(Emit::Cli((code, maybe_map)));
}
/// Calculate the hashed version of the module and update the `maybe_version`.
pub fn set_version(&mut self, config: &[u8]) {
self.maybe_version =
Some(get_version(&self.source, &version::deno(), config))
}
pub fn size(&self) -> usize {
self.source.as_bytes().len()
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct Stats(pub Vec<(String, u32)>);
impl<'de> Deserialize<'de> for Stats {
fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let items: Vec<(String, u32)> = Deserialize::deserialize(deserializer)?;
Ok(Stats(items))
}
}
impl Serialize for Stats {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Serialize::serialize(&self.0, serializer)
}
}
impl fmt::Display for Stats {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "Compilation statistics:")?;
for (key, value) in self.0.clone() {
writeln!(f, " {}: {}", key, value)?;
}
Ok(())
}
}
/// A structure that provides information about a module graph result.
#[derive(Debug, Default)]
pub struct ResultInfo {
/// A structure which provides diagnostic information (usually from `tsc`)
/// about the code in the module graph.
pub diagnostics: Diagnostics,
/// A map of specifiers to the result of their resolution in the module graph.
pub loadable_modules:
HashMap<ModuleSpecifier, Result<ModuleSource, AnyError>>,
/// Optionally ignored compiler options that represent any options that were
/// ignored if there was a user provided configuration.
pub maybe_ignored_options: Option<IgnoredCompilerOptions>,
/// A structure providing key metrics around the operation performed, in
/// milliseconds.
pub stats: Stats,
}
/// Represents the "default" type library that should be used when type
/// checking the code in the module graph. Note that a user provided config
/// of `"lib"` would override this value.
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TypeLib {
DenoWindow,
DenoWorker,
UnstableDenoWindow,
UnstableDenoWorker,
}
impl Default for TypeLib {
fn default() -> Self {
TypeLib::DenoWindow
}
}
impl Serialize for TypeLib {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let value = match self {
TypeLib::DenoWindow => vec!["deno.window".to_string()],
TypeLib::DenoWorker => vec!["deno.worker".to_string()],
TypeLib::UnstableDenoWindow => {
vec!["deno.window".to_string(), "deno.unstable".to_string()]
}
TypeLib::UnstableDenoWorker => {
vec!["deno.worker".to_string(), "deno.unstable".to_string()]
}
};
Serialize::serialize(&value, serializer)
}
}
#[derive(Debug, Default)]
pub struct BundleOptions {
/// If `true` then debug logging will be output from the isolate.
pub debug: bool,
/// An optional string that points to a user supplied TypeScript configuration
/// file that augments the the default configuration passed to the TypeScript
/// compiler.
pub maybe_config_path: Option<String>,
}
#[derive(Debug, Default)]
pub struct CheckOptions {
/// If `true` then debug logging will be output from the isolate.
pub debug: bool,
/// Utilise the emit from `tsc` to update the emitted code for modules.
pub emit: bool,
/// The base type libraries that should be used when type checking.
pub lib: TypeLib,
/// An optional string that points to a user supplied TypeScript configuration
/// file that augments the the default configuration passed to the TypeScript
/// compiler.
pub maybe_config_path: Option<String>,
/// Ignore any previously emits and ensure that all files are emitted from
/// source.
pub reload: bool,
}
#[derive(Debug, Eq, PartialEq)]
pub enum BundleType {
/// Return the emitted contents of the program as a single "flattened" ES
/// module.
Esm,
/// Return the emitted contents of the program as a single script that
/// executes the program using an immediately invoked function execution
/// (IIFE).
Iife,
/// Do not bundle the emit, instead returning each of the modules that are
/// part of the program as individual files.
None,
}
impl Default for BundleType {
fn default() -> Self {
BundleType::None
}
}
#[derive(Debug, Default)]
pub struct EmitOptions {
/// If true, then code will be type checked, otherwise type checking will be
/// skipped. If false, then swc will be used for the emit, otherwise tsc will
/// be used.
pub check: bool,
/// Indicate the form the result of the emit should take.
pub bundle_type: BundleType,
/// If `true` then debug logging will be output from the isolate.
pub debug: bool,
/// An optional map that contains user supplied TypeScript compiler
/// configuration options that are passed to the TypeScript compiler.
pub maybe_user_config: Option<HashMap<String, Value>>,
}
/// A structure which provides options when transpiling modules.
#[derive(Debug, Default)]
pub struct TranspileOptions {
/// If `true` then debug logging will be output from the isolate.
pub debug: bool,
/// An optional string that points to a user supplied TypeScript configuration
/// file that augments the the default configuration passed to the TypeScript
/// compiler.
pub maybe_config_path: Option<String>,
/// Ignore any previously emits and ensure that all files are emitted from
/// source.
pub reload: bool,
}
#[derive(Debug, Clone)]
enum ModuleSlot {
/// The module fetch resulted in a non-recoverable error.
Err(Arc<AnyError>),
/// The the fetch resulted in a module.
Module(Box<Module>),
/// Used to denote a module that isn't part of the graph.
None,
/// The fetch of the module is pending.
Pending,
}
/// A dependency graph of modules, were the modules that have been inserted via
/// the builder will be loaded into the graph. Also provides an interface to
/// be able to manipulate and handle the graph.
#[derive(Debug, Clone)]
pub struct Graph {
/// A reference to the specifier handler that will retrieve and cache modules
/// for the graph.
handler: Arc<Mutex<dyn SpecifierHandler>>,
/// Optional TypeScript build info that will be passed to `tsc` if `tsc` is
/// invoked.
maybe_tsbuildinfo: Option<String>,
/// The modules that are part of the graph.
modules: HashMap<ModuleSpecifier, ModuleSlot>,
/// A map of redirects, where a module specifier is redirected to another
/// module specifier by the handler. All modules references should be
/// resolved internally via this, before attempting to access the module via
/// the handler, to make sure the correct modules is being dealt with.
redirects: HashMap<ModuleSpecifier, ModuleSpecifier>,
/// The module specifiers that have been uniquely added to the graph, which
/// does not include any transient dependencies.
roots: Vec<ModuleSpecifier>,
/// If all of the root modules are dynamically imported, then this is true.
/// This is used to ensure correct `--reload` behavior, where subsequent
/// calls to a module graph where the emit is already valid do not cause the
/// graph to re-emit.
roots_dynamic: bool,
// A reference to lock file that will be used to check module integrity.
maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
}
/// Convert a specifier and a module slot in a result to the module source which
/// is needed by Deno core for loading the module.
fn to_module_result(
(specifier, module_slot): (&ModuleSpecifier, &ModuleSlot),
) -> (ModuleSpecifier, Result<ModuleSource, AnyError>) {
match module_slot {
ModuleSlot::Err(err) => (specifier.clone(), Err(anyhow!(err.to_string()))),
ModuleSlot::Module(module) => (
specifier.clone(),
if let Some(emit) = &module.maybe_emit {
match emit {
Emit::Cli((code, _)) => Ok(ModuleSource {
code: code.clone(),
module_url_found: module.specifier.to_string(),
module_url_specified: specifier.to_string(),
}),
}
} else {
match module.media_type {
MediaType::JavaScript | MediaType::Unknown => Ok(ModuleSource {
code: module.source.clone(),
module_url_found: module.specifier.to_string(),
module_url_specified: specifier.to_string(),
}),
_ => Err(custom_error(
"NotFound",
format!("Compiled module not found \"{}\"", specifier),
)),
}
},
),
_ => (
specifier.clone(),
Err(anyhow!("Module \"{}\" unavailable.", specifier)),
),
}
}
impl Graph {
/// Create a new instance of a graph, ready to have modules loaded it.
///
/// The argument `handler` is an instance of a structure that implements the
/// `SpecifierHandler` trait.
///
pub fn new(
handler: Arc<Mutex<dyn SpecifierHandler>>,
maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
) -> Self {
Graph {
handler,
maybe_tsbuildinfo: None,
modules: HashMap::new(),
redirects: HashMap::new(),
roots: Vec::new(),
roots_dynamic: true,
maybe_lockfile,
}
}
/// Transform the module graph into a single JavaScript module which is
/// returned as a `String` in the result.
pub fn bundle(
&self,
options: BundleOptions,
) -> Result<(String, Stats, Option<IgnoredCompilerOptions>), AnyError> {
if self.roots.is_empty() || self.roots.len() > 1 {
return Err(GraphError::NotSupported(format!("Bundling is only supported when there is a single root module in the graph. Found: {}", self.roots.len())).into());
}
let start = Instant::now();
let root_specifier = self.roots[0].clone();
let mut ts_config = TsConfig::new(json!({
"checkJs": false,
"emitDecoratorMetadata": false,
"importsNotUsedAsValues": "remove",
"inlineSourceMap": true,
"jsx": "react",
"jsxFactory": "React.createElement",
"jsxFragmentFactory": "React.Fragment",
}));
let maybe_ignored_options =
ts_config.merge_tsconfig(options.maybe_config_path)?;
let s =
self.emit_bundle(&root_specifier, &ts_config.into(), &BundleType::Esm)?;
let stats = Stats(vec![
("Files".to_string(), self.modules.len() as u32),
("Total time".to_string(), start.elapsed().as_millis() as u32),
]);
Ok((s, stats, maybe_ignored_options))
}
/// Type check the module graph, corresponding to the options provided.
pub fn check(self, options: CheckOptions) -> Result<ResultInfo, AnyError> {
self.validate()?;
let mut config = TsConfig::new(json!({
"allowJs": true,
// TODO(@kitsonk) is this really needed?
"esModuleInterop": true,
// Enabled by default to align to transpile/swc defaults
"experimentalDecorators": true,
"incremental": true,
"jsx": "react",
"isolatedModules": true,
"lib": options.lib,
"module": "esnext",
"strict": true,
"target": "esnext",
"tsBuildInfoFile": "deno:///.tsbuildinfo",
"useDefineForClassFields": true,
}));
if options.emit {
config.merge(&json!({
// TODO(@kitsonk) consider enabling this by default
// see: https://github.com/denoland/deno/issues/7732
"emitDecoratorMetadata": false,
"importsNotUsedAsValues": "remove",
"inlineSourceMap": true,
"outDir": "deno://",
"removeComments": true,
}));
} else {
config.merge(&json!({
"noEmit": true,
}));
}
let maybe_ignored_options =
config.merge_tsconfig(options.maybe_config_path)?;
// Short circuit if none of the modules require an emit, or all of the
// modules that require an emit have a valid emit. There is also an edge
// case where there are multiple imports of a dynamic module during a
// single invocation, if that is the case, even if there is a reload, we
// will simply look at if the emit is invalid, to avoid two checks for the
// same programme.
if !self.needs_emit(&config)
|| (self.is_emit_valid(&config)
&& (!options.reload || self.roots_dynamic))
{
debug!("graph does not need to be checked or emitted.");
return Ok(ResultInfo {
maybe_ignored_options,
loadable_modules: self.get_loadable_modules(),
..Default::default()
});
}
// TODO(@kitsonk) not totally happy with this here, but this is the first
// point where we know we are actually going to check the program. If we
// moved it out of here, we wouldn't know until after the check has already
// happened, which isn't informative to the users.
for specifier in &self.roots {
log::info!("{} {}", colors::green("Check"), specifier);
}
let root_names = self.get_root_names(!config.get_check_js())?;
let maybe_tsbuildinfo = self.maybe_tsbuildinfo.clone();
let hash_data =
vec![config.as_bytes(), version::deno().as_bytes().to_owned()];
let graph = Arc::new(Mutex::new(self));
let response = tsc::exec(tsc::Request {
config: config.clone(),
debug: options.debug,
graph: graph.clone(),
hash_data,
maybe_tsbuildinfo,
root_names,
})?;
let mut graph = graph.lock().unwrap();
graph.maybe_tsbuildinfo = response.maybe_tsbuildinfo;
// Only process changes to the graph if there are no diagnostics and there
// were files emitted.
if response.diagnostics.is_empty() {
if !response.emitted_files.is_empty() {
let mut codes = HashMap::new();
let mut maps = HashMap::new();
let check_js = config.get_check_js();
for emit in &response.emitted_files {
if let Some(specifiers) = &emit.maybe_specifiers {
assert!(specifiers.len() == 1, "Unexpected specifier length");
// The specifier emitted might not be the redirected specifier, and
// therefore we need to ensure it is the correct one.
let specifier = graph.resolve_specifier(&specifiers[0]);
// Sometimes if tsc sees a CommonJS file it will _helpfully_ output it
// to ESM, which we don't really want unless someone has enabled the
// check_js option.
if !check_js
&& graph.get_media_type(&specifier) == Some(MediaType::JavaScript)
{
debug!("skipping emit for {}", specifier);
continue;
}
match emit.media_type {
MediaType::JavaScript => {
codes.insert(specifier.clone(), emit.data.clone());
}
MediaType::SourceMap => {
maps.insert(specifier.clone(), emit.data.clone());
}
_ => unreachable!(),
}
}
}
let config = config.as_bytes();
for (specifier, code) in codes.iter() {
if let ModuleSlot::Module(module) =
graph.get_module_mut(specifier).unwrap()
{
module.set_emit(code.clone(), maps.get(specifier).cloned());
module.set_version(&config);
module.is_dirty = true;
} else {
return Err(GraphError::MissingSpecifier(specifier.clone()).into());
}
}
}
graph.flush()?;
}
Ok(ResultInfo {
diagnostics: response.diagnostics,
loadable_modules: graph.get_loadable_modules(),
maybe_ignored_options,
stats: response.stats,
})
}
/// Emit the module graph in a specific format. This is specifically designed
/// to be an "all-in-one" API for access by the runtime, allowing both
/// emitting single modules as well as bundles, using Deno module resolution
/// or supplied sources.
pub fn emit(
mut self,
options: EmitOptions,
) -> Result<(HashMap<String, String>, ResultInfo), AnyError> {
let mut config = TsConfig::new(json!({
"allowJs": true,
"checkJs": false,
// TODO(@kitsonk) consider enabling this by default
// see: https://github.com/denoland/deno/issues/7732
"emitDecoratorMetadata": false,
"esModuleInterop": true,
"experimentalDecorators": true,
"importsNotUsedAsValues": "remove",
"inlineSourceMap": false,
"isolatedModules": true,
"jsx": "react",
"jsxFactory": "React.createElement",
"jsxFragmentFactory": "React.Fragment",
"lib": TypeLib::DenoWindow,
"module": "esnext",
"strict": true,
"target": "esnext",
"useDefineForClassFields": true,
}));
let opts = match options.bundle_type {
BundleType::Esm | BundleType::Iife => json!({
"noEmit": true,
}),
BundleType::None => json!({
"outDir": "deno://",
"removeComments": true,
"sourceMap": true,
}),
};
config.merge(&opts);
let maybe_ignored_options =
if let Some(user_options) = &options.maybe_user_config {
config.merge_user_config(user_options)?
} else {
None
};
if !options.check && config.get_declaration() {
return Err(anyhow!("The option of `check` is false, but the compiler option of `declaration` is true which is not currently supported."));
}
if options.bundle_type != BundleType::None && config.get_declaration() {
return Err(anyhow!("The bundle option is set, but the compiler option of `declaration` is true which is not currently supported."));
}
let mut emitted_files = HashMap::new();
if options.check {
let root_names = self.get_root_names(!config.get_check_js())?;
let hash_data =
vec![config.as_bytes(), version::deno().as_bytes().to_owned()];
let graph = Arc::new(Mutex::new(self));
let response = tsc::exec(tsc::Request {
config: config.clone(),
debug: options.debug,
graph: graph.clone(),
hash_data,
maybe_tsbuildinfo: None,
root_names,
})?;
let graph = graph.lock().unwrap();
match options.bundle_type {
BundleType::Esm | BundleType::Iife => {
assert!(
response.emitted_files.is_empty(),
"No files should have been emitted from tsc."
);
assert_eq!(
graph.roots.len(),
1,
"Only a single root module supported."
);
let specifier = &graph.roots[0];
let s = graph.emit_bundle(
specifier,
&config.into(),
&options.bundle_type,
)?;
emitted_files.insert("deno:///bundle.js".to_string(), s);
}
BundleType::None => {
for emitted_file in &response.emitted_files {
assert!(
emitted_file.maybe_specifiers.is_some(),
"Orphaned file emitted."
);
let specifiers = emitted_file.maybe_specifiers.clone().unwrap();
assert_eq!(
specifiers.len(),
1,
"An unexpected number of specifiers associated with emitted file."
);
let specifier = specifiers[0].clone();
let extension = match emitted_file.media_type {
MediaType::JavaScript => ".js",
MediaType::SourceMap => ".js.map",
MediaType::Dts => ".d.ts",
_ => unreachable!(),
};
let key = format!("{}{}", specifier, extension);
emitted_files.insert(key, emitted_file.data.clone());
}
}
};
Ok((
emitted_files,
ResultInfo {
diagnostics: response.diagnostics,
loadable_modules: graph.get_loadable_modules(),
maybe_ignored_options,
stats: response.stats,
},
))
} else {
let start = Instant::now();
let mut emit_count = 0_u32;
match options.bundle_type {
BundleType::Esm | BundleType::Iife => {
assert_eq!(
self.roots.len(),
1,
"Only a single root module supported."
);
let specifier = &self.roots[0];
let s = self.emit_bundle(
specifier,
&config.into(),
&options.bundle_type,
)?;
emit_count += 1;
emitted_files.insert("deno:///bundle.js".to_string(), s);
}
BundleType::None => {
let emit_options: ast::EmitOptions = config.into();
for (_, module_slot) in self.modules.iter_mut() {
if let ModuleSlot::Module(module) = module_slot {
if !(emit_options.check_js
|| module.media_type == MediaType::Jsx
|| module.media_type == MediaType::Tsx
|| module.media_type == MediaType::TypeScript)
{
emitted_files
.insert(module.specifier.to_string(), module.source.clone());
}
let parsed_module = module.parse()?;
let (code, maybe_map) = parsed_module.transpile(&emit_options)?;
emit_count += 1;
emitted_files.insert(format!("{}.js", module.specifier), code);
if let Some(map) = maybe_map {
emitted_files
.insert(format!("{}.js.map", module.specifier), map);
}
}
}
self.flush()?;
}
}
let stats = Stats(vec![
("Files".to_string(), self.modules.len() as u32),
("Emitted".to_string(), emit_count),
("Total time".to_string(), start.elapsed().as_millis() as u32),
]);
Ok((
emitted_files,
ResultInfo {
diagnostics: Default::default(),
loadable_modules: self.get_loadable_modules(),
maybe_ignored_options,
stats,
},
))
}
}
/// Shared between `bundle()` and `emit()`.
fn emit_bundle(
&self,
specifier: &ModuleSpecifier,
emit_options: &ast::EmitOptions,
bundle_type: &BundleType,
) -> Result<String, AnyError> {
let cm = Rc::new(swc_common::SourceMap::new(
swc_common::FilePathMapping::empty(),
));
let globals = swc_common::Globals::new();
let loader = BundleLoader::new(self, emit_options, &globals, cm.clone());
let hook = Box::new(BundleHook);
let module = match bundle_type {
BundleType::Esm => swc_bundler::ModuleType::Es,
BundleType::Iife => swc_bundler::ModuleType::Iife,
_ => unreachable!("invalid bundle type"),
};
let bundler = swc_bundler::Bundler::new(
&globals,
cm.clone(),
loader,
self,
swc_bundler::Config {
module,
..Default::default()
},
hook,
);
let mut entries = HashMap::new();
entries.insert(
"bundle".to_string(),
swc_common::FileName::Custom(specifier.to_string()),
);
let output = bundler
.bundle(entries)
.context("Unable to output bundle during Graph::bundle().")?;
let mut buf = Vec::new();
{
let mut emitter = swc_ecmascript::codegen::Emitter {
cfg: swc_ecmascript::codegen::Config { minify: false },
cm: cm.clone(),
comments: None,
wr: Box::new(swc_ecmascript::codegen::text_writer::JsWriter::new(
cm, "\n", &mut buf, None,
)),
};
emitter
.emit_module(&output[0].module)
.context("Unable to emit bundle during Graph::bundle().")?;
}
String::from_utf8(buf).context("Emitted bundle is an invalid utf-8 string.")
}
/// Update the handler with any modules that are marked as _dirty_ and update
/// any build info if present.
fn flush(&mut self) -> Result<(), AnyError> {
let mut handler = self.handler.lock().unwrap();
for (_, module_slot) in self.modules.iter_mut() {
if let ModuleSlot::Module(module) = module_slot {
if module.is_dirty {
if let Some(emit) = &module.maybe_emit {
handler.set_cache(&module.specifier, emit)?;
}
if let Some(version) = &module.maybe_version {
handler.set_version(&module.specifier, version.clone())?;
}
module.is_dirty = false;
}
}
}
for root_specifier in self.roots.iter() {
if let Some(tsbuildinfo) = &self.maybe_tsbuildinfo {
handler.set_tsbuildinfo(root_specifier, tsbuildinfo.to_owned())?;
}
}
Ok(())
}
/// Retrieve a map that contains a representation of each module in the graph
/// which can be used to provide code to a module loader without holding all
/// the state to be able to operate on the graph.
pub fn get_loadable_modules(
&self,
) -> HashMap<ModuleSpecifier, Result<ModuleSource, AnyError>> {
let mut loadable_modules: HashMap<
ModuleSpecifier,
Result<ModuleSource, AnyError>,
> = self.modules.iter().map(to_module_result).collect();
for (specifier, _) in self.redirects.iter() {
if let Some(module_slot) =
self.modules.get(self.resolve_specifier(specifier))
{
let (_, result) = to_module_result((specifier, module_slot));
loadable_modules.insert(specifier.clone(), result);
}
}
loadable_modules
}
pub fn get_media_type(
&self,
specifier: &ModuleSpecifier,
) -> Option<MediaType> {
if let ModuleSlot::Module(module) = self.get_module(specifier) {
Some(module.media_type)
} else {
None
}
}
fn get_module(&self, specifier: &ModuleSpecifier) -> &ModuleSlot {
let s = self.resolve_specifier(specifier);
if let Some(module_slot) = self.modules.get(s) {
module_slot
} else {
&ModuleSlot::None
}
}
fn get_module_mut(
&mut self,
specifier: &ModuleSpecifier,
) -> Option<&mut ModuleSlot> {
// this is duplicated code because `.resolve_specifier` requires an
// immutable borrow, but if `.resolve_specifier` is mut, then everything
// that calls it is is mut
let mut s = specifier;
while let Some(redirect) = self.redirects.get(s) {
s = redirect;
}
self.modules.get_mut(s)
}
/// Consume graph and return list of all module specifiers contained in the
/// graph.
pub fn get_modules(&self) -> Vec<ModuleSpecifier> {
self.modules.keys().map(|s| s.to_owned()).collect()
}
/// Transform `self.roots` into something that works for `tsc`, because `tsc`
/// doesn't like root names without extensions that match its expectations,
/// nor does it have any concept of redirection, so we have to resolve all
/// that upfront before feeding it to `tsc`. In addition, if checkJs is not
/// true, we should pass all emittable files in as the roots, so that `tsc`
/// type checks them and potentially emits them.
fn get_root_names(
&self,
include_emittable: bool,
) -> Result<Vec<(ModuleSpecifier, MediaType)>, AnyError> {
let root_names: Vec<ModuleSpecifier> = if include_emittable {
// in situations where there is `allowJs` with tsc, but not `checkJs`,
// then tsc will not parse the whole module graph, meaning that any
// JavaScript importing TypeScript will get ignored, meaning that those
// files will not get emitted. To counter act that behavior, we will
// include all modules that are emittable.
let mut specifiers = HashSet::<&ModuleSpecifier>::new();
for (_, module_slot) in self.modules.iter() {
if let ModuleSlot::Module(module) = module_slot {
if module.media_type == MediaType::Jsx
|| module.media_type == MediaType::TypeScript
|| module.media_type == MediaType::Tsx
{
specifiers.insert(&module.specifier);
}
}
}
// We should include all the original roots as well.
for specifier in self.roots.iter() {
specifiers.insert(specifier);
}
specifiers.into_iter().cloned().collect()
} else {
self.roots.clone()
};
let mut root_types = vec![];
for ms in root_names {
// if the root module has a types specifier, we should be sending that
// to tsc instead of the original specifier
let specifier = self.resolve_specifier(&ms);
let module = match self.get_module(specifier) {
ModuleSlot::Module(module) => module,
ModuleSlot::Err(error) => {
// It would be great if we could just clone the error here...
if let Some(class) = get_custom_error_class(error) {
return Err(custom_error(class, error.to_string()));
} else {
panic!("unsupported ModuleSlot error");
}
}
_ => {
panic!("missing module");
}
};
let specifier = if let Some((_, types_specifier)) = &module.maybe_types {
self.resolve_specifier(types_specifier)
} else {
specifier
};
root_types.push((
// root modules can be redirects, so before we pass it to tsc we need
// to resolve the redirect
specifier.clone(),
self.get_media_type(specifier).unwrap(),
));
}
Ok(root_types)
}
/// Get the source for a given module specifier. If the module is not part
/// of the graph, the result will be `None`.
pub fn get_source(&self, specifier: &ModuleSpecifier) -> Option<String> {
if let ModuleSlot::Module(module) = self.get_module(specifier) {
Some(module.source.clone())
} else {
None
}
}
/// Return a structure which provides information about the module graph and
/// the relationship of the modules in the graph. This structure is used to
/// provide information for the `info` subcommand.
pub fn info(&self) -> Result<info::ModuleGraphInfo, AnyError> {
if self.roots.is_empty() || self.roots.len() > 1 {
return Err(GraphError::NotSupported(format!("Info is only supported when there is a single root module in the graph. Found: {}", self.roots.len())).into());
}
let root = self.resolve_specifier(&self.roots[0]).clone();
let mut modules: Vec<info::ModuleGraphInfoMod> = self
.modules
.iter()
.filter_map(|(sp, sl)| match sl {
ModuleSlot::Module(module) => {
let mut dependencies: Vec<info::ModuleGraphInfoDep> = module
.dependencies
.iter()
.map(|(k, v)| info::ModuleGraphInfoDep {
specifier: k.clone(),
is_dynamic: v.is_dynamic,
maybe_code: v
.maybe_code
.clone()
.map(|s| self.resolve_specifier(&s).clone()),
maybe_type: v
.maybe_type
.clone()
.map(|s| self.resolve_specifier(&s).clone()),
})
.collect();
dependencies.sort();
let (emit, map) =
if let Some((emit, maybe_map)) = &module.maybe_emit_path {
(Some(emit.clone()), maybe_map.clone())
} else {
(None, None)
};
Some(info::ModuleGraphInfoMod {
specifier: sp.clone(),
dependencies,
size: Some(module.size()),
media_type: Some(module.media_type),
local: Some(module.source_path.clone()),
checksum: Some(checksum::gen(&[module.source.as_bytes()])),
emit,
map,
..Default::default()
})
}
ModuleSlot::Err(err) => Some(info::ModuleGraphInfoMod {
specifier: sp.clone(),
error: Some(err.to_string()),
..Default::default()
}),
_ => None,
})
.collect();
modules.sort();
let size = modules.iter().fold(0_usize, |acc, m| {
if let Some(size) = &m.size {
acc + size
} else {
acc
}
});
Ok(info::ModuleGraphInfo {
root,
modules,
size,
})
}
/// Determines if all of the modules in the graph that require an emit have
/// a valid emit. Returns `true` if all the modules have a valid emit,
/// otherwise false.
fn is_emit_valid(&self, config: &TsConfig) -> bool {
let check_js = config.get_check_js();
let config = config.as_bytes();
self.modules.iter().all(|(_, m)| {
if let ModuleSlot::Module(m) = m {
let needs_emit = match m.media_type {
MediaType::TypeScript | MediaType::Tsx | MediaType::Jsx => true,
MediaType::JavaScript => check_js,
_ => false,
};
if needs_emit {
m.is_emit_valid(&config)
} else {
true
}
} else {
true
}
})
}
/// Verify the subresource integrity of the graph based upon the optional
/// lockfile, updating the lockfile with any missing resources. This will
/// error if any of the resources do not match their lock status.
pub fn lock(&self) {
if let Some(lf) = self.maybe_lockfile.as_ref() {
let mut lockfile = lf.lock().unwrap();
for (ms, module_slot) in self.modules.iter() {
if let ModuleSlot::Module(module) = module_slot {
let specifier = module.specifier.to_string();
let valid = lockfile.check_or_insert(&specifier, &module.source);
if !valid {
eprintln!(
"{}",
GraphError::InvalidSource(ms.clone(), lockfile.filename.clone())
);
std::process::exit(10);
}
}
}
}
}
/// Determines if any of the modules in the graph are required to be emitted.
/// This is similar to `emit_valid()` except that the actual emit isn't
/// checked to determine if it is valid.
fn needs_emit(&self, config: &TsConfig) -> bool {
let check_js = config.get_check_js();
self.modules.iter().any(|(_, m)| match m {
ModuleSlot::Module(m) => match m.media_type {
MediaType::TypeScript | MediaType::Tsx | MediaType::Jsx => true,
MediaType::JavaScript => check_js,
_ => false,
},
_ => false,
})
}
/// Given a string specifier and a referring module specifier, provide the
/// resulting module specifier and media type for the module that is part of
/// the graph.
///
/// # Arguments
///
/// * `specifier` - The string form of the module specifier that needs to be
/// resolved.
/// * `referrer` - The referring `ModuleSpecifier`.
/// * `prefer_types` - When resolving to a module specifier, determine if a
/// type dependency is preferred over a code dependency. This is set to
/// `true` when resolving module names for `tsc` as it needs the type
/// dependency over the code, while other consumers do not handle type only
/// dependencies.
pub fn resolve(
&self,
specifier: &str,
referrer: &ModuleSpecifier,
prefer_types: bool,
) -> Result<ModuleSpecifier, AnyError> {
let module = if let ModuleSlot::Module(module) = self.get_module(referrer) {
module
} else {
return Err(GraphError::MissingSpecifier(referrer.clone()).into());
};
if !module.dependencies.contains_key(specifier) {
return Err(
GraphError::MissingDependency(
referrer.to_owned(),
specifier.to_owned(),
)
.into(),
);
}
let dependency = module.dependencies.get(specifier).unwrap();
// If there is a @deno-types pragma that impacts the dependency, then the
// maybe_type property will be set with that specifier, otherwise we use the
// specifier that point to the runtime code.
let resolved_specifier = if prefer_types && dependency.maybe_type.is_some()
{
dependency.maybe_type.clone().unwrap()
} else if let Some(code_specifier) = dependency.maybe_code.clone() {
code_specifier
} else {
return Err(
GraphError::MissingDependency(
referrer.to_owned(),
specifier.to_owned(),
)
.into(),
);
};
let dep_module = if let ModuleSlot::Module(dep_module) =
self.get_module(&resolved_specifier)
{
dep_module
} else {
return Err(
GraphError::MissingDependency(
referrer.to_owned(),
resolved_specifier.to_string(),
)
.into(),
);
};
// In the case that there is a X-TypeScript-Types or a triple-slash types,
// then the `maybe_types` specifier will be populated and we should use that
// instead.
let result = if prefer_types && dep_module.maybe_types.is_some() {
let (_, types) = dep_module.maybe_types.clone().unwrap();
// It is possible that `types` points to a redirected specifier, so we
// need to ensure it resolves to the final specifier in the graph.
self.resolve_specifier(&types).clone()
} else {
dep_module.specifier.clone()
};
Ok(result)
}
/// Takes a module specifier and returns the "final" specifier, accounting for
/// any redirects that may have occurred.
fn resolve_specifier<'a>(
&'a self,
specifier: &'a ModuleSpecifier,
) -> &'a ModuleSpecifier {
let mut s = specifier;
let mut seen = HashSet::new();
seen.insert(s.clone());
while let Some(redirect) = self.redirects.get(s) {
if !seen.insert(redirect.clone()) {
eprintln!("An infinite loop of module redirections detected.\n Original specifier: {}", specifier);
break;
}
s = redirect;
if seen.len() > 5 {
eprintln!("An excessive number of module redirections detected.\n Original specifier: {}", specifier);
break;
}
}
s
}
/// Transpile (only transform) the graph, updating any emitted modules
/// with the specifier handler. The result contains any performance stats
/// from the compiler and optionally any user provided configuration compiler
/// options that were ignored.
///
/// # Arguments
///
/// * `options` - A structure of options which impact how the code is
/// transpiled.
///
pub fn transpile(
&mut self,
options: TranspileOptions,
) -> Result<ResultInfo, AnyError> {
let start = Instant::now();
let mut ts_config = TsConfig::new(json!({
"checkJs": false,
"emitDecoratorMetadata": false,
"importsNotUsedAsValues": "remove",
"inlineSourceMap": true,
"jsx": "react",
"jsxFactory": "React.createElement",
"jsxFragmentFactory": "React.Fragment",
}));
let maybe_ignored_options =
ts_config.merge_tsconfig(options.maybe_config_path)?;
let config = ts_config.as_bytes();
let emit_options: ast::EmitOptions = ts_config.into();
let mut emit_count = 0_u32;
for (_, module_slot) in self.modules.iter_mut() {
if let ModuleSlot::Module(module) = module_slot {
// TODO(kitsonk) a lot of this logic should be refactored into `Module` as
// we start to support other methods on the graph. Especially managing
// the dirty state is something the module itself should "own".
// if the module is a Dts file we should skip it
if module.media_type == MediaType::Dts {
continue;
}
// if we don't have check_js enabled, we won't touch non TypeScript or JSX
// modules
if !(emit_options.check_js
|| module.media_type == MediaType::Jsx
|| module.media_type == MediaType::Tsx
|| module.media_type == MediaType::TypeScript)
{
continue;
}
// skip modules that already have a valid emit
if !options.reload && module.is_emit_valid(&config) {
continue;
}
let parsed_module = module.parse()?;
let emit = parsed_module.transpile(&emit_options)?;
emit_count += 1;
module.maybe_emit = Some(Emit::Cli(emit));
module.set_version(&config);
module.is_dirty = true;
}
}
self.flush()?;
let stats = Stats(vec![
("Files".to_string(), self.modules.len() as u32),
("Emitted".to_string(), emit_count),
("Total time".to_string(), start.elapsed().as_millis() as u32),
]);
Ok(ResultInfo {
diagnostics: Default::default(),
loadable_modules: self.get_loadable_modules(),
maybe_ignored_options,
stats,
})
}
/// Validate that the module graph is "valid" in that there are not module
/// slots that have errorred that should be available to be able to statically
/// analyze. In certain situations, we can spin up tsc with an "invalid"
/// graph.
fn validate(&self) -> Result<(), AnyError> {
fn validate_module<F>(
specifier: &ModuleSpecifier,
seen: &mut HashSet<ModuleSpecifier>,
get_module: &F,
) -> Result<(), AnyError>
where
F: Fn(&ModuleSpecifier) -> ModuleSlot,
{
if seen.contains(specifier) {
return Ok(());
}
seen.insert(specifier.clone());
match get_module(specifier) {
ModuleSlot::Err(err) => Err(anyhow!(err.to_string())),
ModuleSlot::Module(module) => {
for (_, dep) in module.dependencies.iter() {
// a dynamic import should be skipped, because while it might not
// be available to statically analyze, it might be available at
// runtime.
if !dep.is_dynamic {
if let Some(code_specifier) = &dep.maybe_code {
validate_module(code_specifier, seen, get_module)?;
}
if let Some(type_specifier) = &dep.maybe_type {
validate_module(type_specifier, seen, get_module)?;
}
}
}
Ok(())
},
ModuleSlot::None => Err(custom_error("NotFound", format!("The specifier \"{}\" is unexpectedly not in the module graph.", specifier))),
ModuleSlot::Pending => Err(custom_error("InvalidState", format!("The specifier \"{}\" is in an unexpected state in the module graph.", specifier))),
}
}
let mut seen = HashSet::new();
for specifier in &self.roots {
validate_module(specifier, &mut seen, &|s| self.get_module(s).clone())?;
}
Ok(())
}
}
impl swc_bundler::Resolve for Graph {
fn resolve(
&self,
referrer: &swc_common::FileName,
specifier: &str,
) -> Result<swc_common::FileName, AnyError> {
let referrer = if let swc_common::FileName::Custom(referrer) = referrer {
resolve_url_or_path(referrer)
.context("Cannot resolve swc FileName to a module specifier")?
} else {
unreachable!(
"An unexpected referrer was passed when bundling: {:?}",
referrer
)
};
let specifier = self.resolve(specifier, &referrer, false)?;
Ok(swc_common::FileName::Custom(specifier.to_string()))
}
}
/// A structure for building a dependency graph of modules.
pub struct GraphBuilder {
graph: Graph,
maybe_import_map: Option<Arc<Mutex<ImportMap>>>,
pending: FuturesUnordered<FetchFuture>,
}
impl GraphBuilder {
pub fn new(
handler: Arc<Mutex<dyn SpecifierHandler>>,
maybe_import_map: Option<ImportMap>,
maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
) -> Self {
let internal_import_map =
maybe_import_map.map(|import_map| Arc::new(Mutex::new(import_map)));
GraphBuilder {
graph: Graph::new(handler, maybe_lockfile),
maybe_import_map: internal_import_map,
pending: FuturesUnordered::new(),
}
}
/// Add a module into the graph based on a module specifier. The module
/// and any dependencies will be fetched from the handler. The module will
/// also be treated as a _root_ module in the graph.
pub async fn add(
&mut self,
specifier: &ModuleSpecifier,
is_dynamic: bool,
) -> Result<(), AnyError> {
self.fetch(specifier, &None, is_dynamic);
loop {
match self.pending.next().await {
Some(Err((specifier, err))) => {
self
.graph
.modules
.insert(specifier, ModuleSlot::Err(Arc::new(err)));
}
Some(Ok(cached_module)) => {
let is_root = &cached_module.specifier == specifier;
self.visit(cached_module, is_root)?;
}
_ => {}
}
if self.pending.is_empty() {
break;
}
}
if !self.graph.roots.contains(specifier) {
self.graph.roots.push(specifier.clone());
self.graph.roots_dynamic = self.graph.roots_dynamic && is_dynamic;
if self.graph.maybe_tsbuildinfo.is_none() {
let handler = self.graph.handler.lock().unwrap();
self.graph.maybe_tsbuildinfo = handler.get_tsbuildinfo(specifier)?;
}
}
Ok(())
}
/// Request a module to be fetched from the handler and queue up its future
/// to be awaited to be resolved.
fn fetch(
&mut self,
specifier: &ModuleSpecifier,
maybe_referrer: &Option<Location>,
is_dynamic: bool,
) {
if !self.graph.modules.contains_key(&specifier) {
self
.graph
.modules
.insert(specifier.clone(), ModuleSlot::Pending);
let mut handler = self.graph.handler.lock().unwrap();
let future =
handler.fetch(specifier.clone(), maybe_referrer.clone(), is_dynamic);
self.pending.push(future);
}
}
/// Visit a module that has been fetched, hydrating the module, analyzing its
/// dependencies if required, fetching those dependencies, and inserting the
/// module into the graph.
fn visit(
&mut self,
cached_module: CachedModule,
is_root: bool,
) -> Result<(), AnyError> {
let specifier = cached_module.specifier.clone();
let requested_specifier = cached_module.requested_specifier.clone();
let mut module =
Module::new(cached_module, is_root, self.maybe_import_map.clone());
match module.media_type {
MediaType::Json
| MediaType::SourceMap
| MediaType::TsBuildInfo
| MediaType::Unknown => {
return Err(
GraphError::UnsupportedImportType(
module.specifier,
module.media_type,
)
.into(),
);
}
_ => (),
}
if !module.is_parsed {
let has_types = module.maybe_types.is_some();
module.parse()?;
if self.maybe_import_map.is_none() {
let mut handler = self.graph.handler.lock().unwrap();
handler.set_deps(&specifier, module.dependencies.clone())?;
if !has_types {
if let Some((types, _)) = module.maybe_types.clone() {
handler.set_types(&specifier, types)?;
}
}
}
}
for (_, dep) in module.dependencies.iter() {
let maybe_referrer = Some(dep.location.clone());
if let Some(specifier) = dep.maybe_code.as_ref() {
self.fetch(specifier, &maybe_referrer, dep.is_dynamic);
}
if let Some(specifier) = dep.maybe_type.as_ref() {
self.fetch(specifier, &maybe_referrer, dep.is_dynamic);
}
}
if let Some((_, specifier)) = module.maybe_types.as_ref() {
self.fetch(specifier, &None, false);
}
if specifier != requested_specifier {
self
.graph
.redirects
.insert(requested_specifier, specifier.clone());
}
self
.graph
.modules
.insert(specifier, ModuleSlot::Module(Box::new(module)));
Ok(())
}
/// Move out the graph from the builder to be utilized further. An optional
/// lockfile can be provided, where if the sources in the graph do not match
/// the expected lockfile, an error will be logged and the process will exit.
pub fn get_graph(self) -> Graph {
self.graph.lock();
self.graph
}
}
#[cfg(test)]
pub mod tests {
use super::*;
use crate::specifier_handler::MemoryHandler;
use deno_core::futures::future;
use std::env;
use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;
macro_rules! map (
{ $($key:expr => $value:expr),+ } => {
{
let mut m = ::std::collections::HashMap::new();
$(
m.insert($key, $value);
)+
m
}
};
);
/// This is a testing mock for `SpecifierHandler` that uses a special file
/// system renaming to mock local and remote modules as well as provides
/// "spies" for the critical methods for testing purposes.
#[derive(Debug, Default)]
pub struct MockSpecifierHandler {
pub fixtures: PathBuf,
pub maybe_tsbuildinfo: Option<String>,
pub tsbuildinfo_calls: Vec<(ModuleSpecifier, String)>,
pub cache_calls: Vec<(ModuleSpecifier, Emit)>,
pub deps_calls: Vec<(ModuleSpecifier, DependencyMap)>,
pub types_calls: Vec<(ModuleSpecifier, String)>,
pub version_calls: Vec<(ModuleSpecifier, String)>,
}
impl MockSpecifierHandler {
fn get_cache(
&self,
specifier: ModuleSpecifier,
) -> Result<CachedModule, (ModuleSpecifier, AnyError)> {
let specifier_text = specifier
.to_string()
.replace(":///", "_")
.replace("://", "_")
.replace("/", "-");
let source_path = self.fixtures.join(specifier_text);
let media_type = MediaType::from(&source_path);
let source = fs::read_to_string(&source_path)
.map_err(|err| (specifier.clone(), err.into()))?;
let is_remote = specifier.scheme() != "file";
Ok(CachedModule {
source,
requested_specifier: specifier.clone(),
source_path,
specifier,
media_type,
is_remote,
..CachedModule::default()
})
}
}
impl SpecifierHandler for MockSpecifierHandler {
fn fetch(
&mut self,
specifier: ModuleSpecifier,
_maybe_referrer: Option<Location>,
_is_dynamic: bool,
) -> FetchFuture {
Box::pin(future::ready(self.get_cache(specifier)))
}
fn get_tsbuildinfo(
&self,
_specifier: &ModuleSpecifier,
) -> Result<Option<String>, AnyError> {
Ok(self.maybe_tsbuildinfo.clone())
}
fn set_cache(
&mut self,
specifier: &ModuleSpecifier,
emit: &Emit,
) -> Result<(), AnyError> {
self.cache_calls.push((specifier.clone(), emit.clone()));
Ok(())
}
fn set_types(
&mut self,
specifier: &ModuleSpecifier,
types: String,
) -> Result<(), AnyError> {
self.types_calls.push((specifier.clone(), types));
Ok(())
}
fn set_tsbuildinfo(
&mut self,
specifier: &ModuleSpecifier,
tsbuildinfo: String,
) -> Result<(), AnyError> {
self.maybe_tsbuildinfo = Some(tsbuildinfo.clone());
self
.tsbuildinfo_calls
.push((specifier.clone(), tsbuildinfo));
Ok(())
}
fn set_deps(
&mut self,
specifier: &ModuleSpecifier,
dependencies: DependencyMap,
) -> Result<(), AnyError> {
self.deps_calls.push((specifier.clone(), dependencies));
Ok(())
}
fn set_version(
&mut self,
specifier: &ModuleSpecifier,
version: String,
) -> Result<(), AnyError> {
self.version_calls.push((specifier.clone(), version));
Ok(())
}
}
async fn setup(
specifier: ModuleSpecifier,
) -> (Graph, Arc<Mutex<MockSpecifierHandler>>) {
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
let fixtures = c.join("tests/module_graph");
let handler = Arc::new(Mutex::new(MockSpecifierHandler {
fixtures,
..MockSpecifierHandler::default()
}));
let mut builder = GraphBuilder::new(handler.clone(), None, None);
builder
.add(&specifier, false)
.await
.expect("module not inserted");
(builder.get_graph(), handler)
}
async fn setup_memory(
specifier: ModuleSpecifier,
sources: HashMap<&str, &str>,
) -> Graph {
let sources: HashMap<String, String> = sources
.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect();
let handler = Arc::new(Mutex::new(MemoryHandler::new(sources)));
let mut builder = GraphBuilder::new(handler.clone(), None, None);
builder
.add(&specifier, false)
.await
.expect("module not inserted");
builder.get_graph()
}
#[test]
fn test_get_version() {
let doc_a = "console.log(42);";
let version_a = get_version(&doc_a, "1.2.3", b"");
let doc_b = "console.log(42);";
let version_b = get_version(&doc_b, "1.2.3", b"");
assert_eq!(version_a, version_b);
let version_c = get_version(&doc_a, "1.2.3", b"options");
assert_ne!(version_a, version_c);
let version_d = get_version(&doc_b, "1.2.3", b"options");
assert_eq!(version_c, version_d);
let version_e = get_version(&doc_a, "1.2.4", b"");
assert_ne!(version_a, version_e);
let version_f = get_version(&doc_b, "1.2.4", b"");
assert_eq!(version_e, version_f);
}
#[test]
fn test_module_emit_valid() {
let source = "console.log(42);".to_string();
let maybe_version = Some(get_version(&source, &version::deno(), b""));
let module = Module {
maybe_version,
source,
..Module::default()
};
assert!(module.is_emit_valid(b""));
let source = "console.log(42);".to_string();
let old_source = "console.log(43);";
let maybe_version = Some(get_version(old_source, &version::deno(), b""));
let module = Module {
maybe_version,
source,
..Module::default()
};
assert!(!module.is_emit_valid(b""));
let source = "console.log(42);".to_string();
let maybe_version = Some(get_version(&source, "0.0.0", b""));
let module = Module {
maybe_version,
source,
..Module::default()
};
assert!(!module.is_emit_valid(b""));
let source = "console.log(42);".to_string();
let module = Module {
source,
..Module::default()
};
assert!(!module.is_emit_valid(b""));
}
#[test]
fn test_module_set_version() {
let source = "console.log(42);".to_string();
let expected = Some(get_version(&source, &version::deno(), b""));
let mut module = Module {
source,
..Module::default()
};
assert!(module.maybe_version.is_none());
module.set_version(b"");
assert_eq!(module.maybe_version, expected);
}
#[tokio::test]
async fn test_graph_bundle() {
let tests = vec![
("file:///tests/fixture01.ts", "fixture01.out"),
("file:///tests/fixture02.ts", "fixture02.out"),
("file:///tests/fixture03.ts", "fixture03.out"),
("file:///tests/fixture04.ts", "fixture04.out"),
("file:///tests/fixture05.ts", "fixture05.out"),
("file:///tests/fixture06.ts", "fixture06.out"),
("file:///tests/fixture07.ts", "fixture07.out"),
("file:///tests/fixture08.ts", "fixture08.out"),
("file:///tests/fixture09.ts", "fixture09.out"),
("file:///tests/fixture10.ts", "fixture10.out"),
("file:///tests/fixture11.ts", "fixture11.out"),
("file:///tests/fixture12.ts", "fixture12.out"),
("file:///tests/fixture13.ts", "fixture13.out"),
("file:///tests/fixture14.ts", "fixture14.out"),
("file:///tests/fixture15.ts", "fixture15.out"),
];
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
let fixtures = c.join("tests/bundle");
for (specifier, expected_str) in tests {
let specifier = resolve_url_or_path(specifier).unwrap();
let handler = Arc::new(Mutex::new(MockSpecifierHandler {
fixtures: fixtures.clone(),
..MockSpecifierHandler::default()
}));
let mut builder = GraphBuilder::new(handler.clone(), None, None);
builder
.add(&specifier, false)
.await
.expect("module not inserted");
let graph = builder.get_graph();
let (actual, stats, maybe_ignored_options) = graph
.bundle(BundleOptions::default())
.expect("could not bundle");
assert_eq!(stats.0.len(), 2);
assert_eq!(maybe_ignored_options, None);
let expected_path = fixtures.join(expected_str);
let expected = fs::read_to_string(expected_path).unwrap();
assert_eq!(actual, expected, "fixture: {}", specifier);
}
}
#[tokio::test]
async fn test_graph_check_emit() {
let specifier = resolve_url_or_path("file:///tests/main.ts")
.expect("could not resolve module");
let (graph, handler) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: true,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(result_info.stats.0.len(), 12);
assert!(result_info.diagnostics.is_empty());
let h = handler.lock().unwrap();
assert_eq!(h.cache_calls.len(), 2);
assert_eq!(h.tsbuildinfo_calls.len(), 1);
}
#[tokio::test]
async fn test_graph_check_ignores_dynamic_import_errors() {
let specifier = resolve_url_or_path("file:///tests/dynamicimport.ts")
.expect("could not resolve module");
let (graph, _) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: false,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.diagnostics.is_empty());
}
#[tokio::test]
async fn fix_graph_check_emit_diagnostics() {
let specifier = resolve_url_or_path("file:///tests/diag.ts")
.expect("could not resolve module");
let (graph, handler) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: true,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(result_info.stats.0.len(), 12);
assert!(!result_info.diagnostics.is_empty());
let h = handler.lock().unwrap();
// we shouldn't cache any files or write out tsbuildinfo if there are
// diagnostic errors
assert_eq!(h.cache_calls.len(), 0);
assert_eq!(h.tsbuildinfo_calls.len(), 0);
}
#[tokio::test]
async fn test_graph_check_no_emit() {
let specifier = resolve_url_or_path("file:///tests/main.ts")
.expect("could not resolve module");
let (graph, handler) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: false,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(result_info.stats.0.len(), 12);
assert!(result_info.diagnostics.is_empty());
let h = handler.lock().unwrap();
assert_eq!(h.cache_calls.len(), 0);
assert_eq!(h.tsbuildinfo_calls.len(), 1);
}
#[tokio::test]
async fn fix_graph_check_mjs_root() {
let specifier = resolve_url_or_path("file:///tests/a.mjs")
.expect("could not resolve module");
let (graph, handler) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: true,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert!(result_info.diagnostics.is_empty());
let h = handler.lock().unwrap();
assert_eq!(h.cache_calls.len(), 1);
assert_eq!(h.tsbuildinfo_calls.len(), 1);
}
#[tokio::test]
async fn fix_graph_check_types_root() {
let specifier = resolve_url_or_path("file:///typesref.js")
.expect("could not resolve module");
let (graph, _) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: false,
lib: TypeLib::DenoWindow,
maybe_config_path: None,
reload: false,
})
.expect("should have checked");
assert!(result_info.diagnostics.is_empty());
}
#[tokio::test]
async fn test_graph_check_user_config() {
let specifier = resolve_url_or_path("file:///tests/checkwithconfig.ts")
.expect("could not resolve module");
let (graph, handler) = setup(specifier.clone()).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: true,
lib: TypeLib::DenoWindow,
maybe_config_path: Some(
"tests/module_graph/tsconfig_01.json".to_string(),
),
reload: true,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert!(result_info.diagnostics.is_empty());
let (ver0, ver1) = {
let h = handler.lock().unwrap();
assert_eq!(h.version_calls.len(), 2);
(h.version_calls[0].1.clone(), h.version_calls[1].1.clone())
};
// let's do it all over again to ensure that the versions are determinstic
let (graph, handler) = setup(specifier).await;
let result_info = graph
.check(CheckOptions {
debug: false,
emit: true,
lib: TypeLib::DenoWindow,
maybe_config_path: Some(
"tests/module_graph/tsconfig_01.json".to_string(),
),
reload: true,
})
.expect("should have checked");
assert!(result_info.maybe_ignored_options.is_none());
assert!(result_info.diagnostics.is_empty());
let h = handler.lock().unwrap();
assert_eq!(h.version_calls.len(), 2);
assert!(h.version_calls[0].1 == ver0 || h.version_calls[0].1 == ver1);
assert!(h.version_calls[1].1 == ver0 || h.version_calls[1].1 == ver1);
}
#[tokio::test]
async fn test_graph_emit() {
let specifier = resolve_url_or_path("file:///a.ts").unwrap();
let graph = setup_memory(
specifier,
map!(
"/a.ts" => r#"
import * as b from "./b.ts";
console.log(b);
"#,
"/b.ts" => r#"
export const b = "b";
"#
),
)
.await;
let (emitted_files, result_info) = graph
.emit(EmitOptions {
check: true,
bundle_type: BundleType::None,
debug: false,
maybe_user_config: None,
})
.expect("should have emitted");
assert!(result_info.diagnostics.is_empty());
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(emitted_files.len(), 4);
let out_a = emitted_files.get("file:///a.ts.js");
assert!(out_a.is_some());
let out_a = out_a.unwrap();
assert!(out_a.starts_with("import * as b from"));
assert!(emitted_files.contains_key("file:///a.ts.js.map"));
let out_b = emitted_files.get("file:///b.ts.js");
assert!(out_b.is_some());
let out_b = out_b.unwrap();
assert!(out_b.starts_with("export const b = \"b\";"));
assert!(emitted_files.contains_key("file:///b.ts.js.map"));
}
#[tokio::test]
async fn test_graph_emit_bundle() {
let specifier = resolve_url_or_path("file:///a.ts").unwrap();
let graph = setup_memory(
specifier,
map!(
"/a.ts" => r#"
import * as b from "./b.ts";
console.log(b);
"#,
"/b.ts" => r#"
export const b = "b";
"#
),
)
.await;
let (emitted_files, result_info) = graph
.emit(EmitOptions {
check: true,
bundle_type: BundleType::Esm,
debug: false,
maybe_user_config: None,
})
.expect("should have emitted");
assert!(result_info.diagnostics.is_empty());
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(emitted_files.len(), 1);
let actual = emitted_files.get("deno:///bundle.js");
assert!(actual.is_some());
let actual = actual.unwrap();
assert!(actual.contains("const b = \"b\";"));
assert!(actual.contains("console.log(mod);"));
}
#[tokio::test]
async fn fix_graph_emit_declaration() {
let specifier = resolve_url_or_path("file:///a.ts").unwrap();
let graph = setup_memory(
specifier,
map!(
"/a.ts" => r#"
import * as b from "./b.ts";
console.log(b);
"#,
"/b.ts" => r#"
export const b = "b";
"#
),
)
.await;
let mut user_config = HashMap::<String, Value>::new();
user_config.insert("declaration".to_string(), json!(true));
let (emitted_files, result_info) = graph
.emit(EmitOptions {
check: true,
bundle_type: BundleType::None,
debug: false,
maybe_user_config: Some(user_config),
})
.expect("should have emitted");
assert!(result_info.diagnostics.is_empty());
assert!(result_info.maybe_ignored_options.is_none());
assert_eq!(emitted_files.len(), 6);
let out_a = emitted_files.get("file:///a.ts.js");
assert!(out_a.is_some());
let out_a = out_a.unwrap();
assert!(out_a.starts_with("import * as b from"));
assert!(emitted_files.contains_key("file:///a.ts.js.map"));
assert!(emitted_files.contains_key("file:///a.ts.d.ts"));
let out_b = emitted_files.get("file:///b.ts.js");
assert!(out_b.is_some());
let out_b = out_b.unwrap();
assert!(out_b.starts_with("export const b = \"b\";"));
assert!(emitted_files.contains_key("file:///b.ts.js.map"));
assert!(emitted_files.contains_key("file:///b.ts.d.ts"));
}
#[tokio::test]
async fn test_graph_info() {
let specifier = resolve_url_or_path("file:///tests/main.ts")
.expect("could not resolve module");
let (graph, _) = setup(specifier.clone()).await;
let info = graph.info().expect("could not get info");
assert_eq!(info.root, specifier);
assert_eq!(info.modules.len(), 7);
assert_eq!(info.size, 518);
}
#[tokio::test]
async fn test_graph_import_json() {
let specifier = resolve_url_or_path("file:///tests/importjson.ts")
.expect("could not resolve module");
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
let fixtures = c.join("tests/module_graph");
let handler = Arc::new(Mutex::new(MockSpecifierHandler {
fixtures,
..MockSpecifierHandler::default()
}));
let mut builder = GraphBuilder::new(handler.clone(), None, None);
builder
.add(&specifier, false)
.await
.expect_err("should have errored");
}
#[tokio::test]
async fn test_graph_transpile() {
// This is a complex scenario of transpiling, where we have TypeScript
// importing a JavaScript file (with type definitions) which imports
// TypeScript, JavaScript, and JavaScript with type definitions.
// For scenarios where we transpile, we only want the TypeScript files
// to be actually emitted.
//
// This also exercises "@deno-types" and type references.
let specifier = resolve_url_or_path("file:///tests/main.ts")
.expect("could not resolve module");
let (mut graph, handler) = setup(specifier).await;
let result_info = graph.transpile(TranspileOptions::default()).unwrap();
assert_eq!(result_info.stats.0.len(), 3);
assert_eq!(result_info.maybe_ignored_options, None);
let h = handler.lock().unwrap();
assert_eq!(h.cache_calls.len(), 2);
match &h.cache_calls[0].1 {
Emit::Cli((code, maybe_map)) => {
assert!(
code.contains("# sourceMappingURL=data:application/json;base64,")
);
assert!(maybe_map.is_none());
}
};
match &h.cache_calls[1].1 {
Emit::Cli((code, maybe_map)) => {
assert!(
code.contains("# sourceMappingURL=data:application/json;base64,")
);
assert!(maybe_map.is_none());
}
};
assert_eq!(h.deps_calls.len(), 7);
assert_eq!(
h.deps_calls[0].0,
resolve_url_or_path("file:///tests/main.ts").unwrap()
);
assert_eq!(h.deps_calls[0].1.len(), 1);
assert_eq!(
h.deps_calls[1].0,
resolve_url_or_path("https://deno.land/x/lib/mod.js").unwrap()
);
assert_eq!(h.deps_calls[1].1.len(), 3);
assert_eq!(
h.deps_calls[2].0,
resolve_url_or_path("https://deno.land/x/lib/mod.d.ts").unwrap()
);
assert_eq!(h.deps_calls[2].1.len(), 3, "should have 3 dependencies");
// sometimes the calls are not deterministic, and so checking the contents
// can cause some failures
assert_eq!(h.deps_calls[3].1.len(), 0, "should have no dependencies");
assert_eq!(h.deps_calls[4].1.len(), 0, "should have no dependencies");
assert_eq!(h.deps_calls[5].1.len(), 0, "should have no dependencies");
assert_eq!(h.deps_calls[6].1.len(), 0, "should have no dependencies");
}
#[tokio::test]
async fn test_graph_transpile_user_config() {
let specifier = resolve_url_or_path("https://deno.land/x/transpile.tsx")
.expect("could not resolve module");
let (mut graph, handler) = setup(specifier).await;
let result_info = graph
.transpile(TranspileOptions {
debug: false,
maybe_config_path: Some("tests/module_graph/tsconfig.json".to_string()),
reload: false,
})
.unwrap();
assert_eq!(
result_info.maybe_ignored_options.unwrap().items,
vec!["target".to_string()],
"the 'target' options should have been ignored"
);
let h = handler.lock().unwrap();
assert_eq!(h.cache_calls.len(), 1, "only one file should be emitted");
// FIXME(bartlomieju): had to add space in `<div>`, probably a quirk in swc_ecma_codegen
match &h.cache_calls[0].1 {
Emit::Cli((code, _)) => {
assert!(
code.contains("<div >Hello world!</div>"),
"jsx should have been preserved"
);
}
}
}
#[tokio::test]
async fn test_graph_import_map_remote_to_local() {
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
let fixtures = c.join("tests/module_graph");
let maybe_import_map = Some(
ImportMap::from_json(
"file:///tests/importmap.json",
r#"{
"imports": {
"https://deno.land/x/b/mod.js": "./b/mod.js"
}
}
"#,
)
.expect("could not parse import map"),
);
let handler = Arc::new(Mutex::new(MockSpecifierHandler {
fixtures,
..Default::default()
}));
let mut builder = GraphBuilder::new(handler, maybe_import_map, None);
let specifier = resolve_url_or_path("file:///tests/importremap.ts")
.expect("could not resolve module");
builder.add(&specifier, false).await.expect("could not add");
builder.get_graph();
}
#[tokio::test]
async fn test_graph_with_lockfile() {
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
let fixtures = c.join("tests/module_graph");
let lockfile_path = fixtures.join("lockfile.json");
let lockfile =
Lockfile::new(lockfile_path, false).expect("could not load lockfile");
let maybe_lockfile = Some(Arc::new(Mutex::new(lockfile)));
let handler = Arc::new(Mutex::new(MockSpecifierHandler {
fixtures,
..MockSpecifierHandler::default()
}));
let mut builder = GraphBuilder::new(handler.clone(), None, maybe_lockfile);
let specifier = resolve_url_or_path("file:///tests/main.ts")
.expect("could not resolve module");
builder
.add(&specifier, false)
.await
.expect("module not inserted");
builder.get_graph();
}
}