@astrojs/language-server 0.27.0 → 0.28.0

package/dist/plugins/PluginHost.d.ts

@@ -33,8 +33,8 @@ export declare class PluginHost {
     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

@@ -151,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

@@ -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/interfaces.d.ts

@@ -88,10 +88,10 @@ 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 & 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;

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

@@ -41,8 +41,12 @@ export declare class TypeScriptPlugin implements Plugin {
     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

@@ -132,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) {
@@ -142,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);
@@ -156,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/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

@@ -186,14 +186,14 @@ 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
@@ -230,7 +230,7 @@ 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();
     });
@@ -242,12 +242,12 @@ function startLanguageServer(connection, env) {
         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.27.0",
+  "version": "0.28.0",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",