rspack_binding_api 0.100.0-rc.2

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

use napi_derive::napi;
use rspack_core::{CodeGenerationResult, CodeGenerationResults, get_runtime_key};
use rustc_hash::FxHashMap as HashMap;

#[napi(object)]
#[derive(Debug)]
pub struct JsCodegenerationResults {
  pub map: HashMap<String, HashMap<String, JsCodegenerationResult>>,
}

#[napi(object)]
#[derive(Debug)]
pub struct JsCodegenerationResult {
  pub sources: HashMap<String, String>,
}

impl From<&CodeGenerationResult> for JsCodegenerationResult {
  fn from(result: &CodeGenerationResult) -> Self {
    Self {
      sources: result
        .inner
        .as_ref()
        .iter()
        .map(|(source_type, source)| {
          (
            source_type.to_string(),
            source.source().into_string_lossy().into_owned(),
          )
        })
        .collect::<HashMap<String, String>>(),
    }
  }
}

impl From<&CodeGenerationResults> for JsCodegenerationResults {
  fn from(results: &CodeGenerationResults) -> Self {
    let (map, id_result_map) = results.inner();

    Self {
      map: map
        .iter()
        .map(|(module_id, runtime_result_map)| {
          let mut runtime_map: HashMap<String, JsCodegenerationResult> = Default::default();
          match &runtime_result_map.mode {
            rspack_core::RuntimeMode::Empty => {}
            rspack_core::RuntimeMode::SingleEntry => {
              runtime_map.insert(
                get_runtime_key(runtime_result_map.single_runtime.as_ref().expect("exist")).clone(),
                id_result_map
                  .get(
                    &runtime_result_map
                      .single_value
                      .expect("should have single value in SingleEntry mode"),
                  )
                  .expect("should have codegen result for single value")
                  .as_ref()
                  .into(),
              );
            }
            rspack_core::RuntimeMode::Map => {
              runtime_result_map.map.iter().for_each(|(k, v)| {
                runtime_map.insert(
                  k.clone(),
                  id_result_map
                    .get(v)
                    .expect("should have codegen result for runtime value")
                    .as_ref()
                    .into(),
                );
              });
            }
          };

          (module_id.to_string(), runtime_map)
        })
        .collect(),
    }
  }
}