@astrojs/language-server 0.9.2 → 0.12.0

package/dist/plugins/html/HTMLPlugin.js

@@ -1,81 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTMLPlugin = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
 const emmet_helper_1 = require("@vscode/emmet-helper");
 const vscode_html_languageservice_1 = require("vscode-html-languageservice");
-const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_1 = require("../../core/documents/utils");
 class HTMLPlugin {
-    constructor(docManager, configManager) {
+    constructor(configManager) {
+        this.__name = 'html';
         this.lang = (0, vscode_html_languageservice_1.getLanguageService)();
-        this.documents = new WeakMap();
-        this.styleScriptTemplate = new Set(['template', 'style', 'script']);
-        this.pluginName = 'HTML';
-        docManager.on('documentChange', (document) => {
-            this.documents.set(document, document.html);
-        });
+        this.styleScriptTemplate = new Set(['style']);
         this.configManager = configManager;
     }
+    /**
+     * Get HTML completions
+     */
     getCompletions(document, position) {
-        const html = this.documents.get(document);
-        if (!html) {
+        if (!this.featureEnabled('completions')) {
             return null;
         }
-        if (this.isInsideFrontmatter(document, position) || this.isInsideExpression(html, document, position)) {
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        if (!html ||
+            (0, utils_1.isInsideFrontmatter)(document.getText(), offset) ||
+            (0, utils_1.isInsideExpression)(document.getText(), html.findNodeAt(offset).start, offset)) {
             return null;
         }
+        // Get Emmet completions
         let emmetResults = {
             isIncomplete: true,
             items: [],
         };
         this.lang.setCompletionParticipants([
             {
-                onHtmlContent: () => (emmetResults = (0, emmet_helper_1.doComplete)(document, position, 'html', this.configManager.getEmmetConfig()) || emmetResults),
+                onHtmlContent: () => (emmetResults =
+                    (0, emmet_helper_1.doComplete)(document, position, 'html', this.configManager.getEmmetConfig()) || emmetResults),
             },
         ]);
-        // For components, we only want Emmet completions inside the component (aka slots) because HTML properties are not necessarily valid for a component
-        const results = (0, utils_1.isInComponentStartTag)(html, document.offsetAt(position)) ? vscode_languageserver_1.CompletionList.create([]) : this.lang.doComplete(document, position, html);
-        const items = this.toCompletionItems(results.items);
-        return vscode_languageserver_1.CompletionList.create([...this.toCompletionItems(items), ...this.getLangCompletions(items), ...emmetResults.items], 
+        // If we're in a component starting tag, we do not want HTML language completions
+        // as HTML attributes are not valid for components
+        const results = (0, utils_1.isInComponentStartTag)(html, document.offsetAt(position))
+            ? vscode_languageserver_1.CompletionList.create([])
+            : this.lang.doComplete(document, position, html);
+        return vscode_languageserver_1.CompletionList.create([...results.items, ...this.getLangCompletions(results.items), ...emmetResults.items], 
         // Emmet completions change on every keystroke, so they are never complete
         emmetResults.items.length > 0);
     }
     getFoldingRanges(document) {
-        const html = this.documents.get(document);
+        const html = document.html;
         if (!html) {
             return null;
         }
         return this.lang.getFoldingRanges(document);
     }
     doTagComplete(document, position) {
-        const html = this.documents.get(document);
-        if (!html) {
+        if (!this.featureEnabled('tagComplete')) {
             return null;
         }
-        if (this.isInsideFrontmatter(document, position) || this.isInsideExpression(html, document, position)) {
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        if (!html ||
+            (0, utils_1.isInsideFrontmatter)(document.getText(), offset) ||
+            (0, utils_1.isInsideExpression)(document.getText(), html.findNodeAt(offset).start, offset)) {
             return null;
         }
         return this.lang.doTagComplete(document, position, html);
     }
     /**
-     * The HTML language service uses newer types which clash
-     * without the stable ones. Transform to the stable types.
+     * Get lang completions for style tags (ex: `<style lang="scss">`)
      */
-    toCompletionItems(items) {
-        return items.map((item) => {
-            if (!item.textEdit || vscode_languageserver_1.TextEdit.is(item.textEdit)) {
-                return item;
-            }
-            return {
-                ...item,
-                textEdit: vscode_languageserver_1.TextEdit.replace(item.textEdit.replace, item.textEdit.newText),
-            };
-        });
-    }
     getLangCompletions(completions) {
         const styleScriptTemplateCompletions = completions.filter((completion) => completion.kind === vscode_languageserver_1.CompletionItemKind.Property && this.styleScriptTemplate.has(completion.label));
         const langCompletions = [];
-        addLangCompletion('style', ['scss', 'sass']);
+        addLangCompletion('style', ['scss', 'sass', 'less', 'styl', 'stylus']);
         return langCompletions;
         /** Add language completions */
         function addLangCompletion(tag, languages) {
@@ -96,13 +93,8 @@ class HTMLPlugin {
             }));
         }
     }
-    isInsideExpression(html, document, position) {
-        const offset = document.offsetAt(position);
-        const node = html.findNodeAt(offset);
-        return (0, utils_1.isInsideExpression)(document.getText(), node.start, offset);
-    }
-    isInsideFrontmatter(document, position) {
-        return (0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position));
+    featureEnabled(feature) {
+        return this.configManager.enabled('html.enabled') && this.configManager.enabled(`html.${feature}.enabled`);
     }
 }
 exports.HTMLPlugin = HTMLPlugin;

package/dist/plugins/index.d.ts

@@ -1,6 +1,6 @@
 export * from './PluginHost';
-export * from './astro/AstroPlugin';
 export * from './html/HTMLPlugin';
+export * from './css/CSSPlugin';
 export * from './typescript/TypeScriptPlugin';
+export * from './astro/AstroPlugin';
 export * from './interfaces';
-export * from './css/CSSPlugin';

package/dist/plugins/index.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];
@@ -11,8 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./PluginHost"), exports);
-__exportStar(require("./astro/AstroPlugin"), exports);
 __exportStar(require("./html/HTMLPlugin"), exports);
+__exportStar(require("./css/CSSPlugin"), exports);
 __exportStar(require("./typescript/TypeScriptPlugin"), exports);
+__exportStar(require("./astro/AstroPlugin"), exports);
 __exportStar(require("./interfaces"), exports);
-__exportStar(require("./css/CSSPlugin"), exports);

package/dist/plugins/interfaces.d.ts

@@ -1,6 +1,5 @@
-import { CompletionContext, FileChangeType, LinkedEditingRanges, SemanticTokens, SignatureHelpContext, TextDocumentContentChangeEvent } from 'vscode-languageserver';
-import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FormattingOptions, Hover, Location, Position, Range, ReferenceContext, SymbolInformation, TextDocumentIdentifier, TextEdit, WorkspaceEdit, SelectionRange, SignatureHelp, FoldingRange } from 'vscode-languageserver-types';
-import { Document } from '../core/documents';
+import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
 export declare type Resolvable<T> = T | Promise<T>;
 export interface AppCompletionItem<T extends TextDocumentIdentifier = any> extends CompletionItem {
     data?: T;
@@ -9,42 +8,42 @@ export interface AppCompletionList<T extends TextDocumentIdentifier = any> exten
     items: Array<AppCompletionItem<T>>;
 }
 export interface DiagnosticsProvider {
-    getDiagnostics(document: Document): Resolvable<Diagnostic[]>;
+    getDiagnostics(document: TextDocument): Resolvable<Diagnostic[]>;
 }
 export interface HoverProvider {
-    doHover(document: Document, position: Position): Resolvable<Hover | null>;
+    doHover(document: TextDocument, position: Position): Resolvable<Hover | null>;
 }
 export interface FoldingRangeProvider {
-    getFoldingRanges(document: Document): Resolvable<FoldingRange[] | null>;
+    getFoldingRanges(document: TextDocument): Resolvable<FoldingRange[] | null>;
 }
 export interface CompletionsProvider<T extends TextDocumentIdentifier = any> {
-    getCompletions(document: Document, position: Position, completionContext?: CompletionContext): Resolvable<AppCompletionList<T> | null>;
-    resolveCompletion?(document: Document, completionItem: AppCompletionItem<T>): Resolvable<AppCompletionItem<T>>;
+    getCompletions(document: TextDocument, position: Position, completionContext?: CompletionContext): Resolvable<AppCompletionList<T> | null>;
+    resolveCompletion?(document: TextDocument, completionItem: AppCompletionItem<T>): Resolvable<AppCompletionItem<T>>;
 }
 export interface FormattingProvider {
-    formatDocument(document: Document, options: FormattingOptions): Resolvable<TextEdit[]>;
+    formatDocument(document: TextDocument, options: FormattingOptions): Resolvable<TextEdit[]>;
 }
 export interface TagCompleteProvider {
-    doTagComplete(document: Document, position: Position): Resolvable<string | null>;
+    doTagComplete(document: TextDocument, position: Position): Resolvable<string | null>;
 }
 export interface DocumentColorsProvider {
-    getDocumentColors(document: Document): Resolvable<ColorInformation[]>;
+    getDocumentColors(document: TextDocument): Resolvable<ColorInformation[]>;
 }
 export interface ColorPresentationsProvider {
-    getColorPresentations(document: Document, range: Range, color: Color): Resolvable<ColorPresentation[]>;
+    getColorPresentations(document: TextDocument, range: Range, color: Color): Resolvable<ColorPresentation[]>;
 }
 export interface DocumentSymbolsProvider {
-    getDocumentSymbols(document: Document): Resolvable<SymbolInformation[]>;
+    getDocumentSymbols(document: TextDocument): Resolvable<SymbolInformation[]>;
 }
 export interface DefinitionsProvider {
-    getDefinitions(document: Document, position: Position): Resolvable<DefinitionLink[]>;
+    getDefinitions(document: TextDocument, position: Position): Resolvable<DefinitionLink[]>;
 }
 export interface BackwardsCompatibleDefinitionsProvider {
-    getDefinitions(document: Document, position: Position): Resolvable<DefinitionLink[] | Location[]>;
+    getDefinitions(document: TextDocument, position: Position): Resolvable<DefinitionLink[] | Location[]>;
 }
 export interface CodeActionsProvider {
-    getCodeActions(document: Document, range: Range, context: CodeActionContext): Resolvable<CodeAction[]>;
-    executeCommand?(document: Document, command: string, args?: any[]): Resolvable<WorkspaceEdit | string | null>;
+    getCodeActions(document: TextDocument, range: Range, context: CodeActionContext): Resolvable<CodeAction[]>;
+    executeCommand?(document: TextDocument, command: string, args?: any[]): Resolvable<WorkspaceEdit | string | null>;
 }
 export interface FileRename {
     oldUri: string;
@@ -54,49 +53,37 @@ export interface UpdateImportsProvider {
     updateImports(fileRename: FileRename): Resolvable<WorkspaceEdit | null>;
 }
 export interface RenameProvider {
-    rename(document: Document, position: Position, newName: string): Resolvable<WorkspaceEdit | null>;
-    prepareRename(document: Document, position: Position): Resolvable<Range | null>;
+    rename(document: TextDocument, position: Position, newName: string): Resolvable<WorkspaceEdit | null>;
+    prepareRename(document: TextDocument, position: Position): Resolvable<Range | null>;
 }
 export interface FindReferencesProvider {
-    findReferences(document: Document, position: Position, context: ReferenceContext): Promise<Location[] | null>;
+    findReferences(document: TextDocument, position: Position, context: ReferenceContext): Promise<Location[] | null>;
 }
 export interface SignatureHelpProvider {
-    getSignatureHelp(document: Document, position: Position, context: SignatureHelpContext | undefined): Resolvable<SignatureHelp | null>;
+    getSignatureHelp(document: TextDocument, position: Position, context: SignatureHelpContext | undefined): Resolvable<SignatureHelp | null>;
 }
 export interface SelectionRangeProvider {
-    getSelectionRange(document: Document, position: Position): Resolvable<SelectionRange | null>;
+    getSelectionRange(document: TextDocument, position: Position): Resolvable<SelectionRange | null>;
 }
 export interface SemanticTokensProvider {
-    getSemanticTokens(textDocument: Document, range?: Range): Resolvable<SemanticTokens | null>;
+    getSemanticTokens(textDocument: TextDocument, range?: Range): Resolvable<SemanticTokens | null>;
 }
 export interface LinkedEditingRangesProvider {
-    getLinkedEditingRanges(document: Document, position: Position): Resolvable<LinkedEditingRanges | null>;
+    getLinkedEditingRanges(document: TextDocument, position: Position): Resolvable<LinkedEditingRanges | null>;
 }
-export interface OnWatchFileChangesPara {
+export interface OnWatchFileChangesParam {
     fileName: string;
     changeType: FileChangeType;
 }
-export interface OnWatchFileChanges {
-    onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesPara[]): void;
-}
-export interface UpdateTsOrJsFile {
-    updateTsOrJsFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
-}
-declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & FormattingProvider & FoldingRangeProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & LinkedEditingRangesProvider;
-export declare type LSProvider = ProviderBase & BackwardsCompatibleDefinitionsProvider;
-export interface LSPProviderConfig {
-    /**
-     * Whether or not completion lists that are marked as imcomplete
-     * should be filtered server side.
-     */
-    filterIncompleteCompletions: boolean;
-    /**
-     * Whether or not getDefinitions supports the LocationLink interface.
-     */
-    definitionLinkSupport: boolean;
-}
-interface NamedPlugin {
-    pluginName: string;
-}
-export declare type Plugin = Partial<NamedPlugin & ProviderBase & DefinitionsProvider & OnWatchFileChanges & SelectionRangeProvider & UpdateTsOrJsFile>;
+export interface OnWatchFileChangesProvider {
+    onWatchFileChanges(onWatchFileChangesParams: OnWatchFileChangesParam[]): void;
+}
+export interface UpdateNonAstroFile {
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
+}
+declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangeProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & UpdateNonAstroFile;
+export declare type LSProvider = ProviderBase;
+export declare type Plugin = Partial<ProviderBase> & {
+    __name: string;
+};
 export {};

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

@@ -1,23 +1,42 @@
-import * as ts from 'typescript';
-import type { Document, DocumentManager } from '../../core/documents';
-import type { ConfigManager } from '../../core/config';
-import { SnapshotManager } from './SnapshotManager';
-import { DocumentSnapshot } from './DocumentSnapshot';
+import ts from 'typescript';
+import { TextDocumentContentChangeEvent } from 'vscode-languageserver';
+import { ConfigManager } from '../../core/config';
+import { AstroDocument, DocumentManager } from '../../core/documents';
+import { LanguageServiceContainer } from './language-service';
+import { DocumentSnapshot } from './snapshots/DocumentSnapshot';
 export declare class LanguageServiceManager {
     private readonly docManager;
-    private readonly configManager;
     private readonly workspaceUris;
+    private readonly configManager;
     private docContext;
-    constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
-    private getWorkspaceRoot;
+    private globalSnapshotManager;
+    constructor(docManager: DocumentManager, workspaceUris: string[], configManager: ConfigManager);
+    /**
+     * Create an AstroDocument (only for astro files)
+     */
     private createDocument;
-    getSnapshot(document: Document): Promise<DocumentSnapshot>;
-    getSnapshot(pathOrDoc: string | Document): Promise<DocumentSnapshot>;
-    getTypeScriptDoc(document: Document): Promise<{
+    getSnapshot(document: AstroDocument): Promise<DocumentSnapshot>;
+    getSnapshot(pathOrDoc: string | AstroDocument): Promise<DocumentSnapshot>;
+    /**
+     * Updates snapshot path in all existing ts services and retrieves snapshot
+     */
+    updateSnapshotPath(oldPath: string, newPath: string): Promise<DocumentSnapshot>;
+    /**
+     * Deletes snapshot in all existing ts services
+     */
+    deleteSnapshot(filePath: string): Promise<void>;
+    /**
+     * Updates project files in all existing ts services
+     */
+    updateProjectFiles(): Promise<void>;
+    /**
+     * Updates file in all ts services where it exists
+     */
+    updateExistingNonAstroFile(path: string, changes?: TextDocumentContentChangeEvent[]): Promise<void>;
+    getLSAndTSDoc(document: AstroDocument): Promise<{
         tsDoc: DocumentSnapshot;
         lang: ts.LanguageService;
     }>;
-    getTypeScriptLangForPath(filePath: string): Promise<ts.LanguageService>;
-    getSnapshotManager(filePath: string): Promise<SnapshotManager>;
-    private getTypeScriptLanguageService;
+    getLSForPath(path: string): Promise<ts.LanguageService>;
+    getTypeScriptLanguageService(filePath: string): Promise<LanguageServiceContainer>;
 }

package/dist/plugins/typescript/LanguageServiceManager.js

@@ -2,62 +2,87 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LanguageServiceManager = void 0;
 const utils_1 = require("../../utils");
-const languageService_1 = require("./languageService");
+const language_service_1 = require("./language-service");
+const SnapshotManager_1 = require("./snapshots/SnapshotManager");
 class LanguageServiceManager {
-    constructor(docManager, configManager, workspaceUris) {
-        this.createDocument = (fileName, content, overrideText) => {
+    constructor(docManager, workspaceUris, configManager) {
+        this.docManager = docManager;
+        this.workspaceUris = workspaceUris;
+        this.configManager = configManager;
+        this.globalSnapshotManager = new SnapshotManager_1.GlobalSnapshotManager();
+        /**
+         * Create an AstroDocument (only for astro files)
+         */
+        this.createDocument = (fileName, content) => {
             const uri = (0, utils_1.pathToUrl)(fileName);
             const document = this.docManager.openDocument({
-                languageId: 'astro',
-                version: 0,
                 text: content,
                 uri,
-                overrideText,
             });
+            this.docManager.lockDocument(uri);
             return document;
         };
-        this.docManager = docManager;
-        this.configManager = configManager;
-        this.workspaceUris = workspaceUris;
         this.docContext = {
-            getWorkspaceRoot: (fileName) => this.getWorkspaceRoot(fileName),
             createDocument: this.createDocument,
+            globalSnapshotManager: this.globalSnapshotManager,
         };
         const handleDocumentChange = (document) => {
-            // This refreshes the document in the ts language service
-            this.getTypeScriptDoc(document);
+            this.getSnapshot(document);
         };
         docManager.on('documentChange', (0, utils_1.debounceSameArg)(handleDocumentChange, (newDoc, prevDoc) => newDoc.uri === (prevDoc === null || prevDoc === void 0 ? void 0 : prevDoc.uri), 1000));
         docManager.on('documentOpen', handleDocumentChange);
     }
-    getWorkspaceRoot(fileName) {
-        if (this.workspaceUris.length === 1)
-            return (0, utils_1.urlToPath)(this.workspaceUris[0]);
-        return this.workspaceUris.reduce((found, curr) => {
-            const url = (0, utils_1.urlToPath)(curr);
-            if (fileName.startsWith(url) && curr.length < url.length)
-                return url;
-            return found;
-        }, '');
-    }
     async getSnapshot(pathOrDoc) {
         const filePath = typeof pathOrDoc === 'string' ? pathOrDoc : pathOrDoc.getFilePath() || '';
         const tsService = await this.getTypeScriptLanguageService(filePath);
-        return tsService.updateDocument(pathOrDoc);
+        return tsService.updateSnapshot(pathOrDoc);
+    }
+    /**
+     * Updates snapshot path in all existing ts services and retrieves snapshot
+     */
+    async updateSnapshotPath(oldPath, newPath) {
+        await this.deleteSnapshot(oldPath);
+        return this.getSnapshot(newPath);
+    }
+    /**
+     * Deletes snapshot in all existing ts services
+     */
+    async deleteSnapshot(filePath) {
+        await (0, language_service_1.forAllLanguageServices)((service) => service.deleteSnapshot(filePath));
+        this.docManager.releaseDocument((0, utils_1.pathToUrl)(filePath));
     }
-    async getTypeScriptDoc(document) {
-        const lang = await (0, languageService_1.getLanguageServiceForDocument)(document, this.workspaceUris, this.docContext);
+    /**
+     * Updates project files in all existing ts services
+     */
+    async updateProjectFiles() {
+        await (0, language_service_1.forAllLanguageServices)((service) => service.updateProjectFiles());
+    }
+    /**
+     * Updates file in all ts services where it exists
+     */
+    async updateExistingNonAstroFile(path, changes) {
+        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
+        // files, the operation wouldn't be idempotent.
+        let didUpdate = false;
+        await (0, language_service_1.forAllLanguageServices)((service) => {
+            if (service.hasFile(path) && !didUpdate) {
+                didUpdate = true;
+                service.updateNonAstroFile(path, changes);
+            }
+        });
+    }
+    async getLSAndTSDoc(document) {
+        const lang = await this.getLSForPath(document.getFilePath() || '');
         const tsDoc = await this.getSnapshot(document);
         return { tsDoc, lang };
     }
-    async getTypeScriptLangForPath(filePath) {
-        return (0, languageService_1.getLanguageServiceForPath)(filePath, this.workspaceUris, this.docContext);
-    }
-    async getSnapshotManager(filePath) {
-        return (await this.getTypeScriptLanguageService(filePath)).snapshotManager;
+    async getLSForPath(path) {
+        return (await this.getTypeScriptLanguageService(path)).getService();
     }
-    getTypeScriptLanguageService(filePath) {
-        return (0, languageService_1.getLanguageService)(filePath, this.workspaceUris, this.docContext);
+    async getTypeScriptLanguageService(filePath) {
+        return (0, language_service_1.getLanguageService)(filePath, this.workspaceUris, this.docContext);
     }
 }
 exports.LanguageServiceManager = LanguageServiceManager;

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;