@astrojs/language-server 0.18.1 → 0.19.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @astrojs/language-server
 
+## 0.19.2
+
+### Patch Changes
+
+- 7de4967: Add better error messages for Vue and Svelte components with syntax errors
+- Updated dependencies [7de4967]
+  - @astrojs/svelte-language-integration@0.1.6
+  - @astrojs/vue-language-integration@0.1.1
+
+## 0.19.1
+
+### Patch Changes
+
+- 729dff5: Add support for giving linked editing ranges
+- 05a48c2: Fix some TypeScript diagnostics not showing up in certain cases
+- fe2d26b: Add support for showing Svelte components documentation on hover
+- Updated dependencies [fe2d26b]
+  - @astrojs/svelte-language-integration@0.1.5
+
+## 0.19.0
+
+### Minor Changes
+
+- a97b9a4: Add support for Inlay Hints. Minimum VS Code version supported starting from this update is 1.67.0 (April 2022)
+
 ## 0.18.1
 
 ### Patch Changes

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

@@ -2,7 +2,7 @@ import { VSCodeEmmetConfig } from '@vscode/emmet-helper';
 import { LSConfig, LSCSSConfig, LSFormatConfig, LSHTMLConfig, LSTypescriptConfig } from './interfaces';
 import { Connection, FormattingOptions } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { FormatCodeSettings, UserPreferences } from 'typescript';
+import { FormatCodeSettings, InlayHintsOptions, UserPreferences } from 'typescript';
 export declare const defaultLSConfig: LSConfig;
 declare type DeepPartial<T> = T extends Record<string, unknown> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
@@ -25,14 +25,18 @@ export declare class ConfigManager {
     getAstroFormatConfig(document: TextDocument): Promise<LSFormatConfig>;
     getTSFormatConfig(document: TextDocument, vscodeOptions?: FormattingOptions): Promise<FormatCodeSettings>;
     getTSPreferences(document: TextDocument): Promise<UserPreferences>;
+    getTSInlayHintsPreferences(document: TextDocument): Promise<InlayHintsOptions>;
     /**
      * Return true if a plugin and an optional feature is enabled
      */
     isEnabled(document: TextDocument, plugin: keyof LSConfig, feature?: keyof LSTypescriptConfig | keyof LSCSSConfig | keyof LSHTMLConfig): Promise<boolean>;
     /**
      * Updating the global config should only be done in cases where the client doesn't support `workspace/configuration`
-     * or inside of tests
+     * or inside of tests.
+     *
+     * The `outsideAstro` parameter can be set to true to change configurations in the global scope.
+     * For example, to change TypeScript settings
      */
-    updateGlobalConfig(config: DeepPartial<LSConfig>): void;
+    updateGlobalConfig(config: DeepPartial<LSConfig> | any, outsideAstro?: boolean): void;
 }
 export {};

package/dist/core/config/ConfigManager.js

@@ -124,6 +124,20 @@ class ConfigManager {
             includeCompletionsWithInsertText: true,
         };
     }
+    async getTSInlayHintsPreferences(document) {
+        const config = (await this.getConfig('typescript', document.uri)) ?? {};
+        const tsPreferences = this.getTSPreferences(document);
+        return {
+            ...tsPreferences,
+            includeInlayParameterNameHints: getInlayParameterNameHintsPreference(config),
+            includeInlayParameterNameHintsWhenArgumentMatchesName: !(config.inlayHints?.parameterNames?.suppressWhenArgumentMatchesName ?? true),
+            includeInlayFunctionParameterTypeHints: config.inlayHints?.parameterTypes?.enabled ?? false,
+            includeInlayVariableTypeHints: config.inlayHints?.variableTypes?.enabled ?? false,
+            includeInlayPropertyDeclarationTypeHints: config.inlayHints?.propertyDeclarationTypes?.enabled ?? false,
+            includeInlayFunctionLikeReturnTypeHints: config.inlayHints?.functionLikeReturnTypes?.enabled ?? false,
+            includeInlayEnumMemberValueHints: config.inlayHints?.enumMemberValues?.enabled ?? false,
+        };
+    }
     /**
      * Return true if a plugin and an optional feature is enabled
      */
@@ -133,10 +147,18 @@ class ConfigManager {
     }
     /**
      * Updating the global config should only be done in cases where the client doesn't support `workspace/configuration`
-     * or inside of tests
+     * or inside of tests.
+     *
+     * The `outsideAstro` parameter can be set to true to change configurations in the global scope.
+     * For example, to change TypeScript settings
      */
-    updateGlobalConfig(config) {
-        this.globalConfig.astro = (0, lodash_1.merge)({}, exports.defaultLSConfig, this.globalConfig.astro, config);
+    updateGlobalConfig(config, outsideAstro) {
+        if (outsideAstro) {
+            this.globalConfig = (0, lodash_1.merge)({}, this.globalConfig, config);
+        }
+        else {
+            this.globalConfig.astro = (0, lodash_1.merge)({}, exports.defaultLSConfig, this.globalConfig.astro, config);
+        }
     }
 }
 exports.ConfigManager = ConfigManager;
@@ -174,3 +196,15 @@ function getImportModuleSpecifierEndingPreference(config) {
             return 'auto';
     }
 }
+function getInlayParameterNameHintsPreference(config) {
+    switch (config.inlayHints?.parameterNames?.enabled) {
+        case 'none':
+            return 'none';
+        case 'literals':
+            return 'literals';
+        case 'all':
+            return 'all';
+        default:
+            return undefined;
+    }
+}

package/dist/plugins/PluginHost.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, SymbolInformation, SemanticTokens, CodeActionContext, CodeAction, FormattingOptions, TextEdit } from 'vscode-languageserver';
+import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, SymbolInformation, SemanticTokens, CodeActionContext, CodeAction, InlayHint, FormattingOptions, TextEdit, LinkedEditingRanges } from 'vscode-languageserver';
 import type { AppCompletionItem, Plugin } from './interfaces';
 import { DocumentManager } from '../core/documents/DocumentManager';
 interface PluginHostConfig {
@@ -22,9 +22,11 @@ export declare class PluginHost {
     getFoldingRanges(textDocument: TextDocumentIdentifier): Promise<FoldingRange[] | null>;
     getDocumentSymbols(textDocument: TextDocumentIdentifier, cancellationToken: CancellationToken): Promise<SymbolInformation[]>;
     getSemanticTokens(textDocument: TextDocumentIdentifier, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
+    getLinkedEditingRanges(textDocument: TextDocumentIdentifier, position: Position): Promise<LinkedEditingRanges | null>;
     getDefinitions(textDocument: TextDocumentIdentifier, position: Position): Promise<DefinitionLink[] | Location[]>;
     rename(textDocument: TextDocumentIdentifier, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getDocumentColors(textDocument: TextDocumentIdentifier): Promise<ColorInformation[]>;
+    getInlayHints(textDocument: TextDocumentIdentifier, range: Range, cancellationToken: CancellationToken): Promise<InlayHint[]>;
     getColorPresentations(textDocument: TextDocumentIdentifier, range: Range, color: Color): Promise<ColorPresentation[]>;
     getSignatureHelp(textDocument: TextDocumentIdentifier, position: Position, context: SignatureHelpContext | undefined, cancellationToken: CancellationToken): Promise<SignatureHelp | null>;
     onWatchFileChanges(onWatchFileChangesParams: any[]): void;

package/dist/plugins/PluginHost.js

@@ -94,6 +94,10 @@ class PluginHost {
         const document = this.getDocument(textDocument.uri);
         return await this.execute('getSemanticTokens', [document, range, cancellationToken], ExecuteMode.FirstNonNull);
     }
+    async getLinkedEditingRanges(textDocument, position) {
+        const document = this.getDocument(textDocument.uri);
+        return await this.execute('getLinkedEditingRanges', [document, position], ExecuteMode.FirstNonNull);
+    }
     async getDefinitions(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
         const definitions = (0, lodash_1.flatten)(await this.execute('getDefinitions', [document, position], ExecuteMode.Collect));
@@ -112,6 +116,10 @@ class PluginHost {
         const document = this.getDocument(textDocument.uri);
         return (0, lodash_1.flatten)(await this.execute('getDocumentColors', [document], ExecuteMode.Collect));
     }
+    async getInlayHints(textDocument, range, cancellationToken) {
+        const document = this.getDocument(textDocument.uri);
+        return (0, lodash_1.flatten)(await this.execute('getInlayHints', [document, range], ExecuteMode.FirstNonNull));
+    }
     async getColorPresentations(textDocument, range, color) {
         const document = this.getDocument(textDocument.uri);
         return (0, lodash_1.flatten)(await this.execute('getColorPresentations', [document, range, color], ExecuteMode.Collect));

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

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

package/dist/plugins/html/HTMLPlugin.js

@@ -105,6 +105,17 @@ class HTMLPlugin {
         }
         return this.lang.getFoldingRanges(document);
     }
+    getLinkedEditingRanges(document, position) {
+        const html = document.html;
+        if (!html) {
+            return null;
+        }
+        const ranges = this.lang.findLinkedEditingRanges(document, position, html);
+        if (!ranges) {
+            return null;
+        }
+        return { ranges };
+    }
     async doTagComplete(document, position) {
         if (!(await this.featureEnabled(document, 'tagComplete'))) {
             return null;

package/dist/plugins/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CodeAction, CodeActionContext, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FileChangeType, FoldingRange, FormattingOptions, Hover, InlayHint, LinkedEditingRanges, Position, Range, ReferenceContext, SelectionRange, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextDocumentIdentifier, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 export declare type Resolvable<T> = T | Promise<T>;
 export interface AppCompletionItem<T extends TextDocumentIdentifier = any> extends CompletionItem {
@@ -52,6 +52,9 @@ export interface FileRename {
 export interface UpdateImportsProvider {
     updateImports(fileRename: FileRename): Resolvable<WorkspaceEdit | null>;
 }
+export interface InlayHintsProvider {
+    getInlayHints(document: TextDocument, range: Range): Resolvable<InlayHint[]>;
+}
 export interface RenameProvider {
     rename(document: TextDocument, position: Position, newName: string): Resolvable<WorkspaceEdit | null>;
     prepareRename(document: TextDocument, position: Position): Resolvable<Range | null>;
@@ -81,7 +84,7 @@ export interface OnWatchFileChangesProvider {
 export interface UpdateNonAstroFile {
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
 }
-declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & UpdateNonAstroFile;
+declare type ProviderBase = DiagnosticsProvider & HoverProvider & CompletionsProvider & DefinitionsProvider & FormattingProvider & FoldingRangesProvider & TagCompleteProvider & DocumentColorsProvider & ColorPresentationsProvider & DocumentSymbolsProvider & UpdateImportsProvider & CodeActionsProvider & FindReferencesProvider & RenameProvider & SignatureHelpProvider & SemanticTokensProvider & SelectionRangeProvider & OnWatchFileChangesProvider & LinkedEditingRangesProvider & InlayHintsProvider & UpdateNonAstroFile;
 export declare type LSProvider = ProviderBase;
 export declare type Plugin = Partial<ProviderBase> & {
     __name: string;

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

@@ -1,4 +1,4 @@
-import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -14,6 +14,7 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
+    private readonly inlayHintsProvider;
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
     private readonly formattingProvider;
@@ -27,6 +28,7 @@ export declare class TypeScriptPlugin implements Plugin {
     getCodeActions(document: AstroDocument, range: Range, context: CodeActionContext, cancellationToken?: CancellationToken): Promise<CodeAction[]>;
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
     resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
+    getInlayHints(document: AstroDocument, range: Range): Promise<InlayHint[]>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
     getDiagnostics(document: AstroDocument, cancellationToken?: CancellationToken): Promise<Diagnostic[]>;
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -17,6 +17,7 @@ const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 const FoldingRangesProvider_1 = require("./features/FoldingRangesProvider");
 const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
 const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
+const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
 const FormattingProvider_1 = require("./features/FormattingProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
@@ -31,6 +32,7 @@ class TypeScriptPlugin {
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
         this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
+        this.inlayHintsProvider = new InlayHintsProvider_1.InlayHintsProviderImpl(this.languageServiceManager, this.configManager);
         this.foldingRangesProvider = new FoldingRangesProvider_1.FoldingRangesProviderImpl(this.languageServiceManager);
         this.formattingProvider = new FormattingProvider_1.FormattingProviderImpl(this.languageServiceManager, this.configManager);
     }
@@ -98,6 +100,9 @@ class TypeScriptPlugin {
     async resolveCompletion(document, completionItem, cancellationToken) {
         return this.completionProvider.resolveCompletion(document, completionItem, cancellationToken);
     }
+    async getInlayHints(document, range) {
+        return this.inlayHintsProvider.getInlayHints(document, range);
+    }
     async getDefinitions(document, position) {
         return this.definitionsProvider.getDefinitions(document, position);
     }

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

@@ -3,6 +3,18 @@ import { Diagnostic } from 'vscode-languageserver-types';
 import { AstroDocument } from '../../../core/documents';
 import { DiagnosticsProvider } from '../../interfaces';
 import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare enum DiagnosticCodes {
+    SPREAD_EXPECTED = 1005,
+    DUPLICATED_JSX_ATTRIBUTES = 17001,
+    MUST_HAVE_PARENT_ELEMENT = 2657,
+    CANNOT_IMPORT_TS_EXT = 2691,
+    CANT_RETURN_OUTSIDE_FUNC = 1108,
+    ISOLATED_MODULE_COMPILE_ERR = 1208,
+    TYPE_NOT_ASSIGNABLE = 2322,
+    JSX_NO_CLOSING_TAG = 17008,
+    NO_DECL_IMPLICIT_ANY_TYPE = 7016,
+    JSX_ELEMENT_NO_CALL = 2604
+}
 export declare class DiagnosticsProviderImpl implements DiagnosticsProvider {
     private readonly languageServiceManager;
     constructor(languageServiceManager: LanguageServiceManager);

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

@@ -3,11 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticsProviderImpl = void 0;
+exports.DiagnosticsProviderImpl = exports.DiagnosticCodes = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 const documents_1 = require("../../../core/documents");
 const utils_1 = require("../utils");
+// List of codes:
+// https://github.com/Microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
+var DiagnosticCodes;
+(function (DiagnosticCodes) {
+    DiagnosticCodes[DiagnosticCodes["SPREAD_EXPECTED"] = 1005] = "SPREAD_EXPECTED";
+    DiagnosticCodes[DiagnosticCodes["DUPLICATED_JSX_ATTRIBUTES"] = 17001] = "DUPLICATED_JSX_ATTRIBUTES";
+    DiagnosticCodes[DiagnosticCodes["MUST_HAVE_PARENT_ELEMENT"] = 2657] = "MUST_HAVE_PARENT_ELEMENT";
+    DiagnosticCodes[DiagnosticCodes["CANNOT_IMPORT_TS_EXT"] = 2691] = "CANNOT_IMPORT_TS_EXT";
+    DiagnosticCodes[DiagnosticCodes["CANT_RETURN_OUTSIDE_FUNC"] = 1108] = "CANT_RETURN_OUTSIDE_FUNC";
+    DiagnosticCodes[DiagnosticCodes["ISOLATED_MODULE_COMPILE_ERR"] = 1208] = "ISOLATED_MODULE_COMPILE_ERR";
+    DiagnosticCodes[DiagnosticCodes["TYPE_NOT_ASSIGNABLE"] = 2322] = "TYPE_NOT_ASSIGNABLE";
+    DiagnosticCodes[DiagnosticCodes["JSX_NO_CLOSING_TAG"] = 17008] = "JSX_NO_CLOSING_TAG";
+    DiagnosticCodes[DiagnosticCodes["NO_DECL_IMPLICIT_ANY_TYPE"] = 7016] = "NO_DECL_IMPLICIT_ANY_TYPE";
+    DiagnosticCodes[DiagnosticCodes["JSX_ELEMENT_NO_CALL"] = 2604] = "JSX_ELEMENT_NO_CALL";
+})(DiagnosticCodes = exports.DiagnosticCodes || (exports.DiagnosticCodes = {}));
 class DiagnosticsProviderImpl {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
@@ -39,17 +54,15 @@ class DiagnosticsProviderImpl {
                 code: diagnostic.code,
                 tags: getDiagnosticTag(diagnostic),
             }))
+                .filter(isNoCantEndWithTS)
                 .map(mapRange(scriptTagSnapshot, document));
             scriptDiagnostics.push(...scriptDiagnostic);
         });
         const { script: scriptBoundaries } = this.getTagBoundaries(lang, filePath);
-        const syntaxDiagnostics = lang.getSyntacticDiagnostics(filePath);
-        const suggestionDiagnostics = lang.getSuggestionDiagnostics(filePath);
-        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath);
         const diagnostics = [
-            ...syntaxDiagnostics,
-            ...suggestionDiagnostics,
-            ...semanticDiagnostics,
+            ...lang.getSyntacticDiagnostics(filePath),
+            ...lang.getSuggestionDiagnostics(filePath),
+            ...lang.getSemanticDiagnostics(filePath),
         ].filter((diag) => {
             return isNoWithinBoundary(scriptBoundaries, diag);
         });
@@ -67,14 +80,15 @@ class DiagnosticsProviderImpl {
             ...scriptDiagnostics,
         ]
             .filter((diag) => {
-            return (hasNoNegativeLines(diag) &&
-                isNoJSXImplicitRuntimeWarning(diag) &&
+            return (
+            // Make sure the diagnostic is inside the document and not in generated code
+            diag.range.start.line <= document.lineCount &&
+                hasNoNegativeLines(diag) &&
                 isNoJSXMustHaveOneParent(diag) &&
-                isNoCantEndWithTS(diag) &&
-                isNoSpreadExpected(diag) &&
-                isNoCantResolveJSONModule(diag) &&
+                isNoSpreadExpected(diag, document) &&
                 isNoCantReturnOutsideFunction(diag) &&
                 isNoIsolatedModuleError(diag) &&
+                isNoImportImplicitAnyType(diag) &&
                 isNoJsxCannotHaveMultipleAttrsError(diag));
         })
             .map(enhanceIfNecessary);
@@ -113,30 +127,39 @@ class DiagnosticsProviderImpl {
     }
 }
 exports.DiagnosticsProviderImpl = DiagnosticsProviderImpl;
-function getDiagnosticTag(diagnostic) {
-    const tags = [];
-    if (diagnostic.reportsUnnecessary) {
-        tags.push(vscode_languageserver_types_1.DiagnosticTag.Unnecessary);
+function isWithinBoundaries(boundaries, start) {
+    for (let [bstart, bend] of boundaries) {
+        if (start > bstart && start < bend) {
+            return true;
+        }
     }
-    if (diagnostic.reportsDeprecated) {
-        tags.push(vscode_languageserver_types_1.DiagnosticTag.Deprecated);
+    return false;
+}
+function diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic) {
+    if ('start' in diagnostic) {
+        if (diagnostic.start == null)
+            return false;
+        return isWithinBoundaries(boundaries, diagnostic.start);
     }
-    return tags;
+    if (!sourceFile)
+        return false;
+    let startRange = diagnostic.range.start;
+    let pos = typescript_1.default.getPositionOfLineAndCharacter(sourceFile, startRange.line, startRange.character);
+    return isWithinBoundaries(boundaries, pos);
+}
+function isNoWithinBoundary(boundaries, diagnostic) {
+    return !diagnosticIsWithinBoundaries(undefined, boundaries, diagnostic);
 }
 function mapRange(fragment, _document) {
     return (diagnostic) => {
         let range = (0, documents_1.mapRangeToOriginal)(fragment, diagnostic.range);
-        if (range.start.line < 0) {
-            // Could be a props error?
-            // From svelte
-        }
         return { ...diagnostic, range };
     };
 }
 /**
  * In some rare cases mapping of diagnostics does not work and produces negative lines.
  * We filter out these diagnostics with negative lines because else the LSP
- * apparently has a hickup and does not show any diagnostics at all.
+ * apparently has a hiccup and does not show any diagnostics at all.
  */
 function hasNoNegativeLines(diagnostic) {
     return diagnostic.range.start.line >= 0 && diagnostic.range.end.line >= 0;
@@ -145,56 +168,68 @@ function hasNoNegativeLines(diagnostic) {
  * Astro allows multiple attributes to have the same name
  */
 function isNoJsxCannotHaveMultipleAttrsError(diagnostic) {
-    return diagnostic.code !== 17001;
+    return diagnostic.code !== DiagnosticCodes.DUPLICATED_JSX_ATTRIBUTES;
 }
 /** Astro allows component with multiple root elements */
 function isNoJSXMustHaveOneParent(diagnostic) {
-    return diagnostic.code !== 2657;
+    return diagnostic.code !== DiagnosticCodes.MUST_HAVE_PARENT_ELEMENT;
 }
-/** Astro allows `.ts` ending for imports, unlike TypeScript */
-function isNoCantEndWithTS(diagnostic) {
-    return diagnostic.code !== 2691;
+function isNoImportImplicitAnyType(diagnostic) {
+    return diagnostic.code !== DiagnosticCodes.NO_DECL_IMPLICIT_ANY_TYPE;
 }
-function isNoSpreadExpected(diagnostic) {
-    return diagnostic.code !== 1005;
+/**
+ * When using the shorthand syntax for props TSX expects you to use the spread operator
+ * Since the shorthand syntax works differently in Astro and this is not required, hide this message
+ * However, the error code used here is quite generic, as such we need to make we only ignore in valid cases
+ */
+function isNoSpreadExpected(diagnostic, document) {
+    if (diagnostic.code === DiagnosticCodes.SPREAD_EXPECTED &&
+        diagnostic.message.includes('...') &&
+        document.offsetAt(diagnostic.range.start) > (document.astroMeta.frontmatter.endOffset ?? 0)) {
+        return false;
+    }
+    return true;
 }
-function isNoJSXImplicitRuntimeWarning(diagnostic) {
-    return diagnostic.code !== 7016 && diagnostic.code !== 2792;
+/** Inside script tags, Astro currently require the `.ts` file extension for imports */
+function isNoCantEndWithTS(diagnostic) {
+    return diagnostic.code !== DiagnosticCodes.CANNOT_IMPORT_TS_EXT;
 }
 /**
  * Ignore "Can't return outside of function body"
- * This is technically a valid diagnostic, but due to how we format our TSX, the frontmatter is at top-level so we have
- * to ignore this. It wasn't a problem before because users didn't need to return things but they can now with SSR
+ * Since the frontmatter is at the top level, users trying to return a Response  for SSR mode run into this
  */
 function isNoCantReturnOutsideFunction(diagnostic) {
-    return diagnostic.code !== 1108;
-}
-/**
- * Astro allows users to import JSON modules
- */
-function isNoCantResolveJSONModule(diagnostic) {
-    return diagnostic.code !== 2732;
+    return diagnostic.code !== DiagnosticCodes.CANT_RETURN_OUTSIDE_FUNC;
 }
 /**
  * When the content of the file is invalid and can't be parsed properly for TSX generation, TS will show an error about
  * how the current module can't be compiled under --isolatedModule, this is confusing to users so let's ignore this
  */
 function isNoIsolatedModuleError(diagnostic) {
-    return diagnostic.code !== 1208;
+    return diagnostic.code !== DiagnosticCodes.ISOLATED_MODULE_COMPILE_ERR;
 }
 /**
  * Some diagnostics have JSX-specific nomenclature or unclear description. Enhance them for more clarity.
  */
 function enhanceIfNecessary(diagnostic) {
     // JSX element has no closing tag. JSX -> HTML
-    if (diagnostic.code === 17008) {
+    if (diagnostic.code === DiagnosticCodes.JSX_NO_CLOSING_TAG) {
         return {
             ...diagnostic,
             message: diagnostic.message.replace('JSX', 'HTML'),
         };
     }
+    // JSX Element can't be constructed or called. This happens on syntax errors / invalid components
+    if (diagnostic.code === DiagnosticCodes.JSX_ELEMENT_NO_CALL) {
+        return {
+            ...diagnostic,
+            message: diagnostic.message
+                .replace('JSX element type', 'Component')
+                .replace('does not have any construct or call signatures.', 'is not a valid component.\n\nIf this is a Svelte or Vue component, it might have a syntax error that makes it impossible to parse.'),
+        };
+    }
     // For the rare case where an user might try to put a client directive on something that is not a component
-    if (diagnostic.code === 2322) {
+    if (diagnostic.code === DiagnosticCodes.TYPE_NOT_ASSIGNABLE) {
         if (diagnostic.message.includes("Property 'client:") && diagnostic.message.includes("to type 'HTMLProps")) {
             return {
                 ...diagnostic,
@@ -202,28 +237,23 @@ function enhanceIfNecessary(diagnostic) {
             };
         }
     }
+    // An import path cannot end with '.ts(x)' consider importing with no extension
+    // TODO: Remove this when https://github.com/withastro/astro/issues/3415 is fixed
+    if (diagnostic.code === DiagnosticCodes.CANNOT_IMPORT_TS_EXT) {
+        return {
+            ...diagnostic,
+            message: diagnostic.message.replace(/\.jsx?/, ''),
+        };
+    }
     return diagnostic;
 }
-function isWithinBoundaries(boundaries, start) {
-    for (let [bstart, bend] of boundaries) {
-        if (start > bstart && start < bend) {
-            return true;
-        }
+function getDiagnosticTag(diagnostic) {
+    const tags = [];
+    if (diagnostic.reportsUnnecessary) {
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Unnecessary);
     }
-    return false;
-}
-function diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic) {
-    if ('start' in diagnostic) {
-        if (diagnostic.start == null)
-            return false;
-        return isWithinBoundaries(boundaries, diagnostic.start);
+    if (diagnostic.reportsDeprecated) {
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Deprecated);
     }
-    if (!sourceFile)
-        return false;
-    let startRange = diagnostic.range.start;
-    let pos = typescript_1.default.getPositionOfLineAndCharacter(sourceFile, startRange.line, startRange.character);
-    return isWithinBoundaries(boundaries, pos);
-}
-function isNoWithinBoundary(boundaries, diagnostic) {
-    return !diagnosticIsWithinBoundaries(undefined, boundaries, diagnostic);
+    return tags;
 }

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

@@ -0,0 +1,12 @@
+import { InlayHint } from 'vscode-languageserver';
+import { AstroDocument } from '../../../core/documents';
+import { InlayHintsProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+import { Range } from 'vscode-languageserver-types';
+import { ConfigManager } from '../../../core/config';
+export declare class InlayHintsProviderImpl implements InlayHintsProvider {
+    private languageServiceManager;
+    private configManager;
+    constructor(languageServiceManager: LanguageServiceManager, configManager: ConfigManager);
+    getInlayHints(document: AstroDocument, range: Range): Promise<InlayHint[]>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlayHintsProviderImpl = void 0;
+const vscode_languageserver_1 = require("vscode-languageserver");
+const utils_1 = require("../utils");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const typescript_1 = __importDefault(require("typescript"));
+class InlayHintsProviderImpl {
+    constructor(languageServiceManager, configManager) {
+        this.languageServiceManager = languageServiceManager;
+        this.configManager = configManager;
+    }
+    async getInlayHints(document, range) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        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.getTSInlayHintsPreferences(document);
+        const inlayHints = lang.provideInlayHints(filePath, { start, length: end - start }, tsPreferences);
+        return inlayHints.map((hint) => {
+            const result = vscode_languageserver_1.InlayHint.create(fragment.getOriginalPosition(fragment.positionAt(hint.position)), hint.text, hint.kind === typescript_1.default.InlayHintKind.Type
+                ? vscode_languageserver_types_1.InlayHintKind.Type
+                : hint.kind === typescript_1.default.InlayHintKind.Parameter
+                    ? vscode_languageserver_types_1.InlayHintKind.Parameter
+                    : undefined);
+            result.paddingLeft = hint.whitespaceBefore;
+            result.paddingRight = hint.whitespaceAfter;
+            return result;
+        });
+    }
+}
+exports.InlayHintsProviderImpl = InlayHintsProviderImpl;

package/dist/plugins/typescript/language-service.js

@@ -224,6 +224,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         const forcedCompilerOptions = {
             noEmit: true,
             declaration: false,
+            resolveJsonModule: true,
             allowNonTsExtensions: true,
             allowJs: true,
             jsx: typescript_1.default.JsxEmit.Preserve,

package/dist/server.js

@@ -129,11 +129,13 @@ function startLanguageServer(connection) {
                 colorProvider: true,
                 hoverProvider: true,
                 documentSymbolProvider: true,
+                linkedEditingRangeProvider: true,
                 semanticTokensProvider: {
                     legend: (0, utils_2.getSemanticTokenLegend)(),
                     range: true,
                     full: true,
                 },
+                inlayHintProvider: true,
                 signatureHelpProvider: {
                     triggerCharacters: ['(', ',', '<'],
                     retriggerCharacters: [')'],
@@ -194,9 +196,11 @@ function startLanguageServer(connection) {
     connection.onDocumentSymbol((params, cancellationToken) => pluginHost.getDocumentSymbols(params.textDocument, cancellationToken));
     connection.onRequest(vscode_languageserver_1.SemanticTokensRequest.type, (evt, cancellationToken) => pluginHost.getSemanticTokens(evt.textDocument, undefined, cancellationToken));
     connection.onRequest(vscode_languageserver_1.SemanticTokensRangeRequest.type, (evt, cancellationToken) => pluginHost.getSemanticTokens(evt.textDocument, evt.range, cancellationToken));
+    connection.onRequest(vscode_languageserver_1.LinkedEditingRangeRequest.type, async (evt) => await pluginHost.getLinkedEditingRanges(evt.textDocument, evt.position));
     connection.onDocumentFormatting((params) => pluginHost.formatDocument(params.textDocument, params.options));
     connection.onDocumentColor((params) => pluginHost.getDocumentColors(params.textDocument));
     connection.onColorPresentation((params) => pluginHost.getColorPresentations(params.textDocument, params.range, params.color));
+    connection.onRequest(vscode_languageserver_1.InlayHintRequest.type, (params, cancellationToken) => pluginHost.getInlayHints(params.textDocument, params.range, cancellationToken));
     connection.onRequest(TagCloseRequest, (evt) => pluginHost.doTagComplete(evt.textDocument, evt.position));
     connection.onSignatureHelp((evt, cancellationToken) => pluginHost.getSignatureHelp(evt.textDocument, evt.position, evt.context, cancellationToken));
     connection.onRenameRequest((evt) => pluginHost.rename(evt.textDocument, evt.position, evt.newName));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "0.18.1",
+  "version": "0.19.2",
   "author": "withastro",
   "license": "MIT",
   "type": "commonjs",
@@ -19,19 +19,19 @@
     "test": "cross-env TS_NODE_TRANSPILE_ONLY=true mocha --timeout 20000 --require ts-node/register \"test/**/*.ts\" --exclude \"test/**/*.d.ts\""
   },
   "dependencies": {
-    "@astrojs/vue-language-integration": "^0.1.0",
-    "@astrojs/svelte-language-integration": "^0.1.4",
+    "@astrojs/vue-language-integration": "^0.1.1",
+    "@astrojs/svelte-language-integration": "^0.1.6",
     "@vscode/emmet-helper": "^2.8.4",
     "lodash": "^4.17.21",
     "source-map": "^0.7.3",
-    "typescript": "~4.6.2",
-    "vscode-css-languageservice": "^5.1.13",
-    "vscode-html-languageservice": "^4.2.5",
-    "vscode-languageserver": "7.0.0",
-    "vscode-languageserver-protocol": "^3.16.0",
-    "vscode-languageserver-textdocument": "^1.0.1",
-    "vscode-languageserver-types": "^3.16.0",
-    "vscode-uri": "^3.0.2"
+    "typescript": "~4.6.4",
+    "vscode-css-languageservice": "^6.0.1",
+    "vscode-html-languageservice": "^5.0.0",
+    "vscode-languageserver": "^8.0.1",
+    "vscode-languageserver-protocol": "^3.17.1",
+    "vscode-languageserver-textdocument": "^1.0.4",
+    "vscode-languageserver-types": "^3.17.1",
+    "vscode-uri": "^3.0.3"
   },
   "devDependencies": {
     "@types/chai": "^4.3.0",