ace-linters

Author: RohitKushvaha01

package-lock.json

@@ -105,6 +105,7 @@
     "@xterm/addon-web-links": "^0.11.0",
     "@xterm/addon-webgl": "^0.18.0",
     "@xterm/xterm": "^5.5.0",
+    "ace-linters": "^1.8.1",
     "autosize": "^6.0.1",
     "cordova": "12.0.0",
     "core-js": "^3.37.1",

package.json

@@ -1,29 +1,27 @@
+import "ace-linters";
+
 export default class lspClient {
 	constructor(serverUrl) {
 		this.serverUrl = serverUrl;
 		this.ws = null;
 		this.messageId = 0;
 		this.pendingRequests = new Map();
+		this.editors = new Map(); // editorId -> { editor, documentUri, language, version }
 
-		// Map of editorId -> { editor, documentUri, language, version, changeHandler }
-		this.editors = new Map();
+		// Enable ace language tools
+		ace.require("ace/ext/language_tools");
 	}
 
-	// Establish WebSocket connection and initialize LSP
 	connect() {
 		this.ws = new WebSocket(this.serverUrl);
-		this.ws.onopen = () => {
-			this.initializeLSP();
-		};
+		this.ws.onopen = () => this.initializeLSP();
 		this.ws.onmessage = (event) => this.handleMessage(event);
 		this.ws.onerror = (error) => console.error("WebSocket error:", error);
 		this.ws.onclose = () => console.log("WebSocket closed");
 	}
 
 	disconnect() {
-		if (this.ws) {
-			this.ws.close();
-		}
+		this.ws?.close();
 	}
 
 	initializeLSP() {
@@ -37,127 +35,121 @@ export default class lspClient {
 				},
 			},
 		};
+
 		this.sendRequest("initialize", initParams)
 			.then(() => {
 				this.sendNotification("initialized", {});
-				// Open all already-registered editors
-				for (const [id, meta] of this.editors) {
+				// Open all registered editors
+				for (const [id] of this.editors) {
 					this.sendDidOpen(id);
 				}
 			})
 			.catch((error) => console.error("Initialization failed:", error));
 	}
 
-	// Add an editor/tab to share this single connection
-	addEditor(id, editor, documentUri, language) {
+	addEditor(id, editor, documentUri, language, mode) {
 		if (this.editors.has(id)) {
-			console.warn(`Editor with id ${id} already registered; replacing.`);
 			this.removeEditor(id);
 		}
 
-		const meta = {
-			editor,
-			documentUri,
-			language,
-			version: 1,
-			changeHandler: null,
-		};
+		// Setup ace-linters with mode
+		const session = editor.getSession();
 
-		// change listener
-		const changeHandler = () => {
-			this.sendDidChange(id);
-		};
-		meta.changeHandler = changeHandler;
-		editor.getSession().on("change", changeHandler);
+		session.setMode(mode);
+		session.setUseWorker(true);
 
-		// completer for this editor
+		// Enable autocompletion
+		editor.setOptions({
+			enableBasicAutocompletion: true,
+			enableLiveAutocompletion: true,
+			enableSnippets: false,
+		});
+
+		// Add LSP completer
 		editor.completers = editor.completers || [];
 		editor.completers.push({
 			getCompletions: (ed, session, pos, prefix, callback) => {
-				this.requestCompletions(id, pos, prefix, callback);
+				this.requestCompletions(id, pos, callback);
 			},
 		});
 
-		this.editors.set(id, meta);
+		// Track changes for LSP
+		const changeHandler = () => this.sendDidChange(id);
+		session.on("change", changeHandler);
+
+		this.editors.set(id, {
+			editor,
+			documentUri,
+			language,
+			version: 1,
+			changeHandler,
+		});
 
-		// If already initialized, immediately send didOpen
 		this.sendDidOpen(id);
 	}
 
-	// Remove an editor/tab
 	removeEditor(id) {
 		const meta = this.editors.get(id);
 		if (!meta) return;
-		const { editor, changeHandler, documentUri } = meta;
 
-		// Optionally notify the server that the document is closed
+		// Clean up
+		meta.editor.getSession().removeListener("change", meta.changeHandler);
 		this.sendNotification("textDocument/didClose", {
-			textDocument: { uri: documentUri },
+			textDocument: { uri: meta.documentUri },
 		});
-
-		// Tear down listener
-		if (changeHandler) {
-			editor.getSession().removeListener("change", changeHandler);
-		}
-
-		// Note: removing completer is left to caller if needed
 		this.editors.delete(id);
 	}
 
 	sendDidOpen(id) {
 		const meta = this.editors.get(id);
 		if (!meta) return;
-		const { editor, documentUri, language, version } = meta;
-		const params = {
+
+		this.sendNotification("textDocument/didOpen", {
 			textDocument: {
-				uri: documentUri,
-				languageId: language,
-				version,
-				text: editor.getValue(),
+				uri: meta.documentUri,
+				languageId: meta.language,
+				version: meta.version,
+				text: meta.editor.getValue(),
 			},
-		};
-		this.sendNotification("textDocument/didOpen", params);
+		});
 	}
 
 	sendDidChange(id) {
 		const meta = this.editors.get(id);
 		if (!meta) return;
-		const { editor, documentUri } = meta;
+
 		meta.version += 1;
-		const params = {
+		this.sendNotification("textDocument/didChange", {
 			textDocument: {
-				uri: documentUri,
+				uri: meta.documentUri,
 				version: meta.version,
 			},
-			contentChanges: [{ text: editor.getValue() }],
-		};
-		this.sendNotification("textDocument/didChange", params);
+			contentChanges: [{ text: meta.editor.getValue() }],
+		});
 	}
 
-	requestCompletions(id, position, prefix, callback) {
+	requestCompletions(id, position, callback) {
 		const meta = this.editors.get(id);
 		if (!meta) {
 			callback(null, []);
 			return;
 		}
-		const { documentUri } = meta;
+
 		const params = {
-			textDocument: { uri: documentUri },
+			textDocument: { uri: meta.documentUri },
 			position: { line: position.row, character: position.column },
 		};
+
 		this.sendRequest("textDocument/completion", params)
 			.then((result) => {
 				const completions = (result?.items || []).map((item) => ({
 					caption: item.label,
 					value: item.insertText || item.label,
-					meta: item.detail || "completion",
+					meta: item.detail || "lsp",
 				}));
 				callback(null, completions);
 			})
-			.catch((error) => {
-				console.error("Completion failed:", error);
-				callback(null, []);
-			});
+			.catch(() => callback(null, []));
 	}
 
 	sendRequest(method, params) {
@@ -166,6 +158,7 @@ export default class lspClient {
 				reject(new Error("WebSocket not open"));
 				return;
 			}
+
 			const id = ++this.messageId;
 			const message = { jsonrpc: "2.0", id, method, params };
 			this.pendingRequests.set(id, { resolve, reject });
@@ -174,9 +167,10 @@ export default class lspClient {
 	}
 
 	sendNotification(method, params) {
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-		const message = { jsonrpc: "2.0", method, params };
-		this.ws.send(JSON.stringify(message));
+		if (this.ws?.readyState === WebSocket.OPEN) {
+			const message = { jsonrpc: "2.0", method, params };
+			this.ws.send(JSON.stringify(message));
+		}
 	}
 
 	handleMessage(event) {
@@ -188,34 +182,43 @@ export default class lspClient {
 			return;
 		}
 
+		// Handle responses
 		if (message.id && this.pendingRequests.has(message.id)) {
 			const { resolve, reject } = this.pendingRequests.get(message.id);
-			if (message.error) {
-				reject(message.error);
-			} else {
-				resolve(message.result);
-			}
+			message.error ? reject(message.error) : resolve(message.result);
 			this.pendingRequests.delete(message.id);
-		} else if (message.method === "textDocument/publishDiagnostics") {
+		}
+		// Handle diagnostics - add to ace-linters annotations
+		else if (message.method === "textDocument/publishDiagnostics") {
 			this.handleDiagnostics(message.params);
 		}
 	}
 
 	handleDiagnostics(params) {
 		const diagnostics = params.diagnostics || [];
-		const uri = params.uri || (params.textDocument && params.textDocument.uri);
+		const uri = params.uri;
 		if (!uri) return;
 
-		// Find all editors with that document URI
+		// Find editors with matching URI
 		for (const [, meta] of this.editors) {
 			if (meta.documentUri === uri) {
-				const annotations = diagnostics.map((d) => ({
+				const session = meta.editor.getSession();
+
+				// Get existing ace-linters annotations
+				const existing = session.getAnnotations() || [];
+				const linterAnnotations = existing.filter((a) => a.source !== "lsp");
+
+				// Add LSP diagnostics
+				const lspAnnotations = diagnostics.map((d) => ({
 					row: d.range.start.line,
 					column: d.range.start.character,
 					text: d.message,
 					type: d.severity === 1 ? "error" : "warning",
+					source: "lsp",
 				}));
-				meta.editor.getSession().setAnnotations(annotations);
+
+				// Combine and set
+				session.setAnnotations([...linterAnnotations, ...lspAnnotations]);
 			}
 		}
 	}