| use std::borrow::Cow; |
|
|
| use anyhow::Result; |
| use swc_core::{ |
| common::GLOBALS, |
| ecma::{ |
| ast::{ |
| ArrowExpr, AssignOp, AssignTarget, BinExpr, BinaryOp, CallExpr, Callee, Expr, |
| ExprOrSpread, ExprStmt, FnExpr, Lit, Module, ModuleItem, Program, Script, |
| SimpleAssignTarget, Stmt, |
| }, |
| visit::{Visit, VisitWith}, |
| }, |
| }; |
| use turbo_tasks::Vc; |
| use turbo_tasks_fs::FileSystemPath; |
| use turbopack_core::source::Source; |
|
|
| use crate::{ |
| EcmascriptInputTransforms, EcmascriptModuleAssetType, |
| analyzer::{JsValue, graph::EvalContext}, |
| parse::{ParseResult, parse}, |
| utils::unparen, |
| }; |
|
|
| #[turbo_tasks::value(shared, serialization = "none")] |
| #[derive(Debug)] |
| pub enum WebpackRuntime { |
| Webpack5 { |
| |
| |
| #[turbo_tasks(trace_ignore)] |
| chunk_request_expr: JsValue, |
| context_path: FileSystemPath, |
| }, |
| None, |
| } |
|
|
| fn iife(stmt: &Stmt) -> Option<&Vec<Stmt>> { |
| if let Stmt::Expr(ExprStmt { expr, .. }) = &stmt |
| && let Expr::Call(CallExpr { |
| callee: Callee::Expr(callee), |
| args, |
| .. |
| }) = unparen(expr) |
| { |
| if !args.is_empty() { |
| return None; |
| } |
| return get_fn_body(callee); |
| } |
| None |
| } |
|
|
| fn program_iife(program: &Program) -> Option<&Vec<Stmt>> { |
| match program { |
| Program::Module(Module { body, .. }) => { |
| if let [ModuleItem::Stmt(stmt)] = &body[..] { |
| return iife(stmt); |
| } |
| } |
| Program::Script(Script { body, .. }) => { |
| if let [stmt] = &body[..] { |
| return iife(stmt); |
| } |
| } |
| } |
| None |
| } |
|
|
| fn is_webpack_require_decl(stmt: &Stmt) -> bool { |
| if let Some(decl) = stmt.as_decl() |
| && let Some(fn_decl) = decl.as_fn_decl() |
| { |
| return &*fn_decl.ident.sym == "__webpack_require__"; |
| } |
| false |
| } |
|
|
| fn get_assign_target_identifier(expr: &AssignTarget) -> Option<Cow<'_, str>> { |
| match expr.as_simple()? { |
| SimpleAssignTarget::Ident(ident) => Some(Cow::Borrowed(&*ident.sym)), |
| SimpleAssignTarget::Member(member) => { |
| if let Some(obj_name) = get_expr_identifier(&member.obj) |
| && let Some(ident) = member.prop.as_ident() |
| { |
| return Some(Cow::Owned(obj_name.into_owned() + "." + &*ident.sym)); |
| } |
| None |
| } |
| SimpleAssignTarget::Paren(p) => get_expr_identifier(&p.expr), |
|
|
| _ => None, |
| } |
| } |
|
|
| fn get_expr_identifier(expr: &Expr) -> Option<Cow<'_, str>> { |
| let expr = unparen(expr); |
| if let Some(ident) = expr.as_ident() { |
| return Some(Cow::Borrowed(&*ident.sym)); |
| } |
| if let Some(member) = expr.as_member() |
| && let Some(ident) = member.prop.as_ident() |
| && let Some(obj_name) = get_expr_identifier(&member.obj) |
| { |
| return Some(Cow::Owned(obj_name.into_owned() + "." + &*ident.sym)); |
| } |
| None |
| } |
|
|
| fn get_assignment<'a>(stmts: &'a Vec<Stmt>, property: &str) -> Option<&'a Expr> { |
| for stmt in stmts { |
| if let Some(stmts) = iife(stmt) |
| && let Some(result) = get_assignment(stmts, property) |
| { |
| return Some(result); |
| } |
| if let Some(expr_stmt) = stmt.as_expr() |
| && let Some(assign) = unparen(&expr_stmt.expr).as_assign() |
| && assign.op == AssignOp::Assign |
| && let Some(name) = get_assign_target_identifier(&assign.left) |
| && name == property |
| { |
| return Some(unparen(&assign.right)); |
| } |
| } |
| None |
| } |
|
|
| fn get_fn_body(expr: &Expr) -> Option<&Vec<Stmt>> { |
| let expr = unparen(expr); |
| if let Some(FnExpr { function, .. }) = expr.as_fn_expr() |
| && let Some(body) = &function.body |
| { |
| return Some(&body.stmts); |
| } |
| if let Some(ArrowExpr { body, .. }) = expr.as_arrow() |
| && let Some(block) = body.as_block_stmt() |
| { |
| return Some(&block.stmts); |
| } |
| None |
| } |
|
|
| fn get_javascript_chunk_filename(stmts: &Vec<Stmt>, eval_context: &EvalContext) -> Option<JsValue> { |
| if let Some(expr) = get_assignment(stmts, "__webpack_require__.u") |
| && let Some(stmts) = get_fn_body(expr) |
| && let Some(ret) = stmts.iter().find_map(|stmt| stmt.as_return_stmt()) |
| && let Some(expr) = &ret.arg |
| { |
| return Some(eval_context.eval(expr)); |
| } |
| None |
| } |
|
|
| struct RequirePrefixVisitor { |
| result: Option<Lit>, |
| } |
|
|
| impl Visit for RequirePrefixVisitor { |
| fn visit_call_expr(&mut self, call: &CallExpr) { |
| if let Some(expr) = call.callee.as_expr() |
| && let Some(name) = get_expr_identifier(expr) |
| && name == "require" |
| && let [ExprOrSpread { spread: None, expr }] = &call.args[..] |
| && let Some(BinExpr { |
| op: BinaryOp::Add, |
| left, |
| .. |
| }) = expr.as_bin() |
| { |
| self.result = left.as_lit().cloned(); |
| return; |
| } |
| call.visit_children_with(self); |
| } |
| } |
|
|
| fn get_require_prefix(stmts: &Vec<Stmt>) -> Option<Lit> { |
| if let Some(expr) = get_assignment(stmts, "__webpack_require__.f.require") { |
| let mut visitor = RequirePrefixVisitor { result: None }; |
| expr.visit_children_with(&mut visitor); |
| return visitor.result; |
| } |
| None |
| } |
|
|
| #[turbo_tasks::function] |
| pub async fn webpack_runtime( |
| source: Vc<Box<dyn Source>>, |
| transforms: Vc<EcmascriptInputTransforms>, |
| ) -> Result<Vc<WebpackRuntime>> { |
| let parsed = parse(source, EcmascriptModuleAssetType::Ecmascript, transforms).await?; |
| match &*parsed { |
| ParseResult::Ok { |
| program, |
| eval_context, |
| globals, |
| .. |
| } => { |
| if let Some(stmts) = program_iife(program) |
| && stmts.iter().any(is_webpack_require_decl) |
| { |
| |
| let chunk_filename = GLOBALS.set(globals, || { |
| get_javascript_chunk_filename(stmts, eval_context) |
| }); |
|
|
| let prefix_path = get_require_prefix(stmts); |
|
|
| if let (Some(chunk_filename), Some(prefix_path)) = (chunk_filename, prefix_path) { |
| let value = JsValue::concat(vec![ |
| JsValue::Constant(prefix_path.into()), |
| chunk_filename, |
| ]); |
|
|
| return Ok(WebpackRuntime::Webpack5 { |
| chunk_request_expr: value, |
| context_path: source.ident().path().await?.parent(), |
| } |
| .into()); |
| } |
| } |
| } |
| ParseResult::Unparsable { .. } | ParseResult::NotFound => {} |
| } |
| Ok(WebpackRuntime::None.into()) |
| } |
|
|
