@astrojs/language-server 0.13.4 → 0.16.0

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

@@ -1,92 +1,302 @@
 "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 = exports.completionOptions = 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({
+const utils_3 = require("../../../utils");
+const lodash_1 = require("lodash");
+const previewer_1 = require("../previewer");
+const utils_4 = require("./utils");
+exports.completionOptions = {
     importModuleSpecifierPreference: 'relative',
     importModuleSpecifierEnding: 'auto',
     quotePreference: 'single',
-});
+    includeCompletionsForModuleExports: true,
+    includeCompletionsForImportStatements: true,
+    includeCompletionsWithInsertText: true,
+    allowIncompleteCompletions: true,
+    includeCompletionsWithSnippetText: true,
+};
+// `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) {
         this.languageServiceManager = languageServiceManager;
+        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 { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const completions = lang.getCompletionsAtPosition(filePath, offset, {
+            ...exports.completionOptions,
+            triggerCharacter: validTriggerCharacter,
+        });
+        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 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
+        exports.completionOptions, // 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/DiagnosticsProvider.js

@@ -13,24 +13,21 @@ class DiagnosticsProviderImpl {
         this.languageServiceManager = languageServiceManager;
     }
     async getDiagnostics(document, _cancellationToken) {
-        var _a, _b, _c;
         // 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);
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
-        const { script: scriptBoundaries, markdown: markdownBoundaries } = this.getTagBoundaries(lang, filePath);
+        const { script: scriptBoundaries } = this.getTagBoundaries(lang, filePath);
         const syntaxDiagnostics = lang.getSyntacticDiagnostics(filePath);
         const suggestionDiagnostics = lang.getSuggestionDiagnostics(filePath);
         const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter((d) => {
-            return isNoWithinScript(scriptBoundaries, d);
+            return isNoWithinBoundary(scriptBoundaries, d);
         });
         const diagnostics = [...syntaxDiagnostics, ...suggestionDiagnostics, ...semanticDiagnostics];
         const fragment = await tsDoc.createFragment();
-        const sourceFile = (_c = lang.getProgram()) === null || _c === void 0 ? void 0 : _c.getSourceFile(filePath);
-        const isNoFalsePositiveInst = isNoFalsePositive();
         return diagnostics
             .map((diagnostic) => ({
             range: (0, utils_1.convertRange)(tsDoc, diagnostic),
@@ -43,20 +40,19 @@ class DiagnosticsProviderImpl {
             .map(mapRange(fragment, document))
             .filter((diag) => {
             return (hasNoNegativeLines(diag) &&
-                isNoFalsePositiveInst(diag) &&
                 isNoJSXImplicitRuntimeWarning(diag) &&
                 isNoJSXMustHaveOneParent(diag) &&
-                isNoCantUseJSX(diag) &&
                 isNoCantEndWithTS(diag) &&
                 isNoSpreadExpected(diag) &&
                 isNoCantResolveJSONModule(diag) &&
-                isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, markdownBoundaries, diag));
+                isNoCantReturnOutsideFunction(diag) &&
+                isNoJsxCannotHaveMultipleAttrsError(diag));
         })
             .map(enhanceIfNecessary);
     }
     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: [],
@@ -64,7 +60,7 @@ class DiagnosticsProviderImpl {
         if (!sourceFile) {
             return boundaries;
         }
-        function findScript(parent) {
+        function findTags(parent) {
             typescript_1.default.forEachChild(parent, (node) => {
                 if (typescript_1.default.isJsxElement(node)) {
                     let tagName = node.openingElement.tagName.getText();
@@ -80,10 +76,10 @@ class DiagnosticsProviderImpl {
                         }
                     }
                 }
-                findScript(node);
+                findTags(node);
             });
         }
-        findScript(sourceFile);
+        findTags(sourceFile);
         return boundaries;
     }
 }
@@ -116,33 +112,55 @@ function mapRange(fragment, _document) {
 function hasNoNegativeLines(diagnostic) {
     return diagnostic.range.start.line >= 0 && diagnostic.range.end.line >= 0;
 }
-function isNoFalsePositive() {
-    return (diagnostic) => {
-        return isNoJsxCannotHaveMultipleAttrsError(diagnostic);
-    };
-}
 /**
- * Jsx cannot have multiple attributes with same name,
- * but that's allowed for svelte
+ * Astro allows multiple attributes to have the same name
  */
 function isNoJsxCannotHaveMultipleAttrsError(diagnostic) {
     return diagnostic.code !== 17001;
 }
-function isNoJSXImplicitRuntimeWarning(diagnostic) {
-    return diagnostic.code !== 7016 && diagnostic.code !== 2792;
-}
+/** Astro allows component with multiple root elements */
 function isNoJSXMustHaveOneParent(diagnostic) {
     return diagnostic.code !== 2657;
 }
-function isNoCantUseJSX(diagnostic) {
-    return diagnostic.code !== 17004 && diagnostic.code !== 6142;
-}
+/** Astro allows `.ts` ending for imports, unlike TypeScript */
 function isNoCantEndWithTS(diagnostic) {
     return diagnostic.code !== 2691;
 }
 function isNoSpreadExpected(diagnostic) {
     return diagnostic.code !== 1005;
 }
+function isNoJSXImplicitRuntimeWarning(diagnostic) {
+    return diagnostic.code !== 7016 && diagnostic.code !== 2792;
+}
+/**
+ * Ignore "Can't return outside of function body"
+ * This is technically a valid diagnostic, but due to how we format our TSX, the frontmatter is at top-level so we have
+ * to ignore this. It wasn't a problem before because users didn't need to return things but they can now with SSR
+ */
+function isNoCantReturnOutsideFunction(diagnostic) {
+    return diagnostic.code !== 1108;
+}
+/**
+ * Astro allows users to import JSON modules
+ */
+function isNoCantResolveJSONModule(diagnostic) {
+    return diagnostic.code !== 2732;
+}
+/**
+ * Some diagnostics have JSX-specific nomenclature or unclear description. Enhance them for more clarity.
+ */
+function enhanceIfNecessary(diagnostic) {
+    if (diagnostic.code === 2322) {
+        // For the rare case where an user might try to put a client directive on something that is not a component
+        if (diagnostic.message.includes("Property 'client:") && diagnostic.message.includes("to type 'HTMLProps")) {
+            return {
+                ...diagnostic,
+                message: 'Client directives are only available on framework components',
+            };
+        }
+    }
+    return diagnostic;
+}
 function isWithinBoundaries(boundaries, start) {
     for (let [bstart, bend] of boundaries) {
         if (start > bstart && start < bend) {
@@ -163,39 +181,6 @@ function diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic) {
     let pos = typescript_1.default.getPositionOfLineAndCharacter(sourceFile, startRange.line, startRange.character);
     return isWithinBoundaries(boundaries, pos);
 }
-function isNoWithinScript(boundaries, diagnostic) {
+function isNoWithinBoundary(boundaries, diagnostic) {
     return !diagnosticIsWithinBoundaries(undefined, boundaries, diagnostic);
 }
-/**
- * This allows us to have JSON module imports.
- */
-function isNoCantResolveJSONModule(diagnostic) {
-    return diagnostic.code !== 2732;
-}
-/**
- * This is for using > within a markdown component like:
- * <Markdown>
- *   > Blockquote here.
- * </Markdown>
- */
-function isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, boundaries, diagnostic) {
-    if (diagnostic.code !== 1382) {
-        return true;
-    }
-    return !diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic);
-}
-/**
- * Some diagnostics have JSX-specific nomenclature. Enhance them for more clarity.
- */
-function enhanceIfNecessary(diagnostic) {
-    if (diagnostic.code === 2322) {
-        // For the rare case where an user might try to put a client directive on something that is not a component
-        if (diagnostic.message.includes("Property 'client:") && diagnostic.message.includes("to type 'HTMLProps")) {
-            return {
-                ...diagnostic,
-                message: 'Client directives are only available on framework components',
-            };
-        }
-    }
-    return diagnostic;
-}

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;
+}