@astrojs/language-server 0.11.0 → 0.13.0

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -24,56 +24,69 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptPlugin = void 0;
-const path_1 = require("path");
-const typescript_1 = require("typescript");
+const typescript_1 = __importStar(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
-const ts = __importStar(require("typescript"));
-const LanguageServiceManager_1 = require("./LanguageServiceManager");
-const utils_1 = require("./utils");
-const utils_2 = require("../../utils");
+const path_1 = require("path");
+const utils_1 = require("../../utils");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
-const HoverProvider_1 = require("./features/HoverProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
-const utils_3 = require("./features/utils");
+const HoverProvider_1 = require("./features/HoverProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
+const utils_2 = require("./features/utils");
+const LanguageServiceManager_1 = require("./LanguageServiceManager");
+const utils_3 = require("./utils");
+const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
-        this.pluginName = 'TypeScript';
-        this.docManager = docManager;
+        this.__name = 'typescript';
         this.configManager = configManager;
-        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, configManager, workspaceUris);
+        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(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);
     }
     async doHover(document, position) {
+        if (!this.featureEnabled('hover')) {
+            return null;
+        }
         return this.hoverProvider.doHover(document, position);
     }
     async rename(document, position, newName) {
-        const { lang, tsDoc } = await this.languageServiceManager.getTypeScriptDoc(document);
-        const fragment = await tsDoc.getFragment();
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const fragment = await tsDoc.createFragment();
         const offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
-        let renames = lang.findRenameLocations((0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
+        let renames = lang.findRenameLocations((0, utils_3.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
         if (!renames) {
             return null;
         }
         let edit = {
-            changes: {}
+            changes: {},
         };
-        renames.forEach(rename => {
-            const filePath = (0, utils_1.ensureRealAstroFilePath)(rename.fileName);
+        renames.forEach((rename) => {
+            const filePath = (0, utils_3.ensureRealFilePath)(rename.fileName);
             if (!(filePath in edit.changes)) {
                 edit.changes[filePath] = [];
             }
             edit.changes[filePath].push({
                 newText: newName,
-                range: (0, utils_1.convertToLocationRange)(fragment, rename.textSpan)
+                range: (0, utils_3.convertToLocationRange)(fragment, rename.textSpan),
             });
         });
         return edit;
     }
+    async getDocumentSymbols(document) {
+        if (!this.featureEnabled('documentSymbols')) {
+            return [];
+        }
+        const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
+        return symbols;
+    }
     async getCompletions(document, position, completionContext) {
+        if (!this.featureEnabled('completions')) {
+            return null;
+        }
         const completions = await this.completionProvider.getCompletions(document, position, completionContext);
         return completions;
     }
@@ -81,10 +94,10 @@ class TypeScriptPlugin {
         return this.completionProvider.resolveCompletion(document, completionItem);
     }
     async getDefinitions(document, position) {
-        const { lang, tsDoc } = await this.languageServiceManager.getTypeScriptDoc(document);
-        const mainFragment = await tsDoc.getFragment();
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
         const filePath = tsDoc.filePath;
-        const tsFilePath = (0, utils_1.toVirtualAstroFilePath)(filePath);
+        const tsFilePath = (0, utils_3.toVirtualAstroFilePath)(filePath);
         const fragmentPosition = mainFragment.getGeneratedPosition(position);
         const fragmentOffset = mainFragment.offsetAt(fragmentPosition);
         let defs = lang.getDefinitionAndBoundSpan(tsFilePath, fragmentOffset);
@@ -98,17 +111,16 @@ class TypeScriptPlugin {
                 defs = importDef;
             }
         }
-        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        const docs = new utils_2.SnapshotFragmentMap(this.languageServiceManager);
         docs.set(tsDoc.filePath, { fragment: mainFragment, snapshot: tsDoc });
         const result = await Promise.all(defs.definitions.map(async (def) => {
             const { fragment, snapshot } = await docs.retrieve(def.fileName);
-            if ((0, utils_3.isNoTextSpanInGeneratedCode)(snapshot.getFullText(), def.textSpan)) {
-                const fileName = (0, utils_1.ensureRealFilePath)(def.fileName);
-                const textSpan = (0, utils_1.isVirtualFilePath)(tsFilePath) ? { start: 0, length: 0 } : def.textSpan;
-                return vscode_languageserver_1.LocationLink.create((0, utils_2.pathToUrl)(fileName), (0, utils_1.convertToLocationRange)(fragment, textSpan), (0, utils_1.convertToLocationRange)(fragment, textSpan), (0, utils_1.convertToLocationRange)(mainFragment, defs.textSpan));
-            }
+            const fileName = (0, utils_3.ensureRealFilePath)(def.fileName);
+            // Since we converted our files to TSX and we don't have sourcemaps, we don't know where the function is, unfortunate
+            const textSpan = (0, utils_3.isVirtualFilePath)(tsFilePath) ? { start: 0, length: 0 } : def.textSpan;
+            return vscode_languageserver_1.LocationLink.create((0, utils_1.pathToUrl)(fileName), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(mainFragment, defs.textSpan));
         }));
-        return result.filter(utils_2.isNotNullOrUndefined);
+        return result.filter(utils_1.isNotNullOrUndefined);
     }
     async getDiagnostics(document, cancellationToken) {
         if (!this.featureEnabled('diagnostics')) {
@@ -116,38 +128,31 @@ class TypeScriptPlugin {
         }
         return this.diagnosticsProvider.getDiagnostics(document, cancellationToken);
     }
-    async onWatchFileChanges(onWatchFileChangesParams) {
-        const doneUpdateProjectFiles = new Set();
-        for (const { fileName, changeType } of onWatchFileChangesParams) {
-            const scriptKind = (0, utils_1.getScriptKindFromFileName)(fileName);
-            if (scriptKind === ts.ScriptKind.Unknown) {
-                // We don't deal with svelte files here
+    async onWatchFileChanges(onWatchFileChangesParas) {
+        let doneUpdateProjectFiles = false;
+        for (const { fileName, changeType } of onWatchFileChangesParas) {
+            const scriptKind = (0, utils_3.getScriptKindFromFileName)(fileName);
+            if (scriptKind === typescript_1.default.ScriptKind.Unknown) {
                 continue;
             }
-            const snapshotManager = await this.getSnapshotManager(fileName);
-            if (changeType === vscode_languageserver_1.FileChangeType.Created) {
-                if (!doneUpdateProjectFiles.has(snapshotManager)) {
-                    snapshotManager.updateProjectFiles();
-                    doneUpdateProjectFiles.add(snapshotManager);
-                }
+            if (changeType === vscode_languageserver_1.FileChangeType.Created && !doneUpdateProjectFiles) {
+                doneUpdateProjectFiles = true;
+                await this.languageServiceManager.updateProjectFiles();
             }
             else if (changeType === vscode_languageserver_1.FileChangeType.Deleted) {
-                snapshotManager.delete(fileName);
-                return;
+                await this.languageServiceManager.deleteSnapshot(fileName);
+            }
+            else {
+                await this.languageServiceManager.updateExistingNonAstroFile(fileName);
             }
-            snapshotManager.updateProjectFile(fileName);
         }
     }
+    async updateNonAstroFile(fileName, changes) {
+        await this.languageServiceManager.updateExistingNonAstroFile(fileName, changes);
+    }
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
     }
-    /**
-     *
-     * @internal
-     */
-    async getSnapshotManager(fileName) {
-        return this.languageServiceManager.getSnapshotManager(fileName);
-    }
     goToDefinitionFoundOnlyAlias(tsFileName, defs) {
         return !!(defs.length === 1 && defs[0].kind === 'alias' && defs[0].fileName === tsFileName);
     }
@@ -155,11 +160,11 @@ class TypeScriptPlugin {
         const program = lang.getProgram();
         const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(tsFilePath);
         if (sourceFile) {
-            let node = ts.getTouchingPropertyName(sourceFile, offset);
+            let node = typescript_1.default.getTouchingPropertyName(sourceFile, offset);
             if (node && node.kind === typescript_1.SyntaxKind.Identifier) {
                 if (node.parent.kind === typescript_1.SyntaxKind.ImportClause) {
                     let decl = node.parent.parent;
-                    let spec = ts.isStringLiteral(decl.moduleSpecifier) && decl.moduleSpecifier.text;
+                    let spec = typescript_1.default.isStringLiteral(decl.moduleSpecifier) && decl.moduleSpecifier.text;
                     if (spec) {
                         let fileName = (0, path_1.join)((0, path_1.dirname)(tsFilePath), spec);
                         let start = node.pos + 1;
@@ -188,10 +193,8 @@ class TypeScriptPlugin {
             }
         }
     }
-    // This exists so we can make features toggleable in the future.
     featureEnabled(feature) {
-        return (this.configManager.enabled('typescript.enable') &&
-            this.configManager.enabled(`typescript.${feature}.enable`));
+        return (this.configManager.enabled('typescript.enabled') && this.configManager.enabled(`typescript.${feature}.enabled`));
     }
 }
 exports.TypeScriptPlugin = TypeScriptPlugin;

package/dist/plugins/typescript/astro-sys.d.ts

@@ -1,6 +1,8 @@
-import * as ts from 'typescript';
-import { DocumentSnapshot } from './DocumentSnapshot';
+import ts from 'typescript';
+import { DocumentSnapshot } from './snapshots/DocumentSnapshot';
 /**
  * This should only be accessed by TS Astro module resolution.
  */
-export declare function createAstroSys(getSnapshot: (fileName: string) => DocumentSnapshot): ts.System;
+export declare function createAstroSys(getSnapshot: (fileName: string) => DocumentSnapshot): ts.System & {
+    deleteFromCache: (path: string) => void;
+};

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

@@ -1,69 +1,48 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAstroSys = void 0;
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const utils_1 = require("./utils");
-const ignoredDirectories = [
-    "node_modules/@types/react"
-];
-const ignoredDirectoriesExp = new RegExp("(" + ignoredDirectories.map(n => n + "$").join("|") + ")");
 /**
  * This should only be accessed by TS Astro module resolution.
  */
 function createAstroSys(getSnapshot) {
+    const fileExistsCache = new Map();
     const AstroSys = {
-        ...ts.sys,
+        ...typescript_1.default.sys,
         fileExists(path) {
-            let doesExist = ts.sys.fileExists((0, utils_1.ensureRealAstroFilePath)(path));
-            return doesExist;
-        },
-        directoryExists(path) {
-            if (ignoredDirectoriesExp.test(path)) {
-                return false;
-            }
-            return ts.sys.directoryExists(path);
+            var _a;
+            path = (0, utils_1.ensureRealFilePath)(path);
+            const exists = (_a = fileExistsCache.get(path)) !== null && _a !== void 0 ? _a : typescript_1.default.sys.fileExists(path);
+            fileExistsCache.set(path, exists);
+            return exists;
         },
         readFile(path) {
-            if ((0, utils_1.isAstroFilePath)(path) || (0, utils_1.isVirtualAstroFilePath)(path)) {
-                console.log('readFile', path);
-            }
             const snapshot = getSnapshot(path);
-            return snapshot.getFullText();
+            return snapshot.getText(0, snapshot.getLength());
         },
         readDirectory(path, extensions, exclude, include, depth) {
             const extensionsWithAstro = (extensions !== null && extensions !== void 0 ? extensions : []).concat(...['.astro', '.svelte', '.vue']);
-            const result = ts.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
+            const result = typescript_1.default.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
             return result;
         },
+        deleteFile(path) {
+            var _a, _b;
+            fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));
+            return (_b = (_a = typescript_1.default.sys).deleteFile) === null || _b === void 0 ? void 0 : _b.call(_a, path);
+        },
+        deleteFromCache(path) {
+            fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));
+        },
     };
-    if (ts.sys.realpath) {
-        const realpath = ts.sys.realpath;
+    if (typescript_1.default.sys.realpath) {
+        const realpath = typescript_1.default.sys.realpath;
         AstroSys.realpath = function (path) {
-            if ((0, utils_1.isVirtualAstroFilePath)(path)) {
-                return realpath((0, utils_1.toRealAstroFilePath)(path)) + '.ts';
+            if ((0, utils_1.isVirtualFilePath)(path)) {
+                return realpath((0, utils_1.ensureRealFilePath)(path)) + '.tsx';
             }
             return realpath(path);
         };

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

@@ -1,16 +1,16 @@
 import type { CompletionContext, Position, TextDocumentIdentifier } from 'vscode-languageserver';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
-import { Document } from '../../../core/documents';
-import * as ts from 'typescript';
+import { AstroDocument } from '../../../core/documents';
+import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
 export interface CompletionEntryWithIdentifer extends ts.CompletionEntry, TextDocumentIdentifier {
     position: Position;
 }
 export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionEntryWithIdentifer> {
-    private lang;
-    constructor(lang: LanguageServiceManager);
-    getCompletions(document: Document, position: Position, _completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
-    resolveCompletion(document: Document, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getCompletions(document: AstroDocument, position: Position, _completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
+    resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
     private toCompletionItem;
     private getCompletionDocument;
 }

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

@@ -1,55 +1,33 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompletionsProviderImpl = void 0;
 const utils_1 = require("../../../core/documents/utils");
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_2 = require("../utils");
 const completionOptions = Object.freeze({
     importModuleSpecifierPreference: 'relative',
-    importModuleSpecifierEnding: 'js',
+    importModuleSpecifierEnding: 'auto',
     quotePreference: 'single',
 });
 class CompletionsProviderImpl {
-    constructor(lang) {
-        this.lang = lang;
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
     }
     async getCompletions(document, position, _completionContext) {
         var _a;
-        // TODO: handle inside expression
+        // TODO: handle inside expression and script tags
         if (!(0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
             return null;
         }
-        const filePath = document.getFilePath();
-        if (!filePath)
-            throw new Error();
-        const { tsDoc, lang } = await this.lang.getTypeScriptDoc(document);
-        const fragment = await tsDoc.getFragment();
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragment = await tsDoc.createFragment();
         const offset = document.offsetAt(position);
-        const entries = ((_a = lang.getCompletionsAtPosition(fragment.filePath, offset, completionOptions)) === null || _a === void 0 ? void 0 : _a.entries) || [];
+        const entries = ((_a = lang.getCompletionsAtPosition(filePath, offset, completionOptions)) === null || _a === void 0 ? void 0 : _a.entries) || [];
         const completionItems = entries
             .map((entry) => this.toCompletionItem(fragment, entry, document.uri, position, new Set()))
             .filter((i) => i);
@@ -57,12 +35,12 @@ class CompletionsProviderImpl {
     }
     async resolveCompletion(document, completionItem) {
         const { data: comp } = completionItem;
-        const { tsDoc, lang } = await this.lang.getTypeScriptDoc(document);
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         let filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
         if (!comp || !filePath) {
             return completionItem;
         }
-        const fragment = await tsDoc.getFragment();
+        const fragment = await tsDoc.createFragment();
         const detail = lang.getCompletionEntryDetails(filePath, // fileName
         fragment.offsetAt(comp.position), // position
         comp.name, // entryName
@@ -97,12 +75,14 @@ class CompletionsProviderImpl {
     }
     getCompletionDocument(compDetail) {
         const { source, documentation: tsDocumentation, displayParts, tags } = compDetail;
-        let detail = ts.displayPartsToString(displayParts);
+        let detail = typescript_1.default.displayPartsToString(displayParts);
         if (source) {
-            const importPath = ts.displayPartsToString(source);
+            const importPath = typescript_1.default.displayPartsToString(source);
             detail = `Auto import from ${importPath}\n${detail}`;
         }
-        const documentation = tsDocumentation ? { value: tsDocumentation.join('\n'), kind: vscode_languageserver_1.MarkupKind.Markdown } : undefined;
+        const documentation = tsDocumentation
+            ? { value: tsDocumentation.join('\n'), kind: vscode_languageserver_1.MarkupKind.Markdown }
+            : undefined;
         return {
             documentation,
             detail,

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

@@ -1,11 +1,11 @@
-import { CancellationToken, Diagnostic } from 'vscode-languageserver';
-import { Document } from '../../../core/documents';
+import { CancellationToken } from 'vscode-languageserver';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { AstroDocument } from '../../../core/documents';
 import { DiagnosticsProvider } from '../../interfaces';
 import { LanguageServiceManager } from '../LanguageServiceManager';
 export declare class DiagnosticsProviderImpl implements DiagnosticsProvider {
     private readonly languageServiceManager;
     constructor(languageServiceManager: LanguageServiceManager);
-    getDiagnostics(document: Document, _cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
-    private getLSAndTSDoc;
+    getDiagnostics(document: AstroDocument, _cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
     private getTagBoundaries;
 }

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

@@ -5,66 +5,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiagnosticsProviderImpl = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const vscode_languageserver_1 = require("vscode-languageserver");
+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");
 class DiagnosticsProviderImpl {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
     }
     async getDiagnostics(document, _cancellationToken) {
-        var _a, _b, _c, _d, _e;
-        if ((((_a = document.getFilePath()) === null || _a === void 0 ? void 0 : _a.includes('/node_modules/')) ||
-            ((_b = document.getFilePath()) === null || _b === void 0 ? void 0 : _b.includes('\\node_modules\\'))) &&
-            // Sapper convention: Put stuff inside node_modules below src
-            !(((_c = document.getFilePath()) === null || _c === void 0 ? void 0 : _c.includes('/src/node_modules/')) ||
-                ((_d = document.getFilePath()) === null || _d === void 0 ? void 0 : _d.includes('\\src\\node_modules\\')))) {
-            // Don't return diagnostics for files inside node_modules. These are considered read-only (cannot be changed)
-            // and in case of svelte-check they would pollute/skew the output
+        var _a, _b, _c;
+        // Don't return diagnostics for files inside node_modules. These are considered read-only
+        // and they would pollute the output for astro check
+        if (((_a = document.getFilePath()) === null || _a === void 0 ? void 0 : _a.includes('/node_modules/')) || ((_b = document.getFilePath()) === null || _b === void 0 ? void 0 : _b.includes('\\node_modules\\'))) {
             return [];
         }
-        const { lang, tsDoc } = await this.getLSAndTSDoc(document);
-        const isTypescript = tsDoc.scriptKind === typescript_1.default.ScriptKind.TSX;
-        // Document preprocessing failed, show parser error instead
-        if (tsDoc.parserError) {
-            return [
-                {
-                    range: tsDoc.parserError.range,
-                    severity: vscode_languageserver_1.DiagnosticSeverity.Error,
-                    source: isTypescript ? 'ts' : 'js',
-                    message: tsDoc.parserError.message,
-                    code: tsDoc.parserError.code
-                }
-            ];
-        }
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
         const { script: scriptBoundaries, markdown: markdownBoundaries } = this.getTagBoundaries(lang, filePath);
         const syntaxDiagnostics = lang.getSyntacticDiagnostics(filePath);
         const suggestionDiagnostics = lang.getSuggestionDiagnostics(filePath);
-        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter(d => {
-            return (isNoWithinScript(scriptBoundaries, d));
+        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter((d) => {
+            return isNoWithinScript(scriptBoundaries, d);
         });
-        const diagnostics = [
-            ...syntaxDiagnostics,
-            ...suggestionDiagnostics,
-            ...semanticDiagnostics
-        ];
-        const fragment = await tsDoc.getFragment();
-        const sourceFile = (_e = lang.getProgram()) === null || _e === void 0 ? void 0 : _e.getSourceFile(filePath);
+        const diagnostics = [...syntaxDiagnostics, ...suggestionDiagnostics, ...semanticDiagnostics];
+        const fragment = await tsDoc.createFragment();
+        const sourceFile = (_c = lang.getProgram()) === null || _c === void 0 ? void 0 : _c.getSourceFile(filePath);
         const isNoFalsePositiveInst = isNoFalsePositive();
         return diagnostics
-            .filter(isNotGenerated(tsDoc.getText(0, tsDoc.getLength())))
             .map((diagnostic) => ({
             range: (0, utils_1.convertRange)(tsDoc, diagnostic),
             severity: (0, utils_1.mapSeverity)(diagnostic.category),
-            source: isTypescript ? 'ts' : 'js',
+            source: 'ts',
             message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
             code: diagnostic.code,
-            tags: getDiagnosticTag(diagnostic)
+            tags: getDiagnosticTag(diagnostic),
         }))
             .map(mapRange(fragment, document))
-            .filter(diag => {
+            .filter((diag) => {
             return (hasNoNegativeLines(diag) &&
                 isNoFalsePositiveInst(diag) &&
                 isNoJSXImplicitRuntimeWarning(diag) &&
@@ -77,21 +54,18 @@ class DiagnosticsProviderImpl {
         })
             .map(enhanceIfNecessary);
     }
-    async getLSAndTSDoc(document) {
-        return this.languageServiceManager.getTypeScriptDoc(document);
-    }
     getTagBoundaries(lang, tsFilePath) {
         const program = lang.getProgram();
         const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(tsFilePath);
         const boundaries = {
             script: [],
-            markdown: []
+            markdown: [],
         };
         if (!sourceFile) {
             return boundaries;
         }
         function findScript(parent) {
-            typescript_1.default.forEachChild(parent, node => {
+            typescript_1.default.forEachChild(parent, (node) => {
                 if (typescript_1.default.isJsxElement(node)) {
                     let tagName = node.openingElement.tagName.getText();
                     switch (tagName) {
@@ -117,10 +91,10 @@ exports.DiagnosticsProviderImpl = DiagnosticsProviderImpl;
 function getDiagnosticTag(diagnostic) {
     const tags = [];
     if (diagnostic.reportsUnnecessary) {
-        tags.push(vscode_languageserver_1.DiagnosticTag.Unnecessary);
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Unnecessary);
     }
     if (diagnostic.reportsDeprecated) {
-        tags.push(vscode_languageserver_1.DiagnosticTag.Deprecated);
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Deprecated);
     }
     return tags;
 }
@@ -144,7 +118,7 @@ function hasNoNegativeLines(diagnostic) {
 }
 function isNoFalsePositive() {
     return (diagnostic) => {
-        return (isNoJsxCannotHaveMultipleAttrsError(diagnostic));
+        return isNoJsxCannotHaveMultipleAttrsError(diagnostic);
     };
 }
 /**
@@ -214,48 +188,14 @@ function isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, boundaries, diagnostic
  * Some diagnostics have JSX-specific nomenclature. Enhance them for more clarity.
  */
 function enhanceIfNecessary(diagnostic) {
-    if (diagnostic.code === 2786) {
-        return {
-            ...diagnostic,
-            message: 'Type definitions are missing for this Svelte Component. ' +
-                // eslint-disable-next-line max-len
-                "It needs a class definition with at least the property '$$prop_def' which should contain a map of input property definitions.\n" +
-                'Example:\n' +
-                '  class ComponentName { $$prop_def: { propertyName: string; } }\n' +
-                'If you are using Svelte 3.31+, use SvelteComponentTyped:\n' +
-                '  import type { SvelteComponentTyped } from "svelte";\n' +
-                '  class ComponentName extends SvelteComponentTyped<{propertyName: string;}> {}\n\n' +
-                'Underlying error:\n' +
-                diagnostic.message
-        };
-    }
-    if (diagnostic.code === 2607) {
-        return {
-            ...diagnostic,
-            message: 'Element does not support attributes because ' +
-                'type definitions are missing for this Svelte Component or element cannot be used as such.\n\n' +
-                'Underlying error:\n' +
-                diagnostic.message
-        };
-    }
-    if (diagnostic.code === 1184) {
-        return {
-            ...diagnostic,
-            message: diagnostic.message +
-                '\nIf this is a declare statement, move it into <script context="module">..</script>'
-        };
+    if (diagnostic.code === 2322) {
+        // For the rare case where an user might try to put a client directive on something that is not a component
+        if (diagnostic.message.includes("Property 'client:") && diagnostic.message.includes("to type 'HTMLProps")) {
+            return {
+                ...diagnostic,
+                message: 'Client directives are only available on framework components',
+            };
+        }
     }
     return diagnostic;
 }
-/**
- * Checks if diagnostic is not within a section that should be completely ignored
- * because it's purely generated.
- */
-function isNotGenerated(text) {
-    return (diagnostic) => {
-        if (diagnostic.start === undefined || diagnostic.length === undefined) {
-            return true;
-        }
-        return !(0, utils_2.isInGeneratedCode)(text, diagnostic.start, diagnostic.start + diagnostic.length);
-    };
-}