@astrojs/ts-plugin 0.2.1 → 0.4.0

package/src/astro2tsx.ts

@@ -1,53 +1,8 @@
-import type { FileMapping } from './source-mapper';
-import { Project } from 'ts-morph';
+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>';
-
-  // See if this has an interface already
-  const project = new Project({});
-  const sourceFile = project.createSourceFile("testing.ts", content);
-  const declarations = sourceFile.getExportedDeclarations();
-  if(declarations.has('Props')) {
-    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

@@ -1,76 +1,65 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { dirname, resolve } from 'path';
+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 { AstroSnapshotManager } from './astro-snapshots.js';
+import { ProjectAstroFilesManager } from './project-astro-files.js';
+import { getConfigPathForProject, readProjectAstroFilesFromFs } from './utils.js';
+
+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));
 
-function init(modules: { typescript: typeof ts }) {
-  function create(info: ts.server.PluginCreateInfo) {
-    const logger = new Logger(info.project.projectService.logger);
+		if (!isAstroProject(info.project, parsedCommandLine)) {
+			logger.log('Detected that this is not an Astro project, abort patching TypeScript');
+			return info.languageService;
+		}
 
-    if (!isAstroProject(info)) {
-        logger.log('Detected that this is not an Astro project, abort patching TypeScript');
-        return info.languageService;
-    }
+		logger.log('Starting Astro plugin');
 
-    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
+			);
+		}
 
-    const snapshotManager = new AstroSnapshotManager(
-        modules.typescript,
-        info.project.projectService,
-        logger
-    );
+		patchModuleLoader(logger, snapshotManager, modules.typescript, info.languageServiceHost, info.project);
+		return decorateLanguageService(info.languageService, snapshotManager, logger);
+	}
 
-    patchCompilerOptions(info.project);
-    patchModuleLoader(
-        logger,
-        snapshotManager,
-        modules.typescript,
-        info.languageServiceHost,
-        info.project
-    );
-    return decorateLanguageService(info.languageService, snapshotManager, logger);
-  }
+	function getExternalFiles(project: ts.server.ConfiguredProject) {
+		return ProjectAstroFilesManager.getInstance(project.getProjectName())?.getFiles() ?? [];
+	}
 
-  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 isAstroProject(project: ts.server.Project, parsedCommandLine: ts.ParsedCommandLine | undefined) {
+		if (parsedCommandLine) {
+			const astroFiles = readProjectAstroFilesFromFs(ts, project, parsedCommandLine);
 
-  function patchCompilerOptions(project: ts.server.Project) {
-      const compilerOptions = project.getCompilerOptions();
-      // Patch needed because astro2tsx creates jsx/tsx files
-      compilerOptions.jsx = modules.typescript.JsxEmit.Preserve;
+			if (astroFiles.length > 0) return true;
+		}
 
-      // 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';
-      }
-  }
+		try {
+			const compilerOptions = project.getCompilerOptions();
+			const hasAstroInstalled =
+				typeof compilerOptions.configFilePath !== 'string' ||
+				require.resolve('astro', { paths: [compilerOptions.configFilePath] });
 
-  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;
-  }
+			return hasAstroInstalled;
+		} catch (e) {
+			project.projectService.logger.info(e as string);
+			return false;
+		}
+	}
 
-  return { create, getExternalFiles };
+	return { create, getExternalFiles };
 }
 
-export = init;
+export = init;

package/src/language-service/completions.ts

@@ -1,73 +1,65 @@
 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_';
 
 export function decorateCompletions(ls: ts.LanguageService, logger: Logger): void {
-    const getCompletionsAtPosition = ls.getCompletionsAtPosition;
-    ls.getCompletionsAtPosition = (fileName, position, options) => {
-        const completions = getCompletionsAtPosition(fileName, position, options);
-        if (!completions) {
-            return completions;
-        }
-        return {
-            ...completions,
-            entries: completions.entries.map((entry) => {
-                if (
-                    !isAstroFilePath(entry.source || '') ||
-                    !entry.name.endsWith(componentPostfix)
-                ) {
-                    return entry;
-                }
-                return {
-                    ...entry,
-                    name: entry.name.slice(0, -componentPostfix.length)
-                };
-            })
-        };
-    };
+	const getCompletionsAtPosition = ls.getCompletionsAtPosition;
+	ls.getCompletionsAtPosition = (fileName, position, options) => {
+		const completions = getCompletionsAtPosition(fileName, position, options);
+		if (!completions) {
+			return completions;
+		}
+		return {
+			...completions,
+			entries: completions.entries.map((entry) => {
+				if (!isAstroFilePath(entry.source || '') || !entry.name.endsWith(componentPostfix)) {
+					return entry;
+				}
+				return {
+					...entry,
+					name: entry.name.slice(0, -componentPostfix.length),
+				};
+			}),
+		};
+	};
 
-    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;
-        }
+	const getCompletionEntryDetails = ls.getCompletionEntryDetails;
+	ls.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+		if (!isAstroFilePath(source || '')) {
+			const details = getCompletionEntryDetails(
+				fileName,
+				position,
+				entryName,
+				formatOptions,
+				source,
+				preferences,
+				data
+			);
 
-        // In the completion list we removed the component postfix. Internally,
-        // the language service saved the list with the postfix, so details
-        // won't match anything. Therefore add it back and remove it afterwards again.
-        const astroDetails = getCompletionEntryDetails(
-            fileName,
-            position,
-            entryName + componentPostfix,
-            formatOptions,
-            source,
-            preferences,
-            data
-        );
-        if (!astroDetails) {
-            return undefined;
-        }
-        logger.debug('Found Astro Component import completion details');
+			if (details) {
+				return details;
+			}
+		}
 
-        return replaceDeep(astroDetails, componentPostfix, '');
-    };
-}
+		// In the completion list we removed the component postfix. Internally,
+		// the language service saved the list with the postfix, so details
+		// won't match anything. Therefore add it back and remove it afterwards again.
+		const astroDetails = getCompletionEntryDetails(
+			fileName,
+			position,
+			entryName + componentPostfix,
+			formatOptions,
+			source,
+			preferences,
+			data
+		);
+		if (!astroDetails) {
+			return undefined;
+		}
+		logger.debug('Found Astro Component import completion details');
+
+		return replaceDeep(astroDetails, componentPostfix, '');
+	};
+}

package/src/language-service/definition.ts

@@ -1,46 +1,39 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-import { Logger } from '../logger';
-import { AstroSnapshotManager } from '../astro-snapshots';
-import { isNotNullOrUndefined, isAstroFilePath } from '../utils';
+import type { AstroSnapshotManager } from '../astro-snapshots';
+import { isAstroFilePath, isNotNullOrUndefined } from '../utils';
 
-export function decorateGetDefinition(
-    ls: ts.LanguageService,
-    snapshotManager: AstroSnapshotManager,
-    logger: Logger
-): void {
-    const getDefinitionAndBoundSpan = ls.getDefinitionAndBoundSpan;
-    ls.getDefinitionAndBoundSpan = (fileName, position) => {
-        const definition = getDefinitionAndBoundSpan(fileName, position);
-        if (!definition?.definitions) {
-            return definition;
-        }
+export function decorateGetDefinition(ls: ts.LanguageService, snapshotManager: AstroSnapshotManager): void {
+	const getDefinitionAndBoundSpan = ls.getDefinitionAndBoundSpan;
+	ls.getDefinitionAndBoundSpan = (fileName, position) => {
+		const definition = getDefinitionAndBoundSpan(fileName, position);
+		if (!definition?.definitions) {
+			return definition;
+		}
 
-        return {
-            ...definition,
-            definitions: definition.definitions
-                .map((def) => {
-                    if (!isAstroFilePath(def.fileName)) {
-                        return def;
-                    }
+		return {
+			...definition,
+			definitions: definition.definitions
+				.map((def) => {
+					if (!isAstroFilePath(def.fileName)) {
+						return def;
+					}
 
-                    let textSpan = snapshotManager
-                        .get(def.fileName)
-                        ?.getOriginalTextSpan(def.textSpan);
-                    if (!textSpan) {
-                        // Unmapped positions are for example the default export.
-                        // Fall back to the start of the file to at least go to the correct file.
-                        textSpan = { start: 0, length: 1 };
-                    }
-                    return {
-                        ...def,
-                        textSpan,
-                        // Spare the work for now
-                        originalTextSpan: undefined,
-                        contextSpan: undefined,
-                        originalContextSpan: undefined
-                    };
-                })
-                .filter(isNotNullOrUndefined)
-        };
-    };
-}
+					let textSpan = snapshotManager.get(def.fileName)?.getOriginalTextSpan(def.textSpan);
+					if (!textSpan) {
+						// Unmapped positions are for example the default export.
+						// Fall back to the start of the file to at least go to the correct file.
+						textSpan = { start: 0, length: 1 };
+					}
+					return {
+						...def,
+						textSpan,
+						// Spare the work for now
+						originalTextSpan: undefined,
+						contextSpan: undefined,
+						originalContextSpan: undefined,
+					};
+				})
+				.filter(isNotNullOrUndefined),
+		};
+	};
+}

package/src/language-service/diagnostics.ts

@@ -1,45 +1,44 @@
 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 {
-    decorateSyntacticDiagnostics(ls);
-    decorateSemanticDiagnostics(ls);
-    decorateSuggestionDiagnostics(ls);
+export function decorateDiagnostics(ls: ts.LanguageService): void {
+	decorateSyntacticDiagnostics(ls);
+	decorateSemanticDiagnostics(ls);
+	decorateSuggestionDiagnostics(ls);
 }
 
 function decorateSyntacticDiagnostics(ls: ts.LanguageService): void {
-    const getSyntacticDiagnostics = ls.getSyntacticDiagnostics;
-    ls.getSyntacticDiagnostics = (fileName: string) => {
-        // Diagnostics inside Astro files are done
-        // by the @astrojs/language-server / Astro for VS Code extension
-        if (isAstroFilePath(fileName)) {
-            return [];
-        }
-        return getSyntacticDiagnostics(fileName);
-    };
+	const getSyntacticDiagnostics = ls.getSyntacticDiagnostics;
+	ls.getSyntacticDiagnostics = (fileName: string) => {
+		// Diagnostics inside Astro files are done
+		// by the @astrojs/language-server / Astro for VS Code extension
+		if (isAstroFilePath(fileName)) {
+			return [];
+		}
+		return getSyntacticDiagnostics(fileName);
+	};
 }
 
 function decorateSemanticDiagnostics(ls: ts.LanguageService): void {
-    const getSemanticDiagnostics = ls.getSemanticDiagnostics;
-    ls.getSemanticDiagnostics = (fileName: string) => {
-        // Diagnostics inside Astro files are done
-        // by the @astrojs/language-server / Astro for VS Code extension
-        if (isAstroFilePath(fileName)) {
-            return [];
-        }
-        return getSemanticDiagnostics(fileName);
-    };
+	const getSemanticDiagnostics = ls.getSemanticDiagnostics;
+	ls.getSemanticDiagnostics = (fileName: string) => {
+		// Diagnostics inside Astro files are done
+		// by the @astrojs/language-server / Astro for VS Code extension
+		if (isAstroFilePath(fileName)) {
+			return [];
+		}
+		return getSemanticDiagnostics(fileName);
+	};
 }
 
 function decorateSuggestionDiagnostics(ls: ts.LanguageService): void {
-    const getSuggestionDiagnostics = ls.getSuggestionDiagnostics;
-    ls.getSuggestionDiagnostics = (fileName: string) => {
-        // Diagnostics inside Astro files are done
-        // by the @astrojs/language-server / Astro for VS Code extension
-        if (isAstroFilePath(fileName)) {
-            return [];
-        }
-        return getSuggestionDiagnostics(fileName);
-    };
-}
+	const getSuggestionDiagnostics = ls.getSuggestionDiagnostics;
+	ls.getSuggestionDiagnostics = (fileName: string) => {
+		// Diagnostics inside Astro files are done
+		// by the @astrojs/language-server / Astro for VS Code extension
+		if (isAstroFilePath(fileName)) {
+			return [];
+		}
+		return getSuggestionDiagnostics(fileName);
+	};
+}

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);
+	};
+}