1use std::collections::HashMap;
2use std::{env, fs};
3
4use serde::Deserialize;
5use zed_extension_api::{self as zed, serde_json, Result};
6
7const SERVER_PATH: &str = "node_modules/@astrojs/language-server/bin/nodeServer.js";
8const PACKAGE_NAME: &str = "@astrojs/language-server";
9
10const TYPESCRIPT_PACKAGE_NAME: &str = "typescript";
11
12/// The relative path to TypeScript's SDK.
13const TYPESCRIPT_TSDK_PATH: &str = "node_modules/typescript/lib";
14
15#[derive(Debug, Deserialize)]
16#[serde(rename_all = "camelCase")]
17struct PackageJson {
18 #[serde(default)]
19 dependencies: HashMap<String, String>,
20 #[serde(default)]
21 dev_dependencies: HashMap<String, String>,
22}
23
24struct AstroExtension {
25 did_find_server: bool,
26 typescript_tsdk_path: String,
27}
28
29impl AstroExtension {
30 fn server_exists(&self) -> bool {
31 fs::metadata(SERVER_PATH).map_or(false, |stat| stat.is_file())
32 }
33
34 fn server_script_path(
35 &mut self,
36 language_server_id: &zed::LanguageServerId,
37 worktree: &zed::Worktree,
38 ) -> Result<String> {
39 let server_exists = self.server_exists();
40 if self.did_find_server && server_exists {
41 self.install_typescript_if_needed(worktree)?;
42 return Ok(SERVER_PATH.to_string());
43 }
44
45 zed::set_language_server_installation_status(
46 language_server_id,
47 &zed::LanguageServerInstallationStatus::CheckingForUpdate,
48 );
49 let version = zed::npm_package_latest_version(PACKAGE_NAME)?;
50
51 if !server_exists
52 || zed::npm_package_installed_version(PACKAGE_NAME)?.as_ref() != Some(&version)
53 {
54 zed::set_language_server_installation_status(
55 language_server_id,
56 &zed::LanguageServerInstallationStatus::Downloading,
57 );
58 let result = zed::npm_install_package(PACKAGE_NAME, &version);
59 match result {
60 Ok(()) => {
61 if !self.server_exists() {
62 Err(format!(
63 "installed package '{PACKAGE_NAME}' did not contain expected path '{SERVER_PATH}'",
64 ))?;
65 }
66 }
67 Err(error) => {
68 if !self.server_exists() {
69 Err(error)?;
70 }
71 }
72 }
73 }
74
75 self.install_typescript_if_needed(worktree)?;
76 self.did_find_server = true;
77 Ok(SERVER_PATH.to_string())
78 }
79
80 /// Returns whether a local copy of TypeScript exists in the worktree.
81 fn typescript_exists_for_worktree(&self, worktree: &zed::Worktree) -> Result<bool> {
82 let package_json = worktree.read_text_file("package.json")?;
83 let package_json: PackageJson = serde_json::from_str(&package_json)
84 .map_err(|err| format!("failed to parse package.json: {err}"))?;
85
86 let dev_dependencies = &package_json.dev_dependencies;
87 let dependencies = &package_json.dependencies;
88
89 // Since the extension is not allowed to read the filesystem within the project
90 // except through the worktree (which does not contains `node_modules`), we check
91 // the `package.json` to see if `typescript` is listed in the dependencies.
92 Ok(dev_dependencies.contains_key(TYPESCRIPT_PACKAGE_NAME)
93 || dependencies.contains_key(TYPESCRIPT_PACKAGE_NAME))
94 }
95
96 fn install_typescript_if_needed(&mut self, worktree: &zed::Worktree) -> Result<()> {
97 if self
98 .typescript_exists_for_worktree(worktree)
99 .unwrap_or_default()
100 {
101 println!("found local TypeScript installation at '{TYPESCRIPT_TSDK_PATH}'");
102 return Ok(());
103 }
104
105 let installed_typescript_version =
106 zed::npm_package_installed_version(TYPESCRIPT_PACKAGE_NAME)?;
107 let latest_typescript_version = zed::npm_package_latest_version(TYPESCRIPT_PACKAGE_NAME)?;
108
109 if installed_typescript_version.as_ref() != Some(&latest_typescript_version) {
110 println!("installing {TYPESCRIPT_PACKAGE_NAME}@{latest_typescript_version}");
111 zed::npm_install_package(TYPESCRIPT_PACKAGE_NAME, &latest_typescript_version)?;
112 } else {
113 println!("typescript already installed");
114 }
115
116 self.typescript_tsdk_path = env::current_dir()
117 .unwrap()
118 .join(TYPESCRIPT_TSDK_PATH)
119 .to_string_lossy()
120 .to_string();
121
122 Ok(())
123 }
124}
125
126impl zed::Extension for AstroExtension {
127 fn new() -> Self {
128 Self {
129 did_find_server: false,
130 typescript_tsdk_path: TYPESCRIPT_TSDK_PATH.to_owned(),
131 }
132 }
133
134 fn language_server_command(
135 &mut self,
136 language_server_id: &zed::LanguageServerId,
137 worktree: &zed::Worktree,
138 ) -> Result<zed::Command> {
139 let server_path = self.server_script_path(language_server_id, worktree)?;
140 Ok(zed::Command {
141 command: zed::node_binary_path()?,
142 args: vec![
143 env::current_dir()
144 .unwrap()
145 .join(&server_path)
146 .to_string_lossy()
147 .to_string(),
148 "--stdio".to_string(),
149 ],
150 env: Default::default(),
151 })
152 }
153
154 fn language_server_initialization_options(
155 &mut self,
156 _language_server_id: &zed::LanguageServerId,
157 _worktree: &zed::Worktree,
158 ) -> Result<Option<serde_json::Value>> {
159 Ok(Some(serde_json::json!({
160 "provideFormatter": true,
161 "typescript": {
162 "tsdk": self.typescript_tsdk_path
163 }
164 })))
165 }
166}
167
168zed::register_extension!(AstroExtension);