turbopack_ecmascript/side_effect_optimization/facade/
chunk_item.rs

1use anyhow::Result;
2use turbo_tasks::{ResolvedVc, Vc};
3use turbopack_core::{
4    chunk::{AsyncModuleInfo, ChunkItem, ChunkType, ChunkingContext},
5    ident::AssetIdent,
6    module::Module,
7};
8
9use super::module::EcmascriptModuleFacadeModule;
10use crate::{
11    EcmascriptAnalyzable,
12    chunk::{
13        EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
14        EcmascriptChunkType,
15    },
16};
17
18/// The chunk item for [EcmascriptModuleFacadeModule].
19#[turbo_tasks::value(shared)]
20pub struct EcmascriptModuleFacadeChunkItem {
21    pub(crate) module: ResolvedVc<EcmascriptModuleFacadeModule>,
22    pub(crate) chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
23}
24
25#[turbo_tasks::value_impl]
26impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
27    #[turbo_tasks::function]
28    fn content(self: Vc<Self>) -> Vc<EcmascriptChunkItemContent> {
29        panic!("content() should never be called");
30    }
31
32    #[turbo_tasks::function]
33    fn content_with_async_module_info(
34        &self,
35        async_module_info: Option<Vc<AsyncModuleInfo>>,
36    ) -> Result<Vc<EcmascriptChunkItemContent>> {
37        let chunking_context = self.chunking_context;
38
39        let content = self
40            .module
41            .module_content(*chunking_context, async_module_info);
42
43        let async_module_options = self
44            .module
45            .get_async_module()
46            .module_options(async_module_info);
47
48        Ok(EcmascriptChunkItemContent::new(
49            content,
50            *chunking_context,
51            async_module_options,
52        ))
53    }
54}
55
56#[turbo_tasks::value_impl]
57impl ChunkItem for EcmascriptModuleFacadeChunkItem {
58    #[turbo_tasks::function]
59    fn asset_ident(&self) -> Vc<AssetIdent> {
60        self.module.ident()
61    }
62
63    #[turbo_tasks::function]
64    fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
65        *ResolvedVc::upcast(self.chunking_context)
66    }
67
68    #[turbo_tasks::function]
69    async fn ty(&self) -> Result<Vc<Box<dyn ChunkType>>> {
70        Ok(Vc::upcast(
71            Vc::<EcmascriptChunkType>::default().resolve().await?,
72        ))
73    }
74
75    #[turbo_tasks::function]
76    fn module(&self) -> Vc<Box<dyn Module>> {
77        *ResolvedVc::upcast(self.module)
78    }
79}