turbopack_ecmascript/references/
typescript.rs

1use anyhow::Result;
2use turbo_rcstr::RcStr;
3use turbo_tasks::{ResolvedVc, ValueToString, Vc};
4use turbo_tasks_fs::FileSystemPath;
5use turbopack_core::{
6    chunk::{ChunkingType, TracedMode},
7    context::AssetContext,
8    file_source::FileSource,
9    reference::ModuleReference,
10    reference_type::{ReferenceType, TypeScriptReferenceSubType},
11    resolve::{ModuleResolveResult, origin::ResolveOrigin, parse::Request},
12};
13use turbopack_resolve::typescript::type_resolve;
14
15use crate::typescript::TsConfigModuleAsset;
16
17#[turbo_tasks::value]
18#[derive(Hash, Clone, Debug, ValueToString)]
19#[value_to_string("tsconfig {tsconfig}")]
20pub struct TsConfigReference {
21    pub tsconfig: FileSystemPath,
22    pub origin: ResolvedVc<Box<dyn ResolveOrigin>>,
23}
24
25#[turbo_tasks::value_impl]
26impl TsConfigReference {
27    #[turbo_tasks::function]
28    pub fn new(origin: ResolvedVc<Box<dyn ResolveOrigin>>, tsconfig: FileSystemPath) -> Vc<Self> {
29        Self::cell(TsConfigReference { tsconfig, origin })
30    }
31}
32
33#[turbo_tasks::value_impl]
34impl ModuleReference for TsConfigReference {
35    #[turbo_tasks::function]
36    async fn resolve_reference(&self) -> Result<Vc<ModuleResolveResult>> {
37        Ok(*ModuleResolveResult::module(ResolvedVc::upcast(
38            TsConfigModuleAsset::new(
39                *self.origin,
40                Vc::upcast(FileSource::new(self.tsconfig.clone())),
41            )
42            .to_resolved()
43            .await?,
44        )))
45    }
46
47    fn chunking_type(&self) -> Option<ChunkingType> {
48        Some(ChunkingType::Traced {
49            mode: TracedMode::Transitive,
50        })
51    }
52}
53
54#[turbo_tasks::value]
55#[derive(Hash, Debug, ValueToString)]
56#[value_to_string("typescript reference path comment {path}")]
57pub struct TsReferencePathAssetReference {
58    pub origin: ResolvedVc<Box<dyn ResolveOrigin>>,
59    pub path: RcStr,
60}
61
62#[turbo_tasks::value_impl]
63impl TsReferencePathAssetReference {
64    #[turbo_tasks::function]
65    pub fn new(origin: ResolvedVc<Box<dyn ResolveOrigin>>, path: RcStr) -> Vc<Self> {
66        Self::cell(TsReferencePathAssetReference { origin, path })
67    }
68}
69
70#[turbo_tasks::value_impl]
71impl ModuleReference for TsReferencePathAssetReference {
72    #[turbo_tasks::function]
73    async fn resolve_reference(&self) -> Result<Vc<ModuleResolveResult>> {
74        let origin = self.origin.into_trait_ref().await?;
75        Ok(
76            if let Some(path) = origin.origin_path().parent().try_join(&self.path) {
77                let module = origin
78                    .asset_context()
79                    .process(
80                        Vc::upcast(FileSource::new(path.clone())),
81                        ReferenceType::TypeScript(TypeScriptReferenceSubType::Undefined),
82                    )
83                    .module()
84                    .to_resolved()
85                    .await?;
86                *ModuleResolveResult::module(module)
87            } else {
88                *ModuleResolveResult::unresolvable()
89            },
90        )
91    }
92
93    fn chunking_type(&self) -> Option<ChunkingType> {
94        Some(ChunkingType::Traced {
95            mode: TracedMode::Transitive,
96        })
97    }
98}
99
100#[turbo_tasks::value]
101#[derive(Hash, Debug, ValueToString)]
102#[value_to_string("typescript reference type comment {module}")]
103pub struct TsReferenceTypeAssetReference {
104    pub origin: ResolvedVc<Box<dyn ResolveOrigin>>,
105    pub module: RcStr,
106}
107
108#[turbo_tasks::value_impl]
109impl TsReferenceTypeAssetReference {
110    #[turbo_tasks::function]
111    pub fn new(origin: ResolvedVc<Box<dyn ResolveOrigin>>, module: RcStr) -> Vc<Self> {
112        Self::cell(TsReferenceTypeAssetReference { origin, module })
113    }
114}
115
116#[turbo_tasks::value_impl]
117impl ModuleReference for TsReferenceTypeAssetReference {
118    #[turbo_tasks::function]
119    fn resolve_reference(&self) -> Vc<ModuleResolveResult> {
120        type_resolve(
121            *self.origin,
122            Request::module(
123                self.module.clone().into(),
124                RcStr::default().into(),
125                RcStr::default(),
126                RcStr::default(),
127            ),
128        )
129    }
130
131    fn chunking_type(&self) -> Option<ChunkingType> {
132        Some(ChunkingType::Traced {
133            mode: TracedMode::Transitive,
134        })
135    }
136}
turbopack_ecmascript/references/typescript.rs

turbopack_ecmascript/references/
typescript.rs
