@astrojs/language-server 0.14.0 → 0.16.1

package/dist/plugins/typescript/LanguageServiceManager.js

@@ -29,7 +29,7 @@ class LanguageServiceManager {
         const handleDocumentChange = (document) => {
             this.getSnapshot(document);
         };
-        docManager.on('documentChange', (0, utils_1.debounceSameArg)(handleDocumentChange, (newDoc, prevDoc) => newDoc.uri === (prevDoc === null || prevDoc === void 0 ? void 0 : prevDoc.uri), 1000));
+        docManager.on('documentChange', (0, utils_1.debounceSameArg)(handleDocumentChange, (newDoc, prevDoc) => newDoc.uri === prevDoc?.uri, 1000));
         docManager.on('documentOpen', handleDocumentChange);
     }
     async getSnapshot(pathOrDoc) {

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

@@ -1,31 +1,34 @@
-import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
-import { CompletionEntryWithIdentifer } from './features/CompletionsProvider';
+import { CompletionItemData } from './features/CompletionsProvider';
 export declare class TypeScriptPlugin implements Plugin {
     __name: string;
     private configManager;
     private readonly languageServiceManager;
+    private readonly codeActionsProvider;
     private readonly completionProvider;
     private readonly hoverProvider;
+    private readonly definitionsProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
     private readonly semanticTokensProvider;
+    private readonly foldingRangesProvider;
     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>;
-    getSemanticTokens(textDocument: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
+    getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
-    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
-    resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
+    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>>;
     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,56 +1,39 @@
 "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");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
         this.configManager = configManager;
         this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
-        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.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
     }
     async doHover(document, position) {
-        if (!this.featureEnabled('hover')) {
+        if (!(await this.featureEnabled(document, 'hover'))) {
             return null;
         }
         return this.hoverProvider.doHover(document, position);
@@ -59,7 +42,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;
         }
@@ -67,71 +50,54 @@ 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 getSemanticTokens(textDocument, range, cancellationToken) {
-        if (!this.featureEnabled('semanticTokens')) {
+    async getFoldingRanges(document) {
+        return this.foldingRangesProvider.getFoldingRanges(document);
+    }
+    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 getCompletions(document, position, completionContext) {
-        if (!this.featureEnabled('completions')) {
+    async getCodeActions(document, range, context, cancellationToken) {
+        if (!(await this.featureEnabled(document, 'codeActions'))) {
+            return [];
+        }
+        return this.codeActionsProvider.getCodeActions(document, range, context, cancellationToken);
+    }
+    async getCompletions(document, position, completionContext, cancellationToken) {
+        if (!(await this.featureEnabled(document, 'completions'))) {
             return null;
         }
-        const completions = await this.completionProvider.getCompletions(document, position, completionContext);
+        const completions = await this.completionProvider.getCompletions(document, position, completionContext, cancellationToken);
         return completions;
     }
-    async resolveCompletion(document, completionItem) {
-        return this.completionProvider.resolveCompletion(document, completionItem);
+    async resolveCompletion(document, completionItem, cancellationToken) {
+        return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
     }
     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);
@@ -139,7 +105,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;
             }
@@ -161,48 +127,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 === null || program === void 0 ? void 0 : 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/astro-sys.js

@@ -14,9 +14,8 @@ function createAstroSys(getSnapshot) {
     const AstroSys = {
         ...typescript_1.default.sys,
         fileExists(path) {
-            var _a;
             path = (0, utils_1.ensureRealFilePath)(path);
-            const exists = (_a = fileExistsCache.get(path)) !== null && _a !== void 0 ? _a : typescript_1.default.sys.fileExists(path);
+            const exists = fileExistsCache.get(path) ?? typescript_1.default.sys.fileExists(path);
             fileExistsCache.set(path, exists);
             return exists;
         },
@@ -25,14 +24,13 @@ function createAstroSys(getSnapshot) {
             return snapshot.getText(0, snapshot.getLength());
         },
         readDirectory(path, extensions, exclude, include, depth) {
-            const extensionsWithAstro = (extensions !== null && extensions !== void 0 ? extensions : []).concat(...['.astro', '.svelte', '.vue']);
+            const extensionsWithAstro = (extensions ?? []).concat(...['.astro', '.svelte', '.vue']);
             const result = typescript_1.default.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
             return result;
         },
         deleteFile(path) {
-            var _a, _b;
             fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));
-            return (_b = (_a = typescript_1.default.sys).deleteFile) === null || _b === void 0 ? void 0 : _b.call(_a, path);
+            return typescript_1.default.sys.deleteFile?.(path);
         },
         deleteFromCache(path) {
             fileExistsCache.delete((0, utils_1.ensureRealFilePath)(path));

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

@@ -1,5 +1,5 @@
 interface Astro2TSXResult {
     code: string;
 }
-export default function (content: string): Astro2TSXResult;
+export default function (content: string, className: string): Astro2TSXResult;
 export {};

package/dist/plugins/typescript/astro2tsx.js

@@ -2,18 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = require("os");
 const parseAstro_1 = require("../../core/documents/parseAstro");
-function addProps(content) {
+function addProps(content, className) {
     let defaultExportType = 'Record<string, any>';
     if (/(interface|type) Props/.test(content)) {
         defaultExportType = 'Props';
     }
-    return os_1.EOL + `export default function (_props: ${defaultExportType}) { return <div></div>; }`;
+    return os_1.EOL + `export default function ${className}__AstroComponent_(_props: ${defaultExportType}): any {}`;
 }
 function escapeTemplateLiteralContent(content) {
     return content.replace(/`/g, '\\`');
 }
-function default_1(content) {
-    var _a, _b;
+function default_1(content, className) {
     let result = {
         code: '',
     };
@@ -22,10 +21,11 @@ function default_1(content) {
     let frontMatterRaw = '';
     if (astroDocument.frontmatter.state === 'closed') {
         frontMatterRaw = content
-            .substring((_a = astroDocument.frontmatter.startOffset) !== null && _a !== void 0 ? _a : 0, ((_b = astroDocument.frontmatter.endOffset) !== null && _b !== void 0 ? _b : 0) + 3)
+            .substring(astroDocument.frontmatter.startOffset ?? 0, (astroDocument.frontmatter.endOffset ?? 0) + 3)
             // Handle case where semicolons is not used in the frontmatter section
+            // We need to add something before the semi-colon or TypeScript won't be able to do completions
             .replace(/((?!^)(?<!;)\n)(---)/g, (_whole, start, _dashes) => {
-            return start + ';' + '//';
+            return start + '"";';
         })
             // Replace frontmatter marks with comments
             .replace(/---/g, '///');
@@ -80,7 +80,7 @@ function default_1(content) {
             htmlRaw +
             os_1.EOL +
             // Add TypeScript definitions
-            addProps(frontMatterRaw);
+            addProps(frontMatterRaw, className);
     return result;
 }
 exports.default = default_1;

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

@@ -0,0 +1,16 @@
+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;
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
+    getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
+    private getComponentQuickFix;
+    private organizeSortImports;
+    private fixIndentationOfImports;
+}

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

@@ -0,0 +1,147 @@
+"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 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 [];
+        }
+        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);
+            let 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));
+            result.push(...codeActions);
+        }
+        return result;
+        function codeFixToCodeAction(codeFix, diagnostics, kind) {
+            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);
+                    }
+                    if (codeFix.fixName === 'fixMissingFunctionDeclaration') {
+                        originalRange = (0, utils_2.checkEndOfFileCodeInsert)(originalRange, document);
+                    }
+                    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;
+        }
+    }
+    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) {
+        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 }, {}, {});
+        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

@@ -1,16 +1,35 @@
-import type { CompletionContext, Position, TextDocumentIdentifier } from 'vscode-languageserver';
+import { CompletionContext, Position, TextDocumentIdentifier, TextEdit, CancellationToken } from 'vscode-languageserver';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
 import { AstroDocument } from '../../../core/documents';
 import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
-export interface CompletionEntryWithIdentifer extends ts.CompletionEntry, TextDocumentIdentifier {
-    position: Position;
+import { AstroSnapshotFragment } from '../snapshots/DocumentSnapshot';
+import { ConfigManager } from '../../../core/config';
+export interface CompletionItemData extends TextDocumentIdentifier {
+    filePath: string;
+    offset: number;
+    originalItem: ts.CompletionEntry;
 }
-export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionEntryWithIdentifer> {
+export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionItemData> {
     private languageServiceManager;
-    constructor(languageServiceManager: LanguageServiceManager);
-    getCompletions(document: AstroDocument, position: Position, _completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
-    resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
+    private readonly validTriggerCharacters;
+    private isValidTriggerCharacter;
+    private lastCompletion?;
+    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
+    resolveCompletion(document: AstroDocument, item: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     private toCompletionItem;
+    private isValidCompletion;
     private getCompletionDocument;
+    /**
+     * If the textEdit is out of the word range of the triggered position
+     * vscode would refuse to show the completions
+     * split those edits into additionalTextEdit to fix it
+     */
+    private fixTextEditRange;
+    private canReuseLastCompletion;
+    private getExistingImports;
+    private isAstroComponentImport;
 }
+export declare function codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, change: ts.TextChange): TextEdit;