rolldown 1.0.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
84

use oxc::{
  ast::ast::{self},
  span::SPAN,
};
use rolldown_ecmascript_utils::ExpressionExt;

use crate::hmr::utils::HmrAstBuilder;

use super::ScopeHoistingFinalizer;

impl<'ast> ScopeHoistingFinalizer<'_, 'ast> {
  pub fn generate_hmr_header(&self) -> Vec<ast::Statement<'ast>> {
    let mut ret = vec![];
    if !self.ctx.options.is_dev_mode_enabled() {
      return ret;
    }

    // `var $hot = __rolldown_runtime__.createModuleHotContext(moduleId);`
    ret.push(self.create_module_hot_context_initializer_stmt());

    ret.push(self.create_register_module_stmt());

    ret
  }

  pub fn rewrite_import_meta_hot(&self, expr: &mut ast::Expression<'ast>) {
    if expr.is_import_meta_hot() {
      if let Some(hmr_hot_ref) = self.ctx.module.ecma_view.hmr_hot_ref {
        let hot_name = self.canonical_name_for(hmr_hot_ref);
        *expr = self.snippet.id_ref_expr(hot_name, SPAN);
      }
    }
  }

  pub fn rewrite_hot_accept_call_deps(&self, call_expr: &mut ast::CallExpression<'ast>) {
    if !self.ctx.options.is_dev_mode_enabled() {
      return;
    }

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

    if call_expr.arguments.is_empty() {
      // `import.meta.hot.accept()`
      return;
    }

    match &mut call_expr.arguments[0] {
      ast::Argument::StringLiteral(string_literal) => {
        // `import.meta.hot.accept('./dep.js', ...)`
        let import_record = &self.ctx.module.import_records[self
          .ctx
          .module
          .hmr_info
          .module_request_to_import_record_idx[string_literal.value.as_str()]];
        // Use stable module ID for consistent runtime lookup
        string_literal.value = self
          .snippet
          .builder
          .str(self.ctx.modules[import_record.into_resolved_module()].stable_id());
      }
      ast::Argument::ArrayExpression(array_expression) => {
        // `import.meta.hot.accept(['./dep1.js', './dep2.js'], ...)`
        array_expression.elements.iter_mut().for_each(|element| {
          if let ast::ArrayExpressionElement::StringLiteral(string_literal) = element {
            let import_record = &self.ctx.module.import_records[self
              .ctx
              .module
              .hmr_info
              .module_request_to_import_record_idx[string_literal.value.as_str()]];
            // Use stable module ID for consistent runtime lookup
            string_literal.value = self
              .snippet
              .builder
              .str(self.ctx.modules[import_record.into_resolved_module()].stable_id());
          }
        });
      }
      _ => {}
    }
  }
}