@astrojs/language-server 2.1.3 → 2.2.0

package/dist/check.d.ts

@@ -1,24 +1,39 @@
 import * as kit from '@volar/kit';
-export { DiagnosticSeverity, type Diagnostic } from '@volar/language-server';
+import { Diagnostic, DiagnosticSeverity } from '@volar/language-server';
+export { DiagnosticSeverity, Diagnostic };
 export interface CheckResult {
-    errors: kit.Diagnostic[];
-    fileUrl: URL;
-    fileContent: string;
+    status: 'completed' | 'cancelled' | undefined;
+    fileChecked: number;
+    errors: number;
+    warnings: number;
+    hints: number;
+    fileResult: {
+        errors: kit.Diagnostic[];
+        fileUrl: URL;
+        fileContent: string;
+    }[];
 }
 export declare class AstroCheck {
     private readonly workspacePath;
     private readonly typescriptPath;
+    private readonly tsconfigPath;
     private ts;
-    private project;
+    project: ReturnType<typeof kit.createProject>;
     private linter;
-    constructor(workspacePath: string, typescriptPath: string | undefined);
+    constructor(workspacePath: string, typescriptPath: string | undefined, tsconfigPath: string | undefined);
     /**
      * Lint a list of files or the entire project and optionally log the errors found
      * @param fileNames List of files to lint, if undefined, all files included in the project will be linted
      * @param logErrors Whether to log errors by itself. This is disabled by default.
      * @return {CheckResult} The result of the lint, including a list of errors, the file's content and its file path.
      */
-    lint(fileNames?: string[] | undefined, logErrors?: boolean): Promise<CheckResult[]>;
+    lint({ fileNames, cancel, logErrors, }: {
+        fileNames?: string[] | undefined;
+        cancel?: () => boolean;
+        logErrors?: {
+            level: 'error' | 'warning' | 'hint';
+        } | undefined;
+    }): Promise<CheckResult>;
     private initialize;
     private getTsconfig;
 }

package/dist/check.js

@@ -26,8 +26,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstroCheck = exports.DiagnosticSeverity = void 0;
+exports.AstroCheck = exports.Diagnostic = exports.DiagnosticSeverity = void 0;
 const kit = __importStar(require("@volar/kit"));
+const language_server_1 = require("@volar/language-server");
+Object.defineProperty(exports, "Diagnostic", { enumerable: true, get: function () { return language_server_1.Diagnostic; } });
+Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return language_server_1.DiagnosticSeverity; } });
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const node_url_1 = require("node:url");
 const index_js_1 = require("./core/index.js");
@@ -36,13 +39,11 @@ const vue_js_1 = require("./core/vue.js");
 const astro_js_1 = __importDefault(require("./plugins/astro.js"));
 const index_js_2 = __importDefault(require("./plugins/typescript/index.js"));
 const utils_js_1 = require("./utils.js");
-// Export those for downstream consumers
-var language_server_1 = require("@volar/language-server");
-Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return language_server_1.DiagnosticSeverity; } });
 class AstroCheck {
-    constructor(workspacePath, typescriptPath) {
+    constructor(workspacePath, typescriptPath, tsconfigPath) {
         this.workspacePath = workspacePath;
         this.typescriptPath = typescriptPath;
+        this.tsconfigPath = tsconfigPath;
         this.initialize();
     }
     /**
@@ -51,27 +52,51 @@ class AstroCheck {
      * @param logErrors Whether to log errors by itself. This is disabled by default.
      * @return {CheckResult} The result of the lint, including a list of errors, the file's content and its file path.
      */
-    async lint(fileNames = undefined, logErrors = false) {
-        const files = fileNames !== undefined
-            ? fileNames
-            : this.project.languageHost.getScriptFileNames().filter((file) => file.endsWith('.astro'));
-        const errors = [];
+    async lint({ fileNames = undefined, cancel = () => false, logErrors = undefined, }) {
+        const files = fileNames !== undefined ? fileNames : this.project.languageHost.getScriptFileNames();
+        const result = {
+            status: undefined,
+            fileChecked: 0,
+            errors: 0,
+            warnings: 0,
+            hints: 0,
+            fileResult: [],
+        };
         for (const file of files) {
-            const fileErrors = await this.linter.check(file);
+            if (cancel()) {
+                result.status = 'cancelled';
+                return result;
+            }
+            const fileDiagnostics = (await this.linter.check(file)).filter((diag) => {
+                const severity = diag.severity ?? language_server_1.DiagnosticSeverity.Error;
+                switch (logErrors?.level ?? 'error') {
+                    case 'error':
+                        return true;
+                    case 'warning':
+                        return severity <= language_server_1.DiagnosticSeverity.Warning;
+                    case 'hint':
+                        return severity <= language_server_1.DiagnosticSeverity.Hint;
+                }
+            });
             if (logErrors) {
-                this.linter.logErrors(file, fileErrors);
+                this.linter.logErrors(file, fileDiagnostics);
             }
-            if (fileErrors.length > 0) {
+            if (fileDiagnostics.length > 0) {
                 const fileSnapshot = this.project.languageHost.getScriptSnapshot(file);
                 const fileContent = fileSnapshot?.getText(0, fileSnapshot.getLength());
-                errors.push({
-                    errors: fileErrors,
+                result.fileResult.push({
+                    errors: fileDiagnostics,
                     fileContent: fileContent ?? '',
                     fileUrl: (0, node_url_1.pathToFileURL)(file),
                 });
+                result.errors += fileDiagnostics.filter((diag) => diag.severity === language_server_1.DiagnosticSeverity.Error).length;
+                result.warnings += fileDiagnostics.filter((diag) => diag.severity === language_server_1.DiagnosticSeverity.Warning).length;
+                result.hints += fileDiagnostics.filter((diag) => diag.severity === language_server_1.DiagnosticSeverity.Hint).length;
             }
+            result.fileChecked += 1;
         }
-        return errors;
+        result.status = 'completed';
+        return result;
     }
     initialize() {
         this.ts = this.typescriptPath ? require(this.typescriptPath) : require('typescript');
@@ -106,8 +131,9 @@ class AstroCheck {
         this.linter = kit.createLinter(config, this.project.languageHost);
     }
     getTsconfig() {
-        const tsconfig = this.ts.findConfigFile(this.workspacePath, this.ts.sys.fileExists) ||
-            this.ts.findConfigFile(this.workspacePath, this.ts.sys.fileExists, 'jsconfig.json');
+        const searchPath = this.tsconfigPath ?? this.workspacePath;
+        const tsconfig = this.ts.findConfigFile(searchPath, this.ts.sys.fileExists) ||
+            this.ts.findConfigFile(searchPath, this.ts.sys.fileExists, 'jsconfig.json');
         return tsconfig;
     }
 }

package/dist/importPackage.d.ts

@@ -2,7 +2,10 @@ import type * as svelte from '@astrojs/svelte/dist/editor.cjs';
 import type * as vue from '@astrojs/vue/dist/editor.cjs';
 import type * as prettier from 'prettier';
 export declare function setIsTrusted(_isTrusted: boolean): void;
-export declare function getPackagePath(packageName: string, fromPath: string[]): string | undefined;
+/**
+ * Get the path of a package's directory from the paths in `fromPath`, if `root` is set to false, it will return the path of the package's entry point
+ */
+export declare function getPackagePath(packageName: string, fromPath: string[], root?: boolean): string | undefined;
 export declare function importSvelteIntegration(fromPath: string): typeof svelte | undefined;
 export declare function importVueIntegration(fromPath: string): typeof vue | undefined;
 export declare function importPrettier(fromPath: string): typeof prettier | undefined;

package/dist/importPackage.js

@@ -7,13 +7,18 @@ function setIsTrusted(_isTrusted) {
     isTrusted = _isTrusted;
 }
 exports.setIsTrusted = setIsTrusted;
-function getPackagePath(packageName, fromPath) {
+/**
+ * Get the path of a package's directory from the paths in `fromPath`, if `root` is set to false, it will return the path of the package's entry point
+ */
+function getPackagePath(packageName, fromPath, root = true) {
     const paths = [];
     if (isTrusted) {
         paths.unshift(...fromPath);
     }
     try {
-        return (0, node_path_1.dirname)(require.resolve(packageName + '/package.json', { paths }));
+        return root
+            ? (0, node_path_1.dirname)(require.resolve(packageName + '/package.json', { paths }))
+            : require.resolve(packageName, { paths });
     }
     catch (e) {
         return undefined;
@@ -51,7 +56,7 @@ function importPrettier(fromPath) {
 }
 exports.importPrettier = importPrettier;
 function getPrettierPluginPath(fromPath) {
-    const prettierPluginPath = getPackagePath('prettier-plugin-astro', [fromPath, __dirname]);
+    const prettierPluginPath = getPackagePath('prettier-plugin-astro', [fromPath, __dirname], false);
     if (!prettierPluginPath) {
         return undefined;
     }

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticSeverity = exports.AstroCheck = void 0;
+exports.DiagnosticSeverity = exports.Diagnostic = exports.AstroCheck = void 0;
 var check_js_1 = require("./check.js");
 Object.defineProperty(exports, "AstroCheck", { enumerable: true, get: function () { return check_js_1.AstroCheck; } });
+Object.defineProperty(exports, "Diagnostic", { enumerable: true, get: function () { return check_js_1.Diagnostic; } });
 Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return check_js_1.DiagnosticSeverity; } });
 //# sourceMappingURL=index.js.map

package/dist/languageServerPlugin.js

@@ -68,8 +68,7 @@ const plugin = (initOptions, modules) => ({
                     languages: ['astro'],
                     ignoreIdeOptions: true,
                     resolveConfigOptions: {
-                        // Prettier's cache is a bit cumbersome, because you need to reload the config yourself on change
-                        // TODO: Upstream a fix for this
+                        // This seems to be broken since Prettier 3, and it'll always use its cumbersome cache. Hopefully it works one day.
                         useCache: false,
                     },
                     additionalOptions: async (resolvedConfig) => {
@@ -77,7 +76,8 @@ const plugin = (initOptions, modules) => ({
                             if (!prettier || !prettierPluginPath) {
                                 return [];
                             }
-                            const hasPluginLoadedAlready = (await prettier.getSupportInfo()).languages.some((l) => l.name === 'astro');
+                            const hasPluginLoadedAlready = (await prettier.getSupportInfo()).languages.some((l) => l.name === 'astro') ||
+                                resolvedConfig.plugins?.includes('prettier-plugin-astro'); // getSupportInfo doesn't seems to work very well in Prettier 3 for plugins
                             return hasPluginLoadedAlready ? [] : [prettierPluginPath];
                         }
                         const plugins = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "author": "withastro",
   "license": "MIT",
   "repository": {