Allow to opt into different chunk chunk methods

sokra · sokra · commit 686a7823bbcd · 2025-04-04T08:38:47.000+02:00
diff --git a/crates/next-core/src/next_client/context.rs b/crates/next-core/src/next_client/context.rs
@@ -13,7 +13,9 @@ use turbopack::{
     },
     resolve_options_context::ResolveOptionsContext,
 };
-use turbopack_browser::{react_refresh::assert_can_resolve_react_refresh, BrowserChunkingContext};
+use turbopack_browser::{
+    react_refresh::assert_can_resolve_react_refresh, BrowserChunkingContext, CurrentChunkMethod,
+};
 use turbopack_core::{
     chunk::{
         module_id_strategies::ModuleIdStrategy, ChunkingConfig, ChunkingContext, MinifyType,
@@ -462,6 +464,7 @@ pub async fn get_client_chunking_context(
         SourceMapsType::None
     })
     .asset_base_path(asset_prefix)
+    .current_chunk_method(CurrentChunkMethod::DocumentCurrentScript)
     .module_id_strategy(module_id_strategy);
 
     if next_mode.is_development() {
diff --git a/turbopack/crates/turbopack-browser/src/chunking_context.rs b/turbopack/crates/turbopack-browser/src/chunking_context.rs
@@ -32,6 +32,13 @@ use crate::ecmascript::{
     list::asset::{EcmascriptDevChunkList, EcmascriptDevChunkListSource},
 };
 
+#[turbo_tasks::value]
+#[derive(Debug, Clone, Copy, Hash)]
+pub enum CurrentChunkMethod {
+    StringLiteral,
+    DocumentCurrentScript,
+}
+
 pub struct BrowserChunkingContextBuilder {
     chunking_context: BrowserChunkingContext,
 }
@@ -92,6 +99,11 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn current_chunk_method(mut self, method: CurrentChunkMethod) -> Self {
+        self.chunking_context.current_chunk_method = method;
+        self
+    }
+
     pub fn module_id_strategy(
         mut self,
         module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
@@ -160,6 +172,8 @@ pub struct BrowserChunkingContext {
     minify_type: MinifyType,
     /// Whether to generate source maps
     source_maps_type: SourceMapsType,
+    /// Method to use when figuring out the current chunk src
+    current_chunk_method: CurrentChunkMethod,
     /// Whether to use manifest chunks for lazy compilation
     manifest_chunks: bool,
     /// The module id strategy to use
@@ -198,6 +212,7 @@ impl BrowserChunkingContext {
                 runtime_type,
                 minify_type: MinifyType::NoMinify,
                 source_maps_type: SourceMapsType::Full,
+                current_chunk_method: CurrentChunkMethod::StringLiteral,
                 manifest_chunks: false,
                 module_id_strategy: ResolvedVc::upcast(DevModuleIdStrategy::new_resolved()),
                 chunking_configs: Default::default(),
@@ -297,6 +312,11 @@ impl BrowserChunkingContext {
             },
         )
     }
+
+    #[turbo_tasks::function]
+    pub fn current_chunk_method(&self) -> Vc<CurrentChunkMethod> {
+        self.current_chunk_method.cell()
+    }
 }
 
 #[turbo_tasks::value_impl]
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/content.rs b/turbopack/crates/turbopack-browser/src/ecmascript/content.rs
@@ -1,6 +1,7 @@
 use std::io::Write;
 
-use anyhow::Result;
+use anyhow::{bail, Result};
+use either::Either;
 use indoc::writedoc;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{ResolvedVc, Vc};
@@ -19,7 +20,7 @@ use super::{
     chunk::EcmascriptBrowserChunk, content_entry::EcmascriptBrowserChunkContentEntries,
     merged::merger::EcmascriptBrowserChunkContentMerger, version::EcmascriptBrowserChunkVersion,
 };
-use crate::BrowserChunkingContext;
+use crate::{chunking_context::CurrentChunkMethod, BrowserChunkingContext};
 
 #[turbo_tasks::value(serialization = "none")]
 pub struct EcmascriptBrowserChunkContent {
@@ -71,6 +72,26 @@ impl EcmascriptBrowserChunkContent {
             .chunking_context
             .reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
             .await?;
+        // Lifetime hack to pull out the var into this scope
+        let chunk_path;
+        let script_or_path = match *this.chunking_context.current_chunk_method().await? {
+            CurrentChunkMethod::StringLiteral => {
+                let output_root = this.chunking_context.output_root().await?;
+                let chunk_path_vc = this.chunk.path();
+                chunk_path = chunk_path_vc.await?;
+                let chunk_server_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
+                    path
+                } else {
+                    bail!(
+                        "chunk path {} is not in output root {}",
+                        chunk_path.to_string(),
+                        output_root.to_string()
+                    );
+                };
+                Either::Left(StringifyJs(chunk_server_path))
+            }
+            CurrentChunkMethod::DocumentCurrentScript => Either::Right("document.currentScript"),
+        };
         let mut code = CodeBuilder::new(source_maps);
 
         // When a chunk is executed, it will either register itself with the current
@@ -83,8 +104,8 @@ impl EcmascriptBrowserChunkContent {
         writedoc!(
             code,
             r#"
-                (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([document.currentScript, {{
-            "#,
+                (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([{script_or_path}, {{
+            "#
         )?;
 
         let content = this.content.await?;
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs b/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs
@@ -1,6 +1,7 @@
 use std::io::Write;
 
-use anyhow::Result;
+use anyhow::{bail, Result};
+use either::Either;
 use indoc::writedoc;
 use serde::Serialize;
 use turbo_rcstr::RcStr;
@@ -26,7 +27,7 @@ use turbopack_ecmascript::{
 };
 use turbopack_ecmascript_runtime::RuntimeType;
 
-use crate::BrowserChunkingContext;
+use crate::{chunking_context::CurrentChunkMethod, BrowserChunkingContext};
 
 /// An Ecmascript chunk that:
 /// * Contains the Turbopack browser runtime code; and
@@ -79,6 +80,26 @@ impl EcmascriptBrowserEvaluateChunk {
             .chunking_context
             .reference_chunk_source_maps(Vc::upcast(self))
             .await?;
+        // Lifetime hack to pull out the var into this scope
+        let chunk_path;
+        let script_or_path = match *this.chunking_context.current_chunk_method().await? {
+            CurrentChunkMethod::StringLiteral => {
+                let output_root = this.chunking_context.output_root().await?;
+                let chunk_path_vc = self.path();
+                chunk_path = chunk_path_vc.await?;
+                let chunk_server_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
+                    path
+                } else {
+                    bail!(
+                        "chunk path {} is not in output root {}",
+                        chunk_path.to_string(),
+                        output_root.to_string()
+                    );
+                };
+                Either::Left(StringifyJs(chunk_server_path))
+            }
+            CurrentChunkMethod::DocumentCurrentScript => Either::Right("document.currentScript"),
+        };
 
         let other_chunks_data = self.chunks_data().await?;
         let other_chunks_data = other_chunks_data.iter().try_join().await?;
@@ -127,7 +148,7 @@ impl EcmascriptBrowserEvaluateChunk {
             code,
             r#"
                 (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([
-                    document.currentScript,
+                    {script_or_path},
                     {{}},
                     {}
                 ]);
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs b/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs
@@ -1,8 +1,13 @@
 use std::io::Write;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
+use either::Either;
 use indoc::writedoc;
-use turbo_tasks::{FxIndexMap, IntoTraitRef, ResolvedVc, TryJoinIterExt, Vc};
+use serde::{Deserialize, Serialize};
+use turbo_rcstr::RcStr;
+use turbo_tasks::{
+    trace::TraceRawVcs, FxIndexMap, IntoTraitRef, NonLocalValue, ResolvedVc, TryJoinIterExt, Vc,
+};
 use turbo_tasks_fs::File;
 use turbopack_core::{
     asset::{Asset, AssetContent},
@@ -20,10 +25,18 @@ use super::{
     update::update_chunk_list,
     version::EcmascriptDevChunkListVersion,
 };
+use crate::chunking_context::CurrentChunkMethod;
+
+#[derive(Clone, Debug, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue)]
+enum CurrentChunkMethodWithData {
+    StringLiteral(RcStr),
+    DocumentCurrentScript,
+}
 
 /// Contents of an [`EcmascriptDevChunkList`].
 #[turbo_tasks::value]
 pub(super) struct EcmascriptDevChunkListContent {
+    current_chunk_method: CurrentChunkMethodWithData,
     pub(super) chunks_contents: FxIndexMap<String, ResolvedVc<Box<dyn VersionedContent>>>,
     source: EcmascriptDevChunkListSource,
 }
@@ -35,21 +48,35 @@ impl EcmascriptDevChunkListContent {
     pub async fn new(chunk_list: Vc<EcmascriptDevChunkList>) -> Result<Vc<Self>> {
         let chunk_list_ref = chunk_list.await?;
         let output_root = chunk_list_ref.chunking_context.output_root().await?;
+        let current_chunk_method = match *chunk_list_ref
+            .chunking_context
+            .current_chunk_method()
+            .await?
+        {
+            CurrentChunkMethod::StringLiteral => {
+                let path = output_root
+                    .get_path_to(&*chunk_list.path().await?)
+                    .context("chunk list path not in output root")?
+                    .into();
+                CurrentChunkMethodWithData::StringLiteral(path)
+            }
+            CurrentChunkMethod::DocumentCurrentScript => {
+                CurrentChunkMethodWithData::DocumentCurrentScript
+            }
+        };
         Ok(EcmascriptDevChunkListContent {
+            current_chunk_method,
             chunks_contents: chunk_list_ref
                 .chunks
                 .await?
                 .iter()
-                .map(|chunk| {
-                    let output_root = output_root.clone();
-                    async move {
-                        Ok((
-                            output_root
-                                .get_path_to(&*chunk.path().await?)
-                                .map(|path| path.to_string()),
-                            chunk.versioned_content().to_resolved().await?,
-                        ))
-                    }
+                .map(async |chunk| {
+                    Ok((
+                        output_root
+                            .get_path_to(&*chunk.path().await?)
+                            .map(|path| path.to_string()),
+                        chunk.versioned_content().to_resolved().await?,
+                    ))
                 })
                 .try_join()
                 .await?
@@ -111,6 +138,13 @@ impl EcmascriptDevChunkListContent {
             .map(|s| s.as_str())
             .collect::<Vec<_>>();
 
+        let script_or_path = match &this.current_chunk_method {
+            CurrentChunkMethodWithData::StringLiteral(path) => Either::Left(StringifyJs(path)),
+            CurrentChunkMethodWithData::DocumentCurrentScript => {
+                Either::Right("document.currentScript")
+            }
+        };
+
         let mut code = CodeBuilder::default();
 
         // When loaded, JS chunks must register themselves with the `TURBOPACK` global
@@ -120,11 +154,11 @@ impl EcmascriptDevChunkListContent {
             code,
             r#"
                 (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([
-                    document.currentScript,
+                    {script_or_path},
                     {{}},
                 ]);
                 (globalThis.TURBOPACK_CHUNK_LISTS = globalThis.TURBOPACK_CHUNK_LISTS || []).push({{
-                    script: document.currentScript,
+                    script: {script_or_path},
                     chunks: {:#},
                     source: {:#}
                 }});
diff --git a/turbopack/crates/turbopack-browser/src/lib.rs b/turbopack/crates/turbopack-browser/src/lib.rs
@@ -7,7 +7,9 @@ pub(crate) mod chunking_context;
 pub mod ecmascript;
 pub mod react_refresh;
 
-pub use chunking_context::{BrowserChunkingContext, BrowserChunkingContextBuilder};
+pub use chunking_context::{
+    BrowserChunkingContext, BrowserChunkingContextBuilder, CurrentChunkMethod,
+};
 
 pub fn register() {
     turbo_tasks::register();
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
@@ -307,9 +307,12 @@ function getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {
 /**
  * Return the ChunkPath from a ChunkScript.
  */
-function getPathFromScript(chunkScript: ChunkScript): ChunkPath;
-function getPathFromScript(chunkScript: ChunkListScript): ChunkListPath;
-function getPathFromScript(chunkScript: ChunkScript | ChunkListScript): ChunkPath | ChunkListPath {
+function getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath;
+function getPathFromScript(chunkScript: ChunkListPath | ChunkListScript): ChunkListPath;
+function getPathFromScript(chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript): ChunkPath | ChunkListPath {
+  if (typeof chunkScript === "string") {
+    return chunkScript as ChunkPath | ChunkListPath;
+  }
   const src = decodeURIComponent(chunkScript.getAttribute("src")!);
   const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
   return path as ChunkPath | ChunkListPath;
