|
|
use std::{ |
|
|
env::current_dir, |
|
|
mem::forget, |
|
|
path::{MAIN_SEPARATOR, PathBuf}, |
|
|
sync::Arc, |
|
|
}; |
|
|
|
|
|
use anyhow::{Context, Result, bail}; |
|
|
use rustc_hash::FxHashSet; |
|
|
use tracing::Instrument; |
|
|
use turbo_rcstr::RcStr; |
|
|
use turbo_tasks::{ |
|
|
ReadConsistency, ResolvedVc, TransientInstance, TryJoinIterExt, TurboTasks, Vc, apply_effects, |
|
|
}; |
|
|
use turbo_tasks_backend::{ |
|
|
BackendOptions, NoopBackingStorage, TurboTasksBackend, noop_backing_storage, |
|
|
}; |
|
|
use turbo_tasks_fs::FileSystem; |
|
|
use turbopack::{ |
|
|
css::chunk::CssChunkType, ecmascript::chunk::EcmascriptChunkType, |
|
|
global_module_ids::get_global_module_id_strategy, |
|
|
}; |
|
|
use turbopack_browser::{BrowserChunkingContext, ContentHashing, CurrentChunkMethod}; |
|
|
use turbopack_cli_utils::issue::{ConsoleUi, LogOptions}; |
|
|
use turbopack_core::{ |
|
|
asset::Asset, |
|
|
chunk::{ |
|
|
ChunkingConfig, ChunkingContext, EvaluatableAsset, EvaluatableAssets, MangleType, |
|
|
MinifyType, SourceMapsType, availability_info::AvailabilityInfo, |
|
|
}, |
|
|
environment::{BrowserEnvironment, Environment, ExecutionEnvironment, NodeJsEnvironment}, |
|
|
ident::AssetIdent, |
|
|
issue::{IssueReporter, IssueSeverity, handle_issues}, |
|
|
module::Module, |
|
|
module_graph::{ |
|
|
ModuleGraph, |
|
|
chunk_group_info::{ChunkGroup, ChunkGroupEntry}, |
|
|
export_usage::compute_export_usage_info, |
|
|
}, |
|
|
output::{OutputAsset, OutputAssets}, |
|
|
reference::all_assets_from_entries, |
|
|
reference_type::{EntryReferenceSubType, ReferenceType}, |
|
|
resolve::{ |
|
|
origin::{PlainResolveOrigin, ResolveOriginExt}, |
|
|
parse::Request, |
|
|
}, |
|
|
}; |
|
|
use turbopack_ecmascript_runtime::RuntimeType; |
|
|
use turbopack_env::dotenv::load_env; |
|
|
use turbopack_node::execution_context::ExecutionContext; |
|
|
use turbopack_nodejs::NodeJsChunkingContext; |
|
|
|
|
|
use crate::{ |
|
|
arguments::{BuildArguments, Target}, |
|
|
contexts::{NodeEnv, get_client_asset_context, get_client_compile_time_info}, |
|
|
util::{ |
|
|
EntryRequest, NormalizedDirs, normalize_dirs, normalize_entries, output_fs, project_fs, |
|
|
}, |
|
|
}; |
|
|
|
|
|
type Backend = TurboTasksBackend<NoopBackingStorage>; |
|
|
|
|
|
pub struct TurbopackBuildBuilder { |
|
|
turbo_tasks: Arc<TurboTasks<Backend>>, |
|
|
project_dir: RcStr, |
|
|
root_dir: RcStr, |
|
|
entry_requests: Vec<EntryRequest>, |
|
|
browserslist_query: RcStr, |
|
|
log_level: IssueSeverity, |
|
|
show_all: bool, |
|
|
log_detail: bool, |
|
|
source_maps_type: SourceMapsType, |
|
|
minify_type: MinifyType, |
|
|
target: Target, |
|
|
scope_hoist: bool, |
|
|
} |
|
|
|
|
|
impl TurbopackBuildBuilder { |
|
|
pub fn new(turbo_tasks: Arc<TurboTasks<Backend>>, project_dir: RcStr, root_dir: RcStr) -> Self { |
|
|
TurbopackBuildBuilder { |
|
|
turbo_tasks, |
|
|
project_dir, |
|
|
root_dir, |
|
|
entry_requests: vec![], |
|
|
browserslist_query: "last 1 Chrome versions, last 1 Firefox versions, last 1 Safari \ |
|
|
versions, last 1 Edge versions" |
|
|
.into(), |
|
|
log_level: IssueSeverity::Warning, |
|
|
show_all: false, |
|
|
log_detail: false, |
|
|
source_maps_type: SourceMapsType::Full, |
|
|
minify_type: MinifyType::Minify { |
|
|
mangle: Some(MangleType::OptimalSize), |
|
|
}, |
|
|
target: Target::Node, |
|
|
scope_hoist: true, |
|
|
} |
|
|
} |
|
|
|
|
|
pub fn entry_request(mut self, entry_asset_path: EntryRequest) -> Self { |
|
|
self.entry_requests.push(entry_asset_path); |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn browserslist_query(mut self, browserslist_query: RcStr) -> Self { |
|
|
self.browserslist_query = browserslist_query; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn log_level(mut self, log_level: IssueSeverity) -> Self { |
|
|
self.log_level = log_level; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn show_all(mut self, show_all: bool) -> Self { |
|
|
self.show_all = show_all; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn log_detail(mut self, log_detail: bool) -> Self { |
|
|
self.log_detail = log_detail; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn source_maps_type(mut self, source_maps_type: SourceMapsType) -> Self { |
|
|
self.source_maps_type = source_maps_type; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn minify_type(mut self, minify_type: MinifyType) -> Self { |
|
|
self.minify_type = minify_type; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn scope_hoist(mut self, scope_hoist: bool) -> Self { |
|
|
self.scope_hoist = scope_hoist; |
|
|
self |
|
|
} |
|
|
|
|
|
pub fn target(mut self, target: Target) -> Self { |
|
|
self.target = target; |
|
|
self |
|
|
} |
|
|
|
|
|
pub async fn build(self) -> Result<()> { |
|
|
let task = self.turbo_tasks.spawn_once_task::<(), _>(async move { |
|
|
let build_result_op = build_internal( |
|
|
self.project_dir.clone(), |
|
|
self.root_dir, |
|
|
self.entry_requests.clone(), |
|
|
self.browserslist_query, |
|
|
self.source_maps_type, |
|
|
self.minify_type, |
|
|
self.target, |
|
|
self.scope_hoist, |
|
|
); |
|
|
|
|
|
|
|
|
build_result_op.read_strongly_consistent().await?; |
|
|
|
|
|
apply_effects(build_result_op) |
|
|
.instrument(tracing::info_span!("apply effects")) |
|
|
.await?; |
|
|
|
|
|
let issue_reporter: Vc<Box<dyn IssueReporter>> = |
|
|
Vc::upcast(ConsoleUi::new(TransientInstance::new(LogOptions { |
|
|
project_dir: PathBuf::from(self.project_dir), |
|
|
current_dir: current_dir().unwrap(), |
|
|
show_all: self.show_all, |
|
|
log_detail: self.log_detail, |
|
|
log_level: self.log_level, |
|
|
}))); |
|
|
|
|
|
handle_issues( |
|
|
build_result_op, |
|
|
issue_reporter, |
|
|
IssueSeverity::Error, |
|
|
None, |
|
|
None, |
|
|
) |
|
|
.await?; |
|
|
|
|
|
Ok(Default::default()) |
|
|
}); |
|
|
|
|
|
self.turbo_tasks |
|
|
.wait_task_completion(task, ReadConsistency::Strong) |
|
|
.await?; |
|
|
|
|
|
Ok(()) |
|
|
} |
|
|
} |
|
|
|
|
|
#[turbo_tasks::function(operation)] |
|
|
async fn build_internal( |
|
|
project_dir: RcStr, |
|
|
root_dir: RcStr, |
|
|
entry_requests: Vec<EntryRequest>, |
|
|
browserslist_query: RcStr, |
|
|
source_maps_type: SourceMapsType, |
|
|
minify_type: MinifyType, |
|
|
target: Target, |
|
|
scope_hoist: bool, |
|
|
) -> Result<Vc<()>> { |
|
|
let output_fs = output_fs(project_dir.clone()); |
|
|
let project_fs = project_fs(root_dir.clone(), false); |
|
|
let project_relative = project_dir.strip_prefix(&*root_dir).unwrap(); |
|
|
let project_relative: RcStr = project_relative |
|
|
.strip_prefix(MAIN_SEPARATOR) |
|
|
.unwrap_or(project_relative) |
|
|
.replace(MAIN_SEPARATOR, "/") |
|
|
.into(); |
|
|
let root_path = project_fs.root().owned().await?; |
|
|
let project_path = root_path.join(&project_relative)?; |
|
|
let build_output_root = output_fs.root().await?.join("dist")?; |
|
|
|
|
|
let node_env = NodeEnv::Production.cell(); |
|
|
|
|
|
let build_output_root_to_root_path = project_path |
|
|
.join("dist")? |
|
|
.get_relative_path_to(&root_path) |
|
|
.context("Project path is in root path")?; |
|
|
|
|
|
let runtime_type = match *node_env.await? { |
|
|
NodeEnv::Development => RuntimeType::Development, |
|
|
NodeEnv::Production => RuntimeType::Production, |
|
|
}; |
|
|
|
|
|
let compile_time_info = get_client_compile_time_info(browserslist_query.clone(), node_env); |
|
|
let execution_context = ExecutionContext::new( |
|
|
root_path.clone(), |
|
|
Vc::upcast( |
|
|
NodeJsChunkingContext::builder( |
|
|
project_path.clone(), |
|
|
build_output_root.clone(), |
|
|
build_output_root_to_root_path.clone(), |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
Environment::new(ExecutionEnvironment::NodeJsLambda( |
|
|
NodeJsEnvironment::default().resolved_cell(), |
|
|
)) |
|
|
.to_resolved() |
|
|
.await?, |
|
|
runtime_type, |
|
|
) |
|
|
.build(), |
|
|
), |
|
|
load_env(root_path.clone()), |
|
|
); |
|
|
|
|
|
let asset_context = get_client_asset_context( |
|
|
project_path.clone(), |
|
|
execution_context, |
|
|
compile_time_info, |
|
|
node_env, |
|
|
source_maps_type, |
|
|
); |
|
|
|
|
|
let entry_requests = (*entry_requests |
|
|
.into_iter() |
|
|
.map(|r| async move { |
|
|
Ok(match r { |
|
|
EntryRequest::Relative(p) => Request::relative( |
|
|
p.clone().into(), |
|
|
Default::default(), |
|
|
Default::default(), |
|
|
false, |
|
|
), |
|
|
EntryRequest::Module(m, p) => Request::module( |
|
|
m.clone(), |
|
|
p.clone().into(), |
|
|
Default::default(), |
|
|
Default::default(), |
|
|
), |
|
|
}) |
|
|
}) |
|
|
.try_join() |
|
|
.await?) |
|
|
.to_vec(); |
|
|
|
|
|
let origin = PlainResolveOrigin::new(asset_context, project_fs.root().await?.join("_")?); |
|
|
let project_dir = &project_dir; |
|
|
let entries = async move { |
|
|
entry_requests |
|
|
.into_iter() |
|
|
.map(|request_vc| async move { |
|
|
let ty = ReferenceType::Entry(EntryReferenceSubType::Undefined); |
|
|
let request = request_vc.await?; |
|
|
origin |
|
|
.resolve_asset(request_vc, origin.resolve_options(ty.clone()).await?, ty) |
|
|
.await? |
|
|
.first_module() |
|
|
.await? |
|
|
.with_context(|| { |
|
|
format!( |
|
|
"Unable to resolve entry {} from directory {}.", |
|
|
request.request().unwrap(), |
|
|
project_dir |
|
|
) |
|
|
}) |
|
|
}) |
|
|
.try_join() |
|
|
.await |
|
|
} |
|
|
.instrument(tracing::info_span!("resolve entries")) |
|
|
.await?; |
|
|
|
|
|
let module_graph = ModuleGraph::from_modules( |
|
|
Vc::cell(vec![ChunkGroupEntry::Entry(entries.clone())]), |
|
|
false, |
|
|
); |
|
|
let module_id_strategy = ResolvedVc::upcast( |
|
|
get_global_module_id_strategy(module_graph) |
|
|
.to_resolved() |
|
|
.await?, |
|
|
); |
|
|
let export_usage = compute_export_usage_info(module_graph.to_resolved().await?) |
|
|
.resolve_strongly_consistent() |
|
|
.await?; |
|
|
|
|
|
let chunking_context: Vc<Box<dyn ChunkingContext>> = match target { |
|
|
Target::Browser => { |
|
|
let mut builder = BrowserChunkingContext::builder( |
|
|
project_path, |
|
|
build_output_root.clone(), |
|
|
build_output_root_to_root_path, |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
Environment::new(ExecutionEnvironment::Browser( |
|
|
BrowserEnvironment { |
|
|
dom: true, |
|
|
web_worker: false, |
|
|
service_worker: false, |
|
|
browserslist_query: browserslist_query.clone(), |
|
|
} |
|
|
.resolved_cell(), |
|
|
)) |
|
|
.to_resolved() |
|
|
.await?, |
|
|
runtime_type, |
|
|
) |
|
|
.source_maps(source_maps_type) |
|
|
.module_id_strategy(module_id_strategy) |
|
|
.export_usage(Some(export_usage)) |
|
|
.current_chunk_method(CurrentChunkMethod::DocumentCurrentScript) |
|
|
.minify_type(minify_type); |
|
|
|
|
|
match *node_env.await? { |
|
|
NodeEnv::Development => {} |
|
|
NodeEnv::Production => { |
|
|
builder = builder |
|
|
.chunking_config( |
|
|
Vc::<EcmascriptChunkType>::default().to_resolved().await?, |
|
|
ChunkingConfig { |
|
|
min_chunk_size: 50_000, |
|
|
max_chunk_count_per_group: 40, |
|
|
max_merge_chunk_size: 200_000, |
|
|
..Default::default() |
|
|
}, |
|
|
) |
|
|
.chunking_config( |
|
|
Vc::<CssChunkType>::default().to_resolved().await?, |
|
|
ChunkingConfig { |
|
|
max_merge_chunk_size: 100_000, |
|
|
..Default::default() |
|
|
}, |
|
|
) |
|
|
.use_content_hashing(ContentHashing::Direct { length: 16 }) |
|
|
.module_merging(scope_hoist); |
|
|
} |
|
|
} |
|
|
|
|
|
Vc::upcast(builder.build()) |
|
|
} |
|
|
Target::Node => { |
|
|
let mut builder = NodeJsChunkingContext::builder( |
|
|
project_path, |
|
|
build_output_root.clone(), |
|
|
build_output_root_to_root_path, |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
build_output_root.clone(), |
|
|
Environment::new(ExecutionEnvironment::NodeJsLambda( |
|
|
NodeJsEnvironment::default().resolved_cell(), |
|
|
)) |
|
|
.to_resolved() |
|
|
.await?, |
|
|
runtime_type, |
|
|
) |
|
|
.source_maps(source_maps_type) |
|
|
.module_id_strategy(module_id_strategy) |
|
|
.export_usage(Some(export_usage)) |
|
|
.minify_type(minify_type); |
|
|
|
|
|
match *node_env.await? { |
|
|
NodeEnv::Development => {} |
|
|
NodeEnv::Production => { |
|
|
builder = builder |
|
|
.chunking_config( |
|
|
Vc::<EcmascriptChunkType>::default().to_resolved().await?, |
|
|
ChunkingConfig { |
|
|
min_chunk_size: 20_000, |
|
|
max_chunk_count_per_group: 100, |
|
|
max_merge_chunk_size: 100_000, |
|
|
..Default::default() |
|
|
}, |
|
|
) |
|
|
.chunking_config( |
|
|
Vc::<CssChunkType>::default().to_resolved().await?, |
|
|
ChunkingConfig { |
|
|
max_merge_chunk_size: 100_000, |
|
|
..Default::default() |
|
|
}, |
|
|
) |
|
|
.module_merging(scope_hoist); |
|
|
} |
|
|
} |
|
|
|
|
|
Vc::upcast(builder.build()) |
|
|
} |
|
|
}; |
|
|
|
|
|
let entry_chunk_groups = entries |
|
|
.into_iter() |
|
|
.map(|entry_module| { |
|
|
let build_output_root = build_output_root.clone(); |
|
|
|
|
|
async move { |
|
|
Ok( |
|
|
if let Some(ecmascript) = |
|
|
ResolvedVc::try_sidecast::<Box<dyn EvaluatableAsset>>(entry_module) |
|
|
{ |
|
|
match target { |
|
|
Target::Browser => { |
|
|
chunking_context |
|
|
.evaluated_chunk_group( |
|
|
AssetIdent::from_path( |
|
|
build_output_root |
|
|
.join( |
|
|
ecmascript |
|
|
.ident() |
|
|
.path() |
|
|
.await? |
|
|
.file_stem() |
|
|
.unwrap(), |
|
|
)? |
|
|
.with_extension("entry.js"), |
|
|
), |
|
|
ChunkGroup::Entry( |
|
|
[ResolvedVc::upcast(ecmascript)].into_iter().collect(), |
|
|
), |
|
|
module_graph, |
|
|
AvailabilityInfo::Root, |
|
|
) |
|
|
.await? |
|
|
.assets |
|
|
} |
|
|
Target::Node => ResolvedVc::cell(vec![ |
|
|
chunking_context |
|
|
.entry_chunk_group( |
|
|
build_output_root |
|
|
.join( |
|
|
ecmascript |
|
|
.ident() |
|
|
.path() |
|
|
.await? |
|
|
.file_stem() |
|
|
.unwrap(), |
|
|
)? |
|
|
.with_extension("entry.js"), |
|
|
EvaluatableAssets::one(*ResolvedVc::upcast(ecmascript)), |
|
|
module_graph, |
|
|
OutputAssets::empty(), |
|
|
AvailabilityInfo::Root, |
|
|
) |
|
|
.await? |
|
|
.asset, |
|
|
]), |
|
|
} |
|
|
} else { |
|
|
bail!( |
|
|
"Entry module is not chunkable, so it can't be used to bootstrap the \ |
|
|
application" |
|
|
) |
|
|
}, |
|
|
) |
|
|
} |
|
|
}) |
|
|
.try_join() |
|
|
.await?; |
|
|
|
|
|
let mut chunks: FxHashSet<ResolvedVc<Box<dyn OutputAsset>>> = FxHashSet::default(); |
|
|
for chunk_group in entry_chunk_groups { |
|
|
chunks.extend( |
|
|
&*async move { all_assets_from_entries(*chunk_group).await } |
|
|
.instrument(tracing::info_span!("list chunks")) |
|
|
.await?, |
|
|
); |
|
|
} |
|
|
|
|
|
chunks |
|
|
.iter() |
|
|
.map(|c| async move { c.content().write(c.path().owned().await?).await }) |
|
|
.try_join() |
|
|
.await?; |
|
|
|
|
|
Ok(Default::default()) |
|
|
} |
|
|
|
|
|
pub async fn build(args: &BuildArguments) -> Result<()> { |
|
|
let NormalizedDirs { |
|
|
project_dir, |
|
|
root_dir, |
|
|
} = normalize_dirs(&args.common.dir, &args.common.root)?; |
|
|
|
|
|
let tt = TurboTasks::new(TurboTasksBackend::new( |
|
|
BackendOptions { |
|
|
dependency_tracking: false, |
|
|
storage_mode: None, |
|
|
..Default::default() |
|
|
}, |
|
|
noop_backing_storage(), |
|
|
)); |
|
|
|
|
|
let mut builder = TurbopackBuildBuilder::new(tt.clone(), project_dir, root_dir) |
|
|
.log_detail(args.common.log_detail) |
|
|
.log_level( |
|
|
args.common |
|
|
.log_level |
|
|
.map_or_else(|| IssueSeverity::Warning, |l| l.0), |
|
|
) |
|
|
.source_maps_type(if args.no_sourcemap { |
|
|
SourceMapsType::None |
|
|
} else { |
|
|
SourceMapsType::Full |
|
|
}) |
|
|
.minify_type(if args.no_minify { |
|
|
MinifyType::NoMinify |
|
|
} else { |
|
|
MinifyType::Minify { |
|
|
mangle: Some(MangleType::OptimalSize), |
|
|
} |
|
|
}) |
|
|
.scope_hoist(!args.no_scope_hoist) |
|
|
.target(args.common.target.unwrap_or(Target::Node)) |
|
|
.show_all(args.common.show_all); |
|
|
|
|
|
for entry in normalize_entries(&args.common.entries) { |
|
|
builder = builder.entry_request(EntryRequest::Relative(entry)); |
|
|
} |
|
|
|
|
|
builder.build().await?; |
|
|
|
|
|
|
|
|
|
|
|
if !args.force_memory_cleanup { |
|
|
forget(tt); |
|
|
} |
|
|
|
|
|
Ok(()) |
|
|
} |
|
|
|
