Unverified Commit 6344e18a authored by Luke Sandberg's avatar Luke Sandberg Committed by GitHub

Turbopack: extract inline base64 decode helper to shared `@turbopack/base64` module (#92549)

### What?

When Turbopack generates a module using `import foo from './blah' with {type:'bytes'}`, it needs a base64 decode helper. Previously this was inlined into every generated module. This PR extracts it to a shared `@turbopack/base64` module imported via a special import map, and encapsulates the import map registration inside the turbopack crate itself.

### Why?

1. **Deduplication** — The base64 decode helper is shared across all `{type:'bytes'}` imports instead of being duplicated inline in every generated module.
2. **Encapsulation** — The `@turbopack/*` and `@vercel/turbopack-ecmascript-runtime/*` import map aliases are now injected automatically by `ModuleAssetContext::resolve_options` in the turbopack crate. Consumers (next-core, turbopack-cli) no longer need to manually register these aliases in their import maps.
3. **Extensibility** — Future turbopack built-in modules can be added to a single `turbopack_runtime_import_map()` function, with no changes needed in any consumer.

### How?

**Base64 module (`turbopack-ecmascript-runtime`):**
- Added `turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/base64.ts` with `base64Decode()` using ES2024 `Uint8Array.fromBase64` with an `atob()`-based fallback.
- The ES2024 feature check is evaluated once at module load time (top-level const), not per-call.
- The module is marked `"use turbopack no side effects"` for tree-shaking.

**BytesSourceTransform (`turbopack-ecmascript`):**
- Changed `BytesSourceTransform` to emit `import { base64Decode } from '@turbopack/base64'` instead of inlining the helper.

**Import map encapsulation (cycle-breaking refactor):**
- Moved `get_runtime_asset_context` from `turbopack-ecmascript-runtime` → `turbopack` crate, breaking the cyclic dependency so turbopack can now depend on `turbopack-ecmascript-runtime`.
- Changed `get_nodejs_runtime_code` and `get_browser_runtime_code` to accept an `AssetContext` parameter instead of constructing one internally.
- Added `turbopack_runtime_import_map()` to `turbopack-ecmascript-runtime` containing both the `@vercel/turbopack-ecmascript-runtime/*` wildcard and `@turbopack/base64` exact aliases.
- `ModuleAssetContext::resolve_options` now injects this import map automatically.
- Removed `insert_turbopack_dev_alias` from `next-core` and the equivalent block from `turbopack-cli`.

<!-- NEXT_JS_LLM_PR -->
parent e9150cad
...@@ -10171,6 +10171,7 @@ dependencies = [ ...@@ -10171,6 +10171,7 @@ dependencies = [
"turbopack-core", "turbopack-core",
"turbopack-css", "turbopack-css",
"turbopack-ecmascript", "turbopack-ecmascript",
"turbopack-ecmascript-runtime",
"turbopack-env", "turbopack-env",
"turbopack-mdx", "turbopack-mdx",
"turbopack-node", "turbopack-node",
...@@ -10241,6 +10242,7 @@ dependencies = [ ...@@ -10241,6 +10242,7 @@ dependencies = [
"turbo-tasks", "turbo-tasks",
"turbo-tasks-fs", "turbo-tasks-fs",
"turbo-tasks-hash", "turbo-tasks-hash",
"turbopack",
"turbopack-core", "turbopack-core",
"turbopack-ecmascript", "turbopack-ecmascript",
"turbopack-ecmascript-runtime", "turbopack-ecmascript-runtime",
...@@ -10529,7 +10531,6 @@ dependencies = [ ...@@ -10529,7 +10531,6 @@ dependencies = [
"turbo-rcstr", "turbo-rcstr",
"turbo-tasks", "turbo-tasks",
"turbo-tasks-fs", "turbo-tasks-fs",
"turbopack",
"turbopack-core", "turbopack-core",
"turbopack-ecmascript", "turbopack-ecmascript",
] ]
...@@ -10667,6 +10668,7 @@ dependencies = [ ...@@ -10667,6 +10668,7 @@ dependencies = [
"turbo-tasks", "turbo-tasks",
"turbo-tasks-fs", "turbo-tasks-fs",
"turbo-tasks-hash", "turbo-tasks-hash",
"turbopack",
"turbopack-core", "turbopack-core",
"turbopack-ecmascript", "turbopack-ecmascript",
"turbopack-ecmascript-runtime", "turbopack-ecmascript-runtime",
......
...@@ -232,7 +232,6 @@ pub async fn get_next_client_import_map( ...@@ -232,7 +232,6 @@ pub async fn get_next_client_import_map(
ClientContextType::Other => {} ClientContextType::Other => {}
} }
insert_turbopack_dev_alias(&mut import_map).await?;
insert_instrumentation_client_alias(&mut import_map, project_path).await?; insert_instrumentation_client_alias(&mut import_map, project_path).await?;
insert_server_only_error_alias(&mut import_map); insert_server_only_error_alias(&mut import_map);
...@@ -264,8 +263,6 @@ pub async fn get_next_client_fallback_import_map(ty: ClientContextType) -> Resul ...@@ -264,8 +263,6 @@ pub async fn get_next_client_fallback_import_map(ty: ClientContextType) -> Resul
ClientContextType::Other => {} ClientContextType::Other => {}
} }
insert_turbopack_dev_alias(&mut import_map).await?;
Ok(import_map.cell()) Ok(import_map.cell())
} }
...@@ -1188,7 +1185,6 @@ async fn insert_next_shared_aliases( ...@@ -1188,7 +1185,6 @@ async fn insert_next_shared_aliases(
), ),
); );
insert_turbopack_dev_alias(import_map).await?;
insert_package_alias( insert_package_alias(
import_map, import_map,
"@vercel/turbopack-node/", "@vercel/turbopack-node/",
...@@ -1407,19 +1403,6 @@ fn insert_package_alias(import_map: &mut ImportMap, prefix: &str, package_root: ...@@ -1407,19 +1403,6 @@ fn insert_package_alias(import_map: &mut ImportMap, prefix: &str, package_root:
); );
} }
/// Inserts an alias to @vercel/turbopack-dev into an import map.
async fn insert_turbopack_dev_alias(import_map: &mut ImportMap) -> Result<()> {
insert_package_alias(
import_map,
"@vercel/turbopack-ecmascript-runtime/",
turbopack_ecmascript_runtime::embed_fs()
.root()
.owned()
.await?,
);
Ok(())
}
/// Handles instrumentation-client.ts bundling logic /// Handles instrumentation-client.ts bundling logic
async fn insert_instrumentation_client_alias( async fn insert_instrumentation_client_alias(
import_map: &mut ImportMap, import_map: &mut ImportMap,
......
...@@ -34,6 +34,7 @@ turbo-rcstr = { workspace = true } ...@@ -34,6 +34,7 @@ turbo-rcstr = { workspace = true }
turbo-tasks = { workspace = true } turbo-tasks = { workspace = true }
turbo-tasks-fs = { workspace = true } turbo-tasks-fs = { workspace = true }
turbo-tasks-hash = { workspace = true } turbo-tasks-hash = { workspace = true }
turbopack = { workspace = true }
turbopack-core = { workspace = true } turbopack-core = { workspace = true }
turbopack-ecmascript = { workspace = true } turbopack-ecmascript = { workspace = true }
turbopack-ecmascript-runtime = { workspace = true } turbopack-ecmascript-runtime = { workspace = true }
......
...@@ -171,11 +171,13 @@ impl EcmascriptBrowserEvaluateChunk { ...@@ -171,11 +171,13 @@ impl EcmascriptBrowserEvaluateChunk {
params = StringifyJs(&params), params = StringifyJs(&params),
)?; )?;
let asset_context = turbopack::get_runtime_asset_context(environment);
let runtime_type = *this.chunking_context.runtime_type().await?; let runtime_type = *this.chunking_context.runtime_type().await?;
match runtime_type { match runtime_type {
RuntimeType::Production | RuntimeType::Development => { RuntimeType::Production | RuntimeType::Development => {
let runtime_code = turbopack_ecmascript_runtime::get_browser_runtime_code( let runtime_code = turbopack_ecmascript_runtime::get_browser_runtime_code(
environment, asset_context,
this.chunking_context.chunk_base_path(), this.chunking_context.chunk_base_path(),
this.chunking_context.asset_suffix(), this.chunking_context.asset_suffix(),
this.chunking_context.worker_forwarded_globals(), this.chunking_context.worker_forwarded_globals(),
......
...@@ -3,7 +3,7 @@ use std::fmt; ...@@ -3,7 +3,7 @@ use std::fmt;
use anyhow::Result; use anyhow::Result;
use turbo_rcstr::{RcStr, rcstr}; use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, Vc}; use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::{FileSystem, FileSystemPath}; use turbo_tasks_fs::FileSystemPath;
use turbopack::{ use turbopack::{
ModuleAssetContext, ModuleAssetContext,
module_options::{ module_options::{
...@@ -21,7 +21,7 @@ use turbopack_core::{ ...@@ -21,7 +21,7 @@ use turbopack_core::{
environment::{BrowserEnvironment, Environment, ExecutionEnvironment}, environment::{BrowserEnvironment, Environment, ExecutionEnvironment},
free_var_references, free_var_references,
ident::Layer, ident::Layer,
resolve::options::{ImportMap, ImportMapping}, resolve::options::ImportMap,
}; };
use turbopack_ecmascript::TreeShakingMode; use turbopack_ecmascript::TreeShakingMode;
use turbopack_node::{ use turbopack_node::{
...@@ -57,20 +57,6 @@ pub async fn get_client_import_map(project_path: FileSystemPath) -> Result<Vc<Im ...@@ -57,20 +57,6 @@ pub async fn get_client_import_map(project_path: FileSystemPath) -> Result<Vc<Im
import_map.insert_singleton_alias(rcstr!("react"), project_path.clone()); import_map.insert_singleton_alias(rcstr!("react"), project_path.clone());
import_map.insert_singleton_alias(rcstr!("react-dom"), project_path.clone()); import_map.insert_singleton_alias(rcstr!("react-dom"), project_path.clone());
import_map.insert_wildcard_alias(
rcstr!("@vercel/turbopack-ecmascript-runtime/"),
ImportMapping::PrimaryAlternative(
rcstr!("./*"),
Some(
turbopack_ecmascript_runtime::embed_fs()
.root()
.owned()
.await?,
),
)
.resolved_cell(),
);
Ok(import_map.cell()) Ok(import_map.cell())
} }
......
...@@ -26,6 +26,5 @@ serde = { workspace = true } ...@@ -26,6 +26,5 @@ serde = { workspace = true }
turbo-rcstr = { workspace = true } turbo-rcstr = { workspace = true }
turbo-tasks = { workspace = true } turbo-tasks = { workspace = true }
turbo-tasks-fs = { workspace = true } turbo-tasks-fs = { workspace = true }
turbopack = { workspace = true }
turbopack-core = { workspace = true } turbopack-core = { workspace = true }
turbopack-ecmascript = { workspace = true } turbopack-ecmascript = { workspace = true }
'use turbopack no side effects'
// Evaluate the ES2024 feature check once at module load time.
const _fromBase64: ((s: string) => Uint8Array) | null =
typeof (Uint8Array as any).fromBase64 === 'function'
? (Uint8Array as any).fromBase64
: null
/**
* Decodes a base64 string to a Uint8Array.
*
* Prefers `Uint8Array.fromBase64` (ES2024) as a fast native path,
* with an `atob()`-based fallback for older environments.
*/
export function base64Decode(base64: string): Uint8Array {
if (_fromBase64 !== null) {
return _fromBase64(base64)
}
const binaryString = atob(base64)
const buffer = new Uint8Array(binaryString.length)
for (let i = 0; i < binaryString.length; i++) {
buffer[i] = binaryString.charCodeAt(i)
}
return buffer
}
...@@ -8,16 +8,16 @@ use turbopack_core::{ ...@@ -8,16 +8,16 @@ use turbopack_core::{
chunk::AssetSuffix, chunk::AssetSuffix,
code_builder::{Code, CodeBuilder}, code_builder::{Code, CodeBuilder},
context::AssetContext, context::AssetContext,
environment::{ChunkLoading, Environment}, environment::ChunkLoading,
}; };
use turbopack_ecmascript::utils::StringifyJs; use turbopack_ecmascript::utils::StringifyJs;
use crate::{RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code}; use crate::{RuntimeType, embed_js::embed_static_code};
/// Returns the code for the ECMAScript runtime. /// Returns the code for the ECMAScript runtime.
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn get_browser_runtime_code( pub async fn get_browser_runtime_code(
environment: ResolvedVc<Environment>, asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunk_base_path: Vc<Option<RcStr>>, chunk_base_path: Vc<Option<RcStr>>,
asset_suffix: Vc<AssetSuffix>, asset_suffix: Vc<AssetSuffix>,
worker_forwarded_globals: Vc<Vec<RcStr>>, worker_forwarded_globals: Vc<Vec<RcStr>>,
...@@ -26,9 +26,8 @@ pub async fn get_browser_runtime_code( ...@@ -26,9 +26,8 @@ pub async fn get_browser_runtime_code(
generate_source_map: bool, generate_source_map: bool,
chunk_loading_global: Vc<RcStr>, chunk_loading_global: Vc<RcStr>,
) -> Result<Vc<Code>> { ) -> Result<Vc<Code>> {
let asset_context = *get_runtime_asset_context(*environment) let asset_context = *asset_context;
.to_resolved() let environment = asset_context.compile_time_info().environment();
.await?;
let shared_runtime_utils_code = embed_static_code( let shared_runtime_utils_code = embed_static_code(
asset_context, asset_context,
......
use anyhow::Result; use anyhow::Result;
use turbo_rcstr::RcStr; use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::Vc; use turbo_tasks::Vc;
use turbo_tasks_fs::{FileContent, FileSystem, FileSystemPath, embed_directory}; use turbo_tasks_fs::{FileContent, FileSystem, FileSystemPath, embed_directory};
use turbopack_core::{code_builder::Code, context::AssetContext}; use turbopack_core::{
code_builder::Code,
context::AssetContext,
resolve::options::{ImportMap, ImportMapping},
};
use turbopack_ecmascript::StaticEcmascriptCode; use turbopack_ecmascript::StaticEcmascriptCode;
#[turbo_tasks::function] #[turbo_tasks::function]
...@@ -33,3 +37,36 @@ pub async fn embed_static_code( ...@@ -33,3 +37,36 @@ pub async fn embed_static_code(
) )
.code()) .code())
} }
/// Returns an [ImportMap] containing:
/// - The `@vercel/turbopack-ecmascript-runtime/*` wildcard alias pointing to the embedded runtime
/// filesystem.
/// - All built-in `@turbopack/*` module aliases (e.g. `@turbopack/base64`).
///
/// This import map is injected automatically by
/// [`ModuleAssetContext::resolve_options`] so that every Turbopack-processed
/// module can resolve these paths without per-consumer configuration.
///
/// As more parts of the turbopack runtime are extracted into importable
/// modules they should be added here.
#[turbo_tasks::function]
pub async fn turbopack_runtime_import_map() -> Result<Vc<ImportMap>> {
let embed_root = embed_fs().root().owned().await?;
let mut import_map = ImportMap::default();
// Wildcard alias: @vercel/turbopack-ecmascript-runtime/* -> embedded fs
import_map.insert_wildcard_alias(
rcstr!("@vercel/turbopack-ecmascript-runtime/"),
ImportMapping::PrimaryAlternative(rcstr!("./*"), Some(embed_root.clone())).resolved_cell(),
);
// Exact alias: @turbopack/base64
import_map.insert_exact_alias(
rcstr!("@turbopack/base64"),
ImportMapping::PrimaryAlternative(rcstr!("./shared/base64.ts"), Some(embed_root))
.resolved_cell(),
);
Ok(import_map.cell())
}
#![feature(arbitrary_self_types)] #![feature(arbitrary_self_types)]
#![feature(arbitrary_self_types_pointers)] #![feature(arbitrary_self_types_pointers)]
pub(crate) mod asset_context;
pub(crate) mod browser_runtime; pub(crate) mod browser_runtime;
#[cfg(feature = "test")] #[cfg(feature = "test")]
pub(crate) mod dummy_runtime; pub(crate) mod dummy_runtime;
...@@ -12,6 +11,6 @@ pub(crate) mod runtime_type; ...@@ -12,6 +11,6 @@ pub(crate) mod runtime_type;
pub use browser_runtime::{get_browser_runtime_code, get_worker_runtime_code}; pub use browser_runtime::{get_browser_runtime_code, get_worker_runtime_code};
#[cfg(feature = "test")] #[cfg(feature = "test")]
pub use dummy_runtime::get_dummy_runtime_code; pub use dummy_runtime::get_dummy_runtime_code;
pub use embed_js::{embed_file, embed_file_path, embed_fs}; pub use embed_js::{embed_file, embed_file_path, embed_fs, turbopack_runtime_import_map};
pub use nodejs_runtime::get_nodejs_runtime_code; pub use nodejs_runtime::get_nodejs_runtime_code;
pub use runtime_type::RuntimeType; pub use runtime_type::RuntimeType;
...@@ -3,21 +3,19 @@ use turbo_rcstr::rcstr; ...@@ -3,21 +3,19 @@ use turbo_rcstr::rcstr;
use turbo_tasks::{ResolvedVc, Vc}; use turbo_tasks::{ResolvedVc, Vc};
use turbopack_core::{ use turbopack_core::{
code_builder::{Code, CodeBuilder}, code_builder::{Code, CodeBuilder},
environment::Environment, context::AssetContext,
}; };
use crate::{RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code}; use crate::{RuntimeType, embed_js::embed_static_code};
/// Returns the code for the Node.js ECMAScript runtime. /// Returns the code for the Node.js ECMAScript runtime.
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn get_nodejs_runtime_code( pub async fn get_nodejs_runtime_code(
environment: ResolvedVc<Environment>, asset_context: ResolvedVc<Box<dyn AssetContext>>,
runtime_type: RuntimeType, runtime_type: RuntimeType,
generate_source_map: bool, generate_source_map: bool,
) -> Result<Vc<Code>> { ) -> Result<Vc<Code>> {
let asset_context = *get_runtime_asset_context(*environment) let asset_context = *asset_context;
.to_resolved()
.await?;
let shared_runtime_utils_code = embed_static_code( let shared_runtime_utils_code = embed_static_code(
asset_context, asset_context,
......
...@@ -51,21 +51,10 @@ impl SourceTransform for BytesSourceTransform { ...@@ -51,21 +51,10 @@ impl SourceTransform for BytesSourceTransform {
let encoded = data_encoding::BASE64_NOPAD.encode(&bytes); let encoded = data_encoding::BASE64_NOPAD.encode(&bytes);
// Generate ES module that decodes base64 to Uint8Array with inline source map. // Generate ES module that decodes base64 to Uint8Array with inline source map.
// Uses Uint8Array.fromBase64 (ES2024+) with atob fallback for older environments.
let code = format!( let code = format!(
r#" r#""use turbopack no side effects";
"use turbopack no side effects"; import {{ base64Decode }} from '@turbopack/base64';
export default base64Decode({});
const decode = Uint8Array.fromBase64 || function(base64) {{
const binaryString = atob(base64);
const buffer = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {{
buffer[i] = binaryString.charCodeAt(i)
}}
return buffer
}};
export default decode({});
{}"#, {}"#,
StringifyJs(&encoded), StringifyJs(&encoded),
// For binary files, we use an empty string as sourcesContent since the // For binary files, we use an empty string as sourcesContent since the
......
...@@ -33,6 +33,7 @@ turbo-rcstr = { workspace = true } ...@@ -33,6 +33,7 @@ turbo-rcstr = { workspace = true }
turbo-tasks = { workspace = true } turbo-tasks = { workspace = true }
turbo-tasks-fs = { workspace = true } turbo-tasks-fs = { workspace = true }
turbo-tasks-hash = { workspace = true } turbo-tasks-hash = { workspace = true }
turbopack = { workspace = true }
turbopack-core = { workspace = true } turbopack-core = { workspace = true }
turbopack-ecmascript = { workspace = true } turbopack-ecmascript = { workspace = true }
turbopack-ecmascript-runtime = { workspace = true } turbopack-ecmascript-runtime = { workspace = true }
......
...@@ -97,10 +97,13 @@ impl EcmascriptBuildNodeRuntimeChunk { ...@@ -97,10 +97,13 @@ impl EcmascriptBuildNodeRuntimeChunk {
)?; )?;
} }
let asset_context =
turbopack::get_runtime_asset_context(this.chunking_context.environment());
match *this.chunking_context.runtime_type().await? { match *this.chunking_context.runtime_type().await? {
RuntimeType::Development => { RuntimeType::Development => {
let runtime_code = turbopack_ecmascript_runtime::get_nodejs_runtime_code( let runtime_code = turbopack_ecmascript_runtime::get_nodejs_runtime_code(
this.chunking_context.environment(), asset_context,
RuntimeType::Development, RuntimeType::Development,
generate_source_map, generate_source_map,
); );
...@@ -108,7 +111,7 @@ impl EcmascriptBuildNodeRuntimeChunk { ...@@ -108,7 +111,7 @@ impl EcmascriptBuildNodeRuntimeChunk {
} }
RuntimeType::Production => { RuntimeType::Production => {
let runtime_code = turbopack_ecmascript_runtime::get_nodejs_runtime_code( let runtime_code = turbopack_ecmascript_runtime::get_nodejs_runtime_code(
this.chunking_context.environment(), asset_context,
RuntimeType::Production, RuntimeType::Production,
generate_source_map, generate_source_map,
); );
......
...@@ -33,6 +33,7 @@ turbo-tasks-hash = { workspace = true } ...@@ -33,6 +33,7 @@ turbo-tasks-hash = { workspace = true }
turbopack-core = { workspace = true } turbopack-core = { workspace = true }
turbopack-css = { workspace = true } turbopack-css = { workspace = true }
turbopack-ecmascript = { workspace = true } turbopack-ecmascript = { workspace = true }
turbopack-ecmascript-runtime = { workspace = true }
turbopack-env = { workspace = true } turbopack-env = { workspace = true }
turbopack-mdx = { workspace = true } turbopack-mdx = { workspace = true }
turbopack-node = { workspace = true, default-features = false } turbopack-node = { workspace = true, default-features = false }
......
...@@ -7,12 +7,14 @@ ...@@ -7,12 +7,14 @@
pub mod evaluate_context; pub mod evaluate_context;
pub mod global_module_ids; pub mod global_module_ids;
pub mod module_options; pub mod module_options;
pub mod runtime_asset_context;
pub mod transition; pub mod transition;
use anyhow::{Context as _, Result, bail}; use anyhow::{Context as _, Result, bail};
use module_options::{ use module_options::{
ConfiguredModuleType, ModuleOptions, ModuleOptionsContext, ModuleRuleEffect, ModuleType, ConfiguredModuleType, ModuleOptions, ModuleOptionsContext, ModuleRuleEffect, ModuleType,
}; };
pub use runtime_asset_context::get_runtime_asset_context;
use tracing::{Instrument, field::Empty}; use tracing::{Instrument, field::Empty};
use turbo_rcstr::{RcStr, rcstr}; use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, TryJoinIterExt, ValueToString, Vc}; use turbo_tasks::{ResolvedVc, TryJoinIterExt, ValueToString, Vc};
...@@ -991,10 +993,17 @@ impl AssetContext for ModuleAssetContext { ...@@ -991,10 +993,17 @@ impl AssetContext for ModuleAssetContext {
self self
}; };
// TODO move `apply_commonjs/esm_resolve_options` etc. to here // TODO move `apply_commonjs/esm_resolve_options` etc. to here
Ok(resolve_options( let options = resolve_options(
origin_path.parent(), origin_path.parent(),
*module_asset_context.await?.resolve_options_context, *module_asset_context.await?.resolve_options_context,
)) );
// Inject the turbopack-ecmascript-runtime import map so that
// @turbopack/* built-in modules and @vercel/turbopack-ecmascript-runtime/*
// paths are always resolvable.
let runtime_import_map = turbopack_ecmascript_runtime::turbopack_runtime_import_map()
.to_resolved()
.await?;
Ok(options.with_extended_import_map(*runtime_import_map))
} }
#[turbo_tasks::function] #[turbo_tasks::function]
......
use turbo_rcstr::rcstr; use turbo_rcstr::rcstr;
use turbo_tasks::{ResolvedVc, Result, Vc}; use turbo_tasks::{ResolvedVc, Result, Vc};
use turbopack::{
ModuleAssetContext,
module_options::{EcmascriptOptionsContext, ModuleOptionsContext, TypescriptTransformOptions},
};
use turbopack_core::{ use turbopack_core::{
compile_time_info::CompileTimeInfo, context::AssetContext, environment::Environment, compile_time_info::CompileTimeInfo, context::AssetContext, environment::Environment,
ident::Layer, ident::Layer,
}; };
use turbopack_ecmascript::TreeShakingMode; use turbopack_ecmascript::TreeShakingMode;
/// Returns the runtime asset context to use to process runtime code assets. use crate::{
ModuleAssetContext,
module_options::{EcmascriptOptionsContext, ModuleOptionsContext, TypescriptTransformOptions},
};
/// Returns the runtime asset context used to compile embedded runtime
/// TypeScript files (e.g. the turbopack-ecmascript-runtime JS sources).
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn get_runtime_asset_context( pub async fn get_runtime_asset_context(
environment: ResolvedVc<Environment>, environment: ResolvedVc<Environment>,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment