@ripple-ts/language-server 0.2.186 → 0.2.188

package/package.json

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

package/src/typescriptDiagnosticPlugin.js

@@ -1,11 +1,77 @@
-/** @import { LanguageServicePlugin } from '@volar/language-server' */
-/** @import { LanguageServicePluginInstance } from '@volar/language-server' */
+/**
+ @import {
+	LanguageServicePlugin,
+	LanguageServicePluginInstance,
+	LanguageServiceContext,
+	Diagnostic,
+} from '@volar/language-server';
+@import {TextDocument} from 'vscode-languageserver-textdocument';
+ */
 
 const { getVirtualCode, createLogging } = require('./utils.js');
 
 const { log, logError } = createLogging('[Ripple TypeScript Diagnostic Plugin]');
 
 /**
+ * Filter diagnostics based on suppressed diagnostic codes in mappings.
+ * @param {TextDocument} document
+ * @param {LanguageServiceContext} context
+ * @param {Diagnostic[]} diagnostics
+ * @returns {Diagnostic[]}
+ */
+function filterDiagnostics(document, context, diagnostics) {
+	if (!diagnostics || diagnostics.length === 0) {
+		return diagnostics;
+	}
+
+	log(`Filtering ${diagnostics.length} TypeScript diagnostics for ${document.uri}`);
+
+	const [virtualCode] = getVirtualCode(document, context);
+
+	if (!virtualCode) {
+		return diagnostics;
+	}
+
+	const filtered = diagnostics.filter((diagnostic) => {
+		const range = diagnostic.range;
+		const rangeStart = document.offsetAt(range.start);
+		const rangeEnd = document.offsetAt(range.end);
+		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;
+		}
+
+		return true;
+	});
+
+	log(`Filtered from ${diagnostics.length} to ${filtered.length} diagnostics`);
+	return filtered;
+}
+
+/**
+ * Creates a plugin that wraps typescript-semantic's provideDiagnostics
+ * to filter out suppressed diagnostics while maintaining the original
+ * plugin association. This is crucial for code actions (like "Add import")
+ * to work correctly, as volar matches diagnostics by pluginIndex.
  * @returns {LanguageServicePlugin}
  */
 function createTypeScriptDiagnosticFilterPlugin() {
@@ -13,87 +79,42 @@ function createTypeScriptDiagnosticFilterPlugin() {
 
 	return {
 		name: 'ripple-typescript-diagnostic-filter',
-		capabilities: {
-			diagnosticProvider: {
-				interFileDependencies: false,
-				workspaceDiagnostics: false,
-			},
-		},
+		// No capabilities - this plugin only wraps typescript-semantic
+		capabilities: {},
 		create(context) {
-			/** @type {LanguageServicePluginInstance['provideDiagnostics']} */
-			let originalProvideDiagnostics;
-			/** @type {LanguageServicePluginInstance} */
+			/** @type {LanguageServicePluginInstance['provideDiagnostics'] | undefined} */
+			let originalProvider;
+			/** @type {LanguageServicePluginInstance | undefined} */
 			let originalInstance;
 
-			// Disable typescript-semantic's provideDiagnostics 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;
+					originalProvider = instance.provideDiagnostics;
+
+					// Wrap the original function to filter diagnostics
+					// This maintains the plugin association for code actions
+					instance.provideDiagnostics = async function (document, token) {
+						const diagnostics = await originalProvider?.call(originalInstance, document, token);
+						return filterDiagnostics(document, context, diagnostics ?? []);
+					};
+
+					log('Successfully wrapped typescript-semantic provideDiagnostics');
+
 					break;
 				}
 			}
 
-			if (!originalProvideDiagnostics) {
+			if (!originalProvider) {
 				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;
-				},
-			};
+			// This plugin doesn't provide any functionality itself,
+			// it only wraps typescript-semantic
+			return {};
 		},
 	};
 }