@astrojs/language-server 0.29.3 → 0.29.5

package/dist/core/worker/TSXService.d.ts

@@ -1,4 +1,4 @@
-import type { TSXResult } from '@astrojs/compiler/shared/types';
+import type { TSXResult } from '@astrojs/compiler/types';
 /**
  * Parse code by `@astrojs/compiler`
  */

package/dist/plugins/PluginHost.d.ts

@@ -28,6 +28,7 @@ export declare class PluginHost {
     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>;
+    prepareRename(textDocument: TextDocumentIdentifier, position: Position): Promise<Range | 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

@@ -131,6 +131,10 @@ class PluginHost {
         const document = this.getDocument(textdocument.uri);
         return this.execute('findReferences', [document, position, context], ExecuteMode.FirstNonNull);
     }
+    async prepareRename(textDocument, position) {
+        const document = this.getDocument(textDocument.uri);
+        return await this.execute('prepareRename', [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/css/CSSPlugin.d.ts

@@ -1,4 +1,4 @@
-import { Color, ColorInformation, ColorPresentation, CompletionContext, CompletionList, FoldingRange, Hover, Position, Range, SymbolInformation } from 'vscode-languageserver';
+import { Color, ColorInformation, ColorPresentation, CompletionContext, CompletionList, FoldingRange, Hover, Position, Range, SymbolInformation, WorkspaceEdit } from 'vscode-languageserver';
 import type { ConfigManager } from '../../core/config/ConfigManager';
 import { AstroDocument } from '../../core/documents';
 import type { Plugin } from '../interfaces';
@@ -14,6 +14,8 @@ export declare class CSSPlugin implements Plugin {
     private getCompletionsInternal;
     getDocumentColors(document: AstroDocument): Promise<ColorInformation[]>;
     getColorPresentations(document: AstroDocument, range: Range, color: Color): Promise<ColorPresentation[]>;
+    prepareRename(document: AstroDocument, position: Position): Range | null;
+    rename(document: AstroDocument, position: Position, newName: string): WorkspaceEdit | null;
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     private inStyleAttributeWithoutInterpolation;

package/dist/plugins/css/CSSPlugin.js

@@ -158,6 +158,34 @@ class CSSPlugin {
         });
         return allColorPres;
     }
+    prepareRename(document, position) {
+        const styleTag = this.getStyleTagForPosition(document, position);
+        if (!styleTag) {
+            return null;
+        }
+        const cssDocument = this.getCSSDocumentForStyleTag(styleTag, document);
+        const cssLang = extractLanguage(cssDocument);
+        const langService = (0, language_service_1.getLanguageService)(cssLang);
+        const range = langService.prepareRename(cssDocument, cssDocument.getGeneratedPosition(position), cssDocument.stylesheet);
+        if (!range) {
+            return null;
+        }
+        return (0, documents_1.mapRangeToOriginal)(cssDocument, range);
+    }
+    rename(document, position, newName) {
+        const styleTag = this.getStyleTagForPosition(document, position);
+        if (!styleTag) {
+            return null;
+        }
+        const cssDocument = this.getCSSDocumentForStyleTag(styleTag, document);
+        const cssLang = extractLanguage(cssDocument);
+        const langService = (0, language_service_1.getLanguageService)(cssLang);
+        const renames = langService.doRename(cssDocument, cssDocument.getGeneratedPosition(position), newName, cssDocument.stylesheet);
+        if (renames?.changes?.[document.uri]) {
+            renames.changes[document.uri] = renames?.changes?.[document.uri].map((edit) => (0, documents_1.mapObjWithRangeToOriginal)(cssDocument, edit));
+        }
+        return renames;
+    }
     getFoldingRanges(document) {
         const allFoldingRanges = this.getCSSDocumentsForDocument(document).flatMap((cssDoc) => {
             const cssLang = extractLanguage(cssDoc);

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

@@ -1,4 +1,4 @@
-import { CompletionList, FoldingRange, Hover, LinkedEditingRanges, Position, SymbolInformation } from 'vscode-languageserver';
+import { CompletionList, FoldingRange, Hover, LinkedEditingRanges, Position, Range, SymbolInformation, WorkspaceEdit } from 'vscode-languageserver';
 import type { ConfigManager } from '../../core/config/ConfigManager';
 import type { AstroDocument } from '../../core/documents/AstroDocument';
 import type { Plugin } from '../interfaces';
@@ -18,10 +18,16 @@ export declare class HTMLPlugin implements Plugin {
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
     getLinkedEditingRanges(document: AstroDocument, position: Position): LinkedEditingRanges | null;
     doTagComplete(document: AstroDocument, position: Position): Promise<string | null>;
+    prepareRename(document: AstroDocument, position: Position): Range | null;
+    rename(document: AstroDocument, position: Position, newName: string): WorkspaceEdit | null;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     /**
      * Get lang completions for style tags (ex: `<style lang="scss">`)
      */
     private getLangCompletions;
+    /**
+     * Returns true if rename happens at the tag name, not anywhere inbetween.
+     */
+    private isRenameAtTag;
     private featureEnabled;
 }

package/dist/plugins/html/HTMLPlugin.js

@@ -118,6 +118,29 @@ class HTMLPlugin {
         }
         return this.lang.doTagComplete(document, position, html);
     }
+    prepareRename(document, position) {
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        const node = html.findNodeAt(offset);
+        if (!node || (0, utils_1.isPossibleComponent)(node) || !node.tag || !this.isRenameAtTag(node, offset)) {
+            return null;
+        }
+        const tagNameStart = node.start + '<'.length;
+        return vscode_languageserver_1.Range.create(document.positionAt(tagNameStart), document.positionAt(tagNameStart + node.tag.length));
+    }
+    rename(document, position, newName) {
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        if (!html || (0, utils_1.isInsideFrontmatter)(document.getText(), offset)) {
+            return null;
+        }
+        const node = html.findNodeAt(offset);
+        // The TypeScript plugin handles renaming for components
+        if (!node || (0, utils_1.isPossibleComponent)(node) || !this.isRenameAtTag(node, offset)) {
+            return null;
+        }
+        return this.lang.doRename(document, position, newName, html);
+    }
     async getDocumentSymbols(document) {
         if (!(await this.featureEnabled(document, 'documentSymbols'))) {
             return [];
@@ -155,6 +178,18 @@ class HTMLPlugin {
             }));
         }
     }
+    /**
+     * Returns true if rename happens at the tag name, not anywhere inbetween.
+     */
+    isRenameAtTag(node, offset) {
+        if (!node.tag) {
+            return false;
+        }
+        const startTagNameEnd = node.start + `<${node.tag}`.length;
+        const isAtStartTag = offset > node.start && offset <= startTagNameEnd;
+        const isAtEndTag = node.endTagStart !== undefined && offset >= node.endTagStart && offset < node.end;
+        return isAtStartTag || isAtEndTag;
+    }
     async featureEnabled(document, feature) {
         return ((await this.configManager.isEnabled(document, 'html')) &&
             (await this.configManager.isEnabled(document, 'html', feature)));

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

@@ -1,4 +1,4 @@
-import type { TSXResult } from '@astrojs/compiler/shared/types';
+import type { TSXResult } from '@astrojs/compiler/types';
 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';
@@ -23,9 +23,11 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly inlayHintsProvider;
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
+    private readonly renameProvider;
     private readonly ts;
     constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
+    prepareRename(document: AstroDocument, position: Position): Promise<Range | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
     getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -17,6 +17,7 @@ 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 RenameProvider_1 = require("./features/RenameProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
 const TypeDefinitionsProvider_1 = require("./features/TypeDefinitionsProvider");
@@ -41,6 +42,7 @@ class TypeScriptPlugin {
         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.renameProvider = new RenameProvider_1.RenameProviderImpl(this.languageServiceManager, this.configManager);
     }
     async doHover(document, position) {
         if (!(await this.featureEnabled(document, 'hover'))) {
@@ -48,27 +50,11 @@ class TypeScriptPlugin {
         }
         return this.hoverProvider.doHover(document, position);
     }
+    async prepareRename(document, position) {
+        return this.renameProvider.prepareRename(document, position);
+    }
     async rename(document, position, newName) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const offset = tsDoc.offsetAt(tsDoc.getGeneratedPosition(position));
-        let renames = lang.findRenameLocations(tsDoc.filePath, offset, false, false, true);
-        if (!renames) {
-            return null;
-        }
-        let edit = {
-            changes: {},
-        };
-        renames.forEach((rename) => {
-            const filePath = (0, utils_1.ensureRealFilePath)(rename.fileName);
-            if (!(filePath in edit.changes)) {
-                edit.changes[filePath] = [];
-            }
-            edit.changes[filePath].push({
-                newText: newName,
-                range: (0, utils_1.convertToLocationRange)(tsDoc, rename.textSpan),
-            });
-        });
-        return edit;
+        return this.renameProvider.rename(document, position, newName);
     }
     async getFoldingRanges(document) {
         return this.foldingRangesProvider.getFoldingRanges(document);

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

@@ -1,2 +1,2 @@
-import { TSXResult } from '@astrojs/compiler/shared/types';
+import { TSXResult } from '@astrojs/compiler/types';
 export default function (content: string, fileName: string): TSXResult;

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

@@ -23,12 +23,6 @@ export declare class CompletionsProviderImpl implements CompletionsProvider<Comp
     resolveCompletion(document: AstroDocument, item: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     private toCompletionItem;
     private getCompletionDocument;
-    /**
-     * If the textEdit is out of the word range of the triggered position
-     * vscode would refuse to show the completions
-     * split those edits into additionalTextEdit to fix it
-     */
-    private fixTextEditRange;
     private canReuseLastCompletion;
     private getExistingImports;
     private isAstroComponentImport;

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

@@ -79,12 +79,6 @@ class CompletionsProviderImpl {
         else {
             // PERF: Getting TS completions is fairly slow and I am currently not sure how to speed it up
             // As such, we'll try to avoid getting them when unneeded, such as when we're doing HTML stuff
-            // When at the root of the document TypeScript offer all kinds of completions, because it doesn't know yet that
-            // it's JSX and not JS. As such, people who are using Emmet to write their template suffer from a very degraded experience
-            // from what they're used to in HTML files (which is instant completions). So let's disable ourselves when we're at the root
-            if (!isCompletionInsideFrontmatter && !node.parent && !isCompletionInsideExpression) {
-                return null;
-            }
             // If the user just typed `<` with nothing else, let's disable ourselves until we're more sure if the user wants TS completions
             if (!isCompletionInsideFrontmatter && node.parent && node.tag === undefined && !isCompletionInsideExpression) {
                 return null;
@@ -102,16 +96,11 @@ class CompletionsProviderImpl {
         if (completions === undefined || completions.entries.length === 0) {
             return null;
         }
-        const wordRange = completions.optionalReplacementSpan
-            ? vscode_languageserver_1.Range.create(document.positionAt(completions.optionalReplacementSpan.start), document.positionAt(completions.optionalReplacementSpan.start + completions.optionalReplacementSpan.length))
-            : undefined;
-        const wordRangeStartPosition = wordRange?.start;
         const existingImports = this.getExistingImports(document);
         const completionItems = completions.entries
             .filter((completion) => this.isValidCompletion(completion, this.ts))
             .map((entry) => this.toCompletionItem(tsDoc, entry, filePath, offset, isCompletionInsideFrontmatter, scriptTagIndex, existingImports))
-            .filter(utils_2.isNotNullOrUndefined)
-            .map((comp) => this.fixTextEditRange(wordRangeStartPosition, comp));
+            .filter(utils_2.isNotNullOrUndefined);
         const completionList = vscode_languageserver_1.CompletionList.create(completionItems, true);
         this.lastCompletion = { key: document.getFilePath() || '', position, completionList };
         return completionList;
@@ -212,7 +201,7 @@ class CompletionsProviderImpl {
             item.insertText = comp.insertText ? (0, utils_3.removeAstroComponentSuffix)(comp.insertText) : undefined;
             item.insertTextFormat = comp.isSnippet ? vscode_languageserver_1.InsertTextFormat.Snippet : vscode_languageserver_1.InsertTextFormat.PlainText;
             item.textEdit = comp.replacementSpan
-                ? vscode_languageserver_1.TextEdit.replace((0, utils_3.convertRange)(snapshot, comp.replacementSpan), item.insertText ?? item.label)
+                ? vscode_languageserver_1.TextEdit.replace((0, utils_3.convertToLocationRange)(snapshot, comp.replacementSpan), item.insertText ?? item.label)
                 : undefined;
         }
         return {
@@ -242,37 +231,6 @@ class CompletionsProviderImpl {
             detail,
         };
     }
-    /**
-     * If the textEdit is out of the word range of the triggered position
-     * vscode would refuse to show the completions
-     * split those edits into additionalTextEdit to fix it
-     */
-    fixTextEditRange(wordRangePosition, completionItem) {
-        const { textEdit } = completionItem;
-        if (!textEdit || !vscode_languageserver_1.TextEdit.is(textEdit) || !wordRangePosition) {
-            return completionItem;
-        }
-        const { newText, range: { start }, } = textEdit;
-        const wordRangeStartCharacter = wordRangePosition.character;
-        if (wordRangePosition.line !== wordRangePosition.line || start.character > wordRangePosition.character) {
-            return completionItem;
-        }
-        textEdit.newText = newText.substring(wordRangeStartCharacter - start.character);
-        textEdit.range.start = {
-            line: start.line,
-            character: wordRangeStartCharacter,
-        };
-        completionItem.additionalTextEdits = [
-            vscode_languageserver_1.TextEdit.replace({
-                start,
-                end: {
-                    line: start.line,
-                    character: wordRangeStartCharacter,
-                },
-            }, newText.substring(0, wordRangeStartCharacter - start.character)),
-        ];
-        return completionItem;
-    }
     canReuseLastCompletion(lastCompletion, triggerKind, triggerCharacter, document, position) {
         return (!!lastCompletion &&
             lastCompletion.key === document.getFilePath() &&

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

@@ -6,6 +6,7 @@ import type { LanguageServiceManager } from '../LanguageServiceManager';
 export declare enum DiagnosticCodes {
     SPREAD_EXPECTED = 1005,
     IS_NOT_A_MODULE = 2306,
+    CANNOT_FIND_MODULE = 2307,
     DUPLICATED_JSX_ATTRIBUTES = 17001,
     CANT_RETURN_OUTSIDE_FUNC = 1108,
     ISOLATED_MODULE_COMPILE_ERR = 1208,

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

@@ -11,6 +11,7 @@ var DiagnosticCodes;
 (function (DiagnosticCodes) {
     DiagnosticCodes[DiagnosticCodes["SPREAD_EXPECTED"] = 1005] = "SPREAD_EXPECTED";
     DiagnosticCodes[DiagnosticCodes["IS_NOT_A_MODULE"] = 2306] = "IS_NOT_A_MODULE";
+    DiagnosticCodes[DiagnosticCodes["CANNOT_FIND_MODULE"] = 2307] = "CANNOT_FIND_MODULE";
     DiagnosticCodes[DiagnosticCodes["DUPLICATED_JSX_ATTRIBUTES"] = 17001] = "DUPLICATED_JSX_ATTRIBUTES";
     DiagnosticCodes[DiagnosticCodes["CANT_RETURN_OUTSIDE_FUNC"] = 1108] = "CANT_RETURN_OUTSIDE_FUNC";
     DiagnosticCodes[DiagnosticCodes["ISOLATED_MODULE_COMPILE_ERR"] = 1208] = "ISOLATED_MODULE_COMPILE_ERR";
@@ -31,8 +32,7 @@ class DiagnosticsProviderImpl {
         }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         // If we have compiler errors, our TSX isn't valid so don't bother showing TS errors
-        if (tsDoc.compilerDiagnostics.filter((diag) => diag.severity === vscode_languageserver_1.DiagnosticSeverity.Error).length >
-            0) {
+        if (tsDoc.isInErrorState) {
             return [];
         }
         let scriptDiagnostics = [];
@@ -203,6 +203,11 @@ function enhanceIfNecessary(diagnostic) {
         }
         return diagnostic;
     }
+    if (diagnostic.code === DiagnosticCodes.CANNOT_FIND_MODULE && diagnostic.message.includes('astro:content')) {
+        diagnostic.message +=
+            "\n\nIf you're using content collections, make sure to run `astro dev`, `astro build` or `astro sync` to first generate the types so you can import from them. If you already ran one of those commands, restarting the language server might be necessary in order for the change to take effect";
+        return diagnostic;
+    }
     // JSX element has no closing tag. JSX -> HTML
     if (diagnostic.code === DiagnosticCodes.JSX_NO_CLOSING_TAG) {
         return {

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

@@ -0,0 +1,13 @@
+import type { Position, Range, WorkspaceEdit } from 'vscode-languageserver-types';
+import type { ConfigManager } from '../../../core/config';
+import { AstroDocument } from '../../../core/documents';
+import type { RenameProvider } from '../../interfaces';
+import type { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class RenameProviderImpl implements RenameProvider {
+    private languageServiceManager;
+    private configManager;
+    private ts;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
+    prepareRename(document: AstroDocument, position: Position): Promise<Range | null>;
+    rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameProviderImpl = void 0;
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class RenameProviderImpl {
+    constructor(languageServiceManager, configManager) {
+        this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
+        this.ts = languageServiceManager.docContext.ts;
+    }
+    async prepareRename(document, position) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const offset = tsDoc.offsetAt(tsDoc.getGeneratedPosition(position));
+        // If our TSX isn't valid, we can't rename safely, so let's abort
+        if (tsDoc.isInErrorState) {
+            return null;
+        }
+        // TODO: Allow renaming of import paths
+        // This requires a bit of work, because we need to create files for the new import paths
+        const renameInfo = lang.getRenameInfo(tsDoc.filePath, offset, { allowRenameOfImportPath: false });
+        if (!renameInfo.canRename) {
+            return null;
+        }
+        return (0, documents_1.mapRangeToOriginal)(tsDoc, (0, utils_2.convertRange)(tsDoc, renameInfo.triggerSpan));
+    }
+    async rename(document, position, newName) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const offset = tsDoc.offsetAt(tsDoc.getGeneratedPosition(position));
+        const { providePrefixAndSuffixTextForRename } = await this.configManager.getTSPreferences(document);
+        let renames = lang.findRenameLocations(tsDoc.filePath, offset, false, false, providePrefixAndSuffixTextForRename);
+        if (!renames) {
+            return null;
+        }
+        const docs = new utils_3.SnapshotMap(this.languageServiceManager);
+        docs.set(tsDoc.filePath, tsDoc);
+        const mappedRenames = await Promise.all(renames.map(async (rename) => {
+            const snapshot = await docs.retrieve(rename.fileName);
+            return {
+                ...rename,
+                range: (0, documents_1.mapRangeToOriginal)(snapshot, (0, utils_2.convertRange)(snapshot, rename.textSpan)),
+                newName,
+            };
+        }));
+        return mappedRenames.reduce((acc, loc) => {
+            const uri = (0, utils_1.pathToUrl)(loc.fileName);
+            if (!acc.changes[uri]) {
+                acc.changes[uri] = [];
+            }
+            acc.changes[uri].push({
+                newText: (loc.prefixText || '') + (loc.newName || newName) + (loc.suffixText || ''),
+                range: loc.range,
+            });
+            return acc;
+        }, { changes: {} });
+    }
+}
+exports.RenameProviderImpl = RenameProviderImpl;

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

@@ -1,4 +1,4 @@
-import type { DiagnosticMessage } from '@astrojs/compiler/shared/types';
+import { DiagnosticMessage } from '@astrojs/compiler/types';
 import { EncodedSourceMap, TraceMap } from '@jridgewell/trace-mapping';
 import { Position, TextDocumentContentChangeEvent } from 'vscode-languageserver';
 import { AstroDocument, DocumentMapper, FragmentMapper, IdentityMapper, SourceMapDocumentMapper, TagInformation } from '../../../core/documents';
@@ -28,6 +28,7 @@ export declare class AstroSnapshot implements DocumentSnapshot {
     scriptTagSnapshots: ScriptTagDocumentSnapshot[];
     version: number;
     constructor(parent: AstroDocument, text: string, tsxMap: EncodedSourceMap, scriptKind: ts.ScriptKind, compilerDiagnostics: DiagnosticMessage[]);
+    get isInErrorState(): boolean;
     isInGenerated(pos: Position): boolean;
     getURL(): string;
     get filePath(): string;

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

@@ -19,6 +19,9 @@ class AstroSnapshot {
         this.scriptTagSnapshots = [];
         this.version = this.parent.version;
     }
+    get isInErrorState() {
+        return this.compilerDiagnostics.filter((diag) => diag.severity === vscode_languageserver_1.DiagnosticSeverity.Error).length > 0;
+    }
     isInGenerated(pos) {
         throw new Error('Method not implemented.');
     }

package/dist/server.js

@@ -105,7 +105,7 @@ function startLanguageServer(connection, env) {
                 typeDefinitionProvider: true,
                 referencesProvider: true,
                 implementationProvider: true,
-                renameProvider: true,
+                renameProvider: params.capabilities.textDocument?.rename?.prepareSupport ? { prepareProvider: true } : true,
                 documentFormattingProvider: true,
                 codeActionProvider: {
                     codeActionKinds: [
@@ -225,6 +225,7 @@ function startLanguageServer(connection, env) {
     connection.onRequest(vscode_languageserver_1.InlayHintRequest.type, (params, cancellationToken) => pluginHost.getInlayHints(params.textDocument, params.range, cancellationToken));
     connection.onRequest(TagCloseRequest, (evt) => pluginHost.doTagComplete(evt.textDocument, evt.position));
     connection.onSignatureHelp((evt, cancellationToken) => pluginHost.getSignatureHelp(evt.textDocument, evt.position, evt.context, cancellationToken));
+    connection.onPrepareRename((evt) => pluginHost.prepareRename(evt.textDocument, evt.position));
     connection.onRenameRequest((evt) => pluginHost.rename(evt.textDocument, evt.position, evt.newName));
     connection.onDidSaveTextDocument(updateAllDiagnostics);
     connection.onNotification('$/onDidChangeNonAstroFile', async (e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.29.3",
+  "version": "0.29.5",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",
@@ -21,7 +21,7 @@
     "prettier": "^2.7.1",
     "prettier-plugin-astro": "^0.7.0",
     "synckit": "^0.8.4",
-    "vscode-css-languageservice": "^6.0.1",
+    "vscode-css-languageservice": "^6.2.1",
     "vscode-html-languageservice": "^5.0.0",
     "vscode-languageserver": "^8.0.1",
     "vscode-languageserver-protocol": "^3.17.1",