@astrojs/language-server 0.26.2 → 0.27.0

package/dist/plugins/PluginHost.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Location, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Location, Position, Range, ReferenceContext, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import type { DocumentManager } from '../core/documents/DocumentManager';
 import type { AppCompletionItem, Plugin } from './interfaces';
 export interface PluginHostConfig {
@@ -23,8 +23,11 @@ export declare class PluginHost {
     getDocumentSymbols(textDocument: TextDocumentIdentifier, cancellationToken?: CancellationToken): Promise<SymbolInformation[]>;
     getSemanticTokens(textDocument: TextDocumentIdentifier, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getLinkedEditingRanges(textDocument: TextDocumentIdentifier, position: Position): Promise<LinkedEditingRanges | null>;
+    fileReferences(textDocument: TextDocumentIdentifier): Promise<Location[] | null>;
     getDefinitions(textDocument: TextDocumentIdentifier, position: Position): Promise<DefinitionLink[] | Location[]>;
-    getTypeDefinition(textDocument: TextDocumentIdentifier, position: Position): Promise<Location[] | null>;
+    getTypeDefinitions(textDocument: TextDocumentIdentifier, position: Position): Promise<Location[] | null>;
+    getImplementations(textDocument: TextDocumentIdentifier, position: Position): Promise<Location[] | null>;
+    getReferences(textdocument: TextDocumentIdentifier, position: Position, context: ReferenceContext): 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

@@ -105,6 +105,10 @@ class PluginHost {
         const document = this.getDocument(textDocument.uri);
         return await this.execute('getLinkedEditingRanges', [document, position], ExecuteMode.FirstNonNull);
     }
+    async fileReferences(textDocument) {
+        const document = this.getDocument(textDocument.uri);
+        return await this.execute('fileReferences', [document], ExecuteMode.FirstNonNull);
+    }
     async getDefinitions(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
         const definitions = await this.execute('getDefinitions', [document, position], ExecuteMode.Collect);
@@ -115,10 +119,18 @@ class PluginHost {
             return definitions.map((def) => ({ range: def.targetSelectionRange, uri: def.targetUri }));
         }
     }
-    getTypeDefinition(textDocument, position) {
+    getTypeDefinitions(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
         return this.execute('getTypeDefinitions', [document, position], ExecuteMode.FirstNonNull);
     }
+    getImplementations(textDocument, position) {
+        const document = this.getDocument(textDocument.uri);
+        return this.execute('getImplementation', [document, position], ExecuteMode.FirstNonNull);
+    }
+    getReferences(textdocument, position, context) {
+        const document = this.getDocument(textdocument.uri);
+        return this.execute('findReferences', [document, position, context], 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/features/CompletionsProvider.js

@@ -34,7 +34,7 @@ class CompletionsProviderImpl {
                 items.push(...props);
             }
             const isAstro = componentFilePath?.endsWith('.astro');
-            if (!isAstro) {
+            if (!isAstro && node.tag !== 'Fragment') {
                 const directives = (0, utils_2.removeDataAttrCompletion)(this.directivesHTMLLang.doComplete(document, position, html).items);
                 items.push(...directives);
             }

package/dist/plugins/html/HTMLPlugin.js

@@ -37,7 +37,7 @@ class HTMLPlugin {
             return null;
         }
         // If the node we're hovering on is a component, instead only provide astro-specific hover info
-        if ((0, utils_1.isPossibleComponent)(node)) {
+        if ((0, utils_1.isPossibleComponent)(node) && node.tag !== 'Fragment') {
             return this.componentLang.doHover(document, position, html);
         }
         return this.lang.doHover(document, position, html);

package/dist/plugins/html/features/astro-attributes.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.astroDirectives = exports.astroAttributes = exports.astroElements = exports.classListAttribute = void 0;
 const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const defaultProvider = (0, vscode_html_languageservice_1.getDefaultHTMLDataProvider)();
+const slotAttr = defaultProvider.provideAttributes('div').find((attr) => attr.name === 'slot');
 exports.classListAttribute = (0, vscode_html_languageservice_1.newHTMLDataProvider)('class-list', {
     version: 1,
     globalAttributes: [
@@ -169,6 +171,7 @@ exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)
                 },
             ],
         },
+        slotAttr,
     ],
 });
 exports.astroDirectives = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-directives', {

package/dist/plugins/interfaces.d.ts

@@ -35,6 +35,9 @@ export interface ColorPresentationsProvider {
 export interface DocumentSymbolsProvider {
     getDocumentSymbols(document: TextDocument): Resolvable<SymbolInformation[]>;
 }
+export interface FileReferencesProvider {
+    fileReferences(document: TextDocument): Promise<Location[] | null>;
+}
 export interface DefinitionsProvider {
     getDefinitions(document: TextDocument, position: Position): Resolvable<DefinitionLink[]>;
 }
@@ -74,7 +77,10 @@ export interface SemanticTokensProvider {
 export interface LinkedEditingRangesProvider {
     getLinkedEditingRanges(document: TextDocument, position: Position): Resolvable<LinkedEditingRanges | null>;
 }
-export interface TypeDefinitionProvider {
+export interface ImplementationProvider {
+    getImplementation(document: TextDocument, position: Position): Resolvable<Location[] | null>;
+}
+export interface TypeDefinitionsProvider {
     getTypeDefinitions(document: TextDocument, position: Position): Resolvable<Location[] | null>;
 }
 export interface OnWatchFileChangesParam {
@@ -87,7 +93,7 @@ export interface OnWatchFileChangesProvider {
 export interface UpdateNonAstroFile {
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
 }
-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;
+declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & FileReferencesProvider & DefinitionsProvider & TypeDefinitionsProvider & ImplementationProvider & 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, Hover, InlayHint, Location, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, Hover, InlayHint, Location, Position, Range, ReferenceContext, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
 import type { ConfigManager } from '../../core/config';
 import type { AstroDocument } from '../../core/documents';
 import type { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -12,8 +12,11 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly codeActionsProvider;
     private readonly completionProvider;
     private readonly hoverProvider;
+    private readonly fileReferencesProvider;
     private readonly definitionsProvider;
     private readonly typeDefinitionsProvider;
+    private readonly implementationsProvider;
+    private readonly referencesProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
@@ -31,8 +34,11 @@ export declare class TypeScriptPlugin implements Plugin {
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
     resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     getInlayHints(document: AstroDocument, range: Range): Promise<InlayHint[]>;
+    fileReferences(document: AstroDocument): Promise<Location[] | null>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
-    getTypeDefinition(document: AstroDocument, position: Position): Promise<Location[] | null>;
+    getTypeDefinitions(document: AstroDocument, position: Position): Promise<Location[] | null>;
+    getImplementation(document: AstroDocument, position: Position): Promise<Location[] | null>;
+    findReferences(document: AstroDocument, position: Position, context: ReferenceContext): 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

@@ -11,9 +11,12 @@ const CompletionsProvider_1 = require("./features/CompletionsProvider");
 const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
+const FileReferencesProvider_1 = require("./features/FileReferencesProvider");
 const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const HoverProvider_1 = require("./features/HoverProvider");
+const ImplementationsProvider_1 = require("./features/ImplementationsProvider");
 const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
+const ReferencesProvider_1 = require("./features/ReferencesProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
 const TypeDefinitionsProvider_1 = require("./features/TypeDefinitionsProvider");
@@ -28,8 +31,11 @@ class TypeScriptPlugin {
         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.fileReferencesProvider = new FileReferencesProvider_1.FileReferencesProviderImpl(this.languageServiceManager);
         this.definitionsProvider = new DefinitionsProvider_1.DefinitionsProviderImpl(this.languageServiceManager);
         this.typeDefinitionsProvider = new TypeDefinitionsProvider_1.TypeDefinitionsProviderImpl(this.languageServiceManager);
+        this.implementationsProvider = new ImplementationsProvider_1.ImplementationsProviderImpl(this.languageServiceManager);
+        this.referencesProvider = new ReferencesProvider_1.FindReferencesProviderImpl(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);
@@ -101,12 +107,21 @@ class TypeScriptPlugin {
     async getInlayHints(document, range) {
         return this.inlayHintsProvider.getInlayHints(document, range);
     }
+    async fileReferences(document) {
+        return this.fileReferencesProvider.fileReferences(document);
+    }
     async getDefinitions(document, position) {
         return this.definitionsProvider.getDefinitions(document, position);
     }
-    async getTypeDefinition(document, position) {
+    async getTypeDefinitions(document, position) {
         return this.typeDefinitionsProvider.getTypeDefinitions(document, position);
     }
+    async getImplementation(document, position) {
+        return this.implementationsProvider.getImplementation(document, position);
+    }
+    async findReferences(document, position, context) {
+        return this.referencesProvider.findReferences(document, position, context);
+    }
     async getDiagnostics(document, cancellationToken) {
         if (!(await this.featureEnabled(document, 'diagnostics'))) {
             return [];

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

@@ -0,0 +1,9 @@
+import { Location } from 'vscode-languageserver';
+import { AstroDocument } from '../../../core/documents';
+import { FileReferencesProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class FileReferencesProviderImpl implements FileReferencesProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    fileReferences(document: AstroDocument): Promise<Location[] | null>;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReferencesProviderImpl = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class FileReferencesProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async fileReferences(document) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const references = lang.getFileReferences(tsDoc.filePath);
+        if (!references) {
+            return null;
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsDoc.filePath, { fragment: mainFragment, snapshot: tsDoc });
+        const locations = await Promise.all(references.map(async (ref) => {
+            const defDoc = await docs.retrieveFragment(ref.fileName);
+            return vscode_languageserver_1.Location.create((0, utils_1.pathToUrl)(ref.fileName), (0, utils_2.convertToLocationRange)(defDoc, ref.textSpan));
+        }));
+        return locations;
+    }
+}
+exports.FileReferencesProviderImpl = FileReferencesProviderImpl;

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementationsProviderImpl = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class ImplementationsProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getImplementation(document, position) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const offset = mainFragment.offsetAt(mainFragment.getGeneratedPosition(position));
+        const node = document.html.findNodeAt(offset);
+        let implementations;
+        if (node.tag === 'script') {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath, offset: scriptOffset, } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node, position);
+            implementations = lang.getImplementationAtPosition(scriptFilePath, scriptOffset);
+            if (implementations) {
+                implementations = implementations.map((impl) => {
+                    const isInSameFile = impl.fileName === scriptFilePath;
+                    impl.fileName = isInSameFile ? tsDoc.filePath : impl.fileName;
+                    if (isInSameFile) {
+                        impl.textSpan.start = mainFragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(impl.textSpan.start)));
+                    }
+                    return impl;
+                });
+            }
+        }
+        else {
+            implementations = lang.getImplementationAtPosition(tsDoc.filePath, offset);
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsDoc.filePath, { fragment: mainFragment, snapshot: tsDoc });
+        if (!implementations) {
+            return null;
+        }
+        const result = await Promise.all(implementations.map(async (implementation) => {
+            const { fragment } = await docs.retrieve(implementation.fileName);
+            const range = (0, documents_1.mapRangeToOriginal)(fragment, (0, utils_2.convertRange)(fragment, implementation.textSpan));
+            if (range.start.line >= 0 && range.end.line >= 0) {
+                return vscode_languageserver_types_1.Location.create((0, utils_1.pathToUrl)(implementation.fileName), range);
+            }
+        }));
+        return result.filter(utils_1.isNotNullOrUndefined);
+    }
+}
+exports.ImplementationsProviderImpl = ImplementationsProviderImpl;

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

@@ -0,0 +1,9 @@
+import { Location, Position, ReferenceContext } from 'vscode-languageserver-types';
+import { AstroDocument } from '../../../core/documents';
+import type { FindReferencesProvider } from '../../interfaces';
+import type { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class FindReferencesProviderImpl implements FindReferencesProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    findReferences(document: AstroDocument, position: Position, context: ReferenceContext): Promise<Location[] | null>;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindReferencesProviderImpl = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class FindReferencesProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async findReferences(document, position, context) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const offset = mainFragment.offsetAt(mainFragment.getGeneratedPosition(position));
+        const node = document.html.findNodeAt(offset);
+        let references;
+        if (node.tag === 'script') {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath, offset: scriptOffset, } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node, position);
+            references = lang.getReferencesAtPosition(scriptFilePath, scriptOffset);
+            if (references) {
+                references = references.map((ref) => {
+                    const isInSameFile = ref.fileName === scriptFilePath;
+                    ref.fileName = isInSameFile ? tsDoc.filePath : ref.fileName;
+                    if (isInSameFile) {
+                        ref.textSpan.start = mainFragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(ref.textSpan.start)));
+                    }
+                    return ref;
+                });
+            }
+        }
+        else {
+            references = lang.getReferencesAtPosition(tsDoc.filePath, offset);
+        }
+        if (!references) {
+            return null;
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsDoc.filePath, { fragment: mainFragment, snapshot: tsDoc });
+        const result = await Promise.all(references.map(async (reference) => {
+            if (!context.includeDeclaration) {
+                return null;
+            }
+            const { fragment } = await docs.retrieve(reference.fileName);
+            const range = (0, documents_1.mapRangeToOriginal)(fragment, (0, utils_2.convertRange)(fragment, reference.textSpan));
+            if (range.start.line >= 0 && range.end.line >= 0) {
+                return vscode_languageserver_types_1.Location.create((0, utils_1.pathToUrl)(reference.fileName), range);
+            }
+        }));
+        return result.filter(utils_1.isNotNullOrUndefined);
+    }
+}
+exports.FindReferencesProviderImpl = FindReferencesProviderImpl;

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

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

package/dist/server.js

@@ -103,6 +103,8 @@ function startLanguageServer(connection, env) {
                 foldingRangeProvider: true,
                 definitionProvider: true,
                 typeDefinitionProvider: true,
+                referencesProvider: true,
+                implementationProvider: true,
                 renameProvider: true,
                 documentFormattingProvider: true,
                 codeActionProvider: {
@@ -197,7 +199,9 @@ function startLanguageServer(connection, env) {
     // 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.onTypeDefinition((evt) => pluginHost.getTypeDefinitions(evt.textDocument, evt.position));
+    connection.onReferences((evt) => pluginHost.getReferences(evt.textDocument, evt.position, evt.context));
+    connection.onImplementation((evt) => pluginHost.getImplementations(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) => {
@@ -230,6 +234,9 @@ function startLanguageServer(connection, env) {
         }
         updateAllDiagnostics();
     });
+    connection.onRequest('$/getFileReferences', async (uri) => {
+        return pluginHost.fileReferences({ uri });
+    });
     connection.onRequest('$/getTSXOutput', async (uri) => {
         const doc = documentManager.get(uri);
         if (!doc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",
@@ -49,6 +49,7 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "dev": "astro-scripts dev \"src/**/*.ts\"",
-    "test": "cross-env TS_NODE_TRANSPILE_ONLY=true mocha --timeout 20000 --require ts-node/register \"test/**/*.ts\" --exclude \"test/**/*.d.ts\""
+    "test": "cross-env TS_NODE_TRANSPILE_ONLY=true mocha --timeout 20000 --require ts-node/register \"test/**/*.ts\" --exclude \"test/**/*.d.ts\"",
+    "test:match": "pnpm run test -g"
   }
 }