@astrojs/language-server 0.16.0 → 0.18.0

package/dist/plugins/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 export declare type Resolvable<T> = T | Promise<T>;
 export interface AppCompletionItem<T extends TextDocumentIdentifier = any> extends CompletionItem {
@@ -52,6 +52,9 @@ export interface FileRename {
 export interface UpdateImportsProvider {
     updateImports(fileRename: FileRename): Resolvable<WorkspaceEdit | null>;
 }
+export interface InlayHintsProvider {
+    getInlayHints(document: TextDocument, range: Range): Resolvable<InlayHint[]>;
+}
 export interface RenameProvider {
     rename(document: TextDocument, position: Position, newName: string): Resolvable<WorkspaceEdit | null>;
     prepareRename(document: TextDocument, position: Position): Resolvable<Range | null>;
@@ -81,7 +84,7 @@ export interface OnWatchFileChangesProvider {
 export interface UpdateNonAstroFile {
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
 }
-declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & UpdateNonAstroFile;
+declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & InlayHintsProvider & UpdateNonAstroFile;
 export declare type LSProvider = ProviderBase;
 export declare type Plugin = Partial<ProviderBase> & {
     __name: string;

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

@@ -1,4 +1,4 @@
-import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -10,26 +10,29 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly codeActionsProvider;
     private readonly completionProvider;
     private readonly hoverProvider;
+    private readonly definitionsProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
+    private readonly inlayHintsProvider;
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
+    private readonly formattingProvider;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
-    getSemanticTokens(textDocument: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
+    getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
     resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
+    getInlayHints(document: AstroDocument, range: Range): Promise<InlayHint[]>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
     getDiagnostics(document: AstroDocument, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): Promise<void>;
     getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
-    private goToDefinitionFoundOnlyAlias;
-    private getGoToDefinitionRefsForImportSpecifier;
     private featureEnabled;
 }

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -1,60 +1,43 @@
 "use strict";
-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;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptPlugin = void 0;
-const typescript_1 = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
-const path_1 = require("path");
-const utils_1 = require("../../utils");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
 const HoverProvider_1 = require("./features/HoverProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
-const utils_2 = require("./features/utils");
 const LanguageServiceManager_1 = require("./LanguageServiceManager");
-const utils_3 = require("./utils");
+const utils_1 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
+const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
+const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
+const FormattingProvider_1 = require("./features/FormattingProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
         this.configManager = configManager;
         this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
-        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager);
-        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
+        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager, this.configManager);
+        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager, this.configManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
+        this.definitionsProvider = new DefinitionsProvider_1.DefinitionsProviderImpl(this.languageServiceManager);
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
         this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
+        this.inlayHintsProvider = new InlayHintsProvider_1.InlayHintsProviderImpl(this.languageServiceManager, this.configManager);
         this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
+        this.formattingProvider = new FormattingProvider_1.FormattingProviderImpl(this.languageServiceManager, this.configManager);
     }
     async doHover(document, position) {
-        if (!this.featureEnabled('hover')) {
+        if (!(await this.featureEnabled(document, 'hover'))) {
             return null;
         }
         return this.hoverProvider.doHover(document, position);
@@ -63,7 +46,7 @@ class TypeScriptPlugin {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const fragment = await tsDoc.createFragment();
         const offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
-        let renames = lang.findRenameLocations((0, utils_3.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
+        let renames = lang.findRenameLocations((0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
         if (!renames) {
             return null;
         }
@@ -71,41 +54,44 @@ class TypeScriptPlugin {
             changes: {},
         };
         renames.forEach((rename) => {
-            const filePath = (0, utils_3.ensureRealFilePath)(rename.fileName);
+            const filePath = (0, utils_1.ensureRealFilePath)(rename.fileName);
             if (!(filePath in edit.changes)) {
                 edit.changes[filePath] = [];
             }
             edit.changes[filePath].push({
                 newText: newName,
-                range: (0, utils_3.convertToLocationRange)(fragment, rename.textSpan),
+                range: (0, utils_1.convertToLocationRange)(fragment, rename.textSpan),
             });
         });
         return edit;
     }
+    async formatDocument(document, options) {
+        return this.formattingProvider.formatDocument(document, options);
+    }
     async getFoldingRanges(document) {
         return this.foldingRangesProvider.getFoldingRanges(document);
     }
-    async getSemanticTokens(textDocument, range, cancellationToken) {
-        if (!this.featureEnabled('semanticTokens')) {
+    async getSemanticTokens(document, range, cancellationToken) {
+        if (!(await this.featureEnabled(document, 'semanticTokens'))) {
             return null;
         }
-        return this.semanticTokensProvider.getSemanticTokens(textDocument, range, cancellationToken);
+        return this.semanticTokensProvider.getSemanticTokens(document, range, cancellationToken);
     }
     async getDocumentSymbols(document) {
-        if (!this.featureEnabled('documentSymbols')) {
+        if (!(await this.featureEnabled(document, 'documentSymbols'))) {
             return [];
         }
         const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
         return symbols;
     }
     async getCodeActions(document, range, context, cancellationToken) {
-        if (!this.featureEnabled('codeActions')) {
+        if (!(await this.featureEnabled(document, 'codeActions'))) {
             return [];
         }
         return this.codeActionsProvider.getCodeActions(document, range, context, cancellationToken);
     }
     async getCompletions(document, position, completionContext, cancellationToken) {
-        if (!this.featureEnabled('completions')) {
+        if (!(await this.featureEnabled(document, 'completions'))) {
             return null;
         }
         const completions = await this.completionProvider.getCompletions(document, position, completionContext, cancellationToken);
@@ -114,37 +100,14 @@ class TypeScriptPlugin {
     async resolveCompletion(document, completionItem, cancellationToken) {
         return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
     }
+    async getInlayHints(document, range) {
+        return this.inlayHintsProvider.getInlayHints(document, range);
+    }
     async getDefinitions(document, position) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const mainFragment = await tsDoc.createFragment();
-        const filePath = tsDoc.filePath;
-        const tsFilePath = (0, utils_3.toVirtualAstroFilePath)(filePath);
-        const fragmentPosition = mainFragment.getGeneratedPosition(position);
-        const fragmentOffset = mainFragment.offsetAt(fragmentPosition);
-        let defs = lang.getDefinitionAndBoundSpan(tsFilePath, fragmentOffset);
-        if (!defs || !defs.definitions) {
-            return [];
-        }
-        // Resolve all imports if we can
-        if (this.goToDefinitionFoundOnlyAlias(tsFilePath, defs.definitions)) {
-            let importDef = this.getGoToDefinitionRefsForImportSpecifier(tsFilePath, fragmentOffset, lang);
-            if (importDef) {
-                defs = importDef;
-            }
-        }
-        const docs = new utils_2.SnapshotFragmentMap(this.languageServiceManager);
-        docs.set(tsDoc.filePath, { 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_3.ensureRealFilePath)(def.fileName);
-            // Since we converted our files to TSX and we don't have sourcemaps, we don't know where the function is, unfortunate
-            const textSpan = (0, utils_3.isVirtualFilePath)(tsFilePath) ? { start: 0, length: 0 } : def.textSpan;
-            return vscode_languageserver_1.LocationLink.create((0, utils_1.pathToUrl)(fileName), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(mainFragment, defs.textSpan));
-        }));
-        return result.filter(utils_1.isNotNullOrUndefined);
+        return this.definitionsProvider.getDefinitions(document, position);
     }
     async getDiagnostics(document, cancellationToken) {
-        if (!this.featureEnabled('diagnostics')) {
+        if (!(await this.featureEnabled(document, 'diagnostics'))) {
             return [];
         }
         return this.diagnosticsProvider.getDiagnostics(document, cancellationToken);
@@ -152,7 +115,7 @@ class TypeScriptPlugin {
     async onWatchFileChanges(onWatchFileChangesParas) {
         let doneUpdateProjectFiles = false;
         for (const { fileName, changeType } of onWatchFileChangesParas) {
-            const scriptKind = (0, utils_3.getScriptKindFromFileName)(fileName);
+            const scriptKind = (0, utils_1.getScriptKindFromFileName)(fileName);
             if (scriptKind === typescript_1.default.ScriptKind.Unknown) {
                 continue;
             }
@@ -174,48 +137,9 @@ class TypeScriptPlugin {
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
     }
-    goToDefinitionFoundOnlyAlias(tsFileName, defs) {
-        return !!(defs.length === 1 && defs[0].kind === 'alias' && defs[0].fileName === tsFileName);
-    }
-    getGoToDefinitionRefsForImportSpecifier(tsFilePath, offset, lang) {
-        const program = lang.getProgram();
-        const sourceFile = program?.getSourceFile(tsFilePath);
-        if (sourceFile) {
-            let node = typescript_1.default.getTouchingPropertyName(sourceFile, offset);
-            if (node && node.kind === typescript_1.SyntaxKind.Identifier) {
-                if (node.parent.kind === typescript_1.SyntaxKind.ImportClause) {
-                    let decl = node.parent.parent;
-                    let spec = typescript_1.default.isStringLiteral(decl.moduleSpecifier) && decl.moduleSpecifier.text;
-                    if (spec) {
-                        let fileName = (0, path_1.join)((0, path_1.dirname)(tsFilePath), spec);
-                        let start = node.pos + 1;
-                        let def = {
-                            definitions: [
-                                {
-                                    kind: 'alias',
-                                    fileName,
-                                    name: '',
-                                    containerKind: '',
-                                    containerName: '',
-                                    textSpan: {
-                                        start: 0,
-                                        length: 0,
-                                    },
-                                },
-                            ],
-                            textSpan: {
-                                start,
-                                length: node.end - start,
-                            },
-                        };
-                        return def;
-                    }
-                }
-            }
-        }
-    }
-    featureEnabled(feature) {
-        return (this.configManager.enabled('typescript.enabled') && this.configManager.enabled(`typescript.${feature}.enabled`));
+    async featureEnabled(document, feature) {
+        return ((await this.configManager.isEnabled(document, 'typescript')) &&
+            (await this.configManager.isEnabled(document, 'typescript', feature)));
     }
 }
 exports.TypeScriptPlugin = TypeScriptPlugin;

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

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

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

@@ -15,15 +15,16 @@ 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) {
+    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 start = fragment.offsetAt(fragment.getGeneratedPosition(range.start));
-        const end = fragment.offsetAt(fragment.getGeneratedPosition(range.end));
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const formatOptions = await this.configManager.getTSFormatConfig(document);
         let result = [];
         if (cancellationToken?.isCancellationRequested) {
             return [];
@@ -47,21 +48,57 @@ class CodeActionsProviderImpl {
                 .map((diag) => Number(diag.code))
                 // We currently cannot support quick fix for unreachable code properly due to the way our TSX output is structured
                 .filter((code) => code !== 7027);
-            let codeFixes = errorCodes.includes(2304) ? this.getComponentQuickFix(start, end, lang, filePath) : undefined;
-            codeFixes = codeFixes ?? lang.getCodeFixesAtPosition(filePath, start, end, errorCodes, {}, {});
-            const codeActions = codeFixes.map((fix) => codeFixToCodeAction(fix, context.diagnostics, context.only ? vscode_languageserver_types_1.CodeActionKind.QuickFix : vscode_languageserver_types_1.CodeActionKind.Empty));
+            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) {
+        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));
-                    if (codeFix.fixName === 'import') {
-                        return (0, CompletionsProvider_1.codeActionChangeToTextEdit)(document, fragment, edit);
+                    // 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);
+                        }
                     }
-                    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);
                 }));
@@ -72,8 +109,17 @@ class CodeActionsProviderImpl {
             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) {
+    getComponentQuickFix(start, end, lang, filePath, formatOptions, tsPreferences) {
         const sourceFile = lang.getProgram()?.getSourceFile(filePath);
         if (!sourceFile) {
             return;
@@ -87,7 +133,7 @@ class CodeActionsProviderImpl {
         }
         const tagName = node.tagName;
         // Unlike quick fixes, completions will be able to find the component, so let's use those to get it
-        const completion = lang.getCompletionsAtPosition(filePath, tagName.getEnd(), CompletionsProvider_1.completionOptions);
+        const completion = lang.getCompletionsAtPosition(filePath, tagName.getEnd(), tsPreferences, formatOptions);
         if (!completion) {
             return;
         }
@@ -101,16 +147,35 @@ class CodeActionsProviderImpl {
         return (0, lodash_1.flatten)(completion.entries.filter((c) => c.name === name || c.name === suffixedName).map(toFix));
     }
     async organizeSortImports(document, skipDestructiveCodeActions = false, cancellationToken) {
-        if (document.astroMeta.frontmatter.state !== 'closed') {
-            return [];
-        }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
         const fragment = await tsDoc.createFragment();
         if (cancellationToken?.isCancellationRequested) {
             return [];
         }
-        const changes = lang.organizeImports({ fileName: filePath, type: 'file', skipDestructiveCodeActions }, {}, {});
+        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));

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

@@ -4,15 +4,17 @@ import { AstroDocument } from '../../../core/documents';
 import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
 import { AstroSnapshotFragment } from '../snapshots/DocumentSnapshot';
-export declare const completionOptions: ts.GetCompletionsAtPositionOptions;
+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?;
@@ -31,4 +33,4 @@ export declare class CompletionsProviderImpl implements CompletionsProvider<Comp
     private getExistingImports;
     private isAstroComponentImport;
 }
-export declare function codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, change: ts.TextChange): TextEdit;
+export declare function codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, isInsideScriptTag: boolean, change: ts.TextChange): TextEdit;