summaryrefslogtreecommitdiff
path: root/cli/tools
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tools')
-rw-r--r--cli/tools/bench.rs47
-rw-r--r--cli/tools/bundle.rs99
-rw-r--r--cli/tools/check.rs7
-rw-r--r--cli/tools/coverage/mod.rs17
-rw-r--r--cli/tools/doc.rs25
-rw-r--r--cli/tools/fmt.rs9
-rw-r--r--cli/tools/info.rs42
-rw-r--r--cli/tools/installer.rs7
-rw-r--r--cli/tools/lint.rs9
-rw-r--r--cli/tools/repl/mod.rs24
-rw-r--r--cli/tools/run.rs70
-rw-r--r--cli/tools/standalone.rs30
-rw-r--r--cli/tools/task.rs32
-rw-r--r--cli/tools/test.rs54
-rw-r--r--cli/tools/upgrade.rs7
-rw-r--r--cli/tools/vendor/mod.rs17
16 files changed, 278 insertions, 218 deletions
diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
index 3f606cfa9..aa5bd044d 100644
--- a/cli/tools/bench.rs
+++ b/cli/tools/bench.rs
@@ -5,10 +5,10 @@ use crate::args::CliOptions;
use crate::args::TypeCheckMode;
use crate::colors;
use crate::display::write_json_to_stdout;
+use crate::factory::CliFactory;
use crate::graph_util::graph_valid_with_cli_options;
use crate::module_loader::ModuleLoadPreparer;
use crate::ops;
-use crate::proc_state::ProcState;
use crate::tools::test::format_test_error;
use crate::tools::test::TestFilter;
use crate::util::file_watcher;
@@ -635,12 +635,13 @@ pub async fn run_benchmarks(
cli_options: CliOptions,
bench_options: BenchOptions,
) -> Result<(), AnyError> {
- let ps = ProcState::from_cli_options(Arc::new(cli_options)).await?;
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
// Various bench files should not share the same permissions in terms of
// `PermissionsContainer` - otherwise granting/revoking permissions in one
// file would have impact on other files, which is undesirable.
let permissions =
- Permissions::from_options(&ps.options.permissions_options())?;
+ Permissions::from_options(&cli_options.permissions_options())?;
let specifiers =
collect_specifiers(&bench_options.files, is_supported_bench_path)?;
@@ -649,15 +650,20 @@ pub async fn run_benchmarks(
return Err(generic_error("No bench modules found"));
}
- check_specifiers(&ps.options, &ps.module_load_preparer, specifiers.clone())
- .await?;
+ check_specifiers(
+ cli_options,
+ factory.module_load_preparer().await?,
+ specifiers.clone(),
+ )
+ .await?;
if bench_options.no_run {
return Ok(());
}
- let log_level = ps.options.log_level();
- let worker_factory = Arc::new(ps.create_cli_main_worker_factory());
+ let log_level = cli_options.log_level();
+ let worker_factory =
+ Arc::new(factory.create_cli_main_worker_factory().await?);
bench_specifiers(
worker_factory,
&permissions,
@@ -678,21 +684,25 @@ pub async fn run_benchmarks_with_watch(
cli_options: CliOptions,
bench_options: BenchOptions,
) -> Result<(), AnyError> {
- let ps = ProcState::from_cli_options(Arc::new(cli_options)).await?;
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let file_watcher = factory.file_watcher()?;
+ let module_load_preparer = factory.module_load_preparer().await?;
// Various bench files should not share the same permissions in terms of
// `PermissionsContainer` - otherwise granting/revoking permissions in one
// file would have impact on other files, which is undesirable.
let permissions =
- Permissions::from_options(&ps.options.permissions_options())?;
- let no_check = ps.options.type_check_mode() == TypeCheckMode::None;
+ Permissions::from_options(&cli_options.permissions_options())?;
+ let no_check = cli_options.type_check_mode() == TypeCheckMode::None;
let resolver = |changed: Option<Vec<PathBuf>>| {
let paths_to_watch = bench_options.files.include.clone();
let paths_to_watch_clone = paths_to_watch.clone();
let files_changed = changed.is_some();
let bench_options = &bench_options;
- let module_graph_builder = ps.module_graph_builder.clone();
- let cli_options = ps.options.clone();
+ let module_graph_builder = module_graph_builder.clone();
+ let cli_options = cli_options.clone();
async move {
let bench_modules =
@@ -797,15 +807,18 @@ pub async fn run_benchmarks_with_watch(
})
};
+ let create_cli_main_worker_factory =
+ factory.create_cli_main_worker_factory_func().await?;
let operation = |modules_to_reload: Vec<ModuleSpecifier>| {
let permissions = &permissions;
let bench_options = &bench_options;
- ps.reset_for_file_watcher();
- let module_load_preparer = ps.module_load_preparer.clone();
- let cli_options = ps.options.clone();
- let worker_factory = Arc::new(ps.create_cli_main_worker_factory());
+ file_watcher.reset();
+ let module_load_preparer = module_load_preparer.clone();
+ let cli_options = cli_options.clone();
+ let create_cli_main_worker_factory = create_cli_main_worker_factory.clone();
async move {
+ let worker_factory = Arc::new(create_cli_main_worker_factory());
let specifiers =
collect_specifiers(&bench_options.files, is_supported_bench_path)?
.into_iter()
@@ -836,7 +849,7 @@ pub async fn run_benchmarks_with_watch(
}
};
- let clear_screen = !ps.options.no_clear_screen();
+ let clear_screen = !cli_options.no_clear_screen();
file_watcher::watch_func(
resolver,
operation,
diff --git a/cli/tools/bundle.rs b/cli/tools/bundle.rs
index 26d170d7e..759882c83 100644
--- a/cli/tools/bundle.rs
+++ b/cli/tools/bundle.rs
@@ -13,8 +13,8 @@ use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::TsConfigType;
use crate::args::TypeCheckMode;
+use crate::factory::CliFactory;
use crate::graph_util::error_for_any_npm_specifier;
-use crate::proc_state::ProcState;
use crate::util;
use crate::util::display;
use crate::util::file_watcher::ResolutionResult;
@@ -40,9 +40,11 @@ pub async fn bundle(
let module_specifier = &module_specifier;
async move {
log::debug!(">>>>> bundle START");
- let ps = ProcState::from_cli_options(cli_options).await?;
- let graph = ps
- .module_graph_builder
+ let factory = CliFactory::from_cli_options(cli_options);
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let cli_options = factory.cli_options();
+
+ let graph = module_graph_builder
.create_graph_and_maybe_check(vec![module_specifier.clone()])
.await?;
@@ -58,15 +60,14 @@ pub async fn bundle(
})
.collect();
- if let Ok(Some(import_map_path)) = ps
- .options
+ if let Ok(Some(import_map_path)) = cli_options
.resolve_import_map_specifier()
.map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
{
paths_to_watch.push(import_map_path);
}
- Ok((paths_to_watch, graph, ps))
+ Ok((paths_to_watch, graph, cli_options.clone()))
}
.map(move |result| match result {
Ok((paths_to_watch, graph, ps)) => ResolutionResult::Restart {
@@ -80,49 +81,50 @@ pub async fn bundle(
})
};
- let operation = |(ps, graph): (ProcState, Arc<deno_graph::ModuleGraph>)| {
- let out_file = &bundle_flags.out_file;
- async move {
- // at the moment, we don't support npm specifiers in deno bundle, so show an error
- error_for_any_npm_specifier(&graph)?;
-
- let bundle_output = bundle_module_graph(graph.as_ref(), &ps)?;
- log::debug!(">>>>> bundle END");
-
- if let Some(out_file) = out_file {
- let output_bytes = bundle_output.code.as_bytes();
- let output_len = output_bytes.len();
- util::fs::write_file(out_file, output_bytes, 0o644)?;
- log::info!(
- "{} {:?} ({})",
- colors::green("Emit"),
- out_file,
- colors::gray(display::human_size(output_len as f64))
- );
- if let Some(bundle_map) = bundle_output.maybe_map {
- let map_bytes = bundle_map.as_bytes();
- let map_len = map_bytes.len();
- let ext = if let Some(curr_ext) = out_file.extension() {
- format!("{}.map", curr_ext.to_string_lossy())
- } else {
- "map".to_string()
- };
- let map_out_file = out_file.with_extension(ext);
- util::fs::write_file(&map_out_file, map_bytes, 0o644)?;
+ let operation =
+ |(cli_options, graph): (Arc<CliOptions>, Arc<deno_graph::ModuleGraph>)| {
+ let out_file = &bundle_flags.out_file;
+ async move {
+ // at the moment, we don't support npm specifiers in deno bundle, so show an error
+ error_for_any_npm_specifier(&graph)?;
+
+ let bundle_output = bundle_module_graph(graph.as_ref(), &cli_options)?;
+ log::debug!(">>>>> bundle END");
+
+ if let Some(out_file) = out_file {
+ let output_bytes = bundle_output.code.as_bytes();
+ let output_len = output_bytes.len();
+ util::fs::write_file(out_file, output_bytes, 0o644)?;
log::info!(
"{} {:?} ({})",
colors::green("Emit"),
- map_out_file,
- colors::gray(display::human_size(map_len as f64))
+ out_file,
+ colors::gray(display::human_size(output_len as f64))
);
+ if let Some(bundle_map) = bundle_output.maybe_map {
+ let map_bytes = bundle_map.as_bytes();
+ let map_len = map_bytes.len();
+ let ext = if let Some(curr_ext) = out_file.extension() {
+ format!("{}.map", curr_ext.to_string_lossy())
+ } else {
+ "map".to_string()
+ };
+ let map_out_file = out_file.with_extension(ext);
+ util::fs::write_file(&map_out_file, map_bytes, 0o644)?;
+ log::info!(
+ "{} {:?} ({})",
+ colors::green("Emit"),
+ map_out_file,
+ colors::gray(display::human_size(map_len as f64))
+ );
+ }
+ } else {
+ println!("{}", bundle_output.code);
}
- } else {
- println!("{}", bundle_output.code);
- }
- Ok(())
- }
- };
+ Ok(())
+ }
+ };
if cli_options.watch_paths().is_some() {
util::file_watcher::watch_func(
@@ -149,14 +151,13 @@ pub async fn bundle(
fn bundle_module_graph(
graph: &deno_graph::ModuleGraph,
- ps: &ProcState,
+ cli_options: &CliOptions,
) -> Result<deno_emit::BundleEmit, AnyError> {
log::info!("{} {}", colors::green("Bundle"), graph.roots[0]);
- let ts_config_result = ps
- .options
- .resolve_ts_config_for_emit(TsConfigType::Bundle)?;
- if ps.options.type_check_mode() == TypeCheckMode::None {
+ let ts_config_result =
+ cli_options.resolve_ts_config_for_emit(TsConfigType::Bundle)?;
+ if cli_options.type_check_mode() == TypeCheckMode::None {
if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
log::warn!("{}", ignored_options);
}
diff --git a/cli/tools/check.rs b/cli/tools/check.rs
index 4fb6800fa..4464802e6 100644
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@@ -19,7 +19,6 @@ use crate::args::TsConfigType;
use crate::args::TsTypeLib;
use crate::args::TypeCheckMode;
use crate::cache::Caches;
-use crate::cache::DenoDir;
use crate::cache::FastInsecureHasher;
use crate::cache::TypeCheckCache;
use crate::npm::CliNpmResolver;
@@ -39,7 +38,6 @@ pub struct CheckOptions {
}
pub struct TypeChecker {
- deno_dir: DenoDir,
caches: Arc<Caches>,
cli_options: Arc<CliOptions>,
node_resolver: Arc<NodeResolver>,
@@ -48,14 +46,12 @@ pub struct TypeChecker {
impl TypeChecker {
pub fn new(
- deno_dir: DenoDir,
caches: Arc<Caches>,
cli_options: Arc<CliOptions>,
node_resolver: Arc<NodeResolver>,
npm_resolver: Arc<CliNpmResolver>,
) -> Self {
Self {
- deno_dir,
caches,
cli_options,
node_resolver,
@@ -95,8 +91,7 @@ impl TypeChecker {
let ts_config = ts_config_result.ts_config;
let type_check_mode = self.cli_options.type_check_mode();
let debug = self.cli_options.log_level() == Some(log::Level::Debug);
- let cache =
- TypeCheckCache::new(self.caches.type_checking_cache_db(&self.deno_dir));
+ let cache = TypeCheckCache::new(self.caches.type_checking_cache_db());
let check_js = ts_config.get_check_js();
let check_hash = match get_check_hash(&graph, type_check_mode, &ts_config) {
CheckHashResult::NoFiles => return Ok(()),
diff --git a/cli/tools/coverage/mod.rs b/cli/tools/coverage/mod.rs
index d3044a716..223bac316 100644
--- a/cli/tools/coverage/mod.rs
+++ b/cli/tools/coverage/mod.rs
@@ -4,7 +4,7 @@ use crate::args::CoverageFlags;
use crate::args::FileFlags;
use crate::args::Flags;
use crate::colors;
-use crate::proc_state::ProcState;
+use crate::factory::CliFactory;
use crate::tools::fmt::format_json;
use crate::tools::test::is_supported_test_path;
use crate::util::fs::FileCollector;
@@ -623,8 +623,11 @@ pub async fn cover_files(
return Err(generic_error("No matching coverage profiles found"));
}
- let ps = ProcState::from_flags(flags).await?;
- let root_dir_url = ps.npm_resolver.root_dir_url();
+ let factory = CliFactory::from_flags(flags).await?;
+ let root_dir_url = factory.npm_resolver().await?.root_dir_url();
+ let file_fetcher = factory.file_fetcher()?;
+ let cli_options = factory.cli_options();
+ let emitter = factory.emitter()?;
let script_coverages = collect_coverages(coverage_flags.files)?;
let script_coverages = filter_coverages(
@@ -667,13 +670,13 @@ pub async fn cover_files(
for script_coverage in script_coverages {
let module_specifier = deno_core::resolve_url_or_path(
&script_coverage.url,
- ps.options.initial_cwd(),
+ cli_options.initial_cwd(),
)?;
let maybe_file = if module_specifier.scheme() == "file" {
- ps.file_fetcher.get_source(&module_specifier)
+ file_fetcher.get_source(&module_specifier)
} else {
- ps.file_fetcher
+ file_fetcher
.fetch_cached(&module_specifier, 10)
.with_context(|| {
format!("Failed to fetch \"{module_specifier}\" from cache.")
@@ -700,7 +703,7 @@ pub async fn cover_files(
| MediaType::Mts
| MediaType::Cts
| MediaType::Tsx => {
- match ps.emitter.maybed_cached_emit(&file.specifier, &file.source) {
+ match emitter.maybed_cached_emit(&file.specifier, &file.source) {
Some(code) => code.into(),
None => {
return Err(anyhow!(
diff --git a/cli/tools/doc.rs b/cli/tools/doc.rs
index a07ba175a..2cb53cb6a 100644
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@@ -6,9 +6,9 @@ use crate::args::Flags;
use crate::colors;
use crate::display::write_json_to_stdout;
use crate::display::write_to_stdout_ignore_sigpipe;
+use crate::factory::CliFactory;
use crate::file_fetcher::File;
use crate::graph_util::graph_lock_or_exit;
-use crate::proc_state::ProcState;
use crate::tsc::get_types_declaration_file_text;
use deno_ast::MediaType;
use deno_core::anyhow::bail;
@@ -23,13 +23,14 @@ pub async fn print_docs(
flags: Flags,
doc_flags: DocFlags,
) -> Result<(), AnyError> {
- let ps = ProcState::from_flags(flags).await?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
let mut doc_nodes = match doc_flags.source_file {
DocSourceFileFlag::Builtin => {
let source_file_specifier =
ModuleSpecifier::parse("internal://lib.deno.d.ts").unwrap();
- let content = get_types_declaration_file_text(ps.options.unstable());
+ let content = get_types_declaration_file_text(cli_options.unstable());
let mut loader = deno_graph::source::MemoryLoader::new(
vec![(
source_file_specifier.to_string(),
@@ -61,13 +62,18 @@ pub async fn print_docs(
doc_parser.parse_module(&source_file_specifier)?.definitions
}
DocSourceFileFlag::Path(source_file) => {
+ let file_fetcher = factory.file_fetcher()?;
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let maybe_lockfile = factory.maybe_lockfile();
+ let parsed_source_cache = factory.parsed_source_cache()?;
+
let module_specifier =
- resolve_url_or_path(&source_file, ps.options.initial_cwd())?;
+ resolve_url_or_path(&source_file, cli_options.initial_cwd())?;
// If the root module has external types, the module graph won't redirect it,
// so instead create a dummy file which exports everything from the actual file being documented.
let root_specifier =
- resolve_path("./$deno$doc.ts", ps.options.initial_cwd()).unwrap();
+ resolve_path("./$deno$doc.ts", cli_options.initial_cwd()).unwrap();
let root = File {
local: PathBuf::from("./$deno$doc.ts"),
maybe_types: None,
@@ -78,21 +84,20 @@ pub async fn print_docs(
};
// Save our fake file into file fetcher cache.
- ps.file_fetcher.insert_cached(root);
+ file_fetcher.insert_cached(root);
- let graph = ps
- .module_graph_builder
+ let graph = module_graph_builder
.create_graph(vec![root_specifier.clone()])
.await?;
- if let Some(lockfile) = &ps.lockfile {
+ if let Some(lockfile) = maybe_lockfile {
graph_lock_or_exit(&graph, &mut lockfile.lock());
}
let doc_parser = doc::DocParser::new(
graph,
doc_flags.private,
- ps.parsed_source_cache.as_capturing_parser(),
+ parsed_source_cache.as_capturing_parser(),
);
doc_parser.parse_with_reexports(&root_specifier)?
}
diff --git a/cli/tools/fmt.rs b/cli/tools/fmt.rs
index 41accacba..70d2bd639 100644
--- a/cli/tools/fmt.rs
+++ b/cli/tools/fmt.rs
@@ -12,8 +12,8 @@ use crate::args::FilesConfig;
use crate::args::FmtOptions;
use crate::args::FmtOptionsConfig;
use crate::args::ProseWrap;
-use crate::cache::Caches;
use crate::colors;
+use crate::factory::CliFactory;
use crate::util::diff::diff;
use crate::util::file_watcher;
use crate::util::file_watcher::ResolutionResult;
@@ -101,11 +101,12 @@ pub async fn format(
}
}
};
- let deno_dir = &cli_options.resolve_deno_dir()?;
- let caches = Caches::default();
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
+ let caches = factory.caches()?;
let operation = |(paths, fmt_options): (Vec<PathBuf>, FmtOptionsConfig)| async {
let incremental_cache = Arc::new(IncrementalCache::new(
- caches.fmt_incremental_cache_db(deno_dir),
+ caches.fmt_incremental_cache_db(),
&fmt_options,
&paths,
));
diff --git a/cli/tools/info.rs b/cli/tools/info.rs
index a59f8a4c8..d491f55dc 100644
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@@ -27,57 +27,61 @@ use deno_semver::npm::NpmPackageReqReference;
use crate::args::Flags;
use crate::args::InfoFlags;
use crate::display;
+use crate::factory::CliFactory;
use crate::graph_util::graph_lock_or_exit;
use crate::npm::CliNpmResolver;
-use crate::proc_state::ProcState;
use crate::util::checksum;
pub async fn info(flags: Flags, info_flags: InfoFlags) -> Result<(), AnyError> {
- let ps = ProcState::from_flags(flags).await?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
if let Some(specifier) = info_flags.file {
- let specifier = resolve_url_or_path(&specifier, ps.options.initial_cwd())?;
- let mut loader = ps.module_graph_builder.create_graph_loader();
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let npm_resolver = factory.npm_resolver().await?;
+ let maybe_lockfile = factory.maybe_lockfile();
+ let specifier = resolve_url_or_path(&specifier, cli_options.initial_cwd())?;
+ let mut loader = module_graph_builder.create_graph_loader();
loader.enable_loading_cache_info(); // for displaying the cache information
- let graph = ps
- .module_graph_builder
+ let graph = module_graph_builder
.create_graph_with_loader(vec![specifier], &mut loader)
.await?;
- if let Some(lockfile) = &ps.lockfile {
+ if let Some(lockfile) = maybe_lockfile {
graph_lock_or_exit(&graph, &mut lockfile.lock());
}
if info_flags.json {
let mut json_graph = json!(graph);
- add_npm_packages_to_json(&mut json_graph, &ps.npm_resolver);
+ add_npm_packages_to_json(&mut json_graph, npm_resolver);
display::write_json_to_stdout(&json_graph)?;
} else {
let mut output = String::new();
- GraphDisplayContext::write(&graph, &ps.npm_resolver, &mut output)?;
+ GraphDisplayContext::write(&graph, npm_resolver, &mut output)?;
display::write_to_stdout_ignore_sigpipe(output.as_bytes())?;
}
} else {
// If it was just "deno info" print location of caches and exit
print_cache_info(
- &ps,
+ &factory,
info_flags.json,
- ps.options.location_flag().as_ref(),
+ cli_options.location_flag().as_ref(),
)?;
}
Ok(())
}
fn print_cache_info(
- state: &ProcState,
+ factory: &CliFactory,
json: bool,
location: Option<&deno_core::url::Url>,
) -> Result<(), AnyError> {
- let deno_dir = &state.dir.root_path_for_display();
- let modules_cache = &state.file_fetcher.get_http_cache_location();
- let npm_cache = &state.npm_cache.as_readonly().get_cache_location();
- let typescript_cache = &state.dir.gen_cache.location;
- let registry_cache = &state.dir.registries_folder_path();
- let mut origin_dir = state.dir.origin_data_folder_path();
+ let dir = factory.deno_dir()?;
+ let modules_cache = factory.file_fetcher()?.get_http_cache_location();
+ let npm_cache = factory.npm_cache()?.as_readonly().get_cache_location();
+ let typescript_cache = &dir.gen_cache.location;
+ let registry_cache = dir.registries_folder_path();
+ let mut origin_dir = dir.origin_data_folder_path();
+ let deno_dir = dir.root_path_for_display().to_string();
if let Some(location) = &location {
origin_dir =
@@ -88,7 +92,7 @@ fn print_cache_info(
if json {
let mut output = json!({
- "denoDir": deno_dir.to_string(),
+ "denoDir": deno_dir,
"modulesCache": modules_cache,
"npmCache": npm_cache,
"typescriptCache": typescript_cache,
diff --git a/cli/tools/installer.rs b/cli/tools/installer.rs
index 461bb1a50..fb83c3cab 100644
--- a/cli/tools/installer.rs
+++ b/cli/tools/installer.rs
@@ -6,8 +6,8 @@ use crate::args::ConfigFlag;
use crate::args::Flags;
use crate::args::InstallFlags;
use crate::args::TypeCheckMode;
+use crate::factory::CliFactory;
use crate::http_util::HttpClient;
-use crate::proc_state::ProcState;
use crate::util::fs::canonicalize_path_maybe_not_exists;
use deno_core::anyhow::Context;
@@ -233,9 +233,10 @@ pub async fn install_command(
install_flags: InstallFlags,
) -> Result<(), AnyError> {
// ensure the module is cached
- ProcState::from_flags(flags.clone())
+ CliFactory::from_flags(flags.clone())
+ .await?
+ .module_load_preparer()
.await?
- .module_load_preparer
.load_and_type_check_files(&[install_flags.module_url.clone()])
.await?;
diff --git a/cli/tools/lint.rs b/cli/tools/lint.rs
index eae2f1032..40c37ce77 100644
--- a/cli/tools/lint.rs
+++ b/cli/tools/lint.rs
@@ -11,8 +11,8 @@ use crate::args::FilesConfig;
use crate::args::LintOptions;
use crate::args::LintReporterKind;
use crate::args::LintRulesConfig;
-use crate::cache::Caches;
use crate::colors;
+use crate::factory::CliFactory;
use crate::tools::fmt::run_parallelized;
use crate::util::file_watcher;
use crate::util::file_watcher::ResolutionResult;
@@ -98,11 +98,12 @@ pub async fn lint(
};
let has_error = Arc::new(AtomicBool::new(false));
- let deno_dir = cli_options.resolve_deno_dir()?;
- let caches = Caches::default();
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
+ let caches = factory.caches()?;
let operation = |paths: Vec<PathBuf>| async {
let incremental_cache = Arc::new(IncrementalCache::new(
- caches.lint_incremental_cache_db(&deno_dir),
+ caches.lint_incremental_cache_db(),
// use a hash of the rule names in order to bust the cache
&{
// ensure this is stable by sorting it
diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs
index f0faf74ec..9f4b58919 100644
--- a/cli/tools/repl/mod.rs
+++ b/cli/tools/repl/mod.rs
@@ -4,8 +4,8 @@ use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::ReplFlags;
use crate::colors;
+use crate::factory::CliFactory;
use crate::file_fetcher::FileFetcher;
-use crate::proc_state::ProcState;
use deno_core::error::AnyError;
use deno_core::futures::StreamExt;
use deno_runtime::permissions::Permissions;
@@ -98,17 +98,17 @@ async fn read_eval_file(
}
pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
- let ps = ProcState::from_flags(flags).await?;
- let main_module = ps.options.resolve_main_module()?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
+ let main_module = cli_options.resolve_main_module()?;
let permissions = PermissionsContainer::new(Permissions::from_options(
- &ps.options.permissions_options(),
+ &cli_options.permissions_options(),
)?);
- let cli_options = ps.options.clone();
- let npm_resolver = ps.npm_resolver.clone();
- let resolver = ps.resolver.clone();
- let dir = ps.dir.clone();
- let file_fetcher = ps.file_fetcher.clone();
- let worker_factory = ps.create_cli_main_worker_factory();
+ let npm_resolver = factory.npm_resolver().await?.clone();
+ let resolver = factory.resolver().await?.clone();
+ let dir = factory.deno_dir()?;
+ let file_fetcher = factory.file_fetcher()?;
+ let worker_factory = factory.create_cli_main_worker_factory().await?;
let mut worker = worker_factory
.create_main_worker(main_module, permissions)
@@ -116,7 +116,7 @@ pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
worker.setup_repl().await?;
let worker = worker.into_main_worker();
let mut repl_session =
- ReplSession::initialize(&cli_options, npm_resolver, resolver, worker)
+ ReplSession::initialize(cli_options, npm_resolver, resolver, worker)
.await?;
let mut rustyline_channel = rustyline_channel();
@@ -130,7 +130,7 @@ pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
if let Some(eval_files) = repl_flags.eval_files {
for eval_file in eval_files {
- match read_eval_file(&cli_options, &file_fetcher, &eval_file).await {
+ match read_eval_file(cli_options, file_fetcher, &eval_file).await {
Ok(eval_source) => {
let output = repl_session
.evaluate_line_and_get_output(&eval_source)
diff --git a/cli/tools/run.rs b/cli/tools/run.rs
index e1dc529bc..c6e706285 100644
--- a/cli/tools/run.rs
+++ b/cli/tools/run.rs
@@ -10,8 +10,9 @@ use deno_runtime::permissions::PermissionsContainer;
use crate::args::EvalFlags;
use crate::args::Flags;
+use crate::factory::CliFactory;
+use crate::factory::CliFactoryBuilder;
use crate::file_fetcher::File;
-use crate::proc_state::ProcState;
use crate::util;
pub async fn run_script(flags: Flags) -> Result<i32, AnyError> {
@@ -31,23 +32,25 @@ To grant permissions, set them before the script argument. For example:
}
// TODO(bartlomieju): actually I think it will also fail if there's an import
- // map specified and bare specifier is used on the command line - this should
- // probably call `ProcState::resolve` instead
- let ps = ProcState::from_flags(flags).await?;
+ // map specified and bare specifier is used on the command line
+ let factory = CliFactory::from_flags(flags).await?;
+ let deno_dir = factory.deno_dir()?;
+ let http_client = factory.http_client()?;
+ let cli_options = factory.cli_options();
// Run a background task that checks for available upgrades. If an earlier
// run of this background task found a new version of Deno.
super::upgrade::check_for_upgrades(
- ps.http_client.clone(),
- ps.dir.upgrade_check_file_path(),
+ http_client.clone(),
+ deno_dir.upgrade_check_file_path(),
);
- let main_module = ps.options.resolve_main_module()?;
+ let main_module = cli_options.resolve_main_module()?;
let permissions = PermissionsContainer::new(Permissions::from_options(
- &ps.options.permissions_options(),
+ &cli_options.permissions_options(),
)?);
- let worker_factory = ps.create_cli_main_worker_factory();
+ let worker_factory = factory.create_cli_main_worker_factory().await?;
let mut worker = worker_factory
.create_main_worker(main_module, permissions)
.await?;
@@ -57,11 +60,14 @@ To grant permissions, set them before the script argument. For example:
}
pub async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
- let ps = ProcState::from_flags(flags).await?;
- let main_module = ps.options.resolve_main_module()?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
+ let main_module = cli_options.resolve_main_module()?;
+ let file_fetcher = factory.file_fetcher()?;
+ let worker_factory = factory.create_cli_main_worker_factory().await?;
let permissions = PermissionsContainer::new(Permissions::from_options(
- &ps.options.permissions_options(),
+ &cli_options.permissions_options(),
)?);
let mut source = Vec::new();
std::io::stdin().read_to_end(&mut source)?;
@@ -76,9 +82,8 @@ pub async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
};
// Save our fake file into file fetcher cache
// to allow module access by TS compiler
- ps.file_fetcher.insert_cached(source_file);
+ file_fetcher.insert_cached(source_file);
- let worker_factory = ps.create_cli_main_worker_factory();
let mut worker = worker_factory
.create_main_worker(main_module, permissions)
.await?;
@@ -90,20 +95,26 @@ pub async fn run_from_stdin(flags: Flags) -> Result<i32, AnyError> {
// code properly.
async fn run_with_watch(flags: Flags) -> Result<i32, AnyError> {
let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
- let ps =
- ProcState::from_flags_for_file_watcher(flags, sender.clone()).await?;
- let clear_screen = !ps.options.no_clear_screen();
- let main_module = ps.options.resolve_main_module()?;
+ let factory = CliFactoryBuilder::new()
+ .with_watcher(sender.clone())
+ .build_from_flags(flags)
+ .await?;
+ let file_watcher = factory.file_watcher()?;
+ let cli_options = factory.cli_options();
+ let clear_screen = !cli_options.no_clear_screen();
+ let main_module = cli_options.resolve_main_module()?;
+ let create_cli_main_worker_factory =
+ factory.create_cli_main_worker_factory_func().await?;
let operation = |main_module: ModuleSpecifier| {
- ps.reset_for_file_watcher();
+ file_watcher.reset();
let permissions = PermissionsContainer::new(Permissions::from_options(
- &ps.options.permissions_options(),
+ &cli_options.permissions_options(),
)?);
- let worker_factory = ps.create_cli_main_worker_factory();
+ let create_cli_main_worker_factory = create_cli_main_worker_factory.clone();
Ok(async move {
- let worker = worker_factory
+ let worker = create_cli_main_worker_factory()
.create_main_worker(main_module, permissions)
.await?;
worker.run_for_watcher().await?;
@@ -130,10 +141,14 @@ pub async fn eval_command(
flags: Flags,
eval_flags: EvalFlags,
) -> Result<i32, AnyError> {
- let ps = ProcState::from_flags(flags).await?;
- let main_module = ps.options.resolve_main_module()?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
+ let file_fetcher = factory.file_fetcher()?;
+ let main_worker_factory = factory.create_cli_main_worker_factory().await?;
+
+ let main_module = cli_options.resolve_main_module()?;
let permissions = PermissionsContainer::new(Permissions::from_options(
- &ps.options.permissions_options(),
+ &cli_options.permissions_options(),
)?);
// Create a dummy source file.
let source_code = if eval_flags.print {
@@ -154,10 +169,9 @@ pub async fn eval_command(
// Save our fake file into file fetcher cache
// to allow module access by TS compiler.
- ps.file_fetcher.insert_cached(file);
+ file_fetcher.insert_cached(file);
- let mut worker = ps
- .create_cli_main_worker_factory()
+ let mut worker = main_worker_factory
.create_main_worker(main_module, permissions)
.await?;
let exit_code = worker.run().await?;
diff --git a/cli/tools/standalone.rs b/cli/tools/standalone.rs
index 94b1c0170..0e8d9ca73 100644
--- a/cli/tools/standalone.rs
+++ b/cli/tools/standalone.rs
@@ -2,11 +2,11 @@
use crate::args::CompileFlags;
use crate::args::Flags;
+use crate::factory::CliFactory;
use crate::graph_util::error_for_any_npm_specifier;
use crate::standalone::is_standalone_binary;
use crate::standalone::DenoCompileBinaryWriter;
use crate::util::path::path_has_trailing_slash;
-use crate::ProcState;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
use deno_core::error::generic_error;
@@ -23,30 +23,34 @@ pub async fn compile(
flags: Flags,
compile_flags: CompileFlags,
) -> Result<(), AnyError> {
- let ps = ProcState::from_flags(flags).await?;
- let binary_writer = DenoCompileBinaryWriter::new(
- ps.file_fetcher.clone(),
- ps.http_client.clone(),
- ps.dir.clone(),
- );
- let module_specifier = ps.options.resolve_main_module()?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
+ let file_fetcher = factory.file_fetcher()?;
+ let http_client = factory.http_client()?;
+ let deno_dir = factory.deno_dir()?;
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let parsed_source_cache = factory.parsed_source_cache()?;
+
+ let binary_writer =
+ DenoCompileBinaryWriter::new(file_fetcher, http_client, deno_dir);
+ let module_specifier = cli_options.resolve_main_module()?;
let module_roots = {
let mut vec = Vec::with_capacity(compile_flags.include.len() + 1);
vec.push(module_specifier.clone());
for side_module in &compile_flags.include {
- vec.push(resolve_url_or_path(side_module, ps.options.initial_cwd())?);
+ vec.push(resolve_url_or_path(side_module, cli_options.initial_cwd())?);
}
vec
};
let output_path = resolve_compile_executable_output_path(
&compile_flags,
- ps.options.initial_cwd(),
+ cli_options.initial_cwd(),
)
.await?;
let graph = Arc::try_unwrap(
- ps.module_graph_builder
+ module_graph_builder
.create_graph_and_maybe_check(module_roots)
.await?,
)
@@ -55,7 +59,7 @@ 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)?;
- let parser = ps.parsed_source_cache.as_capturing_parser();
+ let parser = parsed_source_cache.as_capturing_parser();
let eszip = eszip::EszipV2::from_graph(graph, &parser, Default::default())?;
log::info!(
@@ -73,7 +77,7 @@ pub async fn compile(
eszip,
&module_specifier,
&compile_flags,
- &ps.options,
+ cli_options,
)
.await
.with_context(|| format!("Writing {}", output_path.display()))?;
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index 5d34d39c7..6380d3822 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -4,8 +4,8 @@ use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::TaskFlags;
use crate::colors;
+use crate::factory::CliFactory;
use crate::npm::CliNpmResolver;
-use crate::proc_state::ProcState;
use crate::util::fs::canonicalize_path;
use deno_core::anyhow::bail;
use deno_core::anyhow::Context;
@@ -26,9 +26,10 @@ pub async fn execute_script(
flags: Flags,
task_flags: TaskFlags,
) -> Result<i32, AnyError> {
- let ps = ProcState::from_flags(flags).await?;
- let tasks_config = ps.options.resolve_tasks_config()?;
- let maybe_package_json = ps.options.maybe_package_json();
+ let factory = CliFactory::from_flags(flags).await?;
+ let cli_options = factory.cli_options();
+ let tasks_config = cli_options.resolve_tasks_config()?;
+ let maybe_package_json = cli_options.maybe_package_json();
let package_json_scripts = maybe_package_json
.as_ref()
.and_then(|p| p.scripts.clone())
@@ -43,7 +44,7 @@ pub async fn execute_script(
};
if let Some(script) = tasks_config.get(task_name) {
- let config_file_url = ps.options.maybe_config_file_specifier().unwrap();
+ let config_file_url = cli_options.maybe_config_file_specifier().unwrap();
let config_file_path = if config_file_url.scheme() == "file" {
config_file_url.to_file_path().unwrap()
} else {
@@ -53,7 +54,7 @@ pub async fn execute_script(
Some(path) => canonicalize_path(&PathBuf::from(path))?,
None => config_file_path.parent().unwrap().to_owned(),
};
- let script = get_script_with_args(script, &ps.options);
+ let script = get_script_with_args(script, cli_options);
output_task(task_name, &script);
let seq_list = deno_task_shell::parser::parse(&script)
.with_context(|| format!("Error parsing script '{task_name}'."))?;
@@ -63,7 +64,12 @@ pub async fn execute_script(
.await;
Ok(exit_code)
} else if let Some(script) = package_json_scripts.get(task_name) {
- if let Some(package_deps) = ps.package_json_deps_installer.package_deps() {
+ let package_json_deps_installer =
+ factory.package_json_deps_installer().await?;
+ let npm_resolver = factory.npm_resolver().await?;
+ let node_resolver = factory.node_resolver().await?;
+
+ if let Some(package_deps) = package_json_deps_installer.package_deps() {
for (key, value) in package_deps {
if let Err(err) = value {
log::info!(
@@ -75,13 +81,14 @@ pub async fn execute_script(
}
}
}
- ps.package_json_deps_installer
+
+ package_json_deps_installer
.ensure_top_level_install()
.await?;
- ps.npm_resolver.resolve_pending().await?;
+ npm_resolver.resolve_pending().await?;
log::info!(
- "{} Currently only basic package.json `scripts` are supported. Programs like `rimraf` or `cross-env` will not work correctly. This will be fixed in the upcoming release.",
+ "{} Currently only basic package.json `scripts` are supported. Programs like `rimraf` or `cross-env` will not work correctly. This will be fixed in an upcoming release.",
colors::yellow("Warning"),
);
@@ -95,12 +102,11 @@ pub async fn execute_script(
.unwrap()
.to_owned(),
};
- let script = get_script_with_args(script, &ps.options);
+ let script = get_script_with_args(script, cli_options);
output_task(task_name, &script);
let seq_list = deno_task_shell::parser::parse(&script)
.with_context(|| format!("Error parsing script '{task_name}'."))?;
- let npx_commands =
- resolve_npm_commands(&ps.npm_resolver, &ps.node_resolver)?;
+ let npx_commands = resolve_npm_commands(npm_resolver, node_resolver)?;
let env_vars = collect_env_vars();
let exit_code =
deno_task_shell::execute(seq_list, env_vars, &cwd, npx_commands).await;
diff --git a/cli/tools/test.rs b/cli/tools/test.rs
index 429bee71b..847260352 100644
--- a/cli/tools/test.rs
+++ b/cli/tools/test.rs
@@ -6,12 +6,12 @@ use crate::args::TestOptions;
use crate::args::TypeCheckMode;
use crate::colors;
use crate::display;
+use crate::factory::CliFactory;
use crate::file_fetcher::File;
use crate::file_fetcher::FileFetcher;
use crate::graph_util::graph_valid_with_cli_options;
use crate::module_loader::ModuleLoadPreparer;
use crate::ops;
-use crate::proc_state::ProcState;
use crate::util::checksum;
use crate::util::file_watcher;
use crate::util::file_watcher::ResolutionResult;
@@ -1629,16 +1629,19 @@ pub async fn run_tests(
cli_options: CliOptions,
test_options: TestOptions,
) -> Result<(), AnyError> {
- let ps = ProcState::from_cli_options(Arc::new(cli_options)).await?;
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
+ let file_fetcher = factory.file_fetcher()?;
+ let module_load_preparer = factory.module_load_preparer().await?;
// Various test files should not share the same permissions in terms of
// `PermissionsContainer` - otherwise granting/revoking permissions in one
// file would have impact on other files, which is undesirable.
let permissions =
- Permissions::from_options(&ps.options.permissions_options())?;
- let log_level = ps.options.log_level();
+ Permissions::from_options(&cli_options.permissions_options())?;
+ let log_level = cli_options.log_level();
let specifiers_with_mode = fetch_specifiers_with_test_mode(
- &ps.file_fetcher,
+ file_fetcher,
&test_options.files,
&test_options.doc,
)
@@ -1649,9 +1652,9 @@ pub async fn run_tests(
}
check_specifiers(
- &ps.options,
- &ps.file_fetcher,
- &ps.module_load_preparer,
+ cli_options,
+ file_fetcher,
+ module_load_preparer,
specifiers_with_mode.clone(),
)
.await?;
@@ -1660,7 +1663,8 @@ pub async fn run_tests(
return Ok(());
}
- let worker_factory = Arc::new(ps.create_cli_main_worker_factory());
+ let worker_factory =
+ Arc::new(factory.create_cli_main_worker_factory().await?);
test_specifiers(
worker_factory,
@@ -1692,22 +1696,27 @@ pub async fn run_tests_with_watch(
cli_options: CliOptions,
test_options: TestOptions,
) -> Result<(), AnyError> {
- let ps = ProcState::from_cli_options(Arc::new(cli_options)).await?;
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
+ let module_graph_builder = factory.module_graph_builder().await?;
+ let module_load_preparer = factory.module_load_preparer().await?;
+ let file_fetcher = factory.file_fetcher()?;
+ let file_watcher = factory.file_watcher()?;
// Various test files should not share the same permissions in terms of
// `PermissionsContainer` - otherwise granting/revoking permissions in one
// file would have impact on other files, which is undesirable.
let permissions =
- Permissions::from_options(&ps.options.permissions_options())?;
- let no_check = ps.options.type_check_mode() == TypeCheckMode::None;
- let log_level = ps.options.log_level();
+ Permissions::from_options(&cli_options.permissions_options())?;
+ let no_check = cli_options.type_check_mode() == TypeCheckMode::None;
+ let log_level = cli_options.log_level();
let resolver = |changed: Option<Vec<PathBuf>>| {
let paths_to_watch = test_options.files.include.clone();
let paths_to_watch_clone = paths_to_watch.clone();
let files_changed = changed.is_some();
let test_options = &test_options;
- let cli_options = ps.options.clone();
- let module_graph_builder = ps.module_graph_builder.clone();
+ let cli_options = cli_options.clone();
+ let module_graph_builder = module_graph_builder.clone();
async move {
let test_modules = if test_options.doc {
@@ -1815,16 +1824,19 @@ pub async fn run_tests_with_watch(
})
};
+ let create_cli_main_worker_factory =
+ factory.create_cli_main_worker_factory_func().await?;
let operation = |modules_to_reload: Vec<ModuleSpecifier>| {
let permissions = &permissions;
let test_options = &test_options;
- ps.reset_for_file_watcher();
- let cli_options = ps.options.clone();
- let file_fetcher = ps.file_fetcher.clone();
- let module_load_preparer = ps.module_load_preparer.clone();
- let worker_factory = Arc::new(ps.create_cli_main_worker_factory());
+ file_watcher.reset();
+ let cli_options = cli_options.clone();
+ let file_fetcher = file_fetcher.clone();
+ let module_load_preparer = module_load_preparer.clone();
+ let create_cli_main_worker_factory = create_cli_main_worker_factory.clone();
async move {
+ let worker_factory = Arc::new(create_cli_main_worker_factory());
let specifiers_with_mode = fetch_specifiers_with_test_mode(
&file_fetcher,
&test_options.files,
@@ -1887,7 +1899,7 @@ pub async fn run_tests_with_watch(
}
});
- let clear_screen = !ps.options.no_clear_screen();
+ let clear_screen = !cli_options.no_clear_screen();
file_watcher::watch_func(
resolver,
operation,
diff --git a/cli/tools/upgrade.rs b/cli/tools/upgrade.rs
index f16923bf8..c76d36777 100644
--- a/cli/tools/upgrade.rs
+++ b/cli/tools/upgrade.rs
@@ -5,8 +5,8 @@
use crate::args::Flags;
use crate::args::UpgradeFlags;
use crate::colors;
+use crate::factory::CliFactory;
use crate::http_util::HttpClient;
-use crate::proc_state::ProcState;
use crate::util::progress_bar::ProgressBar;
use crate::util::progress_bar::ProgressBarStyle;
use crate::util::time;
@@ -263,7 +263,8 @@ pub async fn upgrade(
flags: Flags,
upgrade_flags: UpgradeFlags,
) -> Result<(), AnyError> {
- let ps = ProcState::from_flags(flags).await?;
+ let factory = CliFactory::from_flags(flags).await?;
+ let client = factory.http_client()?;
let current_exe_path = std::env::current_exe()?;
let metadata = fs::metadata(&current_exe_path)?;
let permissions = metadata.permissions();
@@ -285,8 +286,6 @@ pub async fn upgrade(
), current_exe_path.display());
}
- let client = &ps.http_client;
-
let install_version = match upgrade_flags.version {
Some(passed_version) => {
let re_hash = lazy_regex::regex!("^[0-9a-f]{40}$");
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index 225c3e6a8..d478c2b57 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -15,8 +15,8 @@ use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::FmtOptionsConfig;
use crate::args::VendorFlags;
+use crate::factory::CliFactory;
use crate::graph_util::ModuleGraphBuilder;
-use crate::proc_state::ProcState;
use crate::tools::fmt::format_json;
use crate::util::fs::canonicalize_path;
use crate::util::fs::resolve_from_cwd;
@@ -43,19 +43,20 @@ pub async fn vendor(
let output_dir = resolve_from_cwd(&raw_output_dir)?;
validate_output_dir(&output_dir, &vendor_flags)?;
validate_options(&mut cli_options, &output_dir)?;
- let ps = ProcState::from_cli_options(Arc::new(cli_options)).await?;
+ let factory = CliFactory::from_cli_options(Arc::new(cli_options));
+ let cli_options = factory.cli_options();
let graph = create_graph(
- &ps.module_graph_builder,
+ factory.module_graph_builder().await?,
&vendor_flags,
- ps.options.initial_cwd(),
+ cli_options.initial_cwd(),
)
.await?;
let vendored_count = build::build(
graph,
- &ps.parsed_source_cache,
+ factory.parsed_source_cache()?,
&output_dir,
- ps.maybe_import_map.as_deref(),
- ps.lockfile.clone(),
+ factory.maybe_import_map().await?.as_deref(),
+ factory.maybe_lockfile().clone(),
&build::RealVendorEnvironment,
)?;
@@ -71,7 +72,7 @@ pub async fn vendor(
);
if vendored_count > 0 {
let import_map_path = raw_output_dir.join("import_map.json");
- if maybe_update_config_file(&output_dir, &ps.options) {
+ if maybe_update_config_file(&output_dir, cli_options) {
log::info!(
concat!(
"\nUpdated your local Deno configuration file with a reference to the ",
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-05 03:16:07 +0000