File size: 3,483 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
use anyhow::Result;
use serde::{Deserialize, Serialize};
use swc_core::quote;
use turbo_rcstr::RcStr;
use turbo_tasks::{
NonLocalValue, ResolvedVc, ValueToString, Vc, debug::ValueDebugFormat, trace::TraceRawVcs,
};
use turbopack_core::{
chunk::{ChunkableModuleReference, ChunkingContext, ChunkingTypeOption, ModuleChunkItemIdExt},
reference::ModuleReference,
resolve::ModuleResolveResult,
};
use super::{EsmAssetReference, base::ReferencedAsset};
use crate::{
code_gen::{CodeGen, CodeGeneration, IntoCodeGenReference},
create_visitor,
references::AstPath,
utils::module_id_to_lit,
};
#[turbo_tasks::value]
#[derive(Hash, Debug)]
pub struct EsmModuleIdAssetReference {
inner: ResolvedVc<EsmAssetReference>,
}
impl EsmModuleIdAssetReference {
pub fn new(inner: ResolvedVc<EsmAssetReference>) -> Self {
EsmModuleIdAssetReference { inner }
}
}
#[turbo_tasks::value_impl]
impl ModuleReference for EsmModuleIdAssetReference {
#[turbo_tasks::function]
fn resolve_reference(&self) -> Vc<ModuleResolveResult> {
self.inner.resolve_reference()
}
}
#[turbo_tasks::value_impl]
impl ValueToString for EsmModuleIdAssetReference {
#[turbo_tasks::function]
async fn to_string(&self) -> Result<Vc<RcStr>> {
Ok(Vc::cell(
format!("module id of {}", self.inner.to_string().await?,).into(),
))
}
}
#[turbo_tasks::value_impl]
impl ChunkableModuleReference for EsmModuleIdAssetReference {
#[turbo_tasks::function]
fn chunking_type(&self) -> Vc<ChunkingTypeOption> {
self.inner.chunking_type()
}
}
impl IntoCodeGenReference for EsmModuleIdAssetReference {
fn into_code_gen_reference(
self,
path: AstPath,
) -> (ResolvedVc<Box<dyn ModuleReference>>, CodeGen) {
let reference = self.resolved_cell();
(
ResolvedVc::upcast(reference),
CodeGen::EsmModuleIdAssetReferenceCodeGen(EsmModuleIdAssetReferenceCodeGen {
reference,
path,
}),
)
}
}
#[derive(PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, ValueDebugFormat, NonLocalValue)]
pub struct EsmModuleIdAssetReferenceCodeGen {
path: AstPath,
reference: ResolvedVc<EsmModuleIdAssetReference>,
}
impl EsmModuleIdAssetReferenceCodeGen {
pub async fn code_generation(
&self,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<CodeGeneration> {
let mut visitors = Vec::new();
if let ReferencedAsset::Some(asset) =
&*self.reference.await?.inner.get_referenced_asset().await?
{
let id = asset.chunk_item_id(Vc::upcast(chunking_context)).await?;
let id = module_id_to_lit(&id);
visitors.push(create_visitor!(
self.path,
visit_mut_expr,
|expr: &mut Expr| {
*expr = id.clone();
}
));
} else {
// If the referenced asset can't be found, replace the expression with null.
// This can happen if the referenced asset is an external, or doesn't resolve
// to anything.
visitors.push(create_visitor!(
self.path,
visit_mut_expr,
|expr: &mut Expr| {
*expr = quote!("null" as Expr);
}
));
}
Ok(CodeGeneration::visitors(visitors))
}
}
|