@astrojs/language-server 0.16.0 → 0.16.1

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))
@@ -84,8 +87,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 +100,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 +137,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',

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

@@ -10,6 +10,7 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly codeActionsProvider;
     private readonly completionProvider;
     private readonly hoverProvider;
+    private readonly definitionsProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
@@ -19,7 +20,7 @@ export declare class TypeScriptPlugin implements Plugin {
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getFoldingRanges(document: AstroDocument): Promise<FoldingRange[] | null>;
-    getSemanticTokens(textDocument: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
+    getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
@@ -29,7 +30,5 @@ export declare class TypeScriptPlugin implements Plugin {
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): Promise<void>;
     getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
-    private goToDefinitionFoundOnlyAlias;
-    private getGoToDefinitionRefsForImportSpecifier;
     private featureEnabled;
 }

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -1,52 +1,31 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptPlugin = void 0;
-const typescript_1 = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
-const path_1 = require("path");
-const utils_1 = require("../../utils");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
 const HoverProvider_1 = require("./features/HoverProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
-const utils_2 = require("./features/utils");
 const LanguageServiceManager_1 = require("./LanguageServiceManager");
-const utils_3 = require("./utils");
+const utils_1 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
+const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
         this.configManager = configManager;
         this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
-        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager);
-        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
+        this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager, this.configManager);
+        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager, this.configManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
+        this.definitionsProvider = new DefinitionsProvider_1.DefinitionsProviderImpl(this.languageServiceManager);
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
@@ -54,7 +33,7 @@ class TypeScriptPlugin {
         this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
     }
     async doHover(document, position) {
-        if (!this.featureEnabled('hover')) {
+        if (!(await this.featureEnabled(document, 'hover'))) {
             return null;
         }
         return this.hoverProvider.doHover(document, position);
@@ -63,7 +42,7 @@ class TypeScriptPlugin {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const fragment = await tsDoc.createFragment();
         const offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
-        let renames = lang.findRenameLocations((0, utils_3.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
+        let renames = lang.findRenameLocations((0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath), offset, false, false, true);
         if (!renames) {
             return null;
         }
@@ -71,13 +50,13 @@ class TypeScriptPlugin {
             changes: {},
         };
         renames.forEach((rename) => {
-            const filePath = (0, utils_3.ensureRealFilePath)(rename.fileName);
+            const filePath = (0, utils_1.ensureRealFilePath)(rename.fileName);
             if (!(filePath in edit.changes)) {
                 edit.changes[filePath] = [];
             }
             edit.changes[filePath].push({
                 newText: newName,
-                range: (0, utils_3.convertToLocationRange)(fragment, rename.textSpan),
+                range: (0, utils_1.convertToLocationRange)(fragment, rename.textSpan),
             });
         });
         return edit;
@@ -85,27 +64,27 @@ class TypeScriptPlugin {
     async getFoldingRanges(document) {
         return this.foldingRangesProvider.getFoldingRanges(document);
     }
-    async getSemanticTokens(textDocument, range, cancellationToken) {
-        if (!this.featureEnabled('semanticTokens')) {
+    async getSemanticTokens(document, range, cancellationToken) {
+        if (!(await this.featureEnabled(document, 'semanticTokens'))) {
             return null;
         }
-        return this.semanticTokensProvider.getSemanticTokens(textDocument, range, cancellationToken);
+        return this.semanticTokensProvider.getSemanticTokens(document, range, cancellationToken);
     }
     async getDocumentSymbols(document) {
-        if (!this.featureEnabled('documentSymbols')) {
+        if (!(await this.featureEnabled(document, 'documentSymbols'))) {
             return [];
         }
         const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
         return symbols;
     }
     async getCodeActions(document, range, context, cancellationToken) {
-        if (!this.featureEnabled('codeActions')) {
+        if (!(await this.featureEnabled(document, 'codeActions'))) {
             return [];
         }
         return this.codeActionsProvider.getCodeActions(document, range, context, cancellationToken);
     }
     async getCompletions(document, position, completionContext, cancellationToken) {
-        if (!this.featureEnabled('completions')) {
+        if (!(await this.featureEnabled(document, 'completions'))) {
             return null;
         }
         const completions = await this.completionProvider.getCompletions(document, position, completionContext, cancellationToken);
@@ -115,36 +94,10 @@ class TypeScriptPlugin {
         return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
     }
     async getDefinitions(document, position) {
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        const mainFragment = await tsDoc.createFragment();
-        const filePath = tsDoc.filePath;
-        const tsFilePath = (0, utils_3.toVirtualAstroFilePath)(filePath);
-        const fragmentPosition = mainFragment.getGeneratedPosition(position);
-        const fragmentOffset = mainFragment.offsetAt(fragmentPosition);
-        let defs = lang.getDefinitionAndBoundSpan(tsFilePath, fragmentOffset);
-        if (!defs || !defs.definitions) {
-            return [];
-        }
-        // Resolve all imports if we can
-        if (this.goToDefinitionFoundOnlyAlias(tsFilePath, defs.definitions)) {
-            let importDef = this.getGoToDefinitionRefsForImportSpecifier(tsFilePath, fragmentOffset, lang);
-            if (importDef) {
-                defs = importDef;
-            }
-        }
-        const docs = new utils_2.SnapshotFragmentMap(this.languageServiceManager);
-        docs.set(tsDoc.filePath, { fragment: mainFragment, snapshot: tsDoc });
-        const result = await Promise.all(defs.definitions.map(async (def) => {
-            const { fragment, snapshot } = await docs.retrieve(def.fileName);
-            const fileName = (0, utils_3.ensureRealFilePath)(def.fileName);
-            // Since we converted our files to TSX and we don't have sourcemaps, we don't know where the function is, unfortunate
-            const textSpan = (0, utils_3.isVirtualFilePath)(tsFilePath) ? { start: 0, length: 0 } : def.textSpan;
-            return vscode_languageserver_1.LocationLink.create((0, utils_1.pathToUrl)(fileName), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(fragment, textSpan), (0, utils_3.convertToLocationRange)(mainFragment, defs.textSpan));
-        }));
-        return result.filter(utils_1.isNotNullOrUndefined);
+        return this.definitionsProvider.getDefinitions(document, position);
     }
     async getDiagnostics(document, cancellationToken) {
-        if (!this.featureEnabled('diagnostics')) {
+        if (!(await this.featureEnabled(document, 'diagnostics'))) {
             return [];
         }
         return this.diagnosticsProvider.getDiagnostics(document, cancellationToken);
@@ -152,7 +105,7 @@ class TypeScriptPlugin {
     async onWatchFileChanges(onWatchFileChangesParas) {
         let doneUpdateProjectFiles = false;
         for (const { fileName, changeType } of onWatchFileChangesParas) {
-            const scriptKind = (0, utils_3.getScriptKindFromFileName)(fileName);
+            const scriptKind = (0, utils_1.getScriptKindFromFileName)(fileName);
             if (scriptKind === typescript_1.default.ScriptKind.Unknown) {
                 continue;
             }
@@ -174,48 +127,9 @@ class TypeScriptPlugin {
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
     }
-    goToDefinitionFoundOnlyAlias(tsFileName, defs) {
-        return !!(defs.length === 1 && defs[0].kind === 'alias' && defs[0].fileName === tsFileName);
-    }
-    getGoToDefinitionRefsForImportSpecifier(tsFilePath, offset, lang) {
-        const program = lang.getProgram();
-        const sourceFile = program?.getSourceFile(tsFilePath);
-        if (sourceFile) {
-            let node = typescript_1.default.getTouchingPropertyName(sourceFile, offset);
-            if (node && node.kind === typescript_1.SyntaxKind.Identifier) {
-                if (node.parent.kind === typescript_1.SyntaxKind.ImportClause) {
-                    let decl = node.parent.parent;
-                    let spec = typescript_1.default.isStringLiteral(decl.moduleSpecifier) && decl.moduleSpecifier.text;
-                    if (spec) {
-                        let fileName = (0, path_1.join)((0, path_1.dirname)(tsFilePath), spec);
-                        let start = node.pos + 1;
-                        let def = {
-                            definitions: [
-                                {
-                                    kind: 'alias',
-                                    fileName,
-                                    name: '',
-                                    containerKind: '',
-                                    containerName: '',
-                                    textSpan: {
-                                        start: 0,
-                                        length: 0,
-                                    },
-                                },
-                            ],
-                            textSpan: {
-                                start,
-                                length: node.end - start,
-                            },
-                        };
-                        return def;
-                    }
-                }
-            }
-        }
-    }
-    featureEnabled(feature) {
-        return (this.configManager.enabled('typescript.enabled') && this.configManager.enabled(`typescript.${feature}.enabled`));
+    async featureEnabled(document, feature) {
+        return ((await this.configManager.isEnabled(document, 'typescript')) &&
+            (await this.configManager.isEnabled(document, 'typescript', feature)));
     }
 }
 exports.TypeScriptPlugin = TypeScriptPlugin;

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

@@ -1,12 +1,14 @@
 import { CancellationToken } from 'vscode-languageserver';
 import { CodeAction, CodeActionContext, Range } from 'vscode-languageserver-types';
+import { ConfigManager } from '../../../core/config';
 import { AstroDocument } from '../../../core/documents';
 import { CodeActionsProvider } from '../../interfaces';
 import { LanguageServiceManager } from '../LanguageServiceManager';
 export declare const sortImportKind: string;
 export declare class CodeActionsProviderImpl implements CodeActionsProvider {
     private languageServiceManager;
-    constructor(languageServiceManager: LanguageServiceManager);
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
     getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
     private getComponentQuickFix;
     private organizeSortImports;

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

@@ -15,8 +15,9 @@ const utils_3 = require("./utils");
 // These are VS Code specific CodeActionKind so they're not in the language server protocol
 exports.sortImportKind = `${vscode_languageserver_types_1.CodeActionKind.Source}.sortImports`;
 class CodeActionsProviderImpl {
-    constructor(languageServiceManager) {
+    constructor(languageServiceManager, configManager) {
         this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
     }
     async getCodeActions(document, range, context, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -24,6 +25,8 @@ class CodeActionsProviderImpl {
         const fragment = await tsDoc.createFragment();
         const start = fragment.offsetAt(fragment.getGeneratedPosition(range.start));
         const end = fragment.offsetAt(fragment.getGeneratedPosition(range.end));
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const formatOptions = await this.configManager.getTSFormatConfig(document);
         let result = [];
         if (cancellationToken?.isCancellationRequested) {
             return [];
@@ -47,8 +50,11 @@ class CodeActionsProviderImpl {
                 .map((diag) => Number(diag.code))
                 // We currently cannot support quick fix for unreachable code properly due to the way our TSX output is structured
                 .filter((code) => code !== 7027);
-            let codeFixes = errorCodes.includes(2304) ? this.getComponentQuickFix(start, end, lang, filePath) : undefined;
-            codeFixes = codeFixes ?? lang.getCodeFixesAtPosition(filePath, start, end, errorCodes, {}, {});
+            let codeFixes = errorCodes.includes(2304)
+                ? this.getComponentQuickFix(start, end, lang, filePath, formatOptions, tsPreferences)
+                : undefined;
+            codeFixes =
+                codeFixes ?? lang.getCodeFixesAtPosition(filePath, start, end, errorCodes, formatOptions, tsPreferences);
             const codeActions = codeFixes.map((fix) => codeFixToCodeAction(fix, context.diagnostics, context.only ? vscode_languageserver_types_1.CodeActionKind.QuickFix : vscode_languageserver_types_1.CodeActionKind.Empty));
             result.push(...codeActions);
         }
@@ -73,7 +79,7 @@ class CodeActionsProviderImpl {
             return codeAction;
         }
     }
-    getComponentQuickFix(start, end, lang, filePath) {
+    getComponentQuickFix(start, end, lang, filePath, formatOptions, tsPreferences) {
         const sourceFile = lang.getProgram()?.getSourceFile(filePath);
         if (!sourceFile) {
             return;
@@ -87,7 +93,7 @@ class CodeActionsProviderImpl {
         }
         const tagName = node.tagName;
         // Unlike quick fixes, completions will be able to find the component, so let's use those to get it
-        const completion = lang.getCompletionsAtPosition(filePath, tagName.getEnd(), CompletionsProvider_1.completionOptions);
+        const completion = lang.getCompletionsAtPosition(filePath, tagName.getEnd(), tsPreferences, formatOptions);
         if (!completion) {
             return;
         }

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

@@ -4,7 +4,7 @@ import { AstroDocument } from '../../../core/documents';
 import ts from 'typescript';
 import { AppCompletionItem, AppCompletionList, CompletionsProvider } from '../../interfaces';
 import { AstroSnapshotFragment } from '../snapshots/DocumentSnapshot';
-export declare const completionOptions: ts.GetCompletionsAtPositionOptions;
+import { ConfigManager } from '../../../core/config';
 export interface CompletionItemData extends TextDocumentIdentifier {
     filePath: string;
     offset: number;
@@ -12,7 +12,8 @@ export interface CompletionItemData extends TextDocumentIdentifier {
 }
 export declare class CompletionsProviderImpl implements CompletionsProvider<CompletionItemData> {
     private languageServiceManager;
-    constructor(languageServiceManager: LanguageServiceManager);
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
     private readonly validTriggerCharacters;
     private isValidTriggerCharacter;
     private lastCompletion?;

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

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeActionChangeToTextEdit = exports.CompletionsProviderImpl = exports.completionOptions = void 0;
+exports.codeActionChangeToTextEdit = exports.CompletionsProviderImpl = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
 const utils_1 = require("../../../core/documents/utils");
@@ -35,22 +35,13 @@ const utils_3 = require("../../../utils");
 const lodash_1 = require("lodash");
 const previewer_1 = require("../previewer");
 const utils_4 = require("./utils");
-exports.completionOptions = {
-    importModuleSpecifierPreference: 'relative',
-    importModuleSpecifierEnding: 'auto',
-    quotePreference: 'single',
-    includeCompletionsForModuleExports: true,
-    includeCompletionsForImportStatements: true,
-    includeCompletionsWithInsertText: true,
-    allowIncompleteCompletions: true,
-    includeCompletionsWithSnippetText: true,
-};
 // `import {...} from '..'` or `import ... from '..'`
 // Note: Does not take into account if import is within a comment.
 const scriptImportRegex = /\bimport\s+{([^}]*?)}\s+?from\s+['"`].+?['"`]|\bimport\s+(\w+?)\s+from\s+['"`].+?['"`]/g;
 class CompletionsProviderImpl {
-    constructor(languageServiceManager) {
+    constructor(languageServiceManager, configManager) {
         this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
         this.validTriggerCharacters = ['.', '"', "'", '`', '/', '@', '<', '#'];
     }
     isValidTriggerCharacter(character) {
@@ -97,12 +88,14 @@ class CompletionsProviderImpl {
         if (!isCompletionInsideFrontmatter && !(0, utils_1.isComponentTag)(node) && !isCompletionInsideExpression) {
             return null;
         }
+        const tsPreferences = await this.configManager.getTSPreferences(document);
+        const formatOptions = await this.configManager.getTSFormatConfig(document);
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
         const completions = lang.getCompletionsAtPosition(filePath, offset, {
-            ...exports.completionOptions,
+            ...tsPreferences,
             triggerCharacter: validTriggerCharacter,
-        });
+        }, formatOptions);
         if (completions === undefined || completions.entries.length === 0) {
             return null;
         }
@@ -123,6 +116,7 @@ class CompletionsProviderImpl {
     }
     async resolveCompletion(document, item, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const tsPreferences = await this.configManager.getTSPreferences(document);
         const data = item.data;
         if (!data || !data.filePath || cancellationToken?.isCancellationRequested) {
             return item;
@@ -133,7 +127,7 @@ class CompletionsProviderImpl {
         data.originalItem.name, // entryName
         {}, // formatOptions
         data.originalItem.source, // source
-        exports.completionOptions, // preferences
+        tsPreferences, // preferences
         data.originalItem.data // data
         );
         if (detail) {

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

@@ -0,0 +1,9 @@
+import { Position, LocationLink } from 'vscode-languageserver-types';
+import { AstroDocument } from '../../../core/documents';
+import { DefinitionsProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class DefinitionsProviderImpl implements DefinitionsProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getDefinitions(document: AstroDocument, position: Position): Promise<LocationLink[]>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionsProviderImpl = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const utils_3 = require("./utils");
+class DefinitionsProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getDefinitions(document, position) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const mainFragment = await tsDoc.createFragment();
+        const tsFilePath = (0, utils_2.toVirtualAstroFilePath)(tsDoc.filePath);
+        const fragmentPosition = mainFragment.getGeneratedPosition(position);
+        const fragmentOffset = mainFragment.offsetAt(fragmentPosition);
+        const defs = lang.getDefinitionAndBoundSpan(tsFilePath, fragmentOffset);
+        if (!defs || !defs.definitions) {
+            return [];
+        }
+        const docs = new utils_3.SnapshotFragmentMap(this.languageServiceManager);
+        docs.set(tsFilePath, { fragment: mainFragment, snapshot: tsDoc });
+        const result = await Promise.all(defs.definitions.map(async (def) => {
+            const { fragment, snapshot } = await docs.retrieve(def.fileName);
+            const fileName = (0, utils_2.ensureRealFilePath)(def.fileName);
+            // For Astro, Svelte and Vue, the position is wrongly mapped to the end of the file due to the TSX output
+            // So we'll instead redirect to the beginning of the file
+            const isFramework = (0, utils_2.isFrameworkFilePath)(def.fileName) || (0, utils_2.isAstroFilePath)(def.fileName);
+            const textSpan = isFramework && tsDoc.filePath !== def.fileName ? { start: 0, length: 0 } : def.textSpan;
+            return vscode_languageserver_types_1.LocationLink.create((0, utils_1.pathToUrl)(fileName), (0, utils_2.convertToLocationRange)(fragment, textSpan), (0, utils_2.convertToLocationRange)(fragment, textSpan), (0, utils_2.convertToLocationRange)(mainFragment, defs.textSpan));
+        }));
+        return result.filter(utils_1.isNotNullOrUndefined);
+    }
+}
+exports.DefinitionsProviderImpl = DefinitionsProviderImpl;

package/dist/server.js

@@ -41,9 +41,10 @@ const TagCloseRequest = new vscode.RequestType('html/tag');
 // Start the language server
 function startLanguageServer(connection) {
     // Create our managers
-    const configManager = new ConfigManager_1.ConfigManager();
     const documentManager = new DocumentManager_1.DocumentManager();
     const pluginHost = new PluginHost_1.PluginHost(documentManager);
+    const configManager = new ConfigManager_1.ConfigManager(connection);
+    let hasConfigurationCapability = false;
     connection.onInitialize((params) => {
         const workspaceUris = params.workspaceFolders?.map((folder) => folder.uri.toString()) ?? [params.rootUri ?? ''];
         workspaceUris.forEach((uri) => {
@@ -62,6 +63,7 @@ function startLanguageServer(connection) {
                 });
             }
         });
+        hasConfigurationCapability = !!(params.capabilities.workspace && !!params.capabilities.workspace.configuration);
         pluginHost.initialize({
             filterIncompleteCompletions: !params.initializationOptions?.dontFilterIncompleteCompletions,
             definitionLinkSupport: !!params.capabilities.textDocument?.definition?.linkSupport,
@@ -74,15 +76,6 @@ function startLanguageServer(connection) {
             pluginHost.registerPlugin(new AstroPlugin_1.AstroPlugin(documentManager, configManager, workspaceUris));
             pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(documentManager, configManager, workspaceUris));
         }
-        // Update language-server config with what the user supplied to us at launch
-        let astroConfiguration = params.initializationOptions?.configuration?.astro;
-        if (astroConfiguration) {
-            configManager.updateConfig(astroConfiguration);
-        }
-        let emmetConfiguration = params.initializationOptions?.configuration?.emmet;
-        if (emmetConfiguration) {
-            configManager.updateEmmetConfig(emmetConfiguration);
-        }
         return {
             capabilities: {
                 textDocumentSync: {
@@ -147,10 +140,18 @@ function startLanguageServer(connection) {
             },
         };
     });
-    // On update of the user configuration of the language-server
-    connection.onDidChangeConfiguration(({ settings }) => {
-        configManager.updateConfig(settings.astro);
-        configManager.updateEmmetConfig(settings.emmet);
+    // The params don't matter here because in "pull mode" it's always null, it's intended that when the config is updated
+    // you should just reset "your internal cache" and get the config again for relevant documents, weird API design
+    connection.onDidChangeConfiguration(async (change) => {
+        if (hasConfigurationCapability) {
+            configManager.updateConfig();
+            documentManager.getAllOpenedByClient().forEach(async (document) => {
+                await configManager.getConfig('astro', document[1].uri);
+            });
+        }
+        else {
+            configManager.updateGlobalConfig(change.settings.astro || ConfigManager_1.defaultLSConfig);
+        }
     });
     // Documents
     connection.onDidOpenTextDocument((params) => {
@@ -206,10 +207,17 @@ function startLanguageServer(connection) {
         updateAllDiagnostics();
     });
     documentManager.on('documentChange', (0, utils_1.debounceThrottle)(async (document) => diagnosticsManager.update(document), 1000));
-    documentManager.on('documentClose', (document) => diagnosticsManager.removeDiagnostics(document));
+    documentManager.on('documentClose', (document) => {
+        diagnosticsManager.removeDiagnostics(document);
+        configManager.removeDocument(document.uri);
+    });
     // Taking off 🚀
     connection.onInitialized(() => {
         connection.console.log('Successfully initialized! 🚀');
+        // Register for all configuration changes.
+        if (hasConfigurationCapability) {
+            connection.client.register(vscode_languageserver_1.DidChangeConfigurationNotification.type);
+        }
     });
     connection.listen();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",