@astrojs/language-server 1.0.4 → 2.0.0-next.0

package/dist/index.d.ts

@@ -1,2 +1 @@
-export { AstroCheck, Diagnostic, DiagnosticSeverity, GetDiagnosticsResult } from './check';
-export { offsetAt } from './core/documents';
+export * as protocol from '@volar/language-server/protocol';

package/dist/index.js

@@ -1,8 +1,28 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.offsetAt = exports.DiagnosticSeverity = exports.AstroCheck = void 0;
-var check_1 = require("./check");
-Object.defineProperty(exports, "AstroCheck", { enumerable: true, get: function () { return check_1.AstroCheck; } });
-Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return check_1.DiagnosticSeverity; } });
-var documents_1 = require("./core/documents");
-Object.defineProperty(exports, "offsetAt", { enumerable: true, get: function () { return documents_1.offsetAt; } });
+exports.protocol = void 0;
+exports.protocol = __importStar(require("@volar/language-server/protocol"));
+//# sourceMappingURL=index.js.map

package/dist/languageServerPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageServerPlugin } from '@volar/language-server/node';
+export declare const plugin: LanguageServerPlugin;

package/dist/languageServerPlugin.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const volar_service_css_1 = __importDefault(require("volar-service-css"));
+const volar_service_emmet_1 = __importDefault(require("volar-service-emmet"));
+const volar_service_prettier_1 = __importDefault(require("volar-service-prettier"));
+const volar_service_typescript_twoslash_queries_1 = __importDefault(require("volar-service-typescript-twoslash-queries"));
+const core_1 = require("./core");
+const svelte_js_1 = require("./core/svelte.js");
+const utils_1 = require("./core/utils");
+const vue_js_1 = require("./core/vue.js");
+const importPackage_js_1 = require("./importPackage.js");
+const astro_js_1 = __importDefault(require("./plugins/astro.js"));
+const html_js_1 = __importDefault(require("./plugins/html.js"));
+const index_js_1 = __importDefault(require("./plugins/typescript/index.js"));
+const plugin = (initOptions, modules) => ({
+    extraFileExtensions: [
+        { extension: 'astro', isMixedContent: true, scriptKind: 7 },
+        { extension: 'vue', isMixedContent: true, scriptKind: 7 },
+        { extension: 'svelte', isMixedContent: true, scriptKind: 7 },
+    ],
+    watchFileExtensions: [
+        'js',
+        'cjs',
+        'mjs',
+        'ts',
+        'cts',
+        'mts',
+        'jsx',
+        'tsx',
+        'json',
+        'astro',
+        'vue',
+        'svelte',
+    ],
+    resolveConfig(config, ctx) {
+        config.languages ??= {};
+        if (ctx) {
+            config.languages.astro = (0, core_1.getLanguageModule)((0, utils_1.getAstroInstall)([ctx.project.rootUri.fsPath]), modules.typescript);
+            config.languages.vue = (0, vue_js_1.getVueLanguageModule)();
+            config.languages.svelte = (0, svelte_js_1.getSvelteLanguageModule)();
+        }
+        config.services ??= {};
+        config.services.html ??= (0, html_js_1.default)();
+        config.services.css ??= (0, volar_service_css_1.default)();
+        config.services.emmet ??= (0, volar_service_emmet_1.default)();
+        config.services.typescript ??= (0, index_js_1.default)();
+        config.services.typescripttwoslash ??= (0, volar_service_typescript_twoslash_queries_1.default)();
+        config.services.astro ??= (0, astro_js_1.default)();
+        config.services.prettier ??= (0, volar_service_prettier_1.default)({
+            languages: ['astro'],
+            additionalOptions: (resolvedConfig) => {
+                function getAstroPrettierPlugin() {
+                    if (!ctx?.project.rootUri)
+                        return [];
+                    const rootDir = ctx.env.uriToFileName(ctx?.project.rootUri.toString());
+                    const prettier = (0, importPackage_js_1.importPrettier)(rootDir);
+                    const hasPluginLoadedAlready = prettier
+                        .getSupportInfo()
+                        .languages.some((l) => l.name === 'astro');
+                    return hasPluginLoadedAlready ? [] : [(0, importPackage_js_1.getPrettierPluginPath)(rootDir)];
+                }
+                return {
+                    plugins: [...getAstroPrettierPlugin(), ...(resolvedConfig.plugins ?? [])],
+                    parser: 'astro',
+                };
+            },
+        });
+        return config;
+    },
+});
+exports.plugin = plugin;
+//# sourceMappingURL=languageServerPlugin.js.map

package/dist/nodeServer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("@volar/language-server/node");
+const languageServerPlugin_js_1 = require("./languageServerPlugin.js");
+(0, node_1.startLanguageServer)((0, node_1.createConnection)(), languageServerPlugin_js_1.plugin);
+//# sourceMappingURL=nodeServer.js.map

package/dist/plugins/astro.d.ts

@@ -0,0 +1,3 @@
+import { Service } from '@volar/language-server';
+declare const _default: () => Service;
+export default _default;

package/dist/plugins/astro.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_server_1 = require("@volar/language-server");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_path_1 = require("node:path");
+const index_js_1 = require("../core/index.js");
+const utils_js_1 = require("../utils.js");
+exports.default = () => (context, modules) => {
+    return {
+        triggerCharacters: ['-'],
+        provideCompletionItems(document, position, completionContext, token) {
+            if (token.isCancellationRequested)
+                return null;
+            let items = [];
+            const [file] = context.documents.getVirtualFileByUri(document.uri);
+            if (!(file instanceof index_js_1.AstroFile))
+                return;
+            if (completionContext.triggerCharacter === '-') {
+                const frontmatterCompletion = getFrontmatterCompletion(file, document, position);
+                if (frontmatterCompletion)
+                    items.push(frontmatterCompletion);
+            }
+            return {
+                isIncomplete: false,
+                items: items,
+            };
+        },
+        provideSemanticDiagnostics(document, token) {
+            if (token.isCancellationRequested)
+                return [];
+            const [file] = context.documents.getVirtualFileByUri(document.uri);
+            if (!(file instanceof index_js_1.AstroFile))
+                return;
+            return file.compilerDiagnostics.map(compilerMessageToDiagnostic);
+            function compilerMessageToDiagnostic(message) {
+                return {
+                    message: message.text + '\n\n' + message.hint,
+                    range: language_server_1.Range.create(message.location.line - 1, message.location.column - 1, message.location.line, message.location.length),
+                    code: message.code,
+                    severity: message.severity,
+                    source: 'astro',
+                };
+            }
+        },
+        provideCodeLenses(document, token) {
+            if (token.isCancellationRequested)
+                return;
+            if (!modules?.typescript || !context?.typescript || !(0, utils_js_1.isTsDocument)(document.languageId))
+                return;
+            const ts = modules?.typescript;
+            const tsProgram = context.typescript.languageService.getProgram();
+            if (!tsProgram)
+                return;
+            const globcodeLens = [];
+            const sourceFile = tsProgram.getSourceFile(context.env.uriToFileName(document.uri));
+            function walk() {
+                return ts.forEachChild(sourceFile, function cb(node) {
+                    if (ts.isCallExpression(node) && node.expression.getText() === 'Astro.glob') {
+                        const globText = node.arguments.at(0).getText().slice(1, -1);
+                        globcodeLens.push(getGlobResultAsCodeLens(globText, (0, node_path_1.dirname)(context.env.uriToFileName(document.uri)), document.positionAt(node.arguments.pos)));
+                    }
+                    return ts.forEachChild(node, cb);
+                });
+            }
+            walk();
+            return globcodeLens;
+        },
+    };
+};
+function getGlobResultAsCodeLens(globText, dir, position) {
+    const globResult = fast_glob_1.default.sync(globText, {
+        cwd: dir,
+        onlyFiles: true,
+    });
+    return {
+        range: language_server_1.Range.create(position, position),
+        command: { title: `Matches ${globResult.length} files`, command: '' },
+    };
+}
+function getFrontmatterCompletion(file, document, position) {
+    const base = {
+        kind: language_server_1.CompletionItemKind.Snippet,
+        label: '---',
+        sortText: '\0',
+        preselect: true,
+        detail: 'Create component script block',
+        insertTextFormat: language_server_1.InsertTextFormat.Snippet,
+        commitCharacters: [],
+    };
+    const documentLines = document.getText().split(/\r?\n/);
+    const { line, character } = document.positionAt(document.offsetAt(position));
+    const prefix = documentLines[line].slice(0, character);
+    if (file.astroMeta.frontmatter.status === 'doesnt-exist') {
+        return {
+            ...base,
+            insertText: '---\n$0\n---',
+            textEdit: prefix.match(/^\s*\-+/)
+                ? language_server_1.TextEdit.replace({ start: { ...position, character: 0 }, end: position }, '---\n$0\n---')
+                : undefined,
+        };
+    }
+    if (file.astroMeta.frontmatter.status === 'open') {
+        let insertText = '---';
+        // If the current line is a full component script starter/ender, the user expects a full frontmatter
+        // completion and not just a completion for "---"  on the same line (which result in, well, nothing)
+        if (prefix === '---') {
+            insertText = '---\n$0\n---';
+        }
+        return {
+            ...base,
+            insertText,
+            detail: insertText === '---' ? 'Close component script block' : 'Create component script block',
+            textEdit: prefix.match(/^\s*\-+/)
+                ? language_server_1.TextEdit.replace({ start: { ...position, character: 0 }, end: position }, insertText)
+                : undefined,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=astro.js.map

package/dist/plugins/{html/features/astro-attributes.js → html-data.js}

@@ -233,3 +233,4 @@ exports.astroDirectives = (0, vscode_html_languageservice_1.newHTMLDataProvider)
         },
     ],
 });
+//# sourceMappingURL=html-data.js.map

package/dist/plugins/html.d.ts

@@ -0,0 +1,3 @@
+import type { Service } from '@volar/language-service';
+declare const _default: () => Service;
+export default _default;

package/dist/plugins/html.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const volar_service_html_1 = __importDefault(require("volar-service-html"));
+const index_js_1 = require("../core/index.js");
+const utils_js_1 = require("../utils.js");
+const html_data_js_1 = require("./html-data.js");
+exports.default = () => (context) => {
+    const htmlPlugin = (0, volar_service_html_1.default)()(context);
+    if (!context) {
+        return { triggerCharacters: htmlPlugin.triggerCharacters };
+    }
+    htmlPlugin.updateCustomData([html_data_js_1.astroAttributes, html_data_js_1.astroElements, html_data_js_1.classListAttribute]);
+    return {
+        ...htmlPlugin,
+        provideCompletionItems(document, position, completionContext, token) {
+            if (document.languageId !== 'html')
+                return;
+            const [_, source] = context.documents.getVirtualFileByUri(document.uri);
+            const rootVirtualFile = source?.root;
+            if (!(rootVirtualFile instanceof index_js_1.AstroFile))
+                return;
+            // Don't return completions if the current node is a component
+            if ((0, utils_js_1.isInComponentStartTag)(rootVirtualFile.htmlDocument, document.offsetAt(position))) {
+                return null;
+            }
+            return htmlPlugin.provideCompletionItems(document, position, completionContext, token);
+        },
+    };
+};
+//# sourceMappingURL=html.js.map

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

@@ -0,0 +1,4 @@
+import { CodeAction } from '@volar/language-service';
+import type { TextDocument } from 'vscode-html-languageservice';
+import type { AstroFile } from '../../core/index.js';
+export declare function enhancedProvideCodeActions(codeActions: CodeAction[], file: AstroFile, document: TextDocument, newLine: string): CodeAction[];

package/dist/plugins/typescript/codeActions.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhancedProvideCodeActions = void 0;
+const language_service_1 = require("@volar/language-service");
+const utils_js_1 = require("../../utils.js");
+function enhancedProvideCodeActions(codeActions, file, document, newLine) {
+    codeActions = codeActions.map((codeAction) => {
+        if (!codeAction.edit)
+            return codeAction;
+        codeAction.edit.documentChanges = codeAction.edit.documentChanges?.map((change) => {
+            if (language_service_1.TextDocumentEdit.is(change)) {
+                change.edits = change.edits.map((edit) => {
+                    // Move code actions adding new imports to the frontmatter, as by default they'll be outside of it
+                    // TODO: This is a bit brittle, but we're unfortunately too late into the process to be able to tell the `fixName`
+                    // Maybe contribute upstream to pass the `fixName` through `data`?
+                    if (edit.newText.trim().startsWith('import ')) {
+                        if (file.astroMeta.frontmatter.status === 'doesnt-exist') {
+                            return (0, utils_js_1.getNewFrontmatterEdit)(edit, newLine);
+                        }
+                        if (file.astroMeta.frontmatter.status === 'open') {
+                            return (0, utils_js_1.getOpenFrontmatterEdit)(edit, newLine);
+                        }
+                        edit.range = (0, utils_js_1.ensureRangeIsInFrontmatter)(edit.range, file.astroMeta.frontmatter);
+                    }
+                    // Some code actions will insert code at the end of the generated TSX file, so we'll manually
+                    // redirect it to the end of the frontmatter instead, or create a frontmatter if one doesn't exist
+                    if (edit.range.start.line > document.lineCount) {
+                        switch (file.astroMeta.frontmatter.status) {
+                            case 'open':
+                                return (0, utils_js_1.getOpenFrontmatterEdit)(edit, newLine);
+                            case 'closed':
+                                const position = (0, utils_js_1.PointToPosition)(file.astroMeta.frontmatter.position.end);
+                                edit.range = language_service_1.Range.create(position, position);
+                                return edit;
+                            case 'doesnt-exist':
+                                return (0, utils_js_1.getNewFrontmatterEdit)(edit, newLine);
+                        }
+                    }
+                    return edit;
+                });
+            }
+            return change;
+        });
+        return codeAction;
+    });
+    return codeActions;
+}
+exports.enhancedProvideCodeActions = enhancedProvideCodeActions;
+//# sourceMappingURL=codeActions.js.map

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

@@ -0,0 +1,3 @@
+import { CompletionItem, CompletionList, ServiceContext } from '@volar/language-service';
+export declare function enhancedProvideCompletionItems(completions: CompletionList): CompletionList;
+export declare function enhancedResolveCompletionItem(resolvedCompletion: CompletionItem, originalItem: CompletionItem, context: ServiceContext): CompletionItem;

package/dist/plugins/typescript/completions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhancedResolveCompletionItem = exports.enhancedProvideCompletionItems = void 0;
+const language_service_1 = require("@volar/language-service");
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const index_js_1 = require("../../core/index.js");
+const utils_js_1 = require("../../utils.js");
+const defaultHTMLProvider = (0, vscode_html_languageservice_1.getDefaultHTMLDataProvider)();
+const defaultTags = new Set(defaultHTMLProvider.provideTags().map((tag) => tag.name));
+const defaultAttributes = new Set(defaultHTMLProvider.provideTags().flatMap((tag) => tag.attributes.map((attr) => attr.name)));
+function enhancedProvideCompletionItems(completions) {
+    completions.items = completions.items.filter(isValidCompletion).map((completion) => {
+        const source = completion?.data?.originalItem?.source;
+        if (source) {
+            // For components import, use the file kind and sort them higher, as they're often what the user want over something else
+            if (['.astro', '.svelte', '.vue'].some((ext) => source.endsWith(ext))) {
+                completion.kind = language_service_1.CompletionItemKind.File;
+                completion.detail = completion.detail + '\n\n' + source;
+                completion.sortText = '\0';
+                completion.data.isComponent = true;
+            }
+        }
+        return completion;
+    });
+    return completions;
+}
+exports.enhancedProvideCompletionItems = enhancedProvideCompletionItems;
+function enhancedResolveCompletionItem(resolvedCompletion, originalItem, context) {
+    // Make sure we keep our icons even when the completion is resolved
+    if (resolvedCompletion.data.isComponent) {
+        resolvedCompletion.detail = getDetailForFileCompletion(resolvedCompletion.detail ?? '', resolvedCompletion.data.originalItem.source);
+    }
+    // Properly handle completions with actions to make sure their edits end up in the frontmatter when needed
+    const [_, source] = context.documents.getVirtualFileByUri(originalItem.data.uri);
+    const file = source?.root;
+    if (!(file instanceof index_js_1.AstroFile) || !context.host)
+        return resolvedCompletion;
+    const newLine = context.host.getNewLine ? context.host.getNewLine() : '\n';
+    resolvedCompletion.additionalTextEdits = resolvedCompletion.additionalTextEdits?.map((edit) => {
+        if (file.astroMeta.frontmatter.status === 'doesnt-exist') {
+            return (0, utils_js_1.getNewFrontmatterEdit)(edit, newLine);
+        }
+        if (file.astroMeta.frontmatter.status === 'open') {
+            return (0, utils_js_1.getOpenFrontmatterEdit)(edit, newLine);
+        }
+        edit.range = (0, utils_js_1.ensureRangeIsInFrontmatter)(edit.range, file.astroMeta.frontmatter);
+        return edit;
+    });
+    return resolvedCompletion;
+}
+exports.enhancedResolveCompletionItem = enhancedResolveCompletionItem;
+function getDetailForFileCompletion(detail, source) {
+    return `${detail}\n\n${source}`;
+}
+// When Svelte components are imported, we have to reference the svelte2tsx's types to properly type the component
+// An unfortunate downside of this is that it pollutes completions, so let's filter those internal types manually
+const svelte2tsxTypes = new Set([
+    'Svelte2TsxComponent',
+    'Svelte2TsxComponentConstructorParameters',
+    'SvelteComponentConstructor',
+    'SvelteActionReturnType',
+    'SvelteTransitionConfig',
+    'SvelteTransitionReturnType',
+    'SvelteAnimationReturnType',
+    'SvelteWithOptionalProps',
+    'SvelteAllProps',
+    'SveltePropsAnyFallback',
+    'SvelteSlotsAnyFallback',
+    'SvelteRestProps',
+    'SvelteSlots',
+    'SvelteStore',
+]);
+function isValidCompletion(completion) {
+    const isSvelte2tsxCompletion = completion.label.startsWith('__sveltets_') || svelte2tsxTypes.has(completion.label);
+    if (defaultTags.has(completion.label) || defaultAttributes.has(completion.label))
+        return false;
+    if (isSvelte2tsxCompletion)
+        return false;
+    return true;
+}
+//# sourceMappingURL=completions.js.map

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

@@ -0,0 +1,12 @@
+import type { Diagnostic } from '@volar/language-service';
+export declare enum DiagnosticCodes {
+    IS_NOT_A_MODULE = 2306,
+    CANNOT_FIND_MODULE = 2307,
+    DUPLICATED_JSX_ATTRIBUTES = 17001,
+    CANT_RETURN_OUTSIDE_FUNC = 1108,
+    ISOLATED_MODULE_COMPILE_ERR = 1208,
+    TYPE_NOT_ASSIGNABLE = 2322,
+    JSX_NO_CLOSING_TAG = 17008,
+    JSX_ELEMENT_NO_CALL = 2604
+}
+export declare function enhancedProvideSemanticDiagnostics(originalDiagnostics: Diagnostic[], documentLineCount: number): Diagnostic[];

package/dist/plugins/typescript/diagnostics.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhancedProvideSemanticDiagnostics = exports.DiagnosticCodes = void 0;
+// List of codes:
+// https://github.com/Microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
+var DiagnosticCodes;
+(function (DiagnosticCodes) {
+    DiagnosticCodes[DiagnosticCodes["IS_NOT_A_MODULE"] = 2306] = "IS_NOT_A_MODULE";
+    DiagnosticCodes[DiagnosticCodes["CANNOT_FIND_MODULE"] = 2307] = "CANNOT_FIND_MODULE";
+    DiagnosticCodes[DiagnosticCodes["DUPLICATED_JSX_ATTRIBUTES"] = 17001] = "DUPLICATED_JSX_ATTRIBUTES";
+    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["JSX_ELEMENT_NO_CALL"] = 2604] = "JSX_ELEMENT_NO_CALL";
+})(DiagnosticCodes = exports.DiagnosticCodes || (exports.DiagnosticCodes = {}));
+function enhancedProvideSemanticDiagnostics(originalDiagnostics, documentLineCount) {
+    const diagnostics = originalDiagnostics
+        .filter((diagnostic) => diagnostic.range.start.line <= documentLineCount &&
+        isNoCantReturnOutsideFunction(diagnostic) &&
+        isNoIsolatedModuleError(diagnostic) &&
+        isNoJsxCannotHaveMultipleAttrsError(diagnostic))
+        .map(enhanceIfNecessary);
+    return diagnostics;
+}
+exports.enhancedProvideSemanticDiagnostics = enhancedProvideSemanticDiagnostics;
+/**
+ * Some diagnostics have JSX-specific nomenclature or unclear description. Enhance them for more clarity.
+ */
+function enhanceIfNecessary(diagnostic) {
+    // When the language integrations are not installed, the content of the imported snapshot is empty
+    // As such, it triggers the "is not a module error", which we can enhance with a more helpful message for the related framework
+    if (diagnostic.code === DiagnosticCodes.IS_NOT_A_MODULE) {
+        if (diagnostic.message.includes('.svelte')) {
+            diagnostic.message +=
+                '\n\nIs the `@astrojs/svelte` package installed? You can add it to your project by running the following command: `astro add svelte`. If already installed, restarting the language server might be necessary in order for the change to take effect.';
+        }
+        if (diagnostic.message.includes('.vue')) {
+            diagnostic.message +=
+                '\n\nIs the `@astrojs/vue` package installed? You can add it to your project by running the following command: `astro add vue`. If already installed, restarting the language server might be necessary in order for the change to take effect.';
+        }
+        return diagnostic;
+    }
+    if (diagnostic.code === DiagnosticCodes.CANNOT_FIND_MODULE &&
+        diagnostic.message.includes('astro:content')) {
+        diagnostic.message +=
+            "\n\nIf you're using content collections, make sure to run `astro dev`, `astro build` or `astro sync` to first generate the types so you can import from them. If you already ran one of those commands, restarting the language server might be necessary in order for the change to take effect.";
+        return diagnostic;
+    }
+    // JSX element has no closing tag. JSX -> HTML
+    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 === DiagnosticCodes.TYPE_NOT_ASSIGNABLE) {
+        if (diagnostic.message.includes("Property 'client:") &&
+            diagnostic.message.includes("to type 'HTMLAttributes")) {
+            return {
+                ...diagnostic,
+                message: diagnostic.message + '\n\nClient directives are only available on framework components.',
+            };
+        }
+    }
+    return diagnostic;
+}
+/**
+ * Astro allows multiple attributes to have the same name
+ */
+function isNoJsxCannotHaveMultipleAttrsError(diagnostic) {
+    return diagnostic.code !== DiagnosticCodes.DUPLICATED_JSX_ATTRIBUTES;
+}
+/**
+ * Ignore "Can't return outside of function body"
+ * Since the frontmatter is at the top level, users trying to return a Response for SSR mode run into this
+ * TODO: Update the TSX shape so this is not an issue anymore
+ */
+function isNoCantReturnOutsideFunction(diagnostic) {
+    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 !== DiagnosticCodes.ISOLATED_MODULE_COMPILE_ERR;
+}
+//# sourceMappingURL=diagnostics.js.map

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

@@ -0,0 +1,3 @@
+import type { Service } from '@volar/language-service';
+declare const _default: () => Service;
+export default _default;

package/dist/plugins/typescript/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const volar_service_typescript_1 = __importDefault(require("volar-service-typescript"));
+const index_js_1 = require("../../core/index.js");
+const codeActions_js_1 = require("./codeActions.js");
+const completions_js_1 = require("./completions.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+exports.default = () => (context, modules) => {
+    const typeScriptPlugin = (0, volar_service_typescript_1.default)()(context, modules);
+    if (!context) {
+        return { triggerCharacters: typeScriptPlugin.triggerCharacters };
+    }
+    return {
+        ...typeScriptPlugin,
+        async provideCompletionItems(document, position, completionContext, token) {
+            const originalCompletions = await typeScriptPlugin.provideCompletionItems(document, position, completionContext, token);
+            if (!originalCompletions)
+                return null;
+            return (0, completions_js_1.enhancedProvideCompletionItems)(originalCompletions);
+        },
+        async resolveCompletionItem(item, token) {
+            const resolvedCompletionItem = await typeScriptPlugin.resolveCompletionItem(item, token);
+            if (!resolvedCompletionItem)
+                return item;
+            return (0, completions_js_1.enhancedResolveCompletionItem)(resolvedCompletionItem, item, context);
+        },
+        async provideCodeActions(document, range, codeActionContext, token) {
+            const codeActions = await typeScriptPlugin.provideCodeActions(document, range, codeActionContext, token);
+            if (!codeActions)
+                return null;
+            const [_, source] = context.documents.getVirtualFileByUri(document.uri);
+            const file = source?.root;
+            if (!(file instanceof index_js_1.AstroFile) || !context.host)
+                return codeActions;
+            const newLine = context.host.getNewLine ? context.host.getNewLine() : '\n';
+            return (0, codeActions_js_1.enhancedProvideCodeActions)(codeActions, file, context.documents.getDocumentByFileName(file.snapshot, file.sourceFileName), newLine);
+        },
+        async provideSemanticDiagnostics(document, token) {
+            const [_, source] = context.documents.getVirtualFileByUri(document.uri);
+            const file = source?.root;
+            if (!(file instanceof index_js_1.AstroFile))
+                return null;
+            // If we have compiler errors, our TSX isn't valid so don't bother showing TS errors
+            if (file.hasCompilationErrors)
+                return null;
+            const diagnostics = await typeScriptPlugin.provideSemanticDiagnostics(document, token);
+            if (!diagnostics)
+                return null;
+            const astroDocument = context.documents.getDocumentByFileName(file.snapshot, file.sourceFileName);
+            return (0, diagnostics_js_1.enhancedProvideSemanticDiagnostics)(diagnostics, astroDocument.lineCount);
+        },
+    };
+};
+//# sourceMappingURL=index.js.map