@astrojs/language-server 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @astrojs/language-server
 
+## 0.15.0
+
+### Minor Changes
+
+- 6bb45cb: Overhaul TypeScript completions
+
+  - Add support for completions inside expressions
+  - Add support for auto imports on completion
+  - Fix misc issues in completions (missing description, deprecated stuff not showing as deprecated)
+
+### Patch Changes
+
+- 7978de1: Add support for folding JavaScript
+- 3ac74bc: Improve props completions on components
+- Updated dependencies [6bb45cb]
+  - @astrojs/svelte-language-integration@0.1.3
+
 ## 0.14.0
 
 ### Minor Changes

package/dist/core/documents/utils.d.ts

@@ -15,6 +15,11 @@ export interface TagInformation {
 }
 export declare function walk(node: Node): Generator<Node, void, unknown>;
 export declare function extractStyleTags(source: string, html?: HTMLDocument): TagInformation[];
+export declare function getLineAtPosition(position: Position, text: string): string;
+/**
+ * Returns the node if offset is inside a HTML start tag
+ */
+export declare function getNodeIfIsInHTMLStartTag(html: HTMLDocument, offset: number): Node | undefined;
 /**
  * Return if a Node is a Component
  */

package/dist/core/documents/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirstNonWhitespaceIndex = exports.getLineOffsets = exports.offsetAt = exports.positionAt = exports.isInsideFrontmatter = exports.isInsideExpression = exports.isInTag = exports.isInComponentStartTag = exports.isComponentTag = exports.extractStyleTags = exports.walk = void 0;
+exports.getFirstNonWhitespaceIndex = exports.getLineOffsets = exports.offsetAt = exports.positionAt = exports.isInsideFrontmatter = exports.isInsideExpression = exports.isInTag = exports.isInComponentStartTag = exports.isComponentTag = exports.getNodeIfIsInHTMLStartTag = exports.getLineAtPosition = exports.extractStyleTags = exports.walk = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_1 = require("../../utils");
 const parseHtml_1 = require("./parseHtml");
@@ -79,6 +79,20 @@ function parseAttributes(rawAttrs) {
         return attrValue;
     }
 }
+function getLineAtPosition(position, text) {
+    return text.substring(offsetAt({ line: position.line, character: 0 }, text), offsetAt({ line: position.line, character: Number.MAX_VALUE }, text));
+}
+exports.getLineAtPosition = getLineAtPosition;
+/**
+ * Returns the node if offset is inside a HTML start tag
+ */
+function getNodeIfIsInHTMLStartTag(html, offset) {
+    const node = html.findNodeAt(offset);
+    if (!!node.tag && node.tag[0] === node.tag[0].toLowerCase() && (!node.startTagEnd || offset < node.startTagEnd)) {
+        return node;
+    }
+}
+exports.getNodeIfIsInHTMLStartTag = getNodeIfIsInHTMLStartTag;
 /**
  * Return if a Node is a Component
  */

package/dist/plugins/PluginHost.d.ts

@@ -12,7 +12,7 @@ export declare class PluginHost {
     constructor(docManager: DocumentManager);
     initialize(pluginHostConfig: PluginHostConfig): void;
     registerPlugin(plugin: Plugin): void;
-    getCompletions(textDocument: TextDocumentIdentifier, position: Position, completionContext?: CompletionContext): Promise<CompletionList>;
+    getCompletions(textDocument: TextDocumentIdentifier, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<CompletionList>;
     resolveCompletion(textDocument: TextDocumentIdentifier, completionItem: AppCompletionItem): Promise<CompletionItem>;
     getDiagnostics(textDocument: TextDocumentIdentifier): Promise<Diagnostic[]>;
     doHover(textDocument: TextDocumentIdentifier, position: Position): Promise<Hover | null>;

package/dist/plugins/PluginHost.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginHost = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const lodash_1 = require("lodash");
+const utils_1 = require("../utils");
+const documents_1 = require("../core/documents");
 var ExecuteMode;
 (function (ExecuteMode) {
     ExecuteMode[ExecuteMode["None"] = 0] = "None";
@@ -24,11 +26,34 @@ class PluginHost {
     registerPlugin(plugin) {
         this.plugins.push(plugin);
     }
-    async getCompletions(textDocument, position, completionContext) {
+    async getCompletions(textDocument, position, completionContext, cancellationToken) {
         const document = this.getDocument(textDocument.uri);
-        const completions = (await this.execute('getCompletions', [document, position, completionContext], ExecuteMode.Collect)).filter((completion) => completion != null);
-        let flattenedCompletions = (0, lodash_1.flatten)(completions.map((completion) => completion.items));
-        const isIncomplete = completions.reduce((incomplete, completion) => incomplete || completion.isIncomplete, false);
+        const completions = await Promise.all(this.plugins.map(async (plugin) => {
+            const result = await this.tryExecutePlugin(plugin, 'getCompletions', [document, position, completionContext, cancellationToken], null);
+            if (result) {
+                return { result: result, plugin: plugin.__name };
+            }
+        })).then((fullCompletions) => fullCompletions.filter(utils_1.isNotNullOrUndefined));
+        const html = completions.find((completion) => completion.plugin === 'html');
+        const ts = completions.find((completion) => completion.plugin === 'typescript');
+        const astro = completions.find((completion) => completion.plugin === 'astro');
+        if (html && ts) {
+            if ((0, documents_1.getNodeIfIsInHTMLStartTag)(document.html, document.offsetAt(position))) {
+                ts.result.items = [];
+            }
+            // If the Astro plugin has completions for us, don't show TypeScript's as they're most likely duplicates
+            if (astro && astro.result.items.length > 0 && (0, documents_1.isInComponentStartTag)(document.html, document.offsetAt(position))) {
+                ts.result.items = [];
+            }
+            ts.result.items = ts.result.items.map((item) => {
+                if (item.sortText != '-1') {
+                    item.sortText = 'Z' + (item.sortText || '');
+                }
+                return item;
+            });
+        }
+        let flattenedCompletions = (0, lodash_1.flatten)(completions.map((completion) => completion.result.items));
+        const isIncomplete = completions.reduce((incomplete, completion) => incomplete || completion.result.isIncomplete, false);
         return vscode_languageserver_1.CompletionList.create(flattenedCompletions, isIncomplete);
     }
     async resolveCompletion(textDocument, completionItem) {

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

@@ -33,12 +33,12 @@ class CompletionsProviderImpl {
         }
         const html = document.html;
         const offset = document.offsetAt(position);
-        if ((0, utils_1.isInComponentStartTag)(html, offset)) {
+        const node = html.findNodeAt(offset);
+        if ((0, utils_1.isInComponentStartTag)(html, offset) && !(0, utils_1.isInsideExpression)(document.getText(), node.start, offset)) {
             const props = await this.getPropCompletions(document, position, completionContext);
             if (props.length) {
                 items.push(...props);
             }
-            const node = html.findNodeAt(offset);
             const isAstro = await this.isAstroComponent(document, node);
             if (!isAstro) {
                 const directives = (0, utils_4.removeDataAttrCompletion)(this.directivesHTMLLang.doComplete(document, position, html).items);
@@ -123,7 +123,8 @@ class CompletionsProviderImpl {
         // Add completions for this component's props type properties
         const properties = componentType.getProperties().filter((property) => property.name !== 'children') || [];
         properties.forEach((property) => {
-            let completionItem = this.getCompletionItemForProperty(property, typeChecker);
+            const type = typeChecker.getTypeOfSymbolAtLocation(property, imp);
+            let completionItem = this.getCompletionItemForProperty(property, typeChecker, type);
             completionItems.push(completionItem);
         });
         // Ensure that props shows up first as a completion, despite this plugin being ran after the HTML one
@@ -180,10 +181,25 @@ class CompletionsProviderImpl {
         }
         return null;
     }
-    getCompletionItemForProperty(mem, typeChecker) {
+    getCompletionItemForProperty(mem, typeChecker, type) {
+        const typeString = typeChecker.typeToString(type);
+        let insertText = mem.name;
+        switch (typeString) {
+            case 'string':
+                insertText = `${mem.name}="$1"`;
+                break;
+            case 'boolean':
+                insertText = mem.name;
+                break;
+            default:
+                insertText = `${mem.name}={$1}`;
+                break;
+        }
         let item = {
             label: mem.name,
-            insertText: mem.name,
+            detail: typeString,
+            insertText: insertText,
+            insertTextFormat: vscode_languageserver_1.InsertTextFormat.Snippet,
             commitCharacters: [],
         };
         mem.getDocumentationComment(typeChecker);

package/dist/plugins/interfaces.d.ts

@@ -13,7 +13,7 @@ export interface DiagnosticsProvider {
 export interface HoverProvider {
     doHover(document: TextDocument, position: Position): Resolvable<Hover | null>;
 }
-export interface FoldingRangeProvider {
+export interface FoldingRangesProvider {
     getFoldingRanges(document: TextDocument): Resolvable<FoldingRange[] | null>;
 }
 export interface CompletionsProvider<T extends TextDocumentIdentifier = any> {
@@ -81,7 +81,7 @@ export interface OnWatchFileChangesProvider {
 export interface UpdateNonAstroFile {
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
 }
-declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangeProvider & 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 & UpdateNonAstroFile;
 export declare type LSProvider = ProviderBase;
 export declare type Plugin = Partial<ProviderBase> & {
     __name: string;

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

@@ -1,8 +1,8 @@
-import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, 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;
@@ -13,13 +13,15 @@ export declare class TypeScriptPlugin implements Plugin {
     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>;
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
     getSemanticTokens(textDocument: 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>>;
+    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>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -37,6 +37,7 @@ const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_3 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
+const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
@@ -48,6 +49,7 @@ class TypeScriptPlugin {
         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')) {
@@ -78,6 +80,9 @@ class TypeScriptPlugin {
         });
         return edit;
     }
+    async getFoldingRanges(document) {
+        return this.foldingRangesProvider.getFoldingRanges(document);
+    }
     async getSemanticTokens(textDocument, range, cancellationToken) {
         if (!this.featureEnabled('semanticTokens')) {
             return null;
@@ -91,15 +96,15 @@ class TypeScriptPlugin {
         const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
         return symbols;
     }
-    async getCompletions(document, position, completionContext) {
+    async getCompletions(document, position, completionContext, cancellationToken) {
         if (!this.featureEnabled('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);

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,17 +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) {
+function default_1(content, className) {
     var _a, _b;
     let result = {
         code: '',
@@ -24,8 +24,9 @@ function default_1(content) {
         frontMatterRaw = content
             .substring((_a = astroDocument.frontmatter.startOffset) !== null && _a !== void 0 ? _a : 0, ((_b = astroDocument.frontmatter.endOffset) !== null && _b !== void 0 ? _b : 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 +81,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/CompletionsProvider.d.ts

@@ -1,16 +1,33 @@
-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';
+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 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;
+    codeActionChangeToTextEdit(document: AstroDocument, fragment: AstroSnapshotFragment, change: ts.TextChange): TextEdit;
     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;
 }

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

@@ -1,92 +1,297 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompletionsProviderImpl = void 0;
-const utils_1 = require("../../../core/documents/utils");
-const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const utils_1 = require("../../../core/documents/utils");
+const documents_1 = require("../../../core/documents");
+const typescript_1 = __importStar(require("typescript"));
+const vscode_languageserver_2 = require("vscode-languageserver");
 const utils_2 = require("../utils");
-const completionOptions = Object.freeze({
+const utils_3 = require("../../../utils");
+const lodash_1 = require("lodash");
+const previewer_1 = require("../previewer");
+const utils_4 = require("./utils");
+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) {
         this.languageServiceManager = languageServiceManager;
+        this.validTriggerCharacters = ['.', '"', "'", '`', '/', '@', '<', '#'];
     }
-    async getCompletions(document, position, _completionContext) {
-        var _a;
-        // TODO: handle inside expression and script tags
-        if (!(0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
+    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 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)) {
+            return null;
+        }
+        if (this.canReuseLastCompletion(this.lastCompletion, triggerKind, triggerCharacter, document, position)) {
+            this.lastCompletion.position = position;
+            return this.lastCompletion.completionList;
+        }
+        else {
+            this.lastCompletion = undefined;
+        }
+        const html = document.html;
+        const offset = document.offsetAt(position);
+        const node = html.findNodeAt(offset);
+        // TODO: Add support for script tags
+        if (node.tag === 'script') {
+            return null;
+        }
+        const isCompletionInsideFrontmatter = (0, utils_1.isInsideFrontmatter)(document.getText(), offset);
+        const isCompletionInsideExpression = (0, utils_1.isInsideExpression)(document.getText(), node.start, offset);
+        // PERF: Getting TS completions is fairly slow and I am currently not sure how to speed it up
+        // As such, we'll try to avoid getting them when unneeded, such as when we're doing HTML stuff
+        // When at the root of the document TypeScript offer all kinds of completions, because it doesn't know yet that
+        // it's JSX and not JS. As such, people who are using Emmet to write their template suffer from a very degraded experience
+        // from what they're used to in HTML files (which is instant completions). So let's disable ourselves when we're at the root
+        if (!isCompletionInsideFrontmatter && !node.parent && !isCompletionInsideExpression) {
+            return null;
+        }
+        // If the user just typed `<` with nothing else, let's disable ourselves until we're more sure if the user wants TS completions
+        if (!isCompletionInsideFrontmatter && node.parent && node.tag === undefined && !isCompletionInsideExpression) {
+            return null;
+        }
+        // If the current node is not a component (aka, it doesn't start with a caps), let's disable ourselves as the user
+        // is most likely looking for HTML completions
+        if (!isCompletionInsideFrontmatter && !(0, utils_1.isComponentTag)(node) && !isCompletionInsideExpression) {
             return null;
         }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const completions = lang.getCompletionsAtPosition(filePath, offset, {
+            ...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 fragment = await tsDoc.createFragment();
-        const offset = document.offsetAt(position);
-        const entries = ((_a = lang.getCompletionsAtPosition(filePath, offset, completionOptions)) === null || _a === void 0 ? void 0 : _a.entries) || [];
-        const completionItems = entries
-            .map((entry) => this.toCompletionItem(fragment, entry, document.uri, position, new Set()))
-            .filter((i) => i);
-        return vscode_languageserver_1.CompletionList.create(completionItems, true);
+        const existingImports = this.getExistingImports(document);
+        const completionItems = completions.entries
+            .filter(this.isValidCompletion)
+            .map((entry) => this.toCompletionItem(fragment, entry, filePath, offset, isCompletionInsideFrontmatter, existingImports))
+            .filter(utils_3.isNotNullOrUndefined)
+            .map((comp) => this.fixTextEditRange(wordRangeStartPosition, comp));
+        const completionList = vscode_languageserver_2.CompletionList.create(completionItems, true);
+        this.lastCompletion = { key: document.getFilePath() || '', position, completionList };
+        return completionList;
     }
-    async resolveCompletion(document, completionItem) {
-        const { data: comp } = completionItem;
+    async resolveCompletion(document, item, cancellationToken) {
+        var _a;
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        let filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
-        if (!comp || !filePath) {
-            return completionItem;
+        const data = item.data;
+        if (!data || !data.filePath || (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested)) {
+            return item;
         }
         const fragment = await tsDoc.createFragment();
-        const detail = lang.getCompletionEntryDetails(filePath, // fileName
-        fragment.offsetAt(comp.position), // position
-        comp.name, // entryName
+        const detail = lang.getCompletionEntryDetails(data.filePath, // fileName
+        data.offset, // position
+        data.originalItem.name, // entryName
         {}, // formatOptions
-        comp.source, // source
-        {}, // preferences
-        comp.data // data
+        data.originalItem.source, // source
+        completionOptions, // preferences
+        data.originalItem.data // data
         );
         if (detail) {
             const { detail: itemDetail, documentation: itemDocumentation } = this.getCompletionDocument(detail);
-            completionItem.detail = itemDetail;
-            completionItem.documentation = itemDocumentation;
+            item.detail = itemDetail;
+            item.documentation = itemDocumentation;
         }
-        return completionItem;
+        const actions = detail === null || detail === void 0 ? void 0 : detail.codeActions;
+        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)));
+                }
+            }
+            item.additionalTextEdits = ((_a = item.additionalTextEdits) !== null && _a !== void 0 ? _a : []).concat(edit);
+        }
+        return item;
     }
-    toCompletionItem(fragment, comp, uri, position, existingImports) {
+    toCompletionItem(fragment, comp, filePath, offset, insideFrontmatter, existingImports) {
+        var _a, _b, _c;
+        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');
+        // Avoid showing completions for using components as functions
+        if (isAstroComponent && !isImport && insideFrontmatter) {
+            return null;
+        }
+        if (isAstroComponent) {
+            item.label = (0, utils_2.removeAstroComponentSuffix)(comp.name);
+            // Set component imports as file completion, that way we get cool icons
+            item.kind = vscode_languageserver_protocol_1.CompletionItemKind.File;
+            item.detail = (_b = comp.data) === null || _b === void 0 ? void 0 : _b.moduleSpecifier;
+        }
+        else {
+            item.kind = (0, utils_2.scriptElementKindToCompletionItemKind)(comp.kind);
+        }
+        // TS may suggest another component even if there already exists an import with the same.
+        // This happens because internally, components get suffixed with __AstroComponent_
+        if (isAstroComponent && existingImports.has(item.label)) {
+            return null;
+        }
+        if (comp.kindModifiers) {
+            const kindModifiers = new Set(comp.kindModifiers.split(/,|\s+/g));
+            if (kindModifiers.has(typescript_1.ScriptElementKindModifier.deprecatedModifier)) {
+                item.tags = [vscode_languageserver_1.CompletionItemTag.Deprecated];
+            }
+        }
+        // Label details are currently unsupported, however, they'll be supported in the next version of LSP
+        if (comp.sourceDisplay) {
+            item.labelDetails = { description: typescript_1.default.displayPartsToString(comp.sourceDisplay) };
+        }
+        item.commitCharacters = (0, utils_2.getCommitCharactersForScriptElement)(comp.kind);
+        item.sortText = comp.sortText;
+        item.preselect = comp.isRecommended;
+        if (comp.replacementSpan) {
+            item.insertText = comp.insertText ? (0, utils_2.removeAstroComponentSuffix)(comp.insertText) : undefined;
+            item.insertTextFormat = comp.isSnippet ? vscode_languageserver_1.InsertTextFormat.Snippet : vscode_languageserver_1.InsertTextFormat.PlainText;
+            item.textEdit = comp.replacementSpan
+                ? vscode_languageserver_1.TextEdit.replace((0, utils_2.convertRange)(fragment, comp.replacementSpan), (_c = item.insertText) !== null && _c !== void 0 ? _c : item.label)
+                : undefined;
+        }
         return {
-            label: comp.name,
-            insertText: comp.insertText,
-            kind: (0, utils_2.scriptElementKindToCompletionItemKind)(comp.kind),
-            commitCharacters: (0, utils_2.getCommitCharactersForScriptElement)(comp.kind),
-            // Make sure svelte component takes precedence
-            sortText: comp.sortText,
-            preselect: comp.isRecommended,
-            // pass essential data for resolving completion
+            ...item,
             data: {
-                ...comp,
-                uri,
-                position,
+                uri: fragment.getURL(),
+                filePath,
+                offset,
+                originalItem: comp,
             },
         };
     }
+    isValidCompletion(completion) {
+        // Remove completion for default exported function
+        if (completion.name === 'default' && completion.kindModifiers == typescript_1.ScriptElementKindModifier.exportedModifier) {
+            return false;
+        }
+        return true;
+    }
+    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 { source, documentation: tsDocumentation, displayParts, tags } = compDetail;
-        let detail = typescript_1.default.displayPartsToString(displayParts);
-        if (source) {
-            const importPath = typescript_1.default.displayPartsToString(source);
-            detail = `Auto import from ${importPath}\n${detail}`;
-        }
-        const documentation = tsDocumentation
-            ? { value: tsDocumentation.join('\n'), kind: vscode_languageserver_1.MarkupKind.Markdown }
-            : undefined;
+        const { sourceDisplay, documentation: tsDocumentation, displayParts } = compDetail;
+        let detail = (0, utils_2.removeAstroComponentSuffix)(typescript_1.default.displayPartsToString(displayParts));
+        if (sourceDisplay) {
+            const importPath = typescript_1.default.displayPartsToString(sourceDisplay);
+            detail = importPath;
+        }
+        const documentation = {
+            kind: 'markdown',
+            value: (0, previewer_1.getMarkdownDocumentation)(tsDocumentation, compDetail.tags),
+        };
         return {
             documentation,
             detail,
         };
     }
+    /**
+     * If the textEdit is out of the word range of the triggered position
+     * vscode would refuse to show the completions
+     * split those edits into additionalTextEdit to fix it
+     */
+    fixTextEditRange(wordRangePosition, completionItem) {
+        const { textEdit } = completionItem;
+        if (!textEdit || !vscode_languageserver_1.TextEdit.is(textEdit) || !wordRangePosition) {
+            return completionItem;
+        }
+        const { newText, range: { start }, } = textEdit;
+        const wordRangeStartCharacter = wordRangePosition.character;
+        if (wordRangePosition.line !== wordRangePosition.line || start.character > wordRangePosition.character) {
+            return completionItem;
+        }
+        textEdit.newText = newText.substring(wordRangeStartCharacter - start.character);
+        textEdit.range.start = {
+            line: start.line,
+            character: wordRangeStartCharacter,
+        };
+        completionItem.additionalTextEdits = [
+            vscode_languageserver_1.TextEdit.replace({
+                start,
+                end: {
+                    line: start.line,
+                    character: wordRangeStartCharacter,
+                },
+            }, newText.substring(0, wordRangeStartCharacter - start.character)),
+        ];
+        return completionItem;
+    }
+    canReuseLastCompletion(lastCompletion, triggerKind, triggerCharacter, document, position) {
+        return (!!lastCompletion &&
+            lastCompletion.key === document.getFilePath() &&
+            lastCompletion.position.line === position.line &&
+            Math.abs(lastCompletion.position.character - position.character) < 2 &&
+            (triggerKind === vscode_languageserver_1.CompletionTriggerKind.TriggerForIncompleteCompletions ||
+                // Special case: `.` is a trigger character, but inside import path completions
+                // it shouldn't trigger another completion because we can reuse the old one
+                (triggerCharacter === '.' && (0, utils_4.isPartOfImportStatement)(document.getText(), position))));
+    }
+    getExistingImports(document) {
+        const rawImports = (0, utils_3.getRegExpMatches)(scriptImportRegex, document.getText()).map((match) => { var _a; return ((_a = match[1]) !== null && _a !== void 0 ? _a : match[2]).split(','); });
+        const tidiedImports = (0, lodash_1.flatten)(rawImports).map((match) => match.trim());
+        return new Set(tidiedImports);
+    }
+    isAstroComponentImport(className) {
+        return className.endsWith('__AstroComponent_');
+    }
 }
 exports.CompletionsProviderImpl = CompletionsProviderImpl;

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

@@ -42,8 +42,8 @@ class DocumentSymbolsProviderImpl {
                     }
                 }
             }
-            // Remove the default function detected in our TSX output
-            if (symbol.kind === vscode_languageserver_types_1.SymbolKind.Function && symbol.name == 'default') {
+            // Remove the exported function in our TSX output from the symbols
+            if (document.offsetAt(symbol.location.range.start) >= document.getTextLength()) {
                 continue;
             }
             result.push(symbol);

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

@@ -0,0 +1,9 @@
+import { FoldingRange } from 'vscode-languageserver';
+import { AstroDocument } from '../../../core/documents';
+import { FoldingRangesProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class FoldingRangesProviderImpl implements FoldingRangesProvider {
+    private readonly languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoldingRangesProviderImpl = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const vscode_languageserver_1 = require("vscode-languageserver");
+const utils_1 = require("../utils");
+class FoldingRangesProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getFoldingRanges(document) {
+        const html = document.html;
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        const outliningSpans = lang.getOutliningSpans(filePath);
+        const foldingRanges = [];
+        for (const span of outliningSpans) {
+            const node = html.findNodeAt(span.textSpan.start);
+            // Due to how our TSX output transform those tags into function calls or template literals
+            // TypeScript thinks of those as outlining spans, which is fine but we don't want folding ranges for those
+            if (node.tag === 'script' || node.tag === 'Markdown' || node.tag === 'style') {
+                continue;
+            }
+            const start = document.positionAt(span.textSpan.start);
+            const end = adjustFoldingEnd(start, document.positionAt(span.textSpan.start + span.textSpan.length), document);
+            // When using this method for generating folding ranges, TypeScript tend to return some
+            // one line / one character ones that we should be able to safely ignore
+            if (start.line === end.line && start.character === end.character) {
+                continue;
+            }
+            foldingRanges.push(vscode_languageserver_1.FoldingRange.create(start.line, end.line, start.character, end.character, transformFoldingRangeKind(span.kind)));
+        }
+        return foldingRanges;
+    }
+}
+exports.FoldingRangesProviderImpl = FoldingRangesProviderImpl;
+function transformFoldingRangeKind(tsKind) {
+    switch (tsKind) {
+        case typescript_1.default.OutliningSpanKind.Comment:
+            return vscode_languageserver_1.FoldingRangeKind.Comment;
+        case typescript_1.default.OutliningSpanKind.Imports:
+            return vscode_languageserver_1.FoldingRangeKind.Imports;
+        case typescript_1.default.OutliningSpanKind.Region:
+            return vscode_languageserver_1.FoldingRangeKind.Region;
+    }
+}
+// https://github.com/microsoft/vscode/blob/bed61166fb604e519e82e4d1d1ed839bc45d65f8/extensions/typescript-language-features/src/languageFeatures/folding.ts#L61-L73
+function adjustFoldingEnd(start, end, document) {
+    // workaround for #47240
+    if (end.character > 0) {
+        const foldEndCharacter = document.getText({
+            start: { line: end.line, character: end.character - 1 },
+            end,
+        });
+        if (['}', ']', ')', '`'].includes(foldEndCharacter)) {
+            const endOffset = Math.max(document.offsetAt({ line: end.line, character: 0 }) - 1, document.offsetAt(start));
+            return document.positionAt(endOffset);
+        }
+    }
+    return end;
+}

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

@@ -25,7 +25,7 @@ class SemanticTokensProviderImpl {
             length: range
                 ? fragment.offsetAt(fragment.getGeneratedPosition(range.end)) - start
                 : // We don't want tokens for things added by astro2tsx
-                    fragment.text.lastIndexOf('export default function (_props:') || fragment.text.length,
+                    fragment.text.lastIndexOf('export default function ') || fragment.text.length,
         }, typescript_1.default.SemanticClassificationFormat.TwentyTwenty);
         const tokens = [];
         let i = 0;

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

@@ -1,5 +1,7 @@
 import type { SnapshotFragment, DocumentSnapshot } from '../snapshots/DocumentSnapshot';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
+import { Position } from 'vscode-languageserver';
+export declare function isPartOfImportStatement(text: string, position: Position): boolean;
 export declare class SnapshotFragmentMap {
     private languageServiceManager;
     private map;

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

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnapshotFragmentMap = void 0;
+exports.SnapshotFragmentMap = exports.isPartOfImportStatement = void 0;
+const documents_1 = require("../../../core/documents");
+function isPartOfImportStatement(text, position) {
+    const line = (0, documents_1.getLineAtPosition)(position, text);
+    return /\s*from\s+["'][^"']*/.test(line.slice(0, position.character));
+}
+exports.isPartOfImportStatement = isPartOfImportStatement;
 class SnapshotFragmentMap {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;

package/dist/plugins/typescript/snapshots/utils.js

@@ -6,12 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFromFrameworkFilePath = exports.createFromAstroFilePath = exports.createFromTSFilePath = exports.createFromNonAstroFilePath = exports.createFromFilePath = exports.createFromDocument = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const astro2tsx_1 = __importDefault(require("../astro2tsx"));
+const vscode_uri_1 = require("vscode-uri");
 const utils_1 = require("../utils");
 const DocumentSnapshot_1 = require("./DocumentSnapshot");
 const svelte_language_integration_1 = require("@astrojs/svelte-language-integration");
+const utils_2 = require("../../../utils");
 // Utilities to create Snapshots from different contexts
 function createFromDocument(document) {
-    const { code } = (0, astro2tsx_1.default)(document.getText());
+    const { code } = (0, astro2tsx_1.default)(document.getText(), classNameFromFilename(document.getURL()));
     return new DocumentSnapshot_1.AstroSnapshot(document, code, typescript_1.default.ScriptKind.TSX);
 }
 exports.createFromDocument = createFromDocument;
@@ -71,14 +73,33 @@ function createFromAstroFilePath(filePath, createDocument) {
 exports.createFromAstroFilePath = createFromAstroFilePath;
 function createFromFrameworkFilePath(filePath, framework) {
     var _a;
+    const className = classNameFromFilename(filePath);
     const originalText = (_a = typescript_1.default.sys.readFile(filePath)) !== null && _a !== void 0 ? _a : '';
     let code = '';
     if (framework === 'svelte') {
-        code = (0, svelte_language_integration_1.toTSX)(originalText);
+        code = (0, svelte_language_integration_1.toTSX)(originalText, className);
     }
     else {
-        code = 'export default function(props: Record<string, any>): any {<div></div>}';
+        code = `export default function ${className}__AstroComponent_(props: Record<string, any>): any {}`;
     }
     return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, code, typescript_1.default.ScriptKind.TSX);
 }
 exports.createFromFrameworkFilePath = createFromFrameworkFilePath;
+function classNameFromFilename(filename) {
+    const url = vscode_uri_1.URI.parse(filename);
+    const withoutExtensions = vscode_uri_1.Utils.basename(url).slice(0, -vscode_uri_1.Utils.extname(url).length);
+    const withoutInvalidCharacters = withoutExtensions
+        .split('')
+        // Although "-" is invalid, we leave it in, pascal-case-handling will throw it out later
+        .filter((char) => /[A-Za-z$_\d-]/.test(char))
+        .join('');
+    const firstValidCharIdx = withoutInvalidCharacters
+        .split('')
+        // Although _ and $ are valid first characters for classes, they are invalid first characters
+        // for tag names. For a better import autocompletion experience, we therefore throw them out.
+        .findIndex((char) => /[A-Za-z]/.test(char));
+    const withoutLeadingInvalidCharacters = withoutInvalidCharacters.substr(firstValidCharIdx);
+    const inPascalCase = (0, utils_2.toPascalCase)(withoutLeadingInvalidCharacters);
+    const finalName = firstValidCharIdx === -1 ? `A${inPascalCase}` : inPascalCase;
+    return finalName;
+}

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

@@ -1,5 +1,6 @@
 import ts from 'typescript';
 import { CompletionItemKind, DiagnosticSeverity, Position, Range, SymbolKind, SemanticTokensLegend } from 'vscode-languageserver';
+import { AstroDocument } from '../../core/documents';
 import { SnapshotFragment } from './snapshots/DocumentSnapshot';
 export declare const enum TokenType {
     class = 0,
@@ -39,6 +40,8 @@ export declare function convertRange(document: {
     length?: number;
 }): Range;
 export declare function convertToLocationRange(defDoc: SnapshotFragment, textSpan: ts.TextSpan): Range;
+export declare function ensureFrontmatterInsert(resultRange: Range, document: AstroDocument): Range;
+export declare function removeAstroComponentSuffix(name: string): string;
 export declare type FrameworkExt = 'astro' | 'vue' | 'jsx' | 'tsx' | 'svelte';
 declare type FrameworkVirtualExt = 'ts' | 'tsx';
 export declare function getFrameworkFromFilePath(filePath: string): FrameworkExt;

package/dist/plugins/typescript/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureRealFilePath = exports.ensureRealAstroFilePath = exports.toRealAstroFilePath = exports.toVirtualFilePath = exports.toVirtualAstroFilePath = exports.isVirtualFilePath = exports.isVirtualSvelteFilePath = exports.isVirtualVueFilePath = exports.isVirtualAstroFilePath = exports.isFrameworkFilePath = exports.isAstroFilePath = exports.isVirtualFrameworkFilePath = exports.getFrameworkFromFilePath = exports.convertToLocationRange = exports.convertRange = exports.mapSeverity = exports.getScriptKindFromFileName = exports.isSubPath = exports.findTsConfigPath = exports.getExtensionFromScriptKind = exports.getCommitCharactersForScriptElement = exports.scriptElementKindToCompletionItemKind = exports.symbolKindFromString = exports.getSemanticTokenLegend = void 0;
+exports.ensureRealFilePath = exports.ensureRealAstroFilePath = exports.toRealAstroFilePath = exports.toVirtualFilePath = exports.toVirtualAstroFilePath = exports.isVirtualFilePath = exports.isVirtualSvelteFilePath = exports.isVirtualVueFilePath = exports.isVirtualAstroFilePath = exports.isFrameworkFilePath = exports.isAstroFilePath = exports.isVirtualFrameworkFilePath = exports.getFrameworkFromFilePath = exports.removeAstroComponentSuffix = exports.ensureFrontmatterInsert = exports.convertToLocationRange = exports.convertRange = exports.mapSeverity = exports.getScriptKindFromFileName = exports.isSubPath = exports.findTsConfigPath = exports.getExtensionFromScriptKind = exports.getCommitCharactersForScriptElement = exports.scriptElementKindToCompletionItemKind = exports.symbolKindFromString = exports.getSemanticTokenLegend = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const path_1 = require("path");
 const utils_1 = require("../../utils");
@@ -239,6 +239,22 @@ function convertToLocationRange(defDoc, textSpan) {
     return range;
 }
 exports.convertToLocationRange = convertToLocationRange;
+// Some code actions will insert code at the start of the file instead of inside our frontmatter
+// We'll redirect those to the proper starting place
+function ensureFrontmatterInsert(resultRange, document) {
+    if (document.astroMeta.frontmatter.state === 'closed') {
+        const position = document.positionAt(document.astroMeta.frontmatter.startOffset);
+        position.line += 1;
+        position.character = resultRange.start.character;
+        return vscode_languageserver_1.Range.create(position, position);
+    }
+    return resultRange;
+}
+exports.ensureFrontmatterInsert = ensureFrontmatterInsert;
+function removeAstroComponentSuffix(name) {
+    return name.replace(/(\w+)__AstroComponent_/, '$1');
+}
+exports.removeAstroComponentSuffix = removeAstroComponentSuffix;
 const VirtualExtension = {
     ts: 'ts',
     tsx: 'tsx',

package/dist/utils.d.ts

@@ -16,6 +16,10 @@ export declare function pathToUrl(path: string): string;
  * (bar or bar.astro in this example).
  */
 export declare function getLastPartOfPath(path: string): string;
+/**
+ * Transform a string into PascalCase
+ */
+export declare function toPascalCase(string: string): string;
 /**
  * Return true if a specific node could be a component.
  * This is not a 100% sure test as it'll return false for any component that does not match the standard format for a component
@@ -28,6 +32,10 @@ export declare function clamp(num: number, min: number, max: number): number;
 export declare function isNotNullOrUndefined<T>(val: T | undefined | null): val is T;
 export declare function isInRange(range: Range, positionToTest: Position): boolean;
 export declare function isBeforeOrEqualToPosition(position: Position, positionToTest: Position): boolean;
+/**
+ * Get all matches of a regexp.
+ */
+export declare function getRegExpMatches(regex: RegExp, str: string): RegExpExecArray[];
 /**
  * Debounces a function but cancels previous invocation only if
  * a second function determines it should.

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUserAstroVersion = exports.debounceThrottle = exports.debounceSameArg = exports.isBeforeOrEqualToPosition = exports.isInRange = exports.isNotNullOrUndefined = exports.clamp = exports.flatten = exports.isPossibleComponent = exports.getLastPartOfPath = exports.pathToUrl = exports.urlToPath = exports.normalizePath = exports.normalizeUri = void 0;
+exports.getUserAstroVersion = exports.debounceThrottle = exports.debounceSameArg = exports.getRegExpMatches = exports.isBeforeOrEqualToPosition = exports.isInRange = exports.isNotNullOrUndefined = exports.clamp = exports.flatten = exports.isPossibleComponent = exports.toPascalCase = exports.getLastPartOfPath = exports.pathToUrl = exports.urlToPath = exports.normalizePath = exports.normalizeUri = void 0;
 const vscode_uri_1 = require("vscode-uri");
 /** Normalizes a document URI */
 function normalizeUri(uri) {
@@ -37,6 +37,17 @@ function getLastPartOfPath(path) {
     return path.replace(/\\/g, '/').split('/').pop() || '';
 }
 exports.getLastPartOfPath = getLastPartOfPath;
+/**
+ * Transform a string into PascalCase
+ */
+function toPascalCase(string) {
+    return `${string}`
+        .replace(new RegExp(/[-_]+/, 'g'), ' ')
+        .replace(new RegExp(/[^\w\s]/, 'g'), '')
+        .replace(new RegExp(/\s+(.)(\w*)/, 'g'), ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`)
+        .replace(new RegExp(/\w/), (s) => s.toUpperCase());
+}
+exports.toPascalCase = toPascalCase;
 /**
  * Return true if a specific node could be a component.
  * This is not a 100% sure test as it'll return false for any component that does not match the standard format for a component
@@ -69,6 +80,18 @@ function isBeforeOrEqualToPosition(position, positionToTest) {
         (positionToTest.line === position.line && positionToTest.character <= position.character));
 }
 exports.isBeforeOrEqualToPosition = isBeforeOrEqualToPosition;
+/**
+ * Get all matches of a regexp.
+ */
+function getRegExpMatches(regex, str) {
+    const matches = [];
+    let match;
+    while ((match = regex.exec(str))) {
+        matches.push(match);
+    }
+    return matches;
+}
+exports.getRegExpMatches = getRegExpMatches;
 /**
  * Debounces a function but cancels previous invocation only if
  * a second function determines it should.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",
@@ -19,7 +19,7 @@
     "test": "cross-env TS_NODE_TRANSPILE_ONLY=true mocha --timeout 20000 --require ts-node/register \"test/**/*.ts\" --exclude \"test/**/*.d.ts\""
   },
   "dependencies": {
-    "@astrojs/svelte-language-integration": "^0.1.2",
+    "@astrojs/svelte-language-integration": "^0.1.3",
     "@vscode/emmet-helper": "^2.8.4",
     "lodash": "^4.17.21",
     "source-map": "^0.7.3",