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
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

use itertools::Itertools;
use rolldown_common::ExternalModule;
use rolldown_sourcemap::SourceJoiner;

use crate::{
  ecmascript::ecma_generator::{RenderedModuleSource, RenderedModuleSources},
  types::generator::GenerateContext,
};

pub mod namespace;

pub fn render_factory_parameters(
  ctx: &GenerateContext<'_>,
  externals: &[&ExternalModule],
  has_exports: bool,
) -> String {
  let mut parameters = if has_exports { vec!["exports"] } else { vec![] };
  externals.iter().for_each(|external| {
    let symbol_name = &ctx.chunk.canonical_names[&external.namespace_ref];
    parameters.push(symbol_name.as_str());
  });
  parameters.join(", ")
}

pub fn render_chunk_external_imports<'a>(
  ctx: &'a GenerateContext<'_>,
) -> (String, Vec<&'a ExternalModule>) {
  let mut import_code = String::new();

  let externals = ctx
    .chunk
    .direct_imports_from_external_modules
    .iter()
    .filter_map(|(importee_id, _)| {
      let importee = ctx.link_output.module_table[*importee_id]
        .as_external()
        .expect("Should be external module here");

      let external_module_symbol_name = &ctx.chunk.canonical_names[&importee.namespace_ref];

      if ctx.link_output.used_symbol_refs.contains(&importee.namespace_ref) {
        let to_esm_fn_name = &ctx.chunk.canonical_names[&ctx
          .link_output
          .symbol_db
          .canonical_ref_for(ctx.link_output.runtime.resolve_symbol("__toESM"))];

        import_code.push_str(external_module_symbol_name);
        import_code.push_str(" = ");
        import_code.push_str(to_esm_fn_name);
        import_code.push('(');
        import_code.push_str(external_module_symbol_name);
        import_code.push_str(");\n");
        Some(importee)
      } else if importee.side_effects.has_side_effects() {
        Some(importee)
      } else {
        None
      }
    })
    .collect_vec();

  (import_code, externals)
}

pub fn render_modules_with_peek_runtime_module_at_first<'a>(
  ctx: &GenerateContext<'_>,
  source_joiner: &mut SourceJoiner<'a>,
  module_sources: &'a RenderedModuleSources,
  import_code: String,
) {
  let mut module_sources_peekable = module_sources.iter().peekable();
  match module_sources_peekable.peek() {
    Some(RenderedModuleSource { module_idx, .. })
      if *module_idx == ctx.link_output.runtime.id() =>
    {
      if let RenderedModuleSource { sources: Some(emitted_sources), .. } =
        module_sources_peekable.next().expect("Must have module")
      {
        for source in emitted_sources.iter() {
          source_joiner.append_source(source);
        }
      }
    }
    _ => {}
  }

  source_joiner.append_source(import_code);

  // chunk content
  module_sources_peekable.for_each(
    |RenderedModuleSource { sources: module_render_output, .. }| {
      if let Some(emitted_sources) = module_render_output {
        for source in emitted_sources.as_ref() {
          source_joiner.append_source(source);
        }
      }
    },
  );
}

pub fn render_chunk_directives<'a, T: Iterator<Item = &'a &'a str>>(directives: T) -> String {
  let mut ret = String::new();
  for d in directives {
    ret.push_str(d);
    if (d).ends_with(';') {
      ret.push('\n');
    } else {
      ret.push_str(";\n");
    }
  }
  ret
}