rspack_plugin_javascript 0.100.1

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use rspack_util::SpanExt;
use swc_core::{
  common::Spanned,
  ecma::ast::{TaggedTpl, Tpl},
};

use super::BasicEvaluatedExpression;
use crate::visitors::JavascriptParser;

#[derive(Debug, Clone, Copy)]
pub enum TemplateStringKind {
  Cooked,
  // String.raw`./${a}.js`
  Raw,
}

#[inline]
fn get_simplified_template_result<'a>(
  scanner: &mut JavascriptParser,
  kind: TemplateStringKind,
  node: &'a Tpl,
) -> (
  Vec<BasicEvaluatedExpression<'a>>,
  Vec<BasicEvaluatedExpression<'a>>,
) {
  let mut quasis: Vec<BasicEvaluatedExpression<'a>> = vec![];
  let mut parts: Vec<BasicEvaluatedExpression<'a>> = vec![];
  for i in 0..node.quasis.len() {
    let quasi_expr = &node.quasis[i];
    let quasi = match kind {
      TemplateStringKind::Cooked => {
        // When template literals contain invalid escape sequences,
        // the cooked value can be None. Fall back to raw in this case.
        quasi_expr
          .cooked
          .as_ref()
          .and_then(|q| q.as_atom())
          .unwrap_or(&quasi_expr.raw)
      }
      TemplateStringKind::Raw => &quasi_expr.raw,
    };
    if i > 0 {
      let prev_expr = parts.last_mut().expect("should not empty");
      let expr = scanner.evaluate_expression(&node.exprs[i - 1]);
      if !expr.could_have_side_effects()
        && let Some(str) = expr.as_string()
      {
        // We can merge quasi + expr + quasi when expr
        // is a const string
        prev_expr.set_string(format!("{}{}{}", prev_expr.string(), str, quasi));
        prev_expr.set_range(prev_expr.range().0, quasi_expr.span().real_hi());
        // We unset the expression as it doesn't match to a single expression
        prev_expr.set_expression(None);

        // also merge for quasis
        let prev_expr = quasis.last_mut().expect("should not empty");
        prev_expr.set_string(format!("{}{}{}", prev_expr.string(), str, quasi));
        prev_expr.set_range(prev_expr.range().0, quasi_expr.span().real_hi());
        prev_expr.set_expression(None);
        continue;
      }
      parts.push(expr);
    }

    let part = || {
      let mut part = BasicEvaluatedExpression::new();
      part.set_string(quasi.to_string());
      part.set_range(quasi_expr.span().real_lo(), quasi_expr.span().real_hi());
      part
    };
    // part.set_expression(Some(quasi_expr));
    quasis.push(part());
    parts.push(part())
  }

  (quasis, parts)
}

#[inline]
pub fn eval_tpl_expression<'a>(
  scanner: &mut JavascriptParser,
  tpl: &'a Tpl,
) -> Option<BasicEvaluatedExpression<'a>> {
  let kind = TemplateStringKind::Cooked;
  let (quasis, mut parts) = get_simplified_template_result(scanner, kind, tpl);
  if parts.len() == 1 {
    let mut part = parts.remove(0);
    part.set_range(tpl.span().real_lo(), tpl.span().real_hi());
    Some(part)
  } else {
    let mut res = BasicEvaluatedExpression::with_range(tpl.span().real_lo(), tpl.span().real_hi());
    res.set_template_string(quasis, parts, kind);
    Some(res)
  }
}

#[inline]
pub fn eval_tagged_tpl_expression<'a>(
  scanner: &mut JavascriptParser,
  tagged_tpl: &'a TaggedTpl,
) -> Option<BasicEvaluatedExpression<'a>> {
  let tag = scanner.evaluate_expression(&tagged_tpl.tag);
  if !tag.is_identifier() || tag.identifier() != "String.raw" {
    return None;
  };
  let kind = TemplateStringKind::Raw;
  let tpl = &tagged_tpl.tpl;
  let (quasis, parts) = get_simplified_template_result(scanner, kind, tpl);
  let mut res =
    BasicEvaluatedExpression::with_range(tagged_tpl.span().real_lo(), tagged_tpl.span().real_hi());
  res.set_template_string(quasis, parts, kind);
  Some(res)
}