review: ResolveOptions.parse_data_uris

Author: mischnic

turbopack/crates/turbopack-core/src/resolve/mod.rs

@@ -41,7 +41,7 @@ use crate::{
     output::{OutputAsset, OutputAssets},
     package_json::{read_package_json, PackageJsonIssue},
     raw_module::RawModule,
-    reference_type::{ReferenceType, UrlReferenceSubType},
+    reference_type::ReferenceType,
     resolve::{
         node::{node_cjs_resolve_options, node_esm_resolve_options},
         parse::stringify_data_uri,
@@ -1589,14 +1589,10 @@ pub async fn resolve_inline(
             handle_before_resolve_plugins(lookup_path, reference_type.clone(), request, options)
                 .await?;
 
-        let retain_data_url = matches!(
-            *reference_type,
-            ReferenceType::Url(UrlReferenceSubType::CssUrl)
-        );
         let raw_result = match before_plugins_result {
             Some(result) => result,
             None => {
-                resolve_internal(lookup_path, request, options, retain_data_url)
+                resolve_internal(lookup_path, request, options)
                     .resolve()
                     .await?
             }
@@ -1761,16 +1757,14 @@ async fn resolve_internal(
     lookup_path: ResolvedVc<FileSystemPath>,
     request: ResolvedVc<Request>,
     options: ResolvedVc<ResolveOptions>,
-    retain_data_url: bool,
 ) -> Result<Vc<ResolveResult>> {
-    resolve_internal_inline(*lookup_path, *request, *options, retain_data_url).await
+    resolve_internal_inline(*lookup_path, *request, *options).await
 }
 
 async fn resolve_internal_inline(
     lookup_path: Vc<FileSystemPath>,
     request: Vc<Request>,
     options: Vc<ResolveOptions>,
-    retain_data_url: bool,
 ) -> Result<Vc<ResolveResult>> {
     let span = {
         let lookup_path = lookup_path.to_string().await?.to_string();
@@ -1825,9 +1819,7 @@ async fn resolve_internal_inline(
             Request::Alternatives { requests } => {
                 let results = requests
                     .iter()
-                    .map(|req| async {
-                        resolve_internal_inline(lookup_path, **req, options, retain_data_url).await
-                    })
+                    .map(|req| async { resolve_internal_inline(lookup_path, **req, options).await })
                     .try_join()
                     .await?;
 
@@ -1960,7 +1952,6 @@ async fn resolve_internal_inline(
                     lookup_path.root(),
                     relative,
                     options,
-                    retain_data_url,
                 ))
                 .await?
             }
@@ -2014,26 +2005,33 @@ async fn resolve_internal_inline(
                 encoding,
                 data,
             } => {
-                if !retain_data_url {
-                    *ResolveResult::primary(ResolveResultItem::Source(ResolvedVc::upcast(
-                        DataUriSource::new(
-                            media_type.clone(),
-                            encoding.clone(),
-                            **data,
-                            lookup_path,
-                        )
-                        .to_resolved()
-                        .await?,
-                    )))
+                // Behave like Request::Uri
+                let uri: RcStr = stringify_data_uri(media_type, encoding, *data)
+                    .await?
+                    .into();
+                if options.await?.parse_data_uris {
+                    *ResolveResult::primary_with_key(
+                        RequestKey::new(uri.clone()),
+                        ResolveResultItem::Source(ResolvedVc::upcast(
+                            DataUriSource::new(
+                                media_type.clone(),
+                                encoding.clone(),
+                                **data,
+                                lookup_path,
+                            )
+                            .to_resolved()
+                            .await?,
+                        )),
+                    )
                 } else {
-                    let uri: RcStr = stringify_data_uri(media_type, encoding, *data)
-                        .await?
-                        .into();
-                    *ResolveResult::primary(ResolveResultItem::External {
-                        name: uri,
-                        ty: ExternalType::Url,
-                        traced: ExternalTraced::Untraced,
-                    })
+                    *ResolveResult::primary_with_key(
+                        RequestKey::new(uri.clone()),
+                        ResolveResultItem::External {
+                            name: uri,
+                            ty: ExternalType::Url,
+                            traced: ExternalTraced::Untraced,
+                        },
+                    )
                 }
             }
             Request::Uri {
@@ -2127,10 +2125,9 @@ async fn resolve_into_folder(
                         } else {
                             options
                         };
-                        let result =
-                            &*resolve_internal_inline(*package_path, *request, options, false)
-                                .await?
-                                .await?;
+                        let result = &*resolve_internal_inline(*package_path, *request, options)
+                            .await?
+                            .await?;
                         // we are not that strict when a main field fails to resolve
                         // we continue to try other alternatives
                         if !result.is_unresolvable_ref() {
@@ -2166,11 +2163,9 @@ async fn resolve_into_folder(
 
     let request = Request::parse(Value::new(pattern));
 
-    Ok(
-        resolve_internal_inline(*package_path, request, options, false)
-            .await?
-            .with_request(".".into()),
-    )
+    Ok(resolve_internal_inline(*package_path, request, options)
+        .await?
+        .with_request(".".into()))
 }
 
 #[tracing::instrument(level = Level::TRACE, skip_all)]
@@ -2455,7 +2450,6 @@ async fn apply_in_package(
                         .with_query(query)
                         .with_fragment(fragment),
                     options,
-                    false,
                 )
                 .with_replaced_request_key(value.into(), Value::new(request_key))
                 .with_affecting_sources(refs.into_iter().map(|src| *src).collect()),
@@ -2628,13 +2622,8 @@ async fn resolve_module_request(
         let relative = Request::relative(Value::new(pattern), query, fragment, true)
             .to_resolved()
             .await?;
-        let relative_result = Box::pin(resolve_internal_inline(
-            lookup_path,
-            *relative,
-            options,
-            false,
-        ))
-        .await?;
+        let relative_result =
+            Box::pin(resolve_internal_inline(lookup_path, *relative, options)).await?;
         let relative_result = relative_result
             .with_replaced_request_key(module_prefix, Value::new(RequestKey::new(module.into())));
 
@@ -2720,7 +2709,7 @@ async fn resolve_into_package(
         let relative = Request::relative(Value::new(new_pat), query, fragment, true)
             .to_resolved()
             .await?;
-        results.push(resolve_internal_inline(*package_path, *relative, *options, false).await?);
+        results.push(resolve_internal_inline(*package_path, *relative, *options).await?);
     }
 
     Ok(merge_results(results))
@@ -2747,7 +2736,7 @@ async fn resolve_import_map_result(
             if request == original_request && lookup_path == original_lookup_path {
                 None
             } else {
-                let result = resolve_internal(lookup_path, request, options, false);
+                let result = resolve_internal(lookup_path, request, options);
                 Some(result.with_replaced_request_key_pattern(
                     request.request_pattern(),
                     original_request.request_pattern(),
@@ -2788,7 +2777,6 @@ async fn resolve_import_map_result(
                             node_esm_resolve_options(alias_lookup_path.root())
                         }
                     },
-                    false,
                 )
                 .await?
                 .is_unresolvable_ref();
@@ -2934,13 +2922,8 @@ async fn handle_exports_imports_field(
             .to_resolved()
             .await?;
 
-            let resolve_result = Box::pin(resolve_internal_inline(
-                package_path,
-                *request,
-                options,
-                false,
-            ))
-            .await?;
+            let resolve_result =
+                Box::pin(resolve_internal_inline(package_path, *request, options)).await?;
             if conditions.is_empty() {
                 resolved_results.push(resolve_result.with_request(path.into()));
             } else {

turbopack/crates/turbopack-core/src/resolve/options.rs

@@ -602,6 +602,8 @@ pub struct ResolveOptions {
     pub enable_typescript_with_output_extension: bool,
     /// Warn instead of error for resolve errors
     pub loose_errors: bool,
+    /// Whether to parse data URIs into modules (as opposed to keeping them as externals)
+    pub parse_data_uris: bool,
 
     pub placeholder_for_future_extensions: (),
 }

turbopack/crates/turbopack-resolve/src/ecmascript.rs

@@ -71,6 +71,8 @@ async fn apply_esm_specific_options_internal(
         options.extensions.clear();
     }
 
+    options.parse_data_uris = true;
+
     Ok(options.cell())
 }