rspack_plugin_mf 0.100.1

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

use std::{
  path::{Path, PathBuf},
  sync::Arc,
};

use camino::{Utf8Path, Utf8PathBuf};
use rspack_fs::ReadableFileSystem;
use rustc_hash::FxHashSet;

pub mod collect_shared_entry_plugin;
pub mod consume_shared_fallback_dependency;
pub mod consume_shared_module;
pub mod consume_shared_plugin;
pub mod consume_shared_runtime_module;
pub mod provide_for_shared_dependency;
pub mod provide_shared_dependency;
pub mod provide_shared_module;
pub mod provide_shared_module_factory;
pub mod provide_shared_plugin;
pub mod share_runtime_module;
pub mod share_runtime_plugin;
pub mod shared_container_plugin;
pub mod shared_container_runtime_module;
pub mod shared_used_exports_optimizer_plugin;
pub mod shared_used_exports_optimizer_runtime_module;

const DESCRIPTION_FILE_NAME: &str = "package.json";

fn is_node_modules_dir(dir: &Path) -> bool {
  dir.file_name().is_some_and(|name| name == "node_modules")
}

fn collect_description_file_paths(mut dir: &Path) -> Vec<PathBuf> {
  let mut description_file_paths = Vec::new();

  loop {
    if is_node_modules_dir(dir) {
      break;
    }

    description_file_paths.push(dir.join(DESCRIPTION_FILE_NAME));

    if let Some(parent) = dir.parent() {
      dir = parent;
    } else {
      break;
    }
  }

  description_file_paths
}

fn find_ancestor_description_data<T>(
  start_dir: &Path,
  mut matcher: impl FnMut(&Path, &serde_json::Value) -> Option<T>,
) -> Option<T> {
  for description_file in collect_description_file_paths(start_dir) {
    if let Ok(data) = std::fs::read(&description_file)
      && let Ok(data) = serde_json::from_slice::<serde_json::Value>(&data)
      && let Some(dir) = description_file.parent()
      && let Some(value) = matcher(dir, &data)
    {
      return Some(value);
    }
  }

  None
}

async fn get_description_file(
  fs: Arc<dyn ReadableFileSystem>,
  dir: &Utf8Path,
  satisfies_description_file_data: Option<impl Fn(&serde_json::Value) -> bool>,
) -> (Option<serde_json::Value>, Option<Vec<String>>) {
  let mut checked_file_paths = FxHashSet::default();

  for description_file in collect_description_file_paths(dir.as_std_path()) {
    let description_file = Utf8PathBuf::from_path_buf(description_file)
      .expect("description file path should remain utf8");
    let data = fs.read(&description_file).await;

    if let Ok(data) = data
      && let Ok(data) = serde_json::from_slice::<serde_json::Value>(&data)
    {
      if satisfies_description_file_data
        .as_ref()
        .is_some_and(|f| !f(&data))
      {
        checked_file_paths.insert(description_file.to_string());
      } else {
        return (Some(data), None);
      }
    }
  }

  let mut checked_file_paths = checked_file_paths.into_iter().collect::<Vec<_>>();
  checked_file_paths.sort_unstable();

  (None, Some(checked_file_paths))
}