rspack_plugin_module_replacement 0.100.4

rspack module replacement 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

use derive_more::Debug;
use futures::future::BoxFuture;
use rspack_core::{
  ModuleFactoryCreateData, NormalModuleCreateData, NormalModuleFactoryAfterResolve,
  NormalModuleFactoryBeforeResolve, Plugin,
};
use rspack_error::Result;
use rspack_hook::{plugin, plugin_hook};
use rspack_paths::Utf8PathBuf;
use rspack_regex::RspackRegex;

pub struct NormalModuleReplacementPluginOptions {
  pub resource_reg_exp: RspackRegex,
  pub new_resource: NormalModuleReplacer,
}

pub enum NormalModuleReplacer {
  String(String),
  Fn(NormalModuleReplacerFn),
}

pub type NormalModuleReplacerFn = Box<
  dyn for<'a> Fn(
      &'a mut ModuleFactoryCreateData,
      Option<&'a mut NormalModuleCreateData>,
    ) -> BoxFuture<'a, Result<()>>
    + Sync
    + Send,
>;

#[plugin]
#[derive(Debug)]
pub struct NormalModuleReplacementPlugin {
  resource_reg_exp: RspackRegex,
  #[debug(skip)]
  new_resource: NormalModuleReplacer,
}

impl NormalModuleReplacementPlugin {
  pub fn new(options: NormalModuleReplacementPluginOptions) -> Self {
    Self::new_inner(options.resource_reg_exp, options.new_resource)
  }
}

#[plugin_hook(NormalModuleFactoryBeforeResolve for NormalModuleReplacementPlugin)]
async fn nmf_before_resolve(&self, data: &mut ModuleFactoryCreateData) -> Result<Option<bool>> {
  if self.resource_reg_exp.test(&data.request) {
    match &self.new_resource {
      NormalModuleReplacer::String(s) => data.request = s.clone(),
      NormalModuleReplacer::Fn(f) => f(data, None).await?,
    }
  }
  Ok(None)
}

#[plugin_hook(NormalModuleFactoryAfterResolve for NormalModuleReplacementPlugin)]
async fn nmf_after_resolve(
  &self,
  data: &mut ModuleFactoryCreateData,
  create_data: &mut NormalModuleCreateData,
) -> Result<Option<bool>> {
  if self
    .resource_reg_exp
    .test(create_data.resource_resolve_data.resource())
  {
    match &self.new_resource {
      NormalModuleReplacer::String(new_resource) => {
        // Same as [JsCreateData::update_nmf_data] in crates/rspack_binding_api/src/normal_module_factory.rs
        if Utf8PathBuf::from(new_resource).is_absolute() {
          create_data
            .resource_resolve_data
            .update_resource_data(new_resource.clone());
        } else if let Some(dir) =
          Utf8PathBuf::from(create_data.resource_resolve_data.resource()).parent()
        {
          create_data
            .resource_resolve_data
            .update_resource_data(dir.join(new_resource.clone()).to_string());
        }
      }
      NormalModuleReplacer::Fn(f) => f(data, Some(create_data)).await?,
    }
  }
  Ok(None)
}

impl Plugin for NormalModuleReplacementPlugin {
  fn name(&self) -> &'static str {
    "rspack.NormalModuleReplacementPlugin"
  }

  fn apply(&self, ctx: &mut rspack_core::ApplyContext<'_>) -> Result<()> {
    ctx
      .normal_module_factory_hooks
      .before_resolve
      .tap(nmf_before_resolve::new(self));
    ctx
      .normal_module_factory_hooks
      .after_resolve
      .tap(nmf_after_resolve::new(self));
    Ok(())
  }
}