rspack_plugin_javascript 0.101.0

rspack javascript plugin
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use swc_atoms::Atom;
use swc_experimental_ecma_ast::{CallExpr, Callee, MemberProp};

use super::BasicEvaluatedExpression;
use crate::{
  parser_plugin::{
    CREATE_REQUIRE_EVALUATED_TAG, JavascriptParserPlugin, is_create_require_namespace_member,
    is_create_require_specifier,
  },
  visitors::{CallHooksName, JavascriptParser},
};

#[inline]
pub fn eval_call_expression<'parser: 'a, 'a>(
  parser: &mut JavascriptParser<'parser>,
  expr: &'a CallExpr<'a>,
) -> Option<BasicEvaluatedExpression<'a>> {
  let drive = parser.plugin_drive.clone();
  match &expr.callee {
    Callee::Expr(callee_expr) => {
      if let Some(ident) = callee_expr.as_ident() {
        let is_create_require = parser.javascript_options.is_create_require_enabled()
          && is_create_require_specifier(parser, &Atom::from(ident.sym.as_str()));
        let evaluated = if is_create_require {
          Atom::from(ident.sym.as_str()).call_hooks_name(parser, |parser, for_name| {
            drive.evaluate_call_expression(parser, for_name, expr)
          })
        } else if parser.javascript_options.is_create_require_enabled() {
          let evaluated = parser.evaluate_expression(callee_expr);
          if evaluated.is_identifier() && evaluated.identifier() == CREATE_REQUIRE_EVALUATED_TAG {
            drive.evaluate_call_expression(parser, CREATE_REQUIRE_EVALUATED_TAG, expr)
          } else {
            drive.evaluate_call_expression(parser, ident.sym.as_str(), expr)
          }
        } else {
          drive.evaluate_call_expression(parser, ident.sym.as_str(), expr)
        };
        if evaluated.is_some() {
          return evaluated;
        }
      }
      if let Some(member) = callee_expr.as_member()
        && let MemberProp::Ident(ident) = &member.prop
      {
        let param = parser.evaluate_expression(&member.obj);
        return drive.evaluate_call_expression_member(parser, ident.sym.as_str(), expr, param);
      }
      if parser.javascript_options.is_create_require_enabled()
        && is_create_require_namespace_member(parser, callee_expr)
      {
        return drive.evaluate_call_expression(parser, "", expr);
      }
      None
    }
    _ => None,
  }
}