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(¶ms_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(¶ms, "uri")?;
46 serde_json::to_value(engine.publish_diagnostics(uri)).unwrap()
47 }
48 "textDocument/documentSymbol" => {
49 let uri = required_string(¶ms, "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(¶ms, "uri")?;
61 let position = required_position(¶ms)?;
62 serde_json::to_value(engine.hover(uri, position)).unwrap()
63 }
64 "textDocument/completion" => {
65 let uri = required_string(¶ms, "uri")?;
66 let position = required_position(¶ms)?;
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(¶ms, "uri")?;
78 let position = required_position(¶ms)?;
79 serde_json::to_value(engine.definition(uri, position)).unwrap()
80 }
81 "textDocument/references" => {
82 let uri = required_string(¶ms, "uri")?;
83 let position = required_position(¶ms)?;
84 serde_json::to_value(engine.references(uri, position)).unwrap()
85 }
86 "textDocument/typeDefinition" => {
87 let uri = required_string(¶ms, "uri")?;
88 let position = required_position(¶ms)?;
89 serde_json::to_value(engine.type_definition(uri, position)).unwrap()
90 }
91 "textDocument/implementation" => {
92 let uri = required_string(¶ms, "uri")?;
93 let position = required_position(¶ms)?;
94 serde_json::to_value(engine.implementation(uri, position)).unwrap()
95 }
96 "textDocument/documentHighlight" => {
97 let uri = required_string(¶ms, "uri")?;
98 let position = required_position(¶ms)?;
99 serde_json::to_value(engine.document_highlights(uri, position)).unwrap()
100 }
101 "textDocument/semanticTokens/full" => {
102 let uri = required_string(¶ms, "uri")?;
103 serde_json::to_value(engine.semantic_tokens(uri, None)).unwrap()
104 }
105 "textDocument/semanticTokens/range" => {
106 let uri = required_string(¶ms, "uri")?;
107 let range = required_range(¶ms)?;
108 serde_json::to_value(engine.semantic_tokens(uri, Some(range))).unwrap()
109 }
110 "textDocument/foldingRange" => {
111 let uri = required_string(¶ms, "uri")?;
112 serde_json::to_value(engine.folding_ranges(uri)).unwrap()
113 }
114 "textDocument/selectionRange" => {
115 let uri = required_string(¶ms, "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(¶ms, "uri")?;
130 let position = required_position(¶ms)?;
131 serde_json::to_value(engine.prepare_rename(uri, position)).unwrap()
132 }
133 "textDocument/rename" => {
134 let uri = required_string(¶ms, "uri")?;
135 let position = required_position(¶ms)?;
136 let new_name = required_string(¶ms, "newName")?;
137 serde_json::to_value(engine.rename(uri, position, new_name)).unwrap()
138 }
139 "textDocument/codeAction" => {
140 let uri = required_string(¶ms, "uri")?;
141 let range = required_range(¶ms)?;
142 serde_json::to_value(engine.code_actions(uri, range)).unwrap()
143 }
144 "textDocument/signatureHelp" => {
145 let uri = required_string(¶ms, "uri")?;
146 let position = required_position(¶ms)?;
147 serde_json::to_value(engine.signature_help(uri, position)).unwrap()
148 }
149 "textDocument/inlayHint" => {
150 let uri = required_string(¶ms, "uri")?;
151 let range = required_range(¶ms)?;
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}