@astrojs/language-server 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @astrojs/language-server
 
+## 0.23.0
+
+### Minor Changes
+
+- 1dcef68: Automatically type `Astro.props` using the Props interface when available
+
+### Patch Changes
+
+- b6c95f2: Fix completions for HTML attributes not working anymore since 0.20.3
+
+## 0.22.0
+
+### Minor Changes
+
+- d5aafc0: Formatting is now powered by Prettier and our Prettier plugin. Going forward, this should result in a more stable and complete way of formatting Astro files
+
+### Patch Changes
+
+- 61620f1: Add support for Go To Type Definition
+- 9337f00: Fix language server not working when no initlizationOptions were passed
+
+## 0.21.1
+
+### Patch Changes
+
+- 0e9d7d0: Improve error handling in cases where we can't load types from the user's project and when the project isn't at the root of the folder
+- 3f79dbf: Fix `tsconfig.json` not loading properly in certain contexts on Windows
+
 ## 0.21.0
 
 ### Minor Changes

package/README.md

@@ -11,6 +11,5 @@ The Astro language server, implement the [language server protocol](https://micr
 │   ├── core        # Core code such as .astro file parsing, configuration manager, document definition etc
 │   └── plugins     # Modules for the different languages supported in .astro files
 ├── test            # Tests
-├── types           # Types
-└── astro.d.ts      # Types injected into .astro files by the language server
+└── types           # Types injected into Astro files by the language server under certain conditions
 ```

package/dist/check.js

@@ -4,6 +4,8 @@ exports.AstroCheck = exports.DiagnosticSeverity = void 0;
 const config_1 = require("./core/config");
 const documents_1 = require("./core/documents");
 const plugins_1 = require("./plugins");
+const LanguageServiceManager_1 = require("./plugins/typescript/LanguageServiceManager");
+const utils_1 = require("./utils");
 var vscode_languageserver_types_1 = require("vscode-languageserver-types");
 Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return vscode_languageserver_types_1.DiagnosticSeverity; } });
 class AstroCheck {
@@ -37,7 +39,8 @@ class AstroCheck {
         }));
     }
     initialize(workspacePath) {
-        this.pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(this.docManager, this.configManager, [workspacePath]));
+        const languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(this.docManager, [(0, utils_1.normalizeUri)(workspacePath)], this.configManager);
+        this.pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(this.configManager, languageServiceManager));
     }
     async getDiagnosticsForFile(uri) {
         const diagnostics = await this.pluginHost.getDiagnostics({ uri });

package/dist/core/config/ConfigManager.d.ts

@@ -1,5 +1,5 @@
 import { VSCodeEmmetConfig } from '@vscode/emmet-helper';
-import { LSConfig, LSCSSConfig, LSFormatConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
+import { LSConfig, LSCSSConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
 import { Connection, FormattingOptions } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { FormatCodeSettings, InlayHintsOptions, UserPreferences } from 'typescript';
@@ -23,7 +23,6 @@ export declare class ConfigManager {
     removeDocument(scopeUri: string): void;
     getConfig<T>(section: string, scopeUri: string): Promise<T | Record<string, any>>;
     getEmmetConfig(document: TextDocument): Promise<VSCodeEmmetConfig>;
-    getAstroFormatConfig(document: TextDocument): Promise<LSFormatConfig>;
     getTSFormatConfig(document: TextDocument, vscodeOptions?: FormattingOptions): Promise<FormatCodeSettings>;
     getTSPreferences(document: TextDocument): Promise<UserPreferences>;
     getTSInlayHintsPreferences(document: TextDocument): Promise<InlayHintsOptions>;

package/dist/core/config/ConfigManager.js

@@ -90,13 +90,6 @@ class ConfigManager {
             showSuggestionsAsSnippets: emmetConfig.showSuggestionsAsSnippets ?? false,
         };
     }
-    async getAstroFormatConfig(document) {
-        const astroFormatConfig = (await this.getConfig('astro.format', document.uri)) ?? {};
-        return {
-            indentFrontmatter: astroFormatConfig.indentFrontmatter ?? exports.defaultLSConfig.format.indentFrontmatter,
-            newLineAfterFrontmatter: astroFormatConfig.newLineAfterFrontmatter ?? exports.defaultLSConfig.format.newLineAfterFrontmatter,
-        };
-    }
     async getTSFormatConfig(document, vscodeOptions) {
         const formatConfig = (await this.getConfig('typescript.format', document.uri)) ?? {};
         return {

package/dist/importPackage.d.ts

@@ -1,6 +1,9 @@
 import type * as svelte from '@astrojs/svelte/dist/editor.cjs';
 import type * as vue from '@astrojs/svelte/dist/editor.cjs';
+import type * as prettier from 'prettier';
 export declare function setIsTrusted(_isTrusted: boolean): void;
-export declare function getPackagePath(packageName: string, fromPath: string): string | undefined;
+export declare function getPackagePath(packageName: string, fromPath: string[]): string | undefined;
 export declare function importSvelteIntegration(fromPath: string): typeof svelte | undefined;
 export declare function importVueIntegration(fromPath: string): typeof vue | undefined;
+export declare function importPrettier(fromPath: string): typeof prettier;
+export declare function getPrettierPluginPath(fromPath: string): string;

package/dist/importPackage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.importVueIntegration = exports.importSvelteIntegration = exports.getPackagePath = exports.setIsTrusted = void 0;
+exports.getPrettierPluginPath = exports.importPrettier = exports.importVueIntegration = exports.importSvelteIntegration = exports.getPackagePath = exports.setIsTrusted = void 0;
 const path_1 = require("path");
 let isTrusted = true;
 function setIsTrusted(_isTrusted) {
@@ -10,13 +10,10 @@ exports.setIsTrusted = setIsTrusted;
 function getPackagePath(packageName, fromPath) {
     const paths = [];
     if (isTrusted) {
-        paths.unshift(fromPath);
+        paths.unshift(...fromPath);
     }
     try {
-        const packageJSONPath = require.resolve(`${packageName}/package.json`, {
-            paths,
-        });
-        return (0, path_1.dirname)(packageJSONPath);
+        return (0, path_1.dirname)(require.resolve(packageName + '/package.json', { paths }));
     }
     catch (e) {
         return undefined;
@@ -24,10 +21,16 @@ function getPackagePath(packageName, fromPath) {
 }
 exports.getPackagePath = getPackagePath;
 function importEditorIntegration(packageName, fromPath) {
-    const pkgPath = getPackagePath(packageName, fromPath);
+    const pkgPath = getPackagePath(packageName, [fromPath]);
     if (pkgPath) {
-        const main = (0, path_1.resolve)(pkgPath, 'dist', 'editor.cjs');
-        return require(main);
+        try {
+            const main = (0, path_1.resolve)(pkgPath, 'dist', 'editor.cjs');
+            return require(main);
+        }
+        catch (e) {
+            console.error(`Couldn't load editor module from ${pkgPath}. Make sure you're using at least version v0.2.1 of the corresponding integration`);
+            return undefined;
+        }
     }
     return undefined;
 }
@@ -39,3 +42,13 @@ function importVueIntegration(fromPath) {
     return importEditorIntegration('@astrojs/vue', fromPath);
 }
 exports.importVueIntegration = importVueIntegration;
+function importPrettier(fromPath) {
+    // This shouldn't ever fail, because we bundle Prettier in the extension itself
+    const prettierPkg = getPackagePath('prettier', [fromPath, __dirname]);
+    return require(prettierPkg);
+}
+exports.importPrettier = importPrettier;
+function getPrettierPluginPath(fromPath) {
+    return getPackagePath('prettier-plugin-astro', [fromPath, __dirname]);
+}
+exports.getPrettierPluginPath = getPrettierPluginPath;

package/dist/plugins/PluginHost.d.ts

@@ -24,6 +24,7 @@ export declare class PluginHost {
     getSemanticTokens(textDocument: TextDocumentIdentifier, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getLinkedEditingRanges(textDocument: TextDocumentIdentifier, position: Position): Promise<LinkedEditingRanges | null>;
     getDefinitions(textDocument: TextDocumentIdentifier, position: Position): Promise<DefinitionLink[] | Location[]>;
+    getTypeDefinition(textDocument: TextDocumentIdentifier, position: Position): Promise<Location[] | null>;
     rename(textDocument: TextDocumentIdentifier, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getDocumentColors(textDocument: TextDocumentIdentifier): Promise<ColorInformation[]>;
     getColorPresentations(textDocument: TextDocumentIdentifier, range: Range, color: Color): Promise<ColorPresentation[]>;

package/dist/plugins/PluginHost.js

@@ -115,6 +115,10 @@ class PluginHost {
             return definitions.map((def) => ({ range: def.targetSelectionRange, uri: def.targetUri }));
         }
     }
+    getTypeDefinition(textDocument, position) {
+        const document = this.getDocument(textDocument.uri);
+        return this.execute('getTypeDefinitions', [document, position], ExecuteMode.FirstNonNull);
+    }
     async rename(textDocument, position, newName) {
         const document = this.getDocument(textDocument.uri);
         return this.execute('rename', [document, position, newName], ExecuteMode.FirstNonNull);

package/dist/plugins/astro/AstroPlugin.d.ts

@@ -1,13 +1,15 @@
-import { CompletionContext, FoldingRange, Position } from 'vscode-languageserver';
+import { CompletionContext, FoldingRange, Position, TextEdit, FormattingOptions } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
-import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AstroDocument } from '../../core/documents';
 import { AppCompletionList, Plugin } from '../interfaces';
+import { LanguageServiceManager } from '../typescript/LanguageServiceManager';
 export declare class AstroPlugin implements Plugin {
     __name: string;
     private configManager;
     private readonly languageServiceManager;
     private readonly completionProvider;
-    constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
+    constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
+    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): FoldingRange[];
 }

package/dist/plugins/astro/AstroPlugin.js

@@ -2,19 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroPlugin = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
-const LanguageServiceManager_1 = require("../typescript/LanguageServiceManager");
+const importPackage_1 = require("../../importPackage");
+const utils_1 = require("../../utils");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 class AstroPlugin {
-    constructor(docManager, configManager, workspaceUris) {
+    constructor(configManager, languageServiceManager) {
         this.__name = 'astro';
         this.configManager = configManager;
-        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.languageServiceManager = languageServiceManager;
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
     }
     async getCompletions(document, position, completionContext) {
         const completions = this.completionProvider.getCompletions(document, position, completionContext);
         return completions;
     }
+    async formatDocument(document, options) {
+        const filePath = document.getFilePath();
+        if (!filePath) {
+            return [];
+        }
+        const prettier = (0, importPackage_1.importPrettier)(filePath);
+        const prettierConfig = await prettier.resolveConfig(filePath, { editorconfig: true, useCache: false });
+        const editorFormatConfig = options !== undefined
+            ? {
+                tabWidth: prettierConfig?.tabWidth ?? options.tabSize,
+                useTabs: prettierConfig?.useTabs ?? !options.insertSpaces,
+            }
+            : {};
+        const resultConfig = (0, utils_1.mergeDeep)(prettierConfig ?? {}, editorFormatConfig);
+        const fileInfo = await prettier.getFileInfo(filePath, { ignorePath: '.prettierignore' });
+        if (fileInfo.ignored) {
+            return [];
+        }
+        const result = prettier.format(document.getText(), {
+            ...resultConfig,
+            plugins: getAstroPrettierPlugin(),
+            parser: 'astro',
+        });
+        return document.getText() === result
+            ? []
+            : [vscode_languageserver_1.TextEdit.replace(vscode_languageserver_1.Range.create(document.positionAt(0), document.positionAt(document.getTextLength())), result)];
+        function getAstroPrettierPlugin() {
+            const hasPluginLoadedAlready = prettier.getSupportInfo().languages.some((l) => l.name === 'astro');
+            return hasPluginLoadedAlready ? [] : [(0, importPackage_1.getPrettierPluginPath)(filePath)];
+        }
+    }
     getFoldingRanges(document) {
         const foldingRanges = [];
         const { frontmatter } = document.astroMeta;

package/dist/plugins/css/language-service.d.ts

@@ -1,3 +1,3 @@
 import { LanguageService } from 'vscode-css-languageservice';
-export declare function getLanguage(kind?: string): "css" | "scss" | "less";
+export declare function getLanguage(kind?: string): "css" | "less" | "scss";
 export declare function getLanguageService(kind?: string): LanguageService;

package/dist/plugins/html/HTMLPlugin.d.ts

@@ -1,4 +1,4 @@
-import { CompletionList, Position, TextEdit, FoldingRange, Hover, SymbolInformation, FormattingOptions, LinkedEditingRanges } from 'vscode-languageserver';
+import { CompletionList, Position, FoldingRange, Hover, SymbolInformation, LinkedEditingRanges } from 'vscode-languageserver';
 import type { Plugin } from '../interfaces';
 import { ConfigManager } from '../../core/config/ConfigManager';
 import { AstroDocument } from '../../core/documents/AstroDocument';
@@ -15,7 +15,6 @@ export declare class HTMLPlugin implements Plugin {
      * Get HTML completions
      */
     getCompletions(document: AstroDocument, position: Position): Promise<CompletionList | null>;
-    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
     getLinkedEditingRanges(document: AstroDocument, position: Position): LinkedEditingRanges | null;
     doTagComplete(document: AstroDocument, position: Position): Promise<string | null>;

package/dist/plugins/html/HTMLPlugin.js

@@ -76,30 +76,16 @@ class HTMLPlugin {
         const inTagName = (0, utils_1.isInTagName)(html, offset);
         const results = inComponentTag && !inTagName
             ? (0, utils_2.removeDataAttrCompletion)(this.attributeOnlyLang.doComplete(document, position, html).items)
-            : // We filter items with no documentation to prevent duplicates with our own defined script and style tags
-                this.lang.doComplete(document, position, html).items.filter((item) => item.documentation !== undefined);
+            : this.lang.doComplete(document, position, html).items.filter(isNoAddedTagWithNoDocumentation);
         const langCompletions = inComponentTag ? [] : this.getLangCompletions(results);
         return vscode_languageserver_1.CompletionList.create([...results, ...langCompletions, ...emmetResults.items], 
         // Emmet completions change on every keystroke, so they are never complete
         emmetResults.items.length > 0);
-    }
-    async formatDocument(document, options) {
-        const start = document.positionAt(document.astroMeta.frontmatter.state === 'closed' ? document.astroMeta.frontmatter.endOffset + 3 : 0);
-        if (document.astroMeta.frontmatter.state === 'closed') {
-            start.line += 1;
-            start.character = 0;
-        }
-        const end = document.positionAt(document.getTextLength());
-        const htmlFormatConfig = (await this.configManager.getConfig('html.format', document.uri)) ?? {};
-        // The HTML plugin can't format script tags properly, we'll handle those inside the TypeScript plugin
-        if (htmlFormatConfig.contentUnformatted) {
-            htmlFormatConfig.contentUnformatted = htmlFormatConfig.contentUnformatted + ',script';
-        }
-        else {
-            htmlFormatConfig.contentUnformatted = 'script';
-        }
-        const edits = this.lang.format(document, vscode_languageserver_1.Range.create(start, end), { ...htmlFormatConfig, ...options });
-        return edits;
+        // Filter script and style completions with no documentation to prevent duplicates
+        // due to our added definitions for those tags
+        function isNoAddedTagWithNoDocumentation(item) {
+            return !(['script', 'style'].includes(item.label) && item.documentation === undefined);
+        }
     }
     getFoldingRanges(document) {
         const html = document.html;

package/dist/plugins/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CodeAction, CodeActionContext, Color, Location, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 export declare type Resolvable<T> = T | Promise<T>;
 export interface AppCompletionItem<T extends TextDocumentIdentifier = any> extends CompletionItem {
@@ -74,6 +74,9 @@ export interface SemanticTokensProvider {
 export interface LinkedEditingRangesProvider {
     getLinkedEditingRanges(document: TextDocument, position: Position): Resolvable<LinkedEditingRanges | null>;
 }
+export interface TypeDefinitionProvider {
+    getTypeDefinitions(document: TextDocument, position: Position): Resolvable<Location[] | null>;
+}
 export interface OnWatchFileChangesParam {
     fileName: string;
     changeType: FileChangeType;
@@ -84,7 +87,7 @@ export interface OnWatchFileChangesProvider {
 export interface UpdateNonAstroFile {
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
 }
-declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & InlayHintsProvider & UpdateNonAstroFile;
+declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & TypeDefinitionProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & InlayHintsProvider & UpdateNonAstroFile;
 export declare type LSProvider = ProviderBase;
 export declare type Plugin = Partial<ProviderBase> & {
     __name: string;

package/dist/plugins/typescript/TypeScriptPlugin.d.ts

@@ -1,8 +1,9 @@
-import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Location, Diagnostic, FoldingRange, Hover, InlayHint, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
-import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AstroDocument } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
 import { CompletionItemData } from './features/CompletionsProvider';
+import { LanguageServiceManager } from './LanguageServiceManager';
 import { Astro2TSXResult } from './astro2tsx';
 export declare class TypeScriptPlugin implements Plugin {
     __name: string;
@@ -12,17 +13,16 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly completionProvider;
     private readonly hoverProvider;
     private readonly definitionsProvider;
+    private readonly typeDefinitionsProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
     private readonly inlayHintsProvider;
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
-    private readonly formattingProvider;
-    constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
+    constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
-    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
     getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
@@ -31,6 +31,7 @@ export declare class TypeScriptPlugin implements Plugin {
     resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     getInlayHints(document: AstroDocument, range: Range): Promise<InlayHint[]>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
+    getTypeDefinition(document: AstroDocument, position: Position): Promise<Location[] | null>;
     getDiagnostics(document: AstroDocument, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): Promise<void>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -10,7 +10,6 @@ const CompletionsProvider_1 = require("./features/CompletionsProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
 const HoverProvider_1 = require("./features/HoverProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
-const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_1 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
@@ -18,25 +17,25 @@ const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
 const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
 const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
-const FormattingProvider_1 = require("./features/FormattingProvider");
 const astro2tsx_1 = __importDefault(require("./astro2tsx"));
 const utils_2 = require("./snapshots/utils");
+const TypeDefinitionsProvider_1 = require("./features/TypeDefinitionsProvider");
 class TypeScriptPlugin {
-    constructor(docManager, configManager, workspaceUris) {
+    constructor(configManager, languageServiceManager) {
         this.__name = 'typescript';
         this.configManager = configManager;
-        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.languageServiceManager = languageServiceManager;
         this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager, this.configManager);
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager, this.configManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
         this.definitionsProvider = new DefinitionsProvider_1.DefinitionsProviderImpl(this.languageServiceManager);
+        this.typeDefinitionsProvider = new TypeDefinitionsProvider_1.TypeDefinitionsProviderImpl(this.languageServiceManager);
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
         this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
         this.inlayHintsProvider = new InlayHintsProvider_1.InlayHintsProviderImpl(this.languageServiceManager, this.configManager);
         this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
-        this.formattingProvider = new FormattingProvider_1.FormattingProviderImpl(this.languageServiceManager, this.configManager);
     }
     async doHover(document, position) {
         if (!(await this.featureEnabled(document, 'hover'))) {
@@ -67,9 +66,6 @@ class TypeScriptPlugin {
         });
         return edit;
     }
-    async formatDocument(document, options) {
-        return this.formattingProvider.formatDocument(document, options);
-    }
     async getFoldingRanges(document) {
         return this.foldingRangesProvider.getFoldingRanges(document);
     }
@@ -108,6 +104,9 @@ class TypeScriptPlugin {
     async getDefinitions(document, position) {
         return this.definitionsProvider.getDefinitions(document, position);
     }
+    async getTypeDefinition(document, position) {
+        return this.typeDefinitionsProvider.getTypeDefinitions(document, position);
+    }
     async getDiagnostics(document, cancellationToken) {
         if (!(await this.featureEnabled(document, 'diagnostics'))) {
             return [];

package/dist/plugins/typescript/astro2tsx.js

@@ -4,10 +4,24 @@ const os_1 = require("os");
 const parseAstro_1 = require("../../core/documents/parseAstro");
 function addProps(content, className) {
     let defaultExportType = 'Record<string, any>';
+    let shouldAddGlobal = false;
+    let astroGlobal = "type AstroGlobal = import('astro').AstroGlobal";
+    const astroGlobalConstDef = `
+	/**
+	 * Astro global available in all contexts in .astro files
+	 *
+	 * [Astro documentation](https://docs.astro.build/reference/api-reference/#astro-global)
+	 */
+	declare const Astro: Readonly<AstroGlobal>;
+	`;
     if (/(interface|type) Props/.test(content)) {
         defaultExportType = 'Props';
+        shouldAddGlobal = true;
+        astroGlobal += ' & { props: Props }';
     }
-    return os_1.EOL + `export default function ${className}__AstroComponent_(_props: ${defaultExportType}): any {}`;
+    return (os_1.EOL +
+        (shouldAddGlobal ? astroGlobal + os_1.EOL + astroGlobalConstDef : '') +
+        `export default function ${className}__AstroComponent_(_props: ${defaultExportType}): any {}`);
 }
 function escapeTemplateLiteralContent(content) {
     return content.replace(/`/g, '\\`');

package/dist/plugins/typescript/features/TypeDefinitionsProvider.d.ts

@@ -0,0 +1,9 @@
+import { Position, Location } from 'vscode-languageserver-protocol';
+import { AstroDocument } from '../../../core/documents';
+import { TypeDefinitionProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class TypeDefinitionsProviderImpl implements TypeDefinitionProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getTypeDefinitions(document: AstroDocument, position: Position): Promise<Location[]>;
+}

package/dist/plugins/typescript/features/TypeDefinitionsProvider.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeDefinitionsProviderImpl = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class TypeDefinitionsProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getTypeDefinitions(document, position) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const fragmentOffset = mainFragment.offsetAt(mainFragment.getGeneratedPosition(position));
+        const tsFilePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        const node = html.findNodeAt(offset);
+        let typeDefs;
+        if (node.tag === 'script') {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath, offset: scriptOffset, } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node, position);
+            typeDefs = lang.getTypeDefinitionAtPosition(scriptFilePath, scriptOffset);
+            if (typeDefs) {
+                typeDefs = typeDefs.map((def) => {
+                    const isInSameFile = def.fileName === scriptFilePath;
+                    def.fileName = isInSameFile ? tsFilePath : def.fileName;
+                    if (isInSameFile) {
+                        def.textSpan.start = mainFragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(def.textSpan.start)));
+                    }
+                    return def;
+                });
+            }
+        }
+        else {
+            typeDefs = lang.getTypeDefinitionAtPosition(tsFilePath, fragmentOffset);
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsFilePath, { fragment: mainFragment, snapshot: tsDoc });
+        if (!typeDefs) {
+            return [];
+        }
+        const result = await Promise.all(typeDefs.map(async (typeDef) => {
+            const { fragment } = await docs.retrieve(typeDef.fileName);
+            const fileName = (0, utils_2.ensureRealFilePath)(typeDef.fileName);
+            const range = (0, documents_1.mapRangeToOriginal)(fragment, (0, utils_2.convertRange)(fragment, typeDef.textSpan));
+            if (range.start.line >= 0 && range.end.line >= 0) {
+                return vscode_languageserver_protocol_1.Location.create((0, utils_1.pathToUrl)(fileName), range);
+            }
+        }));
+        return result.filter(utils_1.isNotNullOrUndefined);
+    }
+}
+exports.TypeDefinitionsProviderImpl = TypeDefinitionsProviderImpl;

package/dist/plugins/typescript/language-service.js

@@ -72,7 +72,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     const tsconfigRoot = tsconfigPath ? (0, path_1.dirname)(tsconfigPath) : process.cwd();
     const workspacePaths = workspaceUris.map((uri) => (0, utils_1.urlToPath)(uri));
     const workspacePath = workspacePaths.find((uri) => tsconfigRoot.startsWith(uri)) || workspacePaths[0];
-    const astroVersion = (0, utils_1.getUserAstroVersion)(workspacePath);
+    const astroInstall = (0, utils_1.getAstroInstall)([tsconfigRoot, workspacePath]);
     const config = (await docContext.configManager.getConfig('astro.typescript', workspacePath)) ?? {};
     const allowArbitraryAttrs = config.allowArbitraryAttributes ?? false;
     // `raw` here represent the tsconfig merged with any extended config
@@ -81,9 +81,8 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, tsconfigRoot || process.cwd());
     const astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions);
     const scriptFileNames = [];
-    if (astroVersion.exist) {
-        const astroDir = (0, path_1.dirname)(require.resolve('astro', { paths: [workspacePath] }));
-        scriptFileNames.push(...['./env.d.ts', './astro-jsx.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(astroDir, f))));
+    if (astroInstall) {
+        scriptFileNames.push(...['./env.d.ts', './astro-jsx.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(astroInstall.path, f))));
     }
     let languageServerDirectory;
     try {
@@ -92,14 +91,13 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     catch (e) {
         languageServerDirectory = __dirname;
     }
-    // Before Astro 1.0, JSX definitions were inside of the language-server instead of inside Astro
-    // TODO: Remove this and astro-jsx.d.ts in types when we consider having support for Astro < 1.0 unnecessary
-    if ((astroVersion.major === 0 || astroVersion.full === '1.0.0-beta.0') &&
-        !astroVersion.full.startsWith('0.0.0-rc-') // 1.0.0's RC is considered to be 0.0.0, so we have to check for it
+    // Fallback to internal types when Astro is not installed or the Astro version is too old
+    if (!astroInstall ||
+        ((astroInstall.version.major === 0 || astroInstall.version.full === '1.0.0-beta.0') &&
+            !astroInstall.version.full.startsWith('0.0.0-rc-')) // 1.0.0's RC is considered to be 0.0.0, so we have to check for it
     ) {
-        const astroTSXFile = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/astro-jsx.d.ts'));
-        scriptFileNames.push(astroTSXFile);
-        console.warn("Version lower than 1.0 detected, using internal types instead of Astro's");
+        scriptFileNames.push(...['../types/astro-jsx.d.ts', '../types/env.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, f))));
+        console.warn("Couldn't load types from Astro, using internal types instead");
     }
     if (allowArbitraryAttrs) {
         const arbitraryAttrsDTS = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/arbitrary-attrs.d.ts'));