@tsslint/cli 1.4.0 → 1.4.2

package/index.js

@@ -8,6 +8,7 @@ const worker = require("./lib/worker.js");
 const glob = require("glob");
 const fs = require("fs");
 const os = require("os");
+const languagePlugins = require("./lib/languagePlugins.js");
 const _reset = '\x1b[0m';
 const purple = (s) => '\x1b[35m' + s + _reset;
 const darkGray = (s) => '\x1b[90m' + s + _reset;
@@ -24,39 +25,45 @@ if (process.argv.includes('--threads')) {
     }
     threads = Math.min(os.availableParallelism(), Number(threadsArg));
 }
-(async () => {
-    class Project {
-        constructor(tsconfigOption) {
-            this.workers = [];
-            this.fileNames = [];
-            this.options = {};
-            this.currentFileIndex = 0;
-            this.cache = {};
-            try {
-                this.tsconfig = require.resolve(tsconfigOption, { paths: [process.cwd()] });
-            }
-            catch {
-                console.error(lightRed(`No such file: ${tsconfigOption}`));
-                process.exit(1);
-            }
-            this.configFile = ts.findConfigFile(path.dirname(this.tsconfig), ts.sys.fileExists, 'tsslint.config.ts');
-            if (!this.configFile) {
-                log(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray('(No tsslint.config.ts found)')}`);
-                return;
-            }
-            const commonLine = parseCommonLine(this.tsconfig);
-            this.fileNames = commonLine.fileNames;
-            this.options = commonLine.options;
-            if (!this.fileNames.length) {
-                log(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray('(No included files)')}`);
-                return;
-            }
-            log(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray(`(${this.fileNames.length})`)}`);
-            if (!process.argv.includes('--force')) {
-                this.cache = cache.loadCache(this.tsconfig, this.configFile, ts.sys.createHash);
-            }
+class Project {
+    constructor(tsconfigOption, languages) {
+        this.languages = languages;
+        this.workers = [];
+        this.fileNames = [];
+        this.options = {};
+        this.currentFileIndex = 0;
+        this.cache = {};
+        try {
+            this.tsconfig = require.resolve(tsconfigOption, { paths: [process.cwd()] });
         }
+        catch {
+            console.error(lightRed(`No such file: ${tsconfigOption}`));
+            process.exit(1);
+        }
+    }
+    async init(
+    // @ts-expect-error
+    clack) {
+        this.configFile = ts.findConfigFile(path.dirname(this.tsconfig), ts.sys.fileExists, 'tsslint.config.ts');
+        if (!this.configFile) {
+            clack.log.error(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray('(No tsslint.config.ts found)')}`);
+            return this;
+        }
+        const commonLine = await parseCommonLine(this.tsconfig, this.languages);
+        this.fileNames = commonLine.fileNames;
+        this.options = commonLine.options;
+        if (!this.fileNames.length) {
+            clack.log.warn(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray('(No included files)')}`);
+            return this;
+        }
+        clack.log.info(`${purple('[project]')} ${path.relative(process.cwd(), this.tsconfig)} ${darkGray(`(${this.fileNames.length})`)}`);
+        if (!process.argv.includes('--force')) {
+            this.cache = cache.loadCache(this.tsconfig, this.configFile, ts.sys.createHash);
+        }
+        return this;
     }
+}
+(async () => {
     const builtConfigs = new Map();
     const clack = await import('@clack/prompts');
     const processFiles = new Set();
@@ -71,45 +78,164 @@ if (process.argv.includes('--threads')) {
     let errors = 0;
     let warnings = 0;
     let cached = 0;
-    spinner.start();
-    if (process.argv.includes('--project')) {
-        const projectIndex = process.argv.indexOf('--project');
-        let tsconfig = process.argv[projectIndex + 1];
-        if (!tsconfig || tsconfig.startsWith('-')) {
-            console.error(lightRed(`Missing argument for --project.`));
+    const tsconfigAndLanguages = new Map();
+    if (!process.argv.includes('--project')
+        && !process.argv.includes('--projects')
+        && !process.argv.includes('--vue-project')
+        && !process.argv.includes('--vue-projects')
+        && !process.argv.includes('--mdx-project')
+        && !process.argv.includes('--mdx-projects')
+        && !process.argv.includes('--astro-project')
+        && !process.argv.includes('--astro-projects')) {
+        const languages = await clack.multiselect({
+            required: false,
+            message: 'Select frameworks (optional)',
+            options: [{
+                    label: 'Vue',
+                    value: 'vue',
+                }, {
+                    label: 'MDX',
+                    value: 'mdx',
+                }, {
+                    label: 'Astro',
+                    value: 'astro',
+                }],
+        });
+        if (clack.isCancel(languages)) {
             process.exit(1);
         }
-        if (!tsconfig.startsWith('.')) {
-            tsconfig = `./${tsconfig}`;
+        const tsconfigOptions = glob.sync('**/{tsconfig.json,jsconfig.json}');
+        let options = await Promise.all(tsconfigOptions.map(async (tsconfigOption) => {
+            const tsconfig = require.resolve(tsconfigOption.startsWith('.') ? tsconfigOption : `./${tsconfigOption}`, { paths: [process.cwd()] });
+            try {
+                const commonLine = await parseCommonLine(tsconfig, languages);
+                return {
+                    label: path.relative(process.cwd(), tsconfig) + ` (${commonLine.fileNames.length})`,
+                    value: tsconfigOption,
+                };
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        options = options.filter(option => !!option);
+        if (!options.length) {
+            clack.log.error(lightRed('No projects found.'));
+            process.exit(1);
         }
-        projects.push(new Project(tsconfig));
-    }
-    else if (process.argv.includes('--projects')) {
-        const projectsIndex = process.argv.indexOf('--projects');
-        let foundArg = false;
-        for (let i = projectsIndex + 1; i < process.argv.length; i++) {
-            if (process.argv[i].startsWith('-')) {
-                break;
+        const selectedTsconfigs = await clack.multiselect({
+            message: 'Select one or multiple projects',
+            // @ts-expect-error
+            options,
+        });
+        if (clack.isCancel(selectedTsconfigs)) {
+            process.exit(1);
+        }
+        let command = 'tsslint';
+        if (!languages.length) {
+            if (selectedTsconfigs.length === 1) {
+                command += ' --project ' + selectedTsconfigs[0];
             }
-            foundArg = true;
-            const searchGlob = process.argv[i];
-            const tsconfigs = glob.sync(searchGlob);
-            for (let tsconfig of tsconfigs) {
-                if (!tsconfig.startsWith('.')) {
-                    tsconfig = `./${tsconfig}`;
+            else {
+                command += ' --projects ' + selectedTsconfigs.join(' ');
+            }
+        }
+        else {
+            for (const language of languages) {
+                if (selectedTsconfigs.length === 1) {
+                    command += ` --${language}-project ` + selectedTsconfigs[0];
+                }
+                else {
+                    command += ` --${language}-projects ` + selectedTsconfigs.join(' ');
                 }
-                projects.push(new Project(tsconfig));
             }
         }
-        if (!foundArg) {
-            console.error(lightRed(`Missing argument for --projects.`));
-            process.exit(1);
+        clack.log.info(`Running: ${purple(command)}`);
+        for (let tsconfig of selectedTsconfigs) {
+            if (!tsconfig.startsWith('.')) {
+                tsconfig = `./${tsconfig}`;
+            }
+            tsconfigAndLanguages.set(tsconfig, languages);
         }
     }
     else {
-        const tsconfig = await askTSConfig();
-        projects.push(new Project(tsconfig));
+        const options = [
+            {
+                projectFlag: '--project',
+                projectsFlag: '--projects',
+                language: undefined,
+            },
+            {
+                projectFlag: '--vue-project',
+                projectsFlag: '--vue-projects',
+                language: 'vue',
+            },
+            {
+                projectFlag: '--mdx-project',
+                projectsFlag: '--mdx-projects',
+                language: 'mdx',
+            },
+            {
+                projectFlag: '--astro-project',
+                projectsFlag: '--astro-projects',
+                language: 'astro',
+            },
+        ];
+        for (const { projectFlag, projectsFlag, language } of options) {
+            if (process.argv.includes(projectFlag)) {
+                const projectIndex = process.argv.indexOf(projectFlag);
+                let tsconfig = process.argv[projectIndex + 1];
+                if (!tsconfig || tsconfig.startsWith('-')) {
+                    clack.log.error(lightRed(`Missing argument for ${projectFlag}.`));
+                    process.exit(1);
+                }
+                if (!tsconfig.startsWith('.')) {
+                    tsconfig = `./${tsconfig}`;
+                }
+                if (!tsconfigAndLanguages.has(tsconfig)) {
+                    tsconfigAndLanguages.set(tsconfig, []);
+                }
+                if (language) {
+                    tsconfigAndLanguages.get(tsconfig).push(language);
+                }
+            }
+            if (process.argv.includes(projectsFlag)) {
+                const projectsIndex = process.argv.indexOf(projectsFlag);
+                let foundArg = false;
+                for (let i = projectsIndex + 1; i < process.argv.length; i++) {
+                    if (process.argv[i].startsWith('-')) {
+                        break;
+                    }
+                    foundArg = true;
+                    const searchGlob = process.argv[i];
+                    const tsconfigs = glob.sync(searchGlob);
+                    if (!tsconfigs.length) {
+                        clack.log.error(lightRed(`No projects found for ${projectsFlag} ${searchGlob}.`));
+                        process.exit(1);
+                    }
+                    for (let tsconfig of tsconfigs) {
+                        if (!tsconfig.startsWith('.')) {
+                            tsconfig = `./${tsconfig}`;
+                        }
+                        if (!tsconfigAndLanguages.has(tsconfig)) {
+                            tsconfigAndLanguages.set(tsconfig, []);
+                        }
+                        if (language) {
+                            tsconfigAndLanguages.get(tsconfig).push(language);
+                        }
+                    }
+                }
+                if (!foundArg) {
+                    clack.log.error(lightRed(`Missing argument for ${projectsFlag}.`));
+                    process.exit(1);
+                }
+            }
+        }
     }
+    for (const [tsconfig, languages] of tsconfigAndLanguages) {
+        projects.push(await new Project(tsconfig, languages).init(clack));
+    }
+    spinner.start();
     projects = projects.filter(project => !!project.configFile);
     projects = projects.filter(project => !!project.fileNames.length);
     for (const project of projects) {
@@ -168,7 +294,7 @@ if (process.argv.includes('--threads')) {
             })[0];
         }
         project.workers.push(linterWorker);
-        const setupSuccess = await linterWorker.setup(project.tsconfig, project.configFile, project.builtConfig, project.fileNames, project.options);
+        const setupSuccess = await linterWorker.setup(project.tsconfig, project.languages, project.configFile, project.builtConfig, project.fileNames, project.options);
         if (!setupSuccess) {
             projects = projects.filter(p => p !== project);
             startWorker(linterWorker);
@@ -207,7 +333,7 @@ if (process.argv.includes('--threads')) {
                 diagnostics = await linterWorker.lint(fileName, fileCache);
             }
             if (diagnostics.length) {
-                hasFix ||= await linterWorker.hasCodeFixes(fileName);
+                hasFix ||= Object.values(fileCache[1]).some(fixes => fixes > 0) || await linterWorker.hasCodeFixes(fileName);
                 for (const diagnostic of diagnostics) {
                     if (diagnostic.category === ts.DiagnosticCategory.Suggestion) {
                         continue;
@@ -249,31 +375,6 @@ if (process.argv.includes('--threads')) {
         }
         return await builtConfigs.get(configFile);
     }
-    async function askTSConfig() {
-        const presetConfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists);
-        let shortTsconfig = presetConfig ? path.relative(process.cwd(), presetConfig) : undefined;
-        if (!shortTsconfig?.startsWith('.')) {
-            shortTsconfig = `./${shortTsconfig}`;
-        }
-        return await clack.text({
-            message: 'Select the project. (Use --project or --projects to skip this prompt.)',
-            placeholder: shortTsconfig ? `${shortTsconfig} (${parseCommonLine(presetConfig).fileNames.length} files)` : 'No tsconfig.json/jsconfig.json found, please enter the path to the tsconfig.json/jsconfig.json file.',
-            defaultValue: shortTsconfig,
-            validate(value) {
-                value ||= shortTsconfig;
-                try {
-                    require.resolve(value, { paths: [process.cwd()] });
-                }
-                catch {
-                    return 'No such file.';
-                }
-            },
-        });
-    }
-    function parseCommonLine(tsconfig) {
-        const jsonConfigFile = ts.readJsonConfigFile(tsconfig, ts.sys.readFile);
-        return ts.parseJsonSourceFileConfigFileContent(jsonConfigFile, ts.sys, path.dirname(tsconfig), {}, tsconfig);
-    }
     function addProcessFile(fileName) {
         processFiles.add(fileName);
         updateSpinner();
@@ -297,4 +398,10 @@ if (process.argv.includes('--threads')) {
         spinner.start();
     }
 })();
+async function parseCommonLine(tsconfig, languages) {
+    const jsonConfigFile = ts.readJsonConfigFile(tsconfig, ts.sys.readFile);
+    const plugins = await languagePlugins.load(tsconfig, languages);
+    const extraFileExtensions = plugins.flatMap(plugin => plugin.typescript?.extraFileExtensions ?? []).flat();
+    return ts.parseJsonSourceFileConfigFileContent(jsonConfigFile, ts.sys, path.dirname(tsconfig), {}, tsconfig, undefined, extraFileExtensions);
+}
 //# sourceMappingURL=index.js.map

package/lib/languagePlugins.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from '@volar/language-core';
+export declare function load(tsconfig: string, languages: string[]): Promise<LanguagePlugin<string, import("@volar/language-core").VirtualCode>[]>;

package/lib/languagePlugins.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+const path = require("path");
+const ts = require("typescript");
+const cache = new Map();
+async function load(tsconfig, languages) {
+    if (cache.has(tsconfig)) {
+        return cache.get(tsconfig);
+    }
+    const plugins = [];
+    if (languages.includes('vue')) {
+        let vue;
+        let vueTscPkgPath;
+        if (findPackageJson('@vue/language-core')) {
+            vue = require('@vue/language-core');
+        }
+        else if (vueTscPkgPath = findPackageJson('vue-tsc')) {
+            const vueTscPath = path.dirname(vueTscPkgPath);
+            vue = require(require.resolve('@vue/language-core', { paths: [vueTscPath] }));
+        }
+        else {
+            const pkg = ts.findConfigFile(path.dirname(tsconfig), ts.sys.fileExists, 'package.json');
+            if (pkg) {
+                throw new Error('Please install @vue/language-core or vue-tsc to ' + path.relative(process.cwd(), pkg));
+            }
+            else {
+                throw new Error('Please install @vue/language-core or vue-tsc for ' + path.relative(process.cwd(), tsconfig));
+            }
+        }
+        const commonLine = vue.createParsedCommandLine(ts, ts.sys, tsconfig);
+        const vueLanguagePlugin = vue.createVueLanguagePlugin(ts, commonLine.options, commonLine.vueOptions, fileName => fileName);
+        plugins.push(vueLanguagePlugin);
+    }
+    if (languages.includes('mdx')) {
+        let mdx;
+        try {
+            mdx = await import(require.resolve('@mdx-js/language-service', { paths: [path.dirname(tsconfig)] }));
+        }
+        catch {
+            const pkg = ts.findConfigFile(path.dirname(tsconfig), ts.sys.fileExists, 'package.json');
+            if (pkg) {
+                throw new Error('Please install @mdx-js/language-service to ' + path.relative(process.cwd(), pkg));
+            }
+            else {
+                throw new Error('Please install @mdx-js/language-service for ' + path.relative(process.cwd(), tsconfig));
+            }
+        }
+        const mdxLanguagePlugin = mdx.createMdxLanguagePlugin();
+        plugins.push(mdxLanguagePlugin);
+    }
+    if (languages.includes('astro')) {
+        let astro;
+        try {
+            astro = require(require.resolve('@astrojs/ts-plugin/dist/language.js', { paths: [path.dirname(tsconfig)] }));
+        }
+        catch (err) {
+            const pkg = ts.findConfigFile(path.dirname(tsconfig), ts.sys.fileExists, 'package.json');
+            if (pkg) {
+                throw new Error('Please install @astrojs/ts-plugin to ' + path.relative(process.cwd(), pkg));
+            }
+            else {
+                throw new Error('Please install @astrojs/ts-plugin for ' + path.relative(process.cwd(), tsconfig));
+            }
+        }
+        const astroLanguagePlugin = astro.getLanguagePlugin();
+        plugins.push(astroLanguagePlugin);
+    }
+    cache.set(tsconfig, plugins);
+    return plugins;
+    function findPackageJson(pkgName) {
+        try {
+            return require.resolve(`${pkgName}/package.json`, { paths: [path.dirname(tsconfig)] });
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=languagePlugins.js.map

package/lib/worker.d.ts

@@ -1,20 +1,20 @@
 import ts = require('typescript');
 import core = require('@tsslint/core');
 export declare function createLocal(): {
-    setup(tsconfig: string, configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
+    setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
     lint(fileName: string, fileCache: core.FileLintCache): ts.DiagnosticWithLocation[];
     lintAndFix(fileName: string, fileCache: core.FileLintCache): ts.DiagnosticWithLocation[];
     hasCodeFixes(fileName: string): boolean;
-    hasRules(fileName: string, minimatchCache: Record<string, boolean>): Promise<boolean>;
+    hasRules(fileName: string, minimatchCache: Record<string, boolean>): boolean;
 };
 export declare function create(): {
-    setup(tsconfig: string, configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
+    setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
     lint(fileName: string, fileCache: core.FileLintCache): Promise<ts.DiagnosticWithLocation[]>;
     lintAndFix(fileName: string, fileCache: core.FileLintCache): Promise<ts.DiagnosticWithLocation[]>;
     hasCodeFixes(fileName: string): Promise<boolean>;
     hasRules(fileName: string, minimatchCache: Record<string, boolean>): Promise<boolean>;
 };
-declare function setup(tsconfig: string, configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
+declare function setup(tsconfig: string, languages: string[], configFile: string, builtConfig: string, _fileNames: string[], _options: ts.CompilerOptions): Promise<boolean>;
 declare function lintAndFix(fileName: string, fileCache: core.FileLintCache): readonly [ts.DiagnosticWithLocation[], core.FileLintCache];
 declare function lint(fileName: string, fileCache: core.FileLintCache): readonly [ts.DiagnosticWithLocation[], core.FileLintCache];
 declare function hasCodeFixes(fileName: string): boolean;

package/lib/worker.js

@@ -7,14 +7,20 @@ const core = require("@tsslint/core");
 const url = require("url");
 const fs = require("fs");
 const worker_threads = require("worker_threads");
+const languagePlugins = require("./languagePlugins.js");
+const language_core_1 = require("@volar/language-core");
+const typescript_1 = require("@volar/typescript");
+const transform_1 = require("@volar/typescript/lib/node/transform");
 let projectVersion = 0;
 let typeRootsVersion = 0;
 let options = {};
 let fileNames = [];
+let language;
 let linter;
+let linterLanguageService;
 const snapshots = new Map();
 const versions = new Map();
-const languageServiceHost = {
+const originalHost = {
     ...ts.sys,
     useCaseSensitiveFileNames() {
         return ts.sys.useCaseSensitiveFileNames;
@@ -40,11 +46,28 @@ const languageServiceHost = {
         }
         return snapshots.get(fileName);
     },
+    getScriptKind(fileName) {
+        const languageId = (0, typescript_1.resolveFileLanguageId)(fileName);
+        switch (languageId) {
+            case 'javascript':
+                return ts.ScriptKind.JS;
+            case 'javascriptreact':
+                return ts.ScriptKind.JSX;
+            case 'typescript':
+                return ts.ScriptKind.TS;
+            case 'typescriptreact':
+                return ts.ScriptKind.TSX;
+            case 'json':
+                return ts.ScriptKind.JSON;
+        }
+        return ts.ScriptKind.Unknown;
+    },
     getDefaultLibFileName(options) {
         return ts.getDefaultLibFilePath(options);
     },
 };
-const languageService = ts.createLanguageService(languageServiceHost);
+const linterHost = { ...originalHost };
+const originalService = ts.createLanguageService(linterHost);
 function createLocal() {
     return {
         setup(...args) {
@@ -59,7 +82,7 @@ function createLocal() {
         hasCodeFixes(...args) {
             return hasCodeFixes(...args);
         },
-        async hasRules(...args) {
+        hasRules(...args) {
             return hasRules(...args)[0];
         },
     };
@@ -110,7 +133,7 @@ const handlers = {
     hasCodeFixes,
     hasRules,
 };
-async function setup(tsconfig, configFile, builtConfig, _fileNames, _options) {
+async function setup(tsconfig, languages, configFile, builtConfig, _fileNames, _options) {
     const clack = await import('@clack/prompts');
     let config;
     try {
@@ -125,21 +148,55 @@ async function setup(tsconfig, configFile, builtConfig, _fileNames, _options) {
         }
         return false;
     }
+    for (let key in linterHost) {
+        if (!(key in originalHost)) {
+            // @ts-ignore
+            delete linterHost[key];
+        }
+        else {
+            // @ts-ignore
+            linterHost[key] = originalHost[key];
+        }
+    }
+    linterLanguageService = originalService;
+    language = undefined;
+    const plugins = await languagePlugins.load(tsconfig, languages);
+    if (plugins.length) {
+        const { getScriptSnapshot } = originalHost;
+        language = (0, language_core_1.createLanguage)([
+            ...plugins,
+            { getLanguageId: fileName => (0, typescript_1.resolveFileLanguageId)(fileName) },
+        ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
+            const snapshot = getScriptSnapshot(fileName);
+            if (snapshot) {
+                language.scripts.set(fileName, snapshot);
+            }
+        });
+        (0, typescript_1.decorateLanguageServiceHost)(ts, language, linterHost);
+        const proxy = (0, typescript_1.createProxyLanguageService)(linterLanguageService);
+        proxy.initialize(language);
+        linterLanguageService = proxy.proxy;
+    }
     projectVersion++;
     typeRootsVersion++;
     fileNames = _fileNames;
-    options = _options;
+    options = plugins.some(plugin => plugin.typescript?.extraFileExtensions.length)
+        ? {
+            ..._options,
+            allowNonTsExtensions: true,
+        }
+        : _options;
     linter = core.createLinter({
         configFile,
-        languageService,
-        languageServiceHost,
+        languageService: linterLanguageService,
+        languageServiceHost: linterHost,
         typescript: ts,
         tsconfig: ts.server.toNormalizedPath(tsconfig),
     }, config, 'cli', clack);
     return true;
 }
 function lintAndFix(fileName, fileCache) {
-    let retry = 3;
+    let retry = 1;
     let shouldRetry = true;
     let newSnapshot;
     let diagnostics;
@@ -151,9 +208,15 @@ function lintAndFix(fileName, fileCache) {
             fileCache[3].length = 0;
         }
         diagnostics = linter.lint(fileName, fileCache);
-        const fixes = linter
+        let fixes = linter
             .getCodeFixes(fileName, 0, Number.MAX_VALUE, diagnostics, fileCache[4])
             .filter(fix => fix.fixId === 'tsslint');
+        if (language) {
+            fixes = fixes.map(fix => {
+                fix.changes = (0, transform_1.transformFileTextChanges)(language, fix.changes, false, language_core_1.isCodeActionsEnabled);
+                return fix;
+            });
+        }
         const textChanges = core.combineCodeFixes(fileName, fixes);
         if (textChanges.length) {
             const oldSnapshot = snapshots.get(fileName);
@@ -174,8 +237,27 @@ function lintAndFix(fileName, fileCache) {
     if (shouldRetry) {
         diagnostics = linter.lint(fileName, fileCache);
     }
-    return [
-        diagnostics.map(diagnostic => ({
+    if (language) {
+        diagnostics = diagnostics
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, originalService.getCurrentProgram(), false))
+            .filter(d => !!d);
+        diagnostics = diagnostics.map(diagnostic => ({
+            ...diagnostic,
+            file: {
+                fileName: diagnostic.file.fileName,
+                text: getFileText(diagnostic.file.fileName),
+            },
+            relatedInformation: diagnostic.relatedInformation?.map(info => ({
+                ...info,
+                file: info.file ? {
+                    fileName: info.file.fileName,
+                    text: getFileText(info.file.fileName),
+                } : undefined,
+            })),
+        }));
+    }
+    else {
+        diagnostics = diagnostics.map(diagnostic => ({
             ...diagnostic,
             file: {
                 fileName: diagnostic.file.fileName,
@@ -188,13 +270,33 @@ function lintAndFix(fileName, fileCache) {
                     text: info.file.text,
                 } : undefined,
             })),
-        })),
-        fileCache,
-    ];
+        }));
+    }
+    return [diagnostics, fileCache];
 }
 function lint(fileName, fileCache) {
-    return [
-        linter.lint(fileName, fileCache).map(diagnostic => ({
+    let diagnostics = linter.lint(fileName, fileCache);
+    if (language) {
+        diagnostics = diagnostics
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, originalService.getCurrentProgram(), false))
+            .filter(d => !!d);
+        diagnostics = diagnostics.map(diagnostic => ({
+            ...diagnostic,
+            file: {
+                fileName: diagnostic.file.fileName,
+                text: getFileText(diagnostic.file.fileName),
+            },
+            relatedInformation: diagnostic.relatedInformation?.map(info => ({
+                ...info,
+                file: info.file ? {
+                    fileName: info.file.fileName,
+                    text: getFileText(info.file.fileName),
+                } : undefined,
+            })),
+        }));
+    }
+    else {
+        diagnostics = diagnostics.map(diagnostic => ({
             ...diagnostic,
             file: {
                 fileName: diagnostic.file.fileName,
@@ -207,9 +309,12 @@ function lint(fileName, fileCache) {
                     text: info.file.text,
                 } : undefined,
             })),
-        })),
-        fileCache,
-    ];
+        }));
+    }
+    return [diagnostics, fileCache];
+}
+function getFileText(fileName) {
+    return originalHost.getScriptSnapshot(fileName).getText(0, Number.MAX_VALUE);
 }
 function hasCodeFixes(fileName) {
     return linter.hasCodeFixes(fileName);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/cli",
-	"version": "1.4.0",
+	"version": "1.4.2",
 	"license": "MIT",
 	"bin": {
 		"tsslint": "./bin/tsslint.js"
@@ -16,12 +16,17 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^0.8.2",
-		"@tsslint/config": "1.4.0",
-		"@tsslint/core": "1.4.0",
+		"@tsslint/config": "1.4.2",
+		"@tsslint/core": "1.4.2",
+		"@volar/language-core": "~2.4.0",
+		"@volar/typescript": "~2.4.0",
 		"glob": "^10.4.1"
 	},
 	"peerDependencies": {
 		"typescript": "*"
 	},
-	"gitHead": "9a3f7ce55f079eaaedfb61af9b72d8ba736f0123"
+	"devDependencies": {
+		"@vue/language-core": "latest"
+	},
+	"gitHead": "4cdc9070fda83e226ab04fa90b99c2b8d748b315"
 }