oxc-zed 0.4.3

Oxc Zed Extension
Documentation 
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

use crate::lsp::ZedLspSupport;
use log::debug;
use std::path::{Path, PathBuf};
use zed_extension_api::serde_json::Value;
use zed_extension_api::settings::LspSettings;
use zed_extension_api::{Command, EnvVars, LanguageServerId, Result, Worktree, node_binary_path};

pub struct ZedOxlintLsp {}

impl ZedOxlintLsp {
    pub fn new() -> Self {
        ZedOxlintLsp {}
    }
}

impl ZedLspSupport for ZedOxlintLsp {
    fn get_package_name(&self) -> String {
        "oxlint".to_string()
    }

    fn language_server_command(
        &self,
        language_server_id: &LanguageServerId,
        worktree: &Worktree,
    ) -> Result<Command> {
        let settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
        debug!("Oxlint language_server_command LspSettings: {settings:?}");

        let mut args = vec![
            self.get_resolved_exe_path(worktree)?
                .to_string_lossy()
                .to_string(),
            "--lsp".to_string(),
        ];
        let mut command = node_binary_path()?;
        let mut env = EnvVars::default();
        if let Some(binary) = settings.binary {
            if (binary.path.is_some() && binary.arguments.is_none())
                || (binary.path.is_none() && binary.arguments.is_some())
            {
                return Err(
                    "When supplying binary.arguments, binary.path must be supplied (or vice-versa).".to_string(),
                );
            }

            if binary.arguments.is_some() {
                args = binary.arguments.unwrap();
            }
            if binary.path.is_some() {
                command = binary.path.unwrap();
            }
            env = normalize_env(binary.env, worktree)?;
        }

        Ok(Command { command, args, env })
    }

    fn language_server_initialization_options(
        &self,
        language_server_id: &LanguageServerId,
        worktree: &Worktree,
    ) -> Result<Option<Value>> {
        let settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
        debug!("Oxlint language_server_initialization_options LspSettings: {settings:?}");

        Ok(settings.initialization_options)
    }

    fn language_server_workspace_configuration(
        &self,
        language_server_id: &LanguageServerId,
        worktree: &Worktree,
    ) -> Result<Option<Value>> {
        let settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
        debug!("Oxfmt language_server_workspace_configuration LspSettings: {settings:?}");

        Ok(settings
            .initialization_options
            .as_ref()
            .and_then(|v| v.get("settings").cloned()))
    }
}

#[expect(clippy::disallowed_types, reason = "HashMap comes from Zed API")]
fn normalize_env(
    env_map: Option<std::collections::HashMap<String, String>>,
    worktree: &Worktree,
) -> Result<EnvVars> {
    let mut env = env_map.unwrap_or_default();
    if let Some(tsgolint_path) = env.get_mut("OXLINT_TSGOLINT_PATH") {
        let path_buf = PathBuf::from(tsgolint_path.as_str());

        let resolved = if path_buf.is_absolute() {
            path_buf
        } else {
            let root_path = worktree.root_path();
            let worktree_root = Path::new(root_path.as_str());
            worktree_root.join(&path_buf)
        };

        *tsgolint_path = resolved.to_string_lossy().to_string();
    }

    Ok(env.into_iter().collect())
}