rolldown 0.1.0

Fast JavaScript bundler in Rust, designed for the future of Vite
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

use super::AstScanner;
use oxc::ast::ast;
use rolldown_common::{EcmaModuleAstUsage, ImportKind, ImportRecordMeta};
use rolldown_ecmascript_utils::ExpressionExt;
use rustc_hash::FxHashMap;

impl<'me, 'ast: 'me> AstScanner<'me, 'ast> {
  pub(crate) fn try_extract_hmr_info_from_hot_accept_call(
    &mut self,
    call_expr: &ast::CallExpression<'ast>,
  ) {
    if !self.immutable_ctx.options.is_hmr_enabled() {
      return;
    }
    // Possible call patterns for `import.meta.hot.accept`:
    // - `import.meta.hot.accept()`
    // - `import.meta.hot.accept((newModule) => {})`
    // - `import.meta.hot.accept('./dep.js', ...)`
    // - `import.meta.hot.accept(['./dep1.js', './dep2.js'], ...)`

    // Check whether the callee is `import.meta.hot.accept`.
    if !call_expr.callee.is_import_meta_hot_accept() {
      return;
    }

    let mut module_request_to_import_record_idx = FxHashMap::default();

    match call_expr.arguments.as_slice() {
      // `import.meta.hot.accept()`
      // `import.meta.hot.accept(<any expression>)`
      [] | [_] => {
        self.result.ast_usage.insert(EcmaModuleAstUsage::HmrSelfAccept);
      }
      // `import.meta.hot.accept('./dep.js', <any expression>)`
      [ast::Argument::StringLiteral(string_literal), _] => {
        module_request_to_import_record_idx.insert(
          string_literal.value.as_str().into(),
          self.add_import_record(
            &string_literal.value,
            ImportKind::HotAccept,
            call_expr.span,
            ImportRecordMeta::empty(),
          ),
        );
      }
      // `import.meta.hot.accept(['./dep1.js', './dep2.js'], <any expression>)`
      [ast::Argument::ArrayExpression(array_expression), _] => {
        module_request_to_import_record_idx.extend(
          array_expression
            .elements
            .iter()
            .filter_map(|element| {
              if let ast::ArrayExpressionElement::StringLiteral(string_literal) = element {
                Some(string_literal.value)
              } else {
                None
              }
            })
            .map(|lit| {
              (
                lit.as_str().into(),
                self.add_import_record(
                  &lit,
                  ImportKind::HotAccept,
                  call_expr.span,
                  ImportRecordMeta::empty(),
                ),
              )
            }),
        );
      }
      _ => {
        // TODO(hyf0): Unsupported call pattern, maybe we should raise a warning here?
      }
    }

    self
      .result
      .hmr_info
      .module_request_to_import_record_idx
      .extend(module_request_to_import_record_idx);
  }
}