crates/core/src/unpacker/amd.rs
GitHubuse std::collections::HashMap;
use swc_core::atoms::Atom;
use swc_core::common::{sync::Lrc, SourceMap, Span, Spanned, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::*;
use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
use crate::module_path::relative_import_specifier;
use crate::unpacker::wrappers::body_looks_like_umd_wrapper;
use crate::unpacker::{
sanitize_relative_path, span_byte_range, BundleFormat, UnpackResult, UnpackedModule,
};
use crate::utils::paren::strip_parens;
use crate::utils::swc_safety::apply_fixer;
struct AmdDefine<'a> {
id: String,
deps: Vec<String>,
factory: &'a Expr,
is_anonymous: bool,
span: Span,
}
pub(super) fn detect_from_module(module: &Module, cm: Lrc<SourceMap>) -> Option<UnpackResult> {
let mut defines = Vec::new();
let mut only_defines = true;
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) => {
if is_directive_expr(expr) {
continue;
}
if let Some(define) = parse_define_call(expr) {
defines.push(define);
} else {
only_defines = false;
}
}
ModuleItem::Stmt(Stmt::Empty(_)) => {}
_ => only_defines = false,
}
}
if !defines.is_empty() && only_defines {
return emit_define_modules(defines, cm);
}
emit_plain_umd_module(module, cm)
}
fn parse_define_call(expr: &Expr) -> Option<AmdDefine<'_>> {
let Expr::Call(call) = strip_parens(expr) else {
return None;
};
let Callee::Expr(callee_expr) = &call.callee else {
return None;
};
let Expr::Ident(callee_ident) = strip_parens(callee_expr) else {
return None;
};
if callee_ident.sym.as_ref() != "define" {
return None;
}
let mut index = 0;
let mut is_anonymous = true;
let arg = call.args.get(index)?;
let id = if let Some(id) = string_lit_value(&arg.expr) {
index += 1;
is_anonymous = false;
id
} else {
"module".to_string()
};
let deps = if let Some(arg) = call.args.get(index) {
if let Expr::Array(array) = strip_parens(&arg.expr) {
index += 1;
array
.elems
.iter()
.map(|elem| {
let elem = elem.as_ref()?;
if elem.spread.is_some() {
return None;
}
string_lit_value(&elem.expr)
})
.collect::<Option<Vec<_>>>()?
} else {
Vec::new()
}
} else {
Vec::new()
};
let factory = call.args.get(index)?.expr.as_ref();
Some(AmdDefine {
id,
deps,
factory,
is_anonymous,
span: call.span,
})
}
fn string_lit_value(expr: &Expr) -> Option<String> {
match strip_parens(expr) {
Expr::Lit(Lit::Str(s)) => Some(s.value.as_str().unwrap_or("").to_string()),
_ => None,
}
}
fn emit_define_modules(defines: Vec<AmdDefine<'_>>, cm: Lrc<SourceMap>) -> Option<UnpackResult> {
let named_count = defines.iter().filter(|define| !define.is_anonymous).count();
let allow_anonymous = defines.len() == 1 && named_count == 0;
if named_count == 0 && !allow_anonymous {
return None;
}
let id_to_filename: HashMap<String, String> = defines
.iter()
.filter(|define| !define.is_anonymous)
.map(|define| (define.id.clone(), amd_id_to_filename(&define.id)))
.collect();
let last_index = defines.len().saturating_sub(1);
let mut modules = Vec::new();
for (index, define) in defines.iter().enumerate() {
if define.is_anonymous && !allow_anonymous {
return None;
}
let filename = if define.is_anonymous {
"module.js".to_string()
} else {
amd_id_to_filename(&define.id)
};
let module = factory_to_module(
define.factory,
&define.deps,
&filename,
&define.id,
&id_to_filename,
)?;
modules.push(UnpackedModule {
id: define.id.clone(),
is_entry: index == last_index,
code: emit_module(module, cm.clone()).ok()?,
filename,
source_ranges: span_byte_range(&cm, define.span).into_iter().collect(),
source_input: String::new(),
generated_source_map: Vec::new(),
});
}
Some(UnpackResult::new(modules, BundleFormat::Amd))
}
fn emit_plain_umd_module(module: &Module, cm: Lrc<SourceMap>) -> Option<UnpackResult> {
let mut factory = None;
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) => {
if is_directive_expr(expr) {
continue;
}
if factory.is_some() {
return None;
}
factory = Some((umd_factory_arg(expr)?, expr.span()));
}
ModuleItem::Stmt(Stmt::Empty(_)) => {}
_ => return None,
}
}
let (factory, wrapper_span) = factory?;
let synthetic = factory_to_module(factory, &[], "module.js", "module", &HashMap::new())?;
Some(UnpackResult::new(
vec![UnpackedModule {
id: "module".to_string(),
is_entry: true,
code: emit_module(synthetic, cm.clone()).ok()?,
filename: "module.js".to_string(),
source_ranges: span_byte_range(&cm, wrapper_span).into_iter().collect(),
source_input: String::new(),
generated_source_map: Vec::new(),
}],
BundleFormat::Amd,
))
}
fn is_directive_expr(expr: &Expr) -> bool {
matches!(strip_parens(expr), Expr::Lit(Lit::Str(_)))
}
fn umd_factory_arg(expr: &Expr) -> Option<&Expr> {
let call = top_level_call(expr)?;
let (wrapper_params, wrapper_body) = wrapper_callee_parts(&call.callee)?;
let factory_sym = wrapper_params.get(1)?;
if !body_looks_like_umd_wrapper(wrapper_body, factory_sym) {
return None;
}
let factory_arg = call.args.get(1)?;
if factory_arg.spread.is_some() {
return None;
}
Some(strip_parens(&factory_arg.expr))
}
fn top_level_call(expr: &Expr) -> Option<&CallExpr> {
match strip_parens(expr) {
Expr::Call(call) => Some(call),
Expr::Unary(unary) if matches!(unary.op, UnaryOp::Bang) => match strip_parens(&unary.arg) {
Expr::Call(call) => Some(call),
_ => None,
},
_ => None,
}
}
fn wrapper_callee_parts(callee: &Callee) -> Option<(Vec<Atom>, &BlockStmt)> {
let Callee::Expr(callee_expr) = callee else {
return None;
};
match strip_parens(callee_expr) {
Expr::Fn(FnExpr { function, .. }) => {
Some((function_params(&function.params), function.body.as_ref()?))
}
Expr::Arrow(arrow) => {
let BlockStmtOrExpr::BlockStmt(body) = &*arrow.body else {
return None;
};
Some((pat_params(&arrow.params), body))
}
_ => None,
}
}
fn factory_to_module(
factory: &Expr,
deps: &[String],
filename: &str,
module_id: &str,
id_to_filename: &HashMap<String, String>,
) -> Option<Module> {
match strip_parens(factory) {
Expr::Fn(FnExpr { function, .. }) => {
let params = function_params(&function.params);
let body = function.body.as_ref()?;
Some(module_from_factory_parts(
body.stmts.clone(),
None,
deps,
¶ms,
filename,
module_id,
id_to_filename,
))
}
Expr::Arrow(arrow) => {
let params = pat_params(&arrow.params);
match &*arrow.body {
BlockStmtOrExpr::BlockStmt(body) => Some(module_from_factory_parts(
body.stmts.clone(),
None,
deps,
¶ms,
filename,
module_id,
id_to_filename,
)),
BlockStmtOrExpr::Expr(expr) => Some(module_from_factory_parts(
Vec::new(),
Some(strip_parens(expr).clone()),
deps,
¶ms,
filename,
module_id,
id_to_filename,
)),
}
}
expr => Some(module_from_factory_parts(
Vec::new(),
Some(expr.clone()),
deps,
&[],
filename,
module_id,
id_to_filename,
)),
}
}
fn function_params(params: &[Param]) -> Vec<Atom> {
params
.iter()
.filter_map(|param| pat_name(¶m.pat))
.collect()
}
fn pat_params(params: &[Pat]) -> Vec<Atom> {
params.iter().filter_map(pat_name).collect()
}
fn pat_name(pat: &Pat) -> Option<Atom> {
match pat {
Pat::Ident(binding) => Some(binding.sym.clone()),
_ => None,
}
}
fn module_from_factory_parts(
body_stmts: Vec<Stmt>,
returned_expr: Option<Expr>,
deps: &[String],
params: &[Atom],
filename: &str,
module_id: &str,
id_to_filename: &HashMap<String, String>,
) -> Module {
let mut stmts = dependency_stmts(deps, params, filename, module_id, id_to_filename);
stmts.extend(rewrite_terminal_return(body_stmts));
if let Some(expr) = returned_expr {
stmts.push(module_exports_stmt(Box::new(expr)));
}
Module {
span: DUMMY_SP,
body: stmts.into_iter().map(ModuleItem::Stmt).collect(),
shebang: None,
}
}
fn rewrite_terminal_return(mut stmts: Vec<Stmt>) -> Vec<Stmt> {
let Some(last) = stmts.last_mut() else {
return stmts;
};
let Stmt::Return(return_stmt) = last else {
return stmts;
};
let Some(arg) = return_stmt.arg.take() else {
return stmts;
};
*last = module_exports_stmt(arg);
stmts
}
fn dependency_stmts(
deps: &[String],
params: &[Atom],
filename: &str,
module_id: &str,
id_to_filename: &HashMap<String, String>,
) -> Vec<Stmt> {
let mut stmts = Vec::new();
for (index, dep) in deps.iter().enumerate() {
let param = params.get(index);
match dep.as_str() {
"require" | "exports" | "module" => {
if let Some(param) = param {
if param.as_ref() != dep {
stmts.push(const_alias_stmt(param.clone(), ident_expr(dep)));
}
}
}
_ => {
let specifier = dependency_specifier(dep, filename, module_id, id_to_filename);
let require_call = require_call_expr(specifier);
if let Some(param) = param {
stmts.push(const_alias_stmt(param.clone(), require_call));
} else {
stmts.push(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(require_call),
}));
}
}
}
}
stmts
}
fn const_alias_stmt(name: Atom, value: Expr) -> Stmt {
Stmt::Decl(Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: SyntaxContext::empty(),
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(BindingIdent::from(Ident::new(
name,
DUMMY_SP,
SyntaxContext::empty(),
))),
init: Some(Box::new(value)),
definite: false,
}],
})))
}
fn ident_expr(name: &str) -> Expr {
Expr::Ident(Ident::new(name.into(), DUMMY_SP, SyntaxContext::empty()))
}
fn require_call_expr(specifier: String) -> Expr {
Expr::Call(CallExpr {
span: DUMMY_SP,
ctxt: SyntaxContext::empty(),
callee: Callee::Expr(Box::new(ident_expr("require"))),
type_args: None,
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(Expr::Lit(Lit::Str(Str {
span: DUMMY_SP,
value: specifier.into(),
raw: None,
}))),
}],
})
}
fn module_exports_stmt(value: Box<Expr>) -> Stmt {
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Assign(AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(ident_expr("module")),
prop: MemberProp::Ident(IdentName::new("exports".into(), DUMMY_SP)),
})),
right: value,
})),
})
}
fn amd_id_to_filename(id: &str) -> String {
let mut filename = sanitize_relative_path(id, "module");
if !filename.ends_with(".js") {
filename.push_str(".js");
}
filename
}
fn dependency_specifier(
dep: &str,
filename: &str,
module_id: &str,
id_to_filename: &HashMap<String, String>,
) -> String {
// Bare AMD IDs are package/external specifiers unless another named define
// in this bundle proves that the dependency is internal. Turning an
// unknown bare ID into `./<id>.js` changes package resolution semantics.
if !dep.starts_with('.') && !id_to_filename.contains_key(dep) {
return dep.to_string();
}
let target = id_to_filename
.get(dep)
.cloned()
.unwrap_or_else(|| amd_id_to_filename(&resolve_amd_id(module_id, dep)));
relative_import_specifier(filename, &target)
}
fn resolve_amd_id(from_id: &str, dep: &str) -> String {
if !dep.starts_with('.') {
return dep.to_string();
}
let mut parts: Vec<&str> = from_id.split('/').collect();
parts.pop();
for part in dep.split('/') {
match part {
"" | "." => {}
".." => {
parts.pop();
}
_ => parts.push(part),
}
}
parts.join("/")
}
fn emit_module(mut module: Module, cm: Lrc<SourceMap>) -> anyhow::Result<String> {
apply_fixer(&mut module)?;
let mut output = Vec::new();
{
let mut emitter = Emitter {
cfg: Config::default(),
comments: None,
cm: cm.clone(),
wr: JsWriter::new(cm, "\n", &mut output, None),
};
emitter.emit_module(&module)?;
}
Ok(String::from_utf8(output)?)
}