feat: support bundle new url

Author: JSerFeng

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

@@ -276,6 +276,9 @@ pub struct RawJavascriptParserOptions {
   pub dynamic_import_prefetch: Option<String>,
   pub dynamic_import_fetch_priority: Option<String>,
   pub url: Option<String>,
+  /// Bundle new URL() targets as separate entry chunks (single-file output)
+  #[napi(js_name = "bundleNewUrl")]
+  pub bundle_new_url: Option<bool>,
   pub expr_context_critical: Option<bool>,
   pub unknown_context_critical: Option<bool>,
   pub wrapped_context_critical: Option<bool>,
@@ -342,6 +345,7 @@ impl From<RawJavascriptParserOptions> for JavascriptParserOptions {
         .dynamic_import_fetch_priority
         .map(|x| DynamicImportFetchPriority::from(x.as_str())),
       url: value.url.map(|v| JavascriptParserUrl::from(v.as_str())),
+      bundle_new_url: value.bundle_new_url,
       expr_context_critical: value.expr_context_critical,
       unknown_context_critical: value.unknown_context_critical,
       wrapped_context_reg_exp: value.wrapped_context_reg_exp,

crates/rspack_core/src/dependency/dependency_type.rs

@@ -47,6 +47,8 @@ pub enum DependencyType {
   NewUrlContext,
   // new Worker()
   NewWorker,
+  // new URL() bundle mode (single-file entry)
+  NewUrlBundle,
   // create script url
   CreateScriptUrl,
   // import.meta.webpackHot.accept
@@ -151,6 +153,7 @@ impl DependencyType {
       DependencyType::NewUrl => "new URL()",
       DependencyType::NewUrlContext => "new URL() context",
       DependencyType::NewWorker => "new Worker()",
+      DependencyType::NewUrlBundle => "new URL() bundle",
       DependencyType::CreateScriptUrl => "create script url",
       DependencyType::ImportMetaHotAccept => "import.meta.webpackHot.accept",
       DependencyType::ImportMetaHotDecline => "import.meta.webpackHot.decline",

crates/rspack_core/src/options/module.rs

@@ -289,6 +289,8 @@ pub struct JavascriptParserOptions {
   pub dynamic_import_prefetch: Option<JavascriptParserOrder>,
   pub dynamic_import_fetch_priority: Option<DynamicImportFetchPriority>,
   pub url: Option<JavascriptParserUrl>,
+  /// Bundle new URL() targets as separate entry chunks (single-file output)
+  pub bundle_new_url: Option<bool>,
   pub unknown_context_critical: Option<bool>,
   pub expr_context_critical: Option<bool>,
   pub wrapped_context_critical: Option<bool>,

crates/rspack_plugin_javascript/src/dependency/url/mod.rs

@@ -1,3 +1,4 @@
+mod url_bundle;
 use std::sync::LazyLock;
 
 use regex::Regex;
@@ -11,6 +12,7 @@ use rspack_core::{
   URLStaticMode, UsedByExports,
 };
 use swc_core::ecma::atoms::Atom;
+pub use url_bundle::{URLBundleDependency, URLBundleDependencyTemplate};
 
 use crate::{connection_active_used_by_exports, runtime::AUTO_PUBLIC_PATH_PLACEHOLDER};
 

crates/rspack_plugin_javascript/src/dependency/url/url_bundle.rs

@@ -0,0 +1,201 @@
+use rspack_cacheable::{cacheable, cacheable_dyn};
+use rspack_core::{
+  AsContextDependency, Compilation, Dependency, DependencyCategory, DependencyCodeGeneration,
+  DependencyId, DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType,
+  ExtendedReferencedExport, FactorizeInfo, ModuleDependency, ModuleGraph, ModuleGraphCacheArtifact,
+  RuntimeGlobals, RuntimeSpec, TemplateContext, TemplateReplaceSource,
+};
+use rspack_util::ext::DynHash;
+
+/// Dependency for `new URL()` when in bundle mode.
+/// This creates an async block that bundles the target module as a single-file entry.
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct URLBundleDependency {
+  id: DependencyId,
+  request: String,
+  public_path: String,
+  range: DependencyRange,
+  range_url: DependencyRange,
+  factorize_info: FactorizeInfo,
+  /// Whether to render using relative URL (when url mode is NewUrlRelative)
+  use_relative: bool,
+}
+
+impl URLBundleDependency {
+  pub fn new(
+    request: String,
+    public_path: String,
+    range: DependencyRange,
+    range_url: DependencyRange,
+    use_relative: bool,
+  ) -> Self {
+    Self {
+      id: DependencyId::new(),
+      request,
+      public_path,
+      range,
+      range_url,
+      factorize_info: Default::default(),
+      use_relative,
+    }
+  }
+}
+
+#[cacheable_dyn]
+impl Dependency for URLBundleDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn category(&self) -> &DependencyCategory {
+    &DependencyCategory::Url
+  }
+
+  fn dependency_type(&self) -> &DependencyType {
+    &DependencyType::NewUrlBundle
+  }
+
+  fn range(&self) -> Option<DependencyRange> {
+    Some(self.range)
+  }
+
+  fn get_referenced_exports(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_graph_cache: &ModuleGraphCacheArtifact,
+    _runtime: Option<&RuntimeSpec>,
+  ) -> Vec<ExtendedReferencedExport> {
+    vec![]
+  }
+
+  fn could_affect_referencing_module(&self) -> rspack_core::AffectType {
+    rspack_core::AffectType::True
+  }
+}
+
+#[cacheable_dyn]
+impl ModuleDependency for URLBundleDependency {
+  fn request(&self) -> &str {
+    &self.request
+  }
+
+  fn user_request(&self) -> &str {
+    &self.request
+  }
+
+  fn factorize_info(&self) -> &FactorizeInfo {
+    &self.factorize_info
+  }
+
+  fn factorize_info_mut(&mut self) -> &mut FactorizeInfo {
+    &mut self.factorize_info
+  }
+}
+
+#[cacheable_dyn]
+impl DependencyCodeGeneration for URLBundleDependency {
+  fn dependency_template(&self) -> Option<DependencyTemplateType> {
+    Some(URLBundleDependencyTemplate::template_type())
+  }
+
+  fn update_hash(
+    &self,
+    hasher: &mut dyn std::hash::Hasher,
+    _compilation: &Compilation,
+    _runtime: Option<&RuntimeSpec>,
+  ) {
+    self.public_path.dyn_hash(hasher);
+  }
+}
+
+impl AsContextDependency for URLBundleDependency {}
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct URLBundleDependencyTemplate;
+
+impl URLBundleDependencyTemplate {
+  pub fn template_type() -> DependencyTemplateType {
+    DependencyTemplateType::Dependency(DependencyType::NewUrlBundle)
+  }
+}
+
+impl DependencyTemplate for URLBundleDependencyTemplate {
+  fn render(
+    &self,
+    dep: &dyn DependencyCodeGeneration,
+    source: &mut TemplateReplaceSource,
+    code_generatable_context: &mut TemplateContext,
+  ) {
+    let dep = dep
+      .as_any()
+      .downcast_ref::<URLBundleDependency>()
+      .expect("URLBundleDependencyTemplate should be used for URLBundleDependency");
+    let TemplateContext {
+      compilation,
+      runtime_requirements,
+      ..
+    } = code_generatable_context;
+
+    // Get the chunk ID from the async block
+    let chunk_id = compilation
+      .get_module_graph()
+      .get_parent_block(&dep.id)
+      .and_then(|block| {
+        compilation
+          .chunk_graph
+          .get_block_chunk_group(block, &compilation.chunk_group_by_ukey)
+      })
+      .map(|entrypoint| entrypoint.get_entrypoint_chunk())
+      .and_then(|ukey| compilation.chunk_by_ukey.get(&ukey))
+      .and_then(|chunk| chunk.id())
+      .and_then(|chunk_id| serde_json::to_string(chunk_id).ok())
+      .expect("failed to get json stringified chunk id");
+
+    runtime_requirements.insert(RuntimeGlobals::GET_CHUNK_SCRIPT_FILENAME);
+
+    let url_import_str = if dep.use_relative {
+      // Render with relative path using new URL(filename, import.meta.url) pattern
+      format!(
+        "/* url bundle import */ new URL({}({}), import.meta.url)",
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::GET_CHUNK_SCRIPT_FILENAME),
+        chunk_id
+      )
+    } else {
+      // Standard rendering with PUBLIC_PATH and BASE_URI
+      let url_base = if !dep.public_path.is_empty() {
+        format!("\"{}\"", dep.public_path)
+      } else {
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::PUBLIC_PATH)
+      };
+
+      runtime_requirements.insert(RuntimeGlobals::PUBLIC_PATH);
+      runtime_requirements.insert(RuntimeGlobals::BASE_URI);
+
+      // Generate: new URL(publicPath + __webpack_require__.u(chunkId), __webpack_require__.b)
+      format!(
+        "/* url bundle import */ new URL({} + {}({}), {})",
+        url_base,
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::GET_CHUNK_SCRIPT_FILENAME),
+        chunk_id,
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::BASE_URI)
+      )
+    };
+
+    source.replace(
+      dep.range.start,
+      dep.range.end,
+      url_import_str.as_str(),
+      None,
+    );
+  }
+}

crates/rspack_plugin_javascript/src/parser_plugin/url_plugin.rs

@@ -1,7 +1,11 @@
+use std::hash::Hash;
+
 use rspack_core::{
-  ConstDependency, ContextDependency, ContextMode, ContextNameSpaceObject, ContextOptions,
-  DependencyCategory, JavascriptParserUrl, RuntimeGlobals,
+  AsyncDependenciesBlock, ChunkLoading, ConstDependency, ContextDependency, ContextMode,
+  ContextNameSpaceObject, ContextOptions, DependencyCategory, DependencyRange, EntryOptions,
+  GroupOptions, JavascriptParserUrl, RuntimeGlobals, SharedSourceMap,
 };
+use rspack_hash::RspackHash;
 use rspack_util::SpanExt;
 use swc_core::{
   common::Spanned,
@@ -15,7 +19,7 @@ use url::Url;
 use super::JavascriptParserPlugin;
 use crate::{
   InnerGraphPlugin,
-  dependency::{URLContextDependency, URLDependency},
+  dependency::{URLBundleDependency, URLContextDependency, URLDependency},
   magic_comment::try_extract_magic_comment,
   parser_plugin::inner_graph::state::InnerGraphUsageOperation,
   visitors::{ExprRef, JavascriptParser, context_reg_exp, create_context_dependency},
@@ -101,6 +105,8 @@ pub fn get_url_request(
 
 pub struct URLPlugin {
   pub mode: Option<JavascriptParserUrl>,
+  /// Whether to bundle new URL() targets as separate entry chunks
+  pub bundle_new_url: Option<bool>,
 }
 
 impl JavascriptParserPlugin for URLPlugin {
@@ -159,6 +165,11 @@ impl JavascriptParserPlugin for URLPlugin {
     }
 
     if let Some((request, start, end)) = get_url_request(parser, expr) {
+      // Handle Bundle mode - create AsyncDependenciesBlock with special EntryOptions
+      if self.bundle_new_url == Some(true) {
+        return self.handle_bundle_mode(parser, expr, request, start, end);
+      }
+
       let dep = URLDependency::new(
         request.into(),
         expr.span.into(),
@@ -228,3 +239,71 @@ impl JavascriptParserPlugin for URLPlugin {
     Some(true)
   }
 }
+
+impl URLPlugin {
+  /// Handle Bundle mode: creates an AsyncDependenciesBlock with EntryOptions
+  /// that force single-file output (no chunk loading, no async chunks)
+  fn handle_bundle_mode(
+    &self,
+    parser: &mut JavascriptParser,
+    expr: &NewExpr,
+    request: String,
+    start: u32,
+    end: u32,
+  ) -> Option<bool> {
+    let output_options = &parser.compiler_options.output;
+    let mut hasher = RspackHash::from(output_options);
+    parser.module_identifier.hash(&mut hasher);
+    parser.worker_index.hash(&mut hasher);
+    parser.worker_index += 1;
+    let digest = hasher.digest(&output_options.hash_digest);
+    let runtime = digest
+      .rendered(output_options.hash_digest_length)
+      .to_owned();
+
+    // Use empty public_path - it will be resolved at runtime via RuntimeGlobals::PUBLIC_PATH
+    let public_path = String::new();
+
+    // Use relative URL when mode is NewUrlRelative
+    let use_relative = matches!(self.mode, Some(JavascriptParserUrl::NewUrlRelative));
+
+    let dep = Box::new(URLBundleDependency::new(
+      request.clone(),
+      public_path,
+      expr.span.into(),
+      (start, end).into(),
+      use_relative,
+    ));
+
+    let source_map: SharedSourceMap = parser.source_rope().clone();
+    let mut block = AsyncDependenciesBlock::new(
+      *parser.module_identifier,
+      Into::<DependencyRange>::into(expr.span).to_loc(Some(&source_map)),
+      None,
+      vec![dep],
+      Some(request),
+    );
+
+    // Set EntryOptions with:
+    // - chunk_loading: Disable (no chunk loading runtime needed)
+    // - async_chunks: false (prevent further async chunk splitting)
+    // This ensures the bundle is a single self-contained file
+    block.set_group_options(GroupOptions::Entrypoint(Box::new(EntryOptions {
+      name: None, // Anonymous entry - will get auto-generated chunk name
+      runtime: Some(runtime.into()),
+      chunk_loading: Some(ChunkLoading::Disable),
+      wasm_loading: None,
+      async_chunks: Some(false),
+      public_path: None,
+      base_uri: None,
+      filename: None,
+      library: None,
+      depend_on: None,
+      layer: None,
+    })));
+
+    parser.add_block(Box::new(block));
+
+    Some(true)
+  }
+}

crates/rspack_plugin_javascript/src/plugin/url_plugin.rs

@@ -48,6 +48,7 @@ async fn normal_module_factory_parser(
     if !matches!(options.url, Some(JavascriptParserUrl::Disable)) {
       parser.add_parser_plugin(Box::new(crate::parser_plugin::URLPlugin {
         mode: options.url,
+        bundle_new_url: options.bundle_new_url,
       }));
     }
   }