@ripple-ts/language-server 0.2.176 → 0.2.178

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ripple-ts/language-server",
-  "version": "0.2.176",
+  "version": "0.2.178",
   "description": "Language Server Protocol implementation for Ripple",
   "main": "index.js",
   "bin": {
@@ -19,7 +19,7 @@
     "volar-service-typescript": "0.0.65",
     "vscode-languageserver-textdocument": "^1.0.12",
     "vscode-uri": "^3.1.0",
-    "@ripple-ts/typescript-plugin": "0.2.176"
+    "@ripple-ts/typescript-plugin": "0.2.178"
   },
   "peerDependencies": {
     "typescript": "^5.9.2"

package/src/{diagnosticPlugin.js → compileErrorDiagnosticPlugin.js}

@@ -31,7 +31,7 @@ function logError(...args) {
 /**
  * @returns {LanguageServicePlugin}
  */
-function createDiagnosticPlugin() {
+function createCompileErrorDiagnosticPlugin() {
 	log('Creating Ripple diagnostic plugin...');
 
 	return {
@@ -55,37 +55,37 @@ function createDiagnosticPlugin() {
 
 						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);
-								}
-							}
+						if (!info || !info.virtualCode.errors || info.virtualCode.errors.length === 0) {
+							return [];
+						}
 
-							log('Generated', diagnostics.length, 'diagnostics');
-							return diagnostics;
+						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);
+							}
 						}
 
-						return [];
+						log('Generated', diagnostics.length, 'diagnostics');
+						return diagnostics;
 					} catch (err) {
 						logError('Failed to provide diagnostics:', err);
 						return [];
@@ -236,5 +236,5 @@ function getEmbeddedInfo(context, document) {
 }
 
 module.exports = {
-	createDiagnosticPlugin,
+	createCompileErrorDiagnosticPlugin,
 };

package/src/hoverPlugin.js

@@ -1,6 +1,6 @@
 /** @import { LanguageServicePlugin } from '@volar/language-server' */
 /** @import { RippleVirtualCode } from '@ripple-ts/typescript-plugin/src/language.js') */
-/** @typedef {import('@volar/language-server').LanguageServicePluginInstance} LanguageServicePluginInstance */
+/** @import { LanguageServicePluginInstance } from '@volar/language-server' */
 
 const { URI } = require('vscode-uri');
 
@@ -95,6 +95,26 @@ function createHoverPlugin() {
 						return tsHover;
 					}
 
+					const customHover = mapping?.data?.customData?.hover;
+					if (customHover) {
+						log('Found custom hover data in mapping');
+						return {
+							contents: {
+								kind: 'markdown',
+								value: customHover.contents,
+							},
+							range: {
+								start: position,
+								end: position,
+							},
+						};
+					} else if (customHover === false) {
+						log(
+							`Hover explicitly suppressed in mapping at range start: ${rangeStart}, end: ${rangeEnd}`,
+						);
+						return null;
+					}
+
 					log('Found mapping for hover at range', 'start: ', rangeStart, 'end: ', rangeEnd);
 
 					// Check if source length is greater than generated length (component -> function)

package/src/server.js

@@ -3,11 +3,12 @@
 	createServer,
 	createTypeScriptProject,
 } = require('@volar/language-server/node');
-const { createDiagnosticPlugin } = require('./diagnosticPlugin.js');
+const { createCompileErrorDiagnosticPlugin } = require('./compileErrorDiagnosticPlugin.js');
 const { createDefinitionPlugin } = require('./definitionPlugin.js');
 const { createHoverPlugin } = require('./hoverPlugin.js');
 const { createCompletionPlugin } = require('./completionPlugin.js');
 const { createAutoInsertPlugin } = require('./autoInsertPlugin.js');
+const { createTypeScriptDiagnosticFilterPlugin } = require('./typescriptDiagnosticPlugin.js');
 const {
 	getRippleLanguagePlugin,
 	resolveConfig,
@@ -110,12 +111,14 @@ function createRippleLanguageServer() {
 				[
 					createAutoInsertPlugin(),
 					createCompletionPlugin(),
-					createDiagnosticPlugin(),
+					createCompileErrorDiagnosticPlugin(),
 					createDefinitionPlugin(),
 					createCssService(),
 					...createTypeScriptServices(ts),
-					// !IMPORTANT createHoverPlugin has to be loaded after Volar's ts plugins
-					// to overwrite `typescript-semantic` plugin's `provideHover`
+					// !IMPORTANT 'createTypeScriptDiagnosticFilterPlugin' and 'createHoverPlugin'
+					// must come after TypeScript services
+					// to intercept volar's and vscode default providers
+					createTypeScriptDiagnosticFilterPlugin(),
 					createHoverPlugin(),
 				],
 			);

package/src/typescriptDiagnosticPlugin.js

@@ -0,0 +1,171 @@
+/** @import { LanguageServicePlugin } from '@volar/language-server' */
+/** @import { LanguageServicePluginInstance } from '@volar/language-server' */
+
+// @ts-expect-error type-only import from ESM module into CJS is fine
+/** @import { CodeMapping } from 'ripple/compiler' */
+
+const { getVirtualCode } = require('./utils.js');
+
+const DEBUG = process.env.RIPPLE_DEBUG === 'true';
+
+/**
+ * @param {...unknown} args
+ */
+function log(...args) {
+	if (DEBUG) {
+		console.log('[Ripple Typescript Diagnostics]', ...args);
+	}
+}
+
+/**
+ * @param {...unknown} args
+ */
+function logError(...args) {
+	console.error('[Ripple Typescript Diagnostics]', ...args);
+}
+
+/**
+ * Create a plugin to filter TypeScript diagnostics based on customData in mappings
+ * @returns {LanguageServicePlugin}
+ */
+function createTypeScriptDiagnosticFilterPlugin() {
+	log('Creating TypeScript diagnostic filter plugin...');
+
+	return {
+		name: 'ripple-typescript-diagnostic-filter',
+		capabilities: {
+			diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false,
+			},
+		},
+		create(context) {
+			/** @type {LanguageServicePluginInstance['provideDiagnostics']} */
+			let originalProvideDiagnostics;
+			/** @type {LanguageServicePluginInstance} */
+			let originalInstance;
+
+			// Disable typescript-semantic's provideHover so it doesn't merge with ours
+			for (const [plugin, instance] of context.plugins) {
+				if (plugin.name === 'typescript-semantic') {
+					originalInstance = instance;
+					originalProvideDiagnostics = instance.provideDiagnostics;
+					instance.provideDiagnostics = undefined;
+					break;
+				}
+			}
+
+			if (!originalProvideDiagnostics) {
+				logError(
+					"'typescript-semantic plugin' was not found or has no 'provideDiagnostics'. \
+					This plugin must be loaded after Volar's typescript-semantic plugin.",
+				);
+			}
+
+			return {
+				async provideDiagnostics(document, token) {
+					let diagnostics;
+
+					if (originalProvideDiagnostics) {
+						diagnostics = await originalProvideDiagnostics.call(originalInstance, document, token);
+					}
+
+					if (!diagnostics || diagnostics.length === 0) {
+						return diagnostics;
+					}
+
+					log(`Filtering ${diagnostics.length} TypeScript diagnostics for ${document.uri}`);
+
+					const virtualCode = getVirtualCode(document, context);
+
+					const filtered = diagnostics.filter((diagnostic) => {
+						const range = diagnostic.range;
+						const rangeStart = document.offsetAt(range.start);
+						const rangeEnd = document.offsetAt(range.end);
+						// Get the mapping at this diagnostic position
+						const mapping = virtualCode.findMappingByGeneratedRange(rangeStart, rangeEnd);
+
+						if (!mapping) {
+							return true;
+						}
+
+						const suppressedCodes = mapping.data.customData?.suppressedDiagnostics;
+
+						if (!suppressedCodes || suppressedCodes.length === 0) {
+							return true;
+						}
+
+						const diagnosticCode =
+							typeof diagnostic.code === 'number'
+								? diagnostic.code
+								: typeof diagnostic.code === 'string'
+									? parseInt(diagnostic.code)
+									: null;
+
+						if (diagnosticCode && suppressedCodes.includes(diagnosticCode)) {
+							log(`Suppressing diagnostic ${diagnosticCode}: ${diagnostic.message}`);
+							return false; // Filter out this diagnostic
+						}
+
+						return true; // Keep this diagnostic
+					});
+
+					log(`Filtered from ${diagnostics.length} to ${filtered.length} diagnostics`);
+					return filtered;
+				},
+			};
+		},
+	};
+}
+
+/**
+ * Get the mapping at a specific position in the document
+ * @param {import('@volar/language-server').LanguageServiceContext} context
+ * @param {import('vscode-languageserver-textdocument').TextDocument} document
+ * @param {import('@volar/language-server').Position} position
+ * @returns {CodeMapping | null}
+ */
+function getMappingAtPosition(context, document, position) {
+	try {
+		const { URI } = require('vscode-uri');
+		const { RippleVirtualCode } = require('@ripple-ts/typescript-plugin/src/language.js');
+
+		const uri = URI.parse(document.uri);
+		const decoded = context.decodeEmbeddedDocumentUri(uri);
+		if (!decoded) {
+			return null;
+		}
+
+		const [sourceUri, virtualCodeId] = decoded;
+		const sourceScript = context.language.scripts.get(sourceUri);
+		const virtualCode = /** @type {RippleVirtualCode} */ (
+			sourceScript?.generated?.embeddedCodes.get(virtualCodeId)
+		);
+
+		if (!virtualCode?.mappings) {
+			return null;
+		}
+
+		// Convert position to offset in the virtual document
+		const offset = document.offsetAt(position);
+
+		// Find mapping that contains this offset
+		for (const mapping of virtualCode.mappings) {
+			const genStart = mapping.generatedOffsets[0];
+			const genEnd = genStart + mapping.lengths[0];
+
+			if (offset >= genStart && offset < genEnd) {
+				return mapping;
+			}
+		}
+
+		return null;
+	} catch (err) {
+		log('Error getting mapping at position:', err);
+		return null;
+	}
+}
+
+module.exports = {
+	createTypeScriptDiagnosticFilterPlugin,
+};

package/src/utils.js

@@ -0,0 +1,29 @@
+/** @import { TextDocument } from 'vscode-languageserver-textdocument' */
+/** @import { LanguageServiceContext } from '@volar/language-server' */
+/** @import {RippleVirtualCode} from '@ripple-ts/typescript-plugin/src/language.js' */
+
+const { URI } = require('vscode-uri');
+
+/**
+ * Get virtual code from the encoded document URI
+ * @param {LanguageServiceContext} context
+ * @param {TextDocument} document
+ * @returns {RippleVirtualCode}
+ */
+function getVirtualCode(document, context) {
+	const uri = URI.parse(document.uri);
+	const decoded = /** @type {[documentUri: URI, embeddedCodeId: string]} */ (
+		context.decodeEmbeddedDocumentUri(uri)
+	);
+	const [sourceUri, virtualCodeId] = decoded;
+	const sourceScript = context.language.scripts.get(sourceUri);
+	const virtualCode = /** @type {RippleVirtualCode} */ (
+		sourceScript?.generated?.embeddedCodes.get(virtualCodeId)
+	);
+
+	return virtualCode;
+}
+
+module.exports = {
+	getVirtualCode,
+};