@astrojs/language-server 1.0.4 → 2.0.0-next.0

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeScriptPlugin = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
-const astro2tsx_1 = require("./astro2tsx");
-const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
-const CompletionsProvider_1 = require("./features/CompletionsProvider");
-const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
-const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
-const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
-const FileReferencesProvider_1 = require("./features/FileReferencesProvider");
-const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
-const HoverProvider_1 = require("./features/HoverProvider");
-const ImplementationsProvider_1 = require("./features/ImplementationsProvider");
-const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
-const ReferencesProvider_1 = require("./features/ReferencesProvider");
-const RenameProvider_1 = require("./features/RenameProvider");
-const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
-const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
-const TypeDefinitionsProvider_1 = require("./features/TypeDefinitionsProvider");
-const utils_1 = require("./utils");
-class TypeScriptPlugin {
-    constructor(configManager, languageServiceManager) {
-        this.__name = 'typescript';
-        this.configManager = configManager;
-        this.languageServiceManager = languageServiceManager;
-        this.ts = languageServiceManager.docContext.ts;
-        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager, this.configManager);
-        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager, this.configManager);
-        this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
-        this.fileReferencesProvider = new FileReferencesProvider_1.FileReferencesProviderImpl(this.languageServiceManager);
-        this.definitionsProvider = new DefinitionsProvider_1.DefinitionsProviderImpl(this.languageServiceManager);
-        this.typeDefinitionsProvider = new TypeDefinitionsProvider_1.TypeDefinitionsProviderImpl(this.languageServiceManager);
-        this.implementationsProvider = new ImplementationsProvider_1.ImplementationsProviderImpl(this.languageServiceManager);
-        this.referencesProvider = new ReferencesProvider_1.FindReferencesProviderImpl(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);
-        this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
-        this.inlayHintsProvider = new InlayHintsProvider_1.InlayHintsProviderImpl(this.languageServiceManager, this.configManager);
-        this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
-        this.renameProvider = new RenameProvider_1.RenameProviderImpl(this.languageServiceManager, this.configManager);
-    }
-    async doHover(document, position) {
-        if (!(await this.featureEnabled(document, 'hover'))) {
-            return null;
-        }
-        return this.hoverProvider.doHover(document, position);
-    }
-    async prepareRename(document, position) {
-        return this.renameProvider.prepareRename(document, position);
-    }
-    async rename(document, position, newName) {
-        return this.renameProvider.rename(document, position, newName);
-    }
-    async getFoldingRanges(document) {
-        return this.foldingRangesProvider.getFoldingRanges(document);
-    }
-    async getSemanticTokens(document, range, cancellationToken) {
-        if (!(await this.featureEnabled(document, 'semanticTokens'))) {
-            return null;
-        }
-        return this.semanticTokensProvider.getSemanticTokens(document, range, cancellationToken);
-    }
-    async getDocumentSymbols(document) {
-        if (!(await this.featureEnabled(document, 'documentSymbols'))) {
-            return [];
-        }
-        const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
-        return symbols;
-    }
-    async getCodeActions(document, range, context, cancellationToken) {
-        if (!(await this.featureEnabled(document, 'codeActions'))) {
-            return [];
-        }
-        return this.codeActionsProvider.getCodeActions(document, range, context, cancellationToken);
-    }
-    async getCompletions(document, position, completionContext, cancellationToken) {
-        if (!(await this.featureEnabled(document, 'completions'))) {
-            return null;
-        }
-        const completions = await this.completionProvider.getCompletions(document, position, completionContext, cancellationToken);
-        return completions;
-    }
-    async resolveCompletion(document, completionItem, cancellationToken) {
-        return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
-    }
-    async getInlayHints(document, range) {
-        return this.inlayHintsProvider.getInlayHints(document, range);
-    }
-    async fileReferences(document) {
-        return this.fileReferencesProvider.fileReferences(document);
-    }
-    async getDefinitions(document, position) {
-        return this.definitionsProvider.getDefinitions(document, position);
-    }
-    async getTypeDefinitions(document, position) {
-        return this.typeDefinitionsProvider.getTypeDefinitions(document, position);
-    }
-    async getImplementation(document, position) {
-        return this.implementationsProvider.getImplementation(document, position);
-    }
-    async findReferences(document, position, context) {
-        return this.referencesProvider.findReferences(document, position, context);
-    }
-    async getDiagnostics(document, cancellationToken) {
-        if (!(await this.featureEnabled(document, 'diagnostics'))) {
-            return [];
-        }
-        return this.diagnosticsProvider.getDiagnostics(document, cancellationToken);
-    }
-    async onWatchFileChanges(onWatchFileChangesParas) {
-        let doneUpdateProjectFiles = false;
-        for (const { fileName, changeType } of onWatchFileChangesParas) {
-            const scriptKind = (0, utils_1.getScriptKindFromFileName)(fileName, this.ts);
-            if (scriptKind === this.ts.ScriptKind.Unknown && !(0, utils_1.isFrameworkFilePath)(fileName) && !(0, utils_1.isAstroFilePath)(fileName)) {
-                continue;
-            }
-            if (changeType === vscode_languageserver_1.FileChangeType.Created && !doneUpdateProjectFiles) {
-                doneUpdateProjectFiles = true;
-                await this.languageServiceManager.updateProjectFiles();
-            }
-            else if (changeType === vscode_languageserver_1.FileChangeType.Deleted) {
-                await this.languageServiceManager.deleteSnapshot(fileName);
-            }
-            else if (!(0, utils_1.isAstroFilePath)(fileName)) {
-                // Content updates for Astro files are handled through the documentManager and the 'documentChange' event
-                await this.languageServiceManager.updateExistingNonAstroFile(fileName);
-            }
-        }
-    }
-    async updateNonAstroFile(fileName, changes, text) {
-        await this.languageServiceManager.updateExistingNonAstroFile(fileName, changes, text);
-    }
-    async getSignatureHelp(document, position, context, cancellationToken) {
-        return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
-    }
-    getTSXForDocument(document) {
-        return (0, astro2tsx_1.astro2tsx)(document.getText(), document.getURL());
-    }
-    /**
-     * @internal Public for tests only
-     */
-    getSnapshotManager(fileName) {
-        return this.languageServiceManager.getSnapshotManager(fileName);
-    }
-    async featureEnabled(document, feature) {
-        return ((await this.configManager.isEnabled(document, 'typescript')) &&
-            (await this.configManager.isEnabled(document, 'typescript', feature)));
-    }
-}
-exports.TypeScriptPlugin = TypeScriptPlugin;

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

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

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

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAstroSys = void 0;
-const utils_1 = require("./utils");
-/**
- * This should only be accessed by TS Astro module resolution.
- */
-function createAstroSys(getSnapshot, ts) {
-    const fileExistsCache = new Map();
-    const AstroSys = {
-        ...ts.sys,
-        fileExists(path) {
-            path = (0, utils_1.ensureRealFilePath)(path);
-            const exists = fileExistsCache.get(path) ?? ts.sys.fileExists(path);
-            fileExistsCache.set(path, exists);
-            return exists;
-        },
-        readFile(path) {
-            const snapshot = getSnapshot(path);
-            return snapshot.getText(0, snapshot.getLength());
-        },
-        readDirectory(path, extensions, exclude, include, depth) {
-            const extensionsWithAstro = (extensions ?? []).concat(...['.astro', '.svelte', '.vue', '.md', '.mdx', '.html']);
-            const result = ts.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
-            return result;
-        },
-        deleteFile(path) {
-            fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));
-            return ts.sys.deleteFile?.(path);
-        },
-        deleteFromCache(path) {
-            fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));
-        },
-    };
-    if (ts.sys.realpath) {
-        const realpath = ts.sys.realpath;
-        AstroSys.realpath = function (path) {
-            if ((0, utils_1.isVirtualFilePath)(path)) {
-                return realpath((0, utils_1.ensureRealFilePath)(path)) + '.tsx';
-            }
-            return realpath(path);
-        };
-    }
-    return AstroSys;
-}
-exports.createAstroSys = createAstroSys;

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

@@ -1,2 +0,0 @@
-import type { TSXResult } from '@astrojs/compiler/types';
-export declare function astro2tsx(content: string, fileName: string): TSXResult;

package/dist/plugins/typescript/astro2tsx.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.astro2tsx = void 0;
-const sync_1 = require("@astrojs/compiler/sync");
-function astro2tsx(content, fileName) {
-    try {
-        const tsx = (0, sync_1.convertToTSX)(content, { filename: fileName });
-        return tsx;
-    }
-    catch (e) {
-        console.error(`There was an error transforming ${fileName} to TSX. An empty file will be returned instead. Please create an issue: https://github.com/withastro/language-tools/issues\nError: ${e}.`);
-        return {
-            code: '',
-            map: {
-                file: fileName,
-                sources: [],
-                sourcesContent: [],
-                names: [],
-                mappings: '',
-                version: 0,
-            },
-            diagnostics: [],
-        };
-    }
-}
-exports.astro2tsx = astro2tsx;

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

@@ -1,17 +0,0 @@
-import type { CancellationToken } from 'vscode-languageserver';
-import { CodeAction, CodeActionContext, Range } from 'vscode-languageserver-types';
-import type { ConfigManager } from '../../../core/config';
-import { AstroDocument } from '../../../core/documents';
-import type { CodeActionsProvider } from '../../interfaces';
-import type { LanguageServiceManager } from '../LanguageServiceManager';
-export declare const sortImportKind: string;
-export declare class CodeActionsProviderImpl implements CodeActionsProvider {
-    private languageServiceManager;
-    private configManager;
-    private ts;
-    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
-    getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
-    private getComponentQuickFix;
-    private organizeSortImports;
-    private fixIndentationOfImports;
-}

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

@@ -1,212 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeActionsProviderImpl = exports.sortImportKind = void 0;
-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");
-const CompletionsProvider_1 = require("./CompletionsProvider");
-const utils_3 = require("./utils");
-// These are VS Code specific CodeActionKind so they're not in the language server protocol
-exports.sortImportKind = `${vscode_languageserver_types_1.CodeActionKind.Source}.sortImports`;
-class CodeActionsProviderImpl {
-    constructor(languageServiceManager, configManager) {
-        this.languageServiceManager = languageServiceManager;
-        this.configManager = configManager;
-        this.ts = languageServiceManager.docContext.ts;
-    }
-    async getCodeActions(document, range, context, cancellationToken) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const tsPreferences = await this.configManager.getTSPreferences(document);
-        const formatOptions = await this.configManager.getTSFormatConfig(document);
-        let result = [];
-        if (cancellationToken?.isCancellationRequested) {
-            return [];
-        }
-        if (context.only?.[0] === vscode_languageserver_types_1.CodeActionKind.SourceOrganizeImports) {
-            return await this.organizeSortImports(document, false, cancellationToken);
-        }
-        // The difference between Sort Imports and Organize Imports is that Sort Imports won't do anything destructive.
-        // For example, it won't remove unused imports whereas Organize Imports will
-        if (context.only?.[0] === exports.sortImportKind) {
-            return await this.organizeSortImports(document, true, cancellationToken);
-        }
-        if (context.only?.[0] === vscode_languageserver_types_1.CodeActionKind.Source) {
-            return [
-                ...(await this.organizeSortImports(document, true, cancellationToken)),
-                ...(await this.organizeSortImports(document, false, cancellationToken)),
-            ];
-        }
-        if (context.diagnostics.length && (!context.only || context.only.includes(vscode_languageserver_types_1.CodeActionKind.QuickFix))) {
-            const errorCodes = context.diagnostics
-                .map((diag) => Number(diag.code))
-                // We currently cannot support quick fix for unreachable code properly due to the way our TSX output is structured
-                .filter((code) => code !== 7027);
-            const html = document.html;
-            const node = html.findNodeAt(document.offsetAt(range.start));
-            let codeFixes;
-            let isInsideScript = false;
-            if (node.tag === 'script') {
-                const { snapshot: scriptTagSnapshot, filePath: scriptFilePath } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node);
-                const start = scriptTagSnapshot.offsetAt(scriptTagSnapshot.getGeneratedPosition(range.start));
-                const end = scriptTagSnapshot.offsetAt(scriptTagSnapshot.getGeneratedPosition(range.end));
-                codeFixes = lang.getCodeFixesAtPosition(scriptFilePath, start, end, errorCodes, formatOptions, tsPreferences);
-                codeFixes = codeFixes.map((fix) => ({
-                    ...fix,
-                    changes: mapScriptTagFixToOriginal(fix.changes, scriptTagSnapshot),
-                }));
-                isInsideScript = true;
-            }
-            else {
-                const start = tsDoc.offsetAt(tsDoc.getGeneratedPosition(range.start));
-                const end = tsDoc.offsetAt(tsDoc.getGeneratedPosition(range.end));
-                codeFixes = errorCodes.includes(2304)
-                    ? this.getComponentQuickFix(start, end, lang, tsDoc.filePath, formatOptions, tsPreferences)
-                    : undefined;
-                codeFixes =
-                    codeFixes ??
-                        lang.getCodeFixesAtPosition(tsDoc.filePath, start, end, errorCodes, formatOptions, tsPreferences);
-            }
-            const codeActions = codeFixes.map((fix) => codeFixToCodeAction(fix, context.diagnostics, context.only ? vscode_languageserver_types_1.CodeActionKind.QuickFix : vscode_languageserver_types_1.CodeActionKind.Empty, isInsideScript, this.ts));
-            result.push(...codeActions);
-        }
-        return result;
-        function codeFixToCodeAction(codeFix, diagnostics, kind, isInsideScript, ts) {
-            const documentChanges = codeFix.changes.map((change) => {
-                return vscode_languageserver_types_1.TextDocumentEdit.create(vscode_languageserver_types_1.OptionalVersionedTextDocumentIdentifier.create(document.getURL(), null), change.textChanges.map((edit) => {
-                    let originalRange = (0, documents_1.mapRangeToOriginal)(tsDoc, (0, utils_2.convertRange)(tsDoc, edit.span));
-                    // Inside scripts, we don't need to restrain the insertion of code inside a specific zone as it will be
-                    // restricted to the area of the script tag by default
-                    if (!isInsideScript) {
-                        if (codeFix.fixName === 'import') {
-                            return (0, CompletionsProvider_1.codeActionChangeToTextEdit)(document, tsDoc, false, edit, ts);
-                        }
-                        if (codeFix.fixName === 'fixMissingFunctionDeclaration') {
-                            originalRange = (0, utils_2.checkEndOfFileCodeInsert)(originalRange, document);
-                        }
-                    }
-                    else {
-                        // Make sure new imports are not added on the file line of the script tag
-                        if (codeFix.fixName === 'import') {
-                            const existingLine = (0, documents_1.getLineAtPosition)(document.positionAt(edit.span.start), document.getText());
-                            const isNewImport = !existingLine.trim().startsWith('import');
-                            if (!(edit.newText.startsWith('\n') || edit.newText.startsWith('\r\n')) && isNewImport) {
-                                edit.newText = ts.sys.newLine + edit.newText;
-                            }
-                        }
-                    }
-                    return vscode_languageserver_types_1.TextEdit.replace(originalRange, edit.newText);
-                }));
-            });
-            const codeAction = vscode_languageserver_types_1.CodeAction.create(codeFix.description, {
-                documentChanges,
-            }, kind);
-            codeAction.diagnostics = diagnostics;
-            return codeAction;
-        }
-        function mapScriptTagFixToOriginal(changes, scriptTagSnapshot) {
-            return changes.map((change) => {
-                change.textChanges.map((edit) => {
-                    edit.span.start = (0, documents_1.mapScriptSpanStartToSnapshot)(edit.span, scriptTagSnapshot, tsDoc);
-                    return edit;
-                });
-                return change;
-            });
-        }
-    }
-    getComponentQuickFix(start, end, lang, filePath, formatOptions, tsPreferences) {
-        const sourceFile = lang.getProgram()?.getSourceFile(filePath);
-        if (!sourceFile) {
-            return;
-        }
-        const node = (0, utils_3.findContainingNode)(sourceFile, {
-            start,
-            length: end - start,
-        }, (n) => this.ts.isJsxClosingElement(n) || this.ts.isJsxOpeningLikeElement(n));
-        if (!node) {
-            return;
-        }
-        const tagName = node.tagName;
-        // Unlike quick fixes, completions will be able to find the component, so let's use those to get it
-        const completion = lang.getCompletionsAtPosition(filePath, tagName.getEnd(), tsPreferences, formatOptions);
-        if (!completion) {
-            return;
-        }
-        const name = tagName.getText();
-        const suffixedName = name + '__AstroComponent_';
-        const toFix = (c) => lang.getCompletionEntryDetails(filePath, end, c.name, {}, c.source, {}, c.data)?.codeActions?.map((a) => ({
-            ...a,
-            description: (0, utils_2.removeAstroComponentSuffix)(a.description),
-            fixName: 'import',
-        })) ?? [];
-        return completion.entries.filter((c) => c.name === name || c.name === suffixedName).flatMap(toFix);
-    }
-    async organizeSortImports(document, skipDestructiveCodeActions = false, cancellationToken) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const filePath = tsDoc.filePath;
-        if (cancellationToken?.isCancellationRequested) {
-            return [];
-        }
-        let changes = [];
-        if (document.astroMeta.frontmatter.state === 'closed') {
-            changes.push(...lang.organizeImports({ fileName: filePath, type: 'file', skipDestructiveCodeActions }, {}, {}));
-        }
-        document.scriptTags.forEach((scriptTag) => {
-            const { filePath: scriptFilePath, snapshot: scriptTagSnapshot } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, scriptTag.container);
-            const edits = lang.organizeImports({ fileName: scriptFilePath, type: 'file', skipDestructiveCodeActions }, {}, {});
-            edits.forEach((edit) => {
-                edit.fileName = tsDoc.filePath;
-                edit.textChanges = edit.textChanges
-                    .map((change) => {
-                    change.span.start = (0, documents_1.mapScriptSpanStartToSnapshot)(change.span, scriptTagSnapshot, tsDoc);
-                    // If the result ending position is unmapped, it usually means the ending position has a newline
-                    // inside the virtual part of the script tag, so let's just make it a character shorter
-                    const range = (0, documents_1.mapRangeToOriginal)(tsDoc, (0, utils_2.convertRange)(tsDoc, change.span));
-                    if (range.end.character === 0 && range.end.line === 0) {
-                        change.span.length -= 1;
-                    }
-                    return change;
-                })
-                    // Since our last line is a (virtual) export, organize imports will try to rewrite it, so let's only take
-                    // changes that actually happens inside the script tag
-                    .filter((change) => {
-                    return (scriptTagSnapshot.isInGenerated(document.positionAt(change.span.start)) &&
-                        !change.newText.includes('export { }'));
-                });
-                return edit;
-            });
-            changes.push(...edits);
-        });
-        const documentChanges = changes.map((change) => {
-            return vscode_languageserver_types_1.TextDocumentEdit.create(vscode_languageserver_types_1.OptionalVersionedTextDocumentIdentifier.create(document.url, null), change.textChanges.map((edit) => {
-                const range = (0, documents_1.mapRangeToOriginal)(tsDoc, (0, utils_2.convertRange)(tsDoc, edit.span));
-                if (document.offsetAt(range.start) < (document.astroMeta.content.firstNonWhitespaceOffset ?? 0)) {
-                    if (document.offsetAt(range.end) > document.astroMeta.frontmatter.endOffset) {
-                        range.end = document.positionAt(document.astroMeta.frontmatter.endOffset);
-                    }
-                }
-                return vscode_languageserver_types_1.TextEdit.replace(range, this.fixIndentationOfImports(edit.newText, range, document));
-            }));
-        });
-        return [
-            vscode_languageserver_types_1.CodeAction.create(skipDestructiveCodeActions ? 'Sort Imports' : 'Organize Imports', {
-                documentChanges,
-            }, skipDestructiveCodeActions ? exports.sortImportKind : vscode_languageserver_types_1.CodeActionKind.SourceOrganizeImports),
-        ];
-    }
-    // "Organize Imports" will have edits that delete all imports by return empty edits
-    // and one edit which contains all the organized imports. Fix indentation
-    // of that one by prepending all lines with the indentation of the first line.
-    fixIndentationOfImports(edit, range, document) {
-        if (!edit || range.start.character === 0) {
-            return edit;
-        }
-        const existingLine = (0, documents_1.getLineAtPosition)(range.start, document.getText());
-        const leadingChars = existingLine.substring(0, range.start.character);
-        if (leadingChars.trim() !== '') {
-            return edit;
-        }
-        return (0, utils_1.modifyLines)(edit, (line, idx) => (idx === 0 || !line ? line : leadingChars + line));
-    }
-}
-exports.CodeActionsProviderImpl = CodeActionsProviderImpl;

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

@@ -1,31 +0,0 @@
-import type ts from 'typescript';
-import { CancellationToken, CompletionContext, Position, TextDocumentIdentifier, TextEdit } from 'vscode-languageserver';
-import type { ConfigManager } from '../../../core/config';
-import { AstroDocument } from '../../../core/documents';
-import type { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
-import type { LanguageServiceManager } from '../LanguageServiceManager';
-import type { DocumentSnapshot } from '../snapshots/DocumentSnapshot';
-export interface CompletionItemData extends TextDocumentIdentifier {
-    filePath: string;
-    offset: number;
-    scriptTagIndex: number | undefined;
-    originalItem: ts.CompletionEntry;
-}
-export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionItemData> {
-    private languageServiceManager;
-    private configManager;
-    private ts;
-    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
-    private readonly validTriggerCharacters;
-    private isValidTriggerCharacter;
-    private lastCompletion?;
-    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
-    resolveCompletion(document: AstroDocument, item: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
-    private toCompletionItem;
-    private getCompletionDocument;
-    private canReuseLastCompletion;
-    private getExistingImports;
-    private isAstroComponentImport;
-    private isValidCompletion;
-}
-export declare function codeActionChangeToTextEdit(document: AstroDocument, snapshot: DocumentSnapshot, isInsideScriptTag: boolean, change: ts.TextChange, ts: typeof import('typescript/lib/tsserverlibrary')): TextEdit;