@astrojs/language-server 0.21.1 → 0.23.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @astrojs/language-server
 
+## 0.23.1
+
+### Patch Changes
+
+- 422376e: Load settings from the Prettier VS Code extension when available
+
+## 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

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,7 @@ 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>;
+    getPrettierVSConfig(document: TextDocument): Promise<Record<string, any>>;
     getTSFormatConfig(document: TextDocument, vscodeOptions?: FormattingOptions): Promise<FormatCodeSettings>;
     getTSPreferences(document: TextDocument): Promise<UserPreferences>;
     getTSInlayHintsPreferences(document: TextDocument): Promise<InlayHintsOptions>;

package/dist/core/config/ConfigManager.js

@@ -90,12 +90,9 @@ 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 getPrettierVSConfig(document) {
+        const prettierVSConfig = (await this.getConfig('prettier', document.uri)) ?? {};
+        return prettierVSConfig;
     }
     async getTSFormatConfig(document, vscodeOptions) {
         const formatConfig = (await this.getConfig('typescript.format', document.uri)) ?? {};

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 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) {
@@ -42,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,4 +1,4 @@
-import { CompletionContext, FoldingRange, Position } from 'vscode-languageserver';
+import { CompletionContext, FoldingRange, Position, TextEdit, FormattingOptions } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument } from '../../core/documents';
 import { AppCompletionList, Plugin } from '../interfaces';
@@ -10,5 +10,6 @@ export declare class AstroPlugin implements Plugin {
     private readonly completionProvider;
     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,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroPlugin = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
+const importPackage_1 = require("../../importPackage");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 class AstroPlugin {
     constructor(configManager, languageServiceManager) {
@@ -14,6 +15,42 @@ class AstroPlugin {
         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 prettierVSConfig = await this.configManager.getPrettierVSConfig(document);
+        const editorFormatConfig = options !== undefined // We need to check for options existing here because some editors might not have it
+            ? {
+                tabWidth: options.tabSize,
+                useTabs: !options.insertSpaces,
+            }
+            : {};
+        // Return a config with the following cascade:
+        // - Prettier config file should always win if it exists, if it doesn't:
+        // - Prettier config from the VS Code extension is used, if it doesn't exist:
+        // - Use the editor's basic configuration settings
+        const resultConfig = returnObjectIfHasKeys(prettierConfig) || returnObjectIfHasKeys(prettierVSConfig) || 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;
@@ -41,3 +78,8 @@ class AstroPlugin {
     }
 }
 exports.AstroPlugin = AstroPlugin;
+function returnObjectIfHasKeys(obj) {
+    if (Object.keys(obj || {}).length > 0) {
+        return obj;
+    }
+}

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,4 +1,4 @@
-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 } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -13,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(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[]>;
@@ -32,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

@@ -17,9 +17,9 @@ 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(configManager, languageServiceManager) {
         this.__name = 'typescript';
@@ -29,13 +29,13 @@ class TypeScriptPlugin {
         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'))) {
@@ -66,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);
     }
@@ -107,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/server.js

@@ -48,6 +48,7 @@ function startLanguageServer(connection) {
     let typescriptPlugin = undefined;
     let hasConfigurationCapability = false;
     connection.onInitialize((params) => {
+        const environment = params.initializationOptions?.environment ?? 'node';
         const workspaceUris = params.workspaceFolders?.map((folder) => folder.uri.toString()) ?? [params.rootUri ?? ''];
         workspaceUris.forEach((uri) => {
             uri = (0, utils_1.urlToPath)(uri);
@@ -73,7 +74,7 @@ function startLanguageServer(connection) {
         pluginHost.registerPlugin(new HTMLPlugin_1.HTMLPlugin(configManager));
         pluginHost.registerPlugin(new CSSPlugin_1.CSSPlugin(configManager));
         // We don't currently support running the TypeScript and Astro plugin in the browser
-        if (params.initializationOptions.environment !== 'browser') {
+        if (environment === 'node') {
             const languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(documentManager, workspaceUris.map(utils_1.normalizeUri), configManager);
             typescriptPlugin = new plugins_1.TypeScriptPlugin(configManager, languageServiceManager);
             pluginHost.registerPlugin(new AstroPlugin_1.AstroPlugin(configManager, languageServiceManager));
@@ -90,6 +91,7 @@ function startLanguageServer(connection) {
                 },
                 foldingRangeProvider: true,
                 definitionProvider: true,
+                typeDefinitionProvider: true,
                 renameProvider: true,
                 documentFormattingProvider: true,
                 codeActionProvider: {
@@ -184,6 +186,7 @@ function startLanguageServer(connection) {
     // Features
     connection.onHover((params) => pluginHost.doHover(params.textDocument, params.position));
     connection.onDefinition((evt) => pluginHost.getDefinitions(evt.textDocument, evt.position));
+    connection.onTypeDefinition((evt) => pluginHost.getTypeDefinition(evt.textDocument, evt.position));
     connection.onFoldingRanges((evt) => pluginHost.getFoldingRanges(evt.textDocument));
     connection.onCodeAction((evt, cancellationToken) => pluginHost.getCodeActions(evt.textDocument, evt.range, evt.context, cancellationToken));
     connection.onCompletion(async (evt) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.21.1",
+  "version": "0.23.1",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",
@@ -20,6 +20,8 @@
   },
   "dependencies": {
     "@vscode/emmet-helper": "^2.8.4",
+    "prettier": "^2.7.1",
+    "prettier-plugin-astro": "^0.5.3",
     "source-map": "^0.7.3",
     "typescript": "~4.6.4",
     "vscode-css-languageservice": "^6.0.1",
@@ -35,6 +37,7 @@
     "@astrojs/vue": "^0.5.0",
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.1.0",
+    "@types/prettier": "^2.7.0",
     "@types/sinon": "^10.0.11",
     "astro": "^1.0.0-beta.72",
     "astro-scripts": "0.0.1",

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

@@ -1,11 +0,0 @@
-import { FormattingOptions, TextEdit } from 'vscode-languageserver-types';
-import { ConfigManager } from '../../../core/config';
-import { AstroDocument } from '../../../core/documents';
-import { FormattingProvider } from '../../interfaces';
-import { LanguageServiceManager } from '../LanguageServiceManager';
-export declare class FormattingProviderImpl implements FormattingProvider {
-    private languageServiceManager;
-    private configManager;
-    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
-    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
-}

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

@@ -1,132 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FormattingProviderImpl = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const vscode_languageserver_types_1 = require("vscode-languageserver-types");
-const utils_1 = require("../utils");
-class FormattingProviderImpl {
-    constructor(languageServiceManager, configManager) {
-        this.languageServiceManager = languageServiceManager;
-        this.configManager = configManager;
-    }
-    async formatDocument(document, options) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
-        const formatConfig = await this.configManager.getTSFormatConfig(document, options);
-        let frontmatterEdits = [];
-        let scriptTagsEdits = [];
-        if (document.astroMeta.frontmatter.state === 'closed') {
-            const start = document.positionAt(document.astroMeta.frontmatter.startOffset + 3);
-            start.line += 1;
-            start.character = 0;
-            const startOffset = document.offsetAt(start);
-            const endOffset = document.astroMeta.frontmatter.endOffset;
-            const astroFormatConfig = await this.configManager.getAstroFormatConfig(document);
-            const settings = {
-                ...formatConfig,
-                baseIndentSize: astroFormatConfig.indentFrontmatter ? formatConfig.tabSize ?? 0 : undefined,
-            };
-            frontmatterEdits = lang.getFormattingEditsForRange(filePath, startOffset, endOffset, settings);
-            if (astroFormatConfig.newLineAfterFrontmatter) {
-                const templateStart = document.positionAt(endOffset + 3);
-                templateStart.line += 1;
-                templateStart.character = 0;
-                frontmatterEdits.push({
-                    span: { start: document.offsetAt(templateStart), length: 0 },
-                    newText: '\n',
-                });
-            }
-        }
-        document.scriptTags.forEach((scriptTag) => {
-            const { filePath: scriptFilePath, snapshot: scriptTagSnapshot } = (0, utils_1.getScriptTagSnapshot)(tsDoc, document, scriptTag.container);
-            const startLine = document.offsetAt(vscode_languageserver_types_1.Position.create(scriptTag.startPos.line, 0));
-            const initialIndentLevel = computeInitialIndent(document, startLine, options);
-            const baseIndent = (formatConfig.tabSize ?? 0) * (initialIndentLevel + 1);
-            const formatSettings = {
-                baseIndentSize: baseIndent,
-                indentStyle: typescript_1.default.IndentStyle.Smart,
-                ...formatConfig,
-            };
-            let edits = lang.getFormattingEditsForDocument(scriptFilePath, formatSettings);
-            if (edits) {
-                edits = edits
-                    .map((edit) => {
-                    edit.span.start = document.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(edit.span.start)));
-                    return edit;
-                })
-                    .filter((edit) => {
-                    return (scriptTagSnapshot.isInGenerated(document.positionAt(edit.span.start)) &&
-                        scriptTag.end !== edit.span.start &&
-                        // Don't format the last line of the file as it's in most case the indentation
-                        scriptTag.endPos.line !== document.positionAt(edit.span.start).line);
-                });
-                const endLine = document.getLineUntilOffset(document.offsetAt(scriptTag.endPos));
-                if (isWhitespaceOnly(endLine)) {
-                    const endLineStartOffset = document.offsetAt(vscode_languageserver_types_1.Position.create(scriptTag.endPos.line, 0));
-                    const lastLineIndentRange = vscode_languageserver_types_1.Range.create(vscode_languageserver_types_1.Position.create(scriptTag.endPos.line, 0), scriptTag.endPos);
-                    const newText = generateIndent(initialIndentLevel, options);
-                    if (endLine !== newText) {
-                        edits.push({
-                            span: {
-                                start: endLineStartOffset,
-                                length: lastLineIndentRange.end.character,
-                            },
-                            newText,
-                        });
-                    }
-                }
-            }
-            scriptTagsEdits.push(...edits);
-        });
-        return [...frontmatterEdits, ...scriptTagsEdits].map((edit) => ({
-            range: (0, utils_1.convertRange)(document, edit.span),
-            newText: edit.newText,
-        }));
-    }
-}
-exports.FormattingProviderImpl = FormattingProviderImpl;
-function computeInitialIndent(document, lineStart, options) {
-    let content = document.getText();
-    let i = lineStart;
-    let nChars = 0;
-    let tabSize = options.tabSize || 4;
-    while (i < content.length) {
-        let ch = content.charAt(i);
-        if (ch === ' ') {
-            nChars++;
-        }
-        else if (ch === '\t') {
-            nChars += tabSize;
-        }
-        else {
-            break;
-        }
-        i++;
-    }
-    return Math.floor(nChars / tabSize);
-}
-function generateIndent(level, options) {
-    if (options.insertSpaces) {
-        return repeat(' ', level * options.tabSize);
-    }
-    else {
-        return repeat('\t', level);
-    }
-}
-function repeat(value, count) {
-    let s = '';
-    while (count > 0) {
-        if ((count & 1) === 1) {
-            s += value;
-        }
-        value += value;
-        count = count >>> 1;
-    }
-    return s;
-}
-function isWhitespaceOnly(str) {
-    return /^\s*$/.test(str);
-}