@astrojs/ts-plugin 1.0.9 → 1.0.10

package/src/language-service/find-references.ts

@@ -1,90 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from '../astro-snapshots.js';
-import type { Logger } from '../logger';
-import { isAstroFilePath, isNotNullOrUndefined } from '../utils.js';
-
-export function decorateFindReferences(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-): void {
-	decorateGetReferencesAtPosition(ls, snapshotManager, logger);
-	_decorateFindReferences(ls, snapshotManager, logger);
-}
-
-function _decorateFindReferences(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-) {
-	const findReferences = ls.findReferences;
-	ls.findReferences = (fileName, position) => {
-		const references = findReferences(fileName, position);
-		return references
-			?.map((reference) => {
-				const snapshot = snapshotManager.get(reference.definition.fileName);
-				if (!isAstroFilePath(reference.definition.fileName) || !snapshot) {
-					return reference;
-				}
-
-				const textSpan = snapshot.getOriginalTextSpan(reference.definition.textSpan);
-				if (!textSpan) {
-					return null;
-				}
-
-				return {
-					definition: {
-						...reference.definition,
-						textSpan,
-						// Spare the work for now
-						originalTextSpan: undefined,
-					},
-					references: mapReferences(reference.references, snapshotManager, logger),
-				};
-			})
-			.filter(isNotNullOrUndefined);
-	};
-}
-
-function decorateGetReferencesAtPosition(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-) {
-	const getReferencesAtPosition = ls.getReferencesAtPosition;
-	ls.getReferencesAtPosition = (fileName, position) => {
-		const references = getReferencesAtPosition(fileName, position);
-		return references && mapReferences(references, snapshotManager, logger);
-	};
-}
-
-function mapReferences(
-	references: ts.ReferenceEntry[],
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-): ts.ReferenceEntry[] {
-	return references
-		.map((reference) => {
-			const snapshot = snapshotManager.get(reference.fileName);
-			if (!isAstroFilePath(reference.fileName) || !snapshot) {
-				return reference;
-			}
-
-			const textSpan = snapshot.getOriginalTextSpan(reference.textSpan);
-			if (!textSpan) {
-				return null;
-			}
-
-			logger.debug('Find references; map textSpan: changed', reference.textSpan, 'to', textSpan);
-
-			return {
-				...reference,
-				textSpan,
-				// Spare the work for now
-				contextSpan: undefined,
-				originalTextSpan: undefined,
-				originalContextSpan: undefined,
-			};
-		})
-		.filter(isNotNullOrUndefined);
-}

package/src/language-service/implementation.ts

@@ -1,34 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from '../astro-snapshots.js';
-import { isAstroFilePath, isNotNullOrUndefined } from '../utils.js';
-
-export function decorateGetImplementation(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager
-): void {
-	const getImplementationAtPosition = ls.getImplementationAtPosition;
-	ls.getImplementationAtPosition = (fileName, position) => {
-		const implementation = getImplementationAtPosition(fileName, position);
-		return implementation
-			?.map((impl) => {
-				if (!isAstroFilePath(impl.fileName)) {
-					return impl;
-				}
-
-				const textSpan = snapshotManager.get(impl.fileName)?.getOriginalTextSpan(impl.textSpan);
-				if (!textSpan) {
-					return undefined;
-				}
-
-				return {
-					...impl,
-					textSpan,
-					// Spare the work for now
-					contextSpan: undefined,
-					originalTextSpan: undefined,
-					originalContextSpan: undefined,
-				};
-			})
-			.filter(isNotNullOrUndefined);
-	};
-}

package/src/language-service/index.ts

@@ -1,56 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from '../astro-snapshots.js';
-import type { Logger } from '../logger';
-import { decorateCompletions } from './completions.js';
-import { decorateGetDefinition } from './definition.js';
-import { decorateDiagnostics } from './diagnostics.js';
-import { decorateGetFileReferences } from './file-references.js';
-import { decorateFindReferences } from './find-references.js';
-import { decorateGetImplementation } from './implementation.js';
-import { decorateLineColumnOffset } from './line-column-offset.js';
-import { decorateRename } from './rename.js';
-
-const astroPluginPatchSymbol = Symbol('astroPluginPatchSymbol');
-
-export function isPatched(ls: ts.LanguageService) {
-	return (ls as any)[astroPluginPatchSymbol] === true;
-}
-
-export function decorateLanguageService(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	ts: typeof import('typescript/lib/tsserverlibrary'),
-	logger: Logger
-): ts.LanguageService {
-	const proxy = new Proxy(ls, createProxyHandler());
-
-	decorateLineColumnOffset(proxy, snapshotManager);
-	decorateRename(proxy, snapshotManager, logger);
-	decorateDiagnostics(proxy, ts);
-	decorateFindReferences(proxy, snapshotManager, logger);
-	decorateCompletions(proxy, logger);
-	decorateGetDefinition(proxy, snapshotManager);
-	decorateGetImplementation(proxy, snapshotManager);
-	decorateGetFileReferences(proxy, snapshotManager);
-
-	return proxy;
-}
-
-function createProxyHandler(): ProxyHandler<ts.LanguageService> {
-	const decorated: Partial<ts.LanguageService> = {};
-
-	return {
-		get(target, p) {
-			if (p === astroPluginPatchSymbol) {
-				return true;
-			}
-
-			return decorated[p as keyof ts.LanguageService] ?? target[p as keyof ts.LanguageService];
-		},
-		set(_, p, value) {
-			decorated[p as keyof ts.LanguageService] = value;
-
-			return true;
-		},
-	};
-}

package/src/language-service/line-column-offset.ts

@@ -1,24 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from '../astro-snapshots';
-import { isAstroFilePath } from '../utils';
-
-export function decorateLineColumnOffset(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager
-) {
-	if (!ls.toLineColumnOffset) {
-		return;
-	}
-
-	// We need to patch this because (according to source, only) getDefinition uses this
-	const toLineColumnOffset = ls.toLineColumnOffset;
-	ls.toLineColumnOffset = (fileName, position) => {
-		if (isAstroFilePath(fileName)) {
-			const snapshot = snapshotManager.get(fileName);
-			if (snapshot) {
-				return snapshot.positionAt(position);
-			}
-		}
-		return toLineColumnOffset(fileName, position);
-	};
-}

package/src/language-service/rename.ts

@@ -1,46 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from '../astro-snapshots.js';
-import type { Logger } from '../logger.js';
-import { isAstroFilePath, isNotNullOrUndefined } from '../utils.js';
-
-export function decorateRename(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-): void {
-	const findRenameLocations = ls.findRenameLocations;
-	ls.findRenameLocations = (fileName, position, findInStrings, findInComments, preferences) => {
-		const renameLocations = findRenameLocations(
-			fileName,
-			position,
-			findInStrings,
-			findInComments,
-			preferences as ts.UserPreferences
-		);
-		return renameLocations
-			?.map((renameLocation) => {
-				const snapshot = snapshotManager.get(renameLocation.fileName);
-				if (!isAstroFilePath(renameLocation.fileName) || !snapshot) {
-					return renameLocation;
-				}
-
-				// TODO more needed to filter invalid locations, see RenameProvider
-				const textSpan = snapshot.getOriginalTextSpan(renameLocation.textSpan);
-				if (!textSpan) {
-					return null;
-				}
-
-				const converted = {
-					...renameLocation,
-					textSpan,
-				};
-				if (converted.contextSpan) {
-					// Not important, spare the work
-					converted.contextSpan = undefined;
-				}
-				logger.debug('Converted rename location ', converted);
-				return converted;
-			})
-			.filter(isNotNullOrUndefined);
-	};
-}

package/src/logger.ts

@@ -1,41 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-
-export class Logger {
-	constructor(
-		private tsLogService: ts.server.Logger,
-		suppressNonAstroLogs = false,
-		private logDebug = false
-	) {
-		if (suppressNonAstroLogs) {
-			const log = this.tsLogService.info.bind(this.tsLogService);
-			this.tsLogService.info = (s: string) => {
-				if (s.startsWith('-Astro Plugin-')) {
-					log(s);
-				}
-			};
-		}
-	}
-
-	log(...args: any[]) {
-		const str = args
-			.map((arg) => {
-				if (typeof arg === 'object') {
-					try {
-						return JSON.stringify(arg);
-					} catch (e) {
-						return '[object that cannot by stringified]';
-					}
-				}
-				return arg;
-			})
-			.join(' ');
-		this.tsLogService.info('-Astro Plugin- ' + str);
-	}
-
-	debug(...args: any[]) {
-		if (!this.logDebug) {
-			return;
-		}
-		this.log(...args);
-	}
-}

package/src/module-loader.ts

@@ -1,219 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from './astro-snapshots.js';
-import { createAstroSys } from './astro-sys.js';
-import type { Logger } from './logger.js';
-import { ensureRealAstroFilePath, isVirtualAstroFilePath } from './utils.js';
-
-/**
- * Caches resolved modules.
- */
-class ModuleResolutionCache {
-	private cache = new Map<string, ts.ResolvedModuleFull>();
-
-	/**
-	 * Tries to get a cached module.
-	 */
-	get(moduleName: string, containingFile: string): ts.ResolvedModuleFull | undefined {
-		return this.cache.get(this.getKey(moduleName, containingFile));
-	}
-
-	/**
-	 * Caches resolved module, if it is not undefined.
-	 */
-	set(
-		moduleName: string,
-		containingFile: string,
-		resolvedModule: ts.ResolvedModuleFull | undefined
-	) {
-		if (!resolvedModule) {
-			return;
-		}
-		this.cache.set(this.getKey(moduleName, containingFile), resolvedModule);
-	}
-
-	/**
-	 * Deletes module from cache. Call this if a file was deleted.
-	 * @param resolvedModuleName full path of the module
-	 */
-	delete(resolvedModuleName: string): void {
-		this.cache.forEach((val, key) => {
-			if (val.resolvedFileName === resolvedModuleName) {
-				this.cache.delete(key);
-			}
-		});
-	}
-
-	private getKey(moduleName: string, containingFile: string) {
-		return containingFile + ':::' + ensureRealAstroFilePath(moduleName);
-	}
-}
-
-/**
- * Creates a module loader than can also resolve `.astro` files.
- *
- * The typescript language service tries to look up other files that are referenced in the currently open astro file.
- * For `.ts`/`.js` files this works, for `.astro` files it does not by default.
- * Reason: The typescript language service does not know about the `.astro` file ending,
- * so it assumes it's a normal typescript file and searches for files like `../Component.astro.ts`, which is wrong.
- * In order to fix this, we need to wrap typescript's module resolution and reroute all `.astro.ts` file lookups to .astro.
- */
-export function patchModuleLoader(
-	logger: Logger,
-	snapshotManager: AstroSnapshotManager,
-	typescript: typeof ts,
-	lsHost: ts.LanguageServiceHost,
-	project: ts.server.Project
-): void {
-	const astroSys = createAstroSys(logger, typescript);
-	const moduleCache = new ModuleResolutionCache();
-	const origResolveModuleNames = lsHost.resolveModuleNames?.bind(lsHost);
-	const origResolveModuleNamLiterals = lsHost.resolveModuleNameLiterals?.bind(lsHost);
-
-	if (lsHost.resolveModuleNameLiterals) {
-		lsHost.resolveModuleNameLiterals = resolveModuleNameLiterals;
-	} else {
-		lsHost.resolveModuleNames = resolveModuleNames;
-	}
-
-	const origRemoveFile = project.removeFile.bind(project);
-	project.removeFile = (info, fileExists, detachFromProject) => {
-		logger.log('File is being removed. Delete from cache: ', info.fileName);
-		moduleCache.delete(info.fileName);
-		return origRemoveFile(info, fileExists, detachFromProject);
-	};
-
-	// Patch readDirectory so we get completions for .astro files
-	const origReadDirectory = project.readDirectory.bind(project);
-	project.readDirectory = (path, extensions, exclude, include, depth) => {
-		const extensionsWithAstro = (extensions ?? []).concat('.astro', '.md', '.mdx');
-		return origReadDirectory(path, extensionsWithAstro, exclude, include, depth);
-	};
-
-	function resolveModuleNames(
-		moduleNames: string[],
-		containingFile: string,
-		reusedNames: string[] | undefined,
-		redirectedReference: ts.ResolvedProjectReference | undefined,
-		compilerOptions: ts.CompilerOptions
-	): Array<ts.ResolvedModule | undefined> {
-		// logger.log('Resolving modules names for ' + containingFile);
-
-		// Try resolving all module names with the original method first.
-		// The ones that are undefined will be re-checked if they are a
-		// astro file and if so, are resolved, too. This way we can defer
-		// all module resolving logic except for astro files to TypeScript.
-		const resolved =
-			origResolveModuleNames?.(
-				moduleNames,
-				containingFile,
-				reusedNames,
-				redirectedReference,
-				compilerOptions
-			) || Array.from<undefined>(Array(moduleNames.length));
-
-		return resolved.map((moduleName, idx) => {
-			const fileName = moduleNames[idx];
-			if (moduleName || !ensureRealAstroFilePath(fileName).endsWith('.astro')) {
-				return moduleName;
-			}
-
-			const cachedModule = moduleCache.get(fileName, containingFile);
-			if (cachedModule) {
-				return cachedModule;
-			}
-
-			const resolvedModule = resolveModuleName(fileName, containingFile, compilerOptions);
-			moduleCache.set(fileName, containingFile, resolvedModule);
-			return resolvedModule;
-		});
-	}
-
-	function resolveModuleName(
-		name: string,
-		containingFile: string,
-		compilerOptions: ts.CompilerOptions
-	): ts.ResolvedModuleFull | undefined {
-		const astroResolvedModule = typescript.resolveModuleName(
-			name,
-			containingFile,
-			compilerOptions,
-			astroSys
-		).resolvedModule;
-		if (!astroResolvedModule || !isVirtualAstroFilePath(astroResolvedModule.resolvedFileName)) {
-			return astroResolvedModule;
-		}
-
-		const resolvedFileName = ensureRealAstroFilePath(astroResolvedModule.resolvedFileName);
-		logger.log('Resolved', name, 'to astro file', resolvedFileName);
-		const snapshot = snapshotManager.create(resolvedFileName);
-		if (!snapshot) {
-			return undefined;
-		}
-
-		const resolvedAstroModule: ts.ResolvedModuleFull = {
-			extension: typescript.Extension.Tsx,
-			resolvedFileName,
-		};
-		return resolvedAstroModule;
-	}
-
-	function resolveModuleNameLiterals(
-		moduleLiterals: readonly ts.StringLiteralLike[],
-		containingFile: string,
-		redirectedReference: ts.ResolvedProjectReference | undefined,
-		options: ts.CompilerOptions,
-		containingSourceFile: ts.SourceFile,
-		reusedNames: readonly ts.StringLiteralLike[] | undefined
-	): readonly ts.ResolvedModuleWithFailedLookupLocations[] {
-		logger.log('Resolving modules names for ' + containingFile);
-		// Try resolving all module names with the original method first.
-		// The ones that are undefined will be re-checked if they are a
-		// Astro file and if so, are resolved, too. This way we can defer
-		// all module resolving logic except for Astro files to TypeScript.
-		const resolved =
-			origResolveModuleNamLiterals?.(
-				moduleLiterals,
-				containingFile,
-				redirectedReference,
-				options,
-				containingSourceFile,
-				reusedNames
-			) ??
-			moduleLiterals.map(
-				(): ts.ResolvedModuleWithFailedLookupLocations => ({
-					resolvedModule: undefined,
-				})
-			);
-
-		return resolved.map((tsResolvedModule, idx) => {
-			const moduleName = moduleLiterals[idx].text;
-			if (
-				tsResolvedModule.resolvedModule ||
-				!ensureRealAstroFilePath(moduleName).endsWith('.astro')
-			) {
-				return tsResolvedModule;
-			}
-
-			return resolveAstroModuleNameFromCache(moduleName, containingFile, options);
-		});
-	}
-
-	function resolveAstroModuleNameFromCache(
-		moduleName: string,
-		containingFile: string,
-		options: ts.CompilerOptions
-	) {
-		const cachedModule = moduleCache.get(moduleName, containingFile);
-		if (cachedModule) {
-			return {
-				resolvedModule: cachedModule,
-			};
-		}
-
-		const resolvedModule = resolveModuleName(moduleName, containingFile, options);
-		moduleCache.set(moduleName, containingFile, resolvedModule);
-		return {
-			resolvedModule: resolvedModule,
-		};
-	}
-}

package/src/project-astro-files.ts

@@ -1,138 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from './astro-snapshots';
-import { getConfigPathForProject, isAstroFilePath, readProjectAstroFilesFromFs } from './utils';
-
-export class ProjectAstroFilesManager {
-	private files = new Set<string>();
-	private directoryWatchers = new Set<ts.FileWatcher>();
-
-	private static instances = new Map<string, ProjectAstroFilesManager>();
-
-	static getInstance(projectName: string) {
-		return this.instances.get(projectName);
-	}
-
-	constructor(
-		private readonly typescript: typeof ts,
-		private readonly project: ts.server.Project,
-		private readonly serverHost: ts.server.ServerHost,
-		private readonly snapshotManager: AstroSnapshotManager,
-		private parsedCommandLine: ts.ParsedCommandLine
-	) {
-		this.setupWatchers();
-		this.updateProjectAstroFiles();
-
-		ProjectAstroFilesManager.instances.set(project.getProjectName(), this);
-	}
-
-	updateProjectConfig(serviceHost: ts.LanguageServiceHost) {
-		const parsedCommandLine = serviceHost.getParsedCommandLine?.(
-			getConfigPathForProject(this.project)
-		);
-
-		if (!parsedCommandLine) {
-			return;
-		}
-
-		this.disposeWatchersAndFiles();
-		this.parsedCommandLine = parsedCommandLine;
-		this.setupWatchers();
-		this.updateProjectAstroFiles();
-	}
-
-	getFiles() {
-		return Array.from(this.files);
-	}
-
-	/**
-	 * Create directory watcher for include and exclude
-	 * The watcher in tsserver doesn't support astro file
-	 * It won't add new created astro file to root
-	 */
-	private setupWatchers() {
-		for (const directory in this.parsedCommandLine.wildcardDirectories) {
-			if (
-				!Object.prototype.hasOwnProperty.call(this.parsedCommandLine.wildcardDirectories, directory)
-			) {
-				continue;
-			}
-
-			const watchDirectoryFlags = this.parsedCommandLine.wildcardDirectories[directory];
-			const watcher = this.serverHost.watchDirectory(
-				directory,
-				this.watcherCallback.bind(this),
-				watchDirectoryFlags === this.typescript.WatchDirectoryFlags.Recursive,
-				this.parsedCommandLine.watchOptions
-			);
-
-			this.directoryWatchers.add(watcher);
-		}
-	}
-
-	private watcherCallback(fileName: string) {
-		if (!isAstroFilePath(fileName)) {
-			return;
-		}
-
-		// We can't just add the file to the project directly, because
-		// - the casing of fileName is different
-		// - we don't know whether the file was added or deleted
-		this.updateProjectAstroFiles();
-	}
-
-	private updateProjectAstroFiles() {
-		const fileNamesAfter = readProjectAstroFilesFromFs(
-			this.typescript,
-			this.project,
-			this.parsedCommandLine
-		);
-		const removedFiles = new Set(...this.files);
-		const newFiles = fileNamesAfter.filter((fileName) => {
-			const has = this.files.has(fileName);
-			if (has) {
-				removedFiles.delete(fileName);
-			}
-			return !has;
-		});
-
-		for (const newFile of newFiles) {
-			this.addFileToProject(newFile);
-			this.files.add(newFile);
-		}
-		for (const removedFile of removedFiles) {
-			this.removeFileFromProject(removedFile, false);
-			this.files.delete(removedFile);
-		}
-	}
-
-	private addFileToProject(newFile: string) {
-		this.snapshotManager.create(newFile);
-		const snapshot = this.project.projectService.getScriptInfo(newFile);
-
-		if (snapshot) {
-			this.project.addRoot(snapshot);
-		}
-	}
-
-	private removeFileFromProject(file: string, exists = true) {
-		const info = this.project.getScriptInfo(file);
-
-		if (info) {
-			this.project.removeFile(info, exists, true);
-		}
-	}
-
-	private disposeWatchersAndFiles() {
-		this.directoryWatchers.forEach((watcher) => watcher.close());
-		this.directoryWatchers.clear();
-
-		this.files.forEach((file) => this.removeFileFromProject(file));
-		this.files.clear();
-	}
-
-	dispose() {
-		this.disposeWatchersAndFiles();
-
-		ProjectAstroFilesManager.instances.delete(this.project.getProjectName());
-	}
-}