rspack_binding_api 0.101.0-rc.0

Rspack shared binding API
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

use std::sync::Arc;

use napi_derive::napi;
use rspack_core::{Resolve, ResolverFactory};
use rspack_fs::{NativeFileSystem, ReadableFileSystem};

use crate::{
  error::RspackResultToNapiResultExt,
  options::raw_resolve::{
    RawResolveOptions, RawResolveOptionsWithDependencyType,
    normalize_raw_resolve_options_with_dependency_type,
  },
  resolver::JsResolver,
};

#[napi]
pub struct JsResolverFactory {
  input_filesystem: Arc<dyn ReadableFileSystem>,
  resolve_options: Resolve,
  loader_resolve_options: Resolve,

  resolver_factory: Option<Arc<ResolverFactory>>,
  loader_resolver_factory: Option<Arc<ResolverFactory>>,
}

#[napi]
impl JsResolverFactory {
  #[napi(constructor)]
  pub fn new(
    pnp: bool,
    js_resolve_options: RawResolveOptions,
    js_loader_resolve_options: RawResolveOptions,
  ) -> napi::Result<Self> {
    // Webpack handles resolver creation in lib/WebpackOptionsApply.js via resolveOptions hook:
    // 1. For "normal" type: merges compiler.options.resolve and sets inputFileSystem
    // 2. For "loader" type: merges compiler.options.resolveLoader and sets inputFileSystem
    // 3. For "context" type: merges compiler.options.resolve and sets inputFileSystem
    //
    // Since Rspack doesn't support resolveOptions hook, we pre-configure resolve/resolveLoader
    // options and inputFileSystem during ResolverFactory creation for later resolver instantiation.
    let input_filesystem = Arc::new(NativeFileSystem::new(pnp));

    let resolve_options: Resolve = js_resolve_options
      .try_into()
      .map_err(|e: rspack_error::Error| napi::Error::from_reason(e.to_string()))?;

    let loader_resolve_options: Resolve = js_loader_resolve_options
      .try_into()
      .map_err(|e: rspack_error::Error| napi::Error::from_reason(e.to_string()))?;

    Ok(Self {
      resolve_options,
      loader_resolve_options,
      resolver_factory: None,
      loader_resolver_factory: None,
      input_filesystem,
    })
  }

  pub fn update_options(
    &mut self,
    input_filesystem: Option<Arc<dyn ReadableFileSystem>>,
    resolve_options: Resolve,
    loader_resolve_options: Resolve,
  ) {
    if input_filesystem.is_some()
      || self.resolve_options != resolve_options
      || self.loader_resolve_options != loader_resolve_options
    {
      self.resolver_factory = None;
      self.loader_resolver_factory = None;
    }
    if let Some(input_filesystem) = input_filesystem {
      self.input_filesystem = input_filesystem;
    }
    self.resolve_options = resolve_options;
    self.loader_resolve_options = loader_resolve_options;
  }

  pub fn get_resolver_factory(&mut self) -> Arc<ResolverFactory> {
    match &self.resolver_factory {
      Some(resolver_factory) => resolver_factory.clone(),

      None => {
        let resolver_factory = Arc::new(ResolverFactory::new(
          self.resolve_options.clone(),
          self.input_filesystem.clone(),
        ));
        self.resolver_factory = Some(resolver_factory.clone());
        resolver_factory
      }
    }
  }

  pub fn get_loader_resolver_factory(&mut self) -> Arc<ResolverFactory> {
    match &self.loader_resolver_factory {
      Some(resolver_factory) => resolver_factory.clone(),
      None => {
        let resolver_factory = Arc::new(ResolverFactory::new(
          self.loader_resolve_options.clone(),
          self.input_filesystem.clone(),
        ));
        self.loader_resolver_factory = Some(resolver_factory.clone());
        resolver_factory
      }
    }
  }

  #[napi(ts_args_type = "type: string, options?: RawResolveOptionsWithDependencyType")]
  pub fn get(
    &mut self,
    r#type: String,
    raw: Option<RawResolveOptionsWithDependencyType>,
  ) -> napi::Result<JsResolver> {
    match r#type.as_str() {
      "normal" => {
        let resolver_factory = self.get_resolver_factory();
        let options =
          normalize_raw_resolve_options_with_dependency_type(raw, false).to_napi_result()?;
        let resolver = resolver_factory.get(options);
        Ok(JsResolver::new(resolver))
      }
      "loader" => {
        let resolver_factory = self.get_loader_resolver_factory();
        let options =
          normalize_raw_resolve_options_with_dependency_type(raw, false).to_napi_result()?;
        let resolver = resolver_factory.get(options);
        Ok(JsResolver::new(resolver))
      }
      "context" => {
        let resolver_factory = self.get_resolver_factory();
        let options =
          normalize_raw_resolve_options_with_dependency_type(raw, true).to_napi_result()?;
        let resolver = resolver_factory.get(options);
        Ok(JsResolver::new(resolver))
      }
      _ => Err(napi::Error::from_reason(format!(
        "Invalid resolver type '{type}' specified. Rspack only supports 'normal', 'context', and 'loader' types."
      ))),
    }
  }
}