Skip to main content

pkl_lsp_wasm/
lib.rs

1use std::cell::RefCell;
2
3use pkl_lsp_core::{CompletionOptions, DocumentStore, FeatureEngine, TextPosition};
4use wasm_bindgen::prelude::*;
5
6#[wasm_bindgen]
7pub struct ServerHandle {
8    engine: RefCell<FeatureEngine>,
9}
10
11#[wasm_bindgen]
12pub fn create_server(_config: JsValue) -> ServerHandle {
13    console_error_panic_hook::set_once();
14    ServerHandle {
15        engine: RefCell::new(FeatureEngine::new(DocumentStore::default())),
16    }
17}
18
19#[wasm_bindgen]
20impl ServerHandle {
21    pub fn open_document(&self, uri: String, text: String, version: i32) {
22        let mut engine = self.engine.borrow_mut();
23        engine.documents_mut().open(uri, text, version);
24        engine.rebuild();
25    }
26
27    pub fn change_document(&self, uri: String, text: String, version: i32) {
28        let mut engine = self.engine.borrow_mut();
29        engine.documents_mut().change(uri, text, version);
30        engine.rebuild();
31    }
32
33    pub fn close_document(&self, uri: String) {
34        let mut engine = self.engine.borrow_mut();
35        engine.documents_mut().close(&uri);
36        engine.rebuild();
37    }
38
39    pub fn request(&self, method: String, params_json: String) -> Result<String, JsValue> {
40        let engine = self.engine.borrow();
41        let params: serde_json::Value = serde_json::from_str(&params_json)
42            .map_err(|error| JsValue::from_str(&error.to_string()))?;
43        let response = match method.as_str() {
44            "textDocument/diagnostic" | "pkl/diagnostics" => {
45                let uri = required_string(&params, "uri")?;
46                serde_json::to_value(engine.publish_diagnostics(uri)).unwrap()
47            }
48            "textDocument/documentSymbol" => {
49                let uri = required_string(&params, "uri")?;
50                serde_json::to_value(engine.document_symbols(uri)).unwrap()
51            }
52            "workspace/symbol" => {
53                let query = params
54                    .get("query")
55                    .and_then(serde_json::Value::as_str)
56                    .unwrap_or_default();
57                serde_json::to_value(engine.workspace_symbols(query)).unwrap()
58            }
59            "textDocument/hover" => {
60                let uri = required_string(&params, "uri")?;
61                let position = required_position(&params)?;
62                serde_json::to_value(engine.hover(uri, position)).unwrap()
63            }
64            "textDocument/completion" => {
65                let uri = required_string(&params, "uri")?;
66                let position = required_position(&params)?;
67                serde_json::to_value(engine.completion(
68                    uri,
69                    position,
70                    CompletionOptions {
71                        include_keywords: true,
72                    },
73                ))
74                .unwrap()
75            }
76            "textDocument/definition" => {
77                let uri = required_string(&params, "uri")?;
78                let position = required_position(&params)?;
79                serde_json::to_value(engine.definition(uri, position)).unwrap()
80            }
81            "textDocument/references" => {
82                let uri = required_string(&params, "uri")?;
83                let position = required_position(&params)?;
84                serde_json::to_value(engine.references(uri, position)).unwrap()
85            }
86            "textDocument/typeDefinition" => {
87                let uri = required_string(&params, "uri")?;
88                let position = required_position(&params)?;
89                serde_json::to_value(engine.type_definition(uri, position)).unwrap()
90            }
91            "textDocument/implementation" => {
92                let uri = required_string(&params, "uri")?;
93                let position = required_position(&params)?;
94                serde_json::to_value(engine.implementation(uri, position)).unwrap()
95            }
96            "textDocument/documentHighlight" => {
97                let uri = required_string(&params, "uri")?;
98                let position = required_position(&params)?;
99                serde_json::to_value(engine.document_highlights(uri, position)).unwrap()
100            }
101            "textDocument/semanticTokens/full" => {
102                let uri = required_string(&params, "uri")?;
103                serde_json::to_value(engine.semantic_tokens(uri, None)).unwrap()
104            }
105            "textDocument/semanticTokens/range" => {
106                let uri = required_string(&params, "uri")?;
107                let range = required_range(&params)?;
108                serde_json::to_value(engine.semantic_tokens(uri, Some(range))).unwrap()
109            }
110            "textDocument/foldingRange" => {
111                let uri = required_string(&params, "uri")?;
112                serde_json::to_value(engine.folding_ranges(uri)).unwrap()
113            }
114            "textDocument/selectionRange" => {
115                let uri = required_string(&params, "uri")?;
116                let positions = params
117                    .get("positions")
118                    .and_then(serde_json::Value::as_array)
119                    .map(|values| {
120                        values
121                            .iter()
122                            .filter_map(|value| required_position_value(value).ok())
123                            .collect::<Vec<_>>()
124                    })
125                    .unwrap_or_default();
126                serde_json::to_value(engine.selection_ranges(uri, &positions)).unwrap()
127            }
128            "textDocument/prepareRename" => {
129                let uri = required_string(&params, "uri")?;
130                let position = required_position(&params)?;
131                serde_json::to_value(engine.prepare_rename(uri, position)).unwrap()
132            }
133            "textDocument/rename" => {
134                let uri = required_string(&params, "uri")?;
135                let position = required_position(&params)?;
136                let new_name = required_string(&params, "newName")?;
137                serde_json::to_value(engine.rename(uri, position, new_name)).unwrap()
138            }
139            "textDocument/codeAction" => {
140                let uri = required_string(&params, "uri")?;
141                let range = required_range(&params)?;
142                serde_json::to_value(engine.code_actions(uri, range)).unwrap()
143            }
144            "textDocument/signatureHelp" => {
145                let uri = required_string(&params, "uri")?;
146                let position = required_position(&params)?;
147                serde_json::to_value(engine.signature_help(uri, position)).unwrap()
148            }
149            "textDocument/inlayHint" => {
150                let uri = required_string(&params, "uri")?;
151                let range = required_range(&params)?;
152                serde_json::to_value(engine.inlay_hints(uri, range)).unwrap()
153            }
154            _ => {
155                return Err(JsValue::from_str(&format!(
156                    "unsupported request method: {method}"
157                )));
158            }
159        };
160        serde_json::to_string(&response).map_err(|error| JsValue::from_str(&error.to_string()))
161    }
162}
163
164fn required_string<'a>(params: &'a serde_json::Value, field: &str) -> Result<&'a str, JsValue> {
165    params
166        .get(field)
167        .and_then(serde_json::Value::as_str)
168        .ok_or_else(|| JsValue::from_str(&format!("missing string field '{field}'")))
169}
170
171fn required_position(params: &serde_json::Value) -> Result<TextPosition, JsValue> {
172    let position = params
173        .get("position")
174        .ok_or_else(|| JsValue::from_str("missing position"))?;
175    required_position_value(position)
176}
177
178fn required_position_value(position: &serde_json::Value) -> Result<TextPosition, JsValue> {
179    let line = position
180        .get("line")
181        .and_then(serde_json::Value::as_u64)
182        .ok_or_else(|| JsValue::from_str("missing position.line"))?;
183    let character = position
184        .get("character")
185        .and_then(serde_json::Value::as_u64)
186        .ok_or_else(|| JsValue::from_str("missing position.character"))?;
187    Ok(TextPosition {
188        line: line as u32,
189        character: character as u32,
190    })
191}
192
193fn required_range(params: &serde_json::Value) -> Result<pkl_lsp_core::TextRange, JsValue> {
194    let range = params
195        .get("range")
196        .ok_or_else(|| JsValue::from_str("missing range"))?;
197    let start = range
198        .get("start")
199        .ok_or_else(|| JsValue::from_str("missing range.start"))
200        .and_then(required_position_value)?;
201    let end = range
202        .get("end")
203        .ok_or_else(|| JsValue::from_str("missing range.end"))
204        .and_then(required_position_value)?;
205    Ok(pkl_lsp_core::TextRange { start, end })
206}