@ripple-ts/language-server 0.2.153

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dominic Gannaway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# ripple-language-server
+
+Language Server Protocol (LSP) implementation for Ripple. This package provides language intelligence features for
+Ripple files and can be integrated into any editor that supports LSP.
+
+## Features
+
+- TypeScript integration via Volar
+- Ripple syntax diagnostics
+- IntelliSense and autocomplete
+- Go to definition
+- Find references
+- Hover information
+
+## Installation
+
+```bash
+npm install ripple-language-server -g
+```
+
+### Editor Integration
+
+This language server can be integrated into any editor that supports LSP:
+
+#### VS Code
+
+Use the [official extension](https://marketplace.visualstudio.com/items?itemName=ripple-ts.vscode-plugin
+It uses this language server internally.
+
+#### WebStorm/IntelliJ
+
+1. Install the [LSP4IJ plugin](https://plugins.jetbrains.com/plugin/23257-lsp4ij).
+2. Add a new language server in it
+3. Specify `ripple-language-server --stdio` as the command in it.
+4. Go to `Mappings` —> `File name patterns` and add a new value with `File name patterns` set to `*.ripple` and `Language Id` set to `ripple.
+
+#### Neovim
+
+TODO Write instructions
+
+#### Sublime Text
+
+TODO Write instructions

package/bin/language-server.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+const { createRippleLanguageServer } = require('../src/server.js');
+
+createRippleLanguageServer();
+

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./src/server');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@ripple-ts/language-server",
+  "version": "0.2.153",
+  "description": "Language Server Protocol implementation for Ripple",
+  "main": "index.js",
+  "bin": {
+    "@ripple-ts/language-server": "bin/language-server.js"
+  },
+  "author": "Dominic Gannaway",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ripple-TS/ripple.git",
+    "directory": "packages/language-server"
+  },
+  "dependencies": {
+    "@volar/language-server": "~2.4.23",
+    "volar-service-typescript": "0.0.65",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "vscode-uri": "^3.1.0",
+    "@ripple-ts/typescript-plugin": "0.2.153"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.2"
+  }
+}

package/src/diagnosticPlugin.js

@@ -0,0 +1,240 @@
+const { RippleVirtualCode } = require('@ripple-ts/typescript-plugin/src/language.js');
+const { URI } = require('vscode-uri');
+
+/**
+ * @typedef {import('@volar/language-server').LanguageServicePlugin} LanguageServicePlugin
+ * @typedef {import('@volar/language-server').LanguageServiceContext} LanguageServiceContext
+ * @typedef {import('@volar/language-server').Diagnostic} Diagnostic
+ * @typedef {import('@volar/language-server').DiagnosticSeverity} DiagnosticSeverity
+ * @typedef {import('@volar/language-server').Position} Position
+ * @typedef {import('vscode-languageserver-textdocument').TextDocument} TextDocument
+ */
+
+const DEBUG = process.env.RIPPLE_DEBUG === 'true';
+
+/**
+ * @param {...unknown} args
+ */
+function log(...args) {
+	if (DEBUG) {
+		console.log('[Ripple Language]', ...args);
+	}
+}
+
+/**
+ * @param {...unknown} args
+ */
+function logError(...args) {
+	console.error('[Ripple Language ERROR]', ...args);
+}
+
+/**
+ * @returns {LanguageServicePlugin}
+ */
+function createRippleDiagnosticPlugin() {
+	log('Creating Ripple diagnostic plugin...');
+
+	return {
+		name: 'ripple-diagnostics',
+		capabilities: {
+			diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false,
+			},
+		},
+		create(/** @type {LanguageServiceContext} */ context) {
+			return {
+				/**
+				 * @param {TextDocument} document
+				 * @param {import('@volar/language-server').CancellationToken} _token
+				 * @returns {import('@volar/language-server').NullableProviderResult<Diagnostic[]>}
+				 */
+				provideDiagnostics(document, _token) {
+					try {
+						log('Providing Ripple diagnostics for:', document.uri);
+
+						const info = getEmbeddedInfo(context, document);
+
+						if (info && info.virtualCode.errors && info.virtualCode.errors.length > 0) {
+							const virtualCode = info.virtualCode;
+							const diagnostics = [];
+
+							log('Processing', virtualCode.errors.length, 'errors');
+
+							// Convert each stored error to a diagnostic
+							for (const error of virtualCode.errors) {
+								try {
+									// Use the actual snapshot text that Volar is working with
+									const snapshotText = virtualCode.snapshot.getText(
+										0,
+										virtualCode.snapshot.getLength(),
+									);
+									const diagnostic = parseCompilationErrorWithDocument(
+										error,
+										virtualCode.fileName,
+										snapshotText,
+										document,
+									);
+									diagnostics.push(diagnostic);
+								} catch (parseError) {
+									logError('Failed to parse compilation error:', parseError);
+								}
+							}
+
+							log('Generated', diagnostics.length, 'diagnostics');
+							return diagnostics;
+						}
+
+						return [];
+					} catch (err) {
+						logError('Failed to provide diagnostics:', err);
+						return [];
+					}
+				},
+			};
+		},
+	};
+}
+
+// Helper function to parse compilation errors using document.positionAt (Glint style)
+/**
+ * @param {unknown} error
+ * @param {string} fallbackFileName
+ * @param {string} sourceText
+ * @param {TextDocument} document
+ * @returns {Diagnostic}
+ */
+function parseCompilationErrorWithDocument(error, fallbackFileName, sourceText, document) {
+	const errorObject = /** @type {{ message?: string }} */ (error);
+	const message = errorObject.message || String(error);
+
+	try {
+		// First check if there's a GitHub-style range in the error
+		// Format: filename#L39C24-L39C32
+		const githubRangeMatch = message.match(/\(([^#]+)#L(\d+)C(\d+)-L(\d+)C(\d+)\)/);
+
+		if (githubRangeMatch) {
+			// Use the GitHub range data directly
+			const startLine = parseInt(githubRangeMatch[2]);
+			const startColumn = parseInt(githubRangeMatch[3]);
+			const endLine = parseInt(githubRangeMatch[4]);
+			const endColumn = parseInt(githubRangeMatch[5]);
+
+			// Convert to zero-based
+			const zeroBasedStartLine = Math.max(0, startLine - 1);
+			const zeroBasedStartColumn = Math.max(0, startColumn);
+			const zeroBasedEndLine = Math.max(0, endLine - 1);
+			const zeroBasedEndColumn = Math.max(0, endColumn);
+
+			return {
+				severity: 1, // DiagnosticSeverity.Error
+				range: {
+					start: { line: zeroBasedStartLine, character: zeroBasedStartColumn },
+					end: { line: zeroBasedEndLine, character: zeroBasedEndColumn },
+				},
+				message: message.replace(/\s*\([^#]+#L\d+C\d+-L\d+C\d+\)/, '').trim(), // Remove the range part from message
+				source: 'Ripple',
+				code: 'ripple-compile-error',
+			};
+		}
+
+		// Fallback to old parsing method if no range found
+		// Try to parse location from error message
+		// Format: "Error message (filename:line:column)"
+		const locationMatch = message.match(/\(([^:]+):(\d+):(\d+)\)$/);
+
+		if (locationMatch) {
+			const [, fileName, lineStr, columnStr] = locationMatch;
+			const line = parseInt(lineStr, 10);
+			const column = parseInt(columnStr, 10);
+
+			// Extract the main error message (without location)
+			const cleanMessage = message.replace(/\s*\([^:]+:\d+:\d+\)$/, '');
+
+			// Convert 1-based line/column to 0-based for VS Code
+			const zeroBasedLine = Math.max(0, line - 1);
+			const actualColumn = Math.max(0, column - 1);
+
+			// Use the original error coordinates from the Ripple compiler
+			// Just use the compiler's position as-is, with a simple 1-character highlight
+			let length = Math.min(1, sourceText.split('\n')[zeroBasedLine]?.length - actualColumn || 1);
+
+			return {
+				severity: 1, // DiagnosticSeverity.Error
+				range: {
+					start: { line: zeroBasedLine, character: actualColumn },
+					end: { line: zeroBasedLine, character: actualColumn + length },
+				},
+				message: cleanMessage,
+				source: 'Ripple',
+				code: 'ripple-compile-error',
+			};
+		} else {
+			// Fallback for errors without location information
+			const startPosition = document.positionAt(0);
+			const endPosition = document.positionAt(Math.min(1, sourceText.length));
+
+			return {
+				severity: 1, // DiagnosticSeverity.Error
+				range: {
+					start: startPosition,
+					end: endPosition,
+				},
+				message: `Ripple compilation error: ${message}`,
+				source: 'Ripple',
+				code: 'ripple-compile-error',
+			};
+		}
+	} catch (parseError) {
+		logError('Error parsing compilation error:', parseError);
+
+		return {
+			severity: 1,
+			range: {
+				start: { line: 0, character: 0 },
+				end: { line: 0, character: 1 },
+			},
+			message: `Ripple compilation error: ${message}`,
+			source: 'Ripple',
+			code: 'ripple-parse-error',
+		};
+	}
+}
+
+/**
+ * @param {LanguageServiceContext} context
+ * @param {TextDocument} document
+ */
+function getEmbeddedInfo(context, document) {
+	try {
+		const uri = URI.parse(document.uri);
+		const decoded = context.decodeEmbeddedDocumentUri(uri);
+		if (!decoded) {
+			return;
+		}
+
+		const [documentUri, embeddedCodeId] = decoded;
+
+		const sourceScript = context.language.scripts.get(documentUri);
+		if (!sourceScript?.generated) {
+			return;
+		}
+
+		const virtualCode = sourceScript.generated.embeddedCodes.get(embeddedCodeId);
+		if (!(virtualCode instanceof RippleVirtualCode)) {
+			return;
+		}
+
+		return {
+			sourceScript: sourceScript,
+			virtualCode,
+		};
+	} catch (err) {
+		logError('Failed to get embedded info:', err);
+		return null;
+	}
+}
+
+module.exports = {
+	createRippleDiagnosticPlugin,
+};

package/src/server.js

@@ -0,0 +1,135 @@
+const {
+	createConnection,
+	createServer,
+	createTypeScriptProject,
+} = require('@volar/language-server/node');
+const { createRippleDiagnosticPlugin } = require('./diagnosticPlugin.js');
+const { getRippleLanguagePlugin, resolveConfig } = require('@ripple-ts/typescript-plugin/src/language.js');
+const { create: createTypeScriptServices } = require('volar-service-typescript');
+
+const DEBUG = process.env.RIPPLE_DEBUG === 'true';
+
+/** @typedef {import('typescript').CompilerOptions} CompilerOptions */
+
+/**
+ * @param {...unknown} args
+ */
+function log(...args) {
+	if (DEBUG) {
+		console.log('[Ripple Server]', ...args);
+	}
+}
+
+/**
+ * @param {...unknown} args
+ */
+function logError(...args) {
+	console.error('[Ripple Server ERROR]', ...args);
+}
+
+function createRippleLanguageServer() {
+	const connection = createConnection();
+	const server = createServer(connection);
+
+	connection.listen();
+
+	// Create language plugin instance once and reuse it
+	// This prevents creating multiple instances if the callback is called multiple times
+	const rippleLanguagePlugin = getRippleLanguagePlugin();
+	log('Language plugin instance created');
+
+	/** @type {WeakSet<Function>} */
+	const wrappedFunctions = new WeakSet();
+
+	/**
+	 * Ensure TypeScript hosts always see compiler options with Ripple defaults.
+	 * @param {unknown} target
+	 * @param {string} method
+	 */
+	function wrapCompilerOptionsProvider(target, method) {
+		if (!target) {
+			return;
+		}
+
+		const host = /** @type {{ [key: string]: unknown }} */ (target);
+		const original = host[method];
+		if (typeof original !== 'function' || wrappedFunctions.has(original)) {
+			return;
+		}
+
+		/** @type {CompilerOptions | undefined} */
+		let cachedInput;
+		/** @type {CompilerOptions | undefined} */
+		let cachedOutput;
+
+		const wrapped = () => {
+			/** @type {CompilerOptions} */
+			const input = original.call(host);
+			if (cachedInput !== input) {
+				cachedInput = input;
+				cachedOutput = resolveConfig({ options: input }).options;
+			}
+			return cachedOutput;
+		};
+
+		wrappedFunctions.add(original);
+		wrappedFunctions.add(wrapped);
+		host[method] = wrapped;
+	}
+
+	connection.onInitialize(async (params) => {
+		try {
+			log('Initializing Ripple language server...');
+			log('Initialization options:', JSON.stringify(params.initializationOptions, null, 2));
+
+			const ts = require('typescript');
+
+			const initResult = server.initialize(
+				params,
+				createTypeScriptProject(
+					ts,
+					undefined,
+					({ projectHost }) => {
+						wrapCompilerOptionsProvider(projectHost, 'getCompilationSettings');
+
+						return {
+							languagePlugins: [rippleLanguagePlugin],
+							setup({ project }) {
+								wrapCompilerOptionsProvider(project?.typescript?.languageServiceHost, 'getCompilationSettings');
+							},
+						};
+					},
+				),
+				[
+					createRippleDiagnosticPlugin(),
+					...createTypeScriptServices(ts),
+				],
+			);
+
+			log('Server initialization complete');
+			return initResult;
+		} catch (initError) {
+			logError('Server initialization failed:', initError);
+			throw initError;
+		}
+	});
+
+	connection.onInitialized(() => {
+		log('Server initialized.');
+		server.initialized();
+	});
+
+	process.on('uncaughtException', (err) => {
+		logError('Uncaught exception:', err);
+	});
+
+	process.on('unhandledRejection', (reason, promise) => {
+		logError('Unhandled rejection at:', promise, 'reason:', reason);
+	});
+
+	return { connection, server };
+}
+
+module.exports = {
+	createRippleLanguageServer,
+};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "node16",
+    "moduleResolution": "node16",
+    "target": "es2020",
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "types": []
+  },
+  "include": ["src/**/*.js", "index.js", "bin/**/*.js"]
+}