@astrojs/ts-plugin 0.3.0 → 0.4.0

package/src/astro-snapshots.ts

@@ -1,8 +1,8 @@
+import { EncodedSourceMap, originalPositionFor, TraceMap } from '@jridgewell/trace-mapping';
 import type ts from 'typescript/lib/tsserverlibrary';
 import { astro2tsx } from './astro2tsx.js';
-import { Logger } from './logger.js';
-import { SourceMapper } from './source-mapper.js';
-import { isAstroFilePath, isNoTextSpanInGeneratedCode } from './utils.js';
+import type { Logger } from './logger.js';
+import { isAstroFilePath } from './utils.js';
 
 export class AstroSnapshot {
 	private scriptInfo?: ts.server.ScriptInfo;
@@ -13,23 +13,18 @@ export class AstroSnapshot {
 		private typescript: typeof ts,
 		private fileName: string,
 		private astroCode: string,
-		private mapper: SourceMapper,
-		private logger: Logger,
-		public readonly isTsFile: boolean
+		private traceMap: TraceMap,
+		private logger: Logger
 	) {}
 
-	update(astroCode: string, mapper: SourceMapper) {
+	update(astroCode: string, traceMap: TraceMap) {
 		this.astroCode = astroCode;
-		this.mapper = mapper;
+		this.traceMap = traceMap;
 		this.lineOffsets = undefined;
 		this.log('Updated Snapshot');
 	}
 
 	getOriginalTextSpan(textSpan: ts.TextSpan): ts.TextSpan | null {
-		if (!isNoTextSpanInGeneratedCode(this.getText(), textSpan)) {
-			return null;
-		}
-
 		const start = this.getOriginalOffset(textSpan.start);
 		if (start === -1) {
 			return null;
@@ -50,16 +45,17 @@ export class AstroSnapshot {
 		this.toggleMappingMode(true);
 		const lineOffset = this.scriptInfo.positionToLineOffset(generatedOffset);
 		this.debug('try convert offset', generatedOffset, '/', lineOffset);
-		const original = this.mapper.getOriginalPosition({
-			line: lineOffset.line - 1,
-			character: lineOffset.offset - 1,
+		const original = originalPositionFor(this.traceMap, {
+			line: lineOffset.line,
+			column: lineOffset.offset,
 		});
 		this.toggleMappingMode(false);
-		if (original.line === -1) {
+
+		if (!original.line) {
 			return -1;
 		}
 
-		const originalOffset = this.scriptInfo.lineOffsetToPosition(original.line + 1, original.character + 1);
+		const originalOffset = this.scriptInfo.lineOffsetToPosition(original.line, original.column);
 		this.debug('converted offset to', original, '/', originalOffset);
 		return originalOffset;
 	}
@@ -250,14 +246,10 @@ export class AstroSnapshotManager {
 				this.logger.debug('Read Astro file:', path);
 				const astroCode = readFile(path) || '';
 				try {
-					const isTsFile = true;
-					const result = astro2tsx(astroCode, {
-						filename: path.split('/').pop(),
-						isTsFile,
-					});
+					const result = astro2tsx(astroCode, path);
 					const existingSnapshot = this.snapshots.get(path);
 					if (existingSnapshot) {
-						existingSnapshot.update(astroCode, new SourceMapper(result.map.mappings));
+						existingSnapshot.update(astroCode, new TraceMap(result.map as EncodedSourceMap));
 					} else {
 						this.snapshots.set(
 							path,
@@ -265,9 +257,8 @@ export class AstroSnapshotManager {
 								this.typescript,
 								path,
 								astroCode,
-								new SourceMapper(result.map.mappings),
-								this.logger,
-								isTsFile
+								new TraceMap(result.map as EncodedSourceMap),
+								this.logger
 							)
 						);
 					}

package/src/astro-sys.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { Logger } from './logger.js';
+import type { Logger } from './logger.js';
 import { ensureRealAstroFilePath, isVirtualAstroFilePath, toRealAstroFilePath } from './utils.js';
 
 /**

package/src/astro2tsx.ts

@@ -1,49 +1,8 @@
-import type { FileMapping } from './source-mapper';
+import type { TSXResult } from '@astrojs/compiler/shared/types';
+import { convertToTSX } from './workers/TSXService';
 
-// Note that this is a bit of a hack until the new compiler with proper
-// source map support.
+export function astro2tsx(content: string, fileName: string): TSXResult {
+	const tsx = convertToTSX(content, { sourcefile: fileName });
 
-interface Astro2TSXOptions {
-	filename: string | undefined;
-	isTsFile: boolean;
-}
-
-interface Astro2TSXResult {
-	code: string;
-	map: {
-		mappings: FileMapping;
-	};
-}
-
-export function astro2tsx(code: string, options: Astro2TSXOptions): Astro2TSXResult {
-	const compiled = transformContent(code);
-
-	const result: Astro2TSXResult = {
-		code: compiled,
-		map: {
-			mappings: [],
-		},
-	};
-
-	return result;
-}
-
-// This is hacky but it works for now
-function addProps(content: string): string {
-	let defaultExportType = 'Record<string, any>';
-
-	if (/(interface|type) Props/.test(content)) {
-		defaultExportType = 'Props';
-	}
-
-	return '\n' + `export default function (props: ${defaultExportType}): string;`;
-}
-
-function transformContent(content: string) {
-	const ts = content.replace(/---/g, '///');
-	return (
-		ts +
-		// Add TypeScript definitions
-		addProps(ts)
-	);
+	return tsx;
 }

package/src/index.ts

@@ -3,12 +3,17 @@ import { AstroSnapshotManager } from './astro-snapshots.js';
 import { decorateLanguageService } from './language-service/index.js';
 import { Logger } from './logger.js';
 import { patchModuleLoader } from './module-loader.js';
+import { ProjectAstroFilesManager } from './project-astro-files.js';
+import { getConfigPathForProject, readProjectAstroFilesFromFs } from './utils.js';
 
-function init(modules: { typescript: typeof ts }) {
-	function create(info: ts.server.PluginCreateInfo) {
+function init(modules: { typescript: typeof import('typescript/lib/tsserverlibrary') }) {
+	const ts = modules.typescript;
+
+	function create(info: ts.server.PluginCreateInfo): ts.LanguageService {
 		const logger = new Logger(info.project.projectService.logger);
+		const parsedCommandLine = info.languageServiceHost.getParsedCommandLine?.(getConfigPathForProject(info.project));
 
-		if (!isAstroProject(info)) {
+		if (!isAstroProject(info.project, parsedCommandLine)) {
 			logger.log('Detected that this is not an Astro project, abort patching TypeScript');
 			return info.languageService;
 		}
@@ -16,47 +21,42 @@ function init(modules: { typescript: typeof ts }) {
 		logger.log('Starting Astro plugin');
 
 		const snapshotManager = new AstroSnapshotManager(modules.typescript, info.project.projectService, logger);
+		if (parsedCommandLine) {
+			new ProjectAstroFilesManager(
+				modules.typescript,
+				info.project,
+				info.serverHost,
+				snapshotManager,
+				parsedCommandLine
+			);
+		}
 
-		patchCompilerOptions(info.project);
 		patchModuleLoader(logger, snapshotManager, modules.typescript, info.languageServiceHost, info.project);
 		return decorateLanguageService(info.languageService, snapshotManager, logger);
 	}
 
-	function getExternalFiles(_project: ts.server.ConfiguredProject) {
-		// Needed so the ambient definitions are known inside the tsx files
-		/*const astroTsPath = dirname(require.resolve('astro2tsx'));
-      const astroTsxFiles = [
-          './astro-shims.d.ts',
-          './astro-jsx.d.ts',
-          './astro-native-jsx.d.ts'
-      ].map((f) => modules.typescript.sys.resolvePath(resolve(astroTsPath, f)));
-      return astroTsxFiles;*/
-		return [];
+	function getExternalFiles(project: ts.server.ConfiguredProject) {
+		return ProjectAstroFilesManager.getInstance(project.getProjectName())?.getFiles() ?? [];
 	}
 
-	function patchCompilerOptions(project: ts.server.Project) {
-		const compilerOptions = project.getCompilerOptions();
-		// Patch needed because astro2tsx creates jsx/tsx files
-		compilerOptions.jsx = modules.typescript.JsxEmit.Preserve;
+	function isAstroProject(project: ts.server.Project, parsedCommandLine: ts.ParsedCommandLine | undefined) {
+		if (parsedCommandLine) {
+			const astroFiles = readProjectAstroFilesFromFs(ts, project, parsedCommandLine);
 
-		// detect which JSX namespace to use (astro | astronative) if not specified or not compatible
-		if (!compilerOptions.jsxFactory?.startsWith('astro')) {
-			// Default to regular astro, this causes the usage of the "astro.JSX" namespace
-			// We don't need to add a switch for astro-native because the jsx is only relevant
-			// within Astro files, which this plugin does not deal with.
-			compilerOptions.jsxFactory = 'astro.createElement';
+			if (astroFiles.length > 0) return true;
 		}
-	}
 
-	function isAstroProject(info: ts.server.PluginCreateInfo) {
-		// Add more checks like "no Astro file found" or "no config file found"?
-		const compilerOptions = info.project.getCompilerOptions();
-		const isNoJsxProject =
-			(!compilerOptions.jsx || compilerOptions.jsx === modules.typescript.JsxEmit.Preserve) &&
-			(!compilerOptions.jsxFactory || compilerOptions.jsxFactory.startsWith('astro')) &&
-			!compilerOptions.jsxFragmentFactory &&
-			!compilerOptions.jsxImportSource;
-		return isNoJsxProject;
+		try {
+			const compilerOptions = project.getCompilerOptions();
+			const hasAstroInstalled =
+				typeof compilerOptions.configFilePath !== 'string' ||
+				require.resolve('astro', { paths: [compilerOptions.configFilePath] });
+
+			return hasAstroInstalled;
+		} catch (e) {
+			project.projectService.logger.info(e as string);
+			return false;
+		}
 	}
 
 	return { create, getExternalFiles };

package/src/language-service/completions.ts

@@ -1,5 +1,5 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { Logger } from '../logger.js';
+import type { Logger } from '../logger.js';
 import { isAstroFilePath, replaceDeep } from '../utils.js';
 
 const componentPostfix = '__AstroComponent_';
@@ -27,9 +27,20 @@ export function decorateCompletions(ls: ts.LanguageService, logger: Logger): voi
 
 	const getCompletionEntryDetails = ls.getCompletionEntryDetails;
 	ls.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
-		const details = getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
-		if (details || !isAstroFilePath(source || '')) {
-			return details;
+		if (!isAstroFilePath(source || '')) {
+			const details = getCompletionEntryDetails(
+				fileName,
+				position,
+				entryName,
+				formatOptions,
+				source,
+				preferences,
+				data
+			);
+
+			if (details) {
+				return details;
+			}
 		}
 
 		// In the completion list we removed the component postfix. Internally,

package/src/language-service/definition.ts

@@ -1,13 +1,8 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from '../astro-snapshots';
-import { Logger } from '../logger';
+import type { AstroSnapshotManager } from '../astro-snapshots';
 import { isAstroFilePath, isNotNullOrUndefined } from '../utils';
 
-export function decorateGetDefinition(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-): void {
+export function decorateGetDefinition(ls: ts.LanguageService, snapshotManager: AstroSnapshotManager): void {
 	const getDefinitionAndBoundSpan = ls.getDefinitionAndBoundSpan;
 	ls.getDefinitionAndBoundSpan = (fileName, position) => {
 		const definition = getDefinitionAndBoundSpan(fileName, position);

package/src/language-service/diagnostics.ts

@@ -1,8 +1,7 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { Logger } from '../logger.js';
 import { isAstroFilePath } from '../utils.js';
 
-export function decorateDiagnostics(ls: ts.LanguageService, logger: Logger): void {
+export function decorateDiagnostics(ls: ts.LanguageService): void {
 	decorateSyntacticDiagnostics(ls);
 	decorateSemanticDiagnostics(ls);
 	decorateSuggestionDiagnostics(ls);

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

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

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

@@ -1,6 +1,6 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from '../astro-snapshots.js';
-import { Logger } from '../logger';
+import type { AstroSnapshotManager } from '../astro-snapshots.js';
+import type { Logger } from '../logger';
 import { isAstroFilePath, isNotNullOrUndefined } from '../utils.js';
 
 export function decorateFindReferences(

package/src/language-service/implementation.ts

@@ -1,13 +1,8 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from '../astro-snapshots.js';
-import { Logger } from '../logger.js';
+import type { AstroSnapshotManager } from '../astro-snapshots.js';
 import { isAstroFilePath, isNotNullOrUndefined } from '../utils.js';
 
-export function decorateGetImplementation(
-	ls: ts.LanguageService,
-	snapshotManager: AstroSnapshotManager,
-	logger: Logger
-): void {
+export function decorateGetImplementation(ls: ts.LanguageService, snapshotManager: AstroSnapshotManager): void {
 	const getImplementationAtPosition = ls.getImplementationAtPosition;
 	ls.getImplementationAtPosition = (fileName, position) => {
 		const implementation = getImplementationAtPosition(fileName, position);

package/src/language-service/index.ts

@@ -1,12 +1,13 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from '../astro-snapshots.js';
-import { Logger } from '../logger';
-import { isAstroFilePath } from '../utils.js';
+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';
 
 export function decorateLanguageService(
@@ -14,30 +15,14 @@ export function decorateLanguageService(
 	snapshotManager: AstroSnapshotManager,
 	logger: Logger
 ): ts.LanguageService {
-	patchLineColumnOffset(ls, snapshotManager);
+	decorateLineColumnOffset(ls, snapshotManager);
 	decorateRename(ls, snapshotManager, logger);
-	decorateDiagnostics(ls, logger);
+	decorateDiagnostics(ls);
 	decorateFindReferences(ls, snapshotManager, logger);
 	decorateCompletions(ls, logger);
-	decorateGetDefinition(ls, snapshotManager, logger);
-	decorateGetImplementation(ls, snapshotManager, logger);
-	return ls;
-}
+	decorateGetDefinition(ls, snapshotManager);
+	decorateGetImplementation(ls, snapshotManager);
+	decorateGetFileReferences(ls, snapshotManager);
 
-function patchLineColumnOffset(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);
-	};
+	return ls;
 }

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

@@ -0,0 +1,21 @@
+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,6 +1,6 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from '../astro-snapshots.js';
-import { Logger } from '../logger.js';
+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 {

package/src/module-loader.ts

@@ -1,7 +1,7 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { AstroSnapshotManager } from './astro-snapshots.js';
+import type { AstroSnapshotManager } from './astro-snapshots.js';
 import { createAstroSys } from './astro-sys.js';
-import { Logger } from './logger.js';
+import type { Logger } from './logger.js';
 import { ensureRealAstroFilePath, isVirtualAstroFilePath } from './utils.js';
 
 /**
@@ -73,6 +73,13 @@ export function patchModuleLoader(
 		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,
@@ -80,7 +87,8 @@ export function patchModuleLoader(
 		redirectedReference: ts.ResolvedProjectReference | undefined,
 		compilerOptions: ts.CompilerOptions
 	): Array<ts.ResolvedModule | undefined> {
-		logger.log('Resolving modules names for ' + containingFile);
+		// 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
@@ -129,7 +137,7 @@ export function patchModuleLoader(
 		}
 
 		const resolvedAstroModule: ts.ResolvedModuleFull = {
-			extension: snapshot.isTsFile ? typescript.Extension.Tsx : typescript.Extension.Jsx,
+			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());
+	}
+}