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