@astrojs/language-server 0.11.0 → 0.13.0

package/dist/plugins/html/features/astro-attributes.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astroDirectives = exports.astroAttributes = void 0;
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-attributes', {
+    version: 1,
+    globalAttributes: [
+        {
+            name: 'class:list',
+            description: 'Utility to provide a list of class',
+        },
+        {
+            name: 'set:html',
+            description: 'Inject unescaped HTML into this tag',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/migrate/#deprecated-unescaped-html',
+                },
+            ],
+        },
+        {
+            name: 'set:text',
+            description: 'Inject escaped text into this tag',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/migrate/#deprecated-unescaped-html',
+                },
+            ],
+        },
+    ],
+    tags: [
+        {
+            name: 'script',
+            attributes: [
+                {
+                    // The VS Code tag definitions does not provide a description for the deprecated `charset` attribute on script tags
+                    // Which mean that since we get no hover info for this, we instead get JSX hover info. So we'll just specify a description ourselves for this specific case
+                    name: 'charset',
+                    description: "(Deprecated) It's unnecessary to specify the charset attribute, because documents must use UTF-8, and the script element inherits its character encoding from the document.",
+                },
+                {
+                    name: 'define:vars',
+                    description: 'Passes serializable server-side variables into a client-side script element',
+                    references: [
+                        {
+                            name: 'Astro documentation',
+                            url: 'https://docs.astro.build/en/guides/styling/#variables-in-scripts--styles',
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'style',
+            attributes: [
+                {
+                    name: 'define:vars',
+                    description: 'Passes serializable server-side variables into a client-side style element',
+                    references: [
+                        {
+                            name: 'Astro documentation',
+                            url: 'https://docs.astro.build/en/guides/styling/#variables-in-scripts--styles',
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+});
+exports.astroDirectives = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-directives', {
+    version: 1,
+    globalAttributes: [
+        {
+            name: 'client:load',
+            description: 'Start importing the component JS at page load. Hydrate the component when import completes.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:idle',
+            description: 'Start importing the component JS as soon as main thread is free (uses requestIdleCallback()). Hydrate the component when import completes.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:visible',
+            description: 'Start importing the component JS as soon as the element enters the viewport (uses IntersectionObserver). Hydrate the component when import completes. Useful for content lower down on the page.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:media',
+            description: 'Start importing the component JS as soon as the browser matches the given media query (uses matchMedia). Hydrate the component when import completes. Useful for sidebar toggles, or other elements that should only display on mobile or desktop devices.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:only',
+            description: 'Start importing the component JS at page load and hydrate when the import completes, similar to client:load. The component will be skipped at build time, useful for components that are entirely dependent on client-side APIs. This is best avoided unless absolutely needed, in most cases it is best to render placeholder content on the server and delay any browser API calls until the component hydrates in the browser.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+    ],
+});

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

@@ -15,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,28 @@
-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, SymbolInformation, 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;
+    private readonly documentSymbolsProvider;
     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>;
+    getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
+    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;