@astrojs/language-server 0.14.0 → 0.16.1

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

@@ -1,92 +1,296 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionsProviderImpl = void 0;
-const utils_1 = require("../../../core/documents/utils");
-const typescript_1 = __importDefault(require("typescript"));
+exports.codeActionChangeToTextEdit = exports.CompletionsProviderImpl = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const utils_1 = require("../../../core/documents/utils");
+const documents_1 = require("../../../core/documents");
+const typescript_1 = __importStar(require("typescript"));
+const vscode_languageserver_2 = require("vscode-languageserver");
 const utils_2 = require("../utils");
-const completionOptions = Object.freeze({
-    importModuleSpecifierPreference: 'relative',
-    importModuleSpecifierEnding: 'auto',
-    quotePreference: 'single',
-});
+const utils_3 = require("../../../utils");
+const lodash_1 = require("lodash");
+const previewer_1 = require("../previewer");
+const utils_4 = require("./utils");
+// `import {...} from '..'` or `import ... from '..'`
+// Note: Does not take into account if import is within a comment.
+const scriptImportRegex = /\bimport\s+{([^}]*?)}\s+?from\s+['"`].+?['"`]|\bimport\s+(\w+?)\s+from\s+['"`].+?['"`]/g;
 class CompletionsProviderImpl {
-    constructor(languageServiceManager) {
+    constructor(languageServiceManager, configManager) {
         this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
+        this.validTriggerCharacters = ['.', '"', "'", '`', '/', '@', '<', '#'];
+    }
+    isValidTriggerCharacter(character) {
+        return this.validTriggerCharacters.includes(character);
     }
-    async getCompletions(document, position, _completionContext) {
-        var _a;
-        // TODO: handle inside expression and script tags
-        if (!(0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
+    async getCompletions(document, position, completionContext, cancellationToken) {
+        const triggerCharacter = completionContext?.triggerCharacter;
+        const triggerKind = completionContext?.triggerKind;
+        const validTriggerCharacter = this.isValidTriggerCharacter(triggerCharacter) ? triggerCharacter : undefined;
+        const isCustomTriggerCharacter = triggerKind === vscode_languageserver_1.CompletionTriggerKind.TriggerCharacter;
+        if ((isCustomTriggerCharacter && !validTriggerCharacter) || cancellationToken?.isCancellationRequested) {
+            return null;
+        }
+        if (this.canReuseLastCompletion(this.lastCompletion, triggerKind, triggerCharacter, document, position)) {
+            this.lastCompletion.position = position;
+            return this.lastCompletion.completionList;
+        }
+        else {
+            this.lastCompletion = undefined;
+        }
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        const node = html.findNodeAt(offset);
+        // TODO: Add support for script tags
+        if (node.tag === 'script') {
+            return null;
+        }
+        const isCompletionInsideFrontmatter = (0, utils_1.isInsideFrontmatter)(document.getText(), offset);
+        const isCompletionInsideExpression = (0, utils_1.isInsideExpression)(document.getText(), node.start, offset);
+        // PERF: Getting TS completions is fairly slow and I am currently not sure how to speed it up
+        // As such, we'll try to avoid getting them when unneeded, such as when we're doing HTML stuff
+        // When at the root of the document TypeScript offer all kinds of completions, because it doesn't know yet that
+        // it's JSX and not JS. As such, people who are using Emmet to write their template suffer from a very degraded experience
+        // from what they're used to in HTML files (which is instant completions). So let's disable ourselves when we're at the root
+        if (!isCompletionInsideFrontmatter && !node.parent && !isCompletionInsideExpression) {
             return null;
         }
+        // If the user just typed `<` with nothing else, let's disable ourselves until we're more sure if the user wants TS completions
+        if (!isCompletionInsideFrontmatter && node.parent && node.tag === undefined && !isCompletionInsideExpression) {
+            return null;
+        }
+        // If the current node is not a component (aka, it doesn't start with a caps), let's disable ourselves as the user
+        // is most likely looking for HTML completions
+        if (!isCompletionInsideFrontmatter && !(0, utils_1.isComponentTag)(node) && !isCompletionInsideExpression) {
+            return null;
+        }
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const formatOptions = await this.configManager.getTSFormatConfig(document);
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const completions = lang.getCompletionsAtPosition(filePath, offset, {
+            ...tsPreferences,
+            triggerCharacter: validTriggerCharacter,
+        }, formatOptions);
+        if (completions === undefined || completions.entries.length === 0) {
+            return null;
+        }
+        const wordRange = completions.optionalReplacementSpan
+            ? vscode_languageserver_1.Range.create(document.positionAt(completions.optionalReplacementSpan.start), document.positionAt(completions.optionalReplacementSpan.start + completions.optionalReplacementSpan.length))
+            : undefined;
+        const wordRangeStartPosition = wordRange?.start;
         const fragment = await tsDoc.createFragment();
-        const offset = document.offsetAt(position);
-        const entries = ((_a = lang.getCompletionsAtPosition(filePath, offset, completionOptions)) === null || _a === void 0 ? void 0 : _a.entries) || [];
-        const completionItems = entries
-            .map((entry) => this.toCompletionItem(fragment, entry, document.uri, position, new Set()))
-            .filter((i) => i);
-        return vscode_languageserver_1.CompletionList.create(completionItems, true);
+        const existingImports = this.getExistingImports(document);
+        const completionItems = completions.entries
+            .filter(this.isValidCompletion)
+            .map((entry) => this.toCompletionItem(fragment, entry, filePath, offset, isCompletionInsideFrontmatter, existingImports))
+            .filter(utils_3.isNotNullOrUndefined)
+            .map((comp) => this.fixTextEditRange(wordRangeStartPosition, comp));
+        const completionList = vscode_languageserver_2.CompletionList.create(completionItems, true);
+        this.lastCompletion = { key: document.getFilePath() || '', position, completionList };
+        return completionList;
     }
-    async resolveCompletion(document, completionItem) {
-        const { data: comp } = completionItem;
+    async resolveCompletion(document, item, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        let filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
-        if (!comp || !filePath) {
-            return completionItem;
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const data = item.data;
+        if (!data || !data.filePath || cancellationToken?.isCancellationRequested) {
+            return item;
         }
         const fragment = await tsDoc.createFragment();
-        const detail = lang.getCompletionEntryDetails(filePath, // fileName
-        fragment.offsetAt(comp.position), // position
-        comp.name, // entryName
+        const detail = lang.getCompletionEntryDetails(data.filePath, // fileName
+        data.offset, // position
+        data.originalItem.name, // entryName
         {}, // formatOptions
-        comp.source, // source
-        {}, // preferences
-        comp.data // data
+        data.originalItem.source, // source
+        tsPreferences, // preferences
+        data.originalItem.data // data
         );
         if (detail) {
             const { detail: itemDetail, documentation: itemDocumentation } = this.getCompletionDocument(detail);
-            completionItem.detail = itemDetail;
-            completionItem.documentation = itemDocumentation;
+            item.detail = itemDetail;
+            item.documentation = itemDocumentation;
         }
-        return completionItem;
+        const actions = detail?.codeActions;
+        if (actions) {
+            const edit = [];
+            for (const action of actions) {
+                for (const change of action.changes) {
+                    edit.push(...change.textChanges.map((textChange) => codeActionChangeToTextEdit(document, fragment, textChange)));
+                }
+            }
+            item.additionalTextEdits = (item.additionalTextEdits ?? []).concat(edit);
+        }
+        return item;
     }
-    toCompletionItem(fragment, comp, uri, position, existingImports) {
+    toCompletionItem(fragment, comp, filePath, offset, insideFrontmatter, existingImports) {
+        let item = vscode_languageserver_protocol_1.CompletionItem.create(comp.name);
+        const isAstroComponent = this.isAstroComponentImport(comp.name);
+        const isImport = comp.insertText?.includes('import');
+        // Avoid showing completions for using components as functions
+        if (isAstroComponent && !isImport && insideFrontmatter) {
+            return null;
+        }
+        if (isAstroComponent) {
+            item.label = (0, utils_2.removeAstroComponentSuffix)(comp.name);
+            // Set component imports as file completion, that way we get cool icons
+            item.kind = vscode_languageserver_protocol_1.CompletionItemKind.File;
+            item.detail = comp.data?.moduleSpecifier;
+        }
+        else {
+            item.kind = (0, utils_2.scriptElementKindToCompletionItemKind)(comp.kind);
+        }
+        // TS may suggest another component even if there already exists an import with the same.
+        // This happens because internally, components get suffixed with __AstroComponent_
+        if (isAstroComponent && existingImports.has(item.label)) {
+            return null;
+        }
+        if (comp.kindModifiers) {
+            const kindModifiers = new Set(comp.kindModifiers.split(/,|\s+/g));
+            if (kindModifiers.has(typescript_1.ScriptElementKindModifier.deprecatedModifier)) {
+                item.tags = [vscode_languageserver_1.CompletionItemTag.Deprecated];
+            }
+        }
+        // Label details are currently unsupported, however, they'll be supported in the next version of LSP
+        if (comp.sourceDisplay) {
+            item.labelDetails = { description: typescript_1.default.displayPartsToString(comp.sourceDisplay) };
+        }
+        item.commitCharacters = (0, utils_2.getCommitCharactersForScriptElement)(comp.kind);
+        item.sortText = comp.sortText;
+        item.preselect = comp.isRecommended;
+        if (comp.replacementSpan) {
+            item.insertText = comp.insertText ? (0, utils_2.removeAstroComponentSuffix)(comp.insertText) : undefined;
+            item.insertTextFormat = comp.isSnippet ? vscode_languageserver_1.InsertTextFormat.Snippet : vscode_languageserver_1.InsertTextFormat.PlainText;
+            item.textEdit = comp.replacementSpan
+                ? vscode_languageserver_1.TextEdit.replace((0, utils_2.convertRange)(fragment, comp.replacementSpan), item.insertText ?? item.label)
+                : undefined;
+        }
         return {
-            label: comp.name,
-            insertText: comp.insertText,
-            kind: (0, utils_2.scriptElementKindToCompletionItemKind)(comp.kind),
-            commitCharacters: (0, utils_2.getCommitCharactersForScriptElement)(comp.kind),
-            // Make sure svelte component takes precedence
-            sortText: comp.sortText,
-            preselect: comp.isRecommended,
-            // pass essential data for resolving completion
+            ...item,
             data: {
-                ...comp,
-                uri,
-                position,
+                uri: fragment.getURL(),
+                filePath,
+                offset,
+                originalItem: comp,
             },
         };
     }
+    isValidCompletion(completion) {
+        // Remove completion for default exported function
+        if (completion.name === 'default' && completion.kindModifiers == typescript_1.ScriptElementKindModifier.exportedModifier) {
+            return false;
+        }
+        return true;
+    }
     getCompletionDocument(compDetail) {
-        const { source, documentation: tsDocumentation, displayParts, tags } = compDetail;
-        let detail = typescript_1.default.displayPartsToString(displayParts);
-        if (source) {
-            const importPath = typescript_1.default.displayPartsToString(source);
-            detail = `Auto import from ${importPath}\n${detail}`;
-        }
-        const documentation = tsDocumentation
-            ? { value: tsDocumentation.join('\n'), kind: vscode_languageserver_1.MarkupKind.Markdown }
-            : undefined;
+        const { sourceDisplay, documentation: tsDocumentation, displayParts } = compDetail;
+        let detail = (0, utils_2.removeAstroComponentSuffix)(typescript_1.default.displayPartsToString(displayParts));
+        if (sourceDisplay) {
+            const importPath = typescript_1.default.displayPartsToString(sourceDisplay);
+            detail = importPath;
+        }
+        const documentation = {
+            kind: 'markdown',
+            value: (0, previewer_1.getMarkdownDocumentation)(tsDocumentation, compDetail.tags),
+        };
         return {
             documentation,
             detail,
         };
     }
+    /**
+     * 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
+     */
+    fixTextEditRange(wordRangePosition, completionItem) {
+        const { textEdit } = completionItem;
+        if (!textEdit || !vscode_languageserver_1.TextEdit.is(textEdit) || !wordRangePosition) {
+            return completionItem;
+        }
+        const { newText, range: { start }, } = textEdit;
+        const wordRangeStartCharacter = wordRangePosition.character;
+        if (wordRangePosition.line !== wordRangePosition.line || start.character > wordRangePosition.character) {
+            return completionItem;
+        }
+        textEdit.newText = newText.substring(wordRangeStartCharacter - start.character);
+        textEdit.range.start = {
+            line: start.line,
+            character: wordRangeStartCharacter,
+        };
+        completionItem.additionalTextEdits = [
+            vscode_languageserver_1.TextEdit.replace({
+                start,
+                end: {
+                    line: start.line,
+                    character: wordRangeStartCharacter,
+                },
+            }, newText.substring(0, wordRangeStartCharacter - start.character)),
+        ];
+        return completionItem;
+    }
+    canReuseLastCompletion(lastCompletion, triggerKind, triggerCharacter, document, position) {
+        return (!!lastCompletion &&
+            lastCompletion.key === document.getFilePath() &&
+            lastCompletion.position.line === position.line &&
+            Math.abs(lastCompletion.position.character - position.character) < 2 &&
+            (triggerKind === vscode_languageserver_1.CompletionTriggerKind.TriggerForIncompleteCompletions ||
+                // Special case: `.` is a trigger character, but inside import path completions
+                // it shouldn't trigger another completion because we can reuse the old one
+                (triggerCharacter === '.' && (0, utils_4.isPartOfImportStatement)(document.getText(), position))));
+    }
+    getExistingImports(document) {
+        const rawImports = (0, utils_3.getRegExpMatches)(scriptImportRegex, document.getText()).map((match) => (match[1] ?? match[2]).split(','));
+        const tidiedImports = (0, lodash_1.flatten)(rawImports).map((match) => match.trim());
+        return new Set(tidiedImports);
+    }
+    isAstroComponentImport(className) {
+        return className.endsWith('__AstroComponent_');
+    }
 }
 exports.CompletionsProviderImpl = CompletionsProviderImpl;
+function codeActionChangeToTextEdit(document, fragment, change) {
+    change.newText = (0, utils_2.removeAstroComponentSuffix)(change.newText);
+    // If we don't have a frontmatter already, create one with the import
+    const frontmatterState = document.astroMeta.frontmatter.state;
+    if (frontmatterState === null) {
+        return vscode_languageserver_1.TextEdit.replace(vscode_languageserver_1.Range.create(vscode_languageserver_1.Position.create(0, 0), vscode_languageserver_1.Position.create(0, 0)), `---${typescript_1.default.sys.newLine}${change.newText}---${typescript_1.default.sys.newLine}${typescript_1.default.sys.newLine}`);
+    }
+    const { span } = change;
+    let range;
+    const virtualRange = (0, utils_2.convertRange)(fragment, span);
+    range = (0, documents_1.mapRangeToOriginal)(fragment, virtualRange);
+    if (!(0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(range.start))) {
+        range = (0, utils_2.ensureFrontmatterInsert)(range, document);
+    }
+    // First import in a file will wrongly have a newline before it due to how the frontmatter is replaced by a comment
+    if (range.start.line === 1 && (change.newText.startsWith('\n') || change.newText.startsWith('\r\n'))) {
+        change.newText = change.newText.trimStart();
+    }
+    return vscode_languageserver_1.TextEdit.replace(range, change.newText);
+}
+exports.codeActionChangeToTextEdit = codeActionChangeToTextEdit;

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

@@ -0,0 +1,9 @@
+import { Position, LocationLink } from 'vscode-languageserver-types';
+import { AstroDocument } from '../../../core/documents';
+import { DefinitionsProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class DefinitionsProviderImpl implements DefinitionsProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getDefinitions(document: AstroDocument, position: Position): Promise<LocationLink[]>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionsProviderImpl = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class DefinitionsProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getDefinitions(document, position) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const tsFilePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragmentPosition = mainFragment.getGeneratedPosition(position);
+        const fragmentOffset = mainFragment.offsetAt(fragmentPosition);
+        const defs = lang.getDefinitionAndBoundSpan(tsFilePath, fragmentOffset);
+        if (!defs || !defs.definitions) {
+            return [];
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsFilePath, { fragment: mainFragment, snapshot: tsDoc });
+        const result = await Promise.all(defs.definitions.map(async (def) => {
+            const { fragment, snapshot } = await docs.retrieve(def.fileName);
+            const fileName = (0, utils_2.ensureRealFilePath)(def.fileName);
+            // For Astro, Svelte and Vue, the position is wrongly mapped to the end of the file due to the TSX output
+            // So we'll instead redirect to the beginning of the file
+            const isFramework = (0, utils_2.isFrameworkFilePath)(def.fileName) || (0, utils_2.isAstroFilePath)(def.fileName);
+            const textSpan = isFramework && tsDoc.filePath !== def.fileName ? { start: 0, length: 0 } : def.textSpan;
+            return vscode_languageserver_types_1.LocationLink.create((0, utils_1.pathToUrl)(fileName), (0, utils_2.convertToLocationRange)(fragment, textSpan), (0, utils_2.convertToLocationRange)(fragment, textSpan), (0, utils_2.convertToLocationRange)(mainFragment, defs.textSpan));
+        }));
+        return result.filter(utils_1.isNotNullOrUndefined);
+    }
+}
+exports.DefinitionsProviderImpl = DefinitionsProviderImpl;

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

@@ -13,10 +13,9 @@ class DiagnosticsProviderImpl {
         this.languageServiceManager = languageServiceManager;
     }
     async getDiagnostics(document, _cancellationToken) {
-        var _a, _b;
         // Don't return diagnostics for files inside node_modules. These are considered read-only
         // and they would pollute the output for astro check
-        if (((_a = document.getFilePath()) === null || _a === void 0 ? void 0 : _a.includes('/node_modules/')) || ((_b = document.getFilePath()) === null || _b === void 0 ? void 0 : _b.includes('\\node_modules\\'))) {
+        if (document.getFilePath()?.includes('/node_modules/') || document.getFilePath()?.includes('\\node_modules\\')) {
             return [];
         }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -53,7 +52,7 @@ class DiagnosticsProviderImpl {
     }
     getTagBoundaries(lang, tsFilePath) {
         const program = lang.getProgram();
-        const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(tsFilePath);
+        const sourceFile = program?.getSourceFile(tsFilePath);
         const boundaries = {
             script: [],
             markdown: [],

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

@@ -11,7 +11,6 @@ class DocumentSymbolsProviderImpl {
         this.languageServiceManager = languageServiceManager;
     }
     async getDocumentSymbols(document) {
-        var _a, _b, _c;
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const fragment = await tsDoc.createFragment();
         const navTree = lang.getNavigationTree(tsDoc.filePath);
@@ -27,23 +26,23 @@ class DocumentSymbolsProviderImpl {
             result.push(vscode_languageserver_types_1.SymbolInformation.create('Frontmatter', vscode_languageserver_types_1.SymbolKind.Namespace, vscode_languageserver_types_1.Range.create(document.positionAt(document.astroMeta.frontmatter.startOffset), document.positionAt(document.astroMeta.frontmatter.endOffset)), document.getURL()));
         }
         // Add a "Template" namespace for everything under the frontmatter
-        result.push(vscode_languageserver_types_1.SymbolInformation.create('Template', vscode_languageserver_types_1.SymbolKind.Namespace, vscode_languageserver_types_1.Range.create(document.positionAt((_a = document.astroMeta.frontmatter.endOffset) !== null && _a !== void 0 ? _a : 0), document.positionAt(document.getTextLength())), document.getURL()));
+        result.push(vscode_languageserver_types_1.SymbolInformation.create('Template', vscode_languageserver_types_1.SymbolKind.Namespace, vscode_languageserver_types_1.Range.create(document.positionAt(document.astroMeta.frontmatter.endOffset ?? 0), document.positionAt(document.getTextLength())), document.getURL()));
         for (let symbol of symbols.splice(1)) {
             symbol = (0, documents_1.mapSymbolInformationToOriginal)(fragment, symbol);
-            if (document.offsetAt(symbol.location.range.end) >= ((_b = document.astroMeta.content.firstNonWhitespaceOffset) !== null && _b !== void 0 ? _b : 0)) {
+            if (document.offsetAt(symbol.location.range.end) >= (document.astroMeta.content.firstNonWhitespaceOffset ?? 0)) {
                 if (symbol.containerName === originalContainerName) {
                     symbol.containerName = 'Template';
                 }
                 // For some reason, it seems like TypeScript thinks that the "class" attribute is a real class, weird
                 if (symbol.kind === vscode_languageserver_types_1.SymbolKind.Class && symbol.name === '<class>') {
                     const node = document.html.findNodeAt(document.offsetAt(symbol.location.range.start));
-                    if ((_c = node.attributes) === null || _c === void 0 ? void 0 : _c.class) {
+                    if (node.attributes?.class) {
                         continue;
                     }
                 }
             }
-            // Remove the default function detected in our TSX output
-            if (symbol.kind === vscode_languageserver_types_1.SymbolKind.Function && symbol.name == 'default') {
+            // Remove the exported function in our TSX output from the symbols
+            if (document.offsetAt(symbol.location.range.start) >= document.getTextLength()) {
                 continue;
             }
             result.push(symbol);

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

@@ -0,0 +1,9 @@
+import { FoldingRange } from 'vscode-languageserver';
+import { AstroDocument } from '../../../core/documents';
+import { FoldingRangesProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class FoldingRangesProviderImpl implements FoldingRangesProvider {
+    private readonly languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoldingRangesProviderImpl = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const vscode_languageserver_1 = require("vscode-languageserver");
+const utils_1 = require("../utils");
+class FoldingRangesProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getFoldingRanges(document) {
+        const html = document.html;
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        const outliningSpans = lang.getOutliningSpans(filePath);
+        const foldingRanges = [];
+        for (const span of outliningSpans) {
+            const node = html.findNodeAt(span.textSpan.start);
+            // Due to how our TSX output transform those tags into function calls or template literals
+            // TypeScript thinks of those as outlining spans, which is fine but we don't want folding ranges for those
+            if (node.tag === 'script' || node.tag === 'Markdown' || node.tag === 'style') {
+                continue;
+            }
+            const start = document.positionAt(span.textSpan.start);
+            const end = adjustFoldingEnd(start, document.positionAt(span.textSpan.start + span.textSpan.length), document);
+            // When using this method for generating folding ranges, TypeScript tend to return some
+            // one line / one character ones that we should be able to safely ignore
+            if (start.line === end.line && start.character === end.character) {
+                continue;
+            }
+            foldingRanges.push(vscode_languageserver_1.FoldingRange.create(start.line, end.line, start.character, end.character, transformFoldingRangeKind(span.kind)));
+        }
+        return foldingRanges;
+    }
+}
+exports.FoldingRangesProviderImpl = FoldingRangesProviderImpl;
+function transformFoldingRangeKind(tsKind) {
+    switch (tsKind) {
+        case typescript_1.default.OutliningSpanKind.Comment:
+            return vscode_languageserver_1.FoldingRangeKind.Comment;
+        case typescript_1.default.OutliningSpanKind.Imports:
+            return vscode_languageserver_1.FoldingRangeKind.Imports;
+        case typescript_1.default.OutliningSpanKind.Region:
+            return vscode_languageserver_1.FoldingRangeKind.Region;
+    }
+}
+// https://github.com/microsoft/vscode/blob/bed61166fb604e519e82e4d1d1ed839bc45d65f8/extensions/typescript-language-features/src/languageFeatures/folding.ts#L61-L73
+function adjustFoldingEnd(start, end, document) {
+    // workaround for #47240
+    if (end.character > 0) {
+        const foldEndCharacter = document.getText({
+            start: { line: end.line, character: end.character - 1 },
+            end,
+        });
+        if (['}', ']', ')', '`'].includes(foldEndCharacter)) {
+            const endOffset = Math.max(document.offsetAt({ line: end.line, character: 0 }) - 1, document.offsetAt(start));
+            return document.positionAt(endOffset);
+        }
+    }
+    return end;
+}

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

@@ -15,7 +15,7 @@ class SemanticTokensProviderImpl {
     async getSemanticTokens(document, range, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const fragment = (await tsDoc.createFragment());
-        if (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested) {
+        if (cancellationToken?.isCancellationRequested) {
             return null;
         }
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
@@ -25,7 +25,7 @@ class SemanticTokensProviderImpl {
             length: range
                 ? fragment.offsetAt(fragment.getGeneratedPosition(range.end)) - start
                 : // We don't want tokens for things added by astro2tsx
-                    fragment.text.lastIndexOf('export default function (_props:') || fragment.text.length,
+                    fragment.text.lastIndexOf('export default function ') || fragment.text.length,
         }, typescript_1.default.SemanticClassificationFormat.TwentyTwenty);
         const tokens = [];
         let i = 0;

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

@@ -15,7 +15,7 @@ class SignatureHelpProviderImpl {
     async getSignatureHelp(document, position, context, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const fragment = await tsDoc.createFragment();
-        if (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested) {
+        if (cancellationToken?.isCancellationRequested) {
             return null;
         }
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
@@ -44,7 +44,7 @@ class SignatureHelpProviderImpl {
      * adopted from https://github.com/microsoft/vscode/blob/265a2f6424dfbd3a9788652c7d376a7991d049a3/extensions/typescript-language-features/src/languageFeatures/signatureHelp.ts#L103
      */
     toTsTriggerReason(context) {
-        switch (context === null || context === void 0 ? void 0 : context.triggerKind) {
+        switch (context?.triggerKind) {
             case vscode_languageserver_1.SignatureHelpTriggerKind.TriggerCharacter:
                 if (context.triggerCharacter) {
                     if (this.isReTrigger(context.isRetrigger, context.triggerCharacter)) {

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

@@ -1,5 +1,8 @@
 import type { SnapshotFragment, DocumentSnapshot } from '../snapshots/DocumentSnapshot';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
+import { Position } from 'vscode-languageserver';
+import ts from 'typescript';
+export declare function isPartOfImportStatement(text: string, position: Position): boolean;
 export declare class SnapshotFragmentMap {
     private languageServiceManager;
     private map;
@@ -19,3 +22,4 @@ export declare class SnapshotFragmentMap {
     }>;
     retrieveFragment(fileName: string): Promise<SnapshotFragment>;
 }
+export declare function findContainingNode<T extends ts.Node>(node: ts.Node, textSpan: ts.TextSpan, predicate: (node: ts.Node) => node is T): T | undefined;

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

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnapshotFragmentMap = void 0;
+exports.findContainingNode = exports.SnapshotFragmentMap = exports.isPartOfImportStatement = void 0;
+const documents_1 = require("../../../core/documents");
+function isPartOfImportStatement(text, position) {
+    const line = (0, documents_1.getLineAtPosition)(position, text);
+    return /\s*from\s+["'][^"']*/.test(line.slice(0, position.character));
+}
+exports.isPartOfImportStatement = isPartOfImportStatement;
 class SnapshotFragmentMap {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
@@ -13,8 +19,7 @@ class SnapshotFragmentMap {
         return this.map.get(fileName);
     }
     getFragment(fileName) {
-        var _a;
-        return (_a = this.map.get(fileName)) === null || _a === void 0 ? void 0 : _a.fragment;
+        return this.map.get(fileName)?.fragment;
     }
     async retrieve(fileName) {
         let snapshotFragment = this.get(fileName);
@@ -31,3 +36,20 @@ class SnapshotFragmentMap {
     }
 }
 exports.SnapshotFragmentMap = SnapshotFragmentMap;
+function findContainingNode(node, textSpan, predicate) {
+    const children = node.getChildren();
+    const end = textSpan.start + textSpan.length;
+    for (const child of children) {
+        if (!(child.getStart() <= textSpan.start && child.getEnd() >= end)) {
+            continue;
+        }
+        if (predicate(child)) {
+            return child;
+        }
+        const foundInChildren = findContainingNode(child, textSpan, predicate);
+        if (foundInChildren) {
+            return foundInChildren;
+        }
+    }
+}
+exports.findContainingNode = findContainingNode;