@ripple-ts/language-server 0.2.173 → 0.2.175

package/package.json

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

package/src/definitionPlugin.js

@@ -0,0 +1,127 @@
+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
+ */
+
+const DEBUG = process.env.RIPPLE_DEBUG === 'true';
+
+/**
+ * @param {...unknown} args
+ */
+function log(...args) {
+	if (DEBUG) {
+		console.log('[Ripple Definition]', ...args);
+	}
+}
+
+/**
+ * @returns {LanguageServicePlugin}
+ */
+function createDefinitionPlugin() {
+	return {
+		name: 'ripple-definition',
+		capabilities: {
+			definitionProvider: true,
+		},
+		create(/** @type {LanguageServiceContext} */ context) {
+			return {
+				/**
+				 * Provide definition with component keyword support
+				 * @param {import('vscode-languageserver-textdocument').TextDocument} document
+				 * @param {import('@volar/language-server').Position} position
+				 * @param {import('@volar/language-server').CancellationToken} token
+				 */
+				async provideDefinition(document, position, token) {
+					const uri = URI.parse(document.uri);
+					const decoded = context.decodeEmbeddedDocumentUri(uri);
+
+					// Get TypeScript definition from typescript-semantic service
+					let tsDefinitions = [];
+					for (const [plugin, instance] of context.plugins) {
+						if (plugin.name === 'typescript-semantic' && instance.provideDefinition) {
+							const result = await instance.provideDefinition(document, position, token);
+							if (result) {
+								tsDefinitions.push(...(Array.isArray(result) ? result : [result]));
+							}
+							break;
+						}
+					}
+
+					// If no TypeScript definitions, nothing to modify
+					// Volar will let the next ts plugin handle it
+					if (tsDefinitions.length === 0) {
+						return;
+					}
+
+					// If not in a Ripple embedded context, just return TypeScript results
+					if (!decoded) {
+						return tsDefinitions;
+					}
+
+					const [sourceUri, virtualCodeId] = decoded;
+					const sourceScript = context.language.scripts.get(sourceUri);
+					const virtualCode = sourceScript?.generated?.embeddedCodes.get(virtualCodeId);
+
+					if (!(virtualCode instanceof RippleVirtualCode) || !virtualCode.mappings) {
+						return tsDefinitions;
+					}
+
+					// Get the range from TypeScript's definition to find the exact token
+					// This gives us the precise start and end of the token (e.g., "function")
+					const firstDefinition = tsDefinitions[0];
+					if (!firstDefinition?.originSelectionRange) {
+						return tsDefinitions;
+					}
+
+					const range = firstDefinition.originSelectionRange;
+					const rangeStart = document.offsetAt(range.start);
+					const rangeEnd = document.offsetAt(range.end);
+
+					// Find the mapping using the exact token range for O(1) lookup
+					const mapping = virtualCode.findMappingByGeneratedRange(rangeStart, rangeEnd);
+
+					if (!mapping) {
+						return tsDefinitions;
+					}
+
+					log('Found mapping for definition at range', 'start: ', rangeStart, 'end: ', rangeEnd);
+
+					// Check if source length is greater than generated length (component -> function)
+					const customData = mapping.data.customData;
+					const sourceLength = mapping.lengths[0];
+					const generatedLength = customData.generatedLengths[0];
+
+					// If no generatedLengths, or source and generated are same length, no transformation
+					if (sourceLength <= generatedLength) {
+						return tsDefinitions;
+					}
+
+					const diffLength = sourceLength - generatedLength;
+
+					for (const definition of tsDefinitions) {
+						const tsRange = definition.originSelectionRange;
+						if (!tsRange) {
+							continue;
+						}
+
+						definition.originSelectionRange = {
+							start: tsRange.start,
+							end: {
+								line: tsRange.end.line,
+								character: tsRange.end.character + diffLength,
+							},
+						};
+					}
+					return tsDefinitions;
+				},
+			};
+		},
+	};
+}
+
+module.exports = {
+	createDefinitionPlugin,
+};

package/src/diagnosticPlugin.js

@@ -31,7 +31,7 @@ function logError(...args) {
 /**
  * @returns {LanguageServicePlugin}
  */
-function createRippleDiagnosticPlugin() {
+function createDiagnosticPlugin() {
 	log('Creating Ripple diagnostic plugin...');
 
 	return {
@@ -236,5 +236,5 @@ function getEmbeddedInfo(context, document) {
 }
 
 module.exports = {
-	createRippleDiagnosticPlugin,
+	createDiagnosticPlugin,
 };

package/src/server.js

@@ -3,8 +3,12 @@
 	createServer,
 	createTypeScriptProject,
 } = require('@volar/language-server/node');
-const { createRippleDiagnosticPlugin } = require('./diagnosticPlugin.js');
-const { getRippleLanguagePlugin, resolveConfig } = require('@ripple-ts/typescript-plugin/src/language.js');
+const { createDiagnosticPlugin } = require('./diagnosticPlugin.js');
+const { createDefinitionPlugin } = require('./definitionPlugin.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';
@@ -86,24 +90,20 @@ function createRippleLanguageServer() {
 
 			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),
-				],
+				createTypeScriptProject(ts, undefined, ({ projectHost }) => {
+					wrapCompilerOptionsProvider(projectHost, 'getCompilationSettings');
+
+					return {
+						languagePlugins: [rippleLanguagePlugin],
+						setup({ project }) {
+							wrapCompilerOptionsProvider(
+								project?.typescript?.languageServiceHost,
+								'getCompilationSettings',
+							);
+						},
+					};
+				}),
+				[createDiagnosticPlugin(), createDefinitionPlugin(), ...createTypeScriptServices(ts)],
 			);
 
 			log('Server initialization complete');