@astrojs/language-server 0.15.0 → 0.17.0

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

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

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

@@ -4,14 +4,17 @@ import { AstroDocument } from '../../../core/documents';
 import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
 import { AstroSnapshotFragment } from '../snapshots/DocumentSnapshot';
+import { ConfigManager } from '../../../core/config';
 export interface CompletionItemData extends TextDocumentIdentifier {
     filePath: string;
     offset: number;
+    scriptTagIndex: number | undefined;
     originalItem: ts.CompletionEntry;
 }
 export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionItemData> {
     private languageServiceManager;
-    constructor(languageServiceManager: LanguageServiceManager);
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
     private readonly validTriggerCharacters;
     private isValidTriggerCharacter;
     private lastCompletion?;
@@ -19,7 +22,6 @@ export declare class CompletionsProviderImpl implements CompletionsProvider<Comp
     resolveCompletion(document: AstroDocument, item: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     private toCompletionItem;
     private isValidCompletion;
-    codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, change: ts.TextChange): TextEdit;
     private getCompletionDocument;
     /**
      * If the textEdit is out of the word range of the triggered position
@@ -31,3 +33,4 @@ export declare class CompletionsProviderImpl implements CompletionsProvider<Comp
     private getExistingImports;
     private isAstroComponentImport;
 }
+export declare function codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, isInsideScriptTag: boolean, change: ts.TextChange): TextEdit;

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.CompletionsProviderImpl = 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,33 +35,24 @@ const utils_3 = require("../../../utils");
 const lodash_1 = require("lodash");
 const previewer_1 = require("../previewer");
 const utils_4 = require("./utils");
-const 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) {
         return this.validTriggerCharacters.includes(character);
     }
     async getCompletions(document, position, completionContext, cancellationToken) {
-        const triggerCharacter = completionContext === null || completionContext === void 0 ? void 0 : completionContext.triggerCharacter;
-        const triggerKind = completionContext === null || completionContext === void 0 ? void 0 : completionContext.triggerKind;
+        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 === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested)) {
+        if ((isCustomTriggerCharacter && !validTriggerCharacter) || cancellationToken?.isCancellationRequested) {
             return null;
         }
         if (this.canReuseLastCompletion(this.lastCompletion, triggerKind, triggerCharacter, document, position)) {
@@ -74,47 +65,76 @@ 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, {
-            ...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 === null || wordRange === void 0 ? void 0 : wordRange.start;
+        const wordRangeStartPosition = wordRange?.start;
         const fragment = await tsDoc.createFragment();
         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);
@@ -122,10 +142,10 @@ class CompletionsProviderImpl {
         return completionList;
     }
     async resolveCompletion(document, item, cancellationToken) {
-        var _a;
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const tsPreferences = await this.configManager.getTSPreferences(document);
         const data = item.data;
-        if (!data || !data.filePath || (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested)) {
+        if (!data || !data.filePath || cancellationToken?.isCancellationRequested) {
             return item;
         }
         const fragment = await tsDoc.createFragment();
@@ -134,7 +154,7 @@ class CompletionsProviderImpl {
         data.originalItem.name, // entryName
         {}, // formatOptions
         data.originalItem.source, // source
-        completionOptions, // preferences
+        tsPreferences, // preferences
         data.originalItem.data // data
         );
         if (detail) {
@@ -142,23 +162,33 @@ class CompletionsProviderImpl {
             item.detail = itemDetail;
             item.documentation = itemDocumentation;
         }
-        const actions = detail === null || detail === void 0 ? void 0 : detail.codeActions;
+        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) => this.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 = ((_a = item.additionalTextEdits) !== null && _a !== void 0 ? _a : []).concat(edit);
+            item.additionalTextEdits = (item.additionalTextEdits ?? []).concat(edit);
         }
         return item;
     }
-    toCompletionItem(fragment, comp, filePath, offset, insideFrontmatter, existingImports) {
-        var _a, _b, _c;
+    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 = (_a = comp.insertText) === null || _a === void 0 ? void 0 : _a.includes('import');
+        const isImport = comp.insertText?.includes('import');
         // Avoid showing completions for using components as functions
         if (isAstroComponent && !isImport && insideFrontmatter) {
             return null;
@@ -167,7 +197,7 @@ class CompletionsProviderImpl {
             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 = (_b = comp.data) === null || _b === void 0 ? void 0 : _b.moduleSpecifier;
+            item.detail = comp.data?.moduleSpecifier;
         }
         else {
             item.kind = (0, utils_2.scriptElementKindToCompletionItemKind)(comp.kind);
@@ -194,7 +224,7 @@ class CompletionsProviderImpl {
             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), (_c = item.insertText) !== null && _c !== void 0 ? _c : item.label)
+                ? vscode_languageserver_1.TextEdit.replace((0, utils_2.convertRange)(fragment, comp.replacementSpan), item.insertText ?? item.label)
                 : undefined;
         }
         return {
@@ -202,6 +232,7 @@ class CompletionsProviderImpl {
             data: {
                 uri: fragment.getURL(),
                 filePath,
+                scriptTagIndex,
                 offset,
                 originalItem: comp,
             },
@@ -214,20 +245,6 @@ class CompletionsProviderImpl {
         }
         return true;
     }
-    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);
-        range = (0, utils_2.ensureFrontmatterInsert)(range, document);
-        return vscode_languageserver_1.TextEdit.replace(range, change.newText);
-    }
     getCompletionDocument(compDetail) {
         const { sourceDisplay, documentation: tsDocumentation, displayParts } = compDetail;
         let detail = (0, utils_2.removeAstroComponentSuffix)(typescript_1.default.displayPartsToString(displayParts));
@@ -286,7 +303,7 @@ class CompletionsProviderImpl {
                 (triggerCharacter === '.' && (0, utils_4.isPartOfImportStatement)(document.getText(), position))));
     }
     getExistingImports(document) {
-        const rawImports = (0, utils_3.getRegExpMatches)(scriptImportRegex, document.getText()).map((match) => { var _a; return ((_a = match[1]) !== null && _a !== void 0 ? _a : match[2]).split(','); });
+        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);
     }
@@ -295,3 +312,34 @@ class CompletionsProviderImpl {
     }
 }
 exports.CompletionsProviderImpl = CompletionsProviderImpl;
+function codeActionChangeToTextEdit(document, fragment, isInsideScriptTag, change) {
+    change.newText = (0, utils_2.removeAstroComponentSuffix)(change.newText);
+    const { span } = change;
+    let range;
+    const virtualRange = (0, utils_2.convertRange)(fragment, span);
+    range = (0, documents_1.mapRangeToOriginal)(fragment, virtualRange);
+    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();
+        }
+    }
+    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);
+}
+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,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;