@astrojs/language-server 0.16.0 → 0.18.0

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

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeActionChangeToTextEdit = exports.CompletionsProviderImpl = exports.completionOptions = void 0;
+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");
@@ -35,22 +35,13 @@ 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) {
+    constructor(languageServiceManager, configManager) {
         this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
         this.validTriggerCharacters = ['.', '"', "'", '`', '/', '@', '<', '#'];
     }
     isValidTriggerCharacter(character) {
@@ -74,35 +65,64 @@ class CompletionsProviderImpl {
         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 { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        let filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        let completions;
         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;
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const formatOptions = await this.configManager.getTSFormatConfig(document);
+        let scriptTagIndex = undefined;
+        if (node.tag === 'script') {
+            const { filePath: scriptFilePath, offset: scriptOffset, index: scriptIndex, } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node, position);
+            filePath = scriptFilePath;
+            scriptTagIndex = scriptIndex;
+            completions = lang.getCompletionsAtPosition(scriptFilePath, scriptOffset, {
+                ...tsPreferences,
+                // File extensions are required inside script tags, however TypeScript can't return completions with the `ts`
+                // extension, so what we'll do instead is force `minimal` (aka, no extension) and manually add the extensions
+                importModuleSpecifierEnding: 'minimal',
+                triggerCharacter: validTriggerCharacter,
+            }, formatOptions);
+            if (completions) {
+                // Manually adds file extensions to js and ts files
+                completions.entries = completions?.entries.map((comp) => {
+                    if (comp.kind === typescript_1.ScriptElementKind.scriptElement &&
+                        (comp.kindModifiers === '.js' || comp.kindModifiers === '.ts')) {
+                        return {
+                            ...comp,
+                            name: comp.name + comp.kindModifiers,
+                        };
+                    }
+                    else {
+                        return comp;
+                    }
+                });
+            }
         }
-        // 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;
+        else {
+            // 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;
+            }
+            completions = lang.getCompletionsAtPosition(filePath, offset, {
+                ...tsPreferences,
+                triggerCharacter: validTriggerCharacter,
+            }, formatOptions);
         }
-        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;
         }
@@ -114,7 +134,7 @@ class CompletionsProviderImpl {
         const existingImports = this.getExistingImports(document);
         const completionItems = completions.entries
             .filter(this.isValidCompletion)
-            .map((entry) => this.toCompletionItem(fragment, entry, filePath, offset, isCompletionInsideFrontmatter, existingImports))
+            .map((entry) => this.toCompletionItem(fragment, entry, filePath, offset, isCompletionInsideFrontmatter, scriptTagIndex, existingImports))
             .filter(utils_3.isNotNullOrUndefined)
             .map((comp) => this.fixTextEditRange(wordRangeStartPosition, comp));
         const completionList = vscode_languageserver_2.CompletionList.create(completionItems, true);
@@ -123,6 +143,7 @@ class CompletionsProviderImpl {
     }
     async resolveCompletion(document, item, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const tsPreferences = await this.configManager.getTSPreferences(document);
         const data = item.data;
         if (!data || !data.filePath || cancellationToken?.isCancellationRequested) {
             return item;
@@ -133,27 +154,42 @@ class CompletionsProviderImpl {
         data.originalItem.name, // entryName
         {}, // formatOptions
         data.originalItem.source, // source
-        exports.completionOptions, // preferences
+        tsPreferences, // preferences
         data.originalItem.data // data
         );
         if (detail) {
             const { detail: itemDetail, documentation: itemDocumentation } = this.getCompletionDocument(detail);
+            // TODO: Add support for labelDetails
+            // if (data.originalItem.source) {
+            // 	item.labelDetails = { description: data.originalItem.source };
+            // }
             item.detail = itemDetail;
             item.documentation = itemDocumentation;
         }
         const actions = detail?.codeActions;
+        const isInsideScriptTag = data.scriptTagIndex !== undefined;
+        let scriptTagSnapshot;
+        if (isInsideScriptTag) {
+            const { snapshot } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, document.scriptTags[data.scriptTagIndex].container);
+            scriptTagSnapshot = snapshot;
+        }
         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)));
+                    if (isInsideScriptTag) {
+                        change.textChanges.forEach((textChange) => {
+                            textChange.span.start = fragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(textChange.span.start)));
+                        });
+                    }
+                    edit.push(...change.textChanges.map((textChange) => codeActionChangeToTextEdit(document, fragment, isInsideScriptTag, textChange)));
                 }
             }
             item.additionalTextEdits = (item.additionalTextEdits ?? []).concat(edit);
         }
         return item;
     }
-    toCompletionItem(fragment, comp, filePath, offset, insideFrontmatter, existingImports) {
+    toCompletionItem(fragment, comp, filePath, offset, insideFrontmatter, scriptTagIndex, existingImports) {
         let item = vscode_languageserver_protocol_1.CompletionItem.create(comp.name);
         const isAstroComponent = this.isAstroComponentImport(comp.name);
         const isImport = comp.insertText?.includes('import');
@@ -177,14 +213,23 @@ class CompletionsProviderImpl {
         }
         if (comp.kindModifiers) {
             const kindModifiers = new Set(comp.kindModifiers.split(/,|\s+/g));
+            if (kindModifiers.has(typescript_1.ScriptElementKindModifier.optionalModifier)) {
+                if (!item.insertText) {
+                    item.insertText = item.label;
+                }
+                if (!item.filterText) {
+                    item.filterText = item.label;
+                }
+                item.label += '?';
+            }
             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) };
-        }
+        // TODO: Add support for labelDetails
+        // if (comp.sourceDisplay) {
+        // 	item.labelDetails = { description: ts.displayPartsToString(comp.sourceDisplay) };
+        // }
         item.commitCharacters = (0, utils_2.getCommitCharactersForScriptElement)(comp.kind);
         item.sortText = comp.sortText;
         item.preselect = comp.isRecommended;
@@ -200,6 +245,7 @@ class CompletionsProviderImpl {
             data: {
                 uri: fragment.getURL(),
                 filePath,
+                scriptTagIndex,
                 offset,
                 originalItem: comp,
             },
@@ -279,23 +325,33 @@ class CompletionsProviderImpl {
     }
 }
 exports.CompletionsProviderImpl = CompletionsProviderImpl;
-function codeActionChangeToTextEdit(document, fragment, change) {
+function codeActionChangeToTextEdit(document, fragment, isInsideScriptTag, 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);
+    if (!isInsideScriptTag) {
+        // 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}`);
+        }
+        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();
+        }
     }
-    // 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();
+    else {
+        const existingLine = (0, utils_1.getLineAtPosition)(document.positionAt(span.start), document.getText());
+        const isNewImport = !existingLine.trim().startsWith('import');
+        // Avoid putting new imports on the same line as the script tag opening
+        if (!(change.newText.startsWith('\n') || change.newText.startsWith('\r\n')) && isNewImport) {
+            change.newText = typescript_1.default.sys.newLine + change.newText;
+        }
     }
     return vscode_languageserver_1.TextEdit.replace(range, change.newText);
 }

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,57 @@
+"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);
+        let defs;
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        const node = html.findNodeAt(offset);
+        if (node.tag === 'script') {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath, offset: scriptOffset, } = (0, utils_2.getScriptTagSnapshot)(tsDoc, document, node, position);
+            defs = lang.getDefinitionAndBoundSpan(scriptFilePath, scriptOffset);
+            if (defs) {
+                defs.definitions = defs.definitions?.map((def) => {
+                    const isInSameFile = def.fileName === scriptFilePath;
+                    def.fileName = isInSameFile ? tsFilePath : def.fileName;
+                    if (isInSameFile) {
+                        def.textSpan.start = mainFragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(def.textSpan.start)));
+                    }
+                    return def;
+                });
+                defs.textSpan.start = mainFragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(defs.textSpan.start)));
+            }
+        }
+        else {
+            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

@@ -20,24 +20,52 @@ class DiagnosticsProviderImpl {
         }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragment = await tsDoc.createFragment();
+        let scriptDiagnostics = [];
+        document.scriptTags.forEach((scriptTag) => {
+            const { filePath: scriptFilePath, snapshot: scriptTagSnapshot } = (0, utils_1.getScriptTagSnapshot)(tsDoc, document, scriptTag.container);
+            const scriptDiagnostic = [
+                ...lang.getSyntacticDiagnostics(scriptFilePath),
+                ...lang.getSuggestionDiagnostics(scriptFilePath),
+                ...lang.getSemanticDiagnostics(scriptFilePath),
+            ]
+                // We need to duplicate the diagnostic creation here because we can't map TS's diagnostics range to the original
+                // file due to some internal cache inside TS that would cause it to being mapped twice in some cases
+                .map((diagnostic) => ({
+                range: (0, utils_1.convertRange)(scriptTagSnapshot, diagnostic),
+                severity: (0, utils_1.mapSeverity)(diagnostic.category),
+                source: 'ts',
+                message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
+                code: diagnostic.code,
+                tags: getDiagnosticTag(diagnostic),
+            }))
+                .map(mapRange(scriptTagSnapshot, document));
+            scriptDiagnostics.push(...scriptDiagnostic);
+        });
         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 isNoWithinBoundary(scriptBoundaries, d);
+        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath);
+        const diagnostics = [
+            ...syntaxDiagnostics,
+            ...suggestionDiagnostics,
+            ...semanticDiagnostics,
+        ].filter((diag) => {
+            return isNoWithinBoundary(scriptBoundaries, diag);
         });
-        const diagnostics = [...syntaxDiagnostics, ...suggestionDiagnostics, ...semanticDiagnostics];
-        const fragment = await tsDoc.createFragment();
-        return diagnostics
-            .map((diagnostic) => ({
-            range: (0, utils_1.convertRange)(tsDoc, diagnostic),
-            severity: (0, utils_1.mapSeverity)(diagnostic.category),
-            source: 'ts',
-            message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
-            code: diagnostic.code,
-            tags: getDiagnosticTag(diagnostic),
-        }))
-            .map(mapRange(fragment, document))
+        return [
+            ...diagnostics
+                .map((diagnostic) => ({
+                range: (0, utils_1.convertRange)(tsDoc, diagnostic),
+                severity: (0, utils_1.mapSeverity)(diagnostic.category),
+                source: 'ts',
+                message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
+                code: diagnostic.code,
+                tags: getDiagnosticTag(diagnostic),
+            }))
+                .map(mapRange(fragment, document)),
+            ...scriptDiagnostics,
+        ]
             .filter((diag) => {
             return (hasNoNegativeLines(diag) &&
                 isNoJSXImplicitRuntimeWarning(diag) &&
@@ -46,6 +74,7 @@ class DiagnosticsProviderImpl {
                 isNoSpreadExpected(diag) &&
                 isNoCantResolveJSONModule(diag) &&
                 isNoCantReturnOutsideFunction(diag) &&
+                isNoIsolatedModuleError(diag) &&
                 isNoJsxCannotHaveMultipleAttrsError(diag));
         })
             .map(enhanceIfNecessary);
@@ -146,12 +175,26 @@ function isNoCantReturnOutsideFunction(diagnostic) {
 function isNoCantResolveJSONModule(diagnostic) {
     return diagnostic.code !== 2732;
 }
+/**
+ * When the content of the file is invalid and can't be parsed properly for TSX generation, TS will show an error about
+ * how the current module can't be compiled under --isolatedModule, this is confusing to users so let's ignore this
+ */
+function isNoIsolatedModuleError(diagnostic) {
+    return diagnostic.code !== 1208;
+}
 /**
  * Some diagnostics have JSX-specific nomenclature or unclear description. Enhance them for more clarity.
  */
 function enhanceIfNecessary(diagnostic) {
+    // JSX element has no closing tag. JSX -> HTML
+    if (diagnostic.code === 17008) {
+        return {
+            ...diagnostic,
+            message: diagnostic.message.replace('JSX', 'HTML'),
+        };
+    }
+    // For the rare case where an user might try to put a client directive on something that is not a component
     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,

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

@@ -15,15 +15,22 @@ class FoldingRangesProviderImpl {
         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 outliningSpans = lang.getOutliningSpans(filePath).filter((span) => {
             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;
-            }
+            return node.tag !== 'script' && node.tag !== 'style' && node.tag !== 'Markdown';
+        });
+        const scriptOutliningSpans = [];
+        document.scriptTags.forEach((scriptTag) => {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath } = (0, utils_1.getScriptTagSnapshot)(tsDoc, document, scriptTag.container);
+            scriptOutliningSpans.push(...lang.getOutliningSpans(scriptFilePath).map((span) => {
+                span.textSpan.start = document.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(span.textSpan.start)));
+                return span;
+            }));
+        });
+        const foldingRanges = [];
+        for (const span of [...outliningSpans, ...scriptOutliningSpans]) {
             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

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

@@ -0,0 +1,11 @@
+import { FormattingOptions, TextEdit } from 'vscode-languageserver-types';
+import { ConfigManager } from '../../../core/config';
+import { AstroDocument } from '../../../core/documents';
+import { FormattingProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class FormattingProviderImpl implements FormattingProvider {
+    private languageServiceManager;
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
+    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
+}

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

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormattingProviderImpl = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const utils_1 = require("../utils");
+class FormattingProviderImpl {
+    constructor(languageServiceManager, configManager) {
+        this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
+    }
+    async formatDocument(document, options) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        const formatConfig = await this.configManager.getTSFormatConfig(document, options);
+        let frontmatterEdits = [];
+        let scriptTagsEdits = [];
+        if (document.astroMeta.frontmatter.state === 'closed') {
+            const start = document.positionAt(document.astroMeta.frontmatter.startOffset + 3);
+            start.line += 1;
+            start.character = 0;
+            const startOffset = document.offsetAt(start);
+            const endOffset = document.astroMeta.frontmatter.endOffset;
+            const astroFormatConfig = await this.configManager.getAstroFormatConfig(document);
+            const settings = {
+                ...formatConfig,
+                baseIndentSize: astroFormatConfig.indentFrontmatter ? formatConfig.tabSize ?? 0 : undefined,
+            };
+            frontmatterEdits = lang.getFormattingEditsForRange(filePath, startOffset, endOffset, settings);
+            if (astroFormatConfig.newLineAfterFrontmatter) {
+                const templateStart = document.positionAt(endOffset + 3);
+                templateStart.line += 1;
+                templateStart.character = 0;
+                frontmatterEdits.push({
+                    span: { start: document.offsetAt(templateStart), length: 0 },
+                    newText: '\n',
+                });
+            }
+        }
+        document.scriptTags.forEach((scriptTag) => {
+            const { filePath: scriptFilePath, snapshot: scriptTagSnapshot } = (0, utils_1.getScriptTagSnapshot)(tsDoc, document, scriptTag.container);
+            const startLine = document.offsetAt(vscode_languageserver_types_1.Position.create(scriptTag.startPos.line, 0));
+            const initialIndentLevel = computeInitialIndent(document, startLine, options);
+            const baseIndent = (formatConfig.tabSize ?? 0) * (initialIndentLevel + 1);
+            const formatSettings = {
+                baseIndentSize: baseIndent,
+                indentStyle: typescript_1.default.IndentStyle.Smart,
+                ...formatConfig,
+            };
+            let edits = lang.getFormattingEditsForDocument(scriptFilePath, formatSettings);
+            if (edits) {
+                edits = edits
+                    .map((edit) => {
+                    edit.span.start = document.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(edit.span.start)));
+                    return edit;
+                })
+                    .filter((edit) => {
+                    return (scriptTagSnapshot.isInGenerated(document.positionAt(edit.span.start)) &&
+                        scriptTag.end !== edit.span.start &&
+                        // Don't format the last line of the file as it's in most case the indentation
+                        scriptTag.endPos.line !== document.positionAt(edit.span.start).line);
+                });
+                const endLine = document.getLineUntilOffset(document.offsetAt(scriptTag.endPos));
+                if (isWhitespaceOnly(endLine)) {
+                    const endLineStartOffset = document.offsetAt(vscode_languageserver_types_1.Position.create(scriptTag.endPos.line, 0));
+                    const lastLineIndentRange = vscode_languageserver_types_1.Range.create(vscode_languageserver_types_1.Position.create(scriptTag.endPos.line, 0), scriptTag.endPos);
+                    const newText = generateIndent(initialIndentLevel, options);
+                    if (endLine !== newText) {
+                        edits.push({
+                            span: {
+                                start: endLineStartOffset,
+                                length: lastLineIndentRange.end.character,
+                            },
+                            newText,
+                        });
+                    }
+                }
+            }
+            scriptTagsEdits.push(...edits);
+        });
+        return [...frontmatterEdits, ...scriptTagsEdits].map((edit) => ({
+            range: (0, utils_1.convertRange)(document, edit.span),
+            newText: edit.newText,
+        }));
+    }
+}
+exports.FormattingProviderImpl = FormattingProviderImpl;
+function computeInitialIndent(document, lineStart, options) {
+    let content = document.getText();
+    let i = lineStart;
+    let nChars = 0;
+    let tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        let ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function generateIndent(level, options) {
+    if (options.insertSpaces) {
+        return repeat(' ', level * options.tabSize);
+    }
+    else {
+        return repeat('\t', level);
+    }
+}
+function repeat(value, count) {
+    let s = '';
+    while (count > 0) {
+        if ((count & 1) === 1) {
+            s += value;
+        }
+        value += value;
+        count = count >>> 1;
+    }
+    return s;
+}
+function isWhitespaceOnly(str) {
+    return /^\s*$/.test(str);
+}

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

@@ -18,7 +18,20 @@ class HoverProviderImpl {
         const fragment = await tsDoc.createFragment();
         const offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
-        let info = lang.getQuickInfoAtPosition(filePath, offset);
+        const html = document.html;
+        const documentOffset = document.offsetAt(position);
+        const node = html.findNodeAt(documentOffset);
+        let info;
+        if (node.tag === 'script') {
+            const { snapshot: scriptTagSnapshot, filePath: scriptFilePath, offset: scriptOffset, } = (0, utils_1.getScriptTagSnapshot)(tsDoc, document, node, position);
+            info = lang.getQuickInfoAtPosition(scriptFilePath, scriptOffset);
+            if (info) {
+                info.textSpan.start = fragment.offsetAt(scriptTagSnapshot.getOriginalPosition(scriptTagSnapshot.positionAt(info.textSpan.start)));
+            }
+        }
+        else {
+            info = lang.getQuickInfoAtPosition(filePath, offset);
+        }
         if (!info) {
             return null;
         }