@astrojs/language-server 0.16.1 → 0.18.1

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @astrojs/language-server
 
+## 0.18.1
+
+### Patch Changes
+
+- 666739a: Revert update to latest LSP and inlay hints support
+
+## 0.18.0
+
+### Minor Changes
+
+- d3c6fd8: Add support for formatting
+- 09e1163: Updated language server to latest version of LSP, added support for Inlay Hints
+- fcaba8e: Add support for completions and type checking for Vue props
+
+### Patch Changes
+
+- 4138005: Fix frontmatter folding not working properly when last few lines of frontmatter are empty
+- 76ff46a: Add `?` in the label of completions of optional parameters (including component props)
+
+## 0.17.0
+
+### Minor Changes
+
+- 3ad0f65: Add support for TypeScript features inside script tags (completions, diagnostics, hover etc)
+
+### Patch Changes
+
+- 2e9da14: Add support for loading props completions from .d.ts files, improve performance of props completions
+
 ## 0.16.1
 
 ### Patch Changes

package/dist/core/config/ConfigManager.d.ts

@@ -1,6 +1,6 @@
 import { VSCodeEmmetConfig } from '@vscode/emmet-helper';
-import { LSConfig, LSCSSConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
-import { Connection } from 'vscode-languageserver';
+import { LSConfig, LSCSSConfig, LSFormatConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
+import { Connection, FormattingOptions } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { FormatCodeSettings, UserPreferences } from 'typescript';
 export declare const defaultLSConfig: LSConfig;
@@ -22,7 +22,8 @@ export declare class ConfigManager {
     removeDocument(scopeUri: string): void;
     getConfig<T>(section: string, scopeUri: string): Promise<T>;
     getEmmetConfig(document: TextDocument): Promise<VSCodeEmmetConfig>;
-    getTSFormatConfig(document: TextDocument): Promise<FormatCodeSettings>;
+    getAstroFormatConfig(document: TextDocument): Promise<LSFormatConfig>;
+    getTSFormatConfig(document: TextDocument, vscodeOptions?: FormattingOptions): Promise<FormatCodeSettings>;
     getTSPreferences(document: TextDocument): Promise<UserPreferences>;
     /**
      * Return true if a plugin and an optional feature is enabled

package/dist/core/config/ConfigManager.js

@@ -30,6 +30,10 @@ exports.defaultLSConfig = {
         tagComplete: { enabled: true },
         documentSymbols: { enabled: true },
     },
+    format: {
+        indentFrontmatter: true,
+        newLineAfterFrontmatter: true,
+    },
 };
 /**
  * Manager class to facilitate accessing and updating the user's config
@@ -69,9 +73,19 @@ class ConfigManager {
         const emmetConfig = (await this.getConfig('emmet', document.uri)) ?? {};
         return emmetConfig;
     }
-    async getTSFormatConfig(document) {
+    async getAstroFormatConfig(document) {
+        const astroFormatConfig = (await this.getConfig('astro.format', document.uri)) ?? {};
+        return {
+            indentFrontmatter: astroFormatConfig.indentFrontmatter ?? true,
+            newLineAfterFrontmatter: astroFormatConfig.newLineAfterFrontmatter ?? true,
+        };
+    }
+    async getTSFormatConfig(document, vscodeOptions) {
         const formatConfig = (await this.getConfig('typescript.format', document.uri)) ?? {};
         return {
+            tabSize: vscodeOptions?.tabSize,
+            indentSize: vscodeOptions?.tabSize,
+            convertTabsToSpaces: vscodeOptions?.insertSpaces,
             // We can use \n here since the editor normalizes later on to its line endings.
             newLineCharacter: '\n',
             insertSpaceAfterCommaDelimiter: formatConfig.insertSpaceAfterCommaDelimiter ?? true,

package/dist/core/config/interfaces.d.ts

@@ -6,6 +6,11 @@ export interface LSConfig {
     typescript: LSTypescriptConfig;
     html: LSHTMLConfig;
     css: LSCSSConfig;
+    format: LSFormatConfig;
+}
+export interface LSFormatConfig {
+    indentFrontmatter: boolean;
+    newLineAfterFrontmatter: boolean;
 }
 export interface LSTypescriptConfig {
     enabled: boolean;

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

@@ -9,6 +9,7 @@ export declare class AstroDocument extends WritableDocument {
     astroMeta: AstroMetadata;
     html: HTMLDocument;
     styleTags: TagInformation[];
+    scriptTags: TagInformation[];
     constructor(url: string, content: string);
     private updateDocInfo;
     setText(text: string): void;

package/dist/core/documents/AstroDocument.js

@@ -18,6 +18,7 @@ class AstroDocument extends DocumentBase_1.WritableDocument {
         this.astroMeta = (0, parseAstro_1.parseAstro)(this.content);
         this.html = (0, parseHtml_1.parseHtml)(this.content);
         this.styleTags = (0, utils_2.extractStyleTags)(this.content, this.html);
+        this.scriptTags = (0, utils_2.extractScriptTags)(this.content, this.html);
     }
     setText(text) {
         this.content = text;

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

@@ -46,6 +46,8 @@ export declare class FragmentMapper implements DocumentMapper {
     private originalText;
     private tagInfo;
     private url;
+    private lineOffsetsOriginal;
+    private lineOffsetsGenerated;
     constructor(originalText: string, tagInfo: TagInformation, url: string);
     getOriginalPosition(generatedPosition: Position): Position;
     private offsetInParent;

package/dist/core/documents/DocumentMapper.js

@@ -45,20 +45,22 @@ class FragmentMapper {
         this.originalText = originalText;
         this.tagInfo = tagInfo;
         this.url = url;
+        this.lineOffsetsOriginal = (0, utils_1.getLineOffsets)(this.originalText);
+        this.lineOffsetsGenerated = (0, utils_1.getLineOffsets)(this.tagInfo.content);
     }
     getOriginalPosition(generatedPosition) {
-        const parentOffset = this.offsetInParent((0, utils_1.offsetAt)(generatedPosition, this.tagInfo.content));
-        return (0, utils_1.positionAt)(parentOffset, this.originalText);
+        const parentOffset = this.offsetInParent((0, utils_1.offsetAt)(generatedPosition, this.tagInfo.content, this.lineOffsetsGenerated));
+        return (0, utils_1.positionAt)(parentOffset, this.originalText, this.lineOffsetsOriginal);
     }
     offsetInParent(offset) {
         return this.tagInfo.start + offset;
     }
     getGeneratedPosition(originalPosition) {
-        const fragmentOffset = (0, utils_1.offsetAt)(originalPosition, this.originalText) - this.tagInfo.start;
-        return (0, utils_1.positionAt)(fragmentOffset, this.tagInfo.content);
+        const fragmentOffset = (0, utils_1.offsetAt)(originalPosition, this.originalText, this.lineOffsetsOriginal) - this.tagInfo.start;
+        return (0, utils_1.positionAt)(fragmentOffset, this.tagInfo.content, this.lineOffsetsGenerated);
     }
     isInGenerated(pos) {
-        const offset = (0, utils_1.offsetAt)(pos, this.originalText);
+        const offset = (0, utils_1.offsetAt)(pos, this.originalText, this.lineOffsetsOriginal);
         return offset >= this.tagInfo.start && offset <= this.tagInfo.end;
     }
     getURL() {

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

@@ -15,6 +15,7 @@ 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 extractScriptTags(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

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.getNodeIfIsInHTMLStartTag = exports.getLineAtPosition = 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.extractScriptTags = exports.extractStyleTags = exports.walk = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_1 = require("../../utils");
 const parseHtml_1 = require("./parseHtml");
@@ -28,6 +28,13 @@ function extractTags(text, tag, html) {
             }
         }
     }
+    if (tag === 'script' && !matchedNodes.length && rootNodes.length) {
+        for (let child of walk(rootNodes[0])) {
+            if (child.tag === 'script') {
+                matchedNodes.push(child);
+            }
+        }
+    }
     return matchedNodes.map(transformToTagInfo);
     function transformToTagInfo(matchedNode) {
         const start = matchedNode.startTagEnd ?? matchedNode.start;
@@ -60,6 +67,14 @@ function extractStyleTags(source, html) {
     return styles;
 }
 exports.extractStyleTags = extractStyleTags;
+function extractScriptTags(source, html) {
+    const scripts = extractTags(source, 'script', html);
+    if (!scripts.length) {
+        return [];
+    }
+    return scripts;
+}
+exports.extractScriptTags = extractScriptTags;
 function parseAttributes(rawAttrs) {
     const attrs = {};
     if (!rawAttrs) {

package/dist/plugins/PluginHost.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, SymbolInformation, SemanticTokens, CodeActionContext, CodeAction } from 'vscode-languageserver';
+import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, SymbolInformation, SemanticTokens, CodeActionContext, CodeAction, FormattingOptions, TextEdit } from 'vscode-languageserver';
 import type { AppCompletionItem, Plugin } from './interfaces';
 import { DocumentManager } from '../core/documents/DocumentManager';
 interface PluginHostConfig {
@@ -16,6 +16,7 @@ export declare class PluginHost {
     resolveCompletion(textDocument: TextDocumentIdentifier, completionItem: AppCompletionItem): Promise<CompletionItem>;
     getDiagnostics(textDocument: TextDocumentIdentifier): Promise<Diagnostic[]>;
     doHover(textDocument: TextDocumentIdentifier, position: Position): Promise<Hover | null>;
+    formatDocument(textDocument: TextDocumentIdentifier, options: FormattingOptions): Promise<TextEdit[]>;
     getCodeActions(textDocument: TextDocumentIdentifier, range: Range, context: CodeActionContext, cancellationToken: CancellationToken): Promise<CodeAction[]>;
     doTagComplete(textDocument: TextDocumentIdentifier, position: Position): Promise<string | null>;
     getFoldingRanges(textDocument: TextDocumentIdentifier): Promise<FoldingRange[] | null>;

package/dist/plugins/PluginHost.js

@@ -69,6 +69,10 @@ class PluginHost {
         const document = this.getDocument(textDocument.uri);
         return this.execute('doHover', [document, position], ExecuteMode.FirstNonNull);
     }
+    async formatDocument(textDocument, options) {
+        const document = this.getDocument(textDocument.uri);
+        return (0, lodash_1.flatten)(await this.execute('formatDocument', [document, options], ExecuteMode.Collect));
+    }
     async getCodeActions(textDocument, range, context, cancellationToken) {
         const document = this.getDocument(textDocument.uri);
         return (0, lodash_1.flatten)(await this.execute('getCodeActions', [document, range, context, cancellationToken], ExecuteMode.Collect));

package/dist/plugins/astro/AstroPlugin.js

@@ -9,7 +9,7 @@ class AstroPlugin {
         this.__name = 'astro';
         this.configManager = configManager;
         this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
-        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(docManager, this.languageServiceManager);
+        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
     }
     async getCompletions(document, position, completionContext) {
         const completions = this.completionProvider.getCompletions(document, position, completionContext);
@@ -21,8 +21,15 @@ class AstroPlugin {
         // Currently editing frontmatter, don't fold
         if (frontmatter.state !== 'closed')
             return foldingRanges;
-        const start = document.positionAt(frontmatter.startOffset);
-        const end = document.positionAt(frontmatter.endOffset - 3);
+        // The way folding ranges work is by folding anything between the starting position and the ending one, as such
+        // the start in this case should be after the frontmatter start (after the starting ---) until the last character
+        // of the last line of the frontmatter before its ending (before the closing ---)
+        // ---
+        //		^ -- start
+        // console.log("Astro")
+        // ---								^ -- end
+        const start = document.positionAt(frontmatter.startOffset + 3);
+        const end = document.positionAt(frontmatter.endOffset - 1);
         return [
             {
                 startLine: start.line,

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

@@ -1,17 +1,16 @@
 import type { AppCompletionList, CompletionsProvider } from '../../interfaces';
-import type { AstroDocument, DocumentManager } from '../../../core/documents';
+import type { AstroDocument } from '../../../core/documents';
 import { CompletionContext, Position } from 'vscode-languageserver';
 import { LanguageServiceManager as TypeScriptLanguageServiceManager } from '../../typescript/LanguageServiceManager';
 export declare class CompletionsProviderImpl implements CompletionsProvider {
-    private readonly docManager;
     private readonly languageServiceManager;
+    private lastCompletion;
     directivesHTMLLang: import("vscode-html-languageservice").LanguageService;
-    constructor(docManager: DocumentManager, languageServiceManager: TypeScriptLanguageServiceManager);
+    constructor(languageServiceManager: TypeScriptLanguageServiceManager);
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
     private getComponentScriptCompletion;
-    private getPropCompletions;
+    private getPropCompletionsAndFilePath;
     private getImportedSymbol;
     private getPropType;
     private getCompletionItemForProperty;
-    private isAstroComponent;
 }

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

@@ -13,21 +13,18 @@ const vscode_html_languageservice_1 = require("vscode-html-languageservice");
 const astro_attributes_1 = require("../../html/features/astro-attributes");
 const utils_4 = require("../../html/utils");
 class CompletionsProviderImpl {
-    constructor(docManager, languageServiceManager) {
+    constructor(languageServiceManager) {
+        this.lastCompletion = null;
         this.directivesHTMLLang = (0, vscode_html_languageservice_1.getLanguageService)({
             customDataProviders: [astro_attributes_1.astroDirectives],
             useDefaultDataProvider: false,
         });
-        this.docManager = docManager;
         this.languageServiceManager = languageServiceManager;
     }
     async getCompletions(document, position, completionContext) {
-        const doc = this.docManager.get(document.uri);
-        if (!doc)
-            return null;
         let items = [];
         if (completionContext?.triggerCharacter === '-') {
-            const frontmatter = this.getComponentScriptCompletion(doc, position, completionContext);
+            const frontmatter = this.getComponentScriptCompletion(document, position);
             if (frontmatter)
                 items.push(frontmatter);
         }
@@ -35,11 +32,11 @@ class CompletionsProviderImpl {
         const offset = document.offsetAt(position);
         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);
+            const { completions: props, componentFilePath } = await this.getPropCompletionsAndFilePath(document, position, completionContext);
             if (props.length) {
                 items.push(...props);
             }
-            const isAstro = await this.isAstroComponent(document, node);
+            const isAstro = componentFilePath?.endsWith('.astro');
             if (!isAstro) {
                 const directives = (0, utils_4.removeDataAttrCompletion)(this.directivesHTMLLang.doComplete(document, position, html).items);
                 items.push(...directives);
@@ -47,7 +44,7 @@ class CompletionsProviderImpl {
         }
         return vscode_languageserver_1.CompletionList.create(items, true);
     }
-    getComponentScriptCompletion(document, position, completionContext) {
+    getComponentScriptCompletion(document, position) {
         const base = {
             kind: vscode_languageserver_1.CompletionItemKind.Snippet,
             label: '---',
@@ -55,7 +52,7 @@ class CompletionsProviderImpl {
             preselect: true,
             detail: 'Component script',
             insertTextFormat: vscode_languageserver_1.InsertTextFormat.Snippet,
-            commitCharacters: ['-'],
+            commitCharacters: [],
         };
         const prefix = document.getLineUntilOffset(document.offsetAt(position));
         if (document.astroMeta.frontmatter.state === null) {
@@ -78,25 +75,25 @@ class CompletionsProviderImpl {
         }
         return null;
     }
-    async getPropCompletions(document, position, completionContext) {
+    async getPropCompletionsAndFilePath(document, position, completionContext) {
         const offset = document.offsetAt(position);
         const html = document.html;
         const node = html.findNodeAt(offset);
         if (!(0, utils_2.isPossibleComponent)(node)) {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         const inAttribute = node.start + node.tag.length < offset;
         if (!inAttribute) {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         if (completionContext?.triggerCharacter === '/' || completionContext?.triggerCharacter === '>') {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         // If inside of attribute value, skip.
         if (completionContext &&
             completionContext.triggerKind === vscode_languageserver_1.CompletionTriggerKind.TriggerCharacter &&
             completionContext.triggerCharacter === '"') {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         const componentName = node.tag;
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -106,18 +103,34 @@ class CompletionsProviderImpl {
         const sourceFile = program?.getSourceFile(tsFilePath);
         const typeChecker = program?.getTypeChecker();
         if (!sourceFile || !typeChecker) {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         // Get the import statement
         const imp = this.getImportedSymbol(sourceFile, componentName);
         const importType = imp && typeChecker.getTypeAtLocation(imp);
         if (!importType) {
-            return [];
+            return { completions: [], componentFilePath: null };
+        }
+        const symbol = importType.getSymbol();
+        if (!symbol) {
+            return { completions: [], componentFilePath: null };
+        }
+        const symbolDeclaration = symbol.declarations;
+        if (!symbolDeclaration) {
+            return { completions: [], componentFilePath: null };
+        }
+        const filePath = symbolDeclaration[0].getSourceFile().fileName;
+        const componentSnapshot = await this.languageServiceManager.getSnapshot(filePath);
+        if (this.lastCompletion) {
+            if (this.lastCompletion.tag === componentName &&
+                this.lastCompletion.documentVersion == componentSnapshot.version) {
+                return { completions: this.lastCompletion.completions, componentFilePath: filePath };
+            }
         }
         // Get the component's props type
-        const componentType = this.getPropType(importType, typeChecker);
+        const componentType = this.getPropType(symbolDeclaration, typeChecker);
         if (!componentType) {
-            return [];
+            return { completions: [], componentFilePath: null };
         }
         let completionItems = [];
         // Add completions for this component's props type properties
@@ -127,11 +140,12 @@ class CompletionsProviderImpl {
             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
-        completionItems = completionItems.map((item) => {
-            return { ...item, sortText: '_' };
-        });
-        return completionItems;
+        this.lastCompletion = {
+            tag: componentName,
+            documentVersion: componentSnapshot.version,
+            completions: completionItems,
+        };
+        return { completions: completionItems, componentFilePath: filePath };
     }
     getImportedSymbol(sourceFile, identifier) {
         for (let list of sourceFile.getChildren()) {
@@ -159,24 +173,20 @@ class CompletionsProviderImpl {
         }
         return null;
     }
-    getPropType(type, typeChecker) {
-        const sym = type?.getSymbol();
-        if (!sym) {
-            return null;
-        }
-        for (const decl of sym?.getDeclarations() || []) {
+    getPropType(declarations, typeChecker) {
+        for (const decl of declarations) {
             const fileName = (0, utils_3.toVirtualFilePath)(decl.getSourceFile().fileName);
-            if (fileName.endsWith('.tsx') || fileName.endsWith('.jsx')) {
-                if (!typescript_1.default.isFunctionDeclaration(decl)) {
-                    console.error(`We only support function components for tsx/jsx at the moment.`);
+            if (fileName.endsWith('.tsx') || fileName.endsWith('.jsx') || fileName.endsWith('.d.ts')) {
+                if (!typescript_1.default.isFunctionDeclaration(decl) && !typescript_1.default.isFunctionTypeNode(decl)) {
+                    console.error(`We only support functions declarations at the moment`);
                     continue;
                 }
                 const fn = decl;
                 if (!fn.parameters.length)
                     continue;
                 const param1 = fn.parameters[0];
-                const type = typeChecker.getTypeAtLocation(param1);
-                return type;
+                const propType = typeChecker.getTypeAtLocation(param1);
+                return propType;
             }
         }
         return null;
@@ -201,7 +211,15 @@ class CompletionsProviderImpl {
             insertText: insertText,
             insertTextFormat: vscode_languageserver_1.InsertTextFormat.Snippet,
             commitCharacters: [],
+            // Ensure that props shows up first as a completion, despite this plugin being ran after the HTML one
+            sortText: '\0',
         };
+        if (mem.flags & typescript_1.default.SymbolFlags.Optional) {
+            item.filterText = item.label;
+            item.label += '?';
+            // Put optional props at a lower priority
+            item.sortText = '_';
+        }
         mem.getDocumentationComment(typeChecker);
         let description = mem
             .getDocumentationComment(typeChecker)
@@ -216,28 +234,5 @@ class CompletionsProviderImpl {
         }
         return item;
     }
-    async isAstroComponent(document, node) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        // Get the source file
-        const tsFilePath = (0, utils_3.toVirtualAstroFilePath)(tsDoc.filePath);
-        const program = lang.getProgram();
-        const sourceFile = program?.getSourceFile(tsFilePath);
-        const typeChecker = program?.getTypeChecker();
-        if (!sourceFile || !typeChecker) {
-            return false;
-        }
-        const componentName = node.tag;
-        const imp = this.getImportedSymbol(sourceFile, componentName);
-        const importType = imp && typeChecker.getTypeAtLocation(imp);
-        if (!importType) {
-            return false;
-        }
-        const symbolDeclaration = importType.getSymbol()?.declarations;
-        if (symbolDeclaration) {
-            const fileName = symbolDeclaration[0].getSourceFile().fileName;
-            return fileName.endsWith('.astro');
-        }
-        return false;
-    }
 }
 exports.CompletionsProviderImpl = CompletionsProviderImpl;

package/dist/plugins/html/HTMLPlugin.d.ts

@@ -1,4 +1,4 @@
-import { CompletionList, Position, FoldingRange, Hover, SymbolInformation } from 'vscode-languageserver';
+import { CompletionList, Position, TextEdit, FoldingRange, Hover, SymbolInformation, FormattingOptions } from 'vscode-languageserver';
 import type { Plugin } from '../interfaces';
 import { ConfigManager } from '../../core/config/ConfigManager';
 import { AstroDocument } from '../../core/documents/AstroDocument';
@@ -15,6 +15,7 @@ export declare class HTMLPlugin implements Plugin {
      * Get HTML completions
      */
     getCompletions(document: AstroDocument, position: Position): Promise<CompletionList | null>;
+    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
     doTagComplete(document: AstroDocument, position: Position): Promise<string | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;

package/dist/plugins/html/HTMLPlugin.js

@@ -80,6 +80,24 @@ class HTMLPlugin {
         // Emmet completions change on every keystroke, so they are never complete
         emmetResults.items.length > 0);
     }
+    async formatDocument(document, options) {
+        const start = document.positionAt(document.astroMeta.frontmatter.state === 'closed' ? document.astroMeta.frontmatter.endOffset + 3 : 0);
+        if (document.astroMeta.frontmatter.state === 'closed') {
+            start.line += 1;
+            start.character = 0;
+        }
+        const end = document.positionAt(document.getTextLength());
+        const htmlFormatConfig = (await this.configManager.getConfig('html.format', document.uri)) ?? {};
+        // The HTML plugin can't format script tags properly, we'll handle those inside the TypeScript plugin
+        if (htmlFormatConfig.contentUnformatted) {
+            htmlFormatConfig.contentUnformatted = htmlFormatConfig.contentUnformatted + ',script';
+        }
+        else {
+            htmlFormatConfig.contentUnformatted = 'script';
+        }
+        const edits = this.lang.format(document, vscode_languageserver_1.Range.create(start, end), { ...htmlFormatConfig, ...options });
+        return edits;
+    }
     getFoldingRanges(document) {
         const html = document.html;
         if (!html) {

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

@@ -1,4 +1,4 @@
-import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -16,9 +16,11 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly documentSymbolsProvider;
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
+    private readonly formattingProvider;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
     getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
     getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -17,6 +17,7 @@ const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
 const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
+const FormattingProvider_1 = require("./features/FormattingProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
@@ -31,6 +32,7 @@ class TypeScriptPlugin {
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
         this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
         this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
+        this.formattingProvider = new FormattingProvider_1.FormattingProviderImpl(this.languageServiceManager, this.configManager);
     }
     async doHover(document, position) {
         if (!(await this.featureEnabled(document, 'hover'))) {
@@ -61,6 +63,9 @@ class TypeScriptPlugin {
         });
         return edit;
     }
+    async formatDocument(document, options) {
+        return this.formattingProvider.formatDocument(document, options);
+    }
     async getFoldingRanges(document) {
         return this.foldingRangesProvider.getFoldingRanges(document);
     }