@astrojs/language-server 0.16.0 → 0.18.0

package/dist/plugins/astro/AstroPlugin.js

@@ -1,22 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroPlugin = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
-const documents_1 = require("../../core/documents");
-const utils_1 = require("../../utils");
 const LanguageServiceManager_1 = require("../typescript/LanguageServiceManager");
-const utils_2 = require("../typescript/utils");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 class AstroPlugin {
     constructor(docManager, configManager, workspaceUris) {
         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);
@@ -28,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,
@@ -40,80 +40,5 @@ class AstroPlugin {
             },
         ];
     }
-    async getDefinitions(document, position) {
-        if (this.isInsideFrontmatter(document, position)) {
-            return [];
-        }
-        const offset = document.offsetAt(position);
-        const html = document.html;
-        const node = html.findNodeAt(offset);
-        if (!this.isComponentTag(node)) {
-            return [];
-        }
-        const [componentName] = node.tag.split(':');
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const defs = this.getDefinitionsForComponentName(document, lang, componentName);
-        if (!defs || !defs.length) {
-            return [];
-        }
-        const startRange = vscode_languageserver_1.Range.create(vscode_languageserver_1.Position.create(0, 0), vscode_languageserver_1.Position.create(0, 0));
-        const links = defs.map((def) => {
-            const defFilePath = (0, utils_2.ensureRealFilePath)(def.fileName);
-            return vscode_languageserver_1.LocationLink.create((0, utils_1.pathToUrl)(defFilePath), startRange, startRange);
-        });
-        return links;
-    }
-    isInsideFrontmatter(document, position) {
-        return (0, documents_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position));
-    }
-    isComponentTag(node) {
-        if (!node.tag) {
-            return false;
-        }
-        const firstChar = node.tag[0];
-        return /[A-Z]/.test(firstChar);
-    }
-    getDefinitionsForComponentName(document, lang, componentName) {
-        const filePath = (0, utils_1.urlToPath)(document.uri);
-        const tsFilePath = (0, utils_2.toVirtualAstroFilePath)(filePath);
-        const program = lang.getProgram();
-        const sourceFile = program?.getSourceFile(tsFilePath);
-        if (!sourceFile) {
-            return undefined;
-        }
-        const specifier = this.getImportSpecifierForIdentifier(sourceFile, componentName);
-        if (!specifier) {
-            return [];
-        }
-        const defs = lang.getDefinitionAtPosition(tsFilePath, specifier.getStart());
-        if (!defs) {
-            return undefined;
-        }
-        return defs;
-    }
-    getImportSpecifierForIdentifier(sourceFile, identifier) {
-        let importSpecifier = undefined;
-        typescript_1.default.forEachChild(sourceFile, (tsNode) => {
-            if (typescript_1.default.isImportDeclaration(tsNode)) {
-                if (tsNode.importClause) {
-                    const { name, namedBindings } = tsNode.importClause;
-                    if (name && name.getText() === identifier) {
-                        importSpecifier = tsNode.moduleSpecifier;
-                        return true;
-                    }
-                    else if (namedBindings && namedBindings.kind === typescript_1.default.SyntaxKind.NamedImports) {
-                        const elements = namedBindings.elements;
-                        for (let elem of elements) {
-                            if (elem.name.getText() === identifier) {
-                                importSpecifier = tsNode.moduleSpecifier;
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        return importSpecifier;
-    }
 }
 exports.AstroPlugin = AstroPlugin;

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/css/CSSPlugin.d.ts

@@ -8,14 +8,14 @@ export declare class CSSPlugin implements Plugin {
     private cssDocuments;
     private triggerCharacters;
     constructor(configManager: ConfigManager);
-    doHover(document: AstroDocument, position: Position): Hover | null;
+    doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     private doHoverInternal;
-    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): CompletionList | null;
+    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<CompletionList | null>;
     private getCompletionsInternal;
-    getDocumentColors(document: AstroDocument): ColorInformation[];
-    getColorPresentations(document: AstroDocument, range: Range, color: Color): ColorPresentation[];
+    getDocumentColors(document: AstroDocument): Promise<ColorInformation[]>;
+    getColorPresentations(document: AstroDocument, range: Range, color: Color): Promise<ColorPresentation[]>;
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
-    getDocumentSymbols(document: AstroDocument): SymbolInformation[];
+    getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     private inStyleAttributeWithoutInterpolation;
     /**
      * Get the associated CSS Document for a style tag

package/dist/plugins/css/CSSPlugin.js

@@ -17,8 +17,8 @@ class CSSPlugin {
         this.triggerCharacters = new Set(['.', ':', '-', '/']);
         this.configManager = configManager;
     }
-    doHover(document, position) {
-        if (!this.featureEnabled('hover')) {
+    async doHover(document, position) {
+        if (!(await this.featureEnabled(document, 'hover'))) {
             return null;
         }
         if ((0, documents_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
@@ -53,8 +53,8 @@ class CSSPlugin {
         const hoverInfo = (0, language_service_1.getLanguageService)(extractLanguage(cssDocument)).doHover(cssDocument, cssDocument.getGeneratedPosition(position), cssDocument.stylesheet);
         return hoverInfo ? (0, documents_1.mapHoverToParent)(cssDocument, hoverInfo) : hoverInfo;
     }
-    getCompletions(document, position, completionContext) {
-        if (!this.featureEnabled('completions')) {
+    async getCompletions(document, position, completionContext) {
+        if (!(await this.featureEnabled(document, 'completions'))) {
             return null;
         }
         if ((0, documents_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
@@ -77,7 +77,7 @@ class CSSPlugin {
             }
             if (this.inStyleAttributeWithoutInterpolation(attributeContext, document.getText())) {
                 const [start, end] = attributeContext.valueRange;
-                return this.getCompletionsInternal(document, position, new StyleAttributeDocument_1.StyleAttributeDocument(document, start, end));
+                return await this.getCompletionsInternal(document, position, new StyleAttributeDocument_1.StyleAttributeDocument(document, start, end));
             }
             // If we're not in a style attribute, instead give completions for ids and classes used in the current document
             else if ((attributeContext.name == 'id' || attributeContext.name == 'class') && attributeContext.inValue) {
@@ -87,13 +87,14 @@ class CSSPlugin {
             return null;
         }
         const cssDocument = this.getCSSDocumentForStyleTag(styleTag, document);
-        return this.getCompletionsInternal(document, position, cssDocument);
+        return await this.getCompletionsInternal(document, position, cssDocument);
     }
-    getCompletionsInternal(document, position, cssDocument) {
+    async getCompletionsInternal(document, position, cssDocument) {
+        const emmetConfig = await this.configManager.getEmmetConfig(document);
         if (isSASS(cssDocument)) {
             // The CSS language service does not support SASS (not to be confused with SCSS)
             // however we can at least still at least provide Emmet completions in SASS blocks
-            return (0, emmet_helper_1.doComplete)(document, position, 'sass', this.configManager.getEmmetConfig()) || null;
+            return (0, emmet_helper_1.doComplete)(document, position, 'sass', emmetConfig) || null;
         }
         const cssLang = extractLanguage(cssDocument);
         const langService = (0, language_service_1.getLanguageService)(cssLang);
@@ -101,29 +102,32 @@ class CSSPlugin {
             isIncomplete: false,
             items: [],
         };
-        langService.setCompletionParticipants([
-            {
-                onCssProperty: (context) => {
-                    if (context?.propertyName) {
-                        emmetResults =
-                            (0, emmet_helper_1.doComplete)(cssDocument, cssDocument.getGeneratedPosition(position), (0, language_service_1.getLanguage)(cssLang), this.configManager.getEmmetConfig()) || emmetResults;
-                    }
+        const extensionConfig = await this.configManager.getConfig('astro', document.uri);
+        if (extensionConfig.css.completions.emmet) {
+            langService.setCompletionParticipants([
+                {
+                    onCssProperty: (context) => {
+                        if (context?.propertyName) {
+                            emmetResults =
+                                (0, emmet_helper_1.doComplete)(cssDocument, cssDocument.getGeneratedPosition(position), (0, language_service_1.getLanguage)(cssLang), emmetConfig) || emmetResults;
+                        }
+                    },
+                    onCssPropertyValue: (context) => {
+                        if (context?.propertyValue) {
+                            emmetResults =
+                                (0, emmet_helper_1.doComplete)(cssDocument, cssDocument.getGeneratedPosition(position), (0, language_service_1.getLanguage)(cssLang), emmetConfig) || emmetResults;
+                        }
+                    },
                 },
-                onCssPropertyValue: (context) => {
-                    if (context?.propertyValue) {
-                        emmetResults =
-                            (0, emmet_helper_1.doComplete)(cssDocument, cssDocument.getGeneratedPosition(position), (0, language_service_1.getLanguage)(cssLang), this.configManager.getEmmetConfig()) || emmetResults;
-                    }
-                },
-            },
-        ]);
+            ]);
+        }
         const results = langService.doComplete(cssDocument, cssDocument.getGeneratedPosition(position), cssDocument.stylesheet);
         return vscode_languageserver_1.CompletionList.create([...(results ? results.items : []), ...emmetResults.items].map((completionItem) => (0, documents_1.mapCompletionItemToOriginal)(cssDocument, completionItem)), 
         // Emmet completions change on every keystroke, so they are never complete
         emmetResults.items.length > 0);
     }
-    getDocumentColors(document) {
-        if (!this.featureEnabled('documentColors')) {
+    async getDocumentColors(document) {
+        if (!(await this.featureEnabled(document, 'documentColors'))) {
             return [];
         }
         const allColorInfo = this.getCSSDocumentsForDocument(document).map((cssDoc) => {
@@ -138,8 +142,8 @@ class CSSPlugin {
         });
         return (0, lodash_1.flatten)(allColorInfo);
     }
-    getColorPresentations(document, range, color) {
-        if (!this.featureEnabled('colorPresentations')) {
+    async getColorPresentations(document, range, color) {
+        if (!(await this.featureEnabled(document, 'documentColors'))) {
             return [];
         }
         const allColorPres = this.getCSSDocumentsForDocument(document).map((cssDoc) => {
@@ -163,8 +167,8 @@ class CSSPlugin {
         });
         return (0, lodash_1.flatten)(allFoldingRanges);
     }
-    getDocumentSymbols(document) {
-        if (!this.featureEnabled('documentSymbols')) {
+    async getDocumentSymbols(document) {
+        if (!(await this.featureEnabled(document, 'documentSymbols'))) {
             return [];
         }
         const allDocumentSymbols = this.getCSSDocumentsForDocument(document).map((cssDoc) => {
@@ -210,8 +214,9 @@ class CSSPlugin {
             return (0, documents_1.isInTag)(position, styleTag);
         });
     }
-    featureEnabled(feature) {
-        return this.configManager.enabled('css.enabled') && this.configManager.enabled(`css.${feature}.enabled`);
+    async featureEnabled(document, feature) {
+        return ((await this.configManager.isEnabled(document, 'css')) &&
+            (await this.configManager.isEnabled(document, 'css', feature)));
     }
 }
 exports.CSSPlugin = CSSPlugin;

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';
@@ -10,14 +10,15 @@ export declare class HTMLPlugin implements Plugin {
     private styleScriptTemplate;
     private configManager;
     constructor(configManager: ConfigManager);
-    doHover(document: AstroDocument, position: Position): Hover | null;
+    doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     /**
      * Get HTML completions
      */
-    getCompletions(document: AstroDocument, position: Position): CompletionList | null;
+    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): string | null;
-    getDocumentSymbols(document: AstroDocument): SymbolInformation[];
+    doTagComplete(document: AstroDocument, position: Position): Promise<string | null>;
+    getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     /**
      * Get lang completions for style tags (ex: `<style lang="scss">`)
      */

package/dist/plugins/html/HTMLPlugin.js

@@ -25,8 +25,8 @@ class HTMLPlugin {
         this.styleScriptTemplate = new Set(['style']);
         this.configManager = configManager;
     }
-    doHover(document, position) {
-        if (!this.featureEnabled('hover')) {
+    async doHover(document, position) {
+        if (!(await this.featureEnabled(document, 'hover'))) {
             return null;
         }
         const html = document.html;
@@ -46,8 +46,8 @@ class HTMLPlugin {
     /**
      * Get HTML completions
      */
-    getCompletions(document, position) {
-        if (!this.featureEnabled('completions')) {
+    async getCompletions(document, position) {
+        if (!(await this.featureEnabled(document, 'completions'))) {
             return null;
         }
         const html = document.html;
@@ -62,12 +62,15 @@ class HTMLPlugin {
             isIncomplete: true,
             items: [],
         };
-        this.lang.setCompletionParticipants([
-            {
-                onHtmlContent: () => (emmetResults =
-                    (0, emmet_helper_1.doComplete)(document, position, 'html', this.configManager.getEmmetConfig()) || emmetResults),
-            },
-        ]);
+        const emmetConfig = await this.configManager.getEmmetConfig(document);
+        const extensionConfig = await this.configManager.getConfig('astro', document.uri);
+        if (extensionConfig.html.completions.emmet) {
+            this.lang.setCompletionParticipants([
+                {
+                    onHtmlContent: () => (emmetResults = (0, emmet_helper_1.doComplete)(document, position, 'html', emmetConfig) || emmetResults),
+                },
+            ]);
+        }
         // If we're in a component starting tag, we do not want HTML language completions
         // as HTML attributes are not valid for components
         const results = (0, utils_1.isInComponentStartTag)(html, document.offsetAt(position))
@@ -77,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) {
@@ -84,8 +105,8 @@ class HTMLPlugin {
         }
         return this.lang.getFoldingRanges(document);
     }
-    doTagComplete(document, position) {
-        if (!this.featureEnabled('tagComplete')) {
+    async doTagComplete(document, position) {
+        if (!(await this.featureEnabled(document, 'tagComplete'))) {
             return null;
         }
         const html = document.html;
@@ -97,8 +118,8 @@ class HTMLPlugin {
         }
         return this.lang.doTagComplete(document, position, html);
     }
-    getDocumentSymbols(document) {
-        if (!this.featureEnabled('documentSymbols')) {
+    async getDocumentSymbols(document) {
+        if (!(await this.featureEnabled(document, 'documentSymbols'))) {
             return [];
         }
         const html = document.html;
@@ -134,8 +155,9 @@ class HTMLPlugin {
             }));
         }
     }
-    featureEnabled(feature) {
-        return this.configManager.enabled('html.enabled') && this.configManager.enabled(`html.${feature}.enabled`);
+    async featureEnabled(document, feature) {
+        return ((await this.configManager.isEnabled(document, 'html')) &&
+            (await this.configManager.isEnabled(document, 'html', feature)));
     }
 }
 exports.HTMLPlugin = HTMLPlugin;

package/dist/plugins/html/features/astro-attributes.js

@@ -43,6 +43,7 @@ exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)
         {
             name: 'is:raw',
             description: 'Instructs the Astro compiler to treat any children of this element as text',
+            valueSet: 'v',
             references: [
                 {
                     name: 'Astro reference',