rspack_core 0.101.10

rspack core
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use async_trait::async_trait;

use super::*;
use crate::{cache::Cache, compilation::pass::PassExt};

/// Collects module identifiers that need ID assignment.
/// A module needs an ID if:
/// - It doesn't already have one assigned
/// - It needs an ID (need_id() returns true)
/// - It's part of at least one chunk
fn get_modules_needing_ids(
  compilation: &Compilation,
  module_ids_artifact: &ModuleIdsArtifact,
) -> IdentifierSet {
  let chunk_graph = &compilation.build_chunk_graph_artifact.chunk_graph;
  compilation
    .get_module_graph()
    .modules()
    .map(|(_, module)| module)
    .filter(|m| {
      m.need_id()
        && ChunkGraph::get_module_id(module_ids_artifact, m.identifier()).is_none()
        && (chunk_graph.get_number_of_module_chunks(m.identifier()) != 0
          || m.build_meta().is_css_module()
          || m.build_meta().need_id_in_concatenation())
    })
    .map(|m| m.identifier())
    .collect()
}

pub struct ModuleIdsPass;

#[async_trait]
impl PassExt for ModuleIdsPass {
  fn name(&self) -> &'static str {
    "module ids"
  }

  async fn before_pass(&self, compilation: &mut Compilation, cache: &mut dyn Cache) {
    cache.before_module_ids(compilation).await;
  }

  async fn run_pass(&self, compilation: &mut Compilation) -> Result<()> {
    // Check if MODULE_IDS pass is disabled, and clear artifact if needed
    if !compilation
      .incremental
      .passes_enabled(IncrementalPasses::MODULE_IDS)
    {
      compilation.module_ids_artifact.clear();
    }

    let module_ids_artifact = compilation.module_ids_artifact.steal();
    let mut preserved_module_ids_artifact = ModuleIdsArtifact::default();

    // Call reviveModules hook - allows plugins to restore IDs from records
    if !compilation
      .plugin_driver
      .compilation_hooks
      .revive_modules
      .is_empty()
    {
      let modules_needing_ids =
        get_modules_needing_ids(compilation, &preserved_module_ids_artifact);
      compilation
        .plugin_driver
        .clone()
        .compilation_hooks
        .revive_modules
        .call(
          compilation,
          &modules_needing_ids,
          &mut preserved_module_ids_artifact,
        )
        .await
        .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.reviveModules"))?;
    }

    // Call beforeModuleIds hook - allows plugins to assign custom IDs
    if !compilation
      .plugin_driver
      .compilation_hooks
      .before_module_ids
      .is_empty()
    {
      let modules_needing_ids =
        get_modules_needing_ids(compilation, &preserved_module_ids_artifact);
      compilation
        .plugin_driver
        .clone()
        .compilation_hooks
        .before_module_ids
        .call(
          compilation,
          &modules_needing_ids,
          &mut preserved_module_ids_artifact,
        )
        .await
        .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.beforeModuleIds"))?;
    }

    // Put the recovered artifact back before preserved IDs are merged.
    compilation.module_ids_artifact = module_ids_artifact.into();

    let mut diagnostics = vec![];
    let mut module_ids_artifact = compilation.module_ids_artifact.steal();

    // Merge IDs assigned by reviveModules and beforeModuleIds before running module ID plugins,
    // so every plugin sees them as reserved IDs. Plugins that reset global IDs retain this
    // preserved subset.
    {
      let mut mutations = compilation.incremental.mutations_write();
      for (module, id) in preserved_module_ids_artifact.iter() {
        if ChunkGraph::set_module_id(&mut module_ids_artifact, *module, id.clone())
          && let Some(mutations) = &mut mutations
        {
          mutations.add(Mutation::ModuleSetId { module: *module });
        }
      }
    }

    compilation
      .plugin_driver
      .clone()
      .compilation_hooks
      .module_ids
      .call(
        compilation,
        &mut module_ids_artifact,
        &preserved_module_ids_artifact,
        &mut diagnostics,
      )
      .await
      .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.moduleIds"))?;

    if !compilation
      .plugin_driver
      .compilation_hooks
      .record_modules
      .is_empty()
    {
      compilation
        .plugin_driver
        .clone()
        .compilation_hooks
        .record_modules
        .call(compilation, &module_ids_artifact)
        .await
        .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.recordModules"))?;
    }
    compilation.module_ids_artifact = module_ids_artifact.into();
    compilation.extend_diagnostics(diagnostics);
    Ok(())
  }

  async fn after_pass(&self, compilation: &mut Compilation, cache: &mut dyn Cache) {
    cache.after_module_ids(compilation).await;
  }
}