@astrojs/language-server 0.16.0 → 0.16.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @astrojs/language-server
 
+## 0.16.1
+
+### Patch Changes
+
+- ad5a5e5: Fix misc issues with Go To Definition
+- 1bd790d: Updates config management, make sure to respect TypeScript settings when doing completions and quickfixes
+
 ## 0.16.0
 
 ### Minor Changes

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

@@ -1,5 +1,9 @@
 import { VSCodeEmmetConfig } from '@vscode/emmet-helper';
-import { LSConfig } from './interfaces';
+import { LSConfig, LSCSSConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
+import { Connection } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { FormatCodeSettings, UserPreferences } from 'typescript';
+export declare const defaultLSConfig: LSConfig;
 declare type DeepPartial<T> = T extends Record<string, unknown> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -9,25 +13,25 @@ declare type DeepPartial<T> = T extends Record<string, unknown> ? {
  * For more info on this, see the [internal docs](../../../../../docs/internal/language-server/config.md)
  */
 export declare class ConfigManager {
-    private config;
-    private emmetConfig;
+    private globalConfig;
+    private documentSettings;
     private isTrusted;
-    updateConfig(config: DeepPartial<LSConfig>): void;
-    updateEmmetConfig(config: VSCodeEmmetConfig): void;
-    getEmmetConfig(): VSCodeEmmetConfig;
+    private connection;
+    constructor(connection?: Connection);
+    updateConfig(): void;
+    removeDocument(scopeUri: string): void;
+    getConfig<T>(section: string, scopeUri: string): Promise<T>;
+    getEmmetConfig(document: TextDocument): Promise<VSCodeEmmetConfig>;
+    getTSFormatConfig(document: TextDocument): Promise<FormatCodeSettings>;
+    getTSPreferences(document: TextDocument): Promise<UserPreferences>;
     /**
-     * Whether or not specified setting is enabled
-     * @param key a string which is a path. Example: 'astro.diagnostics.enabled'.
+     * Return true if a plugin and an optional feature is enabled
      */
-    enabled(key: string): boolean;
+    isEnabled(document: TextDocument, plugin: keyof LSConfig, feature?: keyof LSTypescriptConfig | keyof LSCSSConfig | keyof LSHTMLConfig): Promise<boolean>;
     /**
-     * Get a specific setting value
-     * @param key a string which is a path. Example: 'astro.diagnostics.enable'.
+     * Updating the global config should only be done in cases where the client doesn't support `workspace/configuration`
+     * or inside of tests
      */
-    get<T>(key: string): T;
-    /**
-     * Get the entire user configuration
-     */
-    getFullConfig(): Readonly<LSConfig>;
+    updateGlobalConfig(config: DeepPartial<LSConfig>): void;
 }
 export {};

package/dist/core/config/ConfigManager.js

@@ -1,43 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigManager = void 0;
+exports.ConfigManager = exports.defaultLSConfig = void 0;
 const lodash_1 = require("lodash");
-const defaultLSConfig = {
-    astro: {
-        enabled: true,
-        diagnostics: { enabled: true },
-        rename: { enabled: true },
-        format: { enabled: true },
-        completions: { enabled: true },
-        hover: { enabled: true },
-        codeActions: { enabled: true },
-        selectionRange: { enabled: true },
-    },
+const typescript_1 = require("typescript");
+exports.defaultLSConfig = {
     typescript: {
         enabled: true,
         diagnostics: { enabled: true },
         hover: { enabled: true },
         completions: { enabled: true },
         definitions: { enabled: true },
-        findReferences: { enabled: true },
         documentSymbols: { enabled: true },
         codeActions: { enabled: true },
         rename: { enabled: true },
-        selectionRange: { enabled: true },
         signatureHelp: { enabled: true },
         semanticTokens: { enabled: true },
-        implementation: { enabled: true },
-        typeDefinition: { enabled: true },
     },
     css: {
         enabled: true,
-        diagnostics: { enabled: true },
         hover: { enabled: true },
         completions: { enabled: true, emmet: true },
         documentColors: { enabled: true },
-        colorPresentations: { enabled: true },
         documentSymbols: { enabled: true },
-        selectionRange: { enabled: true },
     },
     html: {
         enabled: true,
@@ -45,8 +29,6 @@ const defaultLSConfig = {
         completions: { enabled: true, emmet: true },
         tagComplete: { enabled: true },
         documentSymbols: { enabled: true },
-        renameTags: { enabled: true },
-        linkedEditing: { enabled: true },
     },
 };
 /**
@@ -55,42 +37,126 @@ const defaultLSConfig = {
  * For more info on this, see the [internal docs](../../../../../docs/internal/language-server/config.md)
  */
 class ConfigManager {
-    constructor() {
-        this.config = defaultLSConfig;
-        this.emmetConfig = {};
+    constructor(connection) {
+        this.globalConfig = { astro: exports.defaultLSConfig };
+        this.documentSettings = {};
         this.isTrusted = true;
+        this.connection = connection;
     }
-    updateConfig(config) {
-        // Ideally we shouldn't need the merge here because all updates should be valid and complete configs.
-        // But since those configs come from the client they might be out of synch with the valid config:
-        // We might at some point in the future forget to synch config settings in all packages after updating the config.
-        this.config = (0, lodash_1.merge)({}, defaultLSConfig, this.config, config);
+    updateConfig() {
+        // Reset all cached document settings
+        this.documentSettings = {};
     }
-    updateEmmetConfig(config) {
-        this.emmetConfig = config || {};
+    removeDocument(scopeUri) {
+        delete this.documentSettings[scopeUri];
     }
-    getEmmetConfig() {
-        return this.emmetConfig;
+    async getConfig(section, scopeUri) {
+        if (!this.connection) {
+            return this.globalConfig[section];
+        }
+        if (!this.documentSettings[scopeUri]) {
+            this.documentSettings[scopeUri] = {};
+        }
+        if (!this.documentSettings[scopeUri][section]) {
+            this.documentSettings[scopeUri][section] = await this.connection.workspace.getConfiguration({
+                scopeUri,
+                section,
+            });
+        }
+        return this.documentSettings[scopeUri][section];
     }
-    /**
-     * Whether or not specified setting is enabled
-     * @param key a string which is a path. Example: 'astro.diagnostics.enabled'.
-     */
-    enabled(key) {
-        return !!this.get(key);
+    async getEmmetConfig(document) {
+        const emmetConfig = (await this.getConfig('emmet', document.uri)) ?? {};
+        return emmetConfig;
+    }
+    async getTSFormatConfig(document) {
+        const formatConfig = (await this.getConfig('typescript.format', document.uri)) ?? {};
+        return {
+            // We can use \n here since the editor normalizes later on to its line endings.
+            newLineCharacter: '\n',
+            insertSpaceAfterCommaDelimiter: formatConfig.insertSpaceAfterCommaDelimiter ?? true,
+            insertSpaceAfterConstructor: formatConfig.insertSpaceAfterConstructor ?? false,
+            insertSpaceAfterSemicolonInForStatements: formatConfig.insertSpaceAfterSemicolonInForStatements ?? true,
+            insertSpaceBeforeAndAfterBinaryOperators: formatConfig.insertSpaceBeforeAndAfterBinaryOperators ?? true,
+            insertSpaceAfterKeywordsInControlFlowStatements: formatConfig.insertSpaceAfterKeywordsInControlFlowStatements ?? true,
+            insertSpaceAfterFunctionKeywordForAnonymousFunctions: formatConfig.insertSpaceAfterFunctionKeywordForAnonymousFunctions ?? true,
+            insertSpaceBeforeFunctionParenthesis: formatConfig.insertSpaceBeforeFunctionParenthesis ?? false,
+            insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: formatConfig.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis ?? false,
+            insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: formatConfig.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets ?? false,
+            insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: formatConfig.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces ?? true,
+            insertSpaceAfterOpeningAndBeforeClosingEmptyBraces: formatConfig.insertSpaceAfterOpeningAndBeforeClosingEmptyBraces ?? true,
+            insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: formatConfig.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces ?? false,
+            insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: formatConfig.insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces ?? false,
+            insertSpaceAfterTypeAssertion: formatConfig.insertSpaceAfterTypeAssertion ?? false,
+            placeOpenBraceOnNewLineForFunctions: formatConfig.placeOpenBraceOnNewLineForFunctions ?? false,
+            placeOpenBraceOnNewLineForControlBlocks: formatConfig.placeOpenBraceOnNewLineForControlBlocks ?? false,
+            semicolons: formatConfig.semicolons ?? typescript_1.SemicolonPreference.Ignore,
+        };
+    }
+    async getTSPreferences(document) {
+        const config = (await this.getConfig('typescript', document.uri)) ?? {};
+        const preferences = (await this.getConfig('typescript.preferences', document.uri)) ?? {};
+        return {
+            quotePreference: getQuoteStylePreference(preferences),
+            importModuleSpecifierPreference: getImportModuleSpecifierPreference(preferences),
+            importModuleSpecifierEnding: getImportModuleSpecifierEndingPreference(preferences),
+            allowTextChangesInNewFiles: document.uri.startsWith('file://'),
+            providePrefixAndSuffixTextForRename: (preferences.renameShorthandProperties ?? true) === false ? false : preferences.useAliasesForRenames ?? true,
+            includeAutomaticOptionalChainCompletions: config.suggest?.includeAutomaticOptionalChainCompletions ?? true,
+            includeCompletionsForImportStatements: config.suggest?.includeCompletionsForImportStatements ?? true,
+            includeCompletionsWithSnippetText: config.suggest?.includeCompletionsWithSnippetText ?? true,
+            includeCompletionsForModuleExports: config.suggest?.autoImports ?? true,
+            allowIncompleteCompletions: true,
+            includeCompletionsWithInsertText: true,
+        };
     }
     /**
-     * Get a specific setting value
-     * @param key a string which is a path. Example: 'astro.diagnostics.enable'.
+     * Return true if a plugin and an optional feature is enabled
      */
-    get(key) {
-        return (0, lodash_1.get)(this.config, key);
+    async isEnabled(document, plugin, feature) {
+        const config = await this.getConfig('astro', document.uri);
+        return feature ? config[plugin].enabled && config[plugin][feature].enabled : config[plugin].enabled;
     }
     /**
-     * Get the entire user configuration
+     * Updating the global config should only be done in cases where the client doesn't support `workspace/configuration`
+     * or inside of tests
      */
-    getFullConfig() {
-        return this.config;
+    updateGlobalConfig(config) {
+        this.globalConfig.astro = (0, lodash_1.merge)({}, exports.defaultLSConfig, this.globalConfig.astro, config);
     }
 }
 exports.ConfigManager = ConfigManager;
+function getQuoteStylePreference(config) {
+    switch (config.quoteStyle) {
+        case 'single':
+            return 'single';
+        case 'double':
+            return 'double';
+        default:
+            return 'auto';
+    }
+}
+function getImportModuleSpecifierPreference(config) {
+    switch (config.importModuleSpecifier) {
+        case 'project-relative':
+            return 'project-relative';
+        case 'relative':
+            return 'relative';
+        case 'non-relative':
+            return 'non-relative';
+        default:
+            return undefined;
+    }
+}
+function getImportModuleSpecifierEndingPreference(config) {
+    switch (config.importModuleSpecifierEnding) {
+        case 'minimal':
+            return 'minimal';
+        case 'index':
+            return 'index';
+        case 'js':
+            return 'js';
+        default:
+            return 'auto';
+    }
+}

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

@@ -3,35 +3,10 @@
  * Make sure that this is kept in sync with the `package.json` of the VS Code extension
  */
 export interface LSConfig {
-    astro: LSAstroConfig;
     typescript: LSTypescriptConfig;
     html: LSHTMLConfig;
     css: LSCSSConfig;
 }
-export interface LSAstroConfig {
-    enabled: boolean;
-    diagnostics: {
-        enabled: boolean;
-    };
-    format: {
-        enabled: boolean;
-    };
-    rename: {
-        enabled: boolean;
-    };
-    completions: {
-        enabled: boolean;
-    };
-    hover: {
-        enabled: boolean;
-    };
-    codeActions: {
-        enabled: boolean;
-    };
-    selectionRange: {
-        enabled: boolean;
-    };
-}
 export interface LSTypescriptConfig {
     enabled: boolean;
     diagnostics: {
@@ -46,9 +21,6 @@ export interface LSTypescriptConfig {
     completions: {
         enabled: boolean;
     };
-    findReferences: {
-        enabled: boolean;
-    };
     definitions: {
         enabled: boolean;
     };
@@ -58,21 +30,12 @@ export interface LSTypescriptConfig {
     rename: {
         enabled: boolean;
     };
-    selectionRange: {
-        enabled: boolean;
-    };
     signatureHelp: {
         enabled: boolean;
     };
     semanticTokens: {
         enabled: boolean;
     };
-    implementation: {
-        enabled: boolean;
-    };
-    typeDefinition: {
-        enabled: boolean;
-    };
 }
 export interface LSHTMLConfig {
     enabled: boolean;
@@ -89,18 +52,9 @@ export interface LSHTMLConfig {
     documentSymbols: {
         enabled: boolean;
     };
-    renameTags: {
-        enabled: boolean;
-    };
-    linkedEditing: {
-        enabled: boolean;
-    };
 }
 export interface LSCSSConfig {
     enabled: boolean;
-    diagnostics: {
-        enabled: boolean;
-    };
     hover: {
         enabled: boolean;
     };
@@ -111,13 +65,7 @@ export interface LSCSSConfig {
     documentColors: {
         enabled: boolean;
     };
-    colorPresentations: {
-        enabled: boolean;
-    };
     documentSymbols: {
         enabled: boolean;
     };
-    selectionRange: {
-        enabled: boolean;
-    };
 }

package/dist/plugins/astro/AstroPlugin.d.ts

@@ -1,4 +1,4 @@
-import { CompletionContext, DefinitionLink, FoldingRange, Position } from 'vscode-languageserver';
+import { CompletionContext, FoldingRange, Position } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionList, Plugin } from '../interfaces';
@@ -10,9 +10,4 @@ export declare class AstroPlugin implements Plugin {
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
     getFoldingRanges(document: AstroDocument): FoldingRange[];
-    getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
-    private isInsideFrontmatter;
-    private isComponentTag;
-    private getDefinitionsForComponentName;
-    private getImportSpecifierForIdentifier;
 }

package/dist/plugins/astro/AstroPlugin.js

@@ -1,15 +1,8 @@
 "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) {
@@ -40,80 +33,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/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

@@ -10,14 +10,14 @@ 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>;
     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">`)
      */