@astrojs/language-server 0.13.4 → 0.16.0

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

@@ -1,25 +1,29 @@
-import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, SemanticTokens, 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';
+import { CompletionItemData } from './features/CompletionsProvider';
 export declare class TypeScriptPlugin implements Plugin {
     __name: string;
     private configManager;
     private readonly languageServiceManager;
+    private readonly codeActionsProvider;
     private readonly completionProvider;
     private readonly hoverProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
     private readonly semanticTokensProvider;
+    private readonly foldingRangesProvider;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
     getSemanticTokens(textDocument: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | 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>>;
+    getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
+    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
+    resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
     getDiagnostics(document: AstroDocument, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -37,17 +37,21 @@ const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_3 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
+const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
+const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
         this.configManager = configManager;
         this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager);
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
         this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
+        this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
     }
     async doHover(document, position) {
         if (!this.featureEnabled('hover')) {
@@ -78,6 +82,9 @@ class TypeScriptPlugin {
         });
         return edit;
     }
+    async getFoldingRanges(document) {
+        return this.foldingRangesProvider.getFoldingRanges(document);
+    }
     async getSemanticTokens(textDocument, range, cancellationToken) {
         if (!this.featureEnabled('semanticTokens')) {
             return null;
@@ -91,15 +98,21 @@ class TypeScriptPlugin {
         const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
         return symbols;
     }
-    async getCompletions(document, position, completionContext) {
+    async getCodeActions(document, range, context, cancellationToken) {
+        if (!this.featureEnabled('codeActions')) {
+            return [];
+        }
+        return this.codeActionsProvider.getCodeActions(document, range, context, cancellationToken);
+    }
+    async getCompletions(document, position, completionContext, cancellationToken) {
         if (!this.featureEnabled('completions')) {
             return null;
         }
-        const completions = await this.completionProvider.getCompletions(document, position, completionContext);
+        const completions = await this.completionProvider.getCompletions(document, position, completionContext, cancellationToken);
         return completions;
     }
-    async resolveCompletion(document, completionItem) {
-        return this.completionProvider.resolveCompletion(document, completionItem);
+    async resolveCompletion(document, completionItem, cancellationToken) {
+        return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
     }
     async getDefinitions(document, position) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -166,7 +179,7 @@ class TypeScriptPlugin {
     }
     getGoToDefinitionRefsForImportSpecifier(tsFilePath, offset, lang) {
         const program = lang.getProgram();
-        const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(tsFilePath);
+        const sourceFile = program?.getSourceFile(tsFilePath);
         if (sourceFile) {
             let node = typescript_1.default.getTouchingPropertyName(sourceFile, offset);
             if (node && node.kind === typescript_1.SyntaxKind.Identifier) {

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

@@ -14,9 +14,8 @@ function createAstroSys(getSnapshot) {
     const AstroSys = {
         ...typescript_1.default.sys,
         fileExists(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);
+            const exists = fileExistsCache.get(path) ?? typescript_1.default.sys.fileExists(path);
             fileExistsCache.set(path, exists);
             return exists;
         },
@@ -25,14 +24,13 @@ function createAstroSys(getSnapshot) {
             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 extensionsWithAstro = (extensions ?? []).concat(...['.astro', '.svelte', '.vue']);
             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);
+            return typescript_1.default.sys.deleteFile?.(path);
         },
         deleteFromCache(path) {
             fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));

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

@@ -1,5 +1,5 @@
 interface Astro2TSXResult {
     code: string;
 }
-export default function (content: string): Astro2TSXResult;
+export default function (content: string, className: string): Astro2TSXResult;
 export {};

package/dist/plugins/typescript/astro2tsx.js

@@ -2,18 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = require("os");
 const parseAstro_1 = require("../../core/documents/parseAstro");
-function addProps(content) {
+function addProps(content, className) {
     let defaultExportType = 'Record<string, any>';
     if (/(interface|type) Props/.test(content)) {
         defaultExportType = 'Props';
     }
-    return os_1.EOL + `export default function (_props: ${defaultExportType}) { return <div></div>; }`;
+    return os_1.EOL + `export default function ${className}__AstroComponent_(_props: ${defaultExportType}): any {}`;
 }
 function escapeTemplateLiteralContent(content) {
     return content.replace(/`/g, '\\`');
 }
-function default_1(content) {
-    var _a, _b;
+function default_1(content, className) {
     let result = {
         code: '',
     };
@@ -22,10 +21,11 @@ function default_1(content) {
     let frontMatterRaw = '';
     if (astroDocument.frontmatter.state === 'closed') {
         frontMatterRaw = content
-            .substring((_a = astroDocument.frontmatter.startOffset) !== null && _a !== void 0 ? _a : 0, ((_b = astroDocument.frontmatter.endOffset) !== null && _b !== void 0 ? _b : 0) + 3)
+            .substring(astroDocument.frontmatter.startOffset ?? 0, (astroDocument.frontmatter.endOffset ?? 0) + 3)
             // Handle case where semicolons is not used in the frontmatter section
+            // We need to add something before the semi-colon or TypeScript won't be able to do completions
             .replace(/((?!^)(?<!;)\n)(---)/g, (_whole, start, _dashes) => {
-            return start + ';' + '//';
+            return start + '"";';
         })
             // Replace frontmatter marks with comments
             .replace(/---/g, '///');
@@ -38,9 +38,13 @@ function default_1(content) {
         .replace(/<\s*!--([^-->]*)(.*?)-->/gs, (whole) => {
         return `{/*${whole}*/}`;
     })
-        // Turn styles into internal strings
+        // Turn styles tags into internal strings
         .replace(/<\s*style([^>]*)>(.*?)<\s*\/\s*style>/gs, (_whole, attrs, children) => {
         return `<style${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</style>`;
+    })
+        // Turn Markdown tags into internal strings
+        .replace(/<\s*Markdown([^>]*)>(.*?)<\s*\/\s*Markdown>/gs, (_whole, attrs, children) => {
+        return `<Markdown${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</Markdown>`;
     })
         // Turn scripts into function calls
         .replace(/<\s*script([^\/>]*)>(.*?)<\s*\/\s*script>/gs, (_whole, attrs, children, offset) => {
@@ -76,7 +80,7 @@ function default_1(content) {
             htmlRaw +
             os_1.EOL +
             // Add TypeScript definitions
-            addProps(frontMatterRaw);
+            addProps(frontMatterRaw, className);
     return result;
 }
 exports.default = default_1;

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

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

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

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeActionsProviderImpl = exports.sortImportKind = void 0;
+const lodash_1 = require("lodash");
+const typescript_1 = __importDefault(require("typescript"));
+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) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getCodeActions(document, range, context, cancellationToken) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragment = await tsDoc.createFragment();
+        const start = fragment.offsetAt(fragment.getGeneratedPosition(range.start));
+        const end = fragment.offsetAt(fragment.getGeneratedPosition(range.end));
+        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);
+            let codeFixes = errorCodes.includes(2304) ? this.getComponentQuickFix(start, end, lang, filePath) : undefined;
+            codeFixes = codeFixes ?? lang.getCodeFixesAtPosition(filePath, start, end, errorCodes, {}, {});
+            const codeActions = codeFixes.map((fix) => codeFixToCodeAction(fix, context.diagnostics, context.only ? vscode_languageserver_types_1.CodeActionKind.QuickFix : vscode_languageserver_types_1.CodeActionKind.Empty));
+            result.push(...codeActions);
+        }
+        return result;
+        function codeFixToCodeAction(codeFix, diagnostics, kind) {
+            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)(fragment, (0, utils_2.convertRange)(fragment, edit.span));
+                    if (codeFix.fixName === 'import') {
+                        return (0, CompletionsProvider_1.codeActionChangeToTextEdit)(document, fragment, edit);
+                    }
+                    if (codeFix.fixName === 'fixMissingFunctionDeclaration') {
+                        originalRange = (0, utils_2.checkEndOfFileCodeInsert)(originalRange, document);
+                    }
+                    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;
+        }
+    }
+    getComponentQuickFix(start, end, lang, filePath) {
+        const sourceFile = lang.getProgram()?.getSourceFile(filePath);
+        if (!sourceFile) {
+            return;
+        }
+        const node = (0, utils_3.findContainingNode)(sourceFile, {
+            start,
+            length: end - start,
+        }, (n) => typescript_1.default.isJsxClosingElement(n) || typescript_1.default.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(), CompletionsProvider_1.completionOptions);
+        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 (0, lodash_1.flatten)(completion.entries.filter((c) => c.name === name || c.name === suffixedName).map(toFix));
+    }
+    async organizeSortImports(document, skipDestructiveCodeActions = false, cancellationToken) {
+        if (document.astroMeta.frontmatter.state !== 'closed') {
+            return [];
+        }
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragment = await tsDoc.createFragment();
+        if (cancellationToken?.isCancellationRequested) {
+            return [];
+        }
+        const changes = lang.organizeImports({ fileName: filePath, type: 'file', skipDestructiveCodeActions }, {}, {});
+        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)(fragment, (0, utils_2.convertRange)(fragment, edit.span));
+                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,16 +1,34 @@
-import type { CompletionContext, Position, TextDocumentIdentifier } from 'vscode-languageserver';
+import { CompletionContext, Position, TextDocumentIdentifier, TextEdit, CancellationToken } from 'vscode-languageserver';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
 import { AstroDocument } from '../../../core/documents';
 import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
-export interface CompletionEntryWithIdentifer extends ts.CompletionEntry, TextDocumentIdentifier {
-    position: Position;
+import { AstroSnapshotFragment } from '../snapshots/DocumentSnapshot';
+export declare const completionOptions: ts.GetCompletionsAtPositionOptions;
+export interface CompletionItemData extends TextDocumentIdentifier {
+    filePath: string;
+    offset: number;
+    originalItem: ts.CompletionEntry;
 }
-export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionEntryWithIdentifer> {
+export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionItemData> {
     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 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 isValidCompletion;
     private getCompletionDocument;
+    /**
+     * If the textEdit is out of the word range of the triggered position
+     * vscode would refuse to show the completions
+     * split those edits into additionalTextEdit to fix it
+     */
+    private fixTextEditRange;
+    private canReuseLastCompletion;
+    private getExistingImports;
+    private isAstroComponentImport;
 }
+export declare function codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, change: ts.TextChange): TextEdit;