@astrojs/language-server 0.9.3 → 0.12.1

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

@@ -1,33 +1,26 @@
-import type { ConfigManager } from '../../core/config';
-import type { CompletionsProvider, AppCompletionItem, AppCompletionList } from '../interfaces';
-import type { CancellationToken, Diagnostic, Hover, SignatureHelp, SignatureHelpContext, WorkspaceEdit } from 'vscode-languageserver';
-import { Document, DocumentManager } from '../../core/documents';
-import { CompletionContext, DefinitionLink, Position } from 'vscode-languageserver';
-import { SnapshotManager } from './SnapshotManager';
+import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { ConfigManager } from '../../core/config';
+import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
 import { CompletionEntryWithIdentifer } from './features/CompletionsProvider';
-export declare class TypeScriptPlugin implements CompletionsProvider {
-    private readonly docManager;
-    private readonly configManager;
+export declare class TypeScriptPlugin implements Plugin {
+    __name: string;
+    private configManager;
     private readonly languageServiceManager;
-    pluginName: string;
     private readonly completionProvider;
     private readonly hoverProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
-    doHover(document: Document, position: Position): Promise<Hover | null>;
-    rename(document: Document, position: Position, newName: string): Promise<WorkspaceEdit | null>;
-    getCompletions(document: Document, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
-    resolveCompletion(document: Document, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
-    getDefinitions(document: Document, position: Position): Promise<DefinitionLink[]>;
-    getDiagnostics(document: Document, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
-    onWatchFileChanges(onWatchFileChangesParams: any[]): Promise<void>;
-    getSignatureHelp(document: Document, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
-    /**
-     *
-     * @internal
-     */
-    getSnapshotManager(fileName: string): Promise<SnapshotManager>;
+    doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
+    rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
+    resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
+    getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
+    getDiagnostics(document: AstroDocument, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
+    onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): Promise<void>;
+    getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
     private goToDefinitionFoundOnlyAlias;
     private getGoToDefinitionRefsForImportSpecifier;
     private featureEnabled;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -20,24 +24,22 @@ 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");
 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);
@@ -47,24 +49,24 @@ class TypeScriptPlugin {
         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;
@@ -77,10 +79,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);
@@ -94,17 +96,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.ensureRealAstroFilePath)(def.fileName);
-                const textSpan = (0, utils_1.isVirtualAstroFilePath)(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')) {
@@ -112,38 +113,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);
     }
@@ -151,11 +145,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;
@@ -184,10 +178,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,65 +1,48 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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,37 +1,21 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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;
@@ -39,13 +23,11 @@ class CompletionsProviderImpl {
         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);
@@ -53,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
@@ -93,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;
 }