|
|
use std::{cell::RefCell, path::PathBuf, rc::Rc, sync::Arc}; |
|
|
|
|
|
use either::Either; |
|
|
use modularize_imports; |
|
|
use preset_env_base::query::targets_to_versions; |
|
|
use rustc_hash::{FxHashMap, FxHashSet}; |
|
|
use serde::Deserialize; |
|
|
use swc_core::{ |
|
|
atoms::Atom, |
|
|
common::{ |
|
|
comments::{Comments, NoopComments}, |
|
|
pass::Optional, |
|
|
FileName, Mark, SourceFile, SourceMap, SyntaxContext, |
|
|
}, |
|
|
ecma::{ |
|
|
ast::{fn_pass, noop_pass, EsVersion, Pass}, |
|
|
parser::parse_file_as_module, |
|
|
visit::visit_mut_pass, |
|
|
}, |
|
|
}; |
|
|
|
|
|
use crate::{ |
|
|
linter::linter, |
|
|
transforms::{ |
|
|
cjs_finder::contains_cjs, |
|
|
dynamic::{next_dynamic, NextDynamicMode}, |
|
|
fonts::next_font_loaders, |
|
|
lint_codemod_comments::lint_codemod_comments, |
|
|
react_server_components, |
|
|
server_actions::ServerActionsMode, |
|
|
}, |
|
|
}; |
|
|
|
|
|
#[derive(Clone, Debug, Deserialize)] |
|
|
#[serde(rename_all = "camelCase")] |
|
|
pub struct TransformOptions { |
|
|
#[serde(flatten)] |
|
|
pub swc: swc_core::base::config::Options, |
|
|
|
|
|
#[serde(default)] |
|
|
pub disable_next_ssg: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub disable_page_config: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub pages_dir: Option<PathBuf>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub app_dir: Option<PathBuf>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub is_page_file: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub is_development: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub is_server_compiler: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub prefer_esm: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub server_components: Option<react_server_components::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub styled_jsx: BoolOr<styled_jsx::visitor::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub styled_components: Option<styled_components::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub remove_console: Option<remove_console::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub react_remove_properties: Option<react_remove_properties::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
#[cfg(not(target_arch = "wasm32"))] |
|
|
pub relay: Option<swc_relay::Config>, |
|
|
|
|
|
#[allow(unused)] |
|
|
#[serde(default)] |
|
|
#[cfg(target_arch = "wasm32")] |
|
|
|
|
|
pub relay: Option<serde_json::Value>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub shake_exports: Option<crate::transforms::shake_exports::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub emotion: Option<swc_emotion::EmotionOptions>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub modularize_imports: Option<modularize_imports::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub auto_modularize_imports: Option<crate::transforms::named_import_transform::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub optimize_barrel_exports: Option<crate::transforms::optimize_barrel::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub font_loaders: Option<crate::transforms::fonts::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub server_actions: Option<crate::transforms::server_actions::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub cjs_require_optimizer: Option<crate::transforms::cjs_optimizer::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub optimize_server_react: Option<crate::transforms::optimize_server_react::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub debug_function_name: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub lint_codemod_comments: bool, |
|
|
|
|
|
#[serde(default)] |
|
|
pub css_env: Option<swc_core::ecma::preset_env::Config>, |
|
|
|
|
|
#[serde(default)] |
|
|
pub track_dynamic_imports: bool, |
|
|
} |
|
|
|
|
|
pub fn custom_before_pass<'a, C>( |
|
|
cm: Arc<SourceMap>, |
|
|
file: Arc<SourceFile>, |
|
|
opts: &'a TransformOptions, |
|
|
comments: C, |
|
|
eliminated_packages: Rc<RefCell<FxHashSet<Atom>>>, |
|
|
unresolved_mark: Mark, |
|
|
use_cache_telemetry_tracker: Rc<RefCell<FxHashMap<String, usize>>>, |
|
|
) -> impl Pass + 'a |
|
|
where |
|
|
C: Clone + Comments + 'a, |
|
|
{ |
|
|
let file_path_str = file.name.to_string(); |
|
|
|
|
|
#[cfg(target_arch = "wasm32")] |
|
|
let relay_plugin = noop_pass(); |
|
|
|
|
|
#[cfg(not(target_arch = "wasm32"))] |
|
|
let relay_plugin = { |
|
|
if let Some(config) = &opts.relay { |
|
|
Either::Left(swc_relay::relay( |
|
|
Arc::new(config.clone()), |
|
|
(*file.name).clone(), |
|
|
std::env::current_dir().unwrap(), |
|
|
opts.pages_dir.clone(), |
|
|
None, |
|
|
)) |
|
|
} else { |
|
|
Either::Right(noop_pass()) |
|
|
} |
|
|
}; |
|
|
|
|
|
let styled_jsx = { |
|
|
let cm = cm.clone(); |
|
|
let file = file.clone(); |
|
|
|
|
|
fn_pass(move |program| { |
|
|
if let Some(config) = opts.styled_jsx.to_option() { |
|
|
let target_browsers = opts |
|
|
.css_env |
|
|
.as_ref() |
|
|
.map(|env| { |
|
|
targets_to_versions(env.targets.clone(), None) |
|
|
.expect("failed to parse env.targets") |
|
|
}) |
|
|
.unwrap_or_default(); |
|
|
|
|
|
program.mutate(styled_jsx::visitor::styled_jsx( |
|
|
cm.clone(), |
|
|
&file.name, |
|
|
&styled_jsx::visitor::Config { |
|
|
use_lightningcss: config.use_lightningcss, |
|
|
browsers: *target_browsers, |
|
|
}, |
|
|
&styled_jsx::visitor::NativeConfig { process_css: None }, |
|
|
)) |
|
|
} |
|
|
}) |
|
|
}; |
|
|
|
|
|
let styled_components = { |
|
|
let file = file.clone(); |
|
|
|
|
|
fn_pass(move |program| { |
|
|
if let Some(config) = &opts.styled_components { |
|
|
program.mutate(styled_components::styled_components( |
|
|
Some(&file_path_str), |
|
|
file.src_hash, |
|
|
config, |
|
|
NoopComments, |
|
|
)) |
|
|
} |
|
|
}) |
|
|
}; |
|
|
|
|
|
let emotion = { |
|
|
let cm = cm.clone(); |
|
|
let file = file.clone(); |
|
|
let comments = comments.clone(); |
|
|
|
|
|
fn_pass(move |program| { |
|
|
if let Some(config) = opts.emotion.as_ref() { |
|
|
if !config.enabled.unwrap_or(false) { |
|
|
return; |
|
|
} |
|
|
if let FileName::Real(path) = &*file.name { |
|
|
program.mutate(swc_emotion::emotion( |
|
|
config, |
|
|
path, |
|
|
file.src_hash as u32, |
|
|
cm.clone(), |
|
|
comments.clone(), |
|
|
)); |
|
|
} |
|
|
} |
|
|
}) |
|
|
}; |
|
|
|
|
|
let modularize_imports = fn_pass(move |program| { |
|
|
if let Some(config) = opts.modularize_imports.as_ref() { |
|
|
program.mutate(modularize_imports::modularize_imports(config)); |
|
|
} |
|
|
}); |
|
|
|
|
|
( |
|
|
( |
|
|
crate::transforms::disallow_re_export_all_in_page::disallow_re_export_all_in_page( |
|
|
opts.is_page_file, |
|
|
), |
|
|
match &opts.server_components { |
|
|
Some(config) if config.truthy() => { |
|
|
Either::Left(react_server_components::server_components( |
|
|
file.name.clone(), |
|
|
config.clone(), |
|
|
comments.clone(), |
|
|
opts.app_dir.clone(), |
|
|
)) |
|
|
} |
|
|
_ => Either::Right(noop_pass()), |
|
|
}, |
|
|
styled_jsx, |
|
|
styled_components, |
|
|
Optional::new( |
|
|
crate::transforms::next_ssg::next_ssg(eliminated_packages), |
|
|
!opts.disable_next_ssg, |
|
|
), |
|
|
crate::transforms::amp_attributes::amp_attributes(), |
|
|
next_dynamic( |
|
|
opts.is_development, |
|
|
opts.is_server_compiler, |
|
|
match &opts.server_components { |
|
|
Some(config) if config.truthy() => match config { |
|
|
|
|
|
|
|
|
react_server_components::Config::WithOptions(config) => { |
|
|
config.is_react_server_layer |
|
|
} |
|
|
_ => false, |
|
|
}, |
|
|
_ => false, |
|
|
}, |
|
|
opts.prefer_esm, |
|
|
NextDynamicMode::Webpack, |
|
|
file.name.clone(), |
|
|
opts.pages_dir.clone().or_else(|| opts.app_dir.clone()), |
|
|
), |
|
|
Optional::new( |
|
|
crate::transforms::page_config::page_config(opts.is_development, opts.is_page_file), |
|
|
!opts.disable_page_config, |
|
|
), |
|
|
relay_plugin, |
|
|
match &opts.remove_console { |
|
|
Some(config) if config.truthy() => Either::Left(remove_console::remove_console( |
|
|
config.clone(), |
|
|
SyntaxContext::empty().apply_mark(unresolved_mark), |
|
|
)), |
|
|
_ => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.react_remove_properties { |
|
|
Some(config) if config.truthy() => Either::Left( |
|
|
react_remove_properties::react_remove_properties(config.clone()), |
|
|
), |
|
|
_ => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.shake_exports { |
|
|
Some(config) => Either::Left(crate::transforms::shake_exports::shake_exports( |
|
|
config.clone(), |
|
|
)), |
|
|
None => Either::Right(noop_pass()), |
|
|
}, |
|
|
), |
|
|
( |
|
|
match &opts.auto_modularize_imports { |
|
|
Some(config) => Either::Left( |
|
|
crate::transforms::named_import_transform::named_import_transform( |
|
|
config.clone(), |
|
|
), |
|
|
), |
|
|
None => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.optimize_barrel_exports { |
|
|
Some(config) => Either::Left(crate::transforms::optimize_barrel::optimize_barrel( |
|
|
config.clone(), |
|
|
)), |
|
|
_ => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.optimize_server_react { |
|
|
Some(config) => Either::Left( |
|
|
crate::transforms::optimize_server_react::optimize_server_react(config.clone()), |
|
|
), |
|
|
_ => Either::Right(noop_pass()), |
|
|
}, |
|
|
emotion, |
|
|
modularize_imports, |
|
|
match &opts.font_loaders { |
|
|
Some(config) => Either::Left(next_font_loaders(config.clone())), |
|
|
None => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.server_actions { |
|
|
Some(config) => Either::Left(crate::transforms::server_actions::server_actions( |
|
|
&file.name, |
|
|
None, |
|
|
config.clone(), |
|
|
comments.clone(), |
|
|
cm.clone(), |
|
|
use_cache_telemetry_tracker, |
|
|
ServerActionsMode::Webpack, |
|
|
)), |
|
|
None => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.track_dynamic_imports { |
|
|
true => Either::Left( |
|
|
crate::transforms::track_dynamic_imports::track_dynamic_imports( |
|
|
unresolved_mark, |
|
|
), |
|
|
), |
|
|
false => Either::Right(noop_pass()), |
|
|
}, |
|
|
match &opts.cjs_require_optimizer { |
|
|
Some(config) => Either::Left(visit_mut_pass( |
|
|
crate::transforms::cjs_optimizer::cjs_optimizer( |
|
|
config.clone(), |
|
|
SyntaxContext::empty().apply_mark(unresolved_mark), |
|
|
), |
|
|
)), |
|
|
None => Either::Right(noop_pass()), |
|
|
}, |
|
|
Optional::new( |
|
|
crate::transforms::debug_fn_name::debug_fn_name(), |
|
|
opts.debug_function_name, |
|
|
), |
|
|
visit_mut_pass(crate::transforms::pure::pure_magic(comments.clone())), |
|
|
Optional::new( |
|
|
linter(lint_codemod_comments(comments)), |
|
|
opts.lint_codemod_comments, |
|
|
), |
|
|
), |
|
|
) |
|
|
} |
|
|
|
|
|
impl TransformOptions { |
|
|
pub fn patch(mut self, fm: &SourceFile) -> Self { |
|
|
self.swc.swcrc = false; |
|
|
|
|
|
let should_enable_commonjs = self.swc.config.module.is_none() |
|
|
&& (fm.src.contains("module.exports") |
|
|
|| fm.src.contains("exports.") |
|
|
|| fm.src.contains("__esModule")) |
|
|
&& { |
|
|
let syntax = self.swc.config.jsc.syntax.unwrap_or_default(); |
|
|
let target = self.swc.config.jsc.target.unwrap_or_else(EsVersion::latest); |
|
|
|
|
|
parse_file_as_module(fm, syntax, target, None, &mut vec![]) |
|
|
.map(|m| contains_cjs(&m)) |
|
|
.unwrap_or_default() |
|
|
}; |
|
|
|
|
|
if should_enable_commonjs { |
|
|
self.swc.config.module = Some( |
|
|
serde_json::from_str(r#"{ "type": "commonjs", "ignoreDynamic": true }"#).unwrap(), |
|
|
); |
|
|
} |
|
|
|
|
|
self |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
|
|
pub enum BoolOr<T> { |
|
|
Bool(bool), |
|
|
Data(T), |
|
|
} |
|
|
|
|
|
impl<T> Default for BoolOr<T> { |
|
|
fn default() -> Self { |
|
|
BoolOr::Bool(false) |
|
|
} |
|
|
} |
|
|
|
|
|
impl<T> BoolOr<T> { |
|
|
pub fn to_option(&self) -> Option<T> |
|
|
where |
|
|
T: Default + Clone, |
|
|
{ |
|
|
match self { |
|
|
BoolOr::Bool(false) => None, |
|
|
BoolOr::Bool(true) => Some(Default::default()), |
|
|
BoolOr::Data(v) => Some(v.clone()), |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
impl<'de, T> Deserialize<'de> for BoolOr<T> |
|
|
where |
|
|
T: Deserialize<'de>, |
|
|
{ |
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> |
|
|
where |
|
|
D: serde::Deserializer<'de>, |
|
|
{ |
|
|
#[derive(Deserialize)] |
|
|
#[serde(untagged)] |
|
|
enum Deser<T> { |
|
|
Bool(bool), |
|
|
Obj(T), |
|
|
EmptyObject(EmptyStruct), |
|
|
} |
|
|
|
|
|
#[derive(Deserialize)] |
|
|
#[serde(deny_unknown_fields)] |
|
|
struct EmptyStruct {} |
|
|
|
|
|
use serde::__private::de; |
|
|
|
|
|
let content = de::Content::deserialize(deserializer)?; |
|
|
|
|
|
let deserializer = de::ContentRefDeserializer::<D::Error>::new(&content); |
|
|
|
|
|
let res = Deser::deserialize(deserializer); |
|
|
|
|
|
match res { |
|
|
Ok(v) => Ok(match v { |
|
|
Deser::Bool(v) => BoolOr::Bool(v), |
|
|
Deser::Obj(v) => BoolOr::Data(v), |
|
|
Deser::EmptyObject(_) => BoolOr::Bool(true), |
|
|
}), |
|
|
Err(..) => { |
|
|
let d = de::ContentDeserializer::<D::Error>::new(content); |
|
|
Ok(BoolOr::Data(T::deserialize(d)?)) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
