@ripple-ts/language-server 0.3.41 → 0.3.42

package/src/definitionPlugin.js

@@ -1,208 +0,0 @@
-/** @import { LanguageServicePlugin, LocationLink } from '@volar/language-server'; */
-/** @import { DefinitionLocation } from '@tsrx/ripple'; */
-
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import { getVirtualCode, createLogging, getWordFromPosition } from './utils.js';
-import path from 'path';
-import {
-	normalizeFileNameOrUri,
-	getRippleDirForFile,
-	getCachedTypeDefinitionFile,
-	getCachedTypeMatches,
-} from '@tsrx/typescript-plugin/src/language.js';
-
-const { log } = createLogging('[Ripple Definition Plugin]');
-/** @type {string | undefined} */
-let ripple_dir;
-
-/**
- * @returns {LanguageServicePlugin}
- */
-export function createDefinitionPlugin() {
-	return {
-		name: 'ripple-definition',
-		capabilities: {
-			definitionProvider: true,
-		},
-		create(context) {
-			return {
-				async provideDefinition(document, position, token) {
-					// Get TypeScript definition from typescript-semantic service
-					/** @type {LocationLink[]} */
-					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;
-						}
-					}
-
-					const { virtualCode, sourceUri } = getVirtualCode(document, context);
-
-					if (virtualCode.languageId !== 'ripple') {
-						// like embedded css
-						log(`Skipping definitions processing in the '${virtualCode.languageId}' context`);
-						return tsDefinitions;
-					}
-
-					// First check for custom definitions (e.g., CSS class selectors)
-					const offset = document.offsetAt(position);
-					const text = document.getText();
-					// Find word boundaries
-					const { word, start, end } = getWordFromPosition(text, offset);
-					const customMapping = virtualCode.findMappingByGeneratedRange(start, end);
-
-					log(`Cursor position in generated code for word '${word}':`, position);
-					log(`Cursor offset in generated code for word '${word}':`, offset);
-
-					// Handle `typeReplace` definitions
-					if (
-						customMapping?.data.customData.definition !== false &&
-						customMapping?.data.customData.definition?.typeReplace
-					) {
-						const { name: typeName, path: typePath } =
-							customMapping.data.customData.definition.typeReplace;
-
-						log(`Found replace definition for ${typeName}`);
-
-						const filePath = sourceUri.fsPath || sourceUri.path;
-						ripple_dir = ripple_dir ?? getRippleDirForFile(normalizeFileNameOrUri(filePath));
-
-						if (!ripple_dir) {
-							log(`Could not determine Ripple source directory for file: ${filePath}`);
-							return;
-						}
-
-						const typesFilePath = path.join(ripple_dir, ...typePath.split('/'));
-
-						const fileContent = getCachedTypeDefinitionFile(typesFilePath);
-
-						if (!fileContent) {
-							// the `getCachedTypeDefinitionFile` already logs the error
-							return;
-						}
-
-						const match = getCachedTypeMatches(typeName, fileContent);
-
-						if (match && match.index !== undefined) {
-							const classStart = match.index + match[0].indexOf(typeName);
-							const classEnd = classStart + typeName.length;
-
-							// Convert offset to line/column
-							const lines = fileContent.substring(0, classStart).split('\n');
-							const line = lines.length - 1;
-							const character = lines[lines.length - 1].length;
-
-							const endLines = fileContent.substring(0, classEnd).split('\n');
-							const endLine = endLines.length - 1;
-							const endCharacter = endLines[endLines.length - 1].length;
-
-							// Create the origin selection range for #Map/#Set
-							const generatedStart = customMapping.generatedOffsets[0];
-							const generatedEnd = generatedStart + customMapping.generatedLengths[0];
-							const originStart = document.positionAt(generatedStart);
-							const originEnd = document.positionAt(generatedEnd);
-
-							/** @type {LocationLink} */
-							const locationLink = {
-								targetUri: `file://${typesFilePath}`,
-								targetRange: {
-									start: { line, character },
-									end: { line: endLine, character: endCharacter },
-								},
-								targetSelectionRange: {
-									start: { line, character },
-									end: { line: endLine, character: endCharacter },
-								},
-								originSelectionRange: {
-									start: originStart,
-									end: originEnd,
-								},
-							};
-
-							log(`Created definition link to ${typesFilePath}:${line}:${character}`);
-							return [locationLink];
-						}
-					}
-
-					// Handle embedded code definition location, e.g. CSS class selectors
-					if (
-						customMapping?.data.customData.definition !== false &&
-						customMapping?.data.customData.definition?.location
-					) {
-						const def = customMapping.data.customData.definition;
-						const loc = /** @type {DefinitionLocation} */ (def.location);
-
-						const embeddedCode = loc.embeddedId
-							? virtualCode.embeddedCodes?.find(
-									(/** @type {{ id: string }} */ { id }) => id === loc.embeddedId,
-								)
-							: undefined;
-
-						if (embeddedCode) {
-							const embedMapping = embeddedCode.mappings[0];
-
-							// Calculate the position in the source document
-							// CSS offset relative to embedded code start + source offset of CSS region
-							const sourceStartOffset = embedMapping.sourceOffsets[0] + loc.start;
-							const sourceEndOffset = embedMapping.sourceOffsets[0] + loc.end;
-
-							log(
-								'Source document offsets - start for matching css:',
-								sourceStartOffset,
-								'end:',
-								sourceEndOffset,
-							);
-
-							// Calculate line/column positions using the source document's proper encoding
-							// Create a TextDocument from the source code for proper position calculations
-							const sourceDocument = TextDocument.create(
-								sourceUri.toString(),
-								'ripple',
-								0,
-								virtualCode.originalCode,
-							);
-							const targetStart = sourceDocument.positionAt(sourceStartOffset);
-							const targetEnd = sourceDocument.positionAt(sourceEndOffset);
-
-							log('Target positions in source - start:', targetStart, 'end:', targetEnd);
-
-							// The origin selection range should be in the virtual document
-							// not in the source document!
-							const generatedStart = customMapping.generatedOffsets[0];
-							const generatedEnd = generatedStart + customMapping.generatedLengths[0];
-							const originStart = document.positionAt(generatedStart);
-							const originEnd = document.positionAt(generatedEnd);
-
-							log('Origin positions - start:', originStart, 'end:', originEnd);
-
-							/** @type {LocationLink} */
-							tsDefinitions.push({
-								targetUri: sourceUri.toString(), // Use the actual source file URI
-								targetRange: {
-									start: targetStart,
-									end: targetEnd,
-								},
-								targetSelectionRange: {
-									start: targetStart,
-									end: targetEnd,
-								},
-								originSelectionRange: {
-									start: originStart,
-									end: originEnd,
-								},
-							});
-
-							return tsDefinitions;
-						}
-					}
-
-					return tsDefinitions;
-				},
-			};
-		},
-	};
-}

package/src/documentHighlightPlugin.js

@@ -1,118 +0,0 @@
-/** @import { LanguageServicePlugin } from '@volar/language-server' */
-/** @import { LanguageServicePluginInstance } from '@volar/language-server' */
-
-import { getVirtualCode, getWordFromPosition, createLogging } from './utils.js';
-const { log } = createLogging('[Ripple Document Highlight Plugin]');
-
-/**
- * Document Highlight plugin for Ripple
- * Provides word highlighting (grey background) for custom Ripple keywords like 'pending'
- * @returns {LanguageServicePlugin}
- */
-export function createDocumentHighlightPlugin() {
-	return {
-		name: 'ripple-document-highlight',
-		capabilities: {
-			documentHighlightProvider: true,
-		},
-		create(context) {
-			/** @type {LanguageServicePluginInstance['provideDocumentHighlights']} */
-			let originalProvideDocumentHighlights;
-			/** @type {LanguageServicePluginInstance} */
-			let originalInstance;
-
-			// Get TypeScript's document highlights provider
-			for (const [plugin, instance] of context.plugins) {
-				if (plugin.name === 'typescript-semantic' && instance.provideDocumentHighlights) {
-					originalInstance = instance;
-					originalProvideDocumentHighlights = instance.provideDocumentHighlights;
-					instance.provideDocumentHighlights = undefined;
-					break;
-				}
-			}
-
-			if (!originalProvideDocumentHighlights) {
-				log(
-					"'typescript-semantic plugin' was not found or has no 'provideDocumentHighlights'. \
-					Document highlights will be limited to custom Ripple keywords only.",
-				);
-			}
-
-			return {
-				async provideDocumentHighlights(document, position, token) {
-					if (!originalProvideDocumentHighlights) {
-						return null;
-					}
-
-					let tsHighlights = await originalProvideDocumentHighlights.call(
-						originalInstance,
-						document,
-						position,
-						token,
-					);
-
-					if (!tsHighlights || tsHighlights.length > 0) {
-						// If TypeScript recognized tokens and provided highlights, return them
-						return tsHighlights;
-					}
-
-					const { virtualCode } = getVirtualCode(document, context);
-
-					if (virtualCode.languageId !== 'ripple') {
-						log(`Skipping highlight processing in the '${virtualCode.languageId}' context`);
-						return tsHighlights;
-					}
-
-					// Check if we're on a custom Ripple keyword
-					const offset = document.offsetAt(position);
-					const text = document.getText();
-
-					// Find word boundaries
-					const { word } = getWordFromPosition(text, offset);
-
-					// If the word is a Ripple keyword, find all occurrences in the document
-
-					const regex = new RegExp(`\\b${word}\\b`, 'g');
-					let match;
-
-					while ((match = regex.exec(text)) !== null) {
-						const start = match.index;
-						const end = match.index + word.length;
-						const mapping = virtualCode.findMappingByGeneratedRange(start, end);
-
-						if (!mapping) {
-							// If no mapping, skip all others as well
-							// This shouldn't happen as TS handles only mapped ranges
-							return tsHighlights;
-						}
-
-						if (!mapping.data.customData?.wordHighlight?.kind) {
-							// Skip if we didn't define word highlighting in segments
-							continue;
-						}
-
-						if (!tsHighlights) {
-							tsHighlights = [];
-						}
-
-						tsHighlights.push({
-							range: {
-								start: document.positionAt(start),
-								end: document.positionAt(end),
-							},
-
-							kind: mapping.data.customData.wordHighlight.kind,
-						});
-					}
-
-					if (tsHighlights.length > 0) {
-						log(`Found ${tsHighlights.length} occurrences of '${word}'`);
-					}
-
-					// Return TypeScript highlights if no custom keyword was found
-					return [...tsHighlights];
-				},
-			};
-		},
-	};
-}

package/src/hoverPlugin.js

@@ -1,146 +0,0 @@
-/**
- @import {
- 	LanguageServicePlugin,
-	LanguageServicePluginInstance,
-	MarkupContent,
-} from '@volar/language-server'; */
-
-import {
-	getVirtualCode,
-	createLogging,
-	getWordFromPosition,
-	concatMarkdownContents,
-	deobfuscateIdentifiers,
-} from './utils.js';
-
-const { log, logError } = createLogging('[Ripple Hover Plugin]');
-
-/**
- * @returns {LanguageServicePlugin}
- */
-export function createHoverPlugin() {
-	return {
-		name: 'ripple-hover',
-		capabilities: {
-			hoverProvider: true,
-		},
-		create(context) {
-			/** @type {LanguageServicePluginInstance['provideHover']} */
-			let originalProvideHover;
-			/** @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;
-					originalProvideHover = instance.provideHover;
-					instance.provideHover = undefined;
-					break;
-				}
-			}
-
-			if (!originalProvideHover) {
-				logError(
-					"'typescript-semantic plugin' was not found or has no 'provideHover'. \
-					This plugin must be loaded after Volar's typescript-semantic plugin.",
-				);
-			}
-			return {
-				async provideHover(document, position, token) {
-					// Get TypeScript hover from typescript-semantic service
-					let tsHover = null;
-					if (originalProvideHover) {
-						tsHover = await originalProvideHover.call(originalInstance, document, position, token);
-					}
-
-					if (tsHover && tsHover.contents) {
-						/** @type {MarkupContent} **/ (tsHover.contents).value = deobfuscateIdentifiers(
-							/** @type {MarkupContent} **/ (tsHover.contents).value,
-						);
-					}
-
-					const { virtualCode } = getVirtualCode(document, context);
-
-					if (!virtualCode) {
-						return tsHover;
-					}
-
-					/** @type {number} */
-					let starOffset;
-					/** @type {number} */
-					let endOffset;
-
-					if (tsHover && tsHover.range) {
-						starOffset = document.offsetAt(tsHover.range.start);
-						endOffset = document.offsetAt(tsHover.range.end);
-					} else {
-						const offset = document.offsetAt(position);
-						const text = document.getText();
-						// Find word boundaries
-						const { word, start, end } = getWordFromPosition(text, offset);
-						starOffset = start;
-						endOffset = end;
-
-						log(`Cursor position in generated code for word '${word}':`, position);
-						log(`Cursor offset in generated code for word '${word}':`, offset);
-					}
-
-					if (virtualCode.languageId !== 'ripple') {
-						log(`Skipping hover processing in the '${virtualCode.languageId}' context`);
-						return tsHover;
-					}
-
-					const mapping = virtualCode.findMappingByGeneratedRange(starOffset, endOffset);
-
-					if (!mapping) {
-						return tsHover;
-					}
-
-					const customHover = mapping?.data?.customData?.hover;
-
-					if (customHover === undefined) {
-						return tsHover;
-					}
-
-					if (typeof customHover === 'function') {
-						if (tsHover) {
-							/** @type {MarkupContent} **/ (tsHover.contents).value = customHover(
-								/** @type {MarkupContent} **/ (tsHover.contents).value,
-							);
-							log('Modified hover contents using custom hover function');
-						}
-						return tsHover;
-					} else if (typeof customHover === 'string') {
-						const contents = tsHover
-							? concatMarkdownContents(
-									/** @type {MarkupContent} **/ (tsHover.contents).value,
-									customHover,
-								)
-							: customHover;
-						log('Found custom hover data in mapping');
-						return {
-							contents: {
-								kind: 'markdown',
-								value: contents,
-							},
-							range: {
-								start: position,
-								end: position,
-							},
-						};
-					} else if (customHover === false) {
-						log(
-							`Hover explicitly suppressed in mapping at range start: ${starOffset}, end: ${endOffset}`,
-						);
-						return null;
-					}
-
-					log('Found mapping for hover at range', 'start: ', starOffset, 'end: ', endOffset);
-
-					return tsHover;
-				},
-			};
-		},
-	};
-}

package/src/server.js

@@ -1,155 +0,0 @@
-/** @import {CompilerOptions} from 'typescript' */
-
-import { createLogging } from './utils.js';
-import {
-	createConnection,
-	createServer,
-	createTypeScriptProject,
-} from '@volar/language-server/node';
-import { createCompileErrorDiagnosticPlugin } from './compileErrorDiagnosticPlugin.js';
-import { createDefinitionPlugin } from './definitionPlugin.js';
-import { createHoverPlugin } from './hoverPlugin.js';
-import { createCompletionPlugin } from './completionPlugin.js';
-import { createAutoInsertPlugin } from './autoInsertPlugin.js';
-import { createTypeScriptDiagnosticFilterPlugin } from './typescriptDiagnosticPlugin.js';
-import { createDocumentHighlightPlugin } from './documentHighlightPlugin.js';
-import { getRippleLanguagePlugin, resolveConfig } from '@tsrx/typescript-plugin/src/language.js';
-import { createTypeScriptServices } from './typescriptService.js';
-import { create as createCssService } from 'volar-service-css';
-
-const { log, logError } = createLogging('[Ripple Language Server]');
-
-export 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',
-							);
-						},
-					};
-				}),
-				[
-					createAutoInsertPlugin(),
-					createCompletionPlugin(),
-					createCompileErrorDiagnosticPlugin(),
-					createDefinitionPlugin(),
-					createCssService(),
-					...createTypeScriptServices(ts),
-					// !IMPORTANT 'createTypeScriptDiagnosticFilterPlugin', 'createHoverPlugin',
-					// and 'createDocumentHighlightPlugin' must come after TypeScript services
-					// to intercept volar's and vscode default providers
-					createTypeScriptDiagnosticFilterPlugin(),
-					createHoverPlugin(),
-					createDocumentHighlightPlugin(),
-				],
-			);
-
-			log('Server initialization complete');
-			return initResult;
-		} catch (initError) {
-			logError('Server initialization failed:', initError);
-			throw initError;
-		}
-	});
-
-	connection.onInitialized(async () => {
-		log('Server initialized.');
-		server.initialized();
-
-		// Register file watchers for TypeScript/JavaScript files so the language
-		// server is notified when they change on disk. Without this, changes to
-		// .ts files that are imported by .tsrx files are not detected, causing
-		// stale diagnostics until the server is restarted.
-		try {
-			await server.fileWatcher.watchFiles([
-				'**/*.ts',
-				'**/*.tsx',
-				'**/*.cts',
-				'**/*.mts',
-				'**/*.js',
-				'**/*.jsx',
-				'**/*.cjs',
-				'**/*.mjs',
-				'**/*.d.ts',
-				'**/tsconfig.json',
-				'**/jsconfig.json',
-			]);
-			log('File watchers registered for TypeScript/JavaScript files.');
-		} catch (err) {
-			logError('Failed to register file watchers:', err);
-		}
-	});
-
-	process.on('uncaughtException', (err) => {
-		logError('Uncaught exception:', err);
-	});
-
-	process.on('unhandledRejection', (reason, promise) => {
-		logError('Unhandled rejection at:', promise, 'reason:', reason);
-	});
-
-	return { connection, server };
-}