@astrojs/language-server 0.26.2 → 0.28.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,15 +23,18 @@ 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[]>;
     getInlayHints(textDocument: TextDocumentIdentifier, range: Range, cancellationToken?: CancellationToken): Promise<InlayHint[]>;
     getSignatureHelp(textDocument: TextDocumentIdentifier, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
-    onWatchFileChanges(onWatchFileChangesParams: any[]): void;
-    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
+    onWatchFileChanges(onWatchFileChangesParams: any[]): Promise<void>;
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[], text?: string): void;
     private getDocument;
     private execute;
     private tryExecutePlugin;

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);
@@ -139,14 +151,14 @@ class PluginHost {
         const document = this.getDocument(textDocument.uri);
         return await this.execute('getSignatureHelp', [document, position, context, cancellationToken], ExecuteMode.FirstNonNull);
     }
-    onWatchFileChanges(onWatchFileChangesParams) {
+    async onWatchFileChanges(onWatchFileChangesParams) {
         for (const support of this.plugins) {
-            support.onWatchFileChanges?.(onWatchFileChangesParams);
+            await support.onWatchFileChanges?.(onWatchFileChangesParams);
         }
     }
-    updateNonAstroFile(fileName, changes) {
+    updateNonAstroFile(fileName, changes, text) {
         for (const support of this.plugins) {
-            support.updateNonAstroFile?.(fileName, changes);
+            support.updateNonAstroFile?.(fileName, changes, text);
         }
     }
     getDocument(uri) {

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);
             }
@@ -157,7 +157,7 @@ class CompletionsProviderImpl {
                 if (this.ts.isImportDeclaration(node)) {
                     let clauses = node.importClause;
                     if (!clauses)
-                        return null;
+                        continue;
                     let namedImport = clauses.getChildAt(0);
                     if (this.ts.isNamedImports(namedImport)) {
                         for (let imp of namedImport.elements) {

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 {
@@ -82,12 +88,12 @@ export interface OnWatchFileChangesParam {
     changeType: FileChangeType;
 }
 export interface OnWatchFileChangesProvider {
-    onWatchFileChanges(onWatchFileChangesParams: OnWatchFileChangesParam[]): void;
+    onWatchFileChanges(onWatchFileChangesParams: OnWatchFileChangesParam[]): Promise<void>;
 }
 export interface UpdateNonAstroFile {
-    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[], text?: string): 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/LanguageServiceManager.d.ts

@@ -3,6 +3,7 @@ import type { ConfigManager } from '../../core/config';
 import type { AstroDocument, DocumentManager } from '../../core/documents';
 import { LanguageServiceContainer, LanguageServiceDocumentContext } from './language-service';
 import type { DocumentSnapshot } from './snapshots/DocumentSnapshot';
+import { SnapshotManager } from './snapshots/SnapshotManager';
 export declare class LanguageServiceManager {
     private readonly docManager;
     private readonly workspaceUris;
@@ -31,11 +32,15 @@ export declare class LanguageServiceManager {
     /**
      * Updates file in all ts services where it exists
      */
-    updateExistingNonAstroFile(path: string, changes?: TextDocumentContentChangeEvent[]): Promise<void>;
+    updateExistingNonAstroFile(path: string, changes?: TextDocumentContentChangeEvent[], text?: string): Promise<void>;
     getLSAndTSDoc(document: AstroDocument): Promise<{
         tsDoc: DocumentSnapshot;
         lang: ts.LanguageService;
     }>;
     getLSForPath(path: string): Promise<import("typescript/lib/tsserverlibrary").LanguageService>;
     getTypeScriptLanguageService(filePath: string): Promise<LanguageServiceContainer>;
+    /**
+     * @internal Public for tests only
+     */
+    getSnapshotManager(filePath: string): Promise<SnapshotManager>;
 }

package/dist/plugins/typescript/LanguageServiceManager.js

@@ -63,7 +63,7 @@ class LanguageServiceManager {
     /**
      * Updates file in all ts services where it exists
      */
-    async updateExistingNonAstroFile(path, changes) {
+    async updateExistingNonAstroFile(path, changes, text) {
         path = (0, utils_1.normalizePath)(path);
         // Only update once because all snapshots are shared between
         // services. Since we don't have a current version of TS/JS
@@ -72,7 +72,7 @@ class LanguageServiceManager {
         await (0, language_service_1.forAllLanguageServices)((service) => {
             if (service.hasFile(path) && !didUpdate) {
                 didUpdate = true;
-                service.updateNonAstroFile(path, changes);
+                service.updateNonAstroFile(path, changes, text);
             }
         });
     }
@@ -87,5 +87,11 @@ class LanguageServiceManager {
     async getTypeScriptLanguageService(filePath) {
         return (0, language_service_1.getLanguageService)(filePath, this.workspaceUris, this.docContext);
     }
+    /**
+     * @internal Public for tests only
+     */
+    async getSnapshotManager(filePath) {
+        return (await this.getTypeScriptLanguageService(filePath)).snapshotManager;
+    }
 }
 exports.LanguageServiceManager = LanguageServiceManager;

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,12 +34,19 @@ 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>;
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[], text?: string): Promise<void>;
     getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
     getTSXForDocument(document: AstroDocument): Astro2TSXResult;
+    /**
+     * @internal Public for tests only
+     */
+    getSnapshotManager(fileName: string): Promise<import("./snapshots/SnapshotManager").SnapshotManager>;
     private featureEnabled;
 }

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 [];
@@ -117,7 +132,7 @@ class TypeScriptPlugin {
         let doneUpdateProjectFiles = false;
         for (const { fileName, changeType } of onWatchFileChangesParas) {
             const scriptKind = (0, utils_2.getScriptKindFromFileName)(fileName, this.ts);
-            if (scriptKind === this.ts.ScriptKind.Unknown) {
+            if (scriptKind === this.ts.ScriptKind.Unknown && !(0, utils_2.isFrameworkFilePath)(fileName) && !(0, utils_2.isAstroFilePath)(fileName)) {
                 continue;
             }
             if (changeType === vscode_languageserver_1.FileChangeType.Created && !doneUpdateProjectFiles) {
@@ -127,13 +142,14 @@ class TypeScriptPlugin {
             else if (changeType === vscode_languageserver_1.FileChangeType.Deleted) {
                 await this.languageServiceManager.deleteSnapshot(fileName);
             }
-            else {
+            else if (!(0, utils_2.isAstroFilePath)(fileName)) {
+                // Content updates for Astro files are handled through the documentManager and the 'documentChange' event
                 await this.languageServiceManager.updateExistingNonAstroFile(fileName);
             }
         }
     }
-    async updateNonAstroFile(fileName, changes) {
-        await this.languageServiceManager.updateExistingNonAstroFile(fileName, changes);
+    async updateNonAstroFile(fileName, changes, text) {
+        await this.languageServiceManager.updateExistingNonAstroFile(fileName, changes, text);
     }
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
@@ -141,6 +157,12 @@ class TypeScriptPlugin {
     getTSXForDocument(document) {
         return (0, astro2tsx_1.default)(document.getText(), (0, utils_1.classNameFromFilename)(document.getURL()));
     }
+    /**
+     * @internal Public for tests only
+     */
+    getSnapshotManager(fileName) {
+        return this.languageServiceManager.getSnapshotManager(fileName);
+    }
     async featureEnabled(document, feature) {
         return ((await this.configManager.isEnabled(document, 'typescript')) &&
             (await this.configManager.isEnabled(document, 'typescript', feature)));

package/dist/plugins/typescript/astro-sys.js

@@ -20,7 +20,7 @@ function createAstroSys(getSnapshot, ts) {
             return snapshot.getText(0, snapshot.getLength());
         },
         readDirectory(path, extensions, exclude, include, depth) {
-            const extensionsWithAstro = (extensions ?? []).concat(...['.astro', '.svelte', '.vue']);
+            const extensionsWithAstro = (extensions ?? []).concat(...['.astro', '.svelte', '.vue', '.md', '.mdx', '.html']);
             const result = ts.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
             return result;
         },

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

@@ -166,7 +166,8 @@ class CodeActionsProviderImpl {
                     // Since our last line is a (virtual) export, organize imports will try to rewrite it, so let's only take
                     // changes that actually happens inside the script tag
                     .filter((change) => {
-                    return scriptTagSnapshot.isInGenerated(document.positionAt(change.span.start));
+                    return (scriptTagSnapshot.isInGenerated(document.positionAt(change.span.start)) &&
+                        !change.newText.includes('export { }'));
                 });
                 return edit;
             });

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/plugins/typescript/language-service.d.ts

@@ -14,7 +14,7 @@ export interface LanguageServiceContainer {
     updateSnapshot(documentOrFilePath: AstroDocument | string, ts: typeof import('typescript/lib/tsserverlibrary')): DocumentSnapshot;
     deleteSnapshot(filePath: string): void;
     updateProjectFiles(): void;
-    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[], text?: string): void;
     /**
      * Checks if a file is present in the project.
      * Unlike `fileBelongsToProject`, this doesn't run a file search on disk.

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

@@ -214,11 +214,11 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         filePath = (0, utils_1.normalizePath)(filePath);
         return hasFile(filePath) || getParsedTSConfig().fileNames.includes(filePath);
     }
-    function updateNonAstroFile(fileName, changes) {
+    function updateNonAstroFile(fileName, changes, text) {
         if (!snapshotManager.has(fileName)) {
             astroModuleLoader.deleteUnresolvedResolutionsFromCache(fileName);
         }
-        snapshotManager.updateNonAstroFile(fileName, changes);
+        snapshotManager.updateNonAstroFile(fileName, changes, text);
     }
     function createScriptTagsSnapshots(fileName, document) {
         return document.scriptTags.map((scriptTag, index) => {
@@ -229,7 +229,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         });
     }
     function createDocumentSymbolSnapshot(doc) {
-        return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(doc.version, doc.filePath, doc.parent.getText(), docContext.ts.ScriptKind.Unknown);
+        return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(doc.version, doc.filePath, doc.parent.getText(), docContext.ts.ScriptKind.Unknown, false);
     }
     function getParsedTSConfig() {
         let configJson = (tsconfigPath && docContext.ts.readConfigFile(tsconfigPath, docContext.ts.sys.readFile).config) || {};

package/dist/plugins/typescript/snapshots/DocumentSnapshot.d.ts

@@ -1,6 +1,5 @@
 import type { Position, TextDocumentContentChangeEvent } from 'vscode-languageserver';
 import { AstroDocument, DocumentMapper, FragmentMapper, IdentityMapper, TagInformation } from '../../../core/documents';
-import type { FrameworkExt } from '../utils';
 export interface DocumentSnapshot extends ts.IScriptSnapshot {
     version: number;
     filePath: string;
@@ -92,10 +91,10 @@ export declare class TypeScriptDocumentSnapshot extends IdentityMapper implement
     version: number;
     readonly filePath: string;
     private text;
-    readonly framework?: FrameworkExt | undefined;
+    readonly supportPartialUpdate: boolean;
     scriptKind: ts.ScriptKind;
     private lineOffsets?;
-    constructor(version: number, filePath: string, text: string, scriptKind: ts.ScriptKind, framework?: FrameworkExt | undefined);
+    constructor(version: number, filePath: string, text: string, scriptKind: ts.ScriptKind, supportPartialUpdate: boolean);
     getText(start: number, end: number): string;
     getLength(): number;
     getFullText(): string;

package/dist/plugins/typescript/snapshots/DocumentSnapshot.js

@@ -119,12 +119,12 @@ exports.ScriptTagDocumentSnapshot = ScriptTagDocumentSnapshot;
  * It's both used for .js(x)/.ts(x) files and .svelte/.vue files
  */
 class TypeScriptDocumentSnapshot extends documents_1.IdentityMapper {
-    constructor(version, filePath, text, scriptKind, framework) {
+    constructor(version, filePath, text, scriptKind, supportPartialUpdate) {
         super((0, utils_1.pathToUrl)(filePath));
         this.version = version;
         this.filePath = filePath;
         this.text = text;
-        this.framework = framework;
+        this.supportPartialUpdate = supportPartialUpdate;
         this.scriptKind = scriptKind;
     }
     getText(start, end) {

package/dist/plugins/typescript/snapshots/SnapshotManager.d.ts

@@ -13,7 +13,7 @@ export declare class GlobalSnapshotManager {
     get(fileName: string): DocumentSnapshot | undefined;
     set(fileName: string, document: DocumentSnapshot): void;
     delete(fileName: string): void;
-    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): TypeScriptDocumentSnapshot | undefined;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[], newText?: string): TypeScriptDocumentSnapshot | undefined;
     onChange(listener: (fileName: string, newDocument: DocumentSnapshot | undefined) => void): void;
 }
 export interface TsFilesSpec {
@@ -31,10 +31,9 @@ export declare class SnapshotManager {
     private ts;
     private documents;
     private lastLogged;
-    private readonly watchExtensions;
     constructor(globalSnapshotsManager: GlobalSnapshotManager, projectFiles: string[], fileSpec: TsFilesSpec, workspaceRoot: string, ts: typeof import('typescript/lib/tsserverlibrary'));
     updateProjectFiles(): void;
-    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[], text?: string): void;
     has(fileName: string): boolean;
     set(fileName: string, snapshot: DocumentSnapshot): void;
     get(fileName: string): DocumentSnapshot | undefined;

package/dist/plugins/typescript/snapshots/SnapshotManager.js

@@ -26,7 +26,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapshotManager = exports.GlobalSnapshotManager = void 0;
 const events_1 = require("events");
 const utils_1 = require("../../../utils");
-const utils_2 = require("../utils");
 const DocumentSnapshot_1 = require("./DocumentSnapshot");
 const DocumentSnapshotUtils = __importStar(require("./utils"));
 /**
@@ -58,20 +57,17 @@ class GlobalSnapshotManager {
         this.documents.delete(fileName);
         this.emitter.emit('change', fileName, undefined);
     }
-    updateNonAstroFile(fileName, changes) {
+    updateNonAstroFile(fileName, changes, newText) {
         fileName = (0, utils_1.normalizePath)(fileName);
         const previousSnapshot = this.get(fileName);
-        if (changes) {
-            // We don't support incremental changes for Framework files, as they need to be rebuilt completely on every change
-            if (!(previousSnapshot instanceof DocumentSnapshot_1.TypeScriptDocumentSnapshot) || previousSnapshot.framework) {
-                return;
-            }
+        const canBePartiallyUpdated = changes && previousSnapshot instanceof DocumentSnapshot_1.TypeScriptDocumentSnapshot && previousSnapshot.supportPartialUpdate;
+        if (canBePartiallyUpdated) {
             previousSnapshot.update(changes);
             this.emitter.emit('change', fileName, previousSnapshot);
             return previousSnapshot;
         }
         else {
-            const newSnapshot = DocumentSnapshotUtils.createFromNonAstroFilePath(fileName, this.ts);
+            const newSnapshot = DocumentSnapshotUtils.createFromNonAstroFilePath(fileName, this.ts, newText);
             if (previousSnapshot) {
                 newSnapshot.version = previousSnapshot.version + 1;
             }
@@ -81,6 +77,7 @@ class GlobalSnapshotManager {
                 newSnapshot.version += 1;
             }
             this.set(fileName, newSnapshot);
+            this.emitter.emit('change', fileName, newSnapshot);
             return newSnapshot;
         }
     }
@@ -101,14 +98,6 @@ class SnapshotManager {
         this.ts = ts;
         this.documents = new Map();
         this.lastLogged = new Date(new Date().getTime() - 60001);
-        this.watchExtensions = [
-            this.ts.Extension.Dts,
-            this.ts.Extension.Js,
-            this.ts.Extension.Jsx,
-            this.ts.Extension.Ts,
-            this.ts.Extension.Tsx,
-            this.ts.Extension.Json,
-        ];
         this.globalSnapshotsManager.onChange((fileName, document) => {
             // Only delete/update snapshots, don't add new ones,
             // as they could be from another TS service and this
@@ -131,12 +120,12 @@ class SnapshotManager {
             return;
         }
         const projectFiles = this.ts.sys
-            .readDirectory(this.workspaceRoot, this.watchExtensions, exclude, include)
+            .readDirectory(this.workspaceRoot, [...Object.values(this.ts.Extension), '.astro', '.svelte', '.vue'], exclude, include)
             .map(utils_1.normalizePath);
         this.projectFiles = Array.from(new Set([...this.projectFiles, ...projectFiles]));
     }
-    updateNonAstroFile(fileName, changes) {
-        const snapshot = this.globalSnapshotsManager.updateNonAstroFile(fileName, changes);
+    updateNonAstroFile(fileName, changes, text) {
+        const snapshot = this.globalSnapshotsManager.updateNonAstroFile(fileName, changes, text);
         // This isn't duplicated logic to the listener, because this could
         // be a new snapshot which the listener wouldn't add.
         if (snapshot) {
@@ -181,8 +170,7 @@ class SnapshotManager {
         if (date.getTime() - this.lastLogged.getTime() > 60000) {
             this.lastLogged = date;
             const projectFiles = this.getProjectFileNames();
-            let allFiles = Array.from(new Set([...projectFiles, ...this.getFileNames()]));
-            allFiles = allFiles.map((file) => (0, utils_2.ensureRealFilePath)(file));
+            const allFiles = Array.from(new Set([...projectFiles, ...this.getFileNames()]));
             // eslint-disable-next-line no-console
             console.log('SnapshotManager File Statistics:\n' +
                 `Project files: ${projectFiles.length}\n` +

package/dist/plugins/typescript/snapshots/utils.d.ts

@@ -12,18 +12,18 @@ export declare function createFromFilePath(filePath: string, createDocument: (fi
  * Return a Framework or a TS snapshot from a file path, depending on the file contents
  * Unlike createFromFilePath, this does not support creating an Astro snapshot
  */
-export declare function createFromNonAstroFilePath(filePath: string, ts: typeof import('typescript/lib/tsserverlibrary')): TypeScriptDocumentSnapshot;
+export declare function createFromNonAstroFilePath(filePath: string, ts: typeof import('typescript/lib/tsserverlibrary'), forceText?: string): TypeScriptDocumentSnapshot;
 /**
  * Returns a ts/js snapshot from a file path.
  * @param filePath path to the js/ts file
  * @param options options that apply in case it's a svelte file
  */
-export declare function createFromTSFilePath(filePath: string, ts: typeof import('typescript/lib/tsserverlibrary')): TypeScriptDocumentSnapshot;
+export declare function createFromTSFilePath(filePath: string, ts: typeof import('typescript/lib/tsserverlibrary'), forceText?: string): TypeScriptDocumentSnapshot;
 /**
  * Returns an Astro snapshot from a file path.
  * @param filePath path to the Astro file
  * @param createDocument function that is used to create a document
  */
 export declare function createFromAstroFilePath(filePath: string, createDocument: (filePath: string, text: string) => AstroDocument, ts: typeof import('typescript/lib/tsserverlibrary')): AstroSnapshot;
-export declare function createFromFrameworkFilePath(filePath: string, framework: FrameworkExt, ts: typeof import('typescript/lib/tsserverlibrary')): TypeScriptDocumentSnapshot;
+export declare function createFromFrameworkFilePath(filePath: string, framework: FrameworkExt, ts: typeof import('typescript/lib/tsserverlibrary'), forceText?: string): TypeScriptDocumentSnapshot;
 export declare function classNameFromFilename(filename: string): string;

package/dist/plugins/typescript/snapshots/utils.js

@@ -38,13 +38,13 @@ exports.createFromFilePath = createFromFilePath;
  * Return a Framework or a TS snapshot from a file path, depending on the file contents
  * Unlike createFromFilePath, this does not support creating an Astro snapshot
  */
-function createFromNonAstroFilePath(filePath, ts) {
+function createFromNonAstroFilePath(filePath, ts, forceText) {
     if ((0, utils_2.isFrameworkFilePath)(filePath)) {
         const framework = (0, utils_2.getFrameworkFromFilePath)(filePath);
-        return createFromFrameworkFilePath(filePath, framework, ts);
+        return createFromFrameworkFilePath(filePath, framework, ts, forceText);
     }
     else {
-        return createFromTSFilePath(filePath, ts);
+        return createFromTSFilePath(filePath, ts, forceText);
     }
 }
 exports.createFromNonAstroFilePath = createFromNonAstroFilePath;
@@ -53,9 +53,9 @@ exports.createFromNonAstroFilePath = createFromNonAstroFilePath;
  * @param filePath path to the js/ts file
  * @param options options that apply in case it's a svelte file
  */
-function createFromTSFilePath(filePath, ts) {
-    const originalText = ts.sys.readFile(filePath) ?? '';
-    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, originalText, (0, utils_2.getScriptKindFromFileName)(filePath, ts));
+function createFromTSFilePath(filePath, ts, forceText) {
+    const originalText = forceText ?? ts.sys.readFile(filePath) ?? '';
+    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, originalText, (0, utils_2.getScriptKindFromFileName)(filePath, ts), true);
 }
 exports.createFromTSFilePath = createFromTSFilePath;
 /**
@@ -68,9 +68,9 @@ function createFromAstroFilePath(filePath, createDocument, ts) {
     return createFromDocument(createDocument(filePath, originalText), ts);
 }
 exports.createFromAstroFilePath = createFromAstroFilePath;
-function createFromFrameworkFilePath(filePath, framework, ts) {
+function createFromFrameworkFilePath(filePath, framework, ts, forceText) {
     const className = classNameFromFilename(filePath);
-    const originalText = ts.sys.readFile(filePath) ?? '';
+    const originalText = forceText ?? ts.sys.readFile(filePath) ?? '';
     let code = '';
     if (framework === 'svelte') {
         const svelteIntegration = (0, importPackage_1.importSvelteIntegration)(filePath);
@@ -84,7 +84,7 @@ function createFromFrameworkFilePath(filePath, framework, ts) {
             code = vueIntegration.toTSX(originalText, className);
         }
     }
-    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, code, ts.ScriptKind.TSX);
+    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, code, ts.ScriptKind.TSX, false);
 }
 exports.createFromFrameworkFilePath = createFromFrameworkFilePath;
 function classNameFromFilename(filename) {

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: {
@@ -184,20 +186,22 @@ function startLanguageServer(connection, env) {
     });
     const diagnosticsManager = new DiagnosticsManager_1.DiagnosticsManager(connection.sendDiagnostics, documentManager, pluginHost.getDiagnostics.bind(pluginHost));
     const updateAllDiagnostics = (0, utils_2.debounceThrottle)(() => diagnosticsManager.updateAll(), 1000);
-    connection.onDidChangeWatchedFiles((evt) => {
+    connection.onDidChangeWatchedFiles(async (evt) => {
         const params = evt.changes
             .map((change) => ({
             fileName: (0, utils_2.urlToPath)(change.uri),
             changeType: change.type,
         }))
             .filter((change) => !!change.fileName);
-        pluginHost.onWatchFileChanges(params);
+        await pluginHost.onWatchFileChanges(params);
         updateAllDiagnostics();
     });
     // 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) => {
@@ -226,21 +230,24 @@ function startLanguageServer(connection, env) {
     connection.onNotification('$/onDidChangeNonAstroFile', async (e) => {
         const path = (0, utils_2.urlToPath)(e.uri);
         if (path) {
-            pluginHost.updateNonAstroFile(path, e.changes);
+            pluginHost.updateNonAstroFile(path, e.changes, e.text);
         }
         updateAllDiagnostics();
     });
+    connection.onRequest('$/getFileReferences', async (uri) => {
+        return pluginHost.fileReferences({ uri });
+    });
     connection.onRequest('$/getTSXOutput', async (uri) => {
         const doc = documentManager.get(uri);
         if (!doc) {
             return undefined;
         }
-        if (doc) {
+        if (doc && typescriptPlugin) {
             const tsxOutput = typescriptPlugin.getTSXForDocument(doc);
             return tsxOutput.code;
         }
     });
-    documentManager.on('documentChange', (0, utils_2.debounceThrottle)(async (document) => diagnosticsManager.update(document), 1000));
+    documentManager.on('documentChange', updateAllDiagnostics);
     documentManager.on('documentClose', (document) => {
         diagnosticsManager.removeDiagnostics(document);
         configManager.removeDocument(document.uri);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.26.2",
+  "version": "0.28.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"
   }
 }