Merge branch 'main' into chore/diff-v2

Author: yifancong

Cargo.lock

@@ -92,7 +92,7 @@ use rspack_plugin_runtime::{
 use rspack_plugin_runtime_chunk::RuntimeChunkPlugin;
 use rspack_plugin_schemes::{DataUriPlugin, FileUriPlugin};
 use rspack_plugin_size_limits::SizeLimitsPlugin;
-use rspack_plugin_sri::SubresourceIntegrityPlugin;
+use rspack_plugin_sri::{SubresourceIntegrityPlugin, SubresourceIntegrityPluginOptions};
 use rspack_plugin_swc_js_minimizer::SwcJsMinimizerRspackPlugin;
 use rspack_plugin_warn_sensitive_module::WarnCaseSensitiveModulesPlugin;
 use rspack_plugin_wasm::{
@@ -819,9 +819,15 @@ impl<'a> BuiltinPlugin<'a> {
       }
       BuiltinPluginName::SubresourceIntegrityPlugin => {
         let raw_options = downcast_into::<RawSubresourceIntegrityPluginOptions>(self.options)
-          .map_err(|report| napi::Error::from_reason(report.to_string()))?;
-        let options = raw_options.into();
-        plugins.push(SubresourceIntegrityPlugin::new(options).boxed());
+          .and_then(SubresourceIntegrityPluginOptions::try_from);
+        match raw_options {
+          Ok(options) => {
+            plugins.push(SubresourceIntegrityPlugin::new(options, None).boxed());
+          }
+          Err(error) => {
+            plugins.push(SubresourceIntegrityPlugin::new(Default::default(), Some(error)).boxed());
+          }
+        }
       }
       BuiltinPluginName::ModuleInfoHeaderPlugin => {
         let verbose = downcast_into::<bool>(self.options)

crates/rspack_binding_api/src/raw_options/raw_builtins/mod.rs

@@ -22,9 +22,22 @@ pub struct RawSubresourceIntegrityPluginOptions {
   pub html_plugin: String,
 }
 
-impl From<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOptions {
-  fn from(options: RawSubresourceIntegrityPluginOptions) -> Self {
-    Self {
+impl TryFrom<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOptions {
+  type Error = rspack_error::Error;
+
+  fn try_from(options: RawSubresourceIntegrityPluginOptions) -> Result<Self, rspack_error::Error> {
+    let html_plugin = options.html_plugin.try_into()?;
+    if options.hash_func_names.is_empty() {
+      return Err(rspack_error::Error::error(
+        "Expect at least one SRI hash function name.".to_string(),
+      ));
+    }
+    let hash_func_names = options
+      .hash_func_names
+      .into_iter()
+      .map(SubresourceIntegrityHashFunction::try_from)
+      .collect::<Result<Vec<_>, rspack_error::Error>>()?;
+    Ok(Self {
       integrity_callback: if let Some(func) = options.integrity_callback {
         Some(Arc::new(move |data| {
           let func = func.clone();
@@ -33,13 +46,9 @@ impl From<RawSubresourceIntegrityPluginOptions> for SubresourceIntegrityPluginOp
       } else {
         None
       },
-      hash_func_names: options
-        .hash_func_names
-        .into_iter()
-        .map(SubresourceIntegrityHashFunction::from)
-        .collect::<Vec<_>>(),
-      html_plugin: options.html_plugin.into(),
-    }
+      hash_func_names,
+      html_plugin,
+    })
   }
 }
 

crates/rspack_binding_api/src/raw_options/raw_builtins/raw_sri.rs

@@ -35,6 +35,14 @@ impl Helper {
           condition_names: Some(vec!["import".into(), "require".into(), "node".into()]),
           exports_fields: Some(vec![vec!["exports".into()]]),
           builtin_modules: true,
+          extensions: Some(vec![
+            ".js".into(),
+            ".ts".into(),
+            ".mjs".into(),
+            ".cjs".into(),
+            ".json".into(),
+            ".node".into(),
+          ]),
           ..Default::default()
         },
         fs,
@@ -182,10 +190,10 @@ mod test {
   async fn helper_file_test() {
     let fs = Arc::new(MemoryFileSystem::default());
     fs.create_dir_all("/".into()).await.unwrap();
-    fs.write("/a.js".into(), r#"require("./a1")"#.as_bytes())
+    fs.write("/a.js".into(), r#"console.log("a")"#.as_bytes())
       .await
       .unwrap();
-    fs.write("/a1.js".into(), r#"console.log('a')"#.as_bytes())
+    fs.write("/a1.jsx".into(), r#"console.log('a1')"#.as_bytes())
       .await
       .unwrap();
     fs.write("/b.js".into(), r#"console.log('b')"#.as_bytes())
@@ -194,14 +202,38 @@ mod test {
     fs.write("/c.txt".into(), r#"123"#.as_bytes())
       .await
       .unwrap();
+    fs.write("/e.ts".into(), r#"console.log("e")"#.as_bytes())
+      .await
+      .unwrap();
+    fs.write("/e1.tsx".into(), r#"console.log("e1")"#.as_bytes())
+      .await
+      .unwrap();
+    fs.write("/f.json".into(), r#"{"name":"f"}"#.as_bytes())
+      .await
+      .unwrap();
+    fs.write("/g.cjs".into(), r#"console.log("g")"#.as_bytes())
+      .await
+      .unwrap();
+    fs.write("/h.mjs".into(), r#"console.log("h")"#.as_bytes())
+      .await
+      .unwrap();
+    fs.write("/i.node".into(), r#""#.as_bytes()).await.unwrap();
     fs.write(
       "/index.js".into(),
       r#"
 import "./a";
+import "./a1";
 import "./b";
 
 require("./c.txt");
 require("./d.md");
+
+require("./e");
+require("./e1");
+require("./f");
+require("./g");
+require("./h");
+require("./i");
 "#
       .as_bytes(),
     )
@@ -213,9 +245,9 @@ require("./d.md");
       .resolve("/index.js".into())
       .await
       .expect("should have deps");
-    assert_eq!(deps.len(), 3);
+    assert_eq!(deps.len(), 8);
     let warnings = helper.into_warnings();
-    assert_eq!(warnings.len(), 1);
+    assert_eq!(warnings.len(), 3);
   }
 
   #[tokio::test]

crates/rspack_core/src/cache/persistent/build_dependencies/helper/mod.rs

@@ -1,5 +1,5 @@
 pub const RESERVED_NAMES: [&str; 188] = [
-  "__WEBPACK_DEFAULT_EXPORT__",
+  "__rspack_default_export",
   "__WEBPACK_NAMESPACE_OBJECT__",
   "abstract",
   "arguments",

crates/rspack_core/src/reserved_names.rs

@@ -14,10 +14,9 @@ use crate::{
   concatenated_module::{ConcatenatedModuleInfo, ModuleInfo},
 };
 
-pub static DEFAULT_EXPORT_ATOM: LazyLock<Atom> =
-  LazyLock::new(|| "__WEBPACK_DEFAULT_EXPORT__".into());
+pub static DEFAULT_EXPORT_ATOM: LazyLock<Atom> = LazyLock::new(|| "__rspack_default_export".into());
 pub const NAMESPACE_OBJECT_EXPORT: &str = "__WEBPACK_NAMESPACE_OBJECT__";
-pub const DEFAULT_EXPORT: &str = "__WEBPACK_DEFAULT_EXPORT__";
+pub const DEFAULT_EXPORT: &str = "__rspack_default_export";
 
 static MODULE_REFERENCE_REGEXP: LazyLock<Regex> = LazyLock::new(|| {
   Regex::new(

crates/rspack_core/src/utils/concatenation_scope.rs

@@ -33,11 +33,12 @@ serde_json                      = { workspace = true }
 sha2                            = { workspace = true }
 tokio                           = { workspace = true }
 tracing                         = { workspace = true }
+url                             = { workspace = true }
 urlencoding                     = { workspace = true }
 
 [package.metadata.cargo-shear]
 ignored = ["tracing", "async-trait", "rspack_hash", "tokio"]
 
 [lints.rust.unexpected_cfgs]
-level = "warn"
 check-cfg = ['cfg(allocative)']
+level     = "warn"

crates/rspack_plugin_sri/Cargo.toml

@@ -15,25 +15,30 @@ use crate::integrity::SubresourceIntegrityHashFunction;
 pub type IntegrityCallbackFn =
   Arc<dyn Fn(IntegrityCallbackData) -> BoxFuture<'static, Result<()>> + Send + Sync>;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub enum IntegrityHtmlPlugin {
   NativePlugin,
   JavaScriptPlugin,
+  #[default]
   Disabled,
 }
 
-impl From<String> for IntegrityHtmlPlugin {
-  fn from(value: String) -> Self {
+impl TryFrom<String> for IntegrityHtmlPlugin {
+  type Error = rspack_error::Error;
+
+  fn try_from(value: String) -> Result<Self, rspack_error::Error> {
     match value.as_str() {
-      "JavaScript" => Self::JavaScriptPlugin,
-      "Native" => Self::NativePlugin,
-      "Disabled" => Self::Disabled,
-      _ => panic!("Invalid integrity html plugin: {value}"),
+      "JavaScript" => Ok(Self::JavaScriptPlugin),
+      "Native" => Ok(Self::NativePlugin),
+      "Disabled" => Ok(Self::Disabled),
+      _ => Err(rspack_error::Error::error(format!(
+        "Invalid integrity html plugin: {value}"
+      ))),
     }
   }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct SubresourceIntegrityPluginOptions {
   pub hash_func_names: Vec<SubresourceIntegrityHashFunction>,
   pub html_plugin: IntegrityHtmlPlugin,

crates/rspack_plugin_sri/src/config.rs

@@ -11,6 +11,7 @@ use rspack_plugin_html::{
 };
 use rustc_hash::FxHashMap as HashMap;
 use tokio::sync::RwLock;
+use url::Url;
 
 use crate::{
   SRICompilationContext, SubresourceIntegrityHashFunction, SubresourceIntegrityPlugin,
@@ -170,6 +171,14 @@ async fn process_tag(
     return Ok(None);
   };
 
+  // A tag which is not generated by chunks should be skipped
+  if let Ok(url) = Url::parse(&tag_src)
+    && (url.scheme() == "http" || url.scheme() == "https")
+    && (public_path.is_empty() || !tag_src.starts_with(public_path))
+  {
+    return Ok(None);
+  }
+
   let src = get_asset_path(&tag_src, public_path);
   if let Some(integrity) =
     get_integrity_checksum_for_asset(&src, integrities, normalized_integrities).await

crates/rspack_plugin_sri/src/html.rs

@@ -11,16 +11,17 @@ pub enum SubresourceIntegrityHashFunction {
   Sha512,
 }
 
-impl From<String> for SubresourceIntegrityHashFunction {
-  fn from(s: String) -> Self {
-    match s.as_str() {
-      "sha256" => Self::Sha256,
-      "sha384" => Self::Sha384,
-      "sha512" => Self::Sha512,
-      _ => panic!(
-        "sri hash function only support 'sha256', 'sha384' or 'sha512', but got '{}'.",
-        s
-      ),
+impl TryFrom<String> for SubresourceIntegrityHashFunction {
+  type Error = rspack_error::Error;
+
+  fn try_from(value: String) -> Result<Self, rspack_error::Error> {
+    match value.as_str() {
+      "sha256" => Ok(Self::Sha256),
+      "sha384" => Ok(Self::Sha384),
+      "sha512" => Ok(Self::Sha512),
+      _ => Err(rspack_error::Error::error(format!(
+        "Expect SRI hash function to be 'sha256', 'sha384' or 'sha512', but got '{value}'."
+      ))),
     }
   }
 }