summaryrefslogtreecommitdiff
path: root/cli/tools
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tools')
-rw-r--r--cli/tools/bench.rs4
-rw-r--r--cli/tools/bundle.rs5
-rw-r--r--cli/tools/check.rs166
-rw-r--r--cli/tools/doc.rs23
-rw-r--r--cli/tools/info.rs44
-rw-r--r--cli/tools/standalone.rs2
-rw-r--r--cli/tools/test.rs4
-rw-r--r--cli/tools/vendor/build.rs29
-rw-r--r--cli/tools/vendor/import_map.rs30
-rw-r--r--cli/tools/vendor/mappings.rs14
-rw-r--r--cli/tools/vendor/test.rs25
11 files changed, 183 insertions, 163 deletions
diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
index 419ac2da6..be0d9ba6c 100644
--- a/cli/tools/bench.rs
+++ b/cli/tools/bench.rs
@@ -4,7 +4,7 @@ use crate::args::BenchOptions;
use crate::args::CliOptions;
use crate::args::TypeCheckMode;
use crate::colors;
-use crate::graph_util::graph_valid;
+use crate::graph_util::graph_valid_with_cli_options;
use crate::ops;
use crate::proc_state::ProcState;
use crate::tools::test::format_test_error;
@@ -549,7 +549,7 @@ pub async fn run_benchmarks_with_watch(
bench_modules.clone()
};
let graph = ps.create_graph(bench_modules.clone()).await?;
- graph_valid(&graph, !no_check, ps.options.check_js())?;
+ graph_valid_with_cli_options(&graph, &bench_modules, &ps.options)?;
// TODO(@kitsonk) - This should be totally derivable from the graph.
for specifier in bench_modules {
diff --git a/cli/tools/bundle.rs b/cli/tools/bundle.rs
index 437bad1d4..86b28828b 100644
--- a/cli/tools/bundle.rs
+++ b/cli/tools/bundle.rs
@@ -38,7 +38,10 @@ pub async fn bundle(
let mut paths_to_watch: Vec<PathBuf> = graph
.specifiers()
- .filter_map(|(_, r)| r.ok().and_then(|(s, _, _)| s.to_file_path().ok()))
+ .filter_map(|(_, r)| {
+ r.ok()
+ .and_then(|module| module.specifier.to_file_path().ok())
+ })
.collect();
if let Ok(Some(import_map_path)) = ps
diff --git a/cli/tools/check.rs b/cli/tools/check.rs
index d669a736f..bf5e3033f 100644
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@@ -5,7 +5,8 @@ use std::sync::Arc;
use deno_ast::MediaType;
use deno_ast::ModuleSpecifier;
use deno_core::error::AnyError;
-use deno_core::parking_lot::RwLock;
+use deno_graph::ModuleGraph;
+use deno_graph::ModuleKind;
use deno_runtime::colors;
use once_cell::sync::Lazy;
use regex::Regex;
@@ -14,8 +15,6 @@ use crate::args::TsConfig;
use crate::args::TypeCheckMode;
use crate::cache::FastInsecureHasher;
use crate::cache::TypeCheckCache;
-use crate::graph_util::GraphData;
-use crate::graph_util::ModuleEntry;
use crate::npm::NpmPackageResolver;
use crate::tsc;
use crate::tsc::Diagnostics;
@@ -40,6 +39,11 @@ pub struct CheckOptions {
/// If true, valid `.tsbuildinfo` files will be ignored and type checking
/// will always occur.
pub reload: bool,
+ /// If the graph has a node built-in specifier.
+ ///
+ /// Although this could be derived from the graph, this helps
+ /// speed things up.
+ pub has_node_builtin_specifier: bool,
}
/// The result of a check of a module graph.
@@ -54,18 +58,13 @@ pub struct CheckResult {
/// It is expected that it is determined if a check and/or emit is validated
/// before the function is called.
pub fn check(
- roots: &[ModuleSpecifier],
- graph_data: Arc<RwLock<GraphData>>,
+ graph: Arc<ModuleGraph>,
cache: &TypeCheckCache,
npm_resolver: &NpmPackageResolver,
options: CheckOptions,
) -> Result<CheckResult, AnyError> {
let check_js = options.ts_config.get_check_js();
- let segment_graph_data = {
- let graph_data = graph_data.read();
- graph_data.graph_segment(roots).unwrap()
- };
- let check_hash = match get_check_hash(&segment_graph_data, &options) {
+ let check_hash = match get_check_hash(&graph, &options) {
CheckHashResult::NoFiles => return Ok(Default::default()),
CheckHashResult::Hash(hash) => hash,
};
@@ -75,23 +74,22 @@ pub fn check(
return Ok(Default::default());
}
- let root_names = get_tsc_roots(&segment_graph_data, check_js);
if options.log_checks {
- for root in roots {
+ for root in &graph.roots {
let root_str = root.as_str();
- // `$deno` specifiers are internal, don't print them.
- if !root_str.contains("$deno") {
- log::info!("{} {}", colors::green("Check"), root_str);
- }
+ log::info!("{} {}", colors::green("Check"), root_str);
}
}
+
+ let root_names =
+ get_tsc_roots(&graph, options.has_node_builtin_specifier, check_js);
// while there might be multiple roots, we can't "merge" the build info, so we
// try to retrieve the build info for first root, which is the most common use
// case.
let maybe_tsbuildinfo = if options.reload {
None
} else {
- cache.get_tsbuildinfo(&roots[0])
+ cache.get_tsbuildinfo(&graph.roots[0])
};
// to make tsc build info work, we need to consistently hash modules, so that
// tsc can better determine if an emit is still valid or not, so we provide
@@ -104,7 +102,7 @@ pub fn check(
let response = tsc::exec(tsc::Request {
config: options.ts_config,
debug: options.debug,
- graph_data,
+ graph: graph.clone(),
hash_data,
maybe_config_specifier: options.maybe_config_specifier,
maybe_npm_resolver: Some(npm_resolver.clone()),
@@ -136,7 +134,7 @@ pub fn check(
};
if let Some(tsbuildinfo) = response.maybe_tsbuildinfo {
- cache.set_tsbuildinfo(&roots[0], &tsbuildinfo);
+ cache.set_tsbuildinfo(&graph.roots[0], &tsbuildinfo);
}
if diagnostics.is_empty() {
@@ -157,7 +155,7 @@ enum CheckHashResult {
/// Gets a hash of the inputs for type checking. This can then
/// be used to tell
fn get_check_hash(
- graph_data: &GraphData,
+ graph: &ModuleGraph,
options: &CheckOptions,
) -> CheckHashResult {
let mut hasher = FastInsecureHasher::new();
@@ -169,47 +167,45 @@ fn get_check_hash(
hasher.write(&options.ts_config.as_bytes());
let check_js = options.ts_config.get_check_js();
- let mut sorted_entries = graph_data.entries().collect::<Vec<_>>();
- sorted_entries.sort_by_key(|(s, _)| s.as_str()); // make it deterministic
+ let mut sorted_modules = graph.modules().collect::<Vec<_>>();
+ sorted_modules.sort_by_key(|m| m.specifier.as_str()); // make it deterministic
let mut has_file = false;
let mut has_file_to_type_check = false;
- for (specifier, module_entry) in sorted_entries {
- if let ModuleEntry::Module {
- code, media_type, ..
- } = module_entry
- {
- let ts_check = has_ts_check(*media_type, code);
- if ts_check {
+ for module in sorted_modules {
+ let ts_check =
+ has_ts_check(module.media_type, module.maybe_source.as_deref());
+ if ts_check {
+ has_file_to_type_check = true;
+ }
+
+ match module.media_type {
+ MediaType::TypeScript
+ | MediaType::Dts
+ | MediaType::Dmts
+ | MediaType::Dcts
+ | MediaType::Mts
+ | MediaType::Cts
+ | MediaType::Tsx => {
+ has_file = true;
has_file_to_type_check = true;
}
-
- match media_type {
- MediaType::TypeScript
- | MediaType::Dts
- | MediaType::Dmts
- | MediaType::Dcts
- | MediaType::Mts
- | MediaType::Cts
- | MediaType::Tsx => {
- has_file = true;
- has_file_to_type_check = true;
+ MediaType::JavaScript
+ | MediaType::Mjs
+ | MediaType::Cjs
+ | MediaType::Jsx => {
+ has_file = true;
+ if !check_js && !ts_check {
+ continue;
}
- MediaType::JavaScript
- | MediaType::Mjs
- | MediaType::Cjs
- | MediaType::Jsx => {
- has_file = true;
- if !check_js && !ts_check {
- continue;
- }
- }
- MediaType::Json
- | MediaType::TsBuildInfo
- | MediaType::SourceMap
- | MediaType::Wasm
- | MediaType::Unknown => continue,
}
- hasher.write_str(specifier.as_str());
+ MediaType::Json
+ | MediaType::TsBuildInfo
+ | MediaType::SourceMap
+ | MediaType::Wasm
+ | MediaType::Unknown => continue,
+ }
+ hasher.write_str(module.specifier.as_str());
+ if let Some(code) = &module.maybe_source {
hasher.write_str(code);
}
}
@@ -229,37 +225,40 @@ fn get_check_hash(
/// the roots, so they get type checked and optionally emitted,
/// otherwise they would be ignored if only imported into JavaScript.
fn get_tsc_roots(
- graph_data: &GraphData,
+ graph: &ModuleGraph,
+ has_node_builtin_specifier: bool,
check_js: bool,
) -> Vec<(ModuleSpecifier, MediaType)> {
let mut result = Vec::new();
- if graph_data.has_node_builtin_specifier() {
+ if has_node_builtin_specifier {
// inject a specifier that will resolve node types
result.push((
ModuleSpecifier::parse("asset:///node_types.d.ts").unwrap(),
MediaType::Dts,
));
}
- result.extend(graph_data.entries().into_iter().filter_map(
- |(specifier, module_entry)| match module_entry {
- ModuleEntry::Module {
- media_type, code, ..
- } => match media_type {
- MediaType::TypeScript
- | MediaType::Tsx
- | MediaType::Mts
- | MediaType::Cts
- | MediaType::Jsx => Some((specifier.clone(), *media_type)),
- MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs
- if check_js || has_ts_check(*media_type, code) =>
- {
- Some((specifier.clone(), *media_type))
- }
- _ => None,
- },
+ result.extend(graph.modules().filter_map(|module| {
+ if module.kind == ModuleKind::External || module.maybe_source.is_none() {
+ return None;
+ }
+ match module.media_type {
+ MediaType::TypeScript
+ | MediaType::Tsx
+ | MediaType::Mts
+ | MediaType::Cts
+ | MediaType::Jsx => Some((module.specifier.clone(), module.media_type)),
+ MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs
+ if check_js
+ || has_ts_check(
+ module.media_type,
+ module.maybe_source.as_deref(),
+ ) =>
+ {
+ Some((module.specifier.clone(), module.media_type))
+ }
_ => None,
- },
- ));
+ }
+ }));
result
}
@@ -267,7 +266,11 @@ fn get_tsc_roots(
static TS_CHECK_RE: Lazy<Regex> =
Lazy::new(|| Regex::new(r#"(?i)^\s*@ts-check(?:\s+|$)"#).unwrap());
-fn has_ts_check(media_type: MediaType, file_text: &str) -> bool {
+fn has_ts_check(media_type: MediaType, maybe_file_text: Option<&str>) -> bool {
+ let file_text = match maybe_file_text {
+ Some(text) => text,
+ None => return false,
+ };
match &media_type {
MediaType::JavaScript
| MediaType::Mjs
@@ -371,19 +374,20 @@ mod test {
fn has_ts_check_test() {
assert!(has_ts_check(
MediaType::JavaScript,
- "// @ts-check\nconsole.log(5);"
+ Some("// @ts-check\nconsole.log(5);")
));
assert!(has_ts_check(
MediaType::JavaScript,
- "// deno-lint-ignore\n// @ts-check\n"
+ Some("// deno-lint-ignore\n// @ts-check\n")
));
assert!(!has_ts_check(
MediaType::JavaScript,
- "test;\n// @ts-check\n"
+ Some("test;\n// @ts-check\n")
));
assert!(!has_ts_check(
MediaType::JavaScript,
- "// ts-check\nconsole.log(5);"
+ Some("// ts-check\nconsole.log(5);")
));
+ assert!(!has_ts_check(MediaType::TypeScript, None,));
}
}
diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs
index 3e19d6df2..e0413ab79 100644
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@@ -40,18 +40,17 @@ pub async fn print_docs(
Vec::new(),
);
let analyzer = deno_graph::CapturingModuleAnalyzer::default();
- let graph = deno_graph::create_graph(
- vec![source_file_specifier.clone()],
- &mut loader,
- deno_graph::GraphOptions {
- is_dynamic: false,
- imports: None,
- resolver: None,
- module_analyzer: Some(&analyzer),
- reporter: None,
- },
- )
- .await;
+ let mut graph = deno_graph::ModuleGraph::default();
+ graph
+ .build(
+ vec![source_file_specifier.clone()],
+ &mut loader,
+ deno_graph::BuildOptions {
+ module_analyzer: Some(&analyzer),
+ ..Default::default()
+ },
+ )
+ .await;
let doc_parser = doc::DocParser::new(
graph,
doc_flags.private,
diff --git a/cli/tools/info.rs b/cli/tools/info.rs
index 090289e5d..1e09d58cb 100644
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@@ -14,7 +14,7 @@ use deno_graph::Dependency;
use deno_graph::Module;
use deno_graph::ModuleGraph;
use deno_graph::ModuleGraphError;
-use deno_graph::Resolved;
+use deno_graph::Resolution;
use deno_runtime::colors;
use crate::args::Flags;
@@ -454,15 +454,16 @@ impl<'a> GraphDisplayContext<'a> {
print_tree_node(&root_node, writer)?;
Ok(())
}
- Err(ModuleGraphError::Missing(_)) => {
- writeln!(
- writer,
- "{} module could not be found",
- colors::red("error:")
- )
- }
Err(err) => {
- writeln!(writer, "{} {}", colors::red("error:"), err)
+ if let ModuleGraphError::Missing(_, _) = *err {
+ writeln!(
+ writer,
+ "{} module could not be found",
+ colors::red("error:")
+ )
+ } else {
+ writeln!(writer, "{} {}", colors::red("error:"), err)
+ }
}
Ok(None) => {
writeln!(
@@ -540,8 +541,10 @@ impl<'a> GraphDisplayContext<'a> {
let mut tree_node = TreeNode::from_text(header_text);
if !was_seen {
- if let Some((_, type_dep)) = &module.maybe_types_dependency {
- if let Some(child) = self.build_resolved_info(type_dep, true) {
+ if let Some(types_dep) = &module.maybe_types_dependency {
+ if let Some(child) =
+ self.build_resolved_info(&types_dep.dependency, true)
+ {
tree_node.children.push(child);
}
}
@@ -600,7 +603,7 @@ impl<'a> GraphDisplayContext<'a> {
ModuleGraphError::InvalidTypeAssertion { .. } => {
self.build_error_msg(specifier, "(invalid import assertion)")
}
- ModuleGraphError::LoadingErr(_, _) => {
+ ModuleGraphError::LoadingErr(_, _, _) => {
self.build_error_msg(specifier, "(loading error)")
}
ModuleGraphError::ParseErr(_, _) => {
@@ -609,13 +612,13 @@ impl<'a> GraphDisplayContext<'a> {
ModuleGraphError::ResolutionError(_) => {
self.build_error_msg(specifier, "(resolution error)")
}
- ModuleGraphError::UnsupportedImportAssertionType(_, _) => {
+ ModuleGraphError::UnsupportedImportAssertionType { .. } => {
self.build_error_msg(specifier, "(unsupported import assertion)")
}
- ModuleGraphError::UnsupportedMediaType(_, _) => {
+ ModuleGraphError::UnsupportedMediaType { .. } => {
self.build_error_msg(specifier, "(unsupported)")
}
- ModuleGraphError::Missing(_) => {
+ ModuleGraphError::Missing(_, _) => {
self.build_error_msg(specifier, "(missing)")
}
}
@@ -635,15 +638,16 @@ impl<'a> GraphDisplayContext<'a> {
fn build_resolved_info(
&mut self,
- resolved: &Resolved,
+ resolution: &Resolution,
type_dep: bool,
) -> Option<TreeNode> {
- match resolved {
- Resolved::Ok { specifier, .. } => {
+ match resolution {
+ Resolution::Ok(resolved) => {
+ let specifier = &resolved.specifier;
let resolved_specifier = self.graph.resolve(specifier);
Some(match self.graph.try_get(&resolved_specifier) {
Ok(Some(module)) => self.build_module_info(module, type_dep),
- Err(err) => self.build_error_info(&err, &resolved_specifier),
+ Err(err) => self.build_error_info(err, &resolved_specifier),
Ok(None) => TreeNode::from_text(format!(
"{} {}",
colors::red(specifier),
@@ -651,7 +655,7 @@ impl<'a> GraphDisplayContext<'a> {
)),
})
}
- Resolved::Err(err) => Some(TreeNode::from_text(format!(
+ Resolution::Err(err) => Some(TreeNode::from_text(format!(
"{} {}",
colors::italic(err.to_string()),
colors::red_bold("(resolve error)")
diff --git a/cli/tools/standalone.rs b/cli/tools/standalone.rs
index 72f30aae9..20e691341 100644
--- a/cli/tools/standalone.rs
+++ b/cli/tools/standalone.rs
@@ -52,8 +52,6 @@ pub async fn compile(
// at the moment, we don't support npm specifiers in deno_compile, so show an error
error_for_any_npm_specifier(&graph)?;
- graph.valid()?;
-
let parser = ps.parsed_source_cache.as_capturing_parser();
let eszip = eszip::EszipV2::from_graph(graph, &parser, Default::default())?;
diff --git a/cli/tools/test.rs b/cli/tools/test.rs
index cd2ac6ba5..d308de8de 100644
--- a/cli/tools/test.rs
+++ b/cli/tools/test.rs
@@ -7,7 +7,7 @@ use crate::args::TypeCheckMode;
use crate::colors;
use crate::display;
use crate::file_fetcher::File;
-use crate::graph_util::graph_valid;
+use crate::graph_util::graph_valid_with_cli_options;
use crate::ops;
use crate::proc_state::ProcState;
use crate::util::checksum;
@@ -1377,7 +1377,7 @@ pub async fn run_tests_with_watch(
test_modules.clone()
};
let graph = ps.create_graph(test_modules.clone()).await?;
- graph_valid(&graph, !no_check, ps.options.check_js())?;
+ graph_valid_with_cli_options(&graph, &test_modules, &ps.options)?;
// TODO(@kitsonk) - This should be totally derivable from the graph.
for specifier in test_modules {
diff --git a/cli/tools/vendor/build.rs b/cli/tools/vendor/build.rs
index f418670b3..f3cc01444 100644
--- a/cli/tools/vendor/build.rs
+++ b/cli/tools/vendor/build.rs
@@ -18,6 +18,7 @@ use import_map::SpecifierMap;
use crate::args::Lockfile;
use crate::cache::ParsedSourceCache;
+use crate::graph_util;
use crate::graph_util::graph_lock_or_exit;
use super::analyze::has_default_export;
@@ -72,18 +73,22 @@ pub fn build(
validate_original_import_map(original_im, &output_dir_specifier)?;
}
- // build the graph
+ // check the lockfile
if let Some(lockfile) = maybe_lockfile {
graph_lock_or_exit(&graph, &mut lockfile.lock());
}
- let mut graph_errors = graph.errors().peekable();
- if graph_errors.peek().is_some() {
- for err in graph_errors {
- log::error!("{}", err);
- }
- bail!("failed vendoring");
- }
+ // surface any errors
+ graph_util::graph_valid(
+ &graph,
+ &graph.roots,
+ deno_graph::WalkOptions {
+ // surface all errors
+ check_js: true,
+ follow_dynamic: true,
+ follow_type_only: true,
+ },
+ )?;
// figure out how to map remote modules to local
let all_modules = graph.modules().collect::<Vec<_>>();
@@ -1119,7 +1124,13 @@ mod test {
.err()
.unwrap();
- assert_eq!(err.to_string(), "failed vendoring");
+ assert_eq!(
+ err.to_string(),
+ concat!(
+ "500 Internal Server Error\n",
+ " at https://localhost/mod.ts:1:14"
+ )
+ );
}
fn to_file_vec(items: &[(&str, &str)]) -> Vec<(String, String)> {
diff --git a/cli/tools/vendor/import_map.rs b/cli/tools/vendor/import_map.rs
index 0897cbcf6..753ac52e5 100644
--- a/cli/tools/vendor/import_map.rs
+++ b/cli/tools/vendor/import_map.rs
@@ -9,7 +9,7 @@ use deno_graph::Module;
use deno_graph::ModuleGraph;
use deno_graph::Position;
use deno_graph::Range;
-use deno_graph::Resolved;
+use deno_graph::Resolution;
use import_map::ImportMap;
use import_map::SpecifierMap;
use indexmap::IndexMap;
@@ -221,7 +221,7 @@ fn visit_modules(
};
for dep in module.dependencies.values() {
- visit_maybe_resolved(
+ visit_resolution(
&dep.maybe_code,
graph,
import_map,
@@ -230,7 +230,7 @@ fn visit_modules(
&text_info,
source_text,
);
- visit_maybe_resolved(
+ visit_resolution(
&dep.maybe_type,
graph,
import_map,
@@ -241,9 +241,9 @@ fn visit_modules(
);
}
- if let Some((_, maybe_resolved)) = &module.maybe_types_dependency {
- visit_maybe_resolved(
- maybe_resolved,
+ if let Some(types_dep) = &module.maybe_types_dependency {
+ visit_resolution(
+ &types_dep.dependency,
graph,
import_map,
&module.specifier,
@@ -257,8 +257,8 @@ fn visit_modules(
Ok(())
}
-fn visit_maybe_resolved(
- maybe_resolved: &Resolved,
+fn visit_resolution(
+ resolution: &Resolution,
graph: &ModuleGraph,
import_map: &mut ImportMapBuilder,
referrer: &ModuleSpecifier,
@@ -266,15 +266,17 @@ fn visit_maybe_resolved(
text_info: &SourceTextInfo,
source_text: &str,
) {
- if let Resolved::Ok {
- specifier, range, ..
- } = maybe_resolved
- {
- let text = text_from_range(text_info, source_text, range);
+ if let Some(resolved) = resolution.ok() {
+ let text = text_from_range(text_info, source_text, &resolved.range);
// if the text is empty then it's probably an x-TypeScript-types
if !text.is_empty() {
handle_dep_specifier(
- text, specifier, graph, import_map, referrer, mappings,
+ text,
+ &resolved.specifier,
+ graph,
+ import_map,
+ referrer,
+ mappings,
);
}
}
diff --git a/cli/tools/vendor/mappings.rs b/cli/tools/vendor/mappings.rs
index 8cf6388d2..399002ea3 100644
--- a/cli/tools/vendor/mappings.rs
+++ b/cli/tools/vendor/mappings.rs
@@ -11,7 +11,6 @@ use deno_core::error::AnyError;
use deno_graph::Module;
use deno_graph::ModuleGraph;
use deno_graph::Position;
-use deno_graph::Resolved;
use crate::util::path::path_with_stem_suffix;
use crate::util::path::relative_specifier;
@@ -76,13 +75,12 @@ impl Mappings {
// resolve all the "proxy" paths to use for when an x-typescript-types header is specified
for module in remote_modules {
- if let Some((
- _,
- Resolved::Ok {
- specifier, range, ..
- },
- )) = &module.maybe_types_dependency
+ if let Some(resolved) = &module
+ .maybe_types_dependency
+ .as_ref()
+ .and_then(|d| d.dependency.ok())
{
+ let range = &resolved.range;
// hack to tell if it's an x-typescript-types header
let is_ts_types_header =
range.start == Position::zeroed() && range.end == Position::zeroed();
@@ -96,7 +94,7 @@ impl Mappings {
module.specifier.clone(),
ProxiedModule {
output_path: proxied_path,
- declaration_specifier: specifier.clone(),
+ declaration_specifier: resolved.specifier.clone(),
},
);
}
diff --git a/cli/tools/vendor/test.rs b/cli/tools/vendor/test.rs
index a24fa1e4f..e5713a54c 100644
--- a/cli/tools/vendor/test.rs
+++ b/cli/tools/vendor/test.rs
@@ -262,18 +262,19 @@ async fn build_test_graph(
) -> ModuleGraph {
let resolver =
original_import_map.map(|m| CliResolver::with_import_map(Arc::new(m)));
- deno_graph::create_graph(
- roots,
- &mut loader,
- deno_graph::GraphOptions {
- is_dynamic: false,
- imports: None,
- resolver: resolver.as_ref().map(|r| r.as_graph_resolver()),
- module_analyzer: Some(analyzer),
- reporter: None,
- },
- )
- .await
+ let mut graph = ModuleGraph::default();
+ graph
+ .build(
+ roots,
+ &mut loader,
+ deno_graph::BuildOptions {
+ resolver: resolver.as_ref().map(|r| r.as_graph_resolver()),
+ module_analyzer: Some(analyzer),
+ ..Default::default()
+ },
+ )
+ .await;
+ graph
}
fn make_path(text: &str) -> PathBuf {
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-25 08:41:24 +0000