@astrojs/ts-plugin 0.2.1 → 0.4.0

package/src/module-loader.ts

@@ -1,47 +1,47 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { Logger } from './logger.js';
-import { AstroSnapshotManager } from './astro-snapshots.js';
+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.ResolvedModule>();
-
-    /**
-     * Tries to get a cached module.
-     */
-    get(moduleName: string, containingFile: string): ts.ResolvedModule | undefined {
-        return this.cache.get(this.getKey(moduleName, containingFile));
-    }
-
-    /**
-     * Caches resolved module, if it is not undefined.
-     */
-    set(moduleName: string, containingFile: string, resolvedModule: ts.ResolvedModule | 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);
-    }
+	private cache = new Map<string, ts.ResolvedModule>();
+
+	/**
+	 * Tries to get a cached module.
+	 */
+	get(moduleName: string, containingFile: string): ts.ResolvedModule | undefined {
+		return this.cache.get(this.getKey(moduleName, containingFile));
+	}
+
+	/**
+	 * Caches resolved module, if it is not undefined.
+	 */
+	set(moduleName: string, containingFile: string, resolvedModule: ts.ResolvedModule | 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);
+	}
 }
 
 /**
@@ -54,92 +54,92 @@ class ModuleResolutionCache {
  * 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
+	logger: Logger,
+	snapshotManager: AstroSnapshotManager,
+	typescript: typeof ts,
+	lsHost: ts.LanguageServiceHost,
+	project: ts.server.Project
 ): void {
-    const astroSys = createAstroSys(logger);
-    const moduleCache = new ModuleResolutionCache();
-    const origResolveModuleNames = lsHost.resolveModuleNames?.bind(lsHost);
-
-    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);
-    };
-
-    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.ResolvedModule | 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: snapshot.isTsFile ? typescript.Extension.Tsx : typescript.Extension.Jsx,
-            resolvedFileName
-        };
-        return resolvedAstroModule;
-    }
-}
+	const astroSys = createAstroSys(logger);
+	const moduleCache = new ModuleResolutionCache();
+	const origResolveModuleNames = lsHost.resolveModuleNames?.bind(lsHost);
+
+	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.ResolvedModule | 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;
+	}
+}

package/src/project-astro-files.ts

@@ -0,0 +1,130 @@
+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());
+	}
+}

package/src/utils.ts

@@ -1,66 +1,75 @@
 export function isAstroFilePath(filePath: string) {
-  return filePath.endsWith('.astro');
+	return filePath.endsWith('.astro');
 }
 
 export function isVirtualAstroFilePath(filePath: string) {
-  return filePath.endsWith('.astro.ts');
+	return filePath.endsWith('.astro.ts');
 }
 
 export function toRealAstroFilePath(filePath: string) {
-  return filePath.slice(0, -'.ts'.length);
+	return filePath.slice(0, -'.ts'.length);
 }
 
 export function ensureRealAstroFilePath(filePath: string) {
-  return isVirtualAstroFilePath(filePath) ? toRealAstroFilePath(filePath) : filePath;
+	return isVirtualAstroFilePath(filePath) ? toRealAstroFilePath(filePath) : filePath;
 }
 
 export function isNotNullOrUndefined<T>(val: T | undefined | null): val is T {
-  return val !== undefined && val !== null;
+	return val !== undefined && val !== null;
 }
 
 /**
-* Checks if this a section that should be completely ignored
-* because it's purely generated.
-*/
-export function isInGeneratedCode(text: string, start: number, end: number) {
-  const lineStart = text.lastIndexOf('\n', start);
-  const lineEnd = text.indexOf('\n', end);
-  const lastStart = text.substring(lineStart, start).lastIndexOf('/*Ωignore_startΩ*/');
-  const lastEnd = text.substring(lineStart, start).lastIndexOf('/*Ωignore_endΩ*/');
-  return lastStart > lastEnd && text.substring(end, lineEnd).includes('/*Ωignore_endΩ*/');
+ * Replace all occurrences of a string within an object with another string,
+ */
+export function replaceDeep<T extends Record<string, any>>(
+	obj: T,
+	searchStr: string | RegExp,
+	replacementStr: string
+): T {
+	return _replaceDeep(obj);
+
+	function _replaceDeep(_obj: any): any {
+		if (typeof _obj === 'string') {
+			return _obj.replace(searchStr, replacementStr);
+		}
+		if (Array.isArray(_obj)) {
+			return _obj.map((entry) => _replaceDeep(entry));
+		}
+		if (typeof _obj === 'object') {
+			return Object.keys(_obj).reduce((_o, key) => {
+				_o[key] = _replaceDeep(_obj[key]);
+				return _o;
+			}, {} as any);
+		}
+		return _obj;
+	}
 }
 
-/**
-* Checks that this isn't a text span that should be completely ignored
-* because it's purely generated.
-*/
-export function isNoTextSpanInGeneratedCode(text: string, span: ts.TextSpan) {
-  return !isInGeneratedCode(text, span.start, span.start + span.length);
+export function getConfigPathForProject(project: ts.server.Project) {
+	return (
+		(project as ts.server.ConfiguredProject).canonicalConfigFilePath ??
+		(project.getCompilerOptions() as any).configFilePath
+	);
 }
 
-/**
-* Replace all occurrences of a string within an object with another string,
-*/
-export function replaceDeep<T extends Record<string, any>>(
-  obj: T,
-  searchStr: string | RegExp,
-  replacementStr: string
-): T {
-  return _replaceDeep(obj);
+export function readProjectAstroFilesFromFs(
+	ts: typeof import('typescript/lib/tsserverlibrary'),
+	project: ts.server.Project,
+	parsedCommandLine: ts.ParsedCommandLine
+) {
+	const fileSpec: TsFilesSpec = parsedCommandLine.raw;
+	const { include, exclude } = fileSpec;
+
+	if (include?.length === 0) {
+		return [];
+	}
 
-  function _replaceDeep(_obj: any): any {
-      if (typeof _obj === 'string') {
-          return _obj.replace(searchStr, replacementStr);
-      }
-      if (Array.isArray(_obj)) {
-          return _obj.map((entry) => _replaceDeep(entry));
-      }
-      if (typeof _obj === 'object') {
-          return Object.keys(_obj).reduce((_o, key) => {
-              _o[key] = _replaceDeep(_obj[key]);
-              return _o;
-          }, {} as any);
-      }
-      return _obj;
-  }
-}
+	return ts.sys
+		.readDirectory(project.getCurrentDirectory() || process.cwd(), ['.astro'], exclude, include)
+		.map(ts.server.toNormalizedPath);
+}
+
+export interface TsFilesSpec {
+	include?: readonly string[];
+	exclude?: readonly string[];
+}

package/src/workers/TSXService.ts

@@ -0,0 +1,11 @@
+import type { TSXResult } from '@astrojs/compiler/shared/types';
+import { createSyncFn } from 'synckit';
+
+const convertToTSXSync = createSyncFn(require.resolve('./TSXWorker'));
+
+/**
+ * Parse code by `@astrojs/compiler`
+ */
+export function convertToTSX(source: string, options: { sourcefile: string }): TSXResult {
+	return convertToTSXSync(source, options);
+}

package/src/workers/TSXWorker.ts

@@ -0,0 +1,8 @@
+import { runAsWorker } from 'synckit';
+
+const dynamicImport = new Function('m', 'return import(m)');
+runAsWorker(async (source: string, options: { sourcefile: string }) => {
+	const { convertToTSX } = await dynamicImport('@astrojs/compiler');
+	const result: any = convertToTSX(source, options);
+	return result;
+});

package/test/fixtures/MyAstroComponent.astro

@@ -0,0 +1,5 @@
+---
+	import { Hello, sayHello } from "./script"
+
+	class MyHello implements Hello {}
+---

package/test/fixtures/script.ts

@@ -0,0 +1,9 @@
+export function sayHello() {
+	console.log("Hello")
+}
+
+MyAstroCompon
+
+export class Hello {
+
+}

package/test/fixtures/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  // Purposely empty, this is done so TypeScript knows where the root of the project is and doesn't try to go too high into the monorepo
+}

package/test/runTest.js

@@ -0,0 +1,41 @@
+const path = require('path');
+const { runTests } = require('@vscode/test-electron');
+const { downloadDirToExecutablePath } = require('./utils');
+const { existsSync, readdirSync } = require('fs');
+
+async function main() {
+	try {
+		// The folder containing the Extension Manifest package.json
+		// Passed to `--extensionDevelopmentPath`
+		const extensionDevelopmentPath = path.resolve(__dirname, '../../vscode');
+
+		// The path to the extension test script
+		// Passed to --extensionTestsPath
+		const extensionTestsPath = path.resolve(__dirname, './suite/index.js');
+
+		// If there's already a downloaded version of VS Code, let's use it
+		const vscodeTestPath = path.resolve(__dirname, '../../vscode/.vscode-test');
+		let vsPath = undefined;
+		if (existsSync(vscodeTestPath)) {
+			const files = readdirSync(vscodeTestPath);
+			files.forEach((file) => {
+				if (file.startsWith('vscode-')) {
+					vsPath = downloadDirToExecutablePath(path.resolve(__dirname, '../../vscode/.vscode-test/', file));
+					return;
+				}
+			});
+		}
+
+		await runTests({
+			extensionDevelopmentPath,
+			extensionTestsPath,
+			vscodeExecutablePath: vsPath,
+			launchArgs: ['./fixtures/fixtures.code-workspace'],
+		});
+	} catch (err) {
+		console.error('Failed to run tests');
+		process.exit(1);
+	}
+}
+
+main();