@astrojs/language-server 0.20.3 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @astrojs/language-server
 
+## 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
+
+- 574b75d: Remove support for the Markdown component
+- d23ba22: Changed how Astro's types are consumed to avoid making type acquisition explicit inside Astro files
+
+### Patch Changes
+
+- 81f3aa5: Added a debug command to show the currently opened document's TSX output
+
 ## 0.20.3
 
 ### Patch 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

@@ -83,24 +83,6 @@ class HTMLPlugin {
         // 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;
-    }
     getFoldingRanges(document) {
         const html = document.html;
         if (!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,10 @@
-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;
     private configManager;
@@ -11,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[]>;
@@ -30,9 +31,11 @@ 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>;
     getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
+    getTSXForDocument(document: AstroDocument): Astro2TSXResult;
     private featureEnabled;
 }

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,23 +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'))) {
@@ -65,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);
     }
@@ -106,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 [];
@@ -137,6 +138,9 @@ class TypeScriptPlugin {
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
     }
+    getTSXForDocument(document) {
+        return (0, astro2tsx_1.default)(document.getText(), (0, utils_2.classNameFromFilename)(document.getURL()));
+    }
     async featureEnabled(document, feature) {
         return ((await this.configManager.isEnabled(document, 'typescript')) &&
             (await this.configManager.isEnabled(document, 'typescript', feature)));

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

@@ -1,5 +1,4 @@
-interface Astro2TSXResult {
+export interface Astro2TSXResult {
     code: string;
 }
 export default function (content: string, className: string): Astro2TSXResult;
-export {};

package/dist/plugins/typescript/astro2tsx.js

@@ -41,10 +41,6 @@ function default_1(content, className) {
         // Turn styles tags into internal strings
         .replace(/<\s*style([^>]*)>(.*?)<\s*\/\s*style>/gs, (_whole, attrs, children) => {
         return `<style${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</style>`;
-    })
-        // Turn Markdown tags into internal strings
-        .replace(/<\s*Markdown([^>]*)>(.*?)<\s*\/\s*Markdown>/gs, (_whole, attrs, children) => {
-        return `<Markdown${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</Markdown>`;
     })
         // Turn scripts into function calls
         .replace(/<\s*script([^\/>]*)>(.*?)<\s*\/\s*script>/gs, (_whole, attrs, children, offset) => {

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

@@ -95,7 +95,6 @@ class DiagnosticsProviderImpl {
         const sourceFile = program?.getSourceFile(tsFilePath);
         const boundaries = {
             script: [],
-            markdown: [],
         };
         if (!sourceFile) {
             return boundaries;
@@ -110,10 +109,6 @@ class DiagnosticsProviderImpl {
                             boundaries.script.push([node.getStart(), node.getEnd()]);
                             break;
                         }
-                        case 'Markdown': {
-                            boundaries.markdown.push([node.getStart(), node.getEnd()]);
-                            break;
-                        }
                     }
                 }
                 findTags(node);

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

@@ -19,7 +19,7 @@ class FoldingRangesProviderImpl {
             const node = html.findNodeAt(span.textSpan.start);
             // Due to how our TSX output transform those tags into function calls or template literals
             // TypeScript thinks of those as outlining spans, which is fine but we don't want folding ranges for those
-            return node.tag !== 'script' && node.tag !== 'style' && node.tag !== 'Markdown';
+            return node.tag !== 'script' && node.tag !== 'style';
         });
         const scriptOutliningSpans = [];
         document.scriptTags.forEach((scriptTag) => {

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;