@astrojs/language-server 0.29.3 → 0.29.4

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.js

@@ -31,8 +31,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 = [];

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.4",
   "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",